diff --git "a/codeparrot-valid_1032.txt" "b/codeparrot-valid_1032.txt" new file mode 100644--- /dev/null +++ "b/codeparrot-valid_1032.txt" @@ -0,0 +1,10000 @@ + "returns the placement of the working plane" + if rotated: + m = FreeCAD.Matrix( + self.u.x,self.axis.x,-self.v.x,self.position.x, + self.u.y,self.axis.y,-self.v.y,self.position.y, + self.u.z,self.axis.z,-self.v.z,self.position.z, + 0.0,0.0,0.0,1.0) + else: + m = FreeCAD.Matrix( + self.u.x,self.v.x,self.axis.x,self.position.x, + self.u.y,self.v.y,self.axis.y,self.position.y, + self.u.z,self.v.z,self.axis.z,self.position.z, + 0.0,0.0,0.0,1.0) + return FreeCAD.Placement(m) + + def setFromPlacement(self,pl): + "sets the working plane from a placement (rotaton ONLY)" + rot = FreeCAD.Placement(pl).Rotation + self.u = rot.multVec(FreeCAD.Vector(1,0,0)) + self.v = rot.multVec(FreeCAD.Vector(0,1,0)) + self.axis = rot.multVec(FreeCAD.Vector(0,0,1)) + + def inverse(self): + "inverts the direction of the working plane" + self.u = self.u.negative() + self.axis = self.axis.negative() + + def save(self): + "stores the current plane state" + self.stored = [self.u,self.v,self.axis,self.position,self.weak] + + def restore(self): + "restores a previously saved plane state, if exists" + if self.stored: + self.u = self.stored[0] + self.v = self.stored[1] + self.axis = self.stored[2] + self.position = self.stored[3] + self.weak = self.stored[4] + self.stored = None + + def getLocalCoords(self,point): + "returns the coordinates of a given point on the working plane" + pt = point.sub(self.position) + xv = DraftVecUtils.project(pt,self.u) + x = xv.Length + if xv.getAngle(self.u) > 1: + x = -x + yv = DraftVecUtils.project(pt,self.v) + y = yv.Length + if yv.getAngle(self.v) > 1: + y = -y + zv = DraftVecUtils.project(pt,self.axis) + z = zv.Length + if zv.getAngle(self.axis) > 1: + z = -z + return Vector(x,y,z) + + def getGlobalCoords(self,point): + "returns the global coordinates of the given point, taken relatively to this working plane" + vx = Vector(self.u).multiply(point.x) + vy = Vector(self.v).multiply(point.y) + vz = Vector(self.axis).multiply(point.z) + pt = (vx.add(vy)).add(vz) + return pt.add(self.position) + + def getLocalRot(self,point): + "Same as getLocalCoords, but discards the WP position" + xv = DraftVecUtils.project(point,self.u) + x = xv.Length + if xv.getAngle(self.u) > 1: + x = -x + yv = DraftVecUtils.project(point,self.v) + y = yv.Length + if yv.getAngle(self.v) > 1: + y = -y + zv = DraftVecUtils.project(point,self.axis) + z = zv.Length + if zv.getAngle(self.axis) > 1: + z = -z + return Vector(x,y,z) + + def getGlobalRot(self,point): + "Same as getGlobalCoords, but discards the WP position" + vx = Vector(self.u).multiply(point.x) + vy = Vector(self.v).multiply(point.y) + vz = Vector(self.axis).multiply(point.z) + pt = (vx.add(vy)).add(vz) + return pt + + def getClosestAxis(self,point): + "returns which of the workingplane axes is closest from the given vector" + ax = point.getAngle(self.u) + ay = point.getAngle(self.v) + az = point.getAngle(self.axis) + bx = point.getAngle(self.u.negative()) + by = point.getAngle(self.v.negative()) + bz = point.getAngle(self.axis.negative()) + b = min(ax,ay,az,bx,by,bz) + if b in [ax,bx]: + return "x" + elif b in [ay,by]: + return "y" + elif b in [az,bz]: + return "z" + else: + return None + + def isGlobal(self): + "returns True if the plane axes are equal to the global axes" + if self.u != Vector(1,0,0): + return False + if self.v != Vector(0,1,0): + return False + if self.axis != Vector(0,0,1): + return False + return True + + def isOrtho(self): + "returns True if the plane axes are following the global axes" + if round(self.u.getAngle(Vector(0,1,0)),6) in [0,-1.570796,1.570796,-3.141593,3.141593,-4.712389,4.712389,6.283185]: + if round(self.v.getAngle(Vector(0,1,0)),6) in [0,-1.570796,1.570796,-3.141593,3.141593,-4.712389,4.712389,6.283185]: + if round(self.axis.getAngle(Vector(0,1,0)),6) in [0,-1.570796,1.570796,-3.141593,3.141593,-4.712389,4.712389,6.283185]: + return True + return False + + def getDeviation(self): + "returns the deviation angle between the u axis and the horizontal plane" + proj = Vector(self.u.x,self.u.y,0) + if self.u.getAngle(proj) == 0: + return 0 + else: + norm = proj.cross(self.u) + return DraftVecUtils.angle(self.u,proj,norm) + +def getPlacementFromPoints(points): + "returns a placement from a list of 3 or 4 vectors" + pl = plane() + try: + pl.position = points[0] + pl.u = (points[1].sub(points[0]).normalize()) + pl.v = (points[2].sub(points[0]).normalize()) + if len(points) == 4: + pl.axis = (points[3].sub(points[0]).normalize()) + else: + pl.axis = ((pl.u).cross(pl.v)).normalize() + except: + return None + p = pl.getPlacement() + del pl + return p + +def getPlacementFromFace(face,rotated=False): + "returns a placement from a face" + pl = plane() + try: + pl.alignToFace(face) + except: + return None + p = pl.getPlacement(rotated) + del pl + return p + +#! /usr/bin/env python2 +""" +mbed SDK +Copyright (c) 2011-2013 ARM Limited + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + + +TEST BUILD & RUN +""" +import sys +from time import sleep +from shutil import copy +from os.path import join, abspath, dirname + +# Be sure that the tools directory is in the search path +ROOT = abspath(join(dirname(__file__), "..")) +sys.path.insert(0, ROOT) + +from workspace_tools.utils import args_error +from workspace_tools.paths import BUILD_DIR +from workspace_tools.paths import RTOS_LIBRARIES +from workspace_tools.paths import ETH_LIBRARY +from workspace_tools.paths import USB_HOST_LIBRARIES, USB_LIBRARIES +from workspace_tools.paths import DSP_LIBRARIES +from workspace_tools.paths import FS_LIBRARY +from workspace_tools.paths import UBLOX_LIBRARY +from workspace_tools.tests import TESTS, Test, TEST_MAP +from workspace_tools.tests import TEST_MBED_LIB +from workspace_tools.targets import TARGET_MAP +from workspace_tools.options import get_default_options_parser +from workspace_tools.build_api import build_project +try: + import workspace_tools.private_settings as ps +except: + ps = object() + + +if __name__ == '__main__': + # Parse Options + parser = get_default_options_parser() + parser.add_option("-p", + type="int", + dest="program", + help="The index of the desired test program: [0-%d]" % (len(TESTS)-1)) + + parser.add_option("-n", + dest="program_name", + help="The name of the desired test program") + + parser.add_option("-j", "--jobs", + type="int", + dest="jobs", + default=1, + help="Number of concurrent jobs (default 1). Use 0 for auto based on host machine's number of CPUs") + + parser.add_option("-v", "--verbose", + action="store_true", + dest="verbose", + default=False, + help="Verbose diagnostic output") + + parser.add_option("--silent", + action="store_true", + dest="silent", + default=False, + help="Silent diagnostic output (no copy, compile notification)") + + parser.add_option("-D", "", + action="append", + dest="macros", + help="Add a macro definition") + + # Local run + parser.add_option("--automated", action="store_true", dest="automated", + default=False, help="Automated test") + parser.add_option("--host", dest="host_test", + default=None, help="Host test") + parser.add_option("--extra", dest="extra", + default=None, help="Extra files") + parser.add_option("--peripherals", dest="peripherals", + default=None, help="Required peripherals") + parser.add_option("--dep", dest="dependencies", + default=None, help="Dependencies") + parser.add_option("--source", dest="source_dir", + default=None, help="The source (input) directory") + parser.add_option("--duration", type="int", dest="duration", + default=None, help="Duration of the test") + parser.add_option("--build", dest="build_dir", + default=None, help="The build (output) directory") + parser.add_option("-d", "--disk", dest="disk", + default=None, help="The mbed disk") + parser.add_option("-s", "--serial", dest="serial", + default=None, help="The mbed serial port") + parser.add_option("-b", "--baud", type="int", dest="baud", + default=None, help="The mbed serial baud rate") + parser.add_option("-L", "--list-tests", action="store_true", dest="list_tests", + default=False, help="List available tests in order and exit") + + # Ideally, all the tests with a single "main" thread can be run with, or + # without the rtos, eth, usb_host, usb, dsp, fat, ublox + parser.add_option("--rtos", + action="store_true", dest="rtos", + default=False, help="Link with RTOS library") + + parser.add_option("--eth", + action="store_true", dest="eth", + default=False, + help="Link with Ethernet library") + + parser.add_option("--usb_host", + action="store_true", + dest="usb_host", + default=False, + help="Link with USB Host library") + + parser.add_option("--usb", + action="store_true", + dest="usb", + default=False, + help="Link with USB Device library") + + parser.add_option("--dsp", + action="store_true", + dest="dsp", + default=False, + help="Link with DSP library") + + parser.add_option("--fat", + action="store_true", + dest="fat", + default=False, + help="Link with FS ad SD card file system library") + + parser.add_option("--ublox", + action="store_true", + dest="ublox", + default=False, + help="Link with U-Blox library") + + parser.add_option("--testlib", + action="store_true", + dest="testlib", + default=False, + help="Link with mbed test library") + + # Specify a different linker script + parser.add_option("-l", "--linker", dest="linker_script", + default=None, help="use the specified linker script") + + (options, args) = parser.parse_args() + + # Print available tests in order and exit + if options.list_tests is True: + print '\n'.join(map(str, sorted(TEST_MAP.values()))) + sys.exit() + + # force program to "0" if a source dir is specified + if options.source_dir is not None: + p = 0 + n = None + else: + # Program Number or name + p, n = options.program, options.program_name + + if n is not None and p is not None: + args_error(parser, "[ERROR] specify either '-n' or '-p', not both") + if n: + # We will transform 'n' to list of 'p' (integers which are test numbers) + nlist = n.split(',') + for test_id in nlist: + if test_id not in TEST_MAP.keys(): + args_error(parser, "[ERROR] Program with name '%s' not found"% test_id) + + p = [TEST_MAP[n].n for n in nlist] + elif p is None or (p < 0) or (p > (len(TESTS)-1)): + message = "[ERROR] You have to specify one of the following tests:\n" + message += '\n'.join(map(str, sorted(TEST_MAP.values()))) + args_error(parser, message) + + # If 'p' was set via -n to list of numbers make this a single element integer list + if type(p) != type([]): + p = [p] + + # Target + if options.mcu is None : + args_error(parser, "[ERROR] You should specify an MCU") + mcu = options.mcu + + # Toolchain + if options.tool is None: + args_error(parser, "[ERROR] You should specify a TOOLCHAIN") + toolchain = options.tool + + # Test + for test_no in p: + test = Test(test_no) + if options.automated is not None: test.automated = options.automated + if options.dependencies is not None: test.dependencies = options.dependencies + if options.host_test is not None: test.host_test = options.host_test; + if options.peripherals is not None: test.peripherals = options.peripherals; + if options.duration is not None: test.duration = options.duration; + if options.extra is not None: test.extra_files = options.extra + + if not test.is_supported(mcu, toolchain): + print 'The selected test is not supported on target %s with toolchain %s' % (mcu, toolchain) + sys.exit() + + # Linking with extra libraries + if options.rtos: test.dependencies.append(RTOS_LIBRARIES) + if options.eth: test.dependencies.append(ETH_LIBRARY) + if options.usb_host: test.dependencies.append(USB_HOST_LIBRARIES) + if options.usb: test.dependencies.append(USB_LIBRARIES) + if options.dsp: test.dependencies.append(DSP_LIBRARIES) + if options.fat: test.dependencies.append(FS_LIBRARY) + if options.ublox: test.dependencies.append(UBLOX_LIBRARY) + if options.testlib: test.dependencies.append(TEST_MBED_LIB) + + build_dir = join(BUILD_DIR, "test", mcu, toolchain, test.id) + if options.source_dir is not None: + test.source_dir = options.source_dir + build_dir = options.source_dir + + if options.build_dir is not None: + build_dir = options.build_dir + + target = TARGET_MAP[mcu] + try: + bin_file = build_project(test.source_dir, build_dir, target, toolchain, test.dependencies, options.options, + linker_script=options.linker_script, + clean=options.clean, + verbose=options.verbose, + silent=options.silent, + macros=options.macros, + jobs=options.jobs) + print 'Image: %s'% bin_file + + if options.disk: + # Simple copy to the mbed disk + copy(bin_file, options.disk) + + if options.serial: + # Import pyserial: https://pypi.python.org/pypi/pyserial + from serial import Serial + + sleep(target.program_cycle_s()) + + serial = Serial(options.serial, timeout = 1) + if options.baud: + serial.setBaudrate(options.baud) + + serial.flushInput() + serial.flushOutput() + + try: + serial.sendBreak() + except: + # In linux a termios.error is raised in sendBreak and in setBreak. + # The following setBreak() is needed to release the reset signal on the target mcu. + try: + serial.setBreak(False) + except: + pass + + while True: + c = serial.read(512) + sys.stdout.write(c) + sys.stdout.flush() + + except KeyboardInterrupt, e: + print "\n[CTRL+c] exit" + except Exception,e: + if options.verbose: + import traceback + traceback.print_exc(file=sys.stdout) + else: + print "[ERROR] %s" % str(e) + +#!/usr/bin/env python + +import os +import shutil +import glob +import time +import sys +import subprocess +from optparse import OptionParser, make_option + + +SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) +PARAMETERS = None +ADB_CMD = "adb" + + +def doCMD(cmd): + # Do not need handle timeout in this short script, let tool do it + print "-->> \"%s\"" % cmd + output = [] + cmd_return_code = 1 + cmd_proc = subprocess.Popen( + cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True) + + while True: + output_line = cmd_proc.stdout.readline().strip("\r\n") + cmd_return_code = cmd_proc.poll() + if output_line == '' and cmd_return_code != None: + break + sys.stdout.write("%s\n" % output_line) + sys.stdout.flush() + output.append(output_line) + + return (cmd_return_code, output) + + +def uninstPKGs(): + action_status = True + for root, dirs, files in os.walk(SCRIPT_DIR): + for file in files: + if file.endswith(".apk"): + cmd = "%s -s %s uninstall org.xwalk.%s" % ( + ADB_CMD, PARAMETERS.device, os.path.basename(os.path.splitext(file)[0])) + (return_code, output) = doCMD(cmd) + for line in output: + if "Failure" in line: + action_status = False + break + return action_status + + +def instPKGs(): + action_status = True + for root, dirs, files in os.walk(SCRIPT_DIR): + for file in files: + if file.endswith(".apk"): + cmd = "%s -s %s install %s" % (ADB_CMD, + PARAMETERS.device, os.path.join(root, file)) + (return_code, output) = doCMD(cmd) + for line in output: + if "Failure" in line: + action_status = False + break + return action_status + + +def main(): + try: + usage = "usage: inst.py -i" + opts_parser = OptionParser(usage=usage) + opts_parser.add_option( + "-s", dest="device", action="store", help="Specify device") + opts_parser.add_option( + "-i", dest="binstpkg", action="store_true", help="Install package") + opts_parser.add_option( + "-u", dest="buninstpkg", action="store_true", help="Uninstall package") + global PARAMETERS + (PARAMETERS, args) = opts_parser.parse_args() + except Exception, e: + print "Got wrong option: %s, exit ..." % e + sys.exit(1) + + if not PARAMETERS.device: + (return_code, output) = doCMD("adb devices") + for line in output: + if str.find(line, "\tdevice") != -1: + PARAMETERS.device = line.split("\t")[0] + break + + if not PARAMETERS.device: + print "No device found" + sys.exit(1) + + if PARAMETERS.binstpkg and PARAMETERS.buninstpkg: + print "-i and -u are conflict" + sys.exit(1) + + if PARAMETERS.buninstpkg: + if not uninstPKGs(): + sys.exit(1) + else: + if not instPKGs(): + sys.exit(1) + +if __name__ == "__main__": + main() + sys.exit(0) + +"""Support for stiebel_eltron climate platform.""" +import logging + +from homeassistant.components.climate import ClimateDevice +from homeassistant.components.climate.const import ( + STATE_AUTO, STATE_ECO, STATE_MANUAL, SUPPORT_OPERATION_MODE, + SUPPORT_TARGET_TEMPERATURE) +from homeassistant.const import ( + ATTR_TEMPERATURE, STATE_OFF, STATE_ON, TEMP_CELSIUS) + +from . import DOMAIN as STE_DOMAIN + +DEPENDENCIES = ['stiebel_eltron'] + +_LOGGER = logging.getLogger(__name__) + + +SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE +OPERATION_MODES = [STATE_AUTO, STATE_MANUAL, STATE_ECO, STATE_OFF] + +# Mapping STIEBEL ELTRON states to homeassistant states. +STE_TO_HA_STATE = {'AUTOMATIC': STATE_AUTO, + 'MANUAL MODE': STATE_MANUAL, + 'STANDBY': STATE_ECO, + 'DAY MODE': STATE_ON, + 'SETBACK MODE': STATE_ON, + 'DHW': STATE_OFF, + 'EMERGENCY OPERATION': STATE_ON} + +# Mapping homeassistant states to STIEBEL ELTRON states. +HA_TO_STE_STATE = {value: key for key, value in STE_TO_HA_STATE.items()} + + +def setup_platform(hass, config, add_entities, discovery_info=None): + """Set up the StiebelEltron platform.""" + name = hass.data[STE_DOMAIN]['name'] + ste_data = hass.data[STE_DOMAIN]['ste_data'] + + add_entities([StiebelEltron(name, ste_data)], True) + + +class StiebelEltron(ClimateDevice): + """Representation of a STIEBEL ELTRON heat pump.""" + + def __init__(self, name, ste_data): + """Initialize the unit.""" + self._name = name + self._target_temperature = None + self._current_temperature = None + self._current_humidity = None + self._operation_modes = OPERATION_MODES + self._current_operation = None + self._filter_alarm = None + self._force_update = False + self._ste_data = ste_data + + @property + def supported_features(self): + """Return the list of supported features.""" + return SUPPORT_FLAGS + + def update(self): + """Update unit attributes.""" + self._ste_data.update(no_throttle=self._force_update) + self._force_update = False + + self._target_temperature = self._ste_data.api.get_target_temp() + self._current_temperature = self._ste_data.api.get_current_temp() + self._current_humidity = self._ste_data.api.get_current_humidity() + self._filter_alarm = self._ste_data.api.get_filter_alarm_status() + self._current_operation = self._ste_data.api.get_operation() + + _LOGGER.debug("Update %s, current temp: %s", self._name, + self._current_temperature) + + @property + def device_state_attributes(self): + """Return device specific state attributes.""" + return { + 'filter_alarm': self._filter_alarm + } + + @property + def name(self): + """Return the name of the climate device.""" + return self._name + + # Handle SUPPORT_TARGET_TEMPERATURE + @property + def temperature_unit(self): + """Return the unit of measurement.""" + return TEMP_CELSIUS + + @property + def current_temperature(self): + """Return the current temperature.""" + return self._current_temperature + + @property + def target_temperature(self): + """Return the temperature we try to reach.""" + return self._target_temperature + + @property + def target_temperature_step(self): + """Return the supported step of target temperature.""" + return 0.1 + + @property + def min_temp(self): + """Return the minimum temperature.""" + return 10.0 + + @property + def max_temp(self): + """Return the maximum temperature.""" + return 30.0 + + def set_temperature(self, **kwargs): + """Set new target temperature.""" + target_temperature = kwargs.get(ATTR_TEMPERATURE) + if target_temperature is not None: + _LOGGER.debug("set_temperature: %s", target_temperature) + self._ste_data.api.set_target_temp(target_temperature) + self._force_update = True + + @property + def current_humidity(self): + """Return the current humidity.""" + return float("{0:.1f}".format(self._current_humidity)) + + # Handle SUPPORT_OPERATION_MODE + @property + def operation_list(self): + """List of the operation modes.""" + return self._operation_modes + + @property + def current_operation(self): + """Return current operation ie. heat, cool, idle.""" + return STE_TO_HA_STATE.get(self._current_operation) + + def set_operation_mode(self, operation_mode): + """Set new operation mode.""" + new_mode = HA_TO_STE_STATE.get(operation_mode) + _LOGGER.debug("set_operation_mode: %s -> %s", self._current_operation, + new_mode) + self._ste_data.api.set_operation(new_mode) + self._force_update = True + +#!/usr/bin/env python +#pylint: disable=missing-docstring +################################################################# +# DO NOT MODIFY THIS HEADER # +# MOOSE - Multiphysics Object Oriented Simulation Environment # +# # +# (c) 2010 Battelle Energy Alliance, LLC # +# ALL RIGHTS RESERVED # +# # +# Prepared by Battelle Energy Alliance, LLC # +# Under Contract No. DE-AC07-05ID14517 # +# With the U. S. Department of Energy # +# # +# See COPYRIGHT for full restrictions # +################################################################# +import chigger +reader = chigger.exodus.ExodusReader('../input/mug_blocks_out.e', timestep=0) +mug = chigger.exodus.ExodusResult(reader, variable='diffused', min=0.5, max=1.8) +cbar = chigger.exodus.ExodusColorBar(mug, primary={'precision':2, 'num_ticks':3, 'notation':'fixed'}) +window = chigger.RenderWindow(mug, cbar, size=[300,300], test=True) + +for i in range(2): + reader.setOptions(timestep=i) + window.write('minmax_' + str(i) + '.png') +window.start() + +from .models import AbstractPerson, BasePerson, Person, Relating, Relation + +TEST_RESULTS = { + 'get_all_field_names': { + Person: [ + 'baseperson_ptr', + 'baseperson_ptr_id', + 'content_type_abstract', + 'content_type_abstract_id', + 'content_type_base', + 'content_type_base_id', + 'content_type_concrete', + 'content_type_concrete_id', + 'data_abstract', + 'data_base', + 'data_inherited', + 'data_not_concrete_abstract', + 'data_not_concrete_base', + 'data_not_concrete_inherited', + 'fk_abstract', + 'fk_abstract_id', + 'fk_base', + 'fk_base_id', + 'fk_inherited', + 'fk_inherited_id', + 'followers_abstract', + 'followers_base', + 'followers_concrete', + 'following_abstract', + 'following_base', + 'following_inherited', + 'friends_abstract', + 'friends_base', + 'friends_inherited', + 'generic_relation_abstract', + 'generic_relation_base', + 'generic_relation_concrete', + 'id', + 'm2m_abstract', + 'm2m_base', + 'm2m_inherited', + 'object_id_abstract', + 'object_id_base', + 'object_id_concrete', + 'relating_basepeople', + 'relating_baseperson', + 'relating_people', + 'relating_person', + ], + BasePerson: [ + 'content_type_abstract', + 'content_type_abstract_id', + 'content_type_base', + 'content_type_base_id', + 'data_abstract', + 'data_base', + 'data_not_concrete_abstract', + 'data_not_concrete_base', + 'fk_abstract', + 'fk_abstract_id', + 'fk_base', + 'fk_base_id', + 'followers_abstract', + 'followers_base', + 'following_abstract', + 'following_base', + 'friends_abstract', + 'friends_base', + 'generic_relation_abstract', + 'generic_relation_base', + 'id', + 'm2m_abstract', + 'm2m_base', + 'object_id_abstract', + 'object_id_base', + 'person', + 'relating_basepeople', + 'relating_baseperson' + ], + AbstractPerson: [ + 'content_type_abstract', + 'content_type_abstract_id', + 'data_abstract', + 'data_not_concrete_abstract', + 'fk_abstract', + 'fk_abstract_id', + 'following_abstract', + 'friends_abstract', + 'generic_relation_abstract', + 'm2m_abstract', + 'object_id_abstract', + ], + Relating: [ + 'basepeople', + 'basepeople_hidden', + 'baseperson', + 'baseperson_hidden', + 'baseperson_hidden_id', + 'baseperson_id', + 'id', + 'people', + 'people_hidden', + 'person', + 'person_hidden', + 'person_hidden_id', + 'person_id', + 'proxyperson', + 'proxyperson_hidden', + 'proxyperson_hidden_id', + 'proxyperson_id', + ], + }, + 'fields': { + Person: [ + 'id', + 'data_abstract', + 'fk_abstract_id', + 'data_not_concrete_abstract', + 'content_type_abstract_id', + 'object_id_abstract', + 'data_base', + 'fk_base_id', + 'data_not_concrete_base', + 'content_type_base_id', + 'object_id_base', + 'baseperson_ptr_id', + 'data_inherited', + 'fk_inherited_id', + 'data_not_concrete_inherited', + 'content_type_concrete_id', + 'object_id_concrete', + ], + BasePerson: [ + 'id', + 'data_abstract', + 'fk_abstract_id', + 'data_not_concrete_abstract', + 'content_type_abstract_id', + 'object_id_abstract', + 'data_base', + 'fk_base_id', + 'data_not_concrete_base', + 'content_type_base_id', + 'object_id_base', + ], + AbstractPerson: [ + 'data_abstract', + 'fk_abstract_id', + 'data_not_concrete_abstract', + 'content_type_abstract_id', + 'object_id_abstract', + ], + Relating: [ + 'id', + 'baseperson_id', + 'baseperson_hidden_id', + 'person_id', + 'person_hidden_id', + 'proxyperson_id', + 'proxyperson_hidden_id', + ], + }, + 'local_fields': { + Person: [ + 'baseperson_ptr_id', + 'data_inherited', + 'fk_inherited_id', + 'data_not_concrete_inherited', + 'content_type_concrete_id', + 'object_id_concrete', + ], + BasePerson: [ + 'id', + 'data_abstract', + 'fk_abstract_id', + 'data_not_concrete_abstract', + 'content_type_abstract_id', + 'object_id_abstract', + 'data_base', + 'fk_base_id', + 'data_not_concrete_base', + 'content_type_base_id', + 'object_id_base', + ], + AbstractPerson: [ + 'data_abstract', + 'fk_abstract_id', + 'data_not_concrete_abstract', + 'content_type_abstract_id', + 'object_id_abstract', + ], + Relating: [ + 'id', + 'baseperson_id', + 'baseperson_hidden_id', + 'person_id', + 'person_hidden_id', + 'proxyperson_id', + 'proxyperson_hidden_id', + ], + }, + 'local_concrete_fields': { + Person: [ + 'baseperson_ptr_id', + 'data_inherited', + 'fk_inherited_id', + 'content_type_concrete_id', + 'object_id_concrete', + ], + BasePerson: [ + 'id', + 'data_abstract', + 'fk_abstract_id', + 'content_type_abstract_id', + 'object_id_abstract', + 'data_base', + 'fk_base_id', + 'content_type_base_id', + 'object_id_base', + ], + AbstractPerson: [ + 'data_abstract', + 'fk_abstract_id', + 'content_type_abstract_id', + 'object_id_abstract', + ], + Relating: [ + 'id', + 'baseperson_id', + 'baseperson_hidden_id', + 'person_id', + 'person_hidden_id', + 'proxyperson_id', + 'proxyperson_hidden_id', + ], + }, + 'many_to_many': { + Person: [ + 'm2m_abstract', + 'friends_abstract', + 'following_abstract', + 'm2m_base', + 'friends_base', + 'following_base', + 'm2m_inherited', + 'friends_inherited', + 'following_inherited', + ], + BasePerson: [ + 'm2m_abstract', + 'friends_abstract', + 'following_abstract', + 'm2m_base', + 'friends_base', + 'following_base', + ], + AbstractPerson: [ + 'm2m_abstract', + 'friends_abstract', + 'following_abstract', + ], + Relating: [ + 'basepeople', + 'basepeople_hidden', + 'people', + 'people_hidden', + ], + }, + 'many_to_many_with_model': { + Person: [ + BasePerson, + BasePerson, + BasePerson, + BasePerson, + BasePerson, + BasePerson, + None, + None, + None, + ], + BasePerson: [ + None, + None, + None, + None, + None, + None, + ], + AbstractPerson: [ + None, + None, + None, + ], + Relating: [ + None, + None, + None, + None, + ], + }, + 'get_all_related_objects_with_model_legacy': { + Person: ( + ('relating_baseperson', BasePerson), + ('relating_person', None), + ), + BasePerson: ( + ('person', None), + ('relating_baseperson', None), + ), + Relation: ( + ('fk_abstract_rel', None), + ('fo_abstract_rel', None), + ('fk_base_rel', None), + ('fo_base_rel', None), + ('fk_concrete_rel', None), + ('fo_concrete_rel', None), + ), + }, + 'get_all_related_objects_with_model_hidden_local': { + Person: ( + ('+', None), + ('_relating_people_hidden_+', None), + ('Person_following_inherited+', None), + ('Person_following_inherited+', None), + ('Person_friends_inherited+', None), + ('Person_friends_inherited+', None), + ('Person_m2m_inherited+', None), + ('Relating_people+', None), + ('Relating_people_hidden+', None), + ('followers_concrete', None), + ('friends_inherited_rel_+', None), + ('relating_people', None), + ('relating_person', None), + ), + BasePerson: ( + ('+', None), + ('_relating_basepeople_hidden_+', None), + ('BasePerson_following_abstract+', None), + ('BasePerson_following_abstract+', None), + ('BasePerson_following_base+', None), + ('BasePerson_following_base+', None), + ('BasePerson_friends_abstract+', None), + ('BasePerson_friends_abstract+', None), + ('BasePerson_friends_base+', None), + ('BasePerson_friends_base+', None), + ('BasePerson_m2m_abstract+', None), + ('BasePerson_m2m_base+', None), + ('Relating_basepeople+', None), + ('Relating_basepeople_hidden+', None), + ('followers_abstract', None), + ('followers_base', None), + ('friends_abstract_rel_+', None), + ('friends_base_rel_+', None), + ('person', None), + ('relating_basepeople', None), + ('relating_baseperson', None), + ), + Relation: ( + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('BasePerson_m2m_abstract+', None), + ('BasePerson_m2m_base+', None), + ('Person_m2m_inherited+', None), + ('fk_abstract_rel', None), + ('fk_base_rel', None), + ('fk_concrete_rel', None), + ('fo_abstract_rel', None), + ('fo_base_rel', None), + ('fo_concrete_rel', None), + ('m2m_abstract_rel', None), + ('m2m_base_rel', None), + ('m2m_concrete_rel', None), + ), + }, + 'get_all_related_objects_with_model_hidden': { + Person: ( + ('+', BasePerson), + ('+', None), + ('_relating_basepeople_hidden_+', BasePerson), + ('_relating_people_hidden_+', None), + ('BasePerson_following_abstract+', BasePerson), + ('BasePerson_following_abstract+', BasePerson), + ('BasePerson_following_base+', BasePerson), + ('BasePerson_following_base+', BasePerson), + ('BasePerson_friends_abstract+', BasePerson), + ('BasePerson_friends_abstract+', BasePerson), + ('BasePerson_friends_base+', BasePerson), + ('BasePerson_friends_base+', BasePerson), + ('BasePerson_m2m_abstract+', BasePerson), + ('BasePerson_m2m_base+', BasePerson), + ('Person_following_inherited+', None), + ('Person_following_inherited+', None), + ('Person_friends_inherited+', None), + ('Person_friends_inherited+', None), + ('Person_m2m_inherited+', None), + ('Relating_basepeople+', BasePerson), + ('Relating_basepeople_hidden+', BasePerson), + ('Relating_people+', None), + ('Relating_people_hidden+', None), + ('followers_abstract', BasePerson), + ('followers_base', BasePerson), + ('followers_concrete', None), + ('friends_abstract_rel_+', BasePerson), + ('friends_base_rel_+', BasePerson), + ('friends_inherited_rel_+', None), + ('relating_basepeople', BasePerson), + ('relating_baseperson', BasePerson), + ('relating_people', None), + ('relating_person', None), + ), + BasePerson: ( + ('+', None), + ('_relating_basepeople_hidden_+', None), + ('BasePerson_following_abstract+', None), + ('BasePerson_following_abstract+', None), + ('BasePerson_following_base+', None), + ('BasePerson_following_base+', None), + ('BasePerson_friends_abstract+', None), + ('BasePerson_friends_abstract+', None), + ('BasePerson_friends_base+', None), + ('BasePerson_friends_base+', None), + ('BasePerson_m2m_abstract+', None), + ('BasePerson_m2m_base+', None), + ('Relating_basepeople+', None), + ('Relating_basepeople_hidden+', None), + ('followers_abstract', None), + ('followers_base', None), + ('friends_abstract_rel_+', None), + ('friends_base_rel_+', None), + ('person', None), + ('relating_basepeople', None), + ('relating_baseperson', None), + ), + Relation: ( + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('BasePerson_m2m_abstract+', None), + ('BasePerson_m2m_base+', None), + ('Person_m2m_inherited+', None), + ('fk_abstract_rel', None), + ('fk_base_rel', None), + ('fk_concrete_rel', None), + ('fo_abstract_rel', None), + ('fo_base_rel', None), + ('fo_concrete_rel', None), + ('m2m_abstract_rel', None), + ('m2m_base_rel', None), + ('m2m_concrete_rel', None), + ), + }, + 'get_all_related_objects_with_model_local': { + Person: ( + ('followers_concrete', None), + ('relating_person', None), + ('relating_people', None), + ), + BasePerson: ( + ('followers_abstract', None), + ('followers_base', None), + ('person', None), + ('relating_baseperson', None), + ('relating_basepeople', None), + ), + Relation: ( + ('fk_abstract_rel', None), + ('fo_abstract_rel', None), + ('fk_base_rel', None), + ('fo_base_rel', None), + ('m2m_abstract_rel', None), + ('m2m_base_rel', None), + ('fk_concrete_rel', None), + ('fo_concrete_rel', None), + ('m2m_concrete_rel', None), + ), + }, + 'get_all_related_objects_with_model': { + Person: ( + ('followers_abstract', BasePerson), + ('followers_base', BasePerson), + ('relating_baseperson', BasePerson), + ('relating_basepeople', BasePerson), + ('followers_concrete', None), + ('relating_person', None), + ('relating_people', None), + ), + BasePerson: ( + ('followers_abstract', None), + ('followers_base', None), + ('person', None), + ('relating_baseperson', None), + ('relating_basepeople', None), + ), + Relation: ( + ('fk_abstract_rel', None), + ('fo_abstract_rel', None), + ('fk_base_rel', None), + ('fo_base_rel', None), + ('m2m_abstract_rel', None), + ('m2m_base_rel', None), + ('fk_concrete_rel', None), + ('fo_concrete_rel', None), + ('m2m_concrete_rel', None), + ), + }, + 'get_all_related_objects_with_model_local_legacy': { + Person: ( + ('relating_person', None), + ), + BasePerson: ( + ('person', None), + ('relating_baseperson', None) + ), + Relation: ( + ('fk_abstract_rel', None), + ('fo_abstract_rel', None), + ('fk_base_rel', None), + ('fo_base_rel', None), + ('fk_concrete_rel', None), + ('fo_concrete_rel', None), + ), + }, + 'get_all_related_objects_with_model_hidden_legacy': { + BasePerson: ( + ('+', None), + ('BasePerson_following_abstract+', None), + ('BasePerson_following_abstract+', None), + ('BasePerson_following_base+', None), + ('BasePerson_following_base+', None), + ('BasePerson_friends_abstract+', None), + ('BasePerson_friends_abstract+', None), + ('BasePerson_friends_base+', None), + ('BasePerson_friends_base+', None), + ('BasePerson_m2m_abstract+', None), + ('BasePerson_m2m_base+', None), + ('Relating_basepeople+', None), + ('Relating_basepeople_hidden+', None), + ('person', None), + ('relating_baseperson', None), + ), + Person: ( + ('+', BasePerson), + ('+', None), + ('BasePerson_following_abstract+', BasePerson), + ('BasePerson_following_abstract+', BasePerson), + ('BasePerson_following_base+', BasePerson), + ('BasePerson_following_base+', BasePerson), + ('BasePerson_friends_abstract+', BasePerson), + ('BasePerson_friends_abstract+', BasePerson), + ('BasePerson_friends_base+', BasePerson), + ('BasePerson_friends_base+', BasePerson), + ('BasePerson_m2m_abstract+', BasePerson), + ('BasePerson_m2m_base+', BasePerson), + ('Person_following_inherited+', None), + ('Person_following_inherited+', None), + ('Person_friends_inherited+', None), + ('Person_friends_inherited+', None), + ('Person_m2m_inherited+', None), + ('Relating_basepeople+', BasePerson), + ('Relating_basepeople_hidden+', BasePerson), + ('Relating_people+', None), + ('Relating_people_hidden+', None), + ('relating_baseperson', BasePerson), + ('relating_person', None), + ), + Relation: ( + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('BasePerson_m2m_abstract+', None), + ('BasePerson_m2m_base+', None), + ('Person_m2m_inherited+', None), + ('fk_abstract_rel', None), + ('fk_base_rel', None), + ('fk_concrete_rel', None), + ('fo_abstract_rel', None), + ('fo_base_rel', None), + ('fo_concrete_rel', None), + ), + }, + 'get_all_related_objects_with_model_hidden_local_legacy': { + BasePerson: ( + ('+', None), + ('BasePerson_following_abstract+', None), + ('BasePerson_following_abstract+', None), + ('BasePerson_following_base+', None), + ('BasePerson_following_base+', None), + ('BasePerson_friends_abstract+', None), + ('BasePerson_friends_abstract+', None), + ('BasePerson_friends_base+', None), + ('BasePerson_friends_base+', None), + ('BasePerson_m2m_abstract+', None), + ('BasePerson_m2m_base+', None), + ('Relating_basepeople+', None), + ('Relating_basepeople_hidden+', None), + ('person', None), + ('relating_baseperson', None), + ), + Person: ( + ('+', None), + ('Person_following_inherited+', None), + ('Person_following_inherited+', None), + ('Person_friends_inherited+', None), + ('Person_friends_inherited+', None), + ('Person_m2m_inherited+', None), + ('Relating_people+', None), + ('Relating_people_hidden+', None), + ('relating_person', None), + ), + Relation: ( + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('BasePerson_m2m_abstract+', None), + ('BasePerson_m2m_base+', None), + ('Person_m2m_inherited+', None), + ('fk_abstract_rel', None), + ('fk_base_rel', None), + ('fk_concrete_rel', None), + ('fo_abstract_rel', None), + ('fo_base_rel', None), + ('fo_concrete_rel', None), + ), + }, + 'get_all_related_objects_with_model_proxy_legacy': { + BasePerson: ( + ('person', None), + ('relating_baseperson', None), + ), + Person: ( + ('relating_baseperson', BasePerson), + ('relating_person', None), ('relating_proxyperson', None), + ), + Relation: ( + ('fk_abstract_rel', None), ('fo_abstract_rel', None), + ('fk_base_rel', None), ('fo_base_rel', None), + ('fk_concrete_rel', None), ('fo_concrete_rel', None), + ), + }, + 'get_all_related_objects_with_model_proxy_hidden_legacy': { + BasePerson: ( + ('+', None), + ('BasePerson_following_abstract+', None), + ('BasePerson_following_abstract+', None), + ('BasePerson_following_base+', None), + ('BasePerson_following_base+', None), + ('BasePerson_friends_abstract+', None), + ('BasePerson_friends_abstract+', None), + ('BasePerson_friends_base+', None), + ('BasePerson_friends_base+', None), + ('BasePerson_m2m_abstract+', None), + ('BasePerson_m2m_base+', None), + ('Relating_basepeople+', None), + ('Relating_basepeople_hidden+', None), + ('person', None), + ('relating_baseperson', None), + ), + Person: ( + ('+', BasePerson), + ('+', None), + ('+', None), + ('BasePerson_following_abstract+', BasePerson), + ('BasePerson_following_abstract+', BasePerson), + ('BasePerson_following_base+', BasePerson), + ('BasePerson_following_base+', BasePerson), + ('BasePerson_friends_abstract+', BasePerson), + ('BasePerson_friends_abstract+', BasePerson), + ('BasePerson_friends_base+', BasePerson), + ('BasePerson_friends_base+', BasePerson), + ('BasePerson_m2m_abstract+', BasePerson), + ('BasePerson_m2m_base+', BasePerson), + ('Person_following_inherited+', None), + ('Person_following_inherited+', None), + ('Person_friends_inherited+', None), + ('Person_friends_inherited+', None), + ('Person_m2m_inherited+', None), + ('Relating_basepeople+', BasePerson), + ('Relating_basepeople_hidden+', BasePerson), + ('Relating_people+', None), + ('Relating_people_hidden+', None), + ('relating_baseperson', BasePerson), + ('relating_person', None), + ('relating_proxyperson', None), + ), + Relation: ( + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('+', None), + ('BasePerson_m2m_abstract+', None), + ('BasePerson_m2m_base+', None), + ('Person_m2m_inherited+', None), + ('fk_abstract_rel', None), + ('fk_base_rel', None), + ('fk_concrete_rel', None), + ('fo_abstract_rel', None), + ('fo_base_rel', None), + ('fo_concrete_rel', None), + ), + }, + 'get_all_related_many_to_many_with_model_legacy': { + BasePerson: ( + ('friends_abstract_rel_+', None), + ('followers_abstract', None), + ('friends_base_rel_+', None), + ('followers_base', None), + ('relating_basepeople', None), + ('_relating_basepeople_hidden_+', None), + ), + Person: ( + ('friends_abstract_rel_+', BasePerson), + ('followers_abstract', BasePerson), + ('friends_base_rel_+', BasePerson), + ('followers_base', BasePerson), + ('relating_basepeople', BasePerson), + ('_relating_basepeople_hidden_+', BasePerson), + ('friends_inherited_rel_+', None), + ('followers_concrete', None), + ('relating_people', None), + ('_relating_people_hidden_+', None), + ), + Relation: ( + ('m2m_abstract_rel', None), + ('m2m_base_rel', None), + ('m2m_concrete_rel', None), + ), + }, + 'get_all_related_many_to_many_local_legacy': { + BasePerson: [ + 'friends_abstract_rel_+', + 'followers_abstract', + 'friends_base_rel_+', + 'followers_base', + 'relating_basepeople', + '_relating_basepeople_hidden_+', + ], + Person: [ + 'friends_inherited_rel_+', + 'followers_concrete', + 'relating_people', + '_relating_people_hidden_+', + ], + Relation: [ + 'm2m_abstract_rel', + 'm2m_base_rel', + 'm2m_concrete_rel', + ], + }, + 'virtual_fields': { + AbstractPerson: [ + 'generic_relation_abstract', + 'content_object_abstract', + ], + BasePerson: [ + 'generic_relation_base', + 'content_object_base', + 'generic_relation_abstract', + 'content_object_abstract', + ], + Person: [ + 'content_object_concrete', + 'generic_relation_concrete', + 'generic_relation_base', + 'content_object_base', + 'generic_relation_abstract', + 'content_object_abstract', + ], + }, + 'labels': { + AbstractPerson: 'model_meta.AbstractPerson', + BasePerson: 'model_meta.BasePerson', + Person: 'model_meta.Person', + Relating: 'model_meta.Relating', + }, + 'lower_labels': { + AbstractPerson: 'model_meta.abstractperson', + BasePerson: 'model_meta.baseperson', + Person: 'model_meta.person', + Relating: 'model_meta.relating', + }, +} + +#!/usr/bin/env python +# +# Copyright (c) 2016, The OpenThread Authors. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# 3. Neither the name of the copyright holder nor the +# names of its contributors may be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +# + +from autothreadharness.harness_case import HarnessCase +import unittest + + +class Router_5_5_1(HarnessCase): + role = HarnessCase.ROLE_ROUTER + case = '5 5 1' + golden_devices_required = 1 + + def on_dialog(self, dialog, title): + pass + + +if __name__ == '__main__': + unittest.main() + +import sys +import time + +from django.conf import settings +from django.db.backends.base.creation import BaseDatabaseCreation +from django.db.utils import DatabaseError +from django.utils.functional import cached_property +from django.utils.six.moves import input + +TEST_DATABASE_PREFIX = 'test_' +PASSWORD = 'Im_a_lumberjack' + + +class DatabaseCreation(BaseDatabaseCreation): + + @cached_property + def _maindb_connection(self): + """ + This is analogous to other backends' `_nodb_connection` property, + which allows access to an "administrative" connection which can + be used to manage the test databases. + For Oracle, the only connection that can be used for that purpose + is the main (non-test) connection. + """ + settings_dict = settings.DATABASES[self.connection.alias] + user = settings_dict.get('SAVED_USER') or settings_dict['USER'] + password = settings_dict.get('SAVED_PASSWORD') or settings_dict['PASSWORD'] + settings_dict = settings_dict.copy() + settings_dict.update(USER=user, PASSWORD=password) + DatabaseWrapper = type(self.connection) + return DatabaseWrapper(settings_dict, alias=self.connection.alias) + + def _create_test_db(self, verbosity=1, autoclobber=False, keepdb=False): + parameters = self._get_test_db_params() + cursor = self._maindb_connection.cursor() + if self._test_database_create(): + try: + self._execute_test_db_creation(cursor, parameters, verbosity, keepdb) + except Exception as e: + # if we want to keep the db, then no need to do any of the below, + # just return and skip it all. + if keepdb: + return + sys.stderr.write("Got an error creating the test database: %s\n" % e) + if not autoclobber: + confirm = input( + "It appears the test database, %s, already exists. " + "Type 'yes' to delete it, or 'no' to cancel: " % parameters['user']) + if autoclobber or confirm == 'yes': + if verbosity >= 1: + print("Destroying old test database for alias '%s'..." % self.connection.alias) + try: + self._execute_test_db_destruction(cursor, parameters, verbosity) + except DatabaseError as e: + if 'ORA-29857' in str(e): + self._handle_objects_preventing_db_destruction(cursor, parameters, + verbosity, autoclobber) + else: + # Ran into a database error that isn't about leftover objects in the tablespace + sys.stderr.write("Got an error destroying the old test database: %s\n" % e) + sys.exit(2) + except Exception as e: + sys.stderr.write("Got an error destroying the old test database: %s\n" % e) + sys.exit(2) + try: + self._execute_test_db_creation(cursor, parameters, verbosity, keepdb) + except Exception as e: + sys.stderr.write("Got an error recreating the test database: %s\n" % e) + sys.exit(2) + else: + print("Tests cancelled.") + sys.exit(1) + + if self._test_user_create(): + if verbosity >= 1: + print("Creating test user...") + try: + self._create_test_user(cursor, parameters, verbosity, keepdb) + except Exception as e: + # If we want to keep the db, then we want to also keep the user. + if keepdb: + return + sys.stderr.write("Got an error creating the test user: %s\n" % e) + if not autoclobber: + confirm = input( + "It appears the test user, %s, already exists. Type " + "'yes' to delete it, or 'no' to cancel: " % parameters['user']) + if autoclobber or confirm == 'yes': + try: + if verbosity >= 1: + print("Destroying old test user...") + self._destroy_test_user(cursor, parameters, verbosity) + if verbosity >= 1: + print("Creating test user...") + self._create_test_user(cursor, parameters, verbosity, keepdb) + except Exception as e: + sys.stderr.write("Got an error recreating the test user: %s\n" % e) + sys.exit(2) + else: + print("Tests cancelled.") + sys.exit(1) + + self._maindb_connection.close() # done with main user -- test user and tablespaces created + self._switch_to_test_user(parameters) + return self.connection.settings_dict['NAME'] + + def _switch_to_test_user(self, parameters): + """ + Oracle doesn't have the concept of separate databases under the same user. + Thus, we use a separate user (see _create_test_db). This method is used + to switch to that user. We will need the main user again for clean-up when + we end testing, so we keep its credentials in SAVED_USER/SAVED_PASSWORD + entries in the settings dict. + """ + real_settings = settings.DATABASES[self.connection.alias] + real_settings['SAVED_USER'] = self.connection.settings_dict['SAVED_USER'] = \ + self.connection.settings_dict['USER'] + real_settings['SAVED_PASSWORD'] = self.connection.settings_dict['SAVED_PASSWORD'] = \ + self.connection.settings_dict['PASSWORD'] + real_test_settings = real_settings['TEST'] + test_settings = self.connection.settings_dict['TEST'] + real_test_settings['USER'] = real_settings['USER'] = test_settings['USER'] = \ + self.connection.settings_dict['USER'] = parameters['user'] + real_settings['PASSWORD'] = self.connection.settings_dict['PASSWORD'] = parameters['password'] + + def set_as_test_mirror(self, primary_settings_dict): + """ + Set this database up to be used in testing as a mirror of a primary database + whose settings are given + """ + self.connection.settings_dict['USER'] = primary_settings_dict['USER'] + self.connection.settings_dict['PASSWORD'] = primary_settings_dict['PASSWORD'] + + def _handle_objects_preventing_db_destruction(self, cursor, parameters, verbosity, autoclobber): + # There are objects in the test tablespace which prevent dropping it + # The easy fix is to drop the test user -- but are we allowed to do so? + print("There are objects in the old test database which prevent its destruction.") + print("If they belong to the test user, deleting the user will allow the test " + "database to be recreated.") + print("Otherwise, you will need to find and remove each of these objects, " + "or use a different tablespace.\n") + if self._test_user_create(): + if not autoclobber: + confirm = input("Type 'yes' to delete user %s: " % parameters['user']) + if autoclobber or confirm == 'yes': + try: + if verbosity >= 1: + print("Destroying old test user...") + self._destroy_test_user(cursor, parameters, verbosity) + except Exception as e: + sys.stderr.write("Got an error destroying the test user: %s\n" % e) + sys.exit(2) + try: + if verbosity >= 1: + print("Destroying old test database for alias '%s'..." % self.connection.alias) + self._execute_test_db_destruction(cursor, parameters, verbosity) + except Exception as e: + sys.stderr.write("Got an error destroying the test database: %s\n" % e) + sys.exit(2) + else: + print("Tests cancelled -- test database cannot be recreated.") + sys.exit(1) + else: + print("Django is configured to use pre-existing test user '%s'," + " and will not attempt to delete it.\n" % parameters['user']) + print("Tests cancelled -- test database cannot be recreated.") + sys.exit(1) + + def _destroy_test_db(self, test_database_name, verbosity=1): + """ + Destroy a test database, prompting the user for confirmation if the + database already exists. Returns the name of the test database created. + """ + self.connection.settings_dict['USER'] = self.connection.settings_dict['SAVED_USER'] + self.connection.settings_dict['PASSWORD'] = self.connection.settings_dict['SAVED_PASSWORD'] + self.connection.close() + parameters = self._get_test_db_params() + cursor = self._maindb_connection.cursor() + time.sleep(1) # To avoid "database is being accessed by other users" errors. + if self._test_user_create(): + if verbosity >= 1: + print('Destroying test user...') + self._destroy_test_user(cursor, parameters, verbosity) + if self._test_database_create(): + if verbosity >= 1: + print('Destroying test database tables...') + self._execute_test_db_destruction(cursor, parameters, verbosity) + self._maindb_connection.close() + + def _execute_test_db_creation(self, cursor, parameters, verbosity, keepdb=False): + if verbosity >= 2: + print("_create_test_db(): dbname = %s" % parameters['user']) + statements = [ + """CREATE TABLESPACE %(tblspace)s + DATAFILE '%(datafile)s' SIZE 20M + REUSE AUTOEXTEND ON NEXT 10M MAXSIZE %(maxsize)s + """, + """CREATE TEMPORARY TABLESPACE %(tblspace_temp)s + TEMPFILE '%(datafile_tmp)s' SIZE 20M + REUSE AUTOEXTEND ON NEXT 10M MAXSIZE %(maxsize_tmp)s + """, + ] + # Ignore "tablespace already exists" error when keepdb is on. + acceptable_ora_err = 'ORA-01543' if keepdb else None + self._execute_allow_fail_statements(cursor, statements, parameters, verbosity, acceptable_ora_err) + + def _create_test_user(self, cursor, parameters, verbosity, keepdb=False): + if verbosity >= 2: + print("_create_test_user(): username = %s" % parameters['user']) + statements = [ + """CREATE USER %(user)s + IDENTIFIED BY %(password)s + DEFAULT TABLESPACE %(tblspace)s + TEMPORARY TABLESPACE %(tblspace_temp)s + QUOTA UNLIMITED ON %(tblspace)s + """, + """GRANT CREATE SESSION, + CREATE TABLE, + CREATE SEQUENCE, + CREATE PROCEDURE, + CREATE TRIGGER + TO %(user)s""", + ] + # Ignore "user already exists" error when keepdb is on + acceptable_ora_err = 'ORA-01920' if keepdb else None + self._execute_allow_fail_statements(cursor, statements, parameters, verbosity, acceptable_ora_err) + # Most test-suites can be run without the create-view privilege. But some need it. + extra = "GRANT CREATE VIEW TO %(user)s" + success = self._execute_allow_fail_statements(cursor, [extra], parameters, verbosity, 'ORA-01031') + if not success and verbosity >= 2: + print("Failed to grant CREATE VIEW permission to test user. This may be ok.") + + def _execute_test_db_destruction(self, cursor, parameters, verbosity): + if verbosity >= 2: + print("_execute_test_db_destruction(): dbname=%s" % parameters['user']) + statements = [ + 'DROP TABLESPACE %(tblspace)s INCLUDING CONTENTS AND DATAFILES CASCADE CONSTRAINTS', + 'DROP TABLESPACE %(tblspace_temp)s INCLUDING CONTENTS AND DATAFILES CASCADE CONSTRAINTS', + ] + self._execute_statements(cursor, statements, parameters, verbosity) + + def _destroy_test_user(self, cursor, parameters, verbosity): + if verbosity >= 2: + print("_destroy_test_user(): user=%s" % parameters['user']) + print("Be patient. This can take some time...") + statements = [ + 'DROP USER %(user)s CASCADE', + ] + self._execute_statements(cursor, statements, parameters, verbosity) + + def _execute_statements(self, cursor, statements, parameters, verbosity, allow_quiet_fail=False): + for template in statements: + stmt = template % parameters + if verbosity >= 2: + print(stmt) + try: + cursor.execute(stmt) + except Exception as err: + if (not allow_quiet_fail) or verbosity >= 2: + sys.stderr.write("Failed (%s)\n" % (err)) + raise + + def _execute_allow_fail_statements(self, cursor, statements, parameters, verbosity, acceptable_ora_err): + """ + Execute statements which are allowed to fail silently if the Oracle + error code given by `acceptable_ora_err` is raised. Return True if the + statements execute without an exception, or False otherwise. + """ + try: + # Statement can fail when acceptable_ora_err is not None + allow_quiet_fail = acceptable_ora_err is not None and len(acceptable_ora_err) > 0 + self._execute_statements(cursor, statements, parameters, verbosity, allow_quiet_fail=allow_quiet_fail) + return True + except DatabaseError as err: + description = str(err) + if acceptable_ora_err is None or acceptable_ora_err not in description: + raise + return False + + def _get_test_db_params(self): + return { + 'dbname': self._test_database_name(), + 'user': self._test_database_user(), + 'password': self._test_database_passwd(), + 'tblspace': self._test_database_tblspace(), + 'tblspace_temp': self._test_database_tblspace_tmp(), + 'datafile': self._test_database_tblspace_datafile(), + 'datafile_tmp': self._test_database_tblspace_tmp_datafile(), + 'maxsize': self._test_database_tblspace_size(), + 'maxsize_tmp': self._test_database_tblspace_tmp_size(), + } + + def _test_settings_get(self, key, default=None, prefixed=None): + """ + Return a value from the test settings dict, + or a given default, + or a prefixed entry from the main settings dict + """ + settings_dict = self.connection.settings_dict + val = settings_dict['TEST'].get(key, default) + if val is None: + val = TEST_DATABASE_PREFIX + settings_dict[prefixed] + return val + + def _test_database_name(self): + return self._test_settings_get('NAME', prefixed='NAME') + + def _test_database_create(self): + return self._test_settings_get('CREATE_DB', default=True) + + def _test_user_create(self): + return self._test_settings_get('CREATE_USER', default=True) + + def _test_database_user(self): + return self._test_settings_get('USER', prefixed='USER') + + def _test_database_passwd(self): + return self._test_settings_get('PASSWORD', default=PASSWORD) + + def _test_database_tblspace(self): + return self._test_settings_get('TBLSPACE', prefixed='USER') + + def _test_database_tblspace_tmp(self): + settings_dict = self.connection.settings_dict + return settings_dict['TEST'].get('TBLSPACE_TMP', + TEST_DATABASE_PREFIX + settings_dict['USER'] + '_temp') + + def _test_database_tblspace_datafile(self): + tblspace = '%s.dbf' % self._test_database_tblspace() + return self._test_settings_get('DATAFILE', default=tblspace) + + def _test_database_tblspace_tmp_datafile(self): + tblspace = '%s.dbf' % self._test_database_tblspace_tmp() + return self._test_settings_get('DATAFILE_TMP', default=tblspace) + + def _test_database_tblspace_size(self): + return self._test_settings_get('DATAFILE_MAXSIZE', default='500M') + + def _test_database_tblspace_tmp_size(self): + return self._test_settings_get('DATAFILE_TMP_MAXSIZE', default='500M') + + def _get_test_db_name(self): + """ + We need to return the 'production' DB name to get the test DB creation + machinery to work. This isn't a great deal in this case because DB + names as handled by Django haven't real counterparts in Oracle. + """ + return self.connection.settings_dict['NAME'] + + def test_db_signature(self): + settings_dict = self.connection.settings_dict + return ( + settings_dict['HOST'], + settings_dict['PORT'], + settings_dict['ENGINE'], + settings_dict['NAME'], + self._test_database_user(), + ) + +# -*- coding: utf-8 -*- +############################################################################## +# +# OpenERP, Open Source Management Solution +# Copyright (C) 2010-Today OpenERP S.A. (). +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as +# published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with this program. If not, see . +# +############################################################################## + +{ + 'name': 'Social Network', + 'version': '1.0', + 'category': 'Social Network', + 'sequence': 2, + 'summary': 'Discussions, Mailing Lists, News', + 'description': """ +Business oriented Social Networking +=================================== +The Social Networking module provides a unified social network abstraction layer allowing applications to display a complete +communication history on documents with a fully-integrated email and message management system. + +It enables the users to read and send messages as well as emails. It also provides a feeds page combined to a subscription mechanism that allows to follow documents and to be constantly updated about recent news. + +Main Features +------------- +* Clean and renewed communication history for any OpenERP document that can act as a discussion topic +* Subscription mechanism to be updated about new messages on interesting documents +* Unified feeds page to see recent messages and activity on followed documents +* User communication through the feeds page +* Threaded discussion design on documents +* Relies on the global outgoing mail server - an integrated email management system - allowing to send emails with a configurable scheduler-based processing engine +* Includes an extensible generic email composition assistant, that can turn into a mass-mailing assistant and is capable of interpreting simple *placeholder expressions* that will be replaced with dynamic data when each email is actually sent. + """, + 'author': 'OpenERP SA', + 'website': 'https://www.odoo.com/page/enterprise-social-network', + 'depends': ['base', 'base_setup'], + 'data': [ + 'wizard/invite_view.xml', + 'wizard/mail_compose_message_view.xml', + 'mail_message_subtype.xml', + 'res_config_view.xml', + 'mail_message_view.xml', + 'mail_mail_view.xml', + 'mail_followers_view.xml', + 'mail_thread_view.xml', + 'mail_group_view.xml', + 'res_partner_view.xml', + 'data/mail_data.xml', + 'data/mail_group_data.xml', + 'security/mail_security.xml', + 'security/ir.model.access.csv', + 'mail_alias_view.xml', + 'res_users_view.xml', + 'views/mail.xml', + ], + 'demo': [ + 'data/mail_demo.xml', + 'data/mail_group_demo_data.xml', + ], + 'installable': True, + 'application': True, + 'images': [ + 'images/inbox.jpeg', + 'images/messages_form.jpeg', + 'images/messages_list.jpeg', + 'images/email.jpeg', + 'images/join_a_group.jpeg', + 'images/share_a_message.jpeg', + ], + 'qweb': [ + 'static/src/xml/mail.xml', + 'static/src/xml/mail_followers.xml', + 'static/src/xml/announcement.xml', + 'static/src/xml/suggestions.xml', + ], +} +# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: + +# Copyright 2016 The TensorFlow Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== + +"""Methods to allow dask.DataFrame.""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np + +try: + # pylint: disable=g-import-not-at-top + import dask.dataframe as dd + allowed_classes = (dd.Series, dd.DataFrame) + HAS_DASK = True +except ImportError: + HAS_DASK = False + + +def _add_to_index(df, start): + """New dask.dataframe with values added to index of each subdataframe.""" + df = df.copy() + df.index += start + return df + + +def _get_divisions(df): + """Number of rows in each sub-dataframe.""" + lengths = df.map_partitions(len).compute() + divisions = np.cumsum(lengths).tolist() + divisions.insert(0, 0) + return divisions + + +def _construct_dask_df_with_divisions(df): + """Construct the new task graph and make a new dask.dataframe around it.""" + divisions = _get_divisions(df) + # pylint: disable=protected-access + name = 'csv-index' + df._name + dsk = {(name, i): (_add_to_index, (df._name, i), divisions[i]) + for i in range(df.npartitions)} + # pylint: enable=protected-access + from toolz import merge # pylint: disable=g-import-not-at-top + if isinstance(df, dd.DataFrame): + return dd.DataFrame(merge(dsk, df.dask), name, df.columns, divisions) + elif isinstance(df, dd.Series): + return dd.Series(merge(dsk, df.dask), name, df.name, divisions) + + +def extract_dask_data(data): + """Extract data from dask.Series or dask.DataFrame for predictors.""" + if isinstance(data, allowed_classes): + return _construct_dask_df_with_divisions(data) + else: + return data + + +def extract_dask_labels(labels): + """Extract data from dask.Series for labels.""" + if isinstance(labels, dd.DataFrame): + ncol = labels.columns + elif isinstance(labels, dd.Series): + ncol = labels.name + if isinstance(labels, allowed_classes): + if len(ncol) > 1: + raise ValueError('Only one column for labels is allowed.') + return _construct_dask_df_with_divisions(labels) + else: + return labels + +import sys +import logging + +console = logging.StreamHandler() +logger = logging.getLogger() +logger.addHandler(console) +logger.setLevel(logging.ERROR) + +labels = {} +program = [] +imm_expr = [] +imm_dict = {} +imm_values = [] + +nr = 0 + +def _get_value_imm(str): + if str[0] == '#': + if phase == 1: + if not str[1:] in imm_expr: # phase 1 + imm_expr.append(str[1:]) + return 0 + else: # phase == 2 + return imm_dict[_get_value(str[1:])] # phase 2 + + # not an immediate value + return _get_value(str) + +def _get_value(str): + if str[0] == '#': + raise ValueError('Not allowed to use immediate value. Line %d' % nr) + + if str[0] == '$': + val = int(str[1:], 16) + elif str[0:2] == '0x': + val = int(str[2:], 16) + else: + try: + val = int(str) + except ValueError: + try: + val = labels[str] + except KeyError: + if phase == 2: + raise NameError('Unknown indentifier ' + str) + val = 0 + return val & 0xFFFF + +def _output_direct(data): + global pc + pc += 1 + if phase == 2: + program.append("%04X" % data) + +def add_label(line): + logger.debug("add label '%s'. Pass %d. PC = %d" % (line, phase, pc)) + split = line.split('=') + + for i in range(len(split)): + split[i] = split[i].strip() + + if (phase == 1) and (split[0] in labels): + raise NameError("Label '%s' already exists." % split[0]) + + if len(split) > 1: + labels[split[0]] = _get_value(split[1]) + else: + labels[split[0]] = pc + +########################################################################## +## +## PARSE rules for each opcode +## +########################################################################## + +def _addr(params, mnem, code): + addr = _get_value(params) + if addr > 0x3FF: + print "Error, address too large: %03x: %s $%03x" % (pc, mnem, addr) + exit() + code |= addr + logger.info("PC: %03x: %04x | %s $%03x" % (pc, code, mnem, addr)) + _output_direct(code) + return code + +def _addr_imm(params, mnem, code): + addr = _get_value_imm(params) + if addr > 0x3FF: + print "Error, address too large: %03x: %s $%03x" % (pc, mnem, addr) + exit() + code |= addr + logger.info("PC: %03x: %04x | %s $%03x" % (pc, code, mnem, addr)) + _output_direct(code) + return code + +def _data(params, mnem, code): + data = _get_value(params) + logger.info("PC: %03x: %s $%04x" % (pc, mnem, data)) + _output_direct(data) + return data + +def _block(params, mnem, code): + length = _get_value(params) + logger.info("PC: %03x: %s $%04x" % (pc, mnem, length)) + for i in range(length): + _output_direct(0) + return 0 + +def _addr_io(params, mnem, code): + addr = _get_value(params) + if addr > 0xFF: + print "Error, address too large: %03x: %s $%03x" % (pc, mnem, addr) + exit() + code |= addr + logger.info("PC: %03x: %04x | %s $%03x" % (pc, code, mnem, addr)) + _output_direct(code) + return code + +def _no_addr(params, mnem, code): + logger.info("PC: %03x: %04x | %s" % (pc, code, mnem)) + _output_direct(code) + return code + +def unknown_mnem(params): + print "Unknown mnemonic: '%s'" % params + +def dump_bram_init(): + bram = [0]*2048 + for i in range(len(program)): + inst = int(program[i], 16) + bram[2*i+0] = inst & 0xFF + bram[2*i+1] = (inst >> 8) & 0xFF + + for i in range(64): + if (i*16) >= len(program): + break + hx = '' + for j in range(31,-1,-1): + hx = hx + "%02X" % bram[i*32+j] + print " INIT_%02X => X\"%s\"," % (i, hx) + +def dump_nan_file(filename): + f = open(filename, "wb") + for i in range(len(program)): + inst = int(program[i], 16) + b1 = inst & 0xFF + b0 = (inst >> 8) & 0xFF + f.write("%c%c" % (b0, b1)) + + f.close() + + +mnemonics = { + 'LOAD' : ( _addr_imm, 0x0800 ), + 'STORE' : ( _addr, 0x8000 ), + 'LOADI' : ( _addr, 0x8800 ), + 'STORI' : ( _addr, 0x9000 ), + 'OR' : ( _addr_imm, 0x1800 ), + 'AND' : ( _addr_imm, 0x2800 ), + 'XOR' : ( _addr_imm, 0x3800 ), + 'ADD' : ( _addr_imm, 0x4800 ), + 'SUB' : ( _addr_imm, 0x5800 ), + 'CMP' : ( _addr_imm, 0x5000 ), + 'ADDC' : ( _addr_imm, 0x6800 ), + 'INP' : ( _addr_io, 0x7800 ), + 'OUTP' : ( _addr_io, 0xA000 ), + 'RET' : ( _no_addr, 0xB800 ), + 'BEQ' : ( _addr, 0xC000 ), + 'BNE' : ( _addr, 0xC800 ), + 'BMI' : ( _addr, 0xD000 ), + 'BPL' : ( _addr, 0xD800 ), + 'BRA' : ( _addr, 0XE000 ), + 'CALL' : ( _addr, 0xE800 ), + 'BCS' : ( _addr, 0xF000 ), + 'BCC' : ( _addr, 0xF800 ), + '.dw' : ( _data, 0x0000 ), + '.blk' : ( _block, 0x0000 ) + } + +def parse_lines(lines): + global nr + nr = 0 + for line in lines: + nr = nr + 1 + line = line.rstrip() + comm = line.split(';', 1) + line = comm[0] + if(line.strip() == ''): + continue + line_strip = line.strip() + if line[0] != ' ': + add_label(line.rstrip()) + if (phase == 2): + print " ", line + continue + #print "Line: '%s'" % line_strip + line_split = line_strip.split(" ", 1) + if len(line_split) == 1: + line_split.append("") + mnem = line_split[0]; + try: + (f, code) = mnemonics[mnem] + except KeyError,e: + raise NameError("Unknown Mnemonic %s in line %d" % (mnem, nr)) + try: + code = f(line_split[1].strip(), mnem, code) + except IndexError,e: + raise ValueError("Value error in line %d" % (nr,)) + if (phase == 2): + print "%03X: %04X | " % (pc-1, code),line + +def resolve_immediates(): + global pc + for imm in imm_expr: + imm_dict[_get_value(imm)] = 0; + for imm in imm_dict: + imm_dict[imm] = pc + imm_values.append(imm) + pc += 1 + #print imm_expr + #print imm_dict + #print imm_values + +if __name__ == "__main__": + inputfile = 'nano_code.nan' + outputfile = 'nano_code.b' + + if len(sys.argv)>1: + inputfile = sys.argv[1] + if len(sys.argv)>2: + outputfile = sys.argv[2] + f = open(inputfile, 'r') + lines = f.readlines() + pc = 0 + phase = 1 + logger.info("Pass 1...") + parse_lines(lines) + # print labels + resolve_immediates() + pc = 0 + phase = 2 + logger.info("Pass 2...") + logger.setLevel(logging.WARN) + parse_lines(lines) + for imm in imm_values: + logger.info("PC: %03x: .dw $%04x" % (pc, imm)) + _output_direct(imm) + + dump_bram_init() + dump_nan_file(outputfile) + +import time + +from pulsar import HttpException +from pulsar.apps import ws +from pulsar.apps.data import PubSubClient, create_store +from pulsar.utils.system import json +from pulsar.utils.string import random_string + + +def home(request): + from django.shortcuts import render_to_response + from django.template import RequestContext + return render_to_response('home.html', { + 'HOST': request.get_host() + }, RequestContext(request)) + + +class ChatClient(PubSubClient): + + def __init__(self, websocket): + self.joined = time.time() + self.websocket = websocket + self.websocket._chat_client = self + + def __call__(self, channel, message): + # The message is an encoded JSON string + self.websocket.write(message, opcode=1) + + +class Chat(ws.WS): + ''':class:`.WS` handler managing the chat application.''' + _store = None + _pubsub = None + _client = None + + def get_pubsub(self, websocket): + '''Create the pubsub handler if not already available''' + if not self._store: + cfg = websocket.cfg + self._store = create_store(cfg.data_store) + self._client = self._store.client() + self._pubsub = self._store.pubsub() + webchat = '%s:webchat' % cfg.exc_id + chatuser = '%s:chatuser' % cfg.exc_id + yield from self._pubsub.subscribe(webchat, chatuser) + return self._pubsub + + def on_open(self, websocket): + '''A new websocket connection is established. + + Add it to the set of clients listening for messages. + ''' + pubsub = yield from self.get_pubsub(websocket) + pubsub.add_client(ChatClient(websocket)) + user, _ = self.user(websocket) + users_key = 'webchatusers:%s' % websocket.cfg.exc_id + # add counter to users + registered = yield from self._client.hincrby(users_key, user, 1) + if registered == 1: + yield from self.publish(websocket, 'chatuser', 'joined') + + def on_close(self, websocket): + '''Leave the chat room + ''' + user, _ = self.user(websocket) + users_key = 'webchatusers:%s' % websocket.cfg.exc_id + registered = yield from self._client.hincrby(users_key, user, -1) + pubsub = yield from self.get_pubsub(websocket) + pubsub.remove_client(websocket._chat_client) + if not registered: + yield from self.publish(websocket, 'chatuser', 'gone') + if registered <= 0: + yield from self._client.hdel(users_key, user) + + def on_message(self, websocket, msg): + '''When a new message arrives, it publishes to all listening clients. + ''' + if msg: + lines = [] + for l in msg.split('\n'): + l = l.strip() + if l: + lines.append(l) + msg = ' '.join(lines) + if msg: + return self.publish(websocket, 'webchat', msg) + + def user(self, websocket): + user = websocket.handshake.get('django.user') + if user.is_authenticated(): + return user.username, True + else: + session = websocket.handshake.get('django.session') + user = session.get('chatuser') + if not user: + user = 'an_%s' % random_string(length=6).lower() + session['chatuser'] = user + return user, False + + def publish(self, websocket, channel, message=''): + user, authenticated = self.user(websocket) + msg = {'message': message, + 'user': user, + 'authenticated': authenticated, + 'channel': channel} + channel = '%s:%s' % (websocket.cfg.exc_id, channel) + return self._pubsub.publish(channel, json.dumps(msg)) + + +class middleware(object): + '''Django middleware for serving the Chat websocket.''' + def __init__(self): + self._web_socket = ws.WebSocket('/message', Chat()) + + def process_request(self, request): + from django.http import HttpResponse + environ = request.META + environ['django.user'] = request.user + environ['django.session'] = request.session + try: + response = self._web_socket(environ) + except HttpException as e: + return HttpResponse(status=e.status) + if response is not None: + # we have a response, this is the websocket upgrade. + # Convert to django response + resp = HttpResponse(status=response.status_code, + content_type=response.content_type) + for header, value in response.headers: + resp[header] = value + return resp + else: + environ.pop('django.user') + environ.pop('django.session') + +#! /bin/env python + +""" +This script will return the paths that distutils will use for installing +a package. To use this script, execute it the same way that you would +execute setup.py, but instead of providing 'install' or 'build' as the +command, specify 'purelib' or 'platlib' and the corresponding path +will be printed. The 'purelib' command will print the install location +for .py files, while the 'platlib' command will print the install location +of binary modules (.so or .dll). + +Written by David Gobbi, Feb 25, 2006. +""" + + +import string +import sys +import os + +def get_install_path(command, *args): + """Return the module install path, given the arguments that were + provided to setup.py. The paths that you can request are 'purelib' + for the .py installation directory and 'platlib' for the binary + module installation directory. + """ + + # convert setup args into an option dictionary + options = {} + + for arg in args: + if arg == '--': + break + if arg[0:2] == "--": + try: + option, value = string.split(arg,"=") + options[option] = value + except ValueError: + options[option] = 1 + + # check for the prefix and exec_prefix + try: + prefix = options["--prefix"] + except KeyError: + prefix = None + + try: + exec_prefix = options["--exec-prefix"] + except KeyError: + exec_prefix = prefix + + # if prefix or exec_prefix aren't set, use default system values + if prefix == None: + prefix = sys.prefix + + if exec_prefix == None: + exec_prefix = sys.exec_prefix + + # replace backslashes with slashes + if os.name != 'posix': + prefix = string.replace(prefix, os.sep, "/") + exec_prefix = string.replace(exec_prefix, os.sep, "/") + + # get rid of trailing separator + if prefix != "" and prefix[-1] == "/": + prefix = prefix[0:-1] + + if exec_prefix != "" and exec_prefix[-1] == "/": + exec_prefix = exec_prefix[0:-1] + + # check for "home" install scheme + try: + home = options["--home"] + if os.name != 'posix': + home = string.replace(home, os.sep, "/") + if home != "" and home[-1] == "/": + home = home[0:-1] + except KeyError: + home = None + + # apply "home" install scheme, but not for Windows with python < 2.4 + # (distutils didn't allow home scheme for windows until 2.4) + if home != None and not (os.name != 'posix' and sys.version < '2.4'): + purelib = home+'/lib/python' + platlib = home+'/lib/python' + scripts = home+'/bin' + data = home + elif os.name == 'posix': + ver = sys.version[0:3] + purelib = prefix+'/lib/python'+ver+'/site-packages' + platlib = exec_prefix+'/lib/python'+ver+'/site-packages' + scripts = prefix+'/bin' + data = prefix + elif sys.version < '2.2': + purelib = prefix + platlib = prefix + scripts = prefix+'/Scripts' + data = prefix + else: + purelib = prefix+'/Lib/site-packages' + platlib = prefix+'/Lib/site-packages' + scripts = prefix+'/Scripts' + data = prefix + + # allow direct setting of install directories + try: + purelib = options["--install-purelib"] + except KeyError: + pass + + try: + platlib = options["--install-platlib"] + except KeyError: + pass + + try: + scripts = options["--install-scripts"] + except KeyError: + pass + + try: + data = options["--install-data"] + except KeyError: + pass + + # return the information that was asked for + if command == 'purelib': + return purelib + elif command == 'platlib': + return platlib + elif command == 'scripts': + return scripts + elif command == 'data': + return data + + +if __name__ == "__main__": + print apply(get_install_path, sys.argv[1:]) + + +"""Default values and other various configuration for projects, +including available theme names and repository types. +""" + +import re + +from django.utils.translation import ugettext_lazy as _ + +THEME_DEFAULT = 'default' +THEME_SPHINX = 'sphinxdoc' +THEME_SCROLLS = 'scrolls' +THEME_AGOGO = 'agogo' +THEME_TRADITIONAL = 'traditional' +THEME_NATURE = 'nature' +THEME_HAIKU = 'haiku' + +DOCUMENTATION_CHOICES = ( + ('auto', _('Automatically Choose')), + ('sphinx', _('Sphinx Html')), + ('mkdocs', _('Mkdocs (Markdown)')), + ('sphinx_htmldir', _('Sphinx HtmlDir')), + ('sphinx_singlehtml', _('Sphinx Single Page HTML')), + #('sphinx_websupport2', _('Sphinx Websupport')), + #('rdoc', 'Rdoc'), +) + +DEFAULT_THEME_CHOICES = ( + # Translators: This is a name of a Sphinx theme. + (THEME_DEFAULT, _('Default')), + # Translators: This is a name of a Sphinx theme. + (THEME_SPHINX, _('Sphinx Docs')), + #(THEME_SCROLLS, 'Scrolls'), + #(THEME_AGOGO, 'Agogo'), + # Translators: This is a name of a Sphinx theme. + (THEME_TRADITIONAL, _('Traditional')), + # Translators: This is a name of a Sphinx theme. + (THEME_NATURE, _('Nature')), + # Translators: This is a name of a Sphinx theme. + (THEME_HAIKU, _('Haiku')), +) + +SAMPLE_FILES = ( + ('Installation', 'projects/samples/installation.rst.html'), + ('Getting started', 'projects/samples/getting_started.rst.html'), +) + +SCRAPE_CONF_SETTINGS = [ + 'copyright', + 'project', + 'version', + 'release', + 'source_suffix', + 'html_theme', + 'extensions', +] + +HEADING_MARKUP = ( + (1, '='), + (2, '-'), + (3, '^'), + (4, '"'), +) + +LIVE_STATUS = 1 +DELETED_STATUS = 99 + +STATUS_CHOICES = ( + (LIVE_STATUS, _('Live')), + (DELETED_STATUS, _('Deleted')), +) + +REPO_CHOICES = ( + ('git', _('Git')), + ('svn', _('Subversion')), + ('hg', _('Mercurial')), + ('bzr', _('Bazaar')), +) + +PUBLIC = 'public' +PROTECTED = 'protected' +PRIVATE = 'private' + +PRIVACY_CHOICES = ( + (PUBLIC, _('Public')), + (PROTECTED, _('Protected')), + (PRIVATE, _('Private')), +) + +IMPORTANT_VERSION_FILTERS = { + 'slug': 'important' +} + +# in the future this constant can be replaced with a implementation that +# detect all available Python interpreters in the fly (Maybe using +# update-alternatives linux tool family?). +PYTHON_CHOICES = ( + ('python', _('CPython 2.x')), + ('python3', _('CPython 3.x')), +) + +# Via http://sphinx-doc.org/latest/config.html#confval-language +# Languages supported for the lang_slug in the URL +# Translations for builtin Sphinx messages only available for a subset of these +LANGUAGES = ( + ("aa", "Afar"), + ("ab", "Abkhaz"), + ("af", "Afrikaans"), + ("am", "Amharic"), + ("ar", "Arabic"), + ("as", "Assamese"), + ("ay", "Aymara"), + ("az", "Azerbaijani"), + ("ba", "Bashkir"), + ("be", "Belarusian"), + ("bg", "Bulgarian"), + ("bh", "Bihari"), + ("bi", "Bislama"), + ("bn", "Bengali"), + ("bo", "Tibetan"), + ("br", "Breton"), + ("ca", "Catalan"), + ("co", "Corsican"), + ("cs", "Czech"), + ("cy", "Welsh"), + ("da", "Danish"), + ("de", "German"), + ("dz", "Dzongkha"), + ("el", "Greek"), + ("en", "English"), + ("eo", "Esperanto"), + ("es", "Spanish"), + ("et", "Estonian"), + ("eu", "Basque"), + ("fa", "Iranian"), + ("fi", "Finnish"), + ("fj", "Fijian"), + ("fo", "Faroese"), + ("fr", "French"), + ("fy", "Western Frisian"), + ("ga", "Irish"), + ("gd", "Scottish Gaelic"), + ("gl", "Galician"), + ("gn", "Guarani"), + ("gu", "Gujarati"), + ("ha", "Hausa"), + ("hi", "Hindi"), + ("he", "Hebrew"), + ("hr", "Croatian"), + ("hu", "Hungarian"), + ("hy", "Armenian"), + ("ia", "Interlingua"), + ("id", "Indonesian"), + ("ie", "Interlingue"), + ("ik", "Inupiaq"), + ("is", "Icelandic"), + ("it", "Italian"), + ("iu", "Inuktitut"), + ("ja", "Japanese"), + ("jv", "Javanese"), + ("ka", "Georgian"), + ("kk", "Kazakh"), + ("kl", "Kalaallisut"), + ("km", "Khmer"), + ("kn", "Kannada"), + ("ko", "Korean"), + ("ks", "Kashmiri"), + ("ku", "Kurdish"), + ("ky", "Kyrgyz"), + ("la", "Latin"), + ("ln", "Lingala"), + ("lo", "Lao"), + ("lt", "Lithuanian"), + ("lv", "Latvian"), + ("mg", "Malagasy"), + ("mi", "Maori"), + ("mk", "Macedonian"), + ("ml", "Malayalam"), + ("mn", "Mongolian"), + ("mr", "Marathi"), + ("ms", "Malay"), + ("mt", "Maltese"), + ("my", "Burmese"), + ("na", "Nauru"), + ("ne", "Nepali"), + ("nl", "Dutch"), + ("no", "Norwegian"), + ("oc", "Occitan"), + ("om", "Oromo"), + ("or", "Oriya"), + ("pa", "Panjabi"), + ("pl", "Polish"), + ("ps", "Pashto"), + ("pt", "Portuguese"), + ("qu", "Quechua"), + ("rm", "Romansh"), + ("rn", "Kirundi"), + ("ro", "Romanian"), + ("ru", "Russian"), + ("rw", "Kinyarwanda"), + ("sa", "Sanskrit"), + ("sd", "Sindhi"), + ("sg", "Sango"), + ("si", "Sinhala"), + ("sk", "Slovak"), + ("sl", "Slovenian"), + ("sm", "Samoan"), + ("sn", "Shona"), + ("so", "Somali"), + ("sq", "Albanian"), + ("sr", "Serbian"), + ("ss", "Swati"), + ("st", "Southern Sotho"), + ("su", "Sudanese"), + ("sv", "Swedish"), + ("sw", "Swahili"), + ("ta", "Tamil"), + ("te", "Telugu"), + ("tg", "Tajik"), + ("th", "Thai"), + ("ti", "Tigrinya"), + ("tk", "Turkmen"), + ("tl", "Tagalog"), + ("tn", "Tswana"), + ("to", "Tonga"), + ("tr", "Turkish"), + ("ts", "Tsonga"), + ("tt", "Tatar"), + ("tw", "Twi"), + ("ug", "Uyghur"), + ("uk", "Ukrainian"), + ("ur", "Urdu"), + ("uz", "Uzbek"), + ("vi", "Vietnamese"), + ("vo", "Volapuk"), + ("wo", "Wolof"), + ("xh", "Xhosa"), + ("yi", "Yiddish"), + ("yo", "Yoruba"), + ("za", "Zhuang"), + ("zh", "Chinese"), + ("zu", "Zulu"), + # Try these to test our non-2 letter language support + ("nb_NO", "Norwegian Bokmal"), + ("pt_BR", "Brazilian Portuguese"), + ("uk_UA", "Ukrainian"), + ("zh_CN", "Simplified Chinese"), + ("zh_TW", "Traditional Chinese"), +) + +LANGUAGES_REGEX = "|".join( + [re.escape(code[0]) for code in LANGUAGES] +) + +PROGRAMMING_LANGUAGES = ( + ("words", "Only Words"), + ("py", "Python"), + ("js", "Javascript"), + ("php", "PHP"), + ("ruby", "Ruby"), + ("perl", "Perl"), + ("java", "Java"), + ("go", "Go"), + ("julia", "Julia"), + ("c", "C"), + ("csharp", "C#"), + ("cpp", "C++"), + ("objc", "Objective-C"), + ("other", "Other"), +) + +LOG_TEMPLATE = u"(Build) [{project}:{version}] {msg}" + +PROJECT_PK_REGEX = '(?:[-\w]+)' +PROJECT_SLUG_REGEX = '(?:[-\w]+)' + +from testsuite.base_test import BaseTest +from core import modules +from core.sessions import SessionURL +from testfixtures import log_capture +from core import messages +import logging +import config +import os + +class FileBzip(BaseTest): + + def setUp(self): + session = SessionURL(self.url, self.password, volatile = True) + modules.load_modules(session) + + # Create and bzip2 binary files for the test + self.string = [ + '\\xe0\\xf5\\xfe\\xe2\\xbd\\x0c\\xbc\\x9b\\xa0\\x8f\\xed?\\xa1\\xe1', + '\\x01\\x00\\x00\\x00\\x00\\x00\\x00\\x06\\x00\\x00\\x00' + ] + self.uncompressed = [ + os.path.join(config.script_folder, 'binfile0'), + os.path.join(config.script_folder, 'binfile1') + ] + self.compressed = [ + os.path.join(config.script_folder, 'binfile0.bz2'), + os.path.join(config.script_folder, 'binfile1.bz2') + ] + + for index in range(0, len(self.string)): + self.check_call(config.cmd_env_content_s_to_s % (self.string[index], self.uncompressed[index])) + self.check_call(config.cmd_env_bzip2_s % (self.uncompressed[index])) + + self.run_argv = modules.loaded['file_bzip2'].run_argv + + def tearDown(self): + + for f in self.uncompressed + self.compressed: + self.check_call(config.cmd_env_remove_s % (f)) + + + def test_compress_decompress(self): + + # Decompress and check test file + self.assertTrue(self.run_argv(["--decompress", self.compressed[0]])); + self.assertEqual( + self.check_output(config.cmd_env_print_repr_s % self.uncompressed[0]), + self.string[0] + ) + + # Let's re-compress it, and decompress and check again + self.assertTrue(self.run_argv([self.uncompressed[0]])) + self.assertTrue(self.run_argv(["--decompress", self.compressed[0]])); + self.assertEqual( + self.check_output(config.cmd_env_print_repr_s % self.uncompressed[0]), + self.string[0] + ) + + # Recompress it keeping the original file + self.assertTrue(self.run_argv([self.uncompressed[0], '--keep'])) + # Check the existance of the original file and remove it + self.check_call(config.cmd_env_stat_permissions_s % self.uncompressed[0]) + self.check_call(config.cmd_env_remove_s % self.uncompressed[0]) + + # Do the same check + self.assertTrue(self.run_argv(["--decompress", self.compressed[0]])); + self.assertEqual( + self.check_output(config.cmd_env_print_repr_s % self.uncompressed[0]), + self.string[0] + ) + + def test_compress_decompress_multiple(self): + + for index in range(0, len(self.compressed)): + + # Decompress and check test file + self.assertTrue(self.run_argv(["--decompress", self.compressed[index]])); + self.assertEqual( + self.check_output(config.cmd_env_print_repr_s % self.uncompressed[index]), + self.string[index] + ) + + # Let's re-compress it, and decompress and check again + self.assertTrue(self.run_argv([self.uncompressed[index]])) + self.assertTrue(self.run_argv(["--decompress", self.compressed[index]])); + self.assertEqual( + self.check_output(config.cmd_env_print_repr_s % self.uncompressed[index]), + self.string[index] + ) + + + @log_capture() + def test_already_exists(self, log_captured): + + # Decompress keeping it and check test file + self.assertTrue(self.run_argv(["--decompress", self.compressed[0], '--keep'])); + self.assertEqual( + self.check_output(config.cmd_env_print_repr_s % self.uncompressed[0]), + self.string[0] + ) + + # Do it again and trigger that the file decompressed already exists + self.assertIsNone(self.run_argv(["--decompress", self.compressed[0]])); + self.assertEqual(log_captured.records[-1].msg, + "File '%s' already exists, skipping decompressing" % self.uncompressed[0]) + + # Compress and trigger that the file compressed already exists + self.assertIsNone(self.run_argv([self.uncompressed[0]])); + self.assertEqual(log_captured.records[-1].msg, + "File '%s' already exists, skipping compressing" % self.compressed[0]) + + @log_capture() + def test_wrong_ext(self, log_captured): + + # Decompress it and check test file + self.assertTrue(self.run_argv(["--decompress", self.compressed[0]])); + self.assertEqual( + self.check_output(config.cmd_env_print_repr_s % self.uncompressed[0]), + self.string[0] + ) + + # Decompress the decompressed, wrong ext + self.assertIsNone(self.run_argv(["--decompress", self.uncompressed[0]])); + self.assertEqual(log_captured.records[-1].msg, + "Unknown suffix, skipping decompressing") + + @log_capture() + def test_unexistant(self, log_captured): + + # Decompress it and check test file + self.assertIsNone(self.run_argv(["--decompress", 'bogus'])); + self.assertEqual(log_captured.records[-1].msg, + "Skipping file '%s', check existance and permission" % 'bogus') + +# -*- coding: utf-8 -*-s +import numpy as np +from calendar_calc import day_number_to_date +from netCDF4 import Dataset, date2num +import pdb +import create_timeseries as cts + +resolution_file = Dataset('/scratch/sit204/ozone_cmip5_files/Ozone_CMIP5_ACC_SPARC_1990-1999_T3M_O3.nc', 'r') + +lons = resolution_file.variables['lon'][:] +lats = resolution_file.variables['lat'][:] + +ozone_in = resolution_file.variables['O3'][:] + +zm_ozone_in = np.mean(ozone_in,axis=3) + +lons = [0.] +lonb_temp = [0., 360.] + +latb_temp=np.zeros(lats.shape[0]+1) + +for tick in np.arange(1,lats.shape[0]): + latb_temp[tick]=(lats[tick-1]+lats[tick])/2. + +latb_temp[0]=-90. +latb_temp[-1]=90. + +latbs=latb_temp +lonbs=lonb_temp + +lats[0]=-90.+0.01 +lats[-1]=90.-0.01 + + +nlon=1#lons.shape[0] +nlat=lats.shape[0] + +nlonb=len(lonbs) +nlatb=latbs.shape[0] + +p_full = resolution_file.variables['plev'][:] + +time_arr = resolution_file.variables['time'][:] + +date_arr=np.mod((time_arr-time_arr[0]),12) +date_arr_new=np.zeros(12) + +ozone_new=np.zeros((12,p_full.shape[0],nlat)) + +mol_to_kg_factor=(3.*16.)/(28.97) + +#time average ozone by month +for month in np.arange(0,12): + time_idx=date_arr==month + ozone_new[month,:,:]=np.mean(zm_ozone_in[time_idx,:,:],axis=0)*(mol_to_kg_factor) + date_arr_new[month]=np.mean(date_arr[time_idx]) + +p_half_temp=np.zeros(p_full.shape[0]+1) + +p_half_temp[0]=1200. + +for tick in np.arange(1,p_full.shape[0]): + + p_half_temp[tick]=(p_full[tick-1]+p_full[tick])/2. + + +p_half=p_half_temp + +time_arr=(date_arr_new+0.5)*30. + + +#DO FLIPPING + +p_full=p_full[::-1] +p_half=p_half[::-1] + +ozone_new=ozone_new[:,::-1,:] + + +#Find grid and time numbers + +nlon=len(lons) +nlat=len(lats) + +nlonb=len(lonbs) +nlatb=len(latbs) + +npfull=len(p_full) +nphalf=len(p_half) + +ntime=len(time_arr) + + +#Output it to a netcdf file. +file_name='ozone_1990_cmip5_test.nc' +variable_name='ozone_1990_cmip5' + +number_dict={} +number_dict['nlat']=nlat +number_dict['nlon']=nlon +number_dict['nlatb']=nlatb +number_dict['nlonb']=nlonb +number_dict['npfull']=npfull +number_dict['nphalf']=nphalf +number_dict['ntime']=ntime + +time_units='days since 0000-01-01 00:00:00.0' + +cts.output_to_file(ozone_new,lats,lons,latbs,lonbs,p_full,p_half,time_arr,time_units,file_name,variable_name,number_dict) + + +""" +This is the default template for our main set of AWS servers. +""" + +# We intentionally define lots of variables that aren't used, and +# want to import all variables from base settings files +# pylint: disable=wildcard-import, unused-wildcard-import + +# Pylint gets confused by path.py instances, which report themselves as class +# objects. As a result, pylint applies the wrong regex in validating names, +# and throws spurious errors. Therefore, we disable invalid-name checking. +# pylint: disable=invalid-name + +import json + +from .common import * + +from openedx.core.lib.logsettings import get_logger_config +import os + +from path import Path as path +from xmodule.modulestore.modulestore_settings import convert_module_store_setting_if_needed + +# SERVICE_VARIANT specifies name of the variant used, which decides what JSON +# configuration files are read during startup. +SERVICE_VARIANT = os.environ.get('SERVICE_VARIANT', None) + +# CONFIG_ROOT specifies the directory where the JSON configuration +# files are expected to be found. If not specified, use the project +# directory. +CONFIG_ROOT = path(os.environ.get('CONFIG_ROOT', ENV_ROOT)) + +# CONFIG_PREFIX specifies the prefix of the JSON configuration files, +# based on the service variant. If no variant is use, don't use a +# prefix. +CONFIG_PREFIX = SERVICE_VARIANT + "." if SERVICE_VARIANT else "" + + +############### ALWAYS THE SAME ################################ + +DEBUG = False + +EMAIL_BACKEND = 'django_ses.SESBackend' +SESSION_ENGINE = 'django.contrib.sessions.backends.cache' + +# IMPORTANT: With this enabled, the server must always be behind a proxy that +# strips the header HTTP_X_FORWARDED_PROTO from client requests. Otherwise, +# a user can fool our server into thinking it was an https connection. +# See +# https://docs.djangoproject.com/en/dev/ref/settings/#secure-proxy-ssl-header +# for other warnings. +SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https') + +###################################### CELERY ################################ + +# Don't use a connection pool, since connections are dropped by ELB. +BROKER_POOL_LIMIT = 0 +BROKER_CONNECTION_TIMEOUT = 1 + +# For the Result Store, use the django cache named 'celery' +CELERY_RESULT_BACKEND = 'djcelery.backends.cache:CacheBackend' + +# When the broker is behind an ELB, use a heartbeat to refresh the +# connection and to detect if it has been dropped. +BROKER_HEARTBEAT = 10.0 +BROKER_HEARTBEAT_CHECKRATE = 2 + +# Each worker should only fetch one message at a time +CELERYD_PREFETCH_MULTIPLIER = 1 + +# Rename the exchange and queues for each variant + +QUEUE_VARIANT = CONFIG_PREFIX.lower() + +CELERY_DEFAULT_EXCHANGE = 'edx.{0}core'.format(QUEUE_VARIANT) + +HIGH_PRIORITY_QUEUE = 'edx.{0}core.high'.format(QUEUE_VARIANT) +DEFAULT_PRIORITY_QUEUE = 'edx.{0}core.default'.format(QUEUE_VARIANT) +LOW_PRIORITY_QUEUE = 'edx.{0}core.low'.format(QUEUE_VARIANT) + +CELERY_DEFAULT_QUEUE = DEFAULT_PRIORITY_QUEUE +CELERY_DEFAULT_ROUTING_KEY = DEFAULT_PRIORITY_QUEUE + +CELERY_QUEUES = { + HIGH_PRIORITY_QUEUE: {}, + LOW_PRIORITY_QUEUE: {}, + DEFAULT_PRIORITY_QUEUE: {} +} + +############# NON-SECURE ENV CONFIG ############################## +# Things like server locations, ports, etc. +with open(CONFIG_ROOT / CONFIG_PREFIX + "env.json") as env_file: + ENV_TOKENS = json.load(env_file) + +# STATIC_URL_BASE specifies the base url to use for static files +STATIC_URL_BASE = ENV_TOKENS.get('STATIC_URL_BASE', None) +if STATIC_URL_BASE: + # collectstatic will fail if STATIC_URL is a unicode string + STATIC_URL = STATIC_URL_BASE.encode('ascii') + if not STATIC_URL.endswith("/"): + STATIC_URL += "/" + STATIC_URL += EDX_PLATFORM_REVISION + "/" + +# GITHUB_REPO_ROOT is the base directory +# for course data +GITHUB_REPO_ROOT = ENV_TOKENS.get('GITHUB_REPO_ROOT', GITHUB_REPO_ROOT) + +# STATIC_ROOT specifies the directory where static files are +# collected + +STATIC_ROOT_BASE = ENV_TOKENS.get('STATIC_ROOT_BASE', None) +if STATIC_ROOT_BASE: + STATIC_ROOT = path(STATIC_ROOT_BASE) / EDX_PLATFORM_REVISION + +EMAIL_BACKEND = ENV_TOKENS.get('EMAIL_BACKEND', EMAIL_BACKEND) +EMAIL_FILE_PATH = ENV_TOKENS.get('EMAIL_FILE_PATH', None) + +EMAIL_HOST = ENV_TOKENS.get('EMAIL_HOST', EMAIL_HOST) +EMAIL_PORT = ENV_TOKENS.get('EMAIL_PORT', EMAIL_PORT) +EMAIL_USE_TLS = ENV_TOKENS.get('EMAIL_USE_TLS', EMAIL_USE_TLS) + +LMS_BASE = ENV_TOKENS.get('LMS_BASE') +# Note that FEATURES['PREVIEW_LMS_BASE'] gets read in from the environment file. + +SITE_NAME = ENV_TOKENS['SITE_NAME'] + +ALLOWED_HOSTS = [ + # TODO: bbeggs remove this before prod, temp fix to get load testing running + "*", + ENV_TOKENS.get('CMS_BASE') +] + +LOG_DIR = ENV_TOKENS['LOG_DIR'] + +CACHES = ENV_TOKENS['CACHES'] +# Cache used for location mapping -- called many times with the same key/value +# in a given request. +if 'loc_cache' not in CACHES: + CACHES['loc_cache'] = { + 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', + 'LOCATION': 'edx_location_mem_cache', + } + +SESSION_COOKIE_DOMAIN = ENV_TOKENS.get('SESSION_COOKIE_DOMAIN') +SESSION_COOKIE_HTTPONLY = ENV_TOKENS.get('SESSION_COOKIE_HTTPONLY', True) +SESSION_ENGINE = ENV_TOKENS.get('SESSION_ENGINE', SESSION_ENGINE) +SESSION_COOKIE_SECURE = ENV_TOKENS.get('SESSION_COOKIE_SECURE', SESSION_COOKIE_SECURE) +SESSION_SAVE_EVERY_REQUEST = ENV_TOKENS.get('SESSION_SAVE_EVERY_REQUEST', SESSION_SAVE_EVERY_REQUEST) + +# social sharing settings +SOCIAL_SHARING_SETTINGS = ENV_TOKENS.get('SOCIAL_SHARING_SETTINGS', SOCIAL_SHARING_SETTINGS) + +# allow for environments to specify what cookie name our login subsystem should use +# this is to fix a bug regarding simultaneous logins between edx.org and edge.edx.org which can +# happen with some browsers (e.g. Firefox) +if ENV_TOKENS.get('SESSION_COOKIE_NAME', None): + # NOTE, there's a bug in Django (http://bugs.python.org/issue18012) which necessitates this being a str() + SESSION_COOKIE_NAME = str(ENV_TOKENS.get('SESSION_COOKIE_NAME')) + +# Set the names of cookies shared with the marketing site +# These have the same cookie domain as the session, which in production +# usually includes subdomains. +EDXMKTG_LOGGED_IN_COOKIE_NAME = ENV_TOKENS.get('EDXMKTG_LOGGED_IN_COOKIE_NAME', EDXMKTG_LOGGED_IN_COOKIE_NAME) +EDXMKTG_USER_INFO_COOKIE_NAME = ENV_TOKENS.get('EDXMKTG_USER_INFO_COOKIE_NAME', EDXMKTG_USER_INFO_COOKIE_NAME) + +#Email overrides +DEFAULT_FROM_EMAIL = ENV_TOKENS.get('DEFAULT_FROM_EMAIL', DEFAULT_FROM_EMAIL) +DEFAULT_FEEDBACK_EMAIL = ENV_TOKENS.get('DEFAULT_FEEDBACK_EMAIL', DEFAULT_FEEDBACK_EMAIL) +ADMINS = ENV_TOKENS.get('ADMINS', ADMINS) +SERVER_EMAIL = ENV_TOKENS.get('SERVER_EMAIL', SERVER_EMAIL) +MKTG_URLS = ENV_TOKENS.get('MKTG_URLS', MKTG_URLS) +TECH_SUPPORT_EMAIL = ENV_TOKENS.get('TECH_SUPPORT_EMAIL', TECH_SUPPORT_EMAIL) + +COURSES_WITH_UNSAFE_CODE = ENV_TOKENS.get("COURSES_WITH_UNSAFE_CODE", []) + +ASSET_IGNORE_REGEX = ENV_TOKENS.get('ASSET_IGNORE_REGEX', ASSET_IGNORE_REGEX) + +# Theme overrides +THEME_NAME = ENV_TOKENS.get('THEME_NAME', None) + +#Timezone overrides +TIME_ZONE = ENV_TOKENS.get('TIME_ZONE', TIME_ZONE) + +# Push to LMS overrides +GIT_REPO_EXPORT_DIR = ENV_TOKENS.get('GIT_REPO_EXPORT_DIR', '/edx/var/edxapp/export_course_repos') + +# Translation overrides +LANGUAGES = ENV_TOKENS.get('LANGUAGES', LANGUAGES) +LANGUAGE_CODE = ENV_TOKENS.get('LANGUAGE_CODE', LANGUAGE_CODE) +USE_I18N = ENV_TOKENS.get('USE_I18N', USE_I18N) + +ENV_FEATURES = ENV_TOKENS.get('FEATURES', {}) +for feature, value in ENV_FEATURES.items(): + FEATURES[feature] = value + +# Additional installed apps +for app in ENV_TOKENS.get('ADDL_INSTALLED_APPS', []): + INSTALLED_APPS += (app,) + +WIKI_ENABLED = ENV_TOKENS.get('WIKI_ENABLED', WIKI_ENABLED) + +LOGGING = get_logger_config(LOG_DIR, + logging_env=ENV_TOKENS['LOGGING_ENV'], + debug=False, + service_variant=SERVICE_VARIANT) + +#theming start: +PLATFORM_NAME = ENV_TOKENS.get('PLATFORM_NAME', 'edX') +STUDIO_NAME = ENV_TOKENS.get('STUDIO_NAME', 'edX Studio') +STUDIO_SHORT_NAME = ENV_TOKENS.get('STUDIO_SHORT_NAME', 'Studio') + +# Event Tracking +if "TRACKING_IGNORE_URL_PATTERNS" in ENV_TOKENS: + TRACKING_IGNORE_URL_PATTERNS = ENV_TOKENS.get("TRACKING_IGNORE_URL_PATTERNS") + +# Django CAS external authentication settings +CAS_EXTRA_LOGIN_PARAMS = ENV_TOKENS.get("CAS_EXTRA_LOGIN_PARAMS", None) +if FEATURES.get('AUTH_USE_CAS'): + CAS_SERVER_URL = ENV_TOKENS.get("CAS_SERVER_URL", None) + AUTHENTICATION_BACKENDS = ( + 'django.contrib.auth.backends.ModelBackend', + 'django_cas.backends.CASBackend', + ) + INSTALLED_APPS += ('django_cas',) + MIDDLEWARE_CLASSES += ('django_cas.middleware.CASMiddleware',) + CAS_ATTRIBUTE_CALLBACK = ENV_TOKENS.get('CAS_ATTRIBUTE_CALLBACK', None) + if CAS_ATTRIBUTE_CALLBACK: + import importlib + CAS_USER_DETAILS_RESOLVER = getattr( + importlib.import_module(CAS_ATTRIBUTE_CALLBACK['module']), + CAS_ATTRIBUTE_CALLBACK['function'] + ) + + +################ SECURE AUTH ITEMS ############################### +# Secret things: passwords, access keys, etc. +with open(CONFIG_ROOT / CONFIG_PREFIX + "auth.json") as auth_file: + AUTH_TOKENS = json.load(auth_file) + +############### XBlock filesystem field config ########## +if 'DJFS' in AUTH_TOKENS and AUTH_TOKENS['DJFS'] is not None: + DJFS = AUTH_TOKENS['DJFS'] + if 'url_root' in DJFS: + DJFS['url_root'] = DJFS['url_root'].format(platform_revision=EDX_PLATFORM_REVISION) + +EMAIL_HOST_USER = AUTH_TOKENS.get('EMAIL_HOST_USER', EMAIL_HOST_USER) +EMAIL_HOST_PASSWORD = AUTH_TOKENS.get('EMAIL_HOST_PASSWORD', EMAIL_HOST_PASSWORD) + +# Note that this is the Studio key for Segment. There is a separate key for the LMS. +CMS_SEGMENT_KEY = AUTH_TOKENS.get('SEGMENT_KEY') + +SECRET_KEY = AUTH_TOKENS['SECRET_KEY'] + +AWS_ACCESS_KEY_ID = AUTH_TOKENS["AWS_ACCESS_KEY_ID"] +if AWS_ACCESS_KEY_ID == "": + AWS_ACCESS_KEY_ID = None + +AWS_SECRET_ACCESS_KEY = AUTH_TOKENS["AWS_SECRET_ACCESS_KEY"] +if AWS_SECRET_ACCESS_KEY == "": + AWS_SECRET_ACCESS_KEY = None + +if AUTH_TOKENS.get('DEFAULT_FILE_STORAGE'): + DEFAULT_FILE_STORAGE = AUTH_TOKENS.get('DEFAULT_FILE_STORAGE') +elif AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY: + DEFAULT_FILE_STORAGE = 'storages.backends.s3boto.S3BotoStorage' +else: + DEFAULT_FILE_STORAGE = 'django.core.files.storage.FileSystemStorage' + +DATABASES = AUTH_TOKENS['DATABASES'] + +# Enable automatic transaction management on all databases +# https://docs.djangoproject.com/en/1.8/topics/db/transactions/#tying-transactions-to-http-requests +# This needs to be true for all databases +for database_name in DATABASES: + DATABASES[database_name]['ATOMIC_REQUESTS'] = True + +MODULESTORE = convert_module_store_setting_if_needed(AUTH_TOKENS.get('MODULESTORE', MODULESTORE)) +CONTENTSTORE = AUTH_TOKENS['CONTENTSTORE'] +DOC_STORE_CONFIG = AUTH_TOKENS['DOC_STORE_CONFIG'] +# Datadog for events! +DATADOG = AUTH_TOKENS.get("DATADOG", {}) +DATADOG.update(ENV_TOKENS.get("DATADOG", {})) + +# TODO: deprecated (compatibility with previous settings) +if 'DATADOG_API' in AUTH_TOKENS: + DATADOG['api_key'] = AUTH_TOKENS['DATADOG_API'] + +# Celery Broker +CELERY_ALWAYS_EAGER = ENV_TOKENS.get("CELERY_ALWAYS_EAGER", False) +CELERY_BROKER_TRANSPORT = ENV_TOKENS.get("CELERY_BROKER_TRANSPORT", "") +CELERY_BROKER_HOSTNAME = ENV_TOKENS.get("CELERY_BROKER_HOSTNAME", "") +CELERY_BROKER_VHOST = ENV_TOKENS.get("CELERY_BROKER_VHOST", "") +CELERY_BROKER_USER = AUTH_TOKENS.get("CELERY_BROKER_USER", "") +CELERY_BROKER_PASSWORD = AUTH_TOKENS.get("CELERY_BROKER_PASSWORD", "") + +BROKER_URL = "{0}://{1}:{2}@{3}/{4}".format(CELERY_BROKER_TRANSPORT, + CELERY_BROKER_USER, + CELERY_BROKER_PASSWORD, + CELERY_BROKER_HOSTNAME, + CELERY_BROKER_VHOST) + +# Event tracking +TRACKING_BACKENDS.update(AUTH_TOKENS.get("TRACKING_BACKENDS", {})) +EVENT_TRACKING_BACKENDS['tracking_logs']['OPTIONS']['backends'].update(AUTH_TOKENS.get("EVENT_TRACKING_BACKENDS", {})) +EVENT_TRACKING_BACKENDS['segmentio']['OPTIONS']['processors'][0]['OPTIONS']['whitelist'].extend( + AUTH_TOKENS.get("EVENT_TRACKING_SEGMENTIO_EMIT_WHITELIST", [])) + +SUBDOMAIN_BRANDING = ENV_TOKENS.get('SUBDOMAIN_BRANDING', {}) +VIRTUAL_UNIVERSITIES = ENV_TOKENS.get('VIRTUAL_UNIVERSITIES', []) + +##### ACCOUNT LOCKOUT DEFAULT PARAMETERS ##### +MAX_FAILED_LOGIN_ATTEMPTS_ALLOWED = ENV_TOKENS.get("MAX_FAILED_LOGIN_ATTEMPTS_ALLOWED", 5) +MAX_FAILED_LOGIN_ATTEMPTS_LOCKOUT_PERIOD_SECS = ENV_TOKENS.get("MAX_FAILED_LOGIN_ATTEMPTS_LOCKOUT_PERIOD_SECS", 15 * 60) + +MICROSITE_CONFIGURATION = ENV_TOKENS.get('MICROSITE_CONFIGURATION', {}) +MICROSITE_ROOT_DIR = path(ENV_TOKENS.get('MICROSITE_ROOT_DIR', '')) + +#### PASSWORD POLICY SETTINGS ##### +PASSWORD_MIN_LENGTH = ENV_TOKENS.get("PASSWORD_MIN_LENGTH") +PASSWORD_MAX_LENGTH = ENV_TOKENS.get("PASSWORD_MAX_LENGTH") +PASSWORD_COMPLEXITY = ENV_TOKENS.get("PASSWORD_COMPLEXITY", {}) +PASSWORD_DICTIONARY_EDIT_DISTANCE_THRESHOLD = ENV_TOKENS.get("PASSWORD_DICTIONARY_EDIT_DISTANCE_THRESHOLD") +PASSWORD_DICTIONARY = ENV_TOKENS.get("PASSWORD_DICTIONARY", []) + +### INACTIVITY SETTINGS #### +SESSION_INACTIVITY_TIMEOUT_IN_SECONDS = AUTH_TOKENS.get("SESSION_INACTIVITY_TIMEOUT_IN_SECONDS") + +##### X-Frame-Options response header settings ##### +X_FRAME_OPTIONS = ENV_TOKENS.get('X_FRAME_OPTIONS', X_FRAME_OPTIONS) + +##### ADVANCED_SECURITY_CONFIG ##### +ADVANCED_SECURITY_CONFIG = ENV_TOKENS.get('ADVANCED_SECURITY_CONFIG', {}) + +################ ADVANCED COMPONENT/PROBLEM TYPES ############### + +ADVANCED_COMPONENT_TYPES = ENV_TOKENS.get('ADVANCED_COMPONENT_TYPES', ADVANCED_COMPONENT_TYPES) +ADVANCED_PROBLEM_TYPES = ENV_TOKENS.get('ADVANCED_PROBLEM_TYPES', ADVANCED_PROBLEM_TYPES) +DEPRECATED_ADVANCED_COMPONENT_TYPES = ENV_TOKENS.get( + 'DEPRECATED_ADVANCED_COMPONENT_TYPES', DEPRECATED_ADVANCED_COMPONENT_TYPES +) + +################ VIDEO UPLOAD PIPELINE ############### + +VIDEO_UPLOAD_PIPELINE = ENV_TOKENS.get('VIDEO_UPLOAD_PIPELINE', VIDEO_UPLOAD_PIPELINE) + +################ PUSH NOTIFICATIONS ############### + +PARSE_KEYS = AUTH_TOKENS.get("PARSE_KEYS", {}) + + +# Video Caching. Pairing country codes with CDN URLs. +# Example: {'CN': 'http://api.xuetangx.com/edx/video?s3_url='} +VIDEO_CDN_URL = ENV_TOKENS.get('VIDEO_CDN_URL', {}) + +if FEATURES['ENABLE_COURSEWARE_INDEX'] or FEATURES['ENABLE_LIBRARY_INDEX']: + # Use ElasticSearch for the search engine + SEARCH_ENGINE = "search.elastic.ElasticSearchEngine" + +XBLOCK_SETTINGS = ENV_TOKENS.get('XBLOCK_SETTINGS', {}) +XBLOCK_SETTINGS.setdefault("VideoDescriptor", {})["licensing_enabled"] = FEATURES.get("LICENSING", False) +XBLOCK_SETTINGS.setdefault("VideoModule", {})['YOUTUBE_API_KEY'] = AUTH_TOKENS.get('YOUTUBE_API_KEY', YOUTUBE_API_KEY) + +################# PROCTORING CONFIGURATION ################## + +PROCTORING_BACKEND_PROVIDER = AUTH_TOKENS.get("PROCTORING_BACKEND_PROVIDER", PROCTORING_BACKEND_PROVIDER) +PROCTORING_SETTINGS = ENV_TOKENS.get("PROCTORING_SETTINGS", PROCTORING_SETTINGS) + +# Copyright 2017 The TensorFlow Authors All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== + +"""Tests for icp grad.""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import icp_grad # pylint: disable=unused-import +import icp_test +import tensorflow as tf +from tensorflow.python.ops import gradient_checker + + +class IcpOpGradTest(icp_test.IcpOpTestBase): + + def test_grad_transform(self): + with self.test_session(): + cloud_source = self.small_cloud + cloud_target = cloud_source + [0.05, 0, 0] + ego_motion = self.identity_transform + transform, unused_residual = self._run_icp(cloud_source, ego_motion, + cloud_target) + err = gradient_checker.compute_gradient_error(ego_motion, + ego_motion.shape.as_list(), + transform, + transform.shape.as_list()) + # Since our gradient is an approximation, it doesn't pass a numerical check. + # Nonetheless, this test verifies that icp_grad computes a gradient. + self.assertGreater(err, 1e-3) + + def test_grad_transform_same_ego_motion(self): + with self.test_session(): + cloud_source = self.small_cloud + cloud_target = cloud_source + [0.1, 0, 0] + ego_motion = tf.constant([[0.1, 0.0, 0.0, 0.0, 0.0, 0.0]], + dtype=tf.float32) + transform, unused_residual = self._run_icp(cloud_source, ego_motion, + cloud_target) + err = gradient_checker.compute_gradient_error(ego_motion, + ego_motion.shape.as_list(), + transform, + transform.shape.as_list()) + # Since our gradient is an approximation, it doesn't pass a numerical check. + # Nonetheless, this test verifies that icp_grad computes a gradient. + self.assertGreater(err, 1e-3) + + def test_grad_residual(self): + with self.test_session(): + cloud_source = self.small_cloud + cloud_target = cloud_source + [0.05, 0, 0] + ego_motion = self.identity_transform + unused_transform, residual = self._run_icp(cloud_source, ego_motion, + cloud_target) + err = gradient_checker.compute_gradient_error( + cloud_source, cloud_source.shape.as_list(), residual, + residual.shape.as_list()) + # Since our gradient is an approximation, it doesn't pass a numerical check. + # Nonetheless, this test verifies that icp_grad computes a gradient. + self.assertGreater(err, 1e-3) + + +if __name__ == '__main__': + tf.test.main() + +# Copyright 2013 VMware, Inc. +# All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# + +import mock +from oslo_config import cfg +from oslo_utils import uuidutils +import testscenarios +from webob import exc + +from neutron.common import constants +from neutron.db import api as db_api +from neutron.db import external_net_db +from neutron.db import l3_db +from neutron.db import l3_gwmode_db +from neutron.db import models_v2 +from neutron.extensions import l3 +from neutron.extensions import l3_ext_gw_mode +from neutron.tests import base +from neutron.tests.unit.db import test_db_base_plugin_v2 +from neutron.tests.unit.extensions import test_l3 +from neutron.tests.unit import testlib_api + +_uuid = uuidutils.generate_uuid +FAKE_GW_PORT_ID = _uuid() +FAKE_GW_PORT_MAC = 'aa:bb:cc:dd:ee:ff' +FAKE_FIP_EXT_PORT_ID = _uuid() +FAKE_FIP_EXT_PORT_MAC = '11:22:33:44:55:66' +FAKE_FIP_INT_PORT_ID = _uuid() +FAKE_FIP_INT_PORT_MAC = 'aa:aa:aa:aa:aa:aa' +FAKE_ROUTER_PORT_ID = _uuid() +FAKE_ROUTER_PORT_MAC = 'bb:bb:bb:bb:bb:bb' + + +class TestExtensionManager(object): + + def get_resources(self): + # Simulate extension of L3 attribute map + for key in l3.RESOURCE_ATTRIBUTE_MAP.keys(): + l3.RESOURCE_ATTRIBUTE_MAP[key].update( + l3_ext_gw_mode.EXTENDED_ATTRIBUTES_2_0.get(key, {})) + return l3.L3.get_resources() + + def get_actions(self): + return [] + + def get_request_extensions(self): + return [] + + +# A simple class for making a concrete class out of the mixin +# for the case of a plugin that integrates l3 routing. +class TestDbIntPlugin(test_l3.TestL3NatIntPlugin, + l3_gwmode_db.L3_NAT_db_mixin): + + supported_extension_aliases = ["external-net", "router", "ext-gw-mode"] + + +# A simple class for making a concrete class out of the mixin +# for the case of a l3 router service plugin +class TestDbSepPlugin(test_l3.TestL3NatServicePlugin, + l3_gwmode_db.L3_NAT_db_mixin): + + supported_extension_aliases = ["router", "ext-gw-mode"] + + +class TestGetEnableSnat(testscenarios.WithScenarios, base.BaseTestCase): + scenarios = [ + ('enabled', {'enable_snat_by_default': True}), + ('disabled', {'enable_snat_by_default': False})] + + def setUp(self): + super(TestGetEnableSnat, self).setUp() + self.config(enable_snat_by_default=self.enable_snat_by_default) + + def _test_get_enable_snat(self, expected, info): + observed = l3_gwmode_db.L3_NAT_dbonly_mixin._get_enable_snat(info) + self.assertEqual(expected, observed) + + def test_get_enable_snat_without_gw_info(self): + self._test_get_enable_snat(self.enable_snat_by_default, {}) + + def test_get_enable_snat_without_enable_snat(self): + info = {'network_id': _uuid()} + self._test_get_enable_snat(self.enable_snat_by_default, info) + + def test_get_enable_snat_with_snat_enabled(self): + self._test_get_enable_snat(True, {'enable_snat': True}) + + def test_get_enable_snat_with_snat_disabled(self): + self._test_get_enable_snat(False, {'enable_snat': False}) + + +class TestL3GwModeMixin(testlib_api.SqlTestCase): + + def setUp(self): + super(TestL3GwModeMixin, self).setUp() + plugin = __name__ + '.' + TestDbIntPlugin.__name__ + self.setup_coreplugin(plugin) + self.target_object = TestDbIntPlugin() + # Patch the context + ctx_patcher = mock.patch('neutron.context', autospec=True) + mock_context = ctx_patcher.start() + self.context = mock_context.get_admin_context() + # This ensure also calls to elevated work in unit tests + self.context.elevated.return_value = self.context + self.context.session = db_api.get_session() + # Create sample data for tests + self.ext_net_id = _uuid() + self.int_net_id = _uuid() + self.int_sub_id = _uuid() + self.tenant_id = 'the_tenant' + self.network = models_v2.Network( + id=self.ext_net_id, + tenant_id=self.tenant_id, + admin_state_up=True, + status=constants.NET_STATUS_ACTIVE) + self.net_ext = external_net_db.ExternalNetwork( + network_id=self.ext_net_id) + self.context.session.add(self.network) + # The following is to avoid complains from sqlite on + # foreign key violations + self.context.session.flush() + self.context.session.add(self.net_ext) + self.router = l3_db.Router( + id=_uuid(), + name=None, + tenant_id=self.tenant_id, + admin_state_up=True, + status=constants.NET_STATUS_ACTIVE, + enable_snat=True, + gw_port_id=None) + self.context.session.add(self.router) + self.context.session.flush() + self.router_gw_port = models_v2.Port( + id=FAKE_GW_PORT_ID, + tenant_id=self.tenant_id, + device_id=self.router.id, + device_owner=l3_db.DEVICE_OWNER_ROUTER_GW, + admin_state_up=True, + status=constants.PORT_STATUS_ACTIVE, + mac_address=FAKE_GW_PORT_MAC, + network_id=self.ext_net_id) + self.router.gw_port_id = self.router_gw_port.id + self.context.session.add(self.router) + self.context.session.add(self.router_gw_port) + self.context.session.flush() + self.fip_ext_port = models_v2.Port( + id=FAKE_FIP_EXT_PORT_ID, + tenant_id=self.tenant_id, + admin_state_up=True, + device_id=self.router.id, + device_owner=l3_db.DEVICE_OWNER_FLOATINGIP, + status=constants.PORT_STATUS_ACTIVE, + mac_address=FAKE_FIP_EXT_PORT_MAC, + network_id=self.ext_net_id) + self.context.session.add(self.fip_ext_port) + self.context.session.flush() + self.int_net = models_v2.Network( + id=self.int_net_id, + tenant_id=self.tenant_id, + admin_state_up=True, + status=constants.NET_STATUS_ACTIVE) + self.int_sub = models_v2.Subnet( + id=self.int_sub_id, + tenant_id=self.tenant_id, + ip_version=4, + cidr='3.3.3.0/24', + gateway_ip='3.3.3.1', + network_id=self.int_net_id) + self.router_port = models_v2.Port( + id=FAKE_ROUTER_PORT_ID, + tenant_id=self.tenant_id, + admin_state_up=True, + device_id=self.router.id, + device_owner=l3_db.DEVICE_OWNER_ROUTER_INTF, + status=constants.PORT_STATUS_ACTIVE, + mac_address=FAKE_ROUTER_PORT_MAC, + network_id=self.int_net_id) + self.router_port_ip_info = models_v2.IPAllocation( + port_id=self.router_port.id, + network_id=self.int_net.id, + subnet_id=self.int_sub_id, + ip_address='3.3.3.1') + self.context.session.add(self.int_net) + self.context.session.add(self.int_sub) + self.context.session.add(self.router_port) + self.context.session.add(self.router_port_ip_info) + self.context.session.flush() + self.fip_int_port = models_v2.Port( + id=FAKE_FIP_INT_PORT_ID, + tenant_id=self.tenant_id, + admin_state_up=True, + device_id='something', + device_owner='compute:nova', + status=constants.PORT_STATUS_ACTIVE, + mac_address=FAKE_FIP_INT_PORT_MAC, + network_id=self.int_net_id) + self.fip_int_ip_info = models_v2.IPAllocation( + port_id=self.fip_int_port.id, + network_id=self.int_net.id, + subnet_id=self.int_sub_id, + ip_address='3.3.3.3') + self.fip = l3_db.FloatingIP( + id=_uuid(), + floating_ip_address='1.1.1.2', + floating_network_id=self.ext_net_id, + floating_port_id=FAKE_FIP_EXT_PORT_ID, + fixed_port_id=None, + fixed_ip_address=None, + router_id=None) + self.context.session.add(self.fip_int_port) + self.context.session.add(self.fip_int_ip_info) + self.context.session.add(self.fip) + self.context.session.flush() + self.fip_request = {'port_id': FAKE_FIP_INT_PORT_ID, + 'tenant_id': self.tenant_id} + + def _get_gwports_dict(self, gw_ports): + return dict((gw_port['id'], gw_port) + for gw_port in gw_ports) + + def _reset_ext_gw(self): + # Reset external gateway + self.router.gw_port_id = None + self.context.session.add(self.router) + self.context.session.flush() + + def _test_update_router_gw(self, current_enable_snat, gw_info=None, + expected_enable_snat=True): + if not current_enable_snat: + previous_gw_info = {'network_id': self.ext_net_id, + 'enable_snat': current_enable_snat} + self.target_object._update_router_gw_info( + self.context, self.router.id, previous_gw_info) + + self.target_object._update_router_gw_info( + self.context, self.router.id, gw_info) + router = self.target_object._get_router( + self.context, self.router.id) + try: + self.assertEqual(FAKE_GW_PORT_ID, + router.gw_port.id) + self.assertEqual(FAKE_GW_PORT_MAC, + router.gw_port.mac_address) + except AttributeError: + self.assertIsNone(router.gw_port) + self.assertEqual(expected_enable_snat, router.enable_snat) + + def test_update_router_gw_with_gw_info_none(self): + self._test_update_router_gw(current_enable_snat=True) + + def test_update_router_gw_without_info_and_snat_disabled_previously(self): + self._test_update_router_gw(current_enable_snat=False) + + def test_update_router_gw_with_network_only(self): + info = {'network_id': self.ext_net_id} + self._test_update_router_gw(current_enable_snat=True, gw_info=info) + + def test_update_router_gw_with_network_and_snat_disabled_previously(self): + info = {'network_id': self.ext_net_id} + self._test_update_router_gw(current_enable_snat=False, gw_info=info) + + def test_update_router_gw_with_snat_disabled(self): + info = {'network_id': self.ext_net_id, + 'enable_snat': False} + self._test_update_router_gw( + current_enable_snat=True, gw_info=info, expected_enable_snat=False) + + def test_update_router_gw_with_snat_enabled(self): + info = {'network_id': self.ext_net_id, + 'enable_snat': True} + self._test_update_router_gw(current_enable_snat=False, gw_info=info) + + def test_make_router_dict_no_ext_gw(self): + self._reset_ext_gw() + router_dict = self.target_object._make_router_dict(self.router) + self.assertIsNone(router_dict[l3.EXTERNAL_GW_INFO]) + + def test_make_router_dict_with_ext_gw(self): + router_dict = self.target_object._make_router_dict(self.router) + self.assertEqual({'network_id': self.ext_net_id, + 'enable_snat': True, + 'external_fixed_ips': []}, + router_dict[l3.EXTERNAL_GW_INFO]) + + def test_make_router_dict_with_ext_gw_snat_disabled(self): + self.router.enable_snat = False + router_dict = self.target_object._make_router_dict(self.router) + self.assertEqual({'network_id': self.ext_net_id, + 'enable_snat': False, + 'external_fixed_ips': []}, + router_dict[l3.EXTERNAL_GW_INFO]) + + def test_build_routers_list_no_ext_gw(self): + self._reset_ext_gw() + router_dict = self.target_object._make_router_dict(self.router) + routers = self.target_object._build_routers_list(self.context, + [router_dict], + []) + self.assertEqual(1, len(routers)) + router = routers[0] + self.assertIsNone(router.get('gw_port')) + self.assertIsNone(router.get('enable_snat')) + + def test_build_routers_list_with_ext_gw(self): + router_dict = self.target_object._make_router_dict(self.router) + routers = self.target_object._build_routers_list( + self.context, [router_dict], + self._get_gwports_dict([self.router.gw_port])) + self.assertEqual(1, len(routers)) + router = routers[0] + self.assertIsNotNone(router.get('gw_port')) + self.assertEqual(FAKE_GW_PORT_ID, router['gw_port']['id']) + self.assertTrue(router.get('enable_snat')) + + def test_build_routers_list_with_ext_gw_snat_disabled(self): + self.router.enable_snat = False + router_dict = self.target_object._make_router_dict(self.router) + routers = self.target_object._build_routers_list( + self.context, [router_dict], + self._get_gwports_dict([self.router.gw_port])) + self.assertEqual(1, len(routers)) + router = routers[0] + self.assertIsNotNone(router.get('gw_port')) + self.assertEqual(FAKE_GW_PORT_ID, router['gw_port']['id']) + self.assertFalse(router.get('enable_snat')) + + def test_build_routers_list_with_gw_port_mismatch(self): + router_dict = self.target_object._make_router_dict(self.router) + routers = self.target_object._build_routers_list( + self.context, [router_dict], {}) + self.assertEqual(1, len(routers)) + router = routers[0] + self.assertIsNone(router.get('gw_port')) + self.assertIsNone(router.get('enable_snat')) + + +class ExtGwModeIntTestCase(test_db_base_plugin_v2.NeutronDbPluginV2TestCase, + test_l3.L3NatTestCaseMixin): + + def setUp(self, plugin=None, svc_plugins=None, ext_mgr=None): + # Store l3 resource attribute map as it will be updated + self._l3_attribute_map_bk = {} + for item in l3.RESOURCE_ATTRIBUTE_MAP: + self._l3_attribute_map_bk[item] = ( + l3.RESOURCE_ATTRIBUTE_MAP[item].copy()) + plugin = plugin or ( + 'neutron.tests.unit.extensions.test_l3_ext_gw_mode.' + 'TestDbIntPlugin') + # for these tests we need to enable overlapping ips + cfg.CONF.set_default('allow_overlapping_ips', True) + ext_mgr = ext_mgr or TestExtensionManager() + super(ExtGwModeIntTestCase, self).setUp(plugin=plugin, + ext_mgr=ext_mgr, + service_plugins=svc_plugins) + self.addCleanup(self.restore_l3_attribute_map) + + def restore_l3_attribute_map(self): + l3.RESOURCE_ATTRIBUTE_MAP = self._l3_attribute_map_bk + + def tearDown(self): + super(ExtGwModeIntTestCase, self).tearDown() + + def _set_router_external_gateway(self, router_id, network_id, + snat_enabled=None, + expected_code=exc.HTTPOk.code, + neutron_context=None): + ext_gw_info = {'network_id': network_id} + # Need to set enable_snat also if snat_enabled == False + if snat_enabled is not None: + ext_gw_info['enable_snat'] = snat_enabled + return self._update('routers', router_id, + {'router': {'external_gateway_info': + ext_gw_info}}, + expected_code=expected_code, + neutron_context=neutron_context) + + def test_router_create_show_no_ext_gwinfo(self): + name = 'router1' + tenant_id = _uuid() + expected_value = [('name', name), ('tenant_id', tenant_id), + ('admin_state_up', True), ('status', 'ACTIVE'), + ('external_gateway_info', None)] + with self.router(name=name, admin_state_up=True, + tenant_id=tenant_id) as router: + res = self._show('routers', router['router']['id']) + for k, v in expected_value: + self.assertEqual(res['router'][k], v) + + def _test_router_create_show_ext_gwinfo(self, snat_input_value, + snat_expected_value): + name = 'router1' + tenant_id = _uuid() + with self.subnet() as s: + ext_net_id = s['subnet']['network_id'] + self._set_net_external(ext_net_id) + input_value = {'network_id': ext_net_id} + if snat_input_value in (True, False): + input_value['enable_snat'] = snat_input_value + expected_value = [('name', name), ('tenant_id', tenant_id), + ('admin_state_up', True), ('status', 'ACTIVE'), + ('external_gateway_info', + {'network_id': ext_net_id, + 'enable_snat': snat_expected_value, + 'external_fixed_ips': [{ + 'ip_address': mock.ANY, + 'subnet_id': s['subnet']['id']}]})] + with self.router( + name=name, admin_state_up=True, tenant_id=tenant_id, + external_gateway_info=input_value) as router: + res = self._show('routers', router['router']['id']) + for k, v in expected_value: + self.assertEqual(res['router'][k], v) + + def test_router_create_show_ext_gwinfo_default(self): + self._test_router_create_show_ext_gwinfo(None, True) + + def test_router_create_show_ext_gwinfo_with_snat_enabled(self): + self._test_router_create_show_ext_gwinfo(True, True) + + def test_router_create_show_ext_gwinfo_with_snat_disabled(self): + self._test_router_create_show_ext_gwinfo(False, False) + + def _test_router_update_ext_gwinfo(self, snat_input_value, + snat_expected_value=False, + expected_http_code=exc.HTTPOk.code): + with self.router() as r: + with self.subnet() as s: + try: + ext_net_id = s['subnet']['network_id'] + self._set_net_external(ext_net_id) + self._set_router_external_gateway( + r['router']['id'], ext_net_id, + snat_enabled=snat_input_value, + expected_code=expected_http_code) + if expected_http_code != exc.HTTPOk.code: + return + body = self._show('routers', r['router']['id']) + res_gw_info = body['router']['external_gateway_info'] + self.assertEqual(res_gw_info['network_id'], ext_net_id) + self.assertEqual(res_gw_info['enable_snat'], + snat_expected_value) + finally: + self._remove_external_gateway_from_router( + r['router']['id'], ext_net_id) + + def test_router_update_ext_gwinfo_default(self): + self._test_router_update_ext_gwinfo(None, True) + + def test_router_update_ext_gwinfo_with_snat_enabled(self): + self._test_router_update_ext_gwinfo(True, True) + + def test_router_update_ext_gwinfo_with_snat_disabled(self): + self._test_router_update_ext_gwinfo(False, False) + + def test_router_update_ext_gwinfo_with_invalid_snat_setting(self): + self._test_router_update_ext_gwinfo( + 'xxx', None, expected_http_code=exc.HTTPBadRequest.code) + + +class ExtGwModeSepTestCase(ExtGwModeIntTestCase): + + def setUp(self, plugin=None): + # Store l3 resource attribute map as it will be updated + self._l3_attribute_map_bk = {} + for item in l3.RESOURCE_ATTRIBUTE_MAP: + self._l3_attribute_map_bk[item] = ( + l3.RESOURCE_ATTRIBUTE_MAP[item].copy()) + plugin = plugin or ( + 'neutron.tests.unit.extensions.test_l3.TestNoL3NatPlugin') + # the L3 service plugin + l3_plugin = ('neutron.tests.unit.extensions.test_l3_ext_gw_mode.' + 'TestDbSepPlugin') + svc_plugins = {'l3_plugin_name': l3_plugin} + # for these tests we need to enable overlapping ips + cfg.CONF.set_default('allow_overlapping_ips', True) + super(ExtGwModeSepTestCase, self).setUp(plugin=plugin, + svc_plugins=svc_plugins) + self.addCleanup(self.restore_l3_attribute_map) + +# -*- coding: utf-8 -*- +# +# +# Author: Nicolas Bessi +# Copyright 2013-2014 Camptocamp SA +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as +# published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with this program. If not, see . +# +# +from openerp import models, fields, api + + +class BaseCommentTemplate(models.Model): + _name = "base.comment.template" + _description = "Base comment template" + + name = fields.Char('Comment summary', required=True) + position = fields.Selection([('before_lines', 'Before lines'), + ('after_lines', 'After lines')], + 'Position', + required=True, + default='before_lines', + help="Position on document") + text = fields.Html('Comment', translate=True, required=True) + + @api.multi + def get_value(self, partner_id=False): + self.ensure_one() + lang = None + if partner_id: + lang = self.env['res.partner'].browse(partner_id).lang + return self.with_context({'lang': lang}).text + +#! /usr/bin/env python3 + +import sys +sys.path.append('../') +import stre.settings +import datetime +import subprocess + +host = stre.settings.DATABASES['default']['HOST'] +user = stre.settings.DATABASES['default']['USER'] +password = stre.settings.DATABASES['default']['PASSWORD'] +name = stre.settings.DATABASES['default']['NAME'] +gpg_target_id = stre.settings.GPG_TARGET_ID + +basename = "{0.year:04d}{0.month:02d}{0.day:02d}_{0.hour:02d}{0.minute:02d}{0.second:02d}".format(datetime.datetime.now()) + + +commands = {} +commands_cleanup= {} + +commands['sql'] = "mysqldump --host={host} --user={user} --password={password} --databases {name} --result-file={basename}.sql".format(host=host, user=user, password=password, name=name, basename=basename) + +commands['briefe_zip'] = "zip -r {basename}_briefe.zip ../dokumente/briefe/*".format(basename=basename) +commands['export_zip'] = "zip -r {basename}_export.zip ../dokumente/export/*".format(basename=basename) +commands['nachweise_zip'] = "zip -r {basename}_nachweise.zip ../dokumente/nachweise/*".format(basename=basename) + +commands['bundle'] = "zip {basename}.zip {basename}.sql {basename}_briefe.zip {basename}_export.zip {basename}_nachweise.zip".format(basename=basename) + +commands['encrypt'] = "gpg --output {basename}.zip.gpg --encrypt --recipient {gpg_target_id} {basename}.zip".format(basename=basename, gpg_target_id=gpg_target_id) + + +commands_cleanup['sql'] = "rm {basename}.sql".format(basename=basename) +commands_cleanup['briefe_zip'] = "rm {basename}_briefe.zip".format(basename=basename) +commands_cleanup['export_zip'] = "rm {basename}_export.zip".format(basename=basename) +commands_cleanup['nachweise_zip'] = "rm {basename}_nachweise.zip".format(basename=basename) +commands_cleanup['zip'] = "rm {basename}.zip".format(basename=basename) + + + +print("Storing backup as {}.gpg".format(basename)) +subprocess.run(commands['sql'], shell=True) +subprocess.run(commands['briefe_zip'], shell=True) +subprocess.run(commands['export_zip'], shell=True) +subprocess.run(commands['nachweise_zip'], shell=True) +subprocess.run(commands['bundle'], shell=True) +subprocess.run(commands['encrypt'], shell=True) + +print("Removing temporary files") +subprocess.run(commands_cleanup['sql'], shell=True) +subprocess.run(commands_cleanup['briefe_zip'], shell=True) +subprocess.run(commands_cleanup['export_zip'], shell=True) +subprocess.run(commands_cleanup['nachweise_zip'], shell=True) +subprocess.run(commands_cleanup['zip'], shell=True) + +print("Backup file created.") + +# -*- coding: utf-8 -*- +""" + jinja2.testsuite.tests + ~~~~~~~~~~~~~~~~~~~~~~ + + Who tests the tests? + + :copyright: (c) 2010 by the Jinja Team. + :license: BSD, see LICENSE for more details. +""" +import unittest +from jinja2.testsuite import JinjaTestCase + +from jinja2 import Markup, Environment + +env = Environment() + + +class TestsTestCase(JinjaTestCase): + + def test_defined(self): + tmpl = env.from_string('{{ missing is defined }}|{{ true is defined }}') + assert tmpl.render() == 'False|True' + + def test_even(self): + tmpl = env.from_string('''{{ 1 is even }}|{{ 2 is even }}''') + assert tmpl.render() == 'False|True' + + def test_odd(self): + tmpl = env.from_string('''{{ 1 is odd }}|{{ 2 is odd }}''') + assert tmpl.render() == 'True|False' + + def test_lower(self): + tmpl = env.from_string('''{{ "foo" is lower }}|{{ "FOO" is lower }}''') + assert tmpl.render() == 'True|False' + + def test_typechecks(self): + tmpl = env.from_string(''' + {{ 42 is undefined }} + {{ 42 is defined }} + {{ 42 is none }} + {{ none is none }} + {{ 42 is number }} + {{ 42 is string }} + {{ "foo" is string }} + {{ "foo" is sequence }} + {{ [1] is sequence }} + {{ range is callable }} + {{ 42 is callable }} + {{ range(5) is iterable }} + ''') + assert tmpl.render().split() == [ + 'False', 'True', 'False', 'True', 'True', 'False', + 'True', 'True', 'True', 'True', 'False', 'True' + ] + + def test_sequence(self): + tmpl = env.from_string( + '{{ [1, 2, 3] is sequence }}|' + '{{ "foo" is sequence }}|' + '{{ 42 is sequence }}' + ) + assert tmpl.render() == 'True|True|False' + + def test_upper(self): + tmpl = env.from_string('{{ "FOO" is upper }}|{{ "foo" is upper }}') + assert tmpl.render() == 'True|False' + + def test_sameas(self): + tmpl = env.from_string('{{ foo is sameas false }}|' + '{{ 0 is sameas false }}') + assert tmpl.render(foo=False) == 'True|False' + + def test_no_paren_for_arg1(self): + tmpl = env.from_string('{{ foo is sameas none }}') + assert tmpl.render(foo=None) == 'True' + + def test_escaped(self): + env = Environment(autoescape=True) + tmpl = env.from_string('{{ x is escaped }}|{{ y is escaped }}') + assert tmpl.render(x='foo', y=Markup('foo')) == 'False|True' + + +def suite(): + suite = unittest.TestSuite() + suite.addTest(unittest.makeSuite(TestsTestCase)) + return suite + +from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandlers + + +import pybindgen.settings +import warnings + +class ErrorHandler(pybindgen.settings.ErrorHandler): + def handle_error(self, wrapper, exception, traceback_): + warnings.warn("exception %r in wrapper %s" % (exception, wrapper)) + return True +pybindgen.settings.error_handler = ErrorHandler() + + +import sys + +def module_init(): + root_module = Module('ns.uan', cpp_namespace='::ns3') + return root_module + +def register_types(module): + root_module = module.get_root() + + ## address.h (module 'network'): ns3::Address [class] + module.add_class('Address', import_from_module='ns.network') + ## address.h (module 'network'): ns3::Address::MaxSize_e [enumeration] + module.add_enum('MaxSize_e', ['MAX_SIZE'], outer_class=root_module['ns3::Address'], import_from_module='ns.network') + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList [class] + module.add_class('AttributeConstructionList', import_from_module='ns.core') + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item [struct] + module.add_class('Item', import_from_module='ns.core', outer_class=root_module['ns3::AttributeConstructionList']) + ## buffer.h (module 'network'): ns3::Buffer [class] + module.add_class('Buffer', import_from_module='ns.network') + ## buffer.h (module 'network'): ns3::Buffer::Iterator [class] + module.add_class('Iterator', import_from_module='ns.network', outer_class=root_module['ns3::Buffer']) + ## packet.h (module 'network'): ns3::ByteTagIterator [class] + module.add_class('ByteTagIterator', import_from_module='ns.network') + ## packet.h (module 'network'): ns3::ByteTagIterator::Item [class] + module.add_class('Item', import_from_module='ns.network', outer_class=root_module['ns3::ByteTagIterator']) + ## byte-tag-list.h (module 'network'): ns3::ByteTagList [class] + module.add_class('ByteTagList', import_from_module='ns.network') + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator [class] + module.add_class('Iterator', import_from_module='ns.network', outer_class=root_module['ns3::ByteTagList']) + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item [struct] + module.add_class('Item', import_from_module='ns.network', outer_class=root_module['ns3::ByteTagList::Iterator']) + ## callback.h (module 'core'): ns3::CallbackBase [class] + module.add_class('CallbackBase', import_from_module='ns.core') + ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer [class] + module.add_class('DeviceEnergyModelContainer', import_from_module='ns.energy') + ## energy-model-helper.h (module 'energy'): ns3::DeviceEnergyModelHelper [class] + module.add_class('DeviceEnergyModelHelper', allow_subclassing=True, import_from_module='ns.energy') + ## energy-model-helper.h (module 'energy'): ns3::EnergySourceHelper [class] + module.add_class('EnergySourceHelper', allow_subclassing=True, import_from_module='ns.energy') + ## event-id.h (module 'core'): ns3::EventId [class] + module.add_class('EventId', import_from_module='ns.core') + ## ipv4-address.h (module 'network'): ns3::Ipv4Address [class] + module.add_class('Ipv4Address', import_from_module='ns.network') + ## ipv4-address.h (module 'network'): ns3::Ipv4Address [class] + root_module['ns3::Ipv4Address'].implicitly_converts_to(root_module['ns3::Address']) + ## ipv4-address.h (module 'network'): ns3::Ipv4Mask [class] + module.add_class('Ipv4Mask', import_from_module='ns.network') + ## ipv6-address.h (module 'network'): ns3::Ipv6Address [class] + module.add_class('Ipv6Address', import_from_module='ns.network') + ## ipv6-address.h (module 'network'): ns3::Ipv6Address [class] + root_module['ns3::Ipv6Address'].implicitly_converts_to(root_module['ns3::Address']) + ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix [class] + module.add_class('Ipv6Prefix', import_from_module='ns.network') + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer [class] + module.add_class('NetDeviceContainer', import_from_module='ns.network') + ## node-container.h (module 'network'): ns3::NodeContainer [class] + module.add_class('NodeContainer', import_from_module='ns.network') + ## object-base.h (module 'core'): ns3::ObjectBase [class] + module.add_class('ObjectBase', allow_subclassing=True, import_from_module='ns.core') + ## object.h (module 'core'): ns3::ObjectDeleter [struct] + module.add_class('ObjectDeleter', import_from_module='ns.core') + ## object-factory.h (module 'core'): ns3::ObjectFactory [class] + module.add_class('ObjectFactory', import_from_module='ns.core') + ## packet-metadata.h (module 'network'): ns3::PacketMetadata [class] + module.add_class('PacketMetadata', import_from_module='ns.network') + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item [struct] + module.add_class('Item', import_from_module='ns.network', outer_class=root_module['ns3::PacketMetadata']) + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item [enumeration] + module.add_enum('', ['PAYLOAD', 'HEADER', 'TRAILER'], outer_class=root_module['ns3::PacketMetadata::Item'], import_from_module='ns.network') + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator [class] + module.add_class('ItemIterator', import_from_module='ns.network', outer_class=root_module['ns3::PacketMetadata']) + ## packet.h (module 'network'): ns3::PacketTagIterator [class] + module.add_class('PacketTagIterator', import_from_module='ns.network') + ## packet.h (module 'network'): ns3::PacketTagIterator::Item [class] + module.add_class('Item', import_from_module='ns.network', outer_class=root_module['ns3::PacketTagIterator']) + ## packet-tag-list.h (module 'network'): ns3::PacketTagList [class] + module.add_class('PacketTagList', import_from_module='ns.network') + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData [struct] + module.add_class('TagData', import_from_module='ns.network', outer_class=root_module['ns3::PacketTagList']) + ## uan-mac-rc.h (module 'uan'): ns3::Reservation [class] + module.add_class('Reservation') + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount [class] + module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::Object', 'ns3::ObjectBase', 'ns3::ObjectDeleter'], parent=root_module['ns3::ObjectBase'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount')) + ## simulator.h (module 'core'): ns3::Simulator [class] + module.add_class('Simulator', destructor_visibility='private', import_from_module='ns.core') + ## tag.h (module 'network'): ns3::Tag [class] + module.add_class('Tag', import_from_module='ns.network', parent=root_module['ns3::ObjectBase']) + ## tag-buffer.h (module 'network'): ns3::TagBuffer [class] + module.add_class('TagBuffer', import_from_module='ns.network') + ## uan-prop-model.h (module 'uan'): ns3::Tap [class] + module.add_class('Tap') + ## traced-value.h (module 'core'): ns3::TracedValue [class] + module.add_class('TracedValue', import_from_module='ns.core', template_parameters=['double']) + ## type-id.h (module 'core'): ns3::TypeId [class] + module.add_class('TypeId', import_from_module='ns.core') + ## type-id.h (module 'core'): ns3::TypeId::AttributeFlag [enumeration] + module.add_enum('AttributeFlag', ['ATTR_GET', 'ATTR_SET', 'ATTR_CONSTRUCT', 'ATTR_SGC'], outer_class=root_module['ns3::TypeId'], import_from_module='ns.core') + ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation [struct] + module.add_class('AttributeInformation', import_from_module='ns.core', outer_class=root_module['ns3::TypeId']) + ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation [struct] + module.add_class('TraceSourceInformation', import_from_module='ns.core', outer_class=root_module['ns3::TypeId']) + ## uan-address.h (module 'uan'): ns3::UanAddress [class] + module.add_class('UanAddress') + ## uan-address.h (module 'uan'): ns3::UanAddress [class] + root_module['ns3::UanAddress'].implicitly_converts_to(root_module['ns3::Address']) + ## uan-helper.h (module 'uan'): ns3::UanHelper [class] + module.add_class('UanHelper') + ## uan-tx-mode.h (module 'uan'): ns3::UanModesList [class] + module.add_class('UanModesList') + ## uan-transducer.h (module 'uan'): ns3::UanPacketArrival [class] + module.add_class('UanPacketArrival') + ## uan-prop-model.h (module 'uan'): ns3::UanPdp [class] + module.add_class('UanPdp') + ## uan-phy.h (module 'uan'): ns3::UanPhyListener [class] + module.add_class('UanPhyListener', allow_subclassing=True) + ## uan-tx-mode.h (module 'uan'): ns3::UanTxMode [class] + module.add_class('UanTxMode') + ## uan-tx-mode.h (module 'uan'): ns3::UanTxMode::ModulationType [enumeration] + module.add_enum('ModulationType', ['PSK', 'QAM', 'FSK', 'OTHER'], outer_class=root_module['ns3::UanTxMode']) + ## uan-tx-mode.h (module 'uan'): ns3::UanTxModeFactory [class] + module.add_class('UanTxModeFactory') + ## vector.h (module 'core'): ns3::Vector2D [class] + module.add_class('Vector2D', import_from_module='ns.core') + ## vector.h (module 'core'): ns3::Vector3D [class] + module.add_class('Vector3D', import_from_module='ns.core') + ## empty.h (module 'core'): ns3::empty [class] + module.add_class('empty', import_from_module='ns.core') + ## int64x64-double.h (module 'core'): ns3::int64x64_t [class] + module.add_class('int64x64_t', import_from_module='ns.core') + ## acoustic-modem-energy-model-helper.h (module 'uan'): ns3::AcousticModemEnergyModelHelper [class] + module.add_class('AcousticModemEnergyModelHelper', parent=root_module['ns3::DeviceEnergyModelHelper']) + ## chunk.h (module 'network'): ns3::Chunk [class] + module.add_class('Chunk', import_from_module='ns.network', parent=root_module['ns3::ObjectBase']) + ## header.h (module 'network'): ns3::Header [class] + module.add_class('Header', import_from_module='ns.network', parent=root_module['ns3::Chunk']) + ## object.h (module 'core'): ns3::Object [class] + module.add_class('Object', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter >']) + ## object.h (module 'core'): ns3::Object::AggregateIterator [class] + module.add_class('AggregateIterator', import_from_module='ns.core', outer_class=root_module['ns3::Object']) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount > [class] + module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::AttributeAccessor', 'ns3::empty', 'ns3::DefaultDeleter'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount')) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount > [class] + module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::AttributeChecker', 'ns3::empty', 'ns3::DefaultDeleter'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount')) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount > [class] + module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::AttributeValue', 'ns3::empty', 'ns3::DefaultDeleter'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount')) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount > [class] + module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::CallbackImplBase', 'ns3::empty', 'ns3::DefaultDeleter'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount')) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount > [class] + module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::EventImpl', 'ns3::empty', 'ns3::DefaultDeleter'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount')) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount > [class] + module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::NixVector', 'ns3::empty', 'ns3::DefaultDeleter'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount')) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount > [class] + module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::Packet', 'ns3::empty', 'ns3::DefaultDeleter'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount')) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount > [class] + module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::TraceSourceAccessor', 'ns3::empty', 'ns3::DefaultDeleter'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount')) + ## nstime.h (module 'core'): ns3::Time [class] + module.add_class('Time', import_from_module='ns.core') + ## nstime.h (module 'core'): ns3::Time::Unit [enumeration] + module.add_enum('Unit', ['S', 'MS', 'US', 'NS', 'PS', 'FS', 'LAST'], outer_class=root_module['ns3::Time'], import_from_module='ns.core') + ## nstime.h (module 'core'): ns3::Time [class] + root_module['ns3::Time'].implicitly_converts_to(root_module['ns3::int64x64_t']) + ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor [class] + module.add_class('TraceSourceAccessor', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter >']) + ## trailer.h (module 'network'): ns3::Trailer [class] + module.add_class('Trailer', import_from_module='ns.network', parent=root_module['ns3::Chunk']) + ## uan-header-common.h (module 'uan'): ns3::UanHeaderCommon [class] + module.add_class('UanHeaderCommon', parent=root_module['ns3::Header']) + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcAck [class] + module.add_class('UanHeaderRcAck', parent=root_module['ns3::Header']) + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcCts [class] + module.add_class('UanHeaderRcCts', parent=root_module['ns3::Header']) + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcCtsGlobal [class] + module.add_class('UanHeaderRcCtsGlobal', parent=root_module['ns3::Header']) + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcData [class] + module.add_class('UanHeaderRcData', parent=root_module['ns3::Header']) + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcRts [class] + module.add_class('UanHeaderRcRts', parent=root_module['ns3::Header']) + ## uan-mac.h (module 'uan'): ns3::UanMac [class] + module.add_class('UanMac', parent=root_module['ns3::Object']) + ## uan-mac-aloha.h (module 'uan'): ns3::UanMacAloha [class] + module.add_class('UanMacAloha', parent=root_module['ns3::UanMac']) + ## uan-mac-cw.h (module 'uan'): ns3::UanMacCw [class] + module.add_class('UanMacCw', parent=[root_module['ns3::UanMac'], root_module['ns3::UanPhyListener']]) + ## uan-mac-rc.h (module 'uan'): ns3::UanMacRc [class] + module.add_class('UanMacRc', parent=root_module['ns3::UanMac']) + ## uan-mac-rc.h (module 'uan'): ns3::UanMacRc [enumeration] + module.add_enum('', ['TYPE_DATA', 'TYPE_GWPING', 'TYPE_RTS', 'TYPE_CTS', 'TYPE_ACK'], outer_class=root_module['ns3::UanMacRc']) + ## uan-mac-rc-gw.h (module 'uan'): ns3::UanMacRcGw [class] + module.add_class('UanMacRcGw', parent=root_module['ns3::UanMac']) + ## uan-noise-model.h (module 'uan'): ns3::UanNoiseModel [class] + module.add_class('UanNoiseModel', parent=root_module['ns3::Object']) + ## uan-noise-model-default.h (module 'uan'): ns3::UanNoiseModelDefault [class] + module.add_class('UanNoiseModelDefault', parent=root_module['ns3::UanNoiseModel']) + ## uan-phy.h (module 'uan'): ns3::UanPhy [class] + module.add_class('UanPhy', parent=root_module['ns3::Object']) + ## uan-phy.h (module 'uan'): ns3::UanPhy::State [enumeration] + module.add_enum('State', ['IDLE', 'CCABUSY', 'RX', 'TX', 'SLEEP'], outer_class=root_module['ns3::UanPhy']) + ## uan-phy.h (module 'uan'): ns3::UanPhyCalcSinr [class] + module.add_class('UanPhyCalcSinr', parent=root_module['ns3::Object']) + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyCalcSinrDefault [class] + module.add_class('UanPhyCalcSinrDefault', parent=root_module['ns3::UanPhyCalcSinr']) + ## uan-phy-dual.h (module 'uan'): ns3::UanPhyCalcSinrDual [class] + module.add_class('UanPhyCalcSinrDual', parent=root_module['ns3::UanPhyCalcSinr']) + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyCalcSinrFhFsk [class] + module.add_class('UanPhyCalcSinrFhFsk', parent=root_module['ns3::UanPhyCalcSinr']) + ## uan-phy-dual.h (module 'uan'): ns3::UanPhyDual [class] + module.add_class('UanPhyDual', parent=root_module['ns3::UanPhy']) + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyGen [class] + module.add_class('UanPhyGen', parent=root_module['ns3::UanPhy']) + ## uan-phy.h (module 'uan'): ns3::UanPhyPer [class] + module.add_class('UanPhyPer', parent=root_module['ns3::Object']) + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerGenDefault [class] + module.add_class('UanPhyPerGenDefault', parent=root_module['ns3::UanPhyPer']) + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerUmodem [class] + module.add_class('UanPhyPerUmodem', parent=root_module['ns3::UanPhyPer']) + ## uan-prop-model.h (module 'uan'): ns3::UanPropModel [class] + module.add_class('UanPropModel', parent=root_module['ns3::Object']) + ## uan-prop-model-ideal.h (module 'uan'): ns3::UanPropModelIdeal [class] + module.add_class('UanPropModelIdeal', parent=root_module['ns3::UanPropModel']) + ## uan-prop-model-thorp.h (module 'uan'): ns3::UanPropModelThorp [class] + module.add_class('UanPropModelThorp', parent=root_module['ns3::UanPropModel']) + ## uan-transducer.h (module 'uan'): ns3::UanTransducer [class] + module.add_class('UanTransducer', parent=root_module['ns3::Object']) + ## uan-transducer.h (module 'uan'): ns3::UanTransducer::State [enumeration] + module.add_enum('State', ['TX', 'RX'], outer_class=root_module['ns3::UanTransducer']) + ## uan-transducer-hd.h (module 'uan'): ns3::UanTransducerHd [class] + module.add_class('UanTransducerHd', parent=root_module['ns3::UanTransducer']) + ## attribute.h (module 'core'): ns3::AttributeAccessor [class] + module.add_class('AttributeAccessor', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter >']) + ## attribute.h (module 'core'): ns3::AttributeChecker [class] + module.add_class('AttributeChecker', allow_subclassing=False, automatic_type_narrowing=True, import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter >']) + ## attribute.h (module 'core'): ns3::AttributeValue [class] + module.add_class('AttributeValue', allow_subclassing=False, automatic_type_narrowing=True, import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter >']) + ## boolean.h (module 'core'): ns3::BooleanChecker [class] + module.add_class('BooleanChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker']) + ## boolean.h (module 'core'): ns3::BooleanValue [class] + module.add_class('BooleanValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue']) + ## callback.h (module 'core'): ns3::CallbackChecker [class] + module.add_class('CallbackChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker']) + ## callback.h (module 'core'): ns3::CallbackImplBase [class] + module.add_class('CallbackImplBase', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter >']) + ## callback.h (module 'core'): ns3::CallbackValue [class] + module.add_class('CallbackValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue']) + ## channel.h (module 'network'): ns3::Channel [class] + module.add_class('Channel', import_from_module='ns.network', parent=root_module['ns3::Object']) + ## device-energy-model.h (module 'energy'): ns3::DeviceEnergyModel [class] + module.add_class('DeviceEnergyModel', import_from_module='ns.energy', parent=root_module['ns3::Object']) + ## double.h (module 'core'): ns3::DoubleValue [class] + module.add_class('DoubleValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue']) + ## attribute.h (module 'core'): ns3::EmptyAttributeValue [class] + module.add_class('EmptyAttributeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue']) + ## energy-source.h (module 'energy'): ns3::EnergySource [class] + module.add_class('EnergySource', import_from_module='ns.energy', parent=root_module['ns3::Object']) + ## energy-source-container.h (module 'energy'): ns3::EnergySourceContainer [class] + module.add_class('EnergySourceContainer', import_from_module='ns.energy', parent=root_module['ns3::Object']) + ## enum.h (module 'core'): ns3::EnumChecker [class] + module.add_class('EnumChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker']) + ## enum.h (module 'core'): ns3::EnumValue [class] + module.add_class('EnumValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue']) + ## event-impl.h (module 'core'): ns3::EventImpl [class] + module.add_class('EventImpl', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter >']) + ## integer.h (module 'core'): ns3::IntegerValue [class] + module.add_class('IntegerValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue']) + ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker [class] + module.add_class('Ipv4AddressChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker']) + ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue [class] + module.add_class('Ipv4AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue']) + ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker [class] + module.add_class('Ipv4MaskChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker']) + ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue [class] + module.add_class('Ipv4MaskValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue']) + ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker [class] + module.add_class('Ipv6AddressChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker']) + ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue [class] + module.add_class('Ipv6AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue']) + ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker [class] + module.add_class('Ipv6PrefixChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker']) + ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue [class] + module.add_class('Ipv6PrefixValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue']) + ## mobility-model.h (module 'mobility'): ns3::MobilityModel [class] + module.add_class('MobilityModel', import_from_module='ns.mobility', parent=root_module['ns3::Object']) + ## net-device.h (module 'network'): ns3::NetDevice [class] + module.add_class('NetDevice', import_from_module='ns.network', parent=root_module['ns3::Object']) + ## net-device.h (module 'network'): ns3::NetDevice::PacketType [enumeration] + module.add_enum('PacketType', ['PACKET_HOST', 'NS3_PACKET_HOST', 'PACKET_BROADCAST', 'NS3_PACKET_BROADCAST', 'PACKET_MULTICAST', 'NS3_PACKET_MULTICAST', 'PACKET_OTHERHOST', 'NS3_PACKET_OTHERHOST'], outer_class=root_module['ns3::NetDevice'], import_from_module='ns.network') + ## nix-vector.h (module 'network'): ns3::NixVector [class] + module.add_class('NixVector', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::NixVector, ns3::empty, ns3::DefaultDeleter >']) + ## node.h (module 'network'): ns3::Node [class] + module.add_class('Node', import_from_module='ns.network', parent=root_module['ns3::Object']) + ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker [class] + module.add_class('ObjectFactoryChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker']) + ## object-factory.h (module 'core'): ns3::ObjectFactoryValue [class] + module.add_class('ObjectFactoryValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue']) + ## packet.h (module 'network'): ns3::Packet [class] + module.add_class('Packet', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter >']) + ## pointer.h (module 'core'): ns3::PointerChecker [class] + module.add_class('PointerChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker']) + ## pointer.h (module 'core'): ns3::PointerValue [class] + module.add_class('PointerValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue']) + ## nstime.h (module 'core'): ns3::TimeChecker [class] + module.add_class('TimeChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker']) + ## nstime.h (module 'core'): ns3::TimeValue [class] + module.add_class('TimeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue']) + ## type-id.h (module 'core'): ns3::TypeIdChecker [class] + module.add_class('TypeIdChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker']) + ## type-id.h (module 'core'): ns3::TypeIdValue [class] + module.add_class('TypeIdValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue']) + ## uan-channel.h (module 'uan'): ns3::UanChannel [class] + module.add_class('UanChannel', parent=root_module['ns3::Channel']) + ## uan-tx-mode.h (module 'uan'): ns3::UanModesListChecker [class] + module.add_class('UanModesListChecker', parent=root_module['ns3::AttributeChecker']) + ## uan-tx-mode.h (module 'uan'): ns3::UanModesListValue [class] + module.add_class('UanModesListValue', parent=root_module['ns3::AttributeValue']) + ## uan-net-device.h (module 'uan'): ns3::UanNetDevice [class] + module.add_class('UanNetDevice', parent=root_module['ns3::NetDevice']) + ## uinteger.h (module 'core'): ns3::UintegerValue [class] + module.add_class('UintegerValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue']) + ## vector.h (module 'core'): ns3::Vector2DChecker [class] + module.add_class('Vector2DChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker']) + ## vector.h (module 'core'): ns3::Vector2DValue [class] + module.add_class('Vector2DValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue']) + ## vector.h (module 'core'): ns3::Vector3DChecker [class] + module.add_class('Vector3DChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker']) + ## vector.h (module 'core'): ns3::Vector3DValue [class] + module.add_class('Vector3DValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue']) + ## acoustic-modem-energy-model.h (module 'uan'): ns3::AcousticModemEnergyModel [class] + module.add_class('AcousticModemEnergyModel', parent=root_module['ns3::DeviceEnergyModel']) + ## address.h (module 'network'): ns3::AddressChecker [class] + module.add_class('AddressChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker']) + ## address.h (module 'network'): ns3::AddressValue [class] + module.add_class('AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue']) + module.add_container('std::list< std::pair< ns3::Ptr< ns3::Packet >, ns3::UanAddress > >', 'std::pair< ns3::Ptr< ns3::Packet >, ns3::UanAddress >', container_type='list') + module.add_container('std::vector< ns3::Tap >', 'ns3::Tap', container_type='vector') + module.add_container('std::vector< std::complex< double > >', 'std::complex< double >', container_type='vector') + module.add_container('std::vector< double >', 'double', container_type='vector') + module.add_container('std::set< unsigned char >', 'unsigned char', container_type='set') + module.add_container('std::list< ns3::UanPacketArrival >', 'ns3::UanPacketArrival', container_type='list') + module.add_container('std::list< ns3::Ptr< ns3::UanPhy > >', 'ns3::Ptr< ns3::UanPhy >', container_type='list') + module.add_container('std::vector< std::pair< ns3::Ptr< ns3::UanNetDevice >, ns3::Ptr< ns3::UanTransducer > > >', 'std::pair< ns3::Ptr< ns3::UanNetDevice >, ns3::Ptr< ns3::UanTransducer > >', container_type='vector') + module.add_container('std::list< ns3::Ptr< ns3::UanTransducer > >', 'ns3::Ptr< ns3::UanTransducer >', container_type='list') + typehandlers.add_type_alias('ns3::Vector3DValue', 'ns3::VectorValue') + typehandlers.add_type_alias('ns3::Vector3DValue*', 'ns3::VectorValue*') + typehandlers.add_type_alias('ns3::Vector3DValue&', 'ns3::VectorValue&') + module.add_typedef(root_module['ns3::Vector3DValue'], 'VectorValue') + typehandlers.add_type_alias('ns3::Vector3D', 'ns3::Vector') + typehandlers.add_type_alias('ns3::Vector3D*', 'ns3::Vector*') + typehandlers.add_type_alias('ns3::Vector3D&', 'ns3::Vector&') + module.add_typedef(root_module['ns3::Vector3D'], 'Vector') + typehandlers.add_type_alias('ns3::Vector3DChecker', 'ns3::VectorChecker') + typehandlers.add_type_alias('ns3::Vector3DChecker*', 'ns3::VectorChecker*') + typehandlers.add_type_alias('ns3::Vector3DChecker&', 'ns3::VectorChecker&') + module.add_typedef(root_module['ns3::Vector3DChecker'], 'VectorChecker') + + ## Register a nested module for the namespace FatalImpl + + nested_module = module.add_cpp_namespace('FatalImpl') + register_types_ns3_FatalImpl(nested_module) + + + ## Register a nested module for the namespace internal + + nested_module = module.add_cpp_namespace('internal') + register_types_ns3_internal(nested_module) + + +def register_types_ns3_FatalImpl(module): + root_module = module.get_root() + + +def register_types_ns3_internal(module): + root_module = module.get_root() + + +def register_methods(root_module): + register_Ns3Address_methods(root_module, root_module['ns3::Address']) + register_Ns3AttributeConstructionList_methods(root_module, root_module['ns3::AttributeConstructionList']) + register_Ns3AttributeConstructionListItem_methods(root_module, root_module['ns3::AttributeConstructionList::Item']) + register_Ns3Buffer_methods(root_module, root_module['ns3::Buffer']) + register_Ns3BufferIterator_methods(root_module, root_module['ns3::Buffer::Iterator']) + register_Ns3ByteTagIterator_methods(root_module, root_module['ns3::ByteTagIterator']) + register_Ns3ByteTagIteratorItem_methods(root_module, root_module['ns3::ByteTagIterator::Item']) + register_Ns3ByteTagList_methods(root_module, root_module['ns3::ByteTagList']) + register_Ns3ByteTagListIterator_methods(root_module, root_module['ns3::ByteTagList::Iterator']) + register_Ns3ByteTagListIteratorItem_methods(root_module, root_module['ns3::ByteTagList::Iterator::Item']) + register_Ns3CallbackBase_methods(root_module, root_module['ns3::CallbackBase']) + register_Ns3DeviceEnergyModelContainer_methods(root_module, root_module['ns3::DeviceEnergyModelContainer']) + register_Ns3DeviceEnergyModelHelper_methods(root_module, root_module['ns3::DeviceEnergyModelHelper']) + register_Ns3EnergySourceHelper_methods(root_module, root_module['ns3::EnergySourceHelper']) + register_Ns3EventId_methods(root_module, root_module['ns3::EventId']) + register_Ns3Ipv4Address_methods(root_module, root_module['ns3::Ipv4Address']) + register_Ns3Ipv4Mask_methods(root_module, root_module['ns3::Ipv4Mask']) + register_Ns3Ipv6Address_methods(root_module, root_module['ns3::Ipv6Address']) + register_Ns3Ipv6Prefix_methods(root_module, root_module['ns3::Ipv6Prefix']) + register_Ns3NetDeviceContainer_methods(root_module, root_module['ns3::NetDeviceContainer']) + register_Ns3NodeContainer_methods(root_module, root_module['ns3::NodeContainer']) + register_Ns3ObjectBase_methods(root_module, root_module['ns3::ObjectBase']) + register_Ns3ObjectDeleter_methods(root_module, root_module['ns3::ObjectDeleter']) + register_Ns3ObjectFactory_methods(root_module, root_module['ns3::ObjectFactory']) + register_Ns3PacketMetadata_methods(root_module, root_module['ns3::PacketMetadata']) + register_Ns3PacketMetadataItem_methods(root_module, root_module['ns3::PacketMetadata::Item']) + register_Ns3PacketMetadataItemIterator_methods(root_module, root_module['ns3::PacketMetadata::ItemIterator']) + register_Ns3PacketTagIterator_methods(root_module, root_module['ns3::PacketTagIterator']) + register_Ns3PacketTagIteratorItem_methods(root_module, root_module['ns3::PacketTagIterator::Item']) + register_Ns3PacketTagList_methods(root_module, root_module['ns3::PacketTagList']) + register_Ns3PacketTagListTagData_methods(root_module, root_module['ns3::PacketTagList::TagData']) + register_Ns3Reservation_methods(root_module, root_module['ns3::Reservation']) + register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, root_module['ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter >']) + register_Ns3Simulator_methods(root_module, root_module['ns3::Simulator']) + register_Ns3Tag_methods(root_module, root_module['ns3::Tag']) + register_Ns3TagBuffer_methods(root_module, root_module['ns3::TagBuffer']) + register_Ns3Tap_methods(root_module, root_module['ns3::Tap']) + register_Ns3TracedValue__Double_methods(root_module, root_module['ns3::TracedValue< double >']) + register_Ns3TypeId_methods(root_module, root_module['ns3::TypeId']) + register_Ns3TypeIdAttributeInformation_methods(root_module, root_module['ns3::TypeId::AttributeInformation']) + register_Ns3TypeIdTraceSourceInformation_methods(root_module, root_module['ns3::TypeId::TraceSourceInformation']) + register_Ns3UanAddress_methods(root_module, root_module['ns3::UanAddress']) + register_Ns3UanHelper_methods(root_module, root_module['ns3::UanHelper']) + register_Ns3UanModesList_methods(root_module, root_module['ns3::UanModesList']) + register_Ns3UanPacketArrival_methods(root_module, root_module['ns3::UanPacketArrival']) + register_Ns3UanPdp_methods(root_module, root_module['ns3::UanPdp']) + register_Ns3UanPhyListener_methods(root_module, root_module['ns3::UanPhyListener']) + register_Ns3UanTxMode_methods(root_module, root_module['ns3::UanTxMode']) + register_Ns3UanTxModeFactory_methods(root_module, root_module['ns3::UanTxModeFactory']) + register_Ns3Vector2D_methods(root_module, root_module['ns3::Vector2D']) + register_Ns3Vector3D_methods(root_module, root_module['ns3::Vector3D']) + register_Ns3Empty_methods(root_module, root_module['ns3::empty']) + register_Ns3Int64x64_t_methods(root_module, root_module['ns3::int64x64_t']) + register_Ns3AcousticModemEnergyModelHelper_methods(root_module, root_module['ns3::AcousticModemEnergyModelHelper']) + register_Ns3Chunk_methods(root_module, root_module['ns3::Chunk']) + register_Ns3Header_methods(root_module, root_module['ns3::Header']) + register_Ns3Object_methods(root_module, root_module['ns3::Object']) + register_Ns3ObjectAggregateIterator_methods(root_module, root_module['ns3::Object::AggregateIterator']) + register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter >']) + register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter >']) + register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter >']) + register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3CallbackImplBase__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter >']) + register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3EventImpl__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter >']) + register_Ns3SimpleRefCount__Ns3NixVector_Ns3Empty_Ns3DefaultDeleter__lt__ns3NixVector__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::NixVector, ns3::empty, ns3::DefaultDeleter >']) + register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Packet__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter >']) + register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3TraceSourceAccessor__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter >']) + register_Ns3Time_methods(root_module, root_module['ns3::Time']) + register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor']) + register_Ns3Trailer_methods(root_module, root_module['ns3::Trailer']) + register_Ns3UanHeaderCommon_methods(root_module, root_module['ns3::UanHeaderCommon']) + register_Ns3UanHeaderRcAck_methods(root_module, root_module['ns3::UanHeaderRcAck']) + register_Ns3UanHeaderRcCts_methods(root_module, root_module['ns3::UanHeaderRcCts']) + register_Ns3UanHeaderRcCtsGlobal_methods(root_module, root_module['ns3::UanHeaderRcCtsGlobal']) + register_Ns3UanHeaderRcData_methods(root_module, root_module['ns3::UanHeaderRcData']) + register_Ns3UanHeaderRcRts_methods(root_module, root_module['ns3::UanHeaderRcRts']) + register_Ns3UanMac_methods(root_module, root_module['ns3::UanMac']) + register_Ns3UanMacAloha_methods(root_module, root_module['ns3::UanMacAloha']) + register_Ns3UanMacCw_methods(root_module, root_module['ns3::UanMacCw']) + register_Ns3UanMacRc_methods(root_module, root_module['ns3::UanMacRc']) + register_Ns3UanMacRcGw_methods(root_module, root_module['ns3::UanMacRcGw']) + register_Ns3UanNoiseModel_methods(root_module, root_module['ns3::UanNoiseModel']) + register_Ns3UanNoiseModelDefault_methods(root_module, root_module['ns3::UanNoiseModelDefault']) + register_Ns3UanPhy_methods(root_module, root_module['ns3::UanPhy']) + register_Ns3UanPhyCalcSinr_methods(root_module, root_module['ns3::UanPhyCalcSinr']) + register_Ns3UanPhyCalcSinrDefault_methods(root_module, root_module['ns3::UanPhyCalcSinrDefault']) + register_Ns3UanPhyCalcSinrDual_methods(root_module, root_module['ns3::UanPhyCalcSinrDual']) + register_Ns3UanPhyCalcSinrFhFsk_methods(root_module, root_module['ns3::UanPhyCalcSinrFhFsk']) + register_Ns3UanPhyDual_methods(root_module, root_module['ns3::UanPhyDual']) + register_Ns3UanPhyGen_methods(root_module, root_module['ns3::UanPhyGen']) + register_Ns3UanPhyPer_methods(root_module, root_module['ns3::UanPhyPer']) + register_Ns3UanPhyPerGenDefault_methods(root_module, root_module['ns3::UanPhyPerGenDefault']) + register_Ns3UanPhyPerUmodem_methods(root_module, root_module['ns3::UanPhyPerUmodem']) + register_Ns3UanPropModel_methods(root_module, root_module['ns3::UanPropModel']) + register_Ns3UanPropModelIdeal_methods(root_module, root_module['ns3::UanPropModelIdeal']) + register_Ns3UanPropModelThorp_methods(root_module, root_module['ns3::UanPropModelThorp']) + register_Ns3UanTransducer_methods(root_module, root_module['ns3::UanTransducer']) + register_Ns3UanTransducerHd_methods(root_module, root_module['ns3::UanTransducerHd']) + register_Ns3AttributeAccessor_methods(root_module, root_module['ns3::AttributeAccessor']) + register_Ns3AttributeChecker_methods(root_module, root_module['ns3::AttributeChecker']) + register_Ns3AttributeValue_methods(root_module, root_module['ns3::AttributeValue']) + register_Ns3BooleanChecker_methods(root_module, root_module['ns3::BooleanChecker']) + register_Ns3BooleanValue_methods(root_module, root_module['ns3::BooleanValue']) + register_Ns3CallbackChecker_methods(root_module, root_module['ns3::CallbackChecker']) + register_Ns3CallbackImplBase_methods(root_module, root_module['ns3::CallbackImplBase']) + register_Ns3CallbackValue_methods(root_module, root_module['ns3::CallbackValue']) + register_Ns3Channel_methods(root_module, root_module['ns3::Channel']) + register_Ns3DeviceEnergyModel_methods(root_module, root_module['ns3::DeviceEnergyModel']) + register_Ns3DoubleValue_methods(root_module, root_module['ns3::DoubleValue']) + register_Ns3EmptyAttributeValue_methods(root_module, root_module['ns3::EmptyAttributeValue']) + register_Ns3EnergySource_methods(root_module, root_module['ns3::EnergySource']) + register_Ns3EnergySourceContainer_methods(root_module, root_module['ns3::EnergySourceContainer']) + register_Ns3EnumChecker_methods(root_module, root_module['ns3::EnumChecker']) + register_Ns3EnumValue_methods(root_module, root_module['ns3::EnumValue']) + register_Ns3EventImpl_methods(root_module, root_module['ns3::EventImpl']) + register_Ns3IntegerValue_methods(root_module, root_module['ns3::IntegerValue']) + register_Ns3Ipv4AddressChecker_methods(root_module, root_module['ns3::Ipv4AddressChecker']) + register_Ns3Ipv4AddressValue_methods(root_module, root_module['ns3::Ipv4AddressValue']) + register_Ns3Ipv4MaskChecker_methods(root_module, root_module['ns3::Ipv4MaskChecker']) + register_Ns3Ipv4MaskValue_methods(root_module, root_module['ns3::Ipv4MaskValue']) + register_Ns3Ipv6AddressChecker_methods(root_module, root_module['ns3::Ipv6AddressChecker']) + register_Ns3Ipv6AddressValue_methods(root_module, root_module['ns3::Ipv6AddressValue']) + register_Ns3Ipv6PrefixChecker_methods(root_module, root_module['ns3::Ipv6PrefixChecker']) + register_Ns3Ipv6PrefixValue_methods(root_module, root_module['ns3::Ipv6PrefixValue']) + register_Ns3MobilityModel_methods(root_module, root_module['ns3::MobilityModel']) + register_Ns3NetDevice_methods(root_module, root_module['ns3::NetDevice']) + register_Ns3NixVector_methods(root_module, root_module['ns3::NixVector']) + register_Ns3Node_methods(root_module, root_module['ns3::Node']) + register_Ns3ObjectFactoryChecker_methods(root_module, root_module['ns3::ObjectFactoryChecker']) + register_Ns3ObjectFactoryValue_methods(root_module, root_module['ns3::ObjectFactoryValue']) + register_Ns3Packet_methods(root_module, root_module['ns3::Packet']) + register_Ns3PointerChecker_methods(root_module, root_module['ns3::PointerChecker']) + register_Ns3PointerValue_methods(root_module, root_module['ns3::PointerValue']) + register_Ns3TimeChecker_methods(root_module, root_module['ns3::TimeChecker']) + register_Ns3TimeValue_methods(root_module, root_module['ns3::TimeValue']) + register_Ns3TypeIdChecker_methods(root_module, root_module['ns3::TypeIdChecker']) + register_Ns3TypeIdValue_methods(root_module, root_module['ns3::TypeIdValue']) + register_Ns3UanChannel_methods(root_module, root_module['ns3::UanChannel']) + register_Ns3UanModesListChecker_methods(root_module, root_module['ns3::UanModesListChecker']) + register_Ns3UanModesListValue_methods(root_module, root_module['ns3::UanModesListValue']) + register_Ns3UanNetDevice_methods(root_module, root_module['ns3::UanNetDevice']) + register_Ns3UintegerValue_methods(root_module, root_module['ns3::UintegerValue']) + register_Ns3Vector2DChecker_methods(root_module, root_module['ns3::Vector2DChecker']) + register_Ns3Vector2DValue_methods(root_module, root_module['ns3::Vector2DValue']) + register_Ns3Vector3DChecker_methods(root_module, root_module['ns3::Vector3DChecker']) + register_Ns3Vector3DValue_methods(root_module, root_module['ns3::Vector3DValue']) + register_Ns3AcousticModemEnergyModel_methods(root_module, root_module['ns3::AcousticModemEnergyModel']) + register_Ns3AddressChecker_methods(root_module, root_module['ns3::AddressChecker']) + register_Ns3AddressValue_methods(root_module, root_module['ns3::AddressValue']) + return + +def register_Ns3Address_methods(root_module, cls): + cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('!=') + cls.add_output_stream_operator() + cls.add_binary_comparison_operator('==') + ## address.h (module 'network'): ns3::Address::Address() [constructor] + cls.add_constructor([]) + ## address.h (module 'network'): ns3::Address::Address(uint8_t type, uint8_t const * buffer, uint8_t len) [constructor] + cls.add_constructor([param('uint8_t', 'type'), param('uint8_t const *', 'buffer'), param('uint8_t', 'len')]) + ## address.h (module 'network'): ns3::Address::Address(ns3::Address const & address) [copy constructor] + cls.add_constructor([param('ns3::Address const &', 'address')]) + ## address.h (module 'network'): bool ns3::Address::CheckCompatible(uint8_t type, uint8_t len) const [member function] + cls.add_method('CheckCompatible', + 'bool', + [param('uint8_t', 'type'), param('uint8_t', 'len')], + is_const=True) + ## address.h (module 'network'): uint32_t ns3::Address::CopyAllFrom(uint8_t const * buffer, uint8_t len) [member function] + cls.add_method('CopyAllFrom', + 'uint32_t', + [param('uint8_t const *', 'buffer'), param('uint8_t', 'len')]) + ## address.h (module 'network'): uint32_t ns3::Address::CopyAllTo(uint8_t * buffer, uint8_t len) const [member function] + cls.add_method('CopyAllTo', + 'uint32_t', + [param('uint8_t *', 'buffer'), param('uint8_t', 'len')], + is_const=True) + ## address.h (module 'network'): uint32_t ns3::Address::CopyFrom(uint8_t const * buffer, uint8_t len) [member function] + cls.add_method('CopyFrom', + 'uint32_t', + [param('uint8_t const *', 'buffer'), param('uint8_t', 'len')]) + ## address.h (module 'network'): uint32_t ns3::Address::CopyTo(uint8_t * buffer) const [member function] + cls.add_method('CopyTo', + 'uint32_t', + [param('uint8_t *', 'buffer')], + is_const=True) + ## address.h (module 'network'): void ns3::Address::Deserialize(ns3::TagBuffer buffer) [member function] + cls.add_method('Deserialize', + 'void', + [param('ns3::TagBuffer', 'buffer')]) + ## address.h (module 'network'): uint8_t ns3::Address::GetLength() const [member function] + cls.add_method('GetLength', + 'uint8_t', + [], + is_const=True) + ## address.h (module 'network'): uint32_t ns3::Address::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', + 'uint32_t', + [], + is_const=True) + ## address.h (module 'network'): bool ns3::Address::IsInvalid() const [member function] + cls.add_method('IsInvalid', + 'bool', + [], + is_const=True) + ## address.h (module 'network'): bool ns3::Address::IsMatchingType(uint8_t type) const [member function] + cls.add_method('IsMatchingType', + 'bool', + [param('uint8_t', 'type')], + is_const=True) + ## address.h (module 'network'): static uint8_t ns3::Address::Register() [member function] + cls.add_method('Register', + 'uint8_t', + [], + is_static=True) + ## address.h (module 'network'): void ns3::Address::Serialize(ns3::TagBuffer buffer) const [member function] + cls.add_method('Serialize', + 'void', + [param('ns3::TagBuffer', 'buffer')], + is_const=True) + return + +def register_Ns3AttributeConstructionList_methods(root_module, cls): + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [copy constructor] + cls.add_constructor([param('ns3::AttributeConstructionList const &', 'arg0')]) + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList() [constructor] + cls.add_constructor([]) + ## attribute-construction-list.h (module 'core'): void ns3::AttributeConstructionList::Add(std::string name, ns3::Ptr checker, ns3::Ptr value) [member function] + cls.add_method('Add', + 'void', + [param('std::string', 'name'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::Ptr< ns3::AttributeValue >', 'value')]) + ## attribute-construction-list.h (module 'core'): std::_List_const_iterator ns3::AttributeConstructionList::Begin() const [member function] + cls.add_method('Begin', + 'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', + [], + is_const=True) + ## attribute-construction-list.h (module 'core'): std::_List_const_iterator ns3::AttributeConstructionList::End() const [member function] + cls.add_method('End', + 'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', + [], + is_const=True) + ## attribute-construction-list.h (module 'core'): ns3::Ptr ns3::AttributeConstructionList::Find(ns3::Ptr checker) const [member function] + cls.add_method('Find', + 'ns3::Ptr< ns3::AttributeValue >', + [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], + is_const=True) + return + +def register_Ns3AttributeConstructionListItem_methods(root_module, cls): + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item() [constructor] + cls.add_constructor([]) + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item(ns3::AttributeConstructionList::Item const & arg0) [copy constructor] + cls.add_constructor([param('ns3::AttributeConstructionList::Item const &', 'arg0')]) + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::checker [variable] + cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False) + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::name [variable] + cls.add_instance_attribute('name', 'std::string', is_const=False) + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::value [variable] + cls.add_instance_attribute('value', 'ns3::Ptr< ns3::AttributeValue >', is_const=False) + return + +def register_Ns3Buffer_methods(root_module, cls): + ## buffer.h (module 'network'): ns3::Buffer::Buffer() [constructor] + cls.add_constructor([]) + ## buffer.h (module 'network'): ns3::Buffer::Buffer(uint32_t dataSize) [constructor] + cls.add_constructor([param('uint32_t', 'dataSize')]) + ## buffer.h (module 'network'): ns3::Buffer::Buffer(uint32_t dataSize, bool initialize) [constructor] + cls.add_constructor([param('uint32_t', 'dataSize'), param('bool', 'initialize')]) + ## buffer.h (module 'network'): ns3::Buffer::Buffer(ns3::Buffer const & o) [copy constructor] + cls.add_constructor([param('ns3::Buffer const &', 'o')]) + ## buffer.h (module 'network'): bool ns3::Buffer::AddAtEnd(uint32_t end) [member function] + cls.add_method('AddAtEnd', + 'bool', + [param('uint32_t', 'end')]) + ## buffer.h (module 'network'): void ns3::Buffer::AddAtEnd(ns3::Buffer const & o) [member function] + cls.add_method('AddAtEnd', + 'void', + [param('ns3::Buffer const &', 'o')]) + ## buffer.h (module 'network'): bool ns3::Buffer::AddAtStart(uint32_t start) [member function] + cls.add_method('AddAtStart', + 'bool', + [param('uint32_t', 'start')]) + ## buffer.h (module 'network'): ns3::Buffer::Iterator ns3::Buffer::Begin() const [member function] + cls.add_method('Begin', + 'ns3::Buffer::Iterator', + [], + is_const=True) + ## buffer.h (module 'network'): void ns3::Buffer::CopyData(std::ostream * os, uint32_t size) const [member function] + cls.add_method('CopyData', + 'void', + [param('std::ostream *', 'os'), param('uint32_t', 'size')], + is_const=True) + ## buffer.h (module 'network'): uint32_t ns3::Buffer::CopyData(uint8_t * buffer, uint32_t size) const [member function] + cls.add_method('CopyData', + 'uint32_t', + [param('uint8_t *', 'buffer'), param('uint32_t', 'size')], + is_const=True) + ## buffer.h (module 'network'): ns3::Buffer ns3::Buffer::CreateFragment(uint32_t start, uint32_t length) const [member function] + cls.add_method('CreateFragment', + 'ns3::Buffer', + [param('uint32_t', 'start'), param('uint32_t', 'length')], + is_const=True) + ## buffer.h (module 'network'): ns3::Buffer ns3::Buffer::CreateFullCopy() const [member function] + cls.add_method('CreateFullCopy', + 'ns3::Buffer', + [], + is_const=True) + ## buffer.h (module 'network'): uint32_t ns3::Buffer::Deserialize(uint8_t const * buffer, uint32_t size) [member function] + cls.add_method('Deserialize', + 'uint32_t', + [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')]) + ## buffer.h (module 'network'): ns3::Buffer::Iterator ns3::Buffer::End() const [member function] + cls.add_method('End', + 'ns3::Buffer::Iterator', + [], + is_const=True) + ## buffer.h (module 'network'): int32_t ns3::Buffer::GetCurrentEndOffset() const [member function] + cls.add_method('GetCurrentEndOffset', + 'int32_t', + [], + is_const=True) + ## buffer.h (module 'network'): int32_t ns3::Buffer::GetCurrentStartOffset() const [member function] + cls.add_method('GetCurrentStartOffset', + 'int32_t', + [], + is_const=True) + ## buffer.h (module 'network'): uint32_t ns3::Buffer::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', + 'uint32_t', + [], + is_const=True) + ## buffer.h (module 'network'): uint32_t ns3::Buffer::GetSize() const [member function] + cls.add_method('GetSize', + 'uint32_t', + [], + is_const=True) + ## buffer.h (module 'network'): uint8_t const * ns3::Buffer::PeekData() const [member function] + cls.add_method('PeekData', + 'uint8_t const *', + [], + is_const=True) + ## buffer.h (module 'network'): void ns3::Buffer::RemoveAtEnd(uint32_t end) [member function] + cls.add_method('RemoveAtEnd', + 'void', + [param('uint32_t', 'end')]) + ## buffer.h (module 'network'): void ns3::Buffer::RemoveAtStart(uint32_t start) [member function] + cls.add_method('RemoveAtStart', + 'void', + [param('uint32_t', 'start')]) + ## buffer.h (module 'network'): uint32_t ns3::Buffer::Serialize(uint8_t * buffer, uint32_t maxSize) const [member function] + cls.add_method('Serialize', + 'uint32_t', + [param('uint8_t *', 'buffer'), param('uint32_t', 'maxSize')], + is_const=True) + return + +def register_Ns3BufferIterator_methods(root_module, cls): + ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator(ns3::Buffer::Iterator const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Buffer::Iterator const &', 'arg0')]) + ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator() [constructor] + cls.add_constructor([]) + ## buffer.h (module 'network'): uint16_t ns3::Buffer::Iterator::CalculateIpChecksum(uint16_t size) [member function] + cls.add_method('CalculateIpChecksum', + 'uint16_t', + [param('uint16_t', 'size')]) + ## buffer.h (module 'network'): uint16_t ns3::Buffer::Iterator::CalculateIpChecksum(uint16_t size, uint32_t initialChecksum) [member function] + cls.add_method('CalculateIpChecksum', + 'uint16_t', + [param('uint16_t', 'size'), param('uint32_t', 'initialChecksum')]) + ## buffer.h (module 'network'): uint32_t ns3::Buffer::Iterator::GetDistanceFrom(ns3::Buffer::Iterator const & o) const [member function] + cls.add_method('GetDistanceFrom', + 'uint32_t', + [param('ns3::Buffer::Iterator const &', 'o')], + is_const=True) + ## buffer.h (module 'network'): uint32_t ns3::Buffer::Iterator::GetSize() const [member function] + cls.add_method('GetSize', + 'uint32_t', + [], + is_const=True) + ## buffer.h (module 'network'): bool ns3::Buffer::Iterator::IsEnd() const [member function] + cls.add_method('IsEnd', + 'bool', + [], + is_const=True) + ## buffer.h (module 'network'): bool ns3::Buffer::Iterator::IsStart() const [member function] + cls.add_method('IsStart', + 'bool', + [], + is_const=True) + ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Next() [member function] + cls.add_method('Next', + 'void', + []) + ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Next(uint32_t delta) [member function] + cls.add_method('Next', + 'void', + [param('uint32_t', 'delta')]) + ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Prev() [member function] + cls.add_method('Prev', + 'void', + []) + ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Prev(uint32_t delta) [member function] + cls.add_method('Prev', + 'void', + [param('uint32_t', 'delta')]) + ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Read(uint8_t * buffer, uint32_t size) [member function] + cls.add_method('Read', + 'void', + [param('uint8_t *', 'buffer'), param('uint32_t', 'size')]) + ## buffer.h (module 'network'): uint16_t ns3::Buffer::Iterator::ReadLsbtohU16() [member function] + cls.add_method('ReadLsbtohU16', + 'uint16_t', + []) + ## buffer.h (module 'network'): uint32_t ns3::Buffer::Iterator::ReadLsbtohU32() [member function] + cls.add_method('ReadLsbtohU32', + 'uint32_t', + []) + ## buffer.h (module 'network'): uint64_t ns3::Buffer::Iterator::ReadLsbtohU64() [member function] + cls.add_method('ReadLsbtohU64', + 'uint64_t', + []) + ## buffer.h (module 'network'): uint16_t ns3::Buffer::Iterator::ReadNtohU16() [member function] + cls.add_method('ReadNtohU16', + 'uint16_t', + []) + ## buffer.h (module 'network'): uint32_t ns3::Buffer::Iterator::ReadNtohU32() [member function] + cls.add_method('ReadNtohU32', + 'uint32_t', + []) + ## buffer.h (module 'network'): uint64_t ns3::Buffer::Iterator::ReadNtohU64() [member function] + cls.add_method('ReadNtohU64', + 'uint64_t', + []) + ## buffer.h (module 'network'): uint16_t ns3::Buffer::Iterator::ReadU16() [member function] + cls.add_method('ReadU16', + 'uint16_t', + []) + ## buffer.h (module 'network'): uint32_t ns3::Buffer::Iterator::ReadU32() [member function] + cls.add_method('ReadU32', + 'uint32_t', + []) + ## buffer.h (module 'network'): uint64_t ns3::Buffer::Iterator::ReadU64() [member function] + cls.add_method('ReadU64', + 'uint64_t', + []) + ## buffer.h (module 'network'): uint8_t ns3::Buffer::Iterator::ReadU8() [member function] + cls.add_method('ReadU8', + 'uint8_t', + []) + ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Write(uint8_t const * buffer, uint32_t size) [member function] + cls.add_method('Write', + 'void', + [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')]) + ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Write(ns3::Buffer::Iterator start, ns3::Buffer::Iterator end) [member function] + cls.add_method('Write', + 'void', + [param('ns3::Buffer::Iterator', 'start'), param('ns3::Buffer::Iterator', 'end')]) + ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtolsbU16(uint16_t data) [member function] + cls.add_method('WriteHtolsbU16', + 'void', + [param('uint16_t', 'data')]) + ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtolsbU32(uint32_t data) [member function] + cls.add_method('WriteHtolsbU32', + 'void', + [param('uint32_t', 'data')]) + ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtolsbU64(uint64_t data) [member function] + cls.add_method('WriteHtolsbU64', + 'void', + [param('uint64_t', 'data')]) + ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtonU16(uint16_t data) [member function] + cls.add_method('WriteHtonU16', + 'void', + [param('uint16_t', 'data')]) + ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtonU32(uint32_t data) [member function] + cls.add_method('WriteHtonU32', + 'void', + [param('uint32_t', 'data')]) + ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtonU64(uint64_t data) [member function] + cls.add_method('WriteHtonU64', + 'void', + [param('uint64_t', 'data')]) + ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU16(uint16_t data) [member function] + cls.add_method('WriteU16', + 'void', + [param('uint16_t', 'data')]) + ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU32(uint32_t data) [member function] + cls.add_method('WriteU32', + 'void', + [param('uint32_t', 'data')]) + ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU64(uint64_t data) [member function] + cls.add_method('WriteU64', + 'void', + [param('uint64_t', 'data')]) + ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU8(uint8_t data) [member function] + cls.add_method('WriteU8', + 'void', + [param('uint8_t', 'data')]) + ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU8(uint8_t data, uint32_t len) [member function] + cls.add_method('WriteU8', + 'void', + [param('uint8_t', 'data'), param('uint32_t', 'len')]) + return + +def register_Ns3ByteTagIterator_methods(root_module, cls): + ## packet.h (module 'network'): ns3::ByteTagIterator::ByteTagIterator(ns3::ByteTagIterator const & arg0) [copy constructor] + cls.add_constructor([param('ns3::ByteTagIterator const &', 'arg0')]) + ## packet.h (module 'network'): bool ns3::ByteTagIterator::HasNext() const [member function] + cls.add_method('HasNext', + 'bool', + [], + is_const=True) + ## packet.h (module 'network'): ns3::ByteTagIterator::Item ns3::ByteTagIterator::Next() [member function] + cls.add_method('Next', + 'ns3::ByteTagIterator::Item', + []) + return + +def register_Ns3ByteTagIteratorItem_methods(root_module, cls): + ## packet.h (module 'network'): ns3::ByteTagIterator::Item::Item(ns3::ByteTagIterator::Item const & arg0) [copy constructor] + cls.add_constructor([param('ns3::ByteTagIterator::Item const &', 'arg0')]) + ## packet.h (module 'network'): uint32_t ns3::ByteTagIterator::Item::GetEnd() const [member function] + cls.add_method('GetEnd', + 'uint32_t', + [], + is_const=True) + ## packet.h (module 'network'): uint32_t ns3::ByteTagIterator::Item::GetStart() const [member function] + cls.add_method('GetStart', + 'uint32_t', + [], + is_const=True) + ## packet.h (module 'network'): void ns3::ByteTagIterator::Item::GetTag(ns3::Tag & tag) const [member function] + cls.add_method('GetTag', + 'void', + [param('ns3::Tag &', 'tag')], + is_const=True) + ## packet.h (module 'network'): ns3::TypeId ns3::ByteTagIterator::Item::GetTypeId() const [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_const=True) + return + +def register_Ns3ByteTagList_methods(root_module, cls): + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList() [constructor] + cls.add_constructor([]) + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList(ns3::ByteTagList const & o) [copy constructor] + cls.add_constructor([param('ns3::ByteTagList const &', 'o')]) + ## byte-tag-list.h (module 'network'): ns3::TagBuffer ns3::ByteTagList::Add(ns3::TypeId tid, uint32_t bufferSize, int32_t start, int32_t end) [member function] + cls.add_method('Add', + 'ns3::TagBuffer', + [param('ns3::TypeId', 'tid'), param('uint32_t', 'bufferSize'), param('int32_t', 'start'), param('int32_t', 'end')]) + ## byte-tag-list.h (module 'network'): void ns3::ByteTagList::Add(ns3::ByteTagList const & o) [member function] + cls.add_method('Add', + 'void', + [param('ns3::ByteTagList const &', 'o')]) + ## byte-tag-list.h (module 'network'): void ns3::ByteTagList::AddAtEnd(int32_t adjustment, int32_t appendOffset) [member function] + cls.add_method('AddAtEnd', + 'void', + [param('int32_t', 'adjustment'), param('int32_t', 'appendOffset')]) + ## byte-tag-list.h (module 'network'): void ns3::ByteTagList::AddAtStart(int32_t adjustment, int32_t prependOffset) [member function] + cls.add_method('AddAtStart', + 'void', + [param('int32_t', 'adjustment'), param('int32_t', 'prependOffset')]) + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator ns3::ByteTagList::Begin(int32_t offsetStart, int32_t offsetEnd) const [member function] + cls.add_method('Begin', + 'ns3::ByteTagList::Iterator', + [param('int32_t', 'offsetStart'), param('int32_t', 'offsetEnd')], + is_const=True) + ## byte-tag-list.h (module 'network'): void ns3::ByteTagList::RemoveAll() [member function] + cls.add_method('RemoveAll', + 'void', + []) + return + +def register_Ns3ByteTagListIterator_methods(root_module, cls): + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Iterator(ns3::ByteTagList::Iterator const & arg0) [copy constructor] + cls.add_constructor([param('ns3::ByteTagList::Iterator const &', 'arg0')]) + ## byte-tag-list.h (module 'network'): uint32_t ns3::ByteTagList::Iterator::GetOffsetStart() const [member function] + cls.add_method('GetOffsetStart', + 'uint32_t', + [], + is_const=True) + ## byte-tag-list.h (module 'network'): bool ns3::ByteTagList::Iterator::HasNext() const [member function] + cls.add_method('HasNext', + 'bool', + [], + is_const=True) + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item ns3::ByteTagList::Iterator::Next() [member function] + cls.add_method('Next', + 'ns3::ByteTagList::Iterator::Item', + []) + return + +def register_Ns3ByteTagListIteratorItem_methods(root_module, cls): + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::ByteTagList::Iterator::Item const & arg0) [copy constructor] + cls.add_constructor([param('ns3::ByteTagList::Iterator::Item const &', 'arg0')]) + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::TagBuffer buf) [constructor] + cls.add_constructor([param('ns3::TagBuffer', 'buf')]) + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::buf [variable] + cls.add_instance_attribute('buf', 'ns3::TagBuffer', is_const=False) + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::end [variable] + cls.add_instance_attribute('end', 'int32_t', is_const=False) + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::size [variable] + cls.add_instance_attribute('size', 'uint32_t', is_const=False) + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::start [variable] + cls.add_instance_attribute('start', 'int32_t', is_const=False) + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::tid [variable] + cls.add_instance_attribute('tid', 'ns3::TypeId', is_const=False) + return + +def register_Ns3CallbackBase_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [copy constructor] + cls.add_constructor([param('ns3::CallbackBase const &', 'arg0')]) + ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::Ptr ns3::CallbackBase::GetImpl() const [member function] + cls.add_method('GetImpl', + 'ns3::Ptr< ns3::CallbackImplBase >', + [], + is_const=True) + ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::Ptr impl) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::CallbackImplBase >', 'impl')], + visibility='protected') + ## callback.h (module 'core'): static std::string ns3::CallbackBase::Demangle(std::string const & mangled) [member function] + cls.add_method('Demangle', + 'std::string', + [param('std::string const &', 'mangled')], + is_static=True, visibility='protected') + return + +def register_Ns3DeviceEnergyModelContainer_methods(root_module, cls): + ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer::DeviceEnergyModelContainer(ns3::DeviceEnergyModelContainer const & arg0) [copy constructor] + cls.add_constructor([param('ns3::DeviceEnergyModelContainer const &', 'arg0')]) + ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer::DeviceEnergyModelContainer() [constructor] + cls.add_constructor([]) + ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer::DeviceEnergyModelContainer(ns3::Ptr model) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::DeviceEnergyModel >', 'model')]) + ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer::DeviceEnergyModelContainer(std::string modelName) [constructor] + cls.add_constructor([param('std::string', 'modelName')]) + ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer::DeviceEnergyModelContainer(ns3::DeviceEnergyModelContainer const & a, ns3::DeviceEnergyModelContainer const & b) [constructor] + cls.add_constructor([param('ns3::DeviceEnergyModelContainer const &', 'a'), param('ns3::DeviceEnergyModelContainer const &', 'b')]) + ## device-energy-model-container.h (module 'energy'): void ns3::DeviceEnergyModelContainer::Add(ns3::DeviceEnergyModelContainer container) [member function] + cls.add_method('Add', + 'void', + [param('ns3::DeviceEnergyModelContainer', 'container')]) + ## device-energy-model-container.h (module 'energy'): void ns3::DeviceEnergyModelContainer::Add(ns3::Ptr model) [member function] + cls.add_method('Add', + 'void', + [param('ns3::Ptr< ns3::DeviceEnergyModel >', 'model')]) + ## device-energy-model-container.h (module 'energy'): void ns3::DeviceEnergyModelContainer::Add(std::string modelName) [member function] + cls.add_method('Add', + 'void', + [param('std::string', 'modelName')]) + ## device-energy-model-container.h (module 'energy'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::DeviceEnergyModelContainer::Begin() const [member function] + cls.add_method('Begin', + '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::DeviceEnergyModel > const, std::vector< ns3::Ptr< ns3::DeviceEnergyModel > > >', + [], + is_const=True) + ## device-energy-model-container.h (module 'energy'): void ns3::DeviceEnergyModelContainer::Clear() [member function] + cls.add_method('Clear', + 'void', + []) + ## device-energy-model-container.h (module 'energy'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::DeviceEnergyModelContainer::End() const [member function] + cls.add_method('End', + '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::DeviceEnergyModel > const, std::vector< ns3::Ptr< ns3::DeviceEnergyModel > > >', + [], + is_const=True) + ## device-energy-model-container.h (module 'energy'): ns3::Ptr ns3::DeviceEnergyModelContainer::Get(uint32_t i) const [member function] + cls.add_method('Get', + 'ns3::Ptr< ns3::DeviceEnergyModel >', + [param('uint32_t', 'i')], + is_const=True) + ## device-energy-model-container.h (module 'energy'): uint32_t ns3::DeviceEnergyModelContainer::GetN() const [member function] + cls.add_method('GetN', + 'uint32_t', + [], + is_const=True) + return + +def register_Ns3DeviceEnergyModelHelper_methods(root_module, cls): + ## energy-model-helper.h (module 'energy'): ns3::DeviceEnergyModelHelper::DeviceEnergyModelHelper() [constructor] + cls.add_constructor([]) + ## energy-model-helper.h (module 'energy'): ns3::DeviceEnergyModelHelper::DeviceEnergyModelHelper(ns3::DeviceEnergyModelHelper const & arg0) [copy constructor] + cls.add_constructor([param('ns3::DeviceEnergyModelHelper const &', 'arg0')]) + ## energy-model-helper.h (module 'energy'): ns3::DeviceEnergyModelContainer ns3::DeviceEnergyModelHelper::Install(ns3::Ptr device, ns3::Ptr source) const [member function] + cls.add_method('Install', + 'ns3::DeviceEnergyModelContainer', + [param('ns3::Ptr< ns3::NetDevice >', 'device'), param('ns3::Ptr< ns3::EnergySource >', 'source')], + is_const=True) + ## energy-model-helper.h (module 'energy'): ns3::DeviceEnergyModelContainer ns3::DeviceEnergyModelHelper::Install(ns3::NetDeviceContainer deviceContainer, ns3::EnergySourceContainer sourceContainer) const [member function] + cls.add_method('Install', + 'ns3::DeviceEnergyModelContainer', + [param('ns3::NetDeviceContainer', 'deviceContainer'), param('ns3::EnergySourceContainer', 'sourceContainer')], + is_const=True) + ## energy-model-helper.h (module 'energy'): void ns3::DeviceEnergyModelHelper::Set(std::string name, ns3::AttributeValue const & v) [member function] + cls.add_method('Set', + 'void', + [param('std::string', 'name'), param('ns3::AttributeValue const &', 'v')], + is_pure_virtual=True, is_virtual=True) + ## energy-model-helper.h (module 'energy'): ns3::Ptr ns3::DeviceEnergyModelHelper::DoInstall(ns3::Ptr device, ns3::Ptr source) const [member function] + cls.add_method('DoInstall', + 'ns3::Ptr< ns3::DeviceEnergyModel >', + [param('ns3::Ptr< ns3::NetDevice >', 'device'), param('ns3::Ptr< ns3::EnergySource >', 'source')], + is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + return + +def register_Ns3EnergySourceHelper_methods(root_module, cls): + ## energy-model-helper.h (module 'energy'): ns3::EnergySourceHelper::EnergySourceHelper() [constructor] + cls.add_constructor([]) + ## energy-model-helper.h (module 'energy'): ns3::EnergySourceHelper::EnergySourceHelper(ns3::EnergySourceHelper const & arg0) [copy constructor] + cls.add_constructor([param('ns3::EnergySourceHelper const &', 'arg0')]) + ## energy-model-helper.h (module 'energy'): ns3::EnergySourceContainer ns3::EnergySourceHelper::Install(ns3::Ptr node) const [member function] + cls.add_method('Install', + 'ns3::EnergySourceContainer', + [param('ns3::Ptr< ns3::Node >', 'node')], + is_const=True) + ## energy-model-helper.h (module 'energy'): ns3::EnergySourceContainer ns3::EnergySourceHelper::Install(ns3::NodeContainer c) const [member function] + cls.add_method('Install', + 'ns3::EnergySourceContainer', + [param('ns3::NodeContainer', 'c')], + is_const=True) + ## energy-model-helper.h (module 'energy'): ns3::EnergySourceContainer ns3::EnergySourceHelper::Install(std::string nodeName) const [member function] + cls.add_method('Install', + 'ns3::EnergySourceContainer', + [param('std::string', 'nodeName')], + is_const=True) + ## energy-model-helper.h (module 'energy'): ns3::EnergySourceContainer ns3::EnergySourceHelper::InstallAll() const [member function] + cls.add_method('InstallAll', + 'ns3::EnergySourceContainer', + [], + is_const=True) + ## energy-model-helper.h (module 'energy'): void ns3::EnergySourceHelper::Set(std::string name, ns3::AttributeValue const & v) [member function] + cls.add_method('Set', + 'void', + [param('std::string', 'name'), param('ns3::AttributeValue const &', 'v')], + is_pure_virtual=True, is_virtual=True) + ## energy-model-helper.h (module 'energy'): ns3::Ptr ns3::EnergySourceHelper::DoInstall(ns3::Ptr node) const [member function] + cls.add_method('DoInstall', + 'ns3::Ptr< ns3::EnergySource >', + [param('ns3::Ptr< ns3::Node >', 'node')], + is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + return + +def register_Ns3EventId_methods(root_module, cls): + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('==') + ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::EventId const & arg0) [copy constructor] + cls.add_constructor([param('ns3::EventId const &', 'arg0')]) + ## event-id.h (module 'core'): ns3::EventId::EventId() [constructor] + cls.add_constructor([]) + ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::Ptr const & impl, uint64_t ts, uint32_t context, uint32_t uid) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::EventImpl > const &', 'impl'), param('uint64_t', 'ts'), param('uint32_t', 'context'), param('uint32_t', 'uid')]) + ## event-id.h (module 'core'): void ns3::EventId::Cancel() [member function] + cls.add_method('Cancel', + 'void', + []) + ## event-id.h (module 'core'): uint32_t ns3::EventId::GetContext() const [member function] + cls.add_method('GetContext', + 'uint32_t', + [], + is_const=True) + ## event-id.h (module 'core'): uint64_t ns3::EventId::GetTs() const [member function] + cls.add_method('GetTs', + 'uint64_t', + [], + is_const=True) + ## event-id.h (module 'core'): uint32_t ns3::EventId::GetUid() const [member function] + cls.add_method('GetUid', + 'uint32_t', + [], + is_const=True) + ## event-id.h (module 'core'): bool ns3::EventId::IsExpired() const [member function] + cls.add_method('IsExpired', + 'bool', + [], + is_const=True) + ## event-id.h (module 'core'): bool ns3::EventId::IsRunning() const [member function] + cls.add_method('IsRunning', + 'bool', + [], + is_const=True) + ## event-id.h (module 'core'): ns3::EventImpl * ns3::EventId::PeekEventImpl() const [member function] + cls.add_method('PeekEventImpl', + 'ns3::EventImpl *', + [], + is_const=True) + return + +def register_Ns3Ipv4Address_methods(root_module, cls): + cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('!=') + cls.add_output_stream_operator() + cls.add_binary_comparison_operator('==') + ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Ipv4Address const &', 'arg0')]) + ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address() [constructor] + cls.add_constructor([]) + ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(uint32_t address) [constructor] + cls.add_constructor([param('uint32_t', 'address')]) + ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(char const * address) [constructor] + cls.add_constructor([param('char const *', 'address')]) + ## ipv4-address.h (module 'network'): ns3::Ipv4Address ns3::Ipv4Address::CombineMask(ns3::Ipv4Mask const & mask) const [member function] + cls.add_method('CombineMask', + 'ns3::Ipv4Address', + [param('ns3::Ipv4Mask const &', 'mask')], + is_const=True) + ## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::ConvertFrom(ns3::Address const & address) [member function] + cls.add_method('ConvertFrom', + 'ns3::Ipv4Address', + [param('ns3::Address const &', 'address')], + is_static=True) + ## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::Deserialize(uint8_t const * buf) [member function] + cls.add_method('Deserialize', + 'ns3::Ipv4Address', + [param('uint8_t const *', 'buf')], + is_static=True) + ## ipv4-address.h (module 'network'): uint32_t ns3::Ipv4Address::Get() const [member function] + cls.add_method('Get', + 'uint32_t', + [], + is_const=True) + ## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::GetAny() [member function] + cls.add_method('GetAny', + 'ns3::Ipv4Address', + [], + is_static=True) + ## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::GetBroadcast() [member function] + cls.add_method('GetBroadcast', + 'ns3::Ipv4Address', + [], + is_static=True) + ## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::GetLoopback() [member function] + cls.add_method('GetLoopback', + 'ns3::Ipv4Address', + [], + is_static=True) + ## ipv4-address.h (module 'network'): ns3::Ipv4Address ns3::Ipv4Address::GetSubnetDirectedBroadcast(ns3::Ipv4Mask const & mask) const [member function] + cls.add_method('GetSubnetDirectedBroadcast', + 'ns3::Ipv4Address', + [param('ns3::Ipv4Mask const &', 'mask')], + is_const=True) + ## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::GetZero() [member function] + cls.add_method('GetZero', + 'ns3::Ipv4Address', + [], + is_static=True) + ## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsBroadcast() const [member function] + cls.add_method('IsBroadcast', + 'bool', + [], + is_const=True) + ## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsEqual(ns3::Ipv4Address const & other) const [member function] + cls.add_method('IsEqual', + 'bool', + [param('ns3::Ipv4Address const &', 'other')], + is_const=True) + ## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsLocalMulticast() const [member function] + cls.add_method('IsLocalMulticast', + 'bool', + [], + is_const=True) + ## ipv4-address.h (module 'network'): static bool ns3::Ipv4Address::IsMatchingType(ns3::Address const & address) [member function] + cls.add_method('IsMatchingType', + 'bool', + [param('ns3::Address const &', 'address')], + is_static=True) + ## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsMulticast() const [member function] + cls.add_method('IsMulticast', + 'bool', + [], + is_const=True) + ## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsSubnetDirectedBroadcast(ns3::Ipv4Mask const & mask) const [member function] + cls.add_method('IsSubnetDirectedBroadcast', + 'bool', + [param('ns3::Ipv4Mask const &', 'mask')], + is_const=True) + ## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Print(std::ostream & os) const [member function] + cls.add_method('Print', + 'void', + [param('std::ostream &', 'os')], + is_const=True) + ## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Serialize(uint8_t * buf) const [member function] + cls.add_method('Serialize', + 'void', + [param('uint8_t *', 'buf')], + is_const=True) + ## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Set(uint32_t address) [member function] + cls.add_method('Set', + 'void', + [param('uint32_t', 'address')]) + ## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Set(char const * address) [member function] + cls.add_method('Set', + 'void', + [param('char const *', 'address')]) + return + +def register_Ns3Ipv4Mask_methods(root_module, cls): + cls.add_binary_comparison_operator('!=') + cls.add_output_stream_operator() + cls.add_binary_comparison_operator('==') + ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Ipv4Mask const &', 'arg0')]) + ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask() [constructor] + cls.add_constructor([]) + ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(uint32_t mask) [constructor] + cls.add_constructor([param('uint32_t', 'mask')]) + ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(char const * mask) [constructor] + cls.add_constructor([param('char const *', 'mask')]) + ## ipv4-address.h (module 'network'): uint32_t ns3::Ipv4Mask::Get() const [member function] + cls.add_method('Get', + 'uint32_t', + [], + is_const=True) + ## ipv4-address.h (module 'network'): uint32_t ns3::Ipv4Mask::GetInverse() const [member function] + cls.add_method('GetInverse', + 'uint32_t', + [], + is_const=True) + ## ipv4-address.h (module 'network'): static ns3::Ipv4Mask ns3::Ipv4Mask::GetLoopback() [member function] + cls.add_method('GetLoopback', + 'ns3::Ipv4Mask', + [], + is_static=True) + ## ipv4-address.h (module 'network'): static ns3::Ipv4Mask ns3::Ipv4Mask::GetOnes() [member function] + cls.add_method('GetOnes', + 'ns3::Ipv4Mask', + [], + is_static=True) + ## ipv4-address.h (module 'network'): uint16_t ns3::Ipv4Mask::GetPrefixLength() const [member function] + cls.add_method('GetPrefixLength', + 'uint16_t', + [], + is_const=True) + ## ipv4-address.h (module 'network'): static ns3::Ipv4Mask ns3::Ipv4Mask::GetZero() [member function] + cls.add_method('GetZero', + 'ns3::Ipv4Mask', + [], + is_static=True) + ## ipv4-address.h (module 'network'): bool ns3::Ipv4Mask::IsEqual(ns3::Ipv4Mask other) const [member function] + cls.add_method('IsEqual', + 'bool', + [param('ns3::Ipv4Mask', 'other')], + is_const=True) + ## ipv4-address.h (module 'network'): bool ns3::Ipv4Mask::IsMatch(ns3::Ipv4Address a, ns3::Ipv4Address b) const [member function] + cls.add_method('IsMatch', + 'bool', + [param('ns3::Ipv4Address', 'a'), param('ns3::Ipv4Address', 'b')], + is_const=True) + ## ipv4-address.h (module 'network'): void ns3::Ipv4Mask::Print(std::ostream & os) const [member function] + cls.add_method('Print', + 'void', + [param('std::ostream &', 'os')], + is_const=True) + ## ipv4-address.h (module 'network'): void ns3::Ipv4Mask::Set(uint32_t mask) [member function] + cls.add_method('Set', + 'void', + [param('uint32_t', 'mask')]) + return + +def register_Ns3Ipv6Address_methods(root_module, cls): + cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('!=') + cls.add_output_stream_operator() + cls.add_binary_comparison_operator('==') + ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address() [constructor] + cls.add_constructor([]) + ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(char const * address) [constructor] + cls.add_constructor([param('char const *', 'address')]) + ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(uint8_t * address) [constructor] + cls.add_constructor([param('uint8_t *', 'address')]) + ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const & addr) [copy constructor] + cls.add_constructor([param('ns3::Ipv6Address const &', 'addr')]) + ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const * addr) [constructor] + cls.add_constructor([param('ns3::Ipv6Address const *', 'addr')]) + ## ipv6-address.h (module 'network'): ns3::Ipv6Address ns3::Ipv6Address::CombinePrefix(ns3::Ipv6Prefix const & prefix) [member function] + cls.add_method('CombinePrefix', + 'ns3::Ipv6Address', + [param('ns3::Ipv6Prefix const &', 'prefix')]) + ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::ConvertFrom(ns3::Address const & address) [member function] + cls.add_method('ConvertFrom', + 'ns3::Ipv6Address', + [param('ns3::Address const &', 'address')], + is_static=True) + ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::Deserialize(uint8_t const * buf) [member function] + cls.add_method('Deserialize', + 'ns3::Ipv6Address', + [param('uint8_t const *', 'buf')], + is_static=True) + ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetAllHostsMulticast() [member function] + cls.add_method('GetAllHostsMulticast', + 'ns3::Ipv6Address', + [], + is_static=True) + ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetAllNodesMulticast() [member function] + cls.add_method('GetAllNodesMulticast', + 'ns3::Ipv6Address', + [], + is_static=True) + ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetAllRoutersMulticast() [member function] + cls.add_method('GetAllRoutersMulticast', + 'ns3::Ipv6Address', + [], + is_static=True) + ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetAny() [member function] + cls.add_method('GetAny', + 'ns3::Ipv6Address', + [], + is_static=True) + ## ipv6-address.h (module 'network'): void ns3::Ipv6Address::GetBytes(uint8_t * buf) const [member function] + cls.add_method('GetBytes', + 'void', + [param('uint8_t *', 'buf')], + is_const=True) + ## ipv6-address.h (module 'network'): ns3::Ipv4Address ns3::Ipv6Address::GetIpv4MappedAddress() const [member function] + cls.add_method('GetIpv4MappedAddress', + 'ns3::Ipv4Address', + [], + is_const=True) + ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetLoopback() [member function] + cls.add_method('GetLoopback', + 'ns3::Ipv6Address', + [], + is_static=True) + ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetOnes() [member function] + cls.add_method('GetOnes', + 'ns3::Ipv6Address', + [], + is_static=True) + ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetZero() [member function] + cls.add_method('GetZero', + 'ns3::Ipv6Address', + [], + is_static=True) + ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAllHostsMulticast() const [member function] + cls.add_method('IsAllHostsMulticast', + 'bool', + [], + is_const=True) + ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAllNodesMulticast() const [member function] + cls.add_method('IsAllNodesMulticast', + 'bool', + [], + is_const=True) + ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAllRoutersMulticast() const [member function] + cls.add_method('IsAllRoutersMulticast', + 'bool', + [], + is_const=True) + ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAny() const [member function] + cls.add_method('IsAny', + 'bool', + [], + is_const=True) + ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsEqual(ns3::Ipv6Address const & other) const [member function] + cls.add_method('IsEqual', + 'bool', + [param('ns3::Ipv6Address const &', 'other')], + is_const=True) + ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsIpv4MappedAddress() [member function] + cls.add_method('IsIpv4MappedAddress', + 'bool', + []) + ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsLinkLocal() const [member function] + cls.add_method('IsLinkLocal', + 'bool', + [], + is_const=True) + ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsLinkLocalMulticast() const [member function] + cls.add_method('IsLinkLocalMulticast', + 'bool', + [], + is_const=True) + ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsLocalhost() const [member function] + cls.add_method('IsLocalhost', + 'bool', + [], + is_const=True) + ## ipv6-address.h (module 'network'): static bool ns3::Ipv6Address::IsMatchingType(ns3::Address const & address) [member function] + cls.add_method('IsMatchingType', + 'bool', + [param('ns3::Address const &', 'address')], + is_static=True) + ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsMulticast() const [member function] + cls.add_method('IsMulticast', + 'bool', + [], + is_const=True) + ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsSolicitedMulticast() const [member function] + cls.add_method('IsSolicitedMulticast', + 'bool', + [], + is_const=True) + ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::MakeAutoconfiguredAddress(ns3::Mac48Address addr, ns3::Ipv6Address prefix) [member function] + cls.add_method('MakeAutoconfiguredAddress', + 'ns3::Ipv6Address', + [param('ns3::Mac48Address', 'addr'), param('ns3::Ipv6Address', 'prefix')], + is_static=True) + ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::MakeAutoconfiguredLinkLocalAddress(ns3::Mac48Address mac) [member function] + cls.add_method('MakeAutoconfiguredLinkLocalAddress', + 'ns3::Ipv6Address', + [param('ns3::Mac48Address', 'mac')], + is_static=True) + ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::MakeIpv4MappedAddress(ns3::Ipv4Address addr) [member function] + cls.add_method('MakeIpv4MappedAddress', + 'ns3::Ipv6Address', + [param('ns3::Ipv4Address', 'addr')], + is_static=True) + ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::MakeSolicitedAddress(ns3::Ipv6Address addr) [member function] + cls.add_method('MakeSolicitedAddress', + 'ns3::Ipv6Address', + [param('ns3::Ipv6Address', 'addr')], + is_static=True) + ## ipv6-address.h (module 'network'): void ns3::Ipv6Address::Print(std::ostream & os) const [member function] + cls.add_method('Print', + 'void', + [param('std::ostream &', 'os')], + is_const=True) + ## ipv6-address.h (module 'network'): void ns3::Ipv6Address::Serialize(uint8_t * buf) const [member function] + cls.add_method('Serialize', + 'void', + [param('uint8_t *', 'buf')], + is_const=True) + ## ipv6-address.h (module 'network'): void ns3::Ipv6Address::Set(char const * address) [member function] + cls.add_method('Set', + 'void', + [param('char const *', 'address')]) + ## ipv6-address.h (module 'network'): void ns3::Ipv6Address::Set(uint8_t * address) [member function] + cls.add_method('Set', + 'void', + [param('uint8_t *', 'address')]) + return + +def register_Ns3Ipv6Prefix_methods(root_module, cls): + cls.add_binary_comparison_operator('!=') + cls.add_output_stream_operator() + cls.add_binary_comparison_operator('==') + ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix() [constructor] + cls.add_constructor([]) + ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(uint8_t * prefix) [constructor] + cls.add_constructor([param('uint8_t *', 'prefix')]) + ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(char const * prefix) [constructor] + cls.add_constructor([param('char const *', 'prefix')]) + ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(uint8_t prefix) [constructor] + cls.add_constructor([param('uint8_t', 'prefix')]) + ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const & prefix) [copy constructor] + cls.add_constructor([param('ns3::Ipv6Prefix const &', 'prefix')]) + ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const * prefix) [constructor] + cls.add_constructor([param('ns3::Ipv6Prefix const *', 'prefix')]) + ## ipv6-address.h (module 'network'): void ns3::Ipv6Prefix::GetBytes(uint8_t * buf) const [member function] + cls.add_method('GetBytes', + 'void', + [param('uint8_t *', 'buf')], + is_const=True) + ## ipv6-address.h (module 'network'): static ns3::Ipv6Prefix ns3::Ipv6Prefix::GetLoopback() [member function] + cls.add_method('GetLoopback', + 'ns3::Ipv6Prefix', + [], + is_static=True) + ## ipv6-address.h (module 'network'): static ns3::Ipv6Prefix ns3::Ipv6Prefix::GetOnes() [member function] + cls.add_method('GetOnes', + 'ns3::Ipv6Prefix', + [], + is_static=True) + ## ipv6-address.h (module 'network'): uint8_t ns3::Ipv6Prefix::GetPrefixLength() const [member function] + cls.add_method('GetPrefixLength', + 'uint8_t', + [], + is_const=True) + ## ipv6-address.h (module 'network'): static ns3::Ipv6Prefix ns3::Ipv6Prefix::GetZero() [member function] + cls.add_method('GetZero', + 'ns3::Ipv6Prefix', + [], + is_static=True) + ## ipv6-address.h (module 'network'): bool ns3::Ipv6Prefix::IsEqual(ns3::Ipv6Prefix const & other) const [member function] + cls.add_method('IsEqual', + 'bool', + [param('ns3::Ipv6Prefix const &', 'other')], + is_const=True) + ## ipv6-address.h (module 'network'): bool ns3::Ipv6Prefix::IsMatch(ns3::Ipv6Address a, ns3::Ipv6Address b) const [member function] + cls.add_method('IsMatch', + 'bool', + [param('ns3::Ipv6Address', 'a'), param('ns3::Ipv6Address', 'b')], + is_const=True) + ## ipv6-address.h (module 'network'): void ns3::Ipv6Prefix::Print(std::ostream & os) const [member function] + cls.add_method('Print', + 'void', + [param('std::ostream &', 'os')], + is_const=True) + return + +def register_Ns3NetDeviceContainer_methods(root_module, cls): + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::NetDeviceContainer const & arg0) [copy constructor] + cls.add_constructor([param('ns3::NetDeviceContainer const &', 'arg0')]) + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer() [constructor] + cls.add_constructor([]) + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::Ptr dev) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::NetDevice >', 'dev')]) + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(std::string devName) [constructor] + cls.add_constructor([param('std::string', 'devName')]) + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::NetDeviceContainer const & a, ns3::NetDeviceContainer const & b) [constructor] + cls.add_constructor([param('ns3::NetDeviceContainer const &', 'a'), param('ns3::NetDeviceContainer const &', 'b')]) + ## net-device-container.h (module 'network'): void ns3::NetDeviceContainer::Add(ns3::NetDeviceContainer other) [member function] + cls.add_method('Add', + 'void', + [param('ns3::NetDeviceContainer', 'other')]) + ## net-device-container.h (module 'network'): void ns3::NetDeviceContainer::Add(ns3::Ptr device) [member function] + cls.add_method('Add', + 'void', + [param('ns3::Ptr< ns3::NetDevice >', 'device')]) + ## net-device-container.h (module 'network'): void ns3::NetDeviceContainer::Add(std::string deviceName) [member function] + cls.add_method('Add', + 'void', + [param('std::string', 'deviceName')]) + ## net-device-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NetDeviceContainer::Begin() const [member function] + cls.add_method('Begin', + '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::NetDevice > const, std::vector< ns3::Ptr< ns3::NetDevice > > >', + [], + is_const=True) + ## net-device-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NetDeviceContainer::End() const [member function] + cls.add_method('End', + '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::NetDevice > const, std::vector< ns3::Ptr< ns3::NetDevice > > >', + [], + is_const=True) + ## net-device-container.h (module 'network'): ns3::Ptr ns3::NetDeviceContainer::Get(uint32_t i) const [member function] + cls.add_method('Get', + 'ns3::Ptr< ns3::NetDevice >', + [param('uint32_t', 'i')], + is_const=True) + ## net-device-container.h (module 'network'): uint32_t ns3::NetDeviceContainer::GetN() const [member function] + cls.add_method('GetN', + 'uint32_t', + [], + is_const=True) + return + +def register_Ns3NodeContainer_methods(root_module, cls): + ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & arg0) [copy constructor] + cls.add_constructor([param('ns3::NodeContainer const &', 'arg0')]) + ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer() [constructor] + cls.add_constructor([]) + ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::Ptr node) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::Node >', 'node')]) + ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(std::string nodeName) [constructor] + cls.add_constructor([param('std::string', 'nodeName')]) + ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & a, ns3::NodeContainer const & b) [constructor] + cls.add_constructor([param('ns3::NodeContainer const &', 'a'), param('ns3::NodeContainer const &', 'b')]) + ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & a, ns3::NodeContainer const & b, ns3::NodeContainer const & c) [constructor] + cls.add_constructor([param('ns3::NodeContainer const &', 'a'), param('ns3::NodeContainer const &', 'b'), param('ns3::NodeContainer const &', 'c')]) + ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & a, ns3::NodeContainer const & b, ns3::NodeContainer const & c, ns3::NodeContainer const & d) [constructor] + cls.add_constructor([param('ns3::NodeContainer const &', 'a'), param('ns3::NodeContainer const &', 'b'), param('ns3::NodeContainer const &', 'c'), param('ns3::NodeContainer const &', 'd')]) + ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & a, ns3::NodeContainer const & b, ns3::NodeContainer const & c, ns3::NodeContainer const & d, ns3::NodeContainer const & e) [constructor] + cls.add_constructor([param('ns3::NodeContainer const &', 'a'), param('ns3::NodeContainer const &', 'b'), param('ns3::NodeContainer const &', 'c'), param('ns3::NodeContainer const &', 'd'), param('ns3::NodeContainer const &', 'e')]) + ## node-container.h (module 'network'): void ns3::NodeContainer::Add(ns3::NodeContainer other) [member function] + cls.add_method('Add', + 'void', + [param('ns3::NodeContainer', 'other')]) + ## node-container.h (module 'network'): void ns3::NodeContainer::Add(ns3::Ptr node) [member function] + cls.add_method('Add', + 'void', + [param('ns3::Ptr< ns3::Node >', 'node')]) + ## node-container.h (module 'network'): void ns3::NodeContainer::Add(std::string nodeName) [member function] + cls.add_method('Add', + 'void', + [param('std::string', 'nodeName')]) + ## node-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeContainer::Begin() const [member function] + cls.add_method('Begin', + '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', + [], + is_const=True) + ## node-container.h (module 'network'): void ns3::NodeContainer::Create(uint32_t n) [member function] + cls.add_method('Create', + 'void', + [param('uint32_t', 'n')]) + ## node-container.h (module 'network'): void ns3::NodeContainer::Create(uint32_t n, uint32_t systemId) [member function] + cls.add_method('Create', + 'void', + [param('uint32_t', 'n'), param('uint32_t', 'systemId')]) + ## node-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeContainer::End() const [member function] + cls.add_method('End', + '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', + [], + is_const=True) + ## node-container.h (module 'network'): ns3::Ptr ns3::NodeContainer::Get(uint32_t i) const [member function] + cls.add_method('Get', + 'ns3::Ptr< ns3::Node >', + [param('uint32_t', 'i')], + is_const=True) + ## node-container.h (module 'network'): static ns3::NodeContainer ns3::NodeContainer::GetGlobal() [member function] + cls.add_method('GetGlobal', + 'ns3::NodeContainer', + [], + is_static=True) + ## node-container.h (module 'network'): uint32_t ns3::NodeContainer::GetN() const [member function] + cls.add_method('GetN', + 'uint32_t', + [], + is_const=True) + return + +def register_Ns3ObjectBase_methods(root_module, cls): + ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase() [constructor] + cls.add_constructor([]) + ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor] + cls.add_constructor([param('ns3::ObjectBase const &', 'arg0')]) + ## object-base.h (module 'core'): void ns3::ObjectBase::GetAttribute(std::string name, ns3::AttributeValue & value) const [member function] + cls.add_method('GetAttribute', + 'void', + [param('std::string', 'name'), param('ns3::AttributeValue &', 'value')], + is_const=True) + ## object-base.h (module 'core'): bool ns3::ObjectBase::GetAttributeFailSafe(std::string name, ns3::AttributeValue & attribute) const [member function] + cls.add_method('GetAttributeFailSafe', + 'bool', + [param('std::string', 'name'), param('ns3::AttributeValue &', 'attribute')], + is_const=True) + ## object-base.h (module 'core'): ns3::TypeId ns3::ObjectBase::GetInstanceTypeId() const [member function] + cls.add_method('GetInstanceTypeId', + 'ns3::TypeId', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## object-base.h (module 'core'): static ns3::TypeId ns3::ObjectBase::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## object-base.h (module 'core'): void ns3::ObjectBase::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function] + cls.add_method('SetAttribute', + 'void', + [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')]) + ## object-base.h (module 'core'): bool ns3::ObjectBase::SetAttributeFailSafe(std::string name, ns3::AttributeValue const & value) [member function] + cls.add_method('SetAttributeFailSafe', + 'bool', + [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')]) + ## object-base.h (module 'core'): bool ns3::ObjectBase::TraceConnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function] + cls.add_method('TraceConnect', + 'bool', + [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')]) + ## object-base.h (module 'core'): bool ns3::ObjectBase::TraceConnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function] + cls.add_method('TraceConnectWithoutContext', + 'bool', + [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')]) + ## object-base.h (module 'core'): bool ns3::ObjectBase::TraceDisconnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function] + cls.add_method('TraceDisconnect', + 'bool', + [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')]) + ## object-base.h (module 'core'): bool ns3::ObjectBase::TraceDisconnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function] + cls.add_method('TraceDisconnectWithoutContext', + 'bool', + [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')]) + ## object-base.h (module 'core'): void ns3::ObjectBase::ConstructSelf(ns3::AttributeConstructionList const & attributes) [member function] + cls.add_method('ConstructSelf', + 'void', + [param('ns3::AttributeConstructionList const &', 'attributes')], + visibility='protected') + ## object-base.h (module 'core'): void ns3::ObjectBase::NotifyConstructionCompleted() [member function] + cls.add_method('NotifyConstructionCompleted', + 'void', + [], + visibility='protected', is_virtual=True) + return + +def register_Ns3ObjectDeleter_methods(root_module, cls): + ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter() [constructor] + cls.add_constructor([]) + ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter(ns3::ObjectDeleter const & arg0) [copy constructor] + cls.add_constructor([param('ns3::ObjectDeleter const &', 'arg0')]) + ## object.h (module 'core'): static void ns3::ObjectDeleter::Delete(ns3::Object * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::Object *', 'object')], + is_static=True) + return + +def register_Ns3ObjectFactory_methods(root_module, cls): + cls.add_output_stream_operator() + ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [copy constructor] + cls.add_constructor([param('ns3::ObjectFactory const &', 'arg0')]) + ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory() [constructor] + cls.add_constructor([]) + ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(std::string typeId) [constructor] + cls.add_constructor([param('std::string', 'typeId')]) + ## object-factory.h (module 'core'): ns3::Ptr ns3::ObjectFactory::Create() const [member function] + cls.add_method('Create', + 'ns3::Ptr< ns3::Object >', + [], + is_const=True) + ## object-factory.h (module 'core'): ns3::TypeId ns3::ObjectFactory::GetTypeId() const [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_const=True) + ## object-factory.h (module 'core'): void ns3::ObjectFactory::Set(std::string name, ns3::AttributeValue const & value) [member function] + cls.add_method('Set', + 'void', + [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')]) + ## object-factory.h (module 'core'): void ns3::ObjectFactory::SetTypeId(ns3::TypeId tid) [member function] + cls.add_method('SetTypeId', + 'void', + [param('ns3::TypeId', 'tid')]) + ## object-factory.h (module 'core'): void ns3::ObjectFactory::SetTypeId(char const * tid) [member function] + cls.add_method('SetTypeId', + 'void', + [param('char const *', 'tid')]) + ## object-factory.h (module 'core'): void ns3::ObjectFactory::SetTypeId(std::string tid) [member function] + cls.add_method('SetTypeId', + 'void', + [param('std::string', 'tid')]) + return + +def register_Ns3PacketMetadata_methods(root_module, cls): + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(uint64_t uid, uint32_t size) [constructor] + cls.add_constructor([param('uint64_t', 'uid'), param('uint32_t', 'size')]) + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(ns3::PacketMetadata const & o) [copy constructor] + cls.add_constructor([param('ns3::PacketMetadata const &', 'o')]) + ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddAtEnd(ns3::PacketMetadata const & o) [member function] + cls.add_method('AddAtEnd', + 'void', + [param('ns3::PacketMetadata const &', 'o')]) + ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddHeader(ns3::Header const & header, uint32_t size) [member function] + cls.add_method('AddHeader', + 'void', + [param('ns3::Header const &', 'header'), param('uint32_t', 'size')]) + ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddPaddingAtEnd(uint32_t end) [member function] + cls.add_method('AddPaddingAtEnd', + 'void', + [param('uint32_t', 'end')]) + ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddTrailer(ns3::Trailer const & trailer, uint32_t size) [member function] + cls.add_method('AddTrailer', + 'void', + [param('ns3::Trailer const &', 'trailer'), param('uint32_t', 'size')]) + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator ns3::PacketMetadata::BeginItem(ns3::Buffer buffer) const [member function] + cls.add_method('BeginItem', + 'ns3::PacketMetadata::ItemIterator', + [param('ns3::Buffer', 'buffer')], + is_const=True) + ## packet-metadata.h (module 'network'): ns3::PacketMetadata ns3::PacketMetadata::CreateFragment(uint32_t start, uint32_t end) const [member function] + cls.add_method('CreateFragment', + 'ns3::PacketMetadata', + [param('uint32_t', 'start'), param('uint32_t', 'end')], + is_const=True) + ## packet-metadata.h (module 'network'): uint32_t ns3::PacketMetadata::Deserialize(uint8_t const * buffer, uint32_t size) [member function] + cls.add_method('Deserialize', + 'uint32_t', + [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')]) + ## packet-metadata.h (module 'network'): static void ns3::PacketMetadata::Enable() [member function] + cls.add_method('Enable', + 'void', + [], + is_static=True) + ## packet-metadata.h (module 'network'): static void ns3::PacketMetadata::EnableChecking() [member function] + cls.add_method('EnableChecking', + 'void', + [], + is_static=True) + ## packet-metadata.h (module 'network'): uint32_t ns3::PacketMetadata::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', + 'uint32_t', + [], + is_const=True) + ## packet-metadata.h (module 'network'): uint64_t ns3::PacketMetadata::GetUid() const [member function] + cls.add_method('GetUid', + 'uint64_t', + [], + is_const=True) + ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::RemoveAtEnd(uint32_t end) [member function] + cls.add_method('RemoveAtEnd', + 'void', + [param('uint32_t', 'end')]) + ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::RemoveAtStart(uint32_t start) [member function] + cls.add_method('RemoveAtStart', + 'void', + [param('uint32_t', 'start')]) + ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::RemoveHeader(ns3::Header const & header, uint32_t size) [member function] + cls.add_method('RemoveHeader', + 'void', + [param('ns3::Header const &', 'header'), param('uint32_t', 'size')]) + ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::RemoveTrailer(ns3::Trailer const & trailer, uint32_t size) [member function] + cls.add_method('RemoveTrailer', + 'void', + [param('ns3::Trailer const &', 'trailer'), param('uint32_t', 'size')]) + ## packet-metadata.h (module 'network'): uint32_t ns3::PacketMetadata::Serialize(uint8_t * buffer, uint32_t maxSize) const [member function] + cls.add_method('Serialize', + 'uint32_t', + [param('uint8_t *', 'buffer'), param('uint32_t', 'maxSize')], + is_const=True) + return + +def register_Ns3PacketMetadataItem_methods(root_module, cls): + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item() [constructor] + cls.add_constructor([]) + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item(ns3::PacketMetadata::Item const & arg0) [copy constructor] + cls.add_constructor([param('ns3::PacketMetadata::Item const &', 'arg0')]) + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::current [variable] + cls.add_instance_attribute('current', 'ns3::Buffer::Iterator', is_const=False) + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::currentSize [variable] + cls.add_instance_attribute('currentSize', 'uint32_t', is_const=False) + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::currentTrimedFromEnd [variable] + cls.add_instance_attribute('currentTrimedFromEnd', 'uint32_t', is_const=False) + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::currentTrimedFromStart [variable] + cls.add_instance_attribute('currentTrimedFromStart', 'uint32_t', is_const=False) + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::isFragment [variable] + cls.add_instance_attribute('isFragment', 'bool', is_const=False) + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::tid [variable] + cls.add_instance_attribute('tid', 'ns3::TypeId', is_const=False) + return + +def register_Ns3PacketMetadataItemIterator_methods(root_module, cls): + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata::ItemIterator const & arg0) [copy constructor] + cls.add_constructor([param('ns3::PacketMetadata::ItemIterator const &', 'arg0')]) + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata const * metadata, ns3::Buffer buffer) [constructor] + cls.add_constructor([param('ns3::PacketMetadata const *', 'metadata'), param('ns3::Buffer', 'buffer')]) + ## packet-metadata.h (module 'network'): bool ns3::PacketMetadata::ItemIterator::HasNext() const [member function] + cls.add_method('HasNext', + 'bool', + [], + is_const=True) + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item ns3::PacketMetadata::ItemIterator::Next() [member function] + cls.add_method('Next', + 'ns3::PacketMetadata::Item', + []) + return + +def register_Ns3PacketTagIterator_methods(root_module, cls): + ## packet.h (module 'network'): ns3::PacketTagIterator::PacketTagIterator(ns3::PacketTagIterator const & arg0) [copy constructor] + cls.add_constructor([param('ns3::PacketTagIterator const &', 'arg0')]) + ## packet.h (module 'network'): bool ns3::PacketTagIterator::HasNext() const [member function] + cls.add_method('HasNext', + 'bool', + [], + is_const=True) + ## packet.h (module 'network'): ns3::PacketTagIterator::Item ns3::PacketTagIterator::Next() [member function] + cls.add_method('Next', + 'ns3::PacketTagIterator::Item', + []) + return + +def register_Ns3PacketTagIteratorItem_methods(root_module, cls): + ## packet.h (module 'network'): ns3::PacketTagIterator::Item::Item(ns3::PacketTagIterator::Item const & arg0) [copy constructor] + cls.add_constructor([param('ns3::PacketTagIterator::Item const &', 'arg0')]) + ## packet.h (module 'network'): void ns3::PacketTagIterator::Item::GetTag(ns3::Tag & tag) const [member function] + cls.add_method('GetTag', + 'void', + [param('ns3::Tag &', 'tag')], + is_const=True) + ## packet.h (module 'network'): ns3::TypeId ns3::PacketTagIterator::Item::GetTypeId() const [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_const=True) + return + +def register_Ns3PacketTagList_methods(root_module, cls): + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList() [constructor] + cls.add_constructor([]) + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList(ns3::PacketTagList const & o) [copy constructor] + cls.add_constructor([param('ns3::PacketTagList const &', 'o')]) + ## packet-tag-list.h (module 'network'): void ns3::PacketTagList::Add(ns3::Tag const & tag) const [member function] + cls.add_method('Add', + 'void', + [param('ns3::Tag const &', 'tag')], + is_const=True) + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData const * ns3::PacketTagList::Head() const [member function] + cls.add_method('Head', + 'ns3::PacketTagList::TagData const *', + [], + is_const=True) + ## packet-tag-list.h (module 'network'): bool ns3::PacketTagList::Peek(ns3::Tag & tag) const [member function] + cls.add_method('Peek', + 'bool', + [param('ns3::Tag &', 'tag')], + is_const=True) + ## packet-tag-list.h (module 'network'): bool ns3::PacketTagList::Remove(ns3::Tag & tag) [member function] + cls.add_method('Remove', + 'bool', + [param('ns3::Tag &', 'tag')]) + ## packet-tag-list.h (module 'network'): void ns3::PacketTagList::RemoveAll() [member function] + cls.add_method('RemoveAll', + 'void', + []) + return + +def register_Ns3PacketTagListTagData_methods(root_module, cls): + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData() [constructor] + cls.add_constructor([]) + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData(ns3::PacketTagList::TagData const & arg0) [copy constructor] + cls.add_constructor([param('ns3::PacketTagList::TagData const &', 'arg0')]) + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::count [variable] + cls.add_instance_attribute('count', 'uint32_t', is_const=False) + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::data [variable] + cls.add_instance_attribute('data', 'uint8_t [ 20 ]', is_const=False) + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::next [variable] + cls.add_instance_attribute('next', 'ns3::PacketTagList::TagData *', is_const=False) + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::tid [variable] + cls.add_instance_attribute('tid', 'ns3::TypeId', is_const=False) + return + +def register_Ns3Reservation_methods(root_module, cls): + ## uan-mac-rc.h (module 'uan'): ns3::Reservation::Reservation(ns3::Reservation const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Reservation const &', 'arg0')]) + ## uan-mac-rc.h (module 'uan'): ns3::Reservation::Reservation() [constructor] + cls.add_constructor([]) + ## uan-mac-rc.h (module 'uan'): ns3::Reservation::Reservation(std::list, ns3::UanAddress>, std::allocator, ns3::UanAddress> > > & list, uint8_t frameNo, uint32_t maxPkts=0) [constructor] + cls.add_constructor([param('std::list< std::pair< ns3::Ptr< ns3::Packet >, ns3::UanAddress > > &', 'list'), param('uint8_t', 'frameNo'), param('uint32_t', 'maxPkts', default_value='0')]) + ## uan-mac-rc.h (module 'uan'): void ns3::Reservation::AddTimestamp(ns3::Time t) [member function] + cls.add_method('AddTimestamp', + 'void', + [param('ns3::Time', 't')]) + ## uan-mac-rc.h (module 'uan'): uint8_t ns3::Reservation::GetFrameNo() const [member function] + cls.add_method('GetFrameNo', + 'uint8_t', + [], + is_const=True) + ## uan-mac-rc.h (module 'uan'): uint32_t ns3::Reservation::GetLength() const [member function] + cls.add_method('GetLength', + 'uint32_t', + [], + is_const=True) + ## uan-mac-rc.h (module 'uan'): uint32_t ns3::Reservation::GetNoFrames() const [member function] + cls.add_method('GetNoFrames', + 'uint32_t', + [], + is_const=True) + ## uan-mac-rc.h (module 'uan'): std::list, ns3::UanAddress>, std::allocator, ns3::UanAddress> > > const & ns3::Reservation::GetPktList() const [member function] + cls.add_method('GetPktList', + 'std::list< std::pair< ns3::Ptr< ns3::Packet >, ns3::UanAddress > > const &', + [], + is_const=True) + ## uan-mac-rc.h (module 'uan'): uint8_t ns3::Reservation::GetRetryNo() const [member function] + cls.add_method('GetRetryNo', + 'uint8_t', + [], + is_const=True) + ## uan-mac-rc.h (module 'uan'): ns3::Time ns3::Reservation::GetTimestamp(uint8_t n) const [member function] + cls.add_method('GetTimestamp', + 'ns3::Time', + [param('uint8_t', 'n')], + is_const=True) + ## uan-mac-rc.h (module 'uan'): void ns3::Reservation::IncrementRetry() [member function] + cls.add_method('IncrementRetry', + 'void', + []) + ## uan-mac-rc.h (module 'uan'): bool ns3::Reservation::IsTransmitted() const [member function] + cls.add_method('IsTransmitted', + 'bool', + [], + is_const=True) + ## uan-mac-rc.h (module 'uan'): void ns3::Reservation::SetFrameNo(uint8_t fn) [member function] + cls.add_method('SetFrameNo', + 'void', + [param('uint8_t', 'fn')]) + ## uan-mac-rc.h (module 'uan'): void ns3::Reservation::SetTransmitted(bool t=true) [member function] + cls.add_method('SetTransmitted', + 'void', + [param('bool', 't', default_value='true')]) + return + +def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, cls): + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount() [constructor] + cls.add_constructor([]) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount(ns3::SimpleRefCount const & o) [copy constructor] + cls.add_constructor([param('ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter > const &', 'o')]) + ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount::Cleanup() [member function] + cls.add_method('Cleanup', + 'void', + [], + is_static=True) + return + +def register_Ns3Simulator_methods(root_module, cls): + ## simulator.h (module 'core'): ns3::Simulator::Simulator(ns3::Simulator const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Simulator const &', 'arg0')]) + ## simulator.h (module 'core'): static void ns3::Simulator::Cancel(ns3::EventId const & id) [member function] + cls.add_method('Cancel', + 'void', + [param('ns3::EventId const &', 'id')], + is_static=True) + ## simulator.h (module 'core'): static void ns3::Simulator::Destroy() [member function] + cls.add_method('Destroy', + 'void', + [], + is_static=True) + ## simulator.h (module 'core'): static uint32_t ns3::Simulator::GetContext() [member function] + cls.add_method('GetContext', + 'uint32_t', + [], + is_static=True) + ## simulator.h (module 'core'): static ns3::Time ns3::Simulator::GetDelayLeft(ns3::EventId const & id) [member function] + cls.add_method('GetDelayLeft', + 'ns3::Time', + [param('ns3::EventId const &', 'id')], + is_static=True) + ## simulator.h (module 'core'): static ns3::Ptr ns3::Simulator::GetImplementation() [member function] + cls.add_method('GetImplementation', + 'ns3::Ptr< ns3::SimulatorImpl >', + [], + is_static=True) + ## simulator.h (module 'core'): static ns3::Time ns3::Simulator::GetMaximumSimulationTime() [member function] + cls.add_method('GetMaximumSimulationTime', + 'ns3::Time', + [], + is_static=True) + ## simulator.h (module 'core'): static uint32_t ns3::Simulator::GetSystemId() [member function] + cls.add_method('GetSystemId', + 'uint32_t', + [], + is_static=True) + ## simulator.h (module 'core'): static bool ns3::Simulator::IsExpired(ns3::EventId const & id) [member function] + cls.add_method('IsExpired', + 'bool', + [param('ns3::EventId const &', 'id')], + is_static=True) + ## simulator.h (module 'core'): static bool ns3::Simulator::IsFinished() [member function] + cls.add_method('IsFinished', + 'bool', + [], + is_static=True) + ## simulator.h (module 'core'): static ns3::Time ns3::Simulator::Now() [member function] + cls.add_method('Now', + 'ns3::Time', + [], + is_static=True) + ## simulator.h (module 'core'): static void ns3::Simulator::Remove(ns3::EventId const & id) [member function] + cls.add_method('Remove', + 'void', + [param('ns3::EventId const &', 'id')], + is_static=True) + ## simulator.h (module 'core'): static void ns3::Simulator::SetImplementation(ns3::Ptr impl) [member function] + cls.add_method('SetImplementation', + 'void', + [param('ns3::Ptr< ns3::SimulatorImpl >', 'impl')], + is_static=True) + ## simulator.h (module 'core'): static void ns3::Simulator::SetScheduler(ns3::ObjectFactory schedulerFactory) [member function] + cls.add_method('SetScheduler', + 'void', + [param('ns3::ObjectFactory', 'schedulerFactory')], + is_static=True) + ## simulator.h (module 'core'): static void ns3::Simulator::Stop() [member function] + cls.add_method('Stop', + 'void', + [], + is_static=True) + ## simulator.h (module 'core'): static void ns3::Simulator::Stop(ns3::Time const & time) [member function] + cls.add_method('Stop', + 'void', + [param('ns3::Time const &', 'time')], + is_static=True) + return + +def register_Ns3Tag_methods(root_module, cls): + ## tag.h (module 'network'): ns3::Tag::Tag() [constructor] + cls.add_constructor([]) + ## tag.h (module 'network'): ns3::Tag::Tag(ns3::Tag const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Tag const &', 'arg0')]) + ## tag.h (module 'network'): void ns3::Tag::Deserialize(ns3::TagBuffer i) [member function] + cls.add_method('Deserialize', + 'void', + [param('ns3::TagBuffer', 'i')], + is_pure_virtual=True, is_virtual=True) + ## tag.h (module 'network'): uint32_t ns3::Tag::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', + 'uint32_t', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## tag.h (module 'network'): static ns3::TypeId ns3::Tag::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## tag.h (module 'network'): void ns3::Tag::Print(std::ostream & os) const [member function] + cls.add_method('Print', + 'void', + [param('std::ostream &', 'os')], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## tag.h (module 'network'): void ns3::Tag::Serialize(ns3::TagBuffer i) const [member function] + cls.add_method('Serialize', + 'void', + [param('ns3::TagBuffer', 'i')], + is_pure_virtual=True, is_const=True, is_virtual=True) + return + +def register_Ns3TagBuffer_methods(root_module, cls): + ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(ns3::TagBuffer const & arg0) [copy constructor] + cls.add_constructor([param('ns3::TagBuffer const &', 'arg0')]) + ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(uint8_t * start, uint8_t * end) [constructor] + cls.add_constructor([param('uint8_t *', 'start'), param('uint8_t *', 'end')]) + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::CopyFrom(ns3::TagBuffer o) [member function] + cls.add_method('CopyFrom', + 'void', + [param('ns3::TagBuffer', 'o')]) + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::Read(uint8_t * buffer, uint32_t size) [member function] + cls.add_method('Read', + 'void', + [param('uint8_t *', 'buffer'), param('uint32_t', 'size')]) + ## tag-buffer.h (module 'network'): double ns3::TagBuffer::ReadDouble() [member function] + cls.add_method('ReadDouble', + 'double', + []) + ## tag-buffer.h (module 'network'): uint16_t ns3::TagBuffer::ReadU16() [member function] + cls.add_method('ReadU16', + 'uint16_t', + []) + ## tag-buffer.h (module 'network'): uint32_t ns3::TagBuffer::ReadU32() [member function] + cls.add_method('ReadU32', + 'uint32_t', + []) + ## tag-buffer.h (module 'network'): uint64_t ns3::TagBuffer::ReadU64() [member function] + cls.add_method('ReadU64', + 'uint64_t', + []) + ## tag-buffer.h (module 'network'): uint8_t ns3::TagBuffer::ReadU8() [member function] + cls.add_method('ReadU8', + 'uint8_t', + []) + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::TrimAtEnd(uint32_t trim) [member function] + cls.add_method('TrimAtEnd', + 'void', + [param('uint32_t', 'trim')]) + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::Write(uint8_t const * buffer, uint32_t size) [member function] + cls.add_method('Write', + 'void', + [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')]) + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteDouble(double v) [member function] + cls.add_method('WriteDouble', + 'void', + [param('double', 'v')]) + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU16(uint16_t data) [member function] + cls.add_method('WriteU16', + 'void', + [param('uint16_t', 'data')]) + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU32(uint32_t data) [member function] + cls.add_method('WriteU32', + 'void', + [param('uint32_t', 'data')]) + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU64(uint64_t v) [member function] + cls.add_method('WriteU64', + 'void', + [param('uint64_t', 'v')]) + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU8(uint8_t v) [member function] + cls.add_method('WriteU8', + 'void', + [param('uint8_t', 'v')]) + return + +def register_Ns3Tap_methods(root_module, cls): + ## uan-prop-model.h (module 'uan'): ns3::Tap::Tap(ns3::Tap const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Tap const &', 'arg0')]) + ## uan-prop-model.h (module 'uan'): ns3::Tap::Tap() [constructor] + cls.add_constructor([]) + ## uan-prop-model.h (module 'uan'): ns3::Tap::Tap(ns3::Time delay, std::complex amp) [constructor] + cls.add_constructor([param('ns3::Time', 'delay'), param('std::complex< double >', 'amp')]) + ## uan-prop-model.h (module 'uan'): std::complex ns3::Tap::GetAmp() const [member function] + cls.add_method('GetAmp', + 'std::complex< double >', + [], + is_const=True) + ## uan-prop-model.h (module 'uan'): ns3::Time ns3::Tap::GetDelay() const [member function] + cls.add_method('GetDelay', + 'ns3::Time', + [], + is_const=True) + return + +def register_Ns3TracedValue__Double_methods(root_module, cls): + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue() [constructor] + cls.add_constructor([]) + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & o) [copy constructor] + cls.add_constructor([param('ns3::TracedValue< double > const &', 'o')]) + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(double const & v) [constructor] + cls.add_constructor([param('double const &', 'v')]) + ## traced-value.h (module 'core'): void ns3::TracedValue::Connect(ns3::CallbackBase const & cb, std::basic_string,std::allocator > path) [member function] + cls.add_method('Connect', + 'void', + [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')]) + ## traced-value.h (module 'core'): void ns3::TracedValue::ConnectWithoutContext(ns3::CallbackBase const & cb) [member function] + cls.add_method('ConnectWithoutContext', + 'void', + [param('ns3::CallbackBase const &', 'cb')]) + ## traced-value.h (module 'core'): void ns3::TracedValue::Disconnect(ns3::CallbackBase const & cb, std::basic_string,std::allocator > path) [member function] + cls.add_method('Disconnect', + 'void', + [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')]) + ## traced-value.h (module 'core'): void ns3::TracedValue::DisconnectWithoutContext(ns3::CallbackBase const & cb) [member function] + cls.add_method('DisconnectWithoutContext', + 'void', + [param('ns3::CallbackBase const &', 'cb')]) + ## traced-value.h (module 'core'): double ns3::TracedValue::Get() const [member function] + cls.add_method('Get', + 'double', + [], + is_const=True) + ## traced-value.h (module 'core'): void ns3::TracedValue::Set(double const & v) [member function] + cls.add_method('Set', + 'void', + [param('double const &', 'v')]) + return + +def register_Ns3TypeId_methods(root_module, cls): + cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('!=') + cls.add_output_stream_operator() + cls.add_binary_comparison_operator('==') + ## type-id.h (module 'core'): ns3::TypeId::TypeId(char const * name) [constructor] + cls.add_constructor([param('char const *', 'name')]) + ## type-id.h (module 'core'): ns3::TypeId::TypeId() [constructor] + cls.add_constructor([]) + ## type-id.h (module 'core'): ns3::TypeId::TypeId(ns3::TypeId const & o) [copy constructor] + cls.add_constructor([param('ns3::TypeId const &', 'o')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker) [member function] + cls.add_method('AddAttribute', + 'ns3::TypeId', + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker) [member function] + cls.add_method('AddAttribute', + 'ns3::TypeId', + [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor) [member function] + cls.add_method('AddTraceSource', + 'ns3::TypeId', + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')]) + ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation ns3::TypeId::GetAttribute(uint32_t i) const [member function] + cls.add_method('GetAttribute', + 'ns3::TypeId::AttributeInformation', + [param('uint32_t', 'i')], + is_const=True) + ## type-id.h (module 'core'): std::string ns3::TypeId::GetAttributeFullName(uint32_t i) const [member function] + cls.add_method('GetAttributeFullName', + 'std::string', + [param('uint32_t', 'i')], + is_const=True) + ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetAttributeN() const [member function] + cls.add_method('GetAttributeN', + 'uint32_t', + [], + is_const=True) + ## type-id.h (module 'core'): ns3::Callback ns3::TypeId::GetConstructor() const [member function] + cls.add_method('GetConstructor', + 'ns3::Callback< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', + [], + is_const=True) + ## type-id.h (module 'core'): std::string ns3::TypeId::GetGroupName() const [member function] + cls.add_method('GetGroupName', + 'std::string', + [], + is_const=True) + ## type-id.h (module 'core'): std::string ns3::TypeId::GetName() const [member function] + cls.add_method('GetName', + 'std::string', + [], + is_const=True) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::GetParent() const [member function] + cls.add_method('GetParent', + 'ns3::TypeId', + [], + is_const=True) + ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::GetRegistered(uint32_t i) [member function] + cls.add_method('GetRegistered', + 'ns3::TypeId', + [param('uint32_t', 'i')], + is_static=True) + ## type-id.h (module 'core'): static uint32_t ns3::TypeId::GetRegisteredN() [member function] + cls.add_method('GetRegisteredN', + 'uint32_t', + [], + is_static=True) + ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation ns3::TypeId::GetTraceSource(uint32_t i) const [member function] + cls.add_method('GetTraceSource', + 'ns3::TypeId::TraceSourceInformation', + [param('uint32_t', 'i')], + is_const=True) + ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetTraceSourceN() const [member function] + cls.add_method('GetTraceSourceN', + 'uint32_t', + [], + is_const=True) + ## type-id.h (module 'core'): uint16_t ns3::TypeId::GetUid() const [member function] + cls.add_method('GetUid', + 'uint16_t', + [], + is_const=True) + ## type-id.h (module 'core'): bool ns3::TypeId::HasConstructor() const [member function] + cls.add_method('HasConstructor', + 'bool', + [], + is_const=True) + ## type-id.h (module 'core'): bool ns3::TypeId::HasParent() const [member function] + cls.add_method('HasParent', + 'bool', + [], + is_const=True) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::HideFromDocumentation() [member function] + cls.add_method('HideFromDocumentation', + 'ns3::TypeId', + []) + ## type-id.h (module 'core'): bool ns3::TypeId::IsChildOf(ns3::TypeId other) const [member function] + cls.add_method('IsChildOf', + 'bool', + [param('ns3::TypeId', 'other')], + is_const=True) + ## type-id.h (module 'core'): bool ns3::TypeId::LookupAttributeByName(std::string name, ns3::TypeId::AttributeInformation * info) const [member function] + cls.add_method('LookupAttributeByName', + 'bool', + [param('std::string', 'name'), param('ns3::TypeId::AttributeInformation *', 'info', transfer_ownership=False)], + is_const=True) + ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByName(std::string name) [member function] + cls.add_method('LookupByName', + 'ns3::TypeId', + [param('std::string', 'name')], + is_static=True) + ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function] + cls.add_method('LookupTraceSourceByName', + 'ns3::Ptr< ns3::TraceSourceAccessor const >', + [param('std::string', 'name')], + is_const=True) + ## type-id.h (module 'core'): bool ns3::TypeId::MustHideFromDocumentation() const [member function] + cls.add_method('MustHideFromDocumentation', + 'bool', + [], + is_const=True) + ## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr initialValue) [member function] + cls.add_method('SetAttributeInitialValue', + 'bool', + [param('uint32_t', 'i'), param('ns3::Ptr< ns3::AttributeValue const >', 'initialValue')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::SetGroupName(std::string groupName) [member function] + cls.add_method('SetGroupName', + 'ns3::TypeId', + [param('std::string', 'groupName')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::SetParent(ns3::TypeId tid) [member function] + cls.add_method('SetParent', + 'ns3::TypeId', + [param('ns3::TypeId', 'tid')]) + ## type-id.h (module 'core'): void ns3::TypeId::SetUid(uint16_t tid) [member function] + cls.add_method('SetUid', + 'void', + [param('uint16_t', 'tid')]) + return + +def register_Ns3TypeIdAttributeInformation_methods(root_module, cls): + ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation() [constructor] + cls.add_constructor([]) + ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation(ns3::TypeId::AttributeInformation const & arg0) [copy constructor] + cls.add_constructor([param('ns3::TypeId::AttributeInformation const &', 'arg0')]) + ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::accessor [variable] + cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::AttributeAccessor const >', is_const=False) + ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::checker [variable] + cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False) + ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::flags [variable] + cls.add_instance_attribute('flags', 'uint32_t', is_const=False) + ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::help [variable] + cls.add_instance_attribute('help', 'std::string', is_const=False) + ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::initialValue [variable] + cls.add_instance_attribute('initialValue', 'ns3::Ptr< ns3::AttributeValue const >', is_const=False) + ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::name [variable] + cls.add_instance_attribute('name', 'std::string', is_const=False) + ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::originalInitialValue [variable] + cls.add_instance_attribute('originalInitialValue', 'ns3::Ptr< ns3::AttributeValue const >', is_const=False) + return + +def register_Ns3TypeIdTraceSourceInformation_methods(root_module, cls): + ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation() [constructor] + cls.add_constructor([]) + ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation(ns3::TypeId::TraceSourceInformation const & arg0) [copy constructor] + cls.add_constructor([param('ns3::TypeId::TraceSourceInformation const &', 'arg0')]) + ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::accessor [variable] + cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::TraceSourceAccessor const >', is_const=False) + ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::help [variable] + cls.add_instance_attribute('help', 'std::string', is_const=False) + ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::name [variable] + cls.add_instance_attribute('name', 'std::string', is_const=False) + return + +def register_Ns3UanAddress_methods(root_module, cls): + cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('!=') + cls.add_output_stream_operator() + cls.add_binary_comparison_operator('==') + ## uan-address.h (module 'uan'): ns3::UanAddress::UanAddress(ns3::UanAddress const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanAddress const &', 'arg0')]) + ## uan-address.h (module 'uan'): ns3::UanAddress::UanAddress() [constructor] + cls.add_constructor([]) + ## uan-address.h (module 'uan'): ns3::UanAddress::UanAddress(uint8_t addr) [constructor] + cls.add_constructor([param('uint8_t', 'addr')]) + ## uan-address.h (module 'uan'): static ns3::UanAddress ns3::UanAddress::Allocate() [member function] + cls.add_method('Allocate', + 'ns3::UanAddress', + [], + is_static=True) + ## uan-address.h (module 'uan'): static ns3::UanAddress ns3::UanAddress::ConvertFrom(ns3::Address const & address) [member function] + cls.add_method('ConvertFrom', + 'ns3::UanAddress', + [param('ns3::Address const &', 'address')], + is_static=True) + ## uan-address.h (module 'uan'): void ns3::UanAddress::CopyFrom(uint8_t const * pBuffer) [member function] + cls.add_method('CopyFrom', + 'void', + [param('uint8_t const *', 'pBuffer')]) + ## uan-address.h (module 'uan'): void ns3::UanAddress::CopyTo(uint8_t * pBuffer) [member function] + cls.add_method('CopyTo', + 'void', + [param('uint8_t *', 'pBuffer')]) + ## uan-address.h (module 'uan'): uint8_t ns3::UanAddress::GetAsInt() const [member function] + cls.add_method('GetAsInt', + 'uint8_t', + [], + is_const=True) + ## uan-address.h (module 'uan'): static ns3::UanAddress ns3::UanAddress::GetBroadcast() [member function] + cls.add_method('GetBroadcast', + 'ns3::UanAddress', + [], + is_static=True) + ## uan-address.h (module 'uan'): static bool ns3::UanAddress::IsMatchingType(ns3::Address const & address) [member function] + cls.add_method('IsMatchingType', + 'bool', + [param('ns3::Address const &', 'address')], + is_static=True) + return + +def register_Ns3UanHelper_methods(root_module, cls): + ## uan-helper.h (module 'uan'): ns3::UanHelper::UanHelper(ns3::UanHelper const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanHelper const &', 'arg0')]) + ## uan-helper.h (module 'uan'): ns3::UanHelper::UanHelper() [constructor] + cls.add_constructor([]) + ## uan-helper.h (module 'uan'): static void ns3::UanHelper::EnableAscii(std::ostream & os, uint32_t nodeid, uint32_t deviceid) [member function] + cls.add_method('EnableAscii', + 'void', + [param('std::ostream &', 'os'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')], + is_static=True) + ## uan-helper.h (module 'uan'): static void ns3::UanHelper::EnableAscii(std::ostream & os, ns3::NetDeviceContainer d) [member function] + cls.add_method('EnableAscii', + 'void', + [param('std::ostream &', 'os'), param('ns3::NetDeviceContainer', 'd')], + is_static=True) + ## uan-helper.h (module 'uan'): static void ns3::UanHelper::EnableAscii(std::ostream & os, ns3::NodeContainer n) [member function] + cls.add_method('EnableAscii', + 'void', + [param('std::ostream &', 'os'), param('ns3::NodeContainer', 'n')], + is_static=True) + ## uan-helper.h (module 'uan'): static void ns3::UanHelper::EnableAsciiAll(std::ostream & os) [member function] + cls.add_method('EnableAsciiAll', + 'void', + [param('std::ostream &', 'os')], + is_static=True) + ## uan-helper.h (module 'uan'): ns3::NetDeviceContainer ns3::UanHelper::Install(ns3::NodeContainer c) const [member function] + cls.add_method('Install', + 'ns3::NetDeviceContainer', + [param('ns3::NodeContainer', 'c')], + is_const=True) + ## uan-helper.h (module 'uan'): ns3::NetDeviceContainer ns3::UanHelper::Install(ns3::NodeContainer c, ns3::Ptr channel) const [member function] + cls.add_method('Install', + 'ns3::NetDeviceContainer', + [param('ns3::NodeContainer', 'c'), param('ns3::Ptr< ns3::UanChannel >', 'channel')], + is_const=True) + ## uan-helper.h (module 'uan'): ns3::Ptr ns3::UanHelper::Install(ns3::Ptr node, ns3::Ptr channel) const [member function] + cls.add_method('Install', + 'ns3::Ptr< ns3::UanNetDevice >', + [param('ns3::Ptr< ns3::Node >', 'node'), param('ns3::Ptr< ns3::UanChannel >', 'channel')], + is_const=True) + ## uan-helper.h (module 'uan'): void ns3::UanHelper::SetMac(std::string type, std::string n0="", ns3::AttributeValue const & v0=ns3::EmptyAttributeValue(), std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue(), std::string n5="", ns3::AttributeValue const & v5=ns3::EmptyAttributeValue(), std::string n6="", ns3::AttributeValue const & v6=ns3::EmptyAttributeValue(), std::string n7="", ns3::AttributeValue const & v7=ns3::EmptyAttributeValue()) [member function] + cls.add_method('SetMac', + 'void', + [param('std::string', 'type'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue const &', 'v0', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue const &', 'v1', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue const &', 'v2', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue const &', 'v3', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue const &', 'v4', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue const &', 'v5', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue const &', 'v6', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue const &', 'v7', default_value='ns3::EmptyAttributeValue()')]) + ## uan-helper.h (module 'uan'): void ns3::UanHelper::SetPhy(std::string phyType, std::string n0="", ns3::AttributeValue const & v0=ns3::EmptyAttributeValue(), std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue(), std::string n5="", ns3::AttributeValue const & v5=ns3::EmptyAttributeValue(), std::string n6="", ns3::AttributeValue const & v6=ns3::EmptyAttributeValue(), std::string n7="", ns3::AttributeValue const & v7=ns3::EmptyAttributeValue()) [member function] + cls.add_method('SetPhy', + 'void', + [param('std::string', 'phyType'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue const &', 'v0', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue const &', 'v1', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue const &', 'v2', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue const &', 'v3', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue const &', 'v4', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue const &', 'v5', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue const &', 'v6', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue const &', 'v7', default_value='ns3::EmptyAttributeValue()')]) + ## uan-helper.h (module 'uan'): void ns3::UanHelper::SetTransducer(std::string type, std::string n0="", ns3::AttributeValue const & v0=ns3::EmptyAttributeValue(), std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue(), std::string n5="", ns3::AttributeValue const & v5=ns3::EmptyAttributeValue(), std::string n6="", ns3::AttributeValue const & v6=ns3::EmptyAttributeValue(), std::string n7="", ns3::AttributeValue const & v7=ns3::EmptyAttributeValue()) [member function] + cls.add_method('SetTransducer', + 'void', + [param('std::string', 'type'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue const &', 'v0', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue const &', 'v1', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue const &', 'v2', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue const &', 'v3', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue const &', 'v4', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue const &', 'v5', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue const &', 'v6', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue const &', 'v7', default_value='ns3::EmptyAttributeValue()')]) + return + +def register_Ns3UanModesList_methods(root_module, cls): + cls.add_output_stream_operator() + ## uan-tx-mode.h (module 'uan'): ns3::UanModesList::UanModesList(ns3::UanModesList const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanModesList const &', 'arg0')]) + ## uan-tx-mode.h (module 'uan'): ns3::UanModesList::UanModesList() [constructor] + cls.add_constructor([]) + ## uan-tx-mode.h (module 'uan'): void ns3::UanModesList::AppendMode(ns3::UanTxMode mode) [member function] + cls.add_method('AppendMode', + 'void', + [param('ns3::UanTxMode', 'mode')]) + ## uan-tx-mode.h (module 'uan'): void ns3::UanModesList::DeleteMode(uint32_t num) [member function] + cls.add_method('DeleteMode', + 'void', + [param('uint32_t', 'num')]) + ## uan-tx-mode.h (module 'uan'): uint32_t ns3::UanModesList::GetNModes() const [member function] + cls.add_method('GetNModes', + 'uint32_t', + [], + is_const=True) + return + +def register_Ns3UanPacketArrival_methods(root_module, cls): + ## uan-transducer.h (module 'uan'): ns3::UanPacketArrival::UanPacketArrival(ns3::UanPacketArrival const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanPacketArrival const &', 'arg0')]) + ## uan-transducer.h (module 'uan'): ns3::UanPacketArrival::UanPacketArrival() [constructor] + cls.add_constructor([]) + ## uan-transducer.h (module 'uan'): ns3::UanPacketArrival::UanPacketArrival(ns3::Ptr packet, double rxPowerDb, ns3::UanTxMode txMode, ns3::UanPdp pdp, ns3::Time arrTime) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::Packet >', 'packet'), param('double', 'rxPowerDb'), param('ns3::UanTxMode', 'txMode'), param('ns3::UanPdp', 'pdp'), param('ns3::Time', 'arrTime')]) + ## uan-transducer.h (module 'uan'): ns3::Time ns3::UanPacketArrival::GetArrivalTime() const [member function] + cls.add_method('GetArrivalTime', + 'ns3::Time', + [], + is_const=True) + ## uan-transducer.h (module 'uan'): ns3::Ptr ns3::UanPacketArrival::GetPacket() const [member function] + cls.add_method('GetPacket', + 'ns3::Ptr< ns3::Packet >', + [], + is_const=True) + ## uan-transducer.h (module 'uan'): ns3::UanPdp ns3::UanPacketArrival::GetPdp() const [member function] + cls.add_method('GetPdp', + 'ns3::UanPdp', + [], + is_const=True) + ## uan-transducer.h (module 'uan'): double ns3::UanPacketArrival::GetRxPowerDb() const [member function] + cls.add_method('GetRxPowerDb', + 'double', + [], + is_const=True) + ## uan-transducer.h (module 'uan'): ns3::UanTxMode const & ns3::UanPacketArrival::GetTxMode() const [member function] + cls.add_method('GetTxMode', + 'ns3::UanTxMode const &', + [], + is_const=True) + return + +def register_Ns3UanPdp_methods(root_module, cls): + cls.add_output_stream_operator() + ## uan-prop-model.h (module 'uan'): ns3::UanPdp::UanPdp(ns3::UanPdp const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanPdp const &', 'arg0')]) + ## uan-prop-model.h (module 'uan'): ns3::UanPdp::UanPdp() [constructor] + cls.add_constructor([]) + ## uan-prop-model.h (module 'uan'): ns3::UanPdp::UanPdp(std::vector > taps, ns3::Time resolution) [constructor] + cls.add_constructor([param('std::vector< ns3::Tap >', 'taps'), param('ns3::Time', 'resolution')]) + ## uan-prop-model.h (module 'uan'): ns3::UanPdp::UanPdp(std::vector,std::allocator > > arrivals, ns3::Time resolution) [constructor] + cls.add_constructor([param('std::vector< std::complex< double > >', 'arrivals'), param('ns3::Time', 'resolution')]) + ## uan-prop-model.h (module 'uan'): ns3::UanPdp::UanPdp(std::vector > arrivals, ns3::Time resolution) [constructor] + cls.add_constructor([param('std::vector< double >', 'arrivals'), param('ns3::Time', 'resolution')]) + ## uan-prop-model.h (module 'uan'): static ns3::UanPdp ns3::UanPdp::CreateImpulsePdp() [member function] + cls.add_method('CreateImpulsePdp', + 'ns3::UanPdp', + [], + is_static=True) + ## uan-prop-model.h (module 'uan'): __gnu_cxx::__normal_iterator > > ns3::UanPdp::GetBegin() const [member function] + cls.add_method('GetBegin', + '__gnu_cxx::__normal_iterator< ns3::Tap const *, std::vector< ns3::Tap > >', + [], + is_const=True) + ## uan-prop-model.h (module 'uan'): __gnu_cxx::__normal_iterator > > ns3::UanPdp::GetEnd() const [member function] + cls.add_method('GetEnd', + '__gnu_cxx::__normal_iterator< ns3::Tap const *, std::vector< ns3::Tap > >', + [], + is_const=True) + ## uan-prop-model.h (module 'uan'): uint32_t ns3::UanPdp::GetNTaps() const [member function] + cls.add_method('GetNTaps', + 'uint32_t', + [], + is_const=True) + ## uan-prop-model.h (module 'uan'): ns3::Time ns3::UanPdp::GetResolution() const [member function] + cls.add_method('GetResolution', + 'ns3::Time', + [], + is_const=True) + ## uan-prop-model.h (module 'uan'): ns3::Tap const & ns3::UanPdp::GetTap(uint32_t i) const [member function] + cls.add_method('GetTap', + 'ns3::Tap const &', + [param('uint32_t', 'i')], + is_const=True) + ## uan-prop-model.h (module 'uan'): void ns3::UanPdp::SetNTaps(uint32_t nTaps) [member function] + cls.add_method('SetNTaps', + 'void', + [param('uint32_t', 'nTaps')]) + ## uan-prop-model.h (module 'uan'): void ns3::UanPdp::SetResolution(ns3::Time resolution) [member function] + cls.add_method('SetResolution', + 'void', + [param('ns3::Time', 'resolution')]) + ## uan-prop-model.h (module 'uan'): void ns3::UanPdp::SetTap(std::complex arrival, uint32_t index) [member function] + cls.add_method('SetTap', + 'void', + [param('std::complex< double >', 'arrival'), param('uint32_t', 'index')]) + ## uan-prop-model.h (module 'uan'): std::complex ns3::UanPdp::SumTapsC(ns3::Time begin, ns3::Time end) const [member function] + cls.add_method('SumTapsC', + 'std::complex< double >', + [param('ns3::Time', 'begin'), param('ns3::Time', 'end')], + is_const=True) + ## uan-prop-model.h (module 'uan'): std::complex ns3::UanPdp::SumTapsFromMaxC(ns3::Time delay, ns3::Time duration) const [member function] + cls.add_method('SumTapsFromMaxC', + 'std::complex< double >', + [param('ns3::Time', 'delay'), param('ns3::Time', 'duration')], + is_const=True) + ## uan-prop-model.h (module 'uan'): double ns3::UanPdp::SumTapsFromMaxNc(ns3::Time delay, ns3::Time duration) const [member function] + cls.add_method('SumTapsFromMaxNc', + 'double', + [param('ns3::Time', 'delay'), param('ns3::Time', 'duration')], + is_const=True) + ## uan-prop-model.h (module 'uan'): double ns3::UanPdp::SumTapsNc(ns3::Time begin, ns3::Time end) const [member function] + cls.add_method('SumTapsNc', + 'double', + [param('ns3::Time', 'begin'), param('ns3::Time', 'end')], + is_const=True) + return + +def register_Ns3UanPhyListener_methods(root_module, cls): + ## uan-phy.h (module 'uan'): ns3::UanPhyListener::UanPhyListener() [constructor] + cls.add_constructor([]) + ## uan-phy.h (module 'uan'): ns3::UanPhyListener::UanPhyListener(ns3::UanPhyListener const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanPhyListener const &', 'arg0')]) + ## uan-phy.h (module 'uan'): void ns3::UanPhyListener::NotifyCcaEnd() [member function] + cls.add_method('NotifyCcaEnd', + 'void', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhyListener::NotifyCcaStart() [member function] + cls.add_method('NotifyCcaStart', + 'void', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhyListener::NotifyRxEndError() [member function] + cls.add_method('NotifyRxEndError', + 'void', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhyListener::NotifyRxEndOk() [member function] + cls.add_method('NotifyRxEndOk', + 'void', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhyListener::NotifyRxStart() [member function] + cls.add_method('NotifyRxStart', + 'void', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhyListener::NotifyTxStart(ns3::Time duration) [member function] + cls.add_method('NotifyTxStart', + 'void', + [param('ns3::Time', 'duration')], + is_pure_virtual=True, is_virtual=True) + return + +def register_Ns3UanTxMode_methods(root_module, cls): + cls.add_output_stream_operator() + ## uan-tx-mode.h (module 'uan'): ns3::UanTxMode::UanTxMode(ns3::UanTxMode const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanTxMode const &', 'arg0')]) + ## uan-tx-mode.h (module 'uan'): ns3::UanTxMode::UanTxMode() [constructor] + cls.add_constructor([]) + ## uan-tx-mode.h (module 'uan'): uint32_t ns3::UanTxMode::GetBandwidthHz() const [member function] + cls.add_method('GetBandwidthHz', + 'uint32_t', + [], + is_const=True) + ## uan-tx-mode.h (module 'uan'): uint32_t ns3::UanTxMode::GetCenterFreqHz() const [member function] + cls.add_method('GetCenterFreqHz', + 'uint32_t', + [], + is_const=True) + ## uan-tx-mode.h (module 'uan'): uint32_t ns3::UanTxMode::GetConstellationSize() const [member function] + cls.add_method('GetConstellationSize', + 'uint32_t', + [], + is_const=True) + ## uan-tx-mode.h (module 'uan'): uint32_t ns3::UanTxMode::GetDataRateBps() const [member function] + cls.add_method('GetDataRateBps', + 'uint32_t', + [], + is_const=True) + ## uan-tx-mode.h (module 'uan'): ns3::UanTxMode::ModulationType ns3::UanTxMode::GetModType() const [member function] + cls.add_method('GetModType', + 'ns3::UanTxMode::ModulationType', + [], + is_const=True) + ## uan-tx-mode.h (module 'uan'): std::string ns3::UanTxMode::GetName() const [member function] + cls.add_method('GetName', + 'std::string', + [], + is_const=True) + ## uan-tx-mode.h (module 'uan'): uint32_t ns3::UanTxMode::GetPhyRateSps() const [member function] + cls.add_method('GetPhyRateSps', + 'uint32_t', + [], + is_const=True) + ## uan-tx-mode.h (module 'uan'): uint32_t ns3::UanTxMode::GetUid() const [member function] + cls.add_method('GetUid', + 'uint32_t', + [], + is_const=True) + return + +def register_Ns3UanTxModeFactory_methods(root_module, cls): + ## uan-tx-mode.h (module 'uan'): ns3::UanTxModeFactory::UanTxModeFactory(ns3::UanTxModeFactory const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanTxModeFactory const &', 'arg0')]) + ## uan-tx-mode.h (module 'uan'): ns3::UanTxModeFactory::UanTxModeFactory() [constructor] + cls.add_constructor([]) + ## uan-tx-mode.h (module 'uan'): static ns3::UanTxMode ns3::UanTxModeFactory::CreateMode(ns3::UanTxMode::ModulationType type, uint32_t dataRateBps, uint32_t phyRateSps, uint32_t cfHz, uint32_t bwHz, uint32_t constSize, std::string name) [member function] + cls.add_method('CreateMode', + 'ns3::UanTxMode', + [param('ns3::UanTxMode::ModulationType', 'type'), param('uint32_t', 'dataRateBps'), param('uint32_t', 'phyRateSps'), param('uint32_t', 'cfHz'), param('uint32_t', 'bwHz'), param('uint32_t', 'constSize'), param('std::string', 'name')], + is_static=True) + ## uan-tx-mode.h (module 'uan'): static ns3::UanTxMode ns3::UanTxModeFactory::GetMode(std::string name) [member function] + cls.add_method('GetMode', + 'ns3::UanTxMode', + [param('std::string', 'name')], + is_static=True) + ## uan-tx-mode.h (module 'uan'): static ns3::UanTxMode ns3::UanTxModeFactory::GetMode(uint32_t uid) [member function] + cls.add_method('GetMode', + 'ns3::UanTxMode', + [param('uint32_t', 'uid')], + is_static=True) + return + +def register_Ns3Vector2D_methods(root_module, cls): + cls.add_output_stream_operator() + ## vector.h (module 'core'): ns3::Vector2D::Vector2D(ns3::Vector2D const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Vector2D const &', 'arg0')]) + ## vector.h (module 'core'): ns3::Vector2D::Vector2D(double _x, double _y) [constructor] + cls.add_constructor([param('double', '_x'), param('double', '_y')]) + ## vector.h (module 'core'): ns3::Vector2D::Vector2D() [constructor] + cls.add_constructor([]) + ## vector.h (module 'core'): ns3::Vector2D::x [variable] + cls.add_instance_attribute('x', 'double', is_const=False) + ## vector.h (module 'core'): ns3::Vector2D::y [variable] + cls.add_instance_attribute('y', 'double', is_const=False) + return + +def register_Ns3Vector3D_methods(root_module, cls): + cls.add_output_stream_operator() + ## vector.h (module 'core'): ns3::Vector3D::Vector3D(ns3::Vector3D const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Vector3D const &', 'arg0')]) + ## vector.h (module 'core'): ns3::Vector3D::Vector3D(double _x, double _y, double _z) [constructor] + cls.add_constructor([param('double', '_x'), param('double', '_y'), param('double', '_z')]) + ## vector.h (module 'core'): ns3::Vector3D::Vector3D() [constructor] + cls.add_constructor([]) + ## vector.h (module 'core'): ns3::Vector3D::x [variable] + cls.add_instance_attribute('x', 'double', is_const=False) + ## vector.h (module 'core'): ns3::Vector3D::y [variable] + cls.add_instance_attribute('y', 'double', is_const=False) + ## vector.h (module 'core'): ns3::Vector3D::z [variable] + cls.add_instance_attribute('z', 'double', is_const=False) + return + +def register_Ns3Empty_methods(root_module, cls): + ## empty.h (module 'core'): ns3::empty::empty() [constructor] + cls.add_constructor([]) + ## empty.h (module 'core'): ns3::empty::empty(ns3::empty const & arg0) [copy constructor] + cls.add_constructor([param('ns3::empty const &', 'arg0')]) + return + +def register_Ns3Int64x64_t_methods(root_module, cls): + cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long unsigned int const', 'right')) + cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long unsigned int const', 'right')) + cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned int const', 'right')) + cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short unsigned int const', 'right')) + cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned char const', 'right')) + cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long int const', 'right')) + cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long int const', 'right')) + cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('int const', 'right')) + cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short int const', 'right')) + cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('signed char const', 'right')) + cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('double const', 'right')) + cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', 'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long unsigned int const', 'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long unsigned int const', 'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned int const', 'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short unsigned int const', 'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned char const', 'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long int const', 'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long int const', 'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('int const', 'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short int const', 'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('signed char const', 'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('double const', 'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', 'right')) + cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long unsigned int const', 'right')) + cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long unsigned int const', 'right')) + cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned int const', 'right')) + cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short unsigned int const', 'right')) + cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned char const', 'right')) + cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long int const', 'right')) + cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long int const', 'right')) + cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('int const', 'right')) + cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short int const', 'right')) + cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('signed char const', 'right')) + cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('double const', 'right')) + cls.add_unary_numeric_operator('-') + cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', 'right')) + cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long unsigned int const', 'right')) + cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long unsigned int const', 'right')) + cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned int const', 'right')) + cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short unsigned int const', 'right')) + cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned char const', 'right')) + cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long int const', 'right')) + cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long int const', 'right')) + cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('int const', 'right')) + cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short int const', 'right')) + cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('signed char const', 'right')) + cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('double const', 'right')) + cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', 'right')) + cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('>') + cls.add_binary_comparison_operator('!=') + cls.add_inplace_numeric_operator('*=', param('ns3::int64x64_t const &', 'right')) + cls.add_inplace_numeric_operator('+=', param('ns3::int64x64_t const &', 'right')) + cls.add_inplace_numeric_operator('-=', param('ns3::int64x64_t const &', 'right')) + cls.add_inplace_numeric_operator('/=', param('ns3::int64x64_t const &', 'right')) + cls.add_output_stream_operator() + cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('>=') + ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor] + cls.add_constructor([]) + ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(double v) [constructor] + cls.add_constructor([param('double', 'v')]) + ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(int v) [constructor] + cls.add_constructor([param('int', 'v')]) + ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long int v) [constructor] + cls.add_constructor([param('long int', 'v')]) + ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long long int v) [constructor] + cls.add_constructor([param('long long int', 'v')]) + ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(unsigned int v) [constructor] + cls.add_constructor([param('unsigned int', 'v')]) + ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long unsigned int v) [constructor] + cls.add_constructor([param('long unsigned int', 'v')]) + ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long long unsigned int v) [constructor] + cls.add_constructor([param('long long unsigned int', 'v')]) + ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(int64_t hi, uint64_t lo) [constructor] + cls.add_constructor([param('int64_t', 'hi'), param('uint64_t', 'lo')]) + ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(ns3::int64x64_t const & o) [copy constructor] + cls.add_constructor([param('ns3::int64x64_t const &', 'o')]) + ## int64x64-double.h (module 'core'): double ns3::int64x64_t::GetDouble() const [member function] + cls.add_method('GetDouble', + 'double', + [], + is_const=True) + ## int64x64-double.h (module 'core'): int64_t ns3::int64x64_t::GetHigh() const [member function] + cls.add_method('GetHigh', + 'int64_t', + [], + is_const=True) + ## int64x64-double.h (module 'core'): uint64_t ns3::int64x64_t::GetLow() const [member function] + cls.add_method('GetLow', + 'uint64_t', + [], + is_const=True) + ## int64x64-double.h (module 'core'): static ns3::int64x64_t ns3::int64x64_t::Invert(uint64_t v) [member function] + cls.add_method('Invert', + 'ns3::int64x64_t', + [param('uint64_t', 'v')], + is_static=True) + ## int64x64-double.h (module 'core'): void ns3::int64x64_t::MulByInvert(ns3::int64x64_t const & o) [member function] + cls.add_method('MulByInvert', + 'void', + [param('ns3::int64x64_t const &', 'o')]) + return + +def register_Ns3AcousticModemEnergyModelHelper_methods(root_module, cls): + ## acoustic-modem-energy-model-helper.h (module 'uan'): ns3::AcousticModemEnergyModelHelper::AcousticModemEnergyModelHelper(ns3::AcousticModemEnergyModelHelper const & arg0) [copy constructor] + cls.add_constructor([param('ns3::AcousticModemEnergyModelHelper const &', 'arg0')]) + ## acoustic-modem-energy-model-helper.h (module 'uan'): ns3::AcousticModemEnergyModelHelper::AcousticModemEnergyModelHelper() [constructor] + cls.add_constructor([]) + ## acoustic-modem-energy-model-helper.h (module 'uan'): void ns3::AcousticModemEnergyModelHelper::Set(std::string name, ns3::AttributeValue const & v) [member function] + cls.add_method('Set', + 'void', + [param('std::string', 'name'), param('ns3::AttributeValue const &', 'v')], + is_virtual=True) + ## acoustic-modem-energy-model-helper.h (module 'uan'): void ns3::AcousticModemEnergyModelHelper::SetDepletionCallback(ns3::Callback callback) [member function] + cls.add_method('SetDepletionCallback', + 'void', + [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) + ## acoustic-modem-energy-model-helper.h (module 'uan'): ns3::Ptr ns3::AcousticModemEnergyModelHelper::DoInstall(ns3::Ptr device, ns3::Ptr source) const [member function] + cls.add_method('DoInstall', + 'ns3::Ptr< ns3::DeviceEnergyModel >', + [param('ns3::Ptr< ns3::NetDevice >', 'device'), param('ns3::Ptr< ns3::EnergySource >', 'source')], + is_const=True, visibility='private', is_virtual=True) + return + +def register_Ns3Chunk_methods(root_module, cls): + ## chunk.h (module 'network'): ns3::Chunk::Chunk() [constructor] + cls.add_constructor([]) + ## chunk.h (module 'network'): ns3::Chunk::Chunk(ns3::Chunk const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Chunk const &', 'arg0')]) + ## chunk.h (module 'network'): uint32_t ns3::Chunk::Deserialize(ns3::Buffer::Iterator start) [member function] + cls.add_method('Deserialize', + 'uint32_t', + [param('ns3::Buffer::Iterator', 'start')], + is_pure_virtual=True, is_virtual=True) + ## chunk.h (module 'network'): static ns3::TypeId ns3::Chunk::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## chunk.h (module 'network'): void ns3::Chunk::Print(std::ostream & os) const [member function] + cls.add_method('Print', + 'void', + [param('std::ostream &', 'os')], + is_pure_virtual=True, is_const=True, is_virtual=True) + return + +def register_Ns3Header_methods(root_module, cls): + cls.add_output_stream_operator() + ## header.h (module 'network'): ns3::Header::Header() [constructor] + cls.add_constructor([]) + ## header.h (module 'network'): ns3::Header::Header(ns3::Header const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Header const &', 'arg0')]) + ## header.h (module 'network'): uint32_t ns3::Header::Deserialize(ns3::Buffer::Iterator start) [member function] + cls.add_method('Deserialize', + 'uint32_t', + [param('ns3::Buffer::Iterator', 'start')], + is_pure_virtual=True, is_virtual=True) + ## header.h (module 'network'): uint32_t ns3::Header::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', + 'uint32_t', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## header.h (module 'network'): static ns3::TypeId ns3::Header::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## header.h (module 'network'): void ns3::Header::Print(std::ostream & os) const [member function] + cls.add_method('Print', + 'void', + [param('std::ostream &', 'os')], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## header.h (module 'network'): void ns3::Header::Serialize(ns3::Buffer::Iterator start) const [member function] + cls.add_method('Serialize', + 'void', + [param('ns3::Buffer::Iterator', 'start')], + is_pure_virtual=True, is_const=True, is_virtual=True) + return + +def register_Ns3Object_methods(root_module, cls): + ## object.h (module 'core'): ns3::Object::Object() [constructor] + cls.add_constructor([]) + ## object.h (module 'core'): void ns3::Object::AggregateObject(ns3::Ptr other) [member function] + cls.add_method('AggregateObject', + 'void', + [param('ns3::Ptr< ns3::Object >', 'other')]) + ## object.h (module 'core'): void ns3::Object::Dispose() [member function] + cls.add_method('Dispose', + 'void', + []) + ## object.h (module 'core'): ns3::Object::AggregateIterator ns3::Object::GetAggregateIterator() const [member function] + cls.add_method('GetAggregateIterator', + 'ns3::Object::AggregateIterator', + [], + is_const=True) + ## object.h (module 'core'): ns3::TypeId ns3::Object::GetInstanceTypeId() const [member function] + cls.add_method('GetInstanceTypeId', + 'ns3::TypeId', + [], + is_const=True, is_virtual=True) + ## object.h (module 'core'): static ns3::TypeId ns3::Object::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## object.h (module 'core'): void ns3::Object::Start() [member function] + cls.add_method('Start', + 'void', + []) + ## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor] + cls.add_constructor([param('ns3::Object const &', 'o')], + visibility='protected') + ## object.h (module 'core'): void ns3::Object::DoDispose() [member function] + cls.add_method('DoDispose', + 'void', + [], + visibility='protected', is_virtual=True) + ## object.h (module 'core'): void ns3::Object::DoStart() [member function] + cls.add_method('DoStart', + 'void', + [], + visibility='protected', is_virtual=True) + ## object.h (module 'core'): void ns3::Object::NotifyNewAggregate() [member function] + cls.add_method('NotifyNewAggregate', + 'void', + [], + visibility='protected', is_virtual=True) + return + +def register_Ns3ObjectAggregateIterator_methods(root_module, cls): + ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Object::AggregateIterator const &', 'arg0')]) + ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator() [constructor] + cls.add_constructor([]) + ## object.h (module 'core'): bool ns3::Object::AggregateIterator::HasNext() const [member function] + cls.add_method('HasNext', + 'bool', + [], + is_const=True) + ## object.h (module 'core'): ns3::Ptr ns3::Object::AggregateIterator::Next() [member function] + cls.add_method('Next', + 'ns3::Ptr< ns3::Object const >', + []) + return + +def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, cls): + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] + cls.add_constructor([]) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter< ns3::AttributeAccessor > > const &', 'o')]) + ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] + cls.add_method('Cleanup', + 'void', + [], + is_static=True) + return + +def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, cls): + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] + cls.add_constructor([]) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter< ns3::AttributeChecker > > const &', 'o')]) + ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] + cls.add_method('Cleanup', + 'void', + [], + is_static=True) + return + +def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, cls): + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] + cls.add_constructor([]) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter< ns3::AttributeValue > > const &', 'o')]) + ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] + cls.add_method('Cleanup', + 'void', + [], + is_static=True) + return + +def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3CallbackImplBase__gt___methods(root_module, cls): + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] + cls.add_constructor([]) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + cls.add_constructor([param('ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter< ns3::CallbackImplBase > > const &', 'o')]) + ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] + cls.add_method('Cleanup', + 'void', + [], + is_static=True) + return + +def register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3EventImpl__gt___methods(root_module, cls): + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] + cls.add_constructor([]) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + cls.add_constructor([param('ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter< ns3::EventImpl > > const &', 'o')]) + ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] + cls.add_method('Cleanup', + 'void', + [], + is_static=True) + return + +def register_Ns3SimpleRefCount__Ns3NixVector_Ns3Empty_Ns3DefaultDeleter__lt__ns3NixVector__gt___methods(root_module, cls): + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] + cls.add_constructor([]) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + cls.add_constructor([param('ns3::SimpleRefCount< ns3::NixVector, ns3::empty, ns3::DefaultDeleter< ns3::NixVector > > const &', 'o')]) + ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] + cls.add_method('Cleanup', + 'void', + [], + is_static=True) + return + +def register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Packet__gt___methods(root_module, cls): + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] + cls.add_constructor([]) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + cls.add_constructor([param('ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter< ns3::Packet > > const &', 'o')]) + ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] + cls.add_method('Cleanup', + 'void', + [], + is_static=True) + return + +def register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3TraceSourceAccessor__gt___methods(root_module, cls): + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] + cls.add_constructor([]) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + cls.add_constructor([param('ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter< ns3::TraceSourceAccessor > > const &', 'o')]) + ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] + cls.add_method('Cleanup', + 'void', + [], + is_static=True) + return + +def register_Ns3Time_methods(root_module, cls): + cls.add_binary_numeric_operator('+', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', 'right')) + cls.add_binary_numeric_operator('-', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', 'right')) + cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('>') + cls.add_binary_comparison_operator('!=') + cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', 'right')) + cls.add_inplace_numeric_operator('-=', param('ns3::Time const &', 'right')) + cls.add_output_stream_operator() + cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('>=') + ## nstime.h (module 'core'): ns3::Time::Time() [constructor] + cls.add_constructor([]) + ## nstime.h (module 'core'): ns3::Time::Time(ns3::Time const & o) [copy constructor] + cls.add_constructor([param('ns3::Time const &', 'o')]) + ## nstime.h (module 'core'): ns3::Time::Time(double v) [constructor] + cls.add_constructor([param('double', 'v')]) + ## nstime.h (module 'core'): ns3::Time::Time(int v) [constructor] + cls.add_constructor([param('int', 'v')]) + ## nstime.h (module 'core'): ns3::Time::Time(long int v) [constructor] + cls.add_constructor([param('long int', 'v')]) + ## nstime.h (module 'core'): ns3::Time::Time(long long int v) [constructor] + cls.add_constructor([param('long long int', 'v')]) + ## nstime.h (module 'core'): ns3::Time::Time(unsigned int v) [constructor] + cls.add_constructor([param('unsigned int', 'v')]) + ## nstime.h (module 'core'): ns3::Time::Time(long unsigned int v) [constructor] + cls.add_constructor([param('long unsigned int', 'v')]) + ## nstime.h (module 'core'): ns3::Time::Time(long long unsigned int v) [constructor] + cls.add_constructor([param('long long unsigned int', 'v')]) + ## nstime.h (module 'core'): ns3::Time::Time(std::string const & s) [constructor] + cls.add_constructor([param('std::string const &', 's')]) + ## nstime.h (module 'core'): ns3::Time::Time(ns3::int64x64_t const & value) [constructor] + cls.add_constructor([param('ns3::int64x64_t const &', 'value')]) + ## nstime.h (module 'core'): int ns3::Time::Compare(ns3::Time const & o) const [member function] + cls.add_method('Compare', + 'int', + [param('ns3::Time const &', 'o')], + is_const=True) + ## nstime.h (module 'core'): static ns3::Time ns3::Time::From(ns3::int64x64_t const & from, ns3::Time::Unit timeUnit) [member function] + cls.add_method('From', + 'ns3::Time', + [param('ns3::int64x64_t const &', 'from'), param('ns3::Time::Unit', 'timeUnit')], + is_static=True) + ## nstime.h (module 'core'): static ns3::Time ns3::Time::From(ns3::int64x64_t const & value) [member function] + cls.add_method('From', + 'ns3::Time', + [param('ns3::int64x64_t const &', 'value')], + is_static=True) + ## nstime.h (module 'core'): static ns3::Time ns3::Time::FromDouble(double value, ns3::Time::Unit timeUnit) [member function] + cls.add_method('FromDouble', + 'ns3::Time', + [param('double', 'value'), param('ns3::Time::Unit', 'timeUnit')], + is_static=True) + ## nstime.h (module 'core'): static ns3::Time ns3::Time::FromInteger(uint64_t value, ns3::Time::Unit timeUnit) [member function] + cls.add_method('FromInteger', + 'ns3::Time', + [param('uint64_t', 'value'), param('ns3::Time::Unit', 'timeUnit')], + is_static=True) + ## nstime.h (module 'core'): double ns3::Time::GetDouble() const [member function] + cls.add_method('GetDouble', + 'double', + [], + is_const=True) + ## nstime.h (module 'core'): int64_t ns3::Time::GetFemtoSeconds() const [member function] + cls.add_method('GetFemtoSeconds', + 'int64_t', + [], + is_const=True) + ## nstime.h (module 'core'): int64_t ns3::Time::GetInteger() const [member function] + cls.add_method('GetInteger', + 'int64_t', + [], + is_const=True) + ## nstime.h (module 'core'): int64_t ns3::Time::GetMicroSeconds() const [member function] + cls.add_method('GetMicroSeconds', + 'int64_t', + [], + is_const=True) + ## nstime.h (module 'core'): int64_t ns3::Time::GetMilliSeconds() const [member function] + cls.add_method('GetMilliSeconds', + 'int64_t', + [], + is_const=True) + ## nstime.h (module 'core'): int64_t ns3::Time::GetNanoSeconds() const [member function] + cls.add_method('GetNanoSeconds', + 'int64_t', + [], + is_const=True) + ## nstime.h (module 'core'): int64_t ns3::Time::GetPicoSeconds() const [member function] + cls.add_method('GetPicoSeconds', + 'int64_t', + [], + is_const=True) + ## nstime.h (module 'core'): static ns3::Time::Unit ns3::Time::GetResolution() [member function] + cls.add_method('GetResolution', + 'ns3::Time::Unit', + [], + is_static=True) + ## nstime.h (module 'core'): double ns3::Time::GetSeconds() const [member function] + cls.add_method('GetSeconds', + 'double', + [], + is_const=True) + ## nstime.h (module 'core'): int64_t ns3::Time::GetTimeStep() const [member function] + cls.add_method('GetTimeStep', + 'int64_t', + [], + is_const=True) + ## nstime.h (module 'core'): bool ns3::Time::IsNegative() const [member function] + cls.add_method('IsNegative', + 'bool', + [], + is_const=True) + ## nstime.h (module 'core'): bool ns3::Time::IsPositive() const [member function] + cls.add_method('IsPositive', + 'bool', + [], + is_const=True) + ## nstime.h (module 'core'): bool ns3::Time::IsStrictlyNegative() const [member function] + cls.add_method('IsStrictlyNegative', + 'bool', + [], + is_const=True) + ## nstime.h (module 'core'): bool ns3::Time::IsStrictlyPositive() const [member function] + cls.add_method('IsStrictlyPositive', + 'bool', + [], + is_const=True) + ## nstime.h (module 'core'): bool ns3::Time::IsZero() const [member function] + cls.add_method('IsZero', + 'bool', + [], + is_const=True) + ## nstime.h (module 'core'): static void ns3::Time::SetResolution(ns3::Time::Unit resolution) [member function] + cls.add_method('SetResolution', + 'void', + [param('ns3::Time::Unit', 'resolution')], + is_static=True) + ## nstime.h (module 'core'): ns3::int64x64_t ns3::Time::To(ns3::Time::Unit timeUnit) const [member function] + cls.add_method('To', + 'ns3::int64x64_t', + [param('ns3::Time::Unit', 'timeUnit')], + is_const=True) + ## nstime.h (module 'core'): double ns3::Time::ToDouble(ns3::Time::Unit timeUnit) const [member function] + cls.add_method('ToDouble', + 'double', + [param('ns3::Time::Unit', 'timeUnit')], + is_const=True) + ## nstime.h (module 'core'): int64_t ns3::Time::ToInteger(ns3::Time::Unit timeUnit) const [member function] + cls.add_method('ToInteger', + 'int64_t', + [param('ns3::Time::Unit', 'timeUnit')], + is_const=True) + return + +def register_Ns3TraceSourceAccessor_methods(root_module, cls): + ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [copy constructor] + cls.add_constructor([param('ns3::TraceSourceAccessor const &', 'arg0')]) + ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor] + cls.add_constructor([]) + ## trace-source-accessor.h (module 'core'): bool ns3::TraceSourceAccessor::Connect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function] + cls.add_method('Connect', + 'bool', + [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## trace-source-accessor.h (module 'core'): bool ns3::TraceSourceAccessor::ConnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function] + cls.add_method('ConnectWithoutContext', + 'bool', + [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase const &', 'cb')], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## trace-source-accessor.h (module 'core'): bool ns3::TraceSourceAccessor::Disconnect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function] + cls.add_method('Disconnect', + 'bool', + [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## trace-source-accessor.h (module 'core'): bool ns3::TraceSourceAccessor::DisconnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function] + cls.add_method('DisconnectWithoutContext', + 'bool', + [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase const &', 'cb')], + is_pure_virtual=True, is_const=True, is_virtual=True) + return + +def register_Ns3Trailer_methods(root_module, cls): + cls.add_output_stream_operator() + ## trailer.h (module 'network'): ns3::Trailer::Trailer() [constructor] + cls.add_constructor([]) + ## trailer.h (module 'network'): ns3::Trailer::Trailer(ns3::Trailer const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Trailer const &', 'arg0')]) + ## trailer.h (module 'network'): uint32_t ns3::Trailer::Deserialize(ns3::Buffer::Iterator end) [member function] + cls.add_method('Deserialize', + 'uint32_t', + [param('ns3::Buffer::Iterator', 'end')], + is_pure_virtual=True, is_virtual=True) + ## trailer.h (module 'network'): uint32_t ns3::Trailer::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', + 'uint32_t', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## trailer.h (module 'network'): static ns3::TypeId ns3::Trailer::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## trailer.h (module 'network'): void ns3::Trailer::Print(std::ostream & os) const [member function] + cls.add_method('Print', + 'void', + [param('std::ostream &', 'os')], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## trailer.h (module 'network'): void ns3::Trailer::Serialize(ns3::Buffer::Iterator start) const [member function] + cls.add_method('Serialize', + 'void', + [param('ns3::Buffer::Iterator', 'start')], + is_pure_virtual=True, is_const=True, is_virtual=True) + return + +def register_Ns3UanHeaderCommon_methods(root_module, cls): + ## uan-header-common.h (module 'uan'): ns3::UanHeaderCommon::UanHeaderCommon(ns3::UanHeaderCommon const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanHeaderCommon const &', 'arg0')]) + ## uan-header-common.h (module 'uan'): ns3::UanHeaderCommon::UanHeaderCommon() [constructor] + cls.add_constructor([]) + ## uan-header-common.h (module 'uan'): ns3::UanHeaderCommon::UanHeaderCommon(ns3::UanAddress const src, ns3::UanAddress const dest, uint8_t type) [constructor] + cls.add_constructor([param('ns3::UanAddress const', 'src'), param('ns3::UanAddress const', 'dest'), param('uint8_t', 'type')]) + ## uan-header-common.h (module 'uan'): uint32_t ns3::UanHeaderCommon::Deserialize(ns3::Buffer::Iterator start) [member function] + cls.add_method('Deserialize', + 'uint32_t', + [param('ns3::Buffer::Iterator', 'start')], + is_virtual=True) + ## uan-header-common.h (module 'uan'): ns3::UanAddress ns3::UanHeaderCommon::GetDest() const [member function] + cls.add_method('GetDest', + 'ns3::UanAddress', + [], + is_const=True) + ## uan-header-common.h (module 'uan'): ns3::TypeId ns3::UanHeaderCommon::GetInstanceTypeId() const [member function] + cls.add_method('GetInstanceTypeId', + 'ns3::TypeId', + [], + is_const=True, is_virtual=True) + ## uan-header-common.h (module 'uan'): uint32_t ns3::UanHeaderCommon::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', + 'uint32_t', + [], + is_const=True, is_virtual=True) + ## uan-header-common.h (module 'uan'): ns3::UanAddress ns3::UanHeaderCommon::GetSrc() const [member function] + cls.add_method('GetSrc', + 'ns3::UanAddress', + [], + is_const=True) + ## uan-header-common.h (module 'uan'): uint8_t ns3::UanHeaderCommon::GetType() const [member function] + cls.add_method('GetType', + 'uint8_t', + [], + is_const=True) + ## uan-header-common.h (module 'uan'): static ns3::TypeId ns3::UanHeaderCommon::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## uan-header-common.h (module 'uan'): void ns3::UanHeaderCommon::Print(std::ostream & os) const [member function] + cls.add_method('Print', + 'void', + [param('std::ostream &', 'os')], + is_const=True, is_virtual=True) + ## uan-header-common.h (module 'uan'): void ns3::UanHeaderCommon::Serialize(ns3::Buffer::Iterator start) const [member function] + cls.add_method('Serialize', + 'void', + [param('ns3::Buffer::Iterator', 'start')], + is_const=True, is_virtual=True) + ## uan-header-common.h (module 'uan'): void ns3::UanHeaderCommon::SetDest(ns3::UanAddress dest) [member function] + cls.add_method('SetDest', + 'void', + [param('ns3::UanAddress', 'dest')]) + ## uan-header-common.h (module 'uan'): void ns3::UanHeaderCommon::SetSrc(ns3::UanAddress src) [member function] + cls.add_method('SetSrc', + 'void', + [param('ns3::UanAddress', 'src')]) + ## uan-header-common.h (module 'uan'): void ns3::UanHeaderCommon::SetType(uint8_t type) [member function] + cls.add_method('SetType', + 'void', + [param('uint8_t', 'type')]) + return + +def register_Ns3UanHeaderRcAck_methods(root_module, cls): + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcAck::UanHeaderRcAck(ns3::UanHeaderRcAck const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanHeaderRcAck const &', 'arg0')]) + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcAck::UanHeaderRcAck() [constructor] + cls.add_constructor([]) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcAck::AddNackedFrame(uint8_t frame) [member function] + cls.add_method('AddNackedFrame', + 'void', + [param('uint8_t', 'frame')]) + ## uan-header-rc.h (module 'uan'): uint32_t ns3::UanHeaderRcAck::Deserialize(ns3::Buffer::Iterator start) [member function] + cls.add_method('Deserialize', + 'uint32_t', + [param('ns3::Buffer::Iterator', 'start')], + is_virtual=True) + ## uan-header-rc.h (module 'uan'): uint8_t ns3::UanHeaderRcAck::GetFrameNo() const [member function] + cls.add_method('GetFrameNo', + 'uint8_t', + [], + is_const=True) + ## uan-header-rc.h (module 'uan'): ns3::TypeId ns3::UanHeaderRcAck::GetInstanceTypeId() const [member function] + cls.add_method('GetInstanceTypeId', + 'ns3::TypeId', + [], + is_const=True, is_virtual=True) + ## uan-header-rc.h (module 'uan'): std::set, std::allocator > const & ns3::UanHeaderRcAck::GetNackedFrames() const [member function] + cls.add_method('GetNackedFrames', + 'std::set< unsigned char > const &', + [], + is_const=True) + ## uan-header-rc.h (module 'uan'): uint8_t ns3::UanHeaderRcAck::GetNoNacks() const [member function] + cls.add_method('GetNoNacks', + 'uint8_t', + [], + is_const=True) + ## uan-header-rc.h (module 'uan'): uint32_t ns3::UanHeaderRcAck::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', + 'uint32_t', + [], + is_const=True, is_virtual=True) + ## uan-header-rc.h (module 'uan'): static ns3::TypeId ns3::UanHeaderRcAck::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcAck::Print(std::ostream & os) const [member function] + cls.add_method('Print', + 'void', + [param('std::ostream &', 'os')], + is_const=True, is_virtual=True) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcAck::Serialize(ns3::Buffer::Iterator start) const [member function] + cls.add_method('Serialize', + 'void', + [param('ns3::Buffer::Iterator', 'start')], + is_const=True, is_virtual=True) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcAck::SetFrameNo(uint8_t frameNo) [member function] + cls.add_method('SetFrameNo', + 'void', + [param('uint8_t', 'frameNo')]) + return + +def register_Ns3UanHeaderRcCts_methods(root_module, cls): + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcCts::UanHeaderRcCts(ns3::UanHeaderRcCts const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanHeaderRcCts const &', 'arg0')]) + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcCts::UanHeaderRcCts() [constructor] + cls.add_constructor([]) + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcCts::UanHeaderRcCts(uint8_t frameNo, uint8_t retryNo, ns3::Time rtsTs, ns3::Time delay, ns3::UanAddress addr) [constructor] + cls.add_constructor([param('uint8_t', 'frameNo'), param('uint8_t', 'retryNo'), param('ns3::Time', 'rtsTs'), param('ns3::Time', 'delay'), param('ns3::UanAddress', 'addr')]) + ## uan-header-rc.h (module 'uan'): uint32_t ns3::UanHeaderRcCts::Deserialize(ns3::Buffer::Iterator start) [member function] + cls.add_method('Deserialize', + 'uint32_t', + [param('ns3::Buffer::Iterator', 'start')], + is_virtual=True) + ## uan-header-rc.h (module 'uan'): ns3::UanAddress ns3::UanHeaderRcCts::GetAddress() const [member function] + cls.add_method('GetAddress', + 'ns3::UanAddress', + [], + is_const=True) + ## uan-header-rc.h (module 'uan'): ns3::Time ns3::UanHeaderRcCts::GetDelayToTx() const [member function] + cls.add_method('GetDelayToTx', + 'ns3::Time', + [], + is_const=True) + ## uan-header-rc.h (module 'uan'): uint8_t ns3::UanHeaderRcCts::GetFrameNo() const [member function] + cls.add_method('GetFrameNo', + 'uint8_t', + [], + is_const=True) + ## uan-header-rc.h (module 'uan'): ns3::TypeId ns3::UanHeaderRcCts::GetInstanceTypeId() const [member function] + cls.add_method('GetInstanceTypeId', + 'ns3::TypeId', + [], + is_const=True, is_virtual=True) + ## uan-header-rc.h (module 'uan'): uint8_t ns3::UanHeaderRcCts::GetRetryNo() const [member function] + cls.add_method('GetRetryNo', + 'uint8_t', + [], + is_const=True) + ## uan-header-rc.h (module 'uan'): ns3::Time ns3::UanHeaderRcCts::GetRtsTimeStamp() const [member function] + cls.add_method('GetRtsTimeStamp', + 'ns3::Time', + [], + is_const=True) + ## uan-header-rc.h (module 'uan'): uint32_t ns3::UanHeaderRcCts::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', + 'uint32_t', + [], + is_const=True, is_virtual=True) + ## uan-header-rc.h (module 'uan'): static ns3::TypeId ns3::UanHeaderRcCts::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcCts::Print(std::ostream & os) const [member function] + cls.add_method('Print', + 'void', + [param('std::ostream &', 'os')], + is_const=True, is_virtual=True) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcCts::Serialize(ns3::Buffer::Iterator start) const [member function] + cls.add_method('Serialize', + 'void', + [param('ns3::Buffer::Iterator', 'start')], + is_const=True, is_virtual=True) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcCts::SetAddress(ns3::UanAddress addr) [member function] + cls.add_method('SetAddress', + 'void', + [param('ns3::UanAddress', 'addr')]) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcCts::SetDelayToTx(ns3::Time delay) [member function] + cls.add_method('SetDelayToTx', + 'void', + [param('ns3::Time', 'delay')]) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcCts::SetFrameNo(uint8_t frameNo) [member function] + cls.add_method('SetFrameNo', + 'void', + [param('uint8_t', 'frameNo')]) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcCts::SetRetryNo(uint8_t no) [member function] + cls.add_method('SetRetryNo', + 'void', + [param('uint8_t', 'no')]) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcCts::SetRtsTimeStamp(ns3::Time timeStamp) [member function] + cls.add_method('SetRtsTimeStamp', + 'void', + [param('ns3::Time', 'timeStamp')]) + return + +def register_Ns3UanHeaderRcCtsGlobal_methods(root_module, cls): + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcCtsGlobal::UanHeaderRcCtsGlobal(ns3::UanHeaderRcCtsGlobal const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanHeaderRcCtsGlobal const &', 'arg0')]) + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcCtsGlobal::UanHeaderRcCtsGlobal() [constructor] + cls.add_constructor([]) + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcCtsGlobal::UanHeaderRcCtsGlobal(ns3::Time wt, ns3::Time ts, uint16_t rate, uint16_t retryRate) [constructor] + cls.add_constructor([param('ns3::Time', 'wt'), param('ns3::Time', 'ts'), param('uint16_t', 'rate'), param('uint16_t', 'retryRate')]) + ## uan-header-rc.h (module 'uan'): uint32_t ns3::UanHeaderRcCtsGlobal::Deserialize(ns3::Buffer::Iterator start) [member function] + cls.add_method('Deserialize', + 'uint32_t', + [param('ns3::Buffer::Iterator', 'start')], + is_virtual=True) + ## uan-header-rc.h (module 'uan'): ns3::TypeId ns3::UanHeaderRcCtsGlobal::GetInstanceTypeId() const [member function] + cls.add_method('GetInstanceTypeId', + 'ns3::TypeId', + [], + is_const=True, is_virtual=True) + ## uan-header-rc.h (module 'uan'): uint16_t ns3::UanHeaderRcCtsGlobal::GetRateNum() const [member function] + cls.add_method('GetRateNum', + 'uint16_t', + [], + is_const=True) + ## uan-header-rc.h (module 'uan'): uint16_t ns3::UanHeaderRcCtsGlobal::GetRetryRate() const [member function] + cls.add_method('GetRetryRate', + 'uint16_t', + [], + is_const=True) + ## uan-header-rc.h (module 'uan'): uint32_t ns3::UanHeaderRcCtsGlobal::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', + 'uint32_t', + [], + is_const=True, is_virtual=True) + ## uan-header-rc.h (module 'uan'): ns3::Time ns3::UanHeaderRcCtsGlobal::GetTxTimeStamp() const [member function] + cls.add_method('GetTxTimeStamp', + 'ns3::Time', + [], + is_const=True) + ## uan-header-rc.h (module 'uan'): static ns3::TypeId ns3::UanHeaderRcCtsGlobal::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## uan-header-rc.h (module 'uan'): ns3::Time ns3::UanHeaderRcCtsGlobal::GetWindowTime() const [member function] + cls.add_method('GetWindowTime', + 'ns3::Time', + [], + is_const=True) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcCtsGlobal::Print(std::ostream & os) const [member function] + cls.add_method('Print', + 'void', + [param('std::ostream &', 'os')], + is_const=True, is_virtual=True) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcCtsGlobal::Serialize(ns3::Buffer::Iterator start) const [member function] + cls.add_method('Serialize', + 'void', + [param('ns3::Buffer::Iterator', 'start')], + is_const=True, is_virtual=True) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcCtsGlobal::SetRateNum(uint16_t rate) [member function] + cls.add_method('SetRateNum', + 'void', + [param('uint16_t', 'rate')]) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcCtsGlobal::SetRetryRate(uint16_t rate) [member function] + cls.add_method('SetRetryRate', + 'void', + [param('uint16_t', 'rate')]) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcCtsGlobal::SetTxTimeStamp(ns3::Time timeStamp) [member function] + cls.add_method('SetTxTimeStamp', + 'void', + [param('ns3::Time', 'timeStamp')]) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcCtsGlobal::SetWindowTime(ns3::Time t) [member function] + cls.add_method('SetWindowTime', + 'void', + [param('ns3::Time', 't')]) + return + +def register_Ns3UanHeaderRcData_methods(root_module, cls): + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcData::UanHeaderRcData(ns3::UanHeaderRcData const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanHeaderRcData const &', 'arg0')]) + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcData::UanHeaderRcData() [constructor] + cls.add_constructor([]) + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcData::UanHeaderRcData(uint8_t frameNum, ns3::Time propDelay) [constructor] + cls.add_constructor([param('uint8_t', 'frameNum'), param('ns3::Time', 'propDelay')]) + ## uan-header-rc.h (module 'uan'): uint32_t ns3::UanHeaderRcData::Deserialize(ns3::Buffer::Iterator start) [member function] + cls.add_method('Deserialize', + 'uint32_t', + [param('ns3::Buffer::Iterator', 'start')], + is_virtual=True) + ## uan-header-rc.h (module 'uan'): uint8_t ns3::UanHeaderRcData::GetFrameNo() const [member function] + cls.add_method('GetFrameNo', + 'uint8_t', + [], + is_const=True) + ## uan-header-rc.h (module 'uan'): ns3::TypeId ns3::UanHeaderRcData::GetInstanceTypeId() const [member function] + cls.add_method('GetInstanceTypeId', + 'ns3::TypeId', + [], + is_const=True, is_virtual=True) + ## uan-header-rc.h (module 'uan'): ns3::Time ns3::UanHeaderRcData::GetPropDelay() const [member function] + cls.add_method('GetPropDelay', + 'ns3::Time', + [], + is_const=True) + ## uan-header-rc.h (module 'uan'): uint32_t ns3::UanHeaderRcData::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', + 'uint32_t', + [], + is_const=True, is_virtual=True) + ## uan-header-rc.h (module 'uan'): static ns3::TypeId ns3::UanHeaderRcData::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcData::Print(std::ostream & os) const [member function] + cls.add_method('Print', + 'void', + [param('std::ostream &', 'os')], + is_const=True, is_virtual=True) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcData::Serialize(ns3::Buffer::Iterator start) const [member function] + cls.add_method('Serialize', + 'void', + [param('ns3::Buffer::Iterator', 'start')], + is_const=True, is_virtual=True) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcData::SetFrameNo(uint8_t frameNum) [member function] + cls.add_method('SetFrameNo', + 'void', + [param('uint8_t', 'frameNum')]) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcData::SetPropDelay(ns3::Time propDelay) [member function] + cls.add_method('SetPropDelay', + 'void', + [param('ns3::Time', 'propDelay')]) + return + +def register_Ns3UanHeaderRcRts_methods(root_module, cls): + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcRts::UanHeaderRcRts(ns3::UanHeaderRcRts const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanHeaderRcRts const &', 'arg0')]) + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcRts::UanHeaderRcRts() [constructor] + cls.add_constructor([]) + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcRts::UanHeaderRcRts(uint8_t frameNo, uint8_t retryNo, uint8_t noFrames, uint16_t length, ns3::Time ts) [constructor] + cls.add_constructor([param('uint8_t', 'frameNo'), param('uint8_t', 'retryNo'), param('uint8_t', 'noFrames'), param('uint16_t', 'length'), param('ns3::Time', 'ts')]) + ## uan-header-rc.h (module 'uan'): uint32_t ns3::UanHeaderRcRts::Deserialize(ns3::Buffer::Iterator start) [member function] + cls.add_method('Deserialize', + 'uint32_t', + [param('ns3::Buffer::Iterator', 'start')], + is_virtual=True) + ## uan-header-rc.h (module 'uan'): uint8_t ns3::UanHeaderRcRts::GetFrameNo() const [member function] + cls.add_method('GetFrameNo', + 'uint8_t', + [], + is_const=True) + ## uan-header-rc.h (module 'uan'): ns3::TypeId ns3::UanHeaderRcRts::GetInstanceTypeId() const [member function] + cls.add_method('GetInstanceTypeId', + 'ns3::TypeId', + [], + is_const=True, is_virtual=True) + ## uan-header-rc.h (module 'uan'): uint16_t ns3::UanHeaderRcRts::GetLength() const [member function] + cls.add_method('GetLength', + 'uint16_t', + [], + is_const=True) + ## uan-header-rc.h (module 'uan'): uint8_t ns3::UanHeaderRcRts::GetNoFrames() const [member function] + cls.add_method('GetNoFrames', + 'uint8_t', + [], + is_const=True) + ## uan-header-rc.h (module 'uan'): uint8_t ns3::UanHeaderRcRts::GetRetryNo() const [member function] + cls.add_method('GetRetryNo', + 'uint8_t', + [], + is_const=True) + ## uan-header-rc.h (module 'uan'): uint32_t ns3::UanHeaderRcRts::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', + 'uint32_t', + [], + is_const=True, is_virtual=True) + ## uan-header-rc.h (module 'uan'): ns3::Time ns3::UanHeaderRcRts::GetTimeStamp() const [member function] + cls.add_method('GetTimeStamp', + 'ns3::Time', + [], + is_const=True) + ## uan-header-rc.h (module 'uan'): static ns3::TypeId ns3::UanHeaderRcRts::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcRts::Print(std::ostream & os) const [member function] + cls.add_method('Print', + 'void', + [param('std::ostream &', 'os')], + is_const=True, is_virtual=True) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcRts::Serialize(ns3::Buffer::Iterator start) const [member function] + cls.add_method('Serialize', + 'void', + [param('ns3::Buffer::Iterator', 'start')], + is_const=True, is_virtual=True) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcRts::SetFrameNo(uint8_t fno) [member function] + cls.add_method('SetFrameNo', + 'void', + [param('uint8_t', 'fno')]) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcRts::SetLength(uint16_t length) [member function] + cls.add_method('SetLength', + 'void', + [param('uint16_t', 'length')]) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcRts::SetNoFrames(uint8_t no) [member function] + cls.add_method('SetNoFrames', + 'void', + [param('uint8_t', 'no')]) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcRts::SetRetryNo(uint8_t no) [member function] + cls.add_method('SetRetryNo', + 'void', + [param('uint8_t', 'no')]) + ## uan-header-rc.h (module 'uan'): void ns3::UanHeaderRcRts::SetTimeStamp(ns3::Time timeStamp) [member function] + cls.add_method('SetTimeStamp', + 'void', + [param('ns3::Time', 'timeStamp')]) + return + +def register_Ns3UanMac_methods(root_module, cls): + ## uan-mac.h (module 'uan'): ns3::UanMac::UanMac() [constructor] + cls.add_constructor([]) + ## uan-mac.h (module 'uan'): ns3::UanMac::UanMac(ns3::UanMac const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanMac const &', 'arg0')]) + ## uan-mac.h (module 'uan'): void ns3::UanMac::AttachPhy(ns3::Ptr phy) [member function] + cls.add_method('AttachPhy', + 'void', + [param('ns3::Ptr< ns3::UanPhy >', 'phy')], + is_pure_virtual=True, is_virtual=True) + ## uan-mac.h (module 'uan'): void ns3::UanMac::Clear() [member function] + cls.add_method('Clear', + 'void', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-mac.h (module 'uan'): bool ns3::UanMac::Enqueue(ns3::Ptr pkt, ns3::Address const & dest, uint16_t protocolNumber) [member function] + cls.add_method('Enqueue', + 'bool', + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], + is_pure_virtual=True, is_virtual=True) + ## uan-mac.h (module 'uan'): ns3::Address ns3::UanMac::GetAddress() [member function] + cls.add_method('GetAddress', + 'ns3::Address', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-mac.h (module 'uan'): ns3::Address ns3::UanMac::GetBroadcast() const [member function] + cls.add_method('GetBroadcast', + 'ns3::Address', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## uan-mac.h (module 'uan'): static ns3::TypeId ns3::UanMac::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## uan-mac.h (module 'uan'): void ns3::UanMac::SetAddress(ns3::UanAddress addr) [member function] + cls.add_method('SetAddress', + 'void', + [param('ns3::UanAddress', 'addr')], + is_pure_virtual=True, is_virtual=True) + ## uan-mac.h (module 'uan'): void ns3::UanMac::SetForwardUpCb(ns3::Callback, ns3::UanAddress const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + cls.add_method('SetForwardUpCb', + 'void', + [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::UanAddress const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], + is_pure_virtual=True, is_virtual=True) + return + +def register_Ns3UanMacAloha_methods(root_module, cls): + ## uan-mac-aloha.h (module 'uan'): ns3::UanMacAloha::UanMacAloha(ns3::UanMacAloha const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanMacAloha const &', 'arg0')]) + ## uan-mac-aloha.h (module 'uan'): ns3::UanMacAloha::UanMacAloha() [constructor] + cls.add_constructor([]) + ## uan-mac-aloha.h (module 'uan'): void ns3::UanMacAloha::AttachPhy(ns3::Ptr phy) [member function] + cls.add_method('AttachPhy', + 'void', + [param('ns3::Ptr< ns3::UanPhy >', 'phy')], + is_virtual=True) + ## uan-mac-aloha.h (module 'uan'): void ns3::UanMacAloha::Clear() [member function] + cls.add_method('Clear', + 'void', + [], + is_virtual=True) + ## uan-mac-aloha.h (module 'uan'): bool ns3::UanMacAloha::Enqueue(ns3::Ptr pkt, ns3::Address const & dest, uint16_t protocolNumber) [member function] + cls.add_method('Enqueue', + 'bool', + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], + is_virtual=True) + ## uan-mac-aloha.h (module 'uan'): ns3::Address ns3::UanMacAloha::GetAddress() [member function] + cls.add_method('GetAddress', + 'ns3::Address', + [], + is_virtual=True) + ## uan-mac-aloha.h (module 'uan'): ns3::Address ns3::UanMacAloha::GetBroadcast() const [member function] + cls.add_method('GetBroadcast', + 'ns3::Address', + [], + is_const=True, is_virtual=True) + ## uan-mac-aloha.h (module 'uan'): static ns3::TypeId ns3::UanMacAloha::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## uan-mac-aloha.h (module 'uan'): void ns3::UanMacAloha::SetAddress(ns3::UanAddress addr) [member function] + cls.add_method('SetAddress', + 'void', + [param('ns3::UanAddress', 'addr')], + is_virtual=True) + ## uan-mac-aloha.h (module 'uan'): void ns3::UanMacAloha::SetForwardUpCb(ns3::Callback, ns3::UanAddress const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + cls.add_method('SetForwardUpCb', + 'void', + [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::UanAddress const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], + is_virtual=True) + ## uan-mac-aloha.h (module 'uan'): void ns3::UanMacAloha::DoDispose() [member function] + cls.add_method('DoDispose', + 'void', + [], + visibility='protected', is_virtual=True) + return + +def register_Ns3UanMacCw_methods(root_module, cls): + ## uan-mac-cw.h (module 'uan'): ns3::UanMacCw::UanMacCw(ns3::UanMacCw const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanMacCw const &', 'arg0')]) + ## uan-mac-cw.h (module 'uan'): ns3::UanMacCw::UanMacCw() [constructor] + cls.add_constructor([]) + ## uan-mac-cw.h (module 'uan'): void ns3::UanMacCw::AttachPhy(ns3::Ptr phy) [member function] + cls.add_method('AttachPhy', + 'void', + [param('ns3::Ptr< ns3::UanPhy >', 'phy')], + is_virtual=True) + ## uan-mac-cw.h (module 'uan'): void ns3::UanMacCw::Clear() [member function] + cls.add_method('Clear', + 'void', + [], + is_virtual=True) + ## uan-mac-cw.h (module 'uan'): bool ns3::UanMacCw::Enqueue(ns3::Ptr pkt, ns3::Address const & dest, uint16_t protocolNumber) [member function] + cls.add_method('Enqueue', + 'bool', + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], + is_virtual=True) + ## uan-mac-cw.h (module 'uan'): ns3::Address ns3::UanMacCw::GetAddress() [member function] + cls.add_method('GetAddress', + 'ns3::Address', + [], + is_virtual=True) + ## uan-mac-cw.h (module 'uan'): ns3::Address ns3::UanMacCw::GetBroadcast() const [member function] + cls.add_method('GetBroadcast', + 'ns3::Address', + [], + is_const=True, is_virtual=True) + ## uan-mac-cw.h (module 'uan'): uint32_t ns3::UanMacCw::GetCw() [member function] + cls.add_method('GetCw', + 'uint32_t', + [], + is_virtual=True) + ## uan-mac-cw.h (module 'uan'): ns3::Time ns3::UanMacCw::GetSlotTime() [member function] + cls.add_method('GetSlotTime', + 'ns3::Time', + [], + is_virtual=True) + ## uan-mac-cw.h (module 'uan'): static ns3::TypeId ns3::UanMacCw::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## uan-mac-cw.h (module 'uan'): void ns3::UanMacCw::NotifyCcaEnd() [member function] + cls.add_method('NotifyCcaEnd', + 'void', + [], + is_virtual=True) + ## uan-mac-cw.h (module 'uan'): void ns3::UanMacCw::NotifyCcaStart() [member function] + cls.add_method('NotifyCcaStart', + 'void', + [], + is_virtual=True) + ## uan-mac-cw.h (module 'uan'): void ns3::UanMacCw::NotifyRxEndError() [member function] + cls.add_method('NotifyRxEndError', + 'void', + [], + is_virtual=True) + ## uan-mac-cw.h (module 'uan'): void ns3::UanMacCw::NotifyRxEndOk() [member function] + cls.add_method('NotifyRxEndOk', + 'void', + [], + is_virtual=True) + ## uan-mac-cw.h (module 'uan'): void ns3::UanMacCw::NotifyRxStart() [member function] + cls.add_method('NotifyRxStart', + 'void', + [], + is_virtual=True) + ## uan-mac-cw.h (module 'uan'): void ns3::UanMacCw::NotifyTxStart(ns3::Time duration) [member function] + cls.add_method('NotifyTxStart', + 'void', + [param('ns3::Time', 'duration')], + is_virtual=True) + ## uan-mac-cw.h (module 'uan'): void ns3::UanMacCw::SetAddress(ns3::UanAddress addr) [member function] + cls.add_method('SetAddress', + 'void', + [param('ns3::UanAddress', 'addr')], + is_virtual=True) + ## uan-mac-cw.h (module 'uan'): void ns3::UanMacCw::SetCw(uint32_t cw) [member function] + cls.add_method('SetCw', + 'void', + [param('uint32_t', 'cw')], + is_virtual=True) + ## uan-mac-cw.h (module 'uan'): void ns3::UanMacCw::SetForwardUpCb(ns3::Callback, ns3::UanAddress const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + cls.add_method('SetForwardUpCb', + 'void', + [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::UanAddress const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], + is_virtual=True) + ## uan-mac-cw.h (module 'uan'): void ns3::UanMacCw::SetSlotTime(ns3::Time duration) [member function] + cls.add_method('SetSlotTime', + 'void', + [param('ns3::Time', 'duration')], + is_virtual=True) + ## uan-mac-cw.h (module 'uan'): void ns3::UanMacCw::DoDispose() [member function] + cls.add_method('DoDispose', + 'void', + [], + visibility='protected', is_virtual=True) + return + +def register_Ns3UanMacRc_methods(root_module, cls): + ## uan-mac-rc.h (module 'uan'): ns3::UanMacRc::UanMacRc(ns3::UanMacRc const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanMacRc const &', 'arg0')]) + ## uan-mac-rc.h (module 'uan'): ns3::UanMacRc::UanMacRc() [constructor] + cls.add_constructor([]) + ## uan-mac-rc.h (module 'uan'): void ns3::UanMacRc::AttachPhy(ns3::Ptr phy) [member function] + cls.add_method('AttachPhy', + 'void', + [param('ns3::Ptr< ns3::UanPhy >', 'phy')], + is_virtual=True) + ## uan-mac-rc.h (module 'uan'): void ns3::UanMacRc::Clear() [member function] + cls.add_method('Clear', + 'void', + [], + is_virtual=True) + ## uan-mac-rc.h (module 'uan'): bool ns3::UanMacRc::Enqueue(ns3::Ptr pkt, ns3::Address const & dest, uint16_t protocolNumber) [member function] + cls.add_method('Enqueue', + 'bool', + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], + is_virtual=True) + ## uan-mac-rc.h (module 'uan'): ns3::Address ns3::UanMacRc::GetAddress() [member function] + cls.add_method('GetAddress', + 'ns3::Address', + [], + is_virtual=True) + ## uan-mac-rc.h (module 'uan'): ns3::Address ns3::UanMacRc::GetBroadcast() const [member function] + cls.add_method('GetBroadcast', + 'ns3::Address', + [], + is_const=True, is_virtual=True) + ## uan-mac-rc.h (module 'uan'): static ns3::TypeId ns3::UanMacRc::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## uan-mac-rc.h (module 'uan'): void ns3::UanMacRc::SetAddress(ns3::UanAddress addr) [member function] + cls.add_method('SetAddress', + 'void', + [param('ns3::UanAddress', 'addr')], + is_virtual=True) + ## uan-mac-rc.h (module 'uan'): void ns3::UanMacRc::SetForwardUpCb(ns3::Callback, ns3::UanAddress const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + cls.add_method('SetForwardUpCb', + 'void', + [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::UanAddress const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], + is_virtual=True) + ## uan-mac-rc.h (module 'uan'): void ns3::UanMacRc::DoDispose() [member function] + cls.add_method('DoDispose', + 'void', + [], + visibility='protected', is_virtual=True) + return + +def register_Ns3UanMacRcGw_methods(root_module, cls): + ## uan-mac-rc-gw.h (module 'uan'): ns3::UanMacRcGw::UanMacRcGw(ns3::UanMacRcGw const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanMacRcGw const &', 'arg0')]) + ## uan-mac-rc-gw.h (module 'uan'): ns3::UanMacRcGw::UanMacRcGw() [constructor] + cls.add_constructor([]) + ## uan-mac-rc-gw.h (module 'uan'): void ns3::UanMacRcGw::AttachPhy(ns3::Ptr phy) [member function] + cls.add_method('AttachPhy', + 'void', + [param('ns3::Ptr< ns3::UanPhy >', 'phy')], + is_virtual=True) + ## uan-mac-rc-gw.h (module 'uan'): void ns3::UanMacRcGw::Clear() [member function] + cls.add_method('Clear', + 'void', + [], + is_virtual=True) + ## uan-mac-rc-gw.h (module 'uan'): bool ns3::UanMacRcGw::Enqueue(ns3::Ptr pkt, ns3::Address const & dest, uint16_t protocolNumber) [member function] + cls.add_method('Enqueue', + 'bool', + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], + is_virtual=True) + ## uan-mac-rc-gw.h (module 'uan'): ns3::Address ns3::UanMacRcGw::GetAddress() [member function] + cls.add_method('GetAddress', + 'ns3::Address', + [], + is_virtual=True) + ## uan-mac-rc-gw.h (module 'uan'): ns3::Address ns3::UanMacRcGw::GetBroadcast() const [member function] + cls.add_method('GetBroadcast', + 'ns3::Address', + [], + is_const=True, is_virtual=True) + ## uan-mac-rc-gw.h (module 'uan'): static ns3::TypeId ns3::UanMacRcGw::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## uan-mac-rc-gw.h (module 'uan'): void ns3::UanMacRcGw::SetAddress(ns3::UanAddress addr) [member function] + cls.add_method('SetAddress', + 'void', + [param('ns3::UanAddress', 'addr')], + is_virtual=True) + ## uan-mac-rc-gw.h (module 'uan'): void ns3::UanMacRcGw::SetForwardUpCb(ns3::Callback, ns3::UanAddress const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + cls.add_method('SetForwardUpCb', + 'void', + [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::UanAddress const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], + is_virtual=True) + ## uan-mac-rc-gw.h (module 'uan'): void ns3::UanMacRcGw::DoDispose() [member function] + cls.add_method('DoDispose', + 'void', + [], + visibility='protected', is_virtual=True) + return + +def register_Ns3UanNoiseModel_methods(root_module, cls): + ## uan-noise-model.h (module 'uan'): ns3::UanNoiseModel::UanNoiseModel() [constructor] + cls.add_constructor([]) + ## uan-noise-model.h (module 'uan'): ns3::UanNoiseModel::UanNoiseModel(ns3::UanNoiseModel const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanNoiseModel const &', 'arg0')]) + ## uan-noise-model.h (module 'uan'): void ns3::UanNoiseModel::Clear() [member function] + cls.add_method('Clear', + 'void', + [], + is_virtual=True) + ## uan-noise-model.h (module 'uan'): void ns3::UanNoiseModel::DoDispose() [member function] + cls.add_method('DoDispose', + 'void', + [], + is_virtual=True) + ## uan-noise-model.h (module 'uan'): double ns3::UanNoiseModel::GetNoiseDbHz(double fKhz) const [member function] + cls.add_method('GetNoiseDbHz', + 'double', + [param('double', 'fKhz')], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## uan-noise-model.h (module 'uan'): static ns3::TypeId ns3::UanNoiseModel::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + return + +def register_Ns3UanNoiseModelDefault_methods(root_module, cls): + ## uan-noise-model-default.h (module 'uan'): ns3::UanNoiseModelDefault::UanNoiseModelDefault(ns3::UanNoiseModelDefault const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanNoiseModelDefault const &', 'arg0')]) + ## uan-noise-model-default.h (module 'uan'): ns3::UanNoiseModelDefault::UanNoiseModelDefault() [constructor] + cls.add_constructor([]) + ## uan-noise-model-default.h (module 'uan'): double ns3::UanNoiseModelDefault::GetNoiseDbHz(double fKhz) const [member function] + cls.add_method('GetNoiseDbHz', + 'double', + [param('double', 'fKhz')], + is_const=True, is_virtual=True) + ## uan-noise-model-default.h (module 'uan'): static ns3::TypeId ns3::UanNoiseModelDefault::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + return + +def register_Ns3UanPhy_methods(root_module, cls): + ## uan-phy.h (module 'uan'): ns3::UanPhy::UanPhy() [constructor] + cls.add_constructor([]) + ## uan-phy.h (module 'uan'): ns3::UanPhy::UanPhy(ns3::UanPhy const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanPhy const &', 'arg0')]) + ## uan-phy.h (module 'uan'): void ns3::UanPhy::Clear() [member function] + cls.add_method('Clear', + 'void', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhy::EnergyDepletionHandler() [member function] + cls.add_method('EnergyDepletionHandler', + 'void', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): double ns3::UanPhy::GetCcaThresholdDb() [member function] + cls.add_method('GetCcaThresholdDb', + 'double', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): ns3::Ptr ns3::UanPhy::GetChannel() const [member function] + cls.add_method('GetChannel', + 'ns3::Ptr< ns3::UanChannel >', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## uan-phy.h (module 'uan'): ns3::Ptr ns3::UanPhy::GetDevice() [member function] + cls.add_method('GetDevice', + 'ns3::Ptr< ns3::UanNetDevice >', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): ns3::UanTxMode ns3::UanPhy::GetMode(uint32_t n) [member function] + cls.add_method('GetMode', + 'ns3::UanTxMode', + [param('uint32_t', 'n')], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): uint32_t ns3::UanPhy::GetNModes() [member function] + cls.add_method('GetNModes', + 'uint32_t', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): ns3::Ptr ns3::UanPhy::GetPacketRx() const [member function] + cls.add_method('GetPacketRx', + 'ns3::Ptr< ns3::Packet >', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## uan-phy.h (module 'uan'): double ns3::UanPhy::GetRxGainDb() [member function] + cls.add_method('GetRxGainDb', + 'double', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): double ns3::UanPhy::GetRxThresholdDb() [member function] + cls.add_method('GetRxThresholdDb', + 'double', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): ns3::Ptr ns3::UanPhy::GetTransducer() [member function] + cls.add_method('GetTransducer', + 'ns3::Ptr< ns3::UanTransducer >', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): double ns3::UanPhy::GetTxPowerDb() [member function] + cls.add_method('GetTxPowerDb', + 'double', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): static ns3::TypeId ns3::UanPhy::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## uan-phy.h (module 'uan'): bool ns3::UanPhy::IsStateBusy() [member function] + cls.add_method('IsStateBusy', + 'bool', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): bool ns3::UanPhy::IsStateCcaBusy() [member function] + cls.add_method('IsStateCcaBusy', + 'bool', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): bool ns3::UanPhy::IsStateIdle() [member function] + cls.add_method('IsStateIdle', + 'bool', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): bool ns3::UanPhy::IsStateRx() [member function] + cls.add_method('IsStateRx', + 'bool', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): bool ns3::UanPhy::IsStateSleep() [member function] + cls.add_method('IsStateSleep', + 'bool', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): bool ns3::UanPhy::IsStateTx() [member function] + cls.add_method('IsStateTx', + 'bool', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhy::NotifyIntChange() [member function] + cls.add_method('NotifyIntChange', + 'void', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhy::NotifyTransStartTx(ns3::Ptr packet, double txPowerDb, ns3::UanTxMode txMode) [member function] + cls.add_method('NotifyTransStartTx', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'packet'), param('double', 'txPowerDb'), param('ns3::UanTxMode', 'txMode')], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhy::RegisterListener(ns3::UanPhyListener * listener) [member function] + cls.add_method('RegisterListener', + 'void', + [param('ns3::UanPhyListener *', 'listener')], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhy::SendPacket(ns3::Ptr pkt, uint32_t modeNum) [member function] + cls.add_method('SendPacket', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('uint32_t', 'modeNum')], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetCcaThresholdDb(double thresh) [member function] + cls.add_method('SetCcaThresholdDb', + 'void', + [param('double', 'thresh')], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetChannel(ns3::Ptr channel) [member function] + cls.add_method('SetChannel', + 'void', + [param('ns3::Ptr< ns3::UanChannel >', 'channel')], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetDevice(ns3::Ptr device) [member function] + cls.add_method('SetDevice', + 'void', + [param('ns3::Ptr< ns3::UanNetDevice >', 'device')], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetEnergyModelCallback(ns3::Callback callback) [member function] + cls.add_method('SetEnergyModelCallback', + 'void', + [param('ns3::Callback< void, int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetMac(ns3::Ptr mac) [member function] + cls.add_method('SetMac', + 'void', + [param('ns3::Ptr< ns3::UanMac >', 'mac')], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetReceiveErrorCallback(ns3::Callback, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + cls.add_method('SetReceiveErrorCallback', + 'void', + [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetReceiveOkCallback(ns3::Callback, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + cls.add_method('SetReceiveOkCallback', + 'void', + [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetRxGainDb(double gain) [member function] + cls.add_method('SetRxGainDb', + 'void', + [param('double', 'gain')], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetRxThresholdDb(double thresh) [member function] + cls.add_method('SetRxThresholdDb', + 'void', + [param('double', 'thresh')], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetSleepMode(bool sleep) [member function] + cls.add_method('SetSleepMode', + 'void', + [param('bool', 'sleep')], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetTransducer(ns3::Ptr trans) [member function] + cls.add_method('SetTransducer', + 'void', + [param('ns3::Ptr< ns3::UanTransducer >', 'trans')], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetTxPowerDb(double txpwr) [member function] + cls.add_method('SetTxPowerDb', + 'void', + [param('double', 'txpwr')], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhy::StartRxPacket(ns3::Ptr pkt, double rxPowerDb, ns3::UanTxMode txMode, ns3::UanPdp pdp) [member function] + cls.add_method('StartRxPacket', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('double', 'rxPowerDb'), param('ns3::UanTxMode', 'txMode'), param('ns3::UanPdp', 'pdp')], + is_pure_virtual=True, is_virtual=True) + return + +def register_Ns3UanPhyCalcSinr_methods(root_module, cls): + ## uan-phy.h (module 'uan'): ns3::UanPhyCalcSinr::UanPhyCalcSinr() [constructor] + cls.add_constructor([]) + ## uan-phy.h (module 'uan'): ns3::UanPhyCalcSinr::UanPhyCalcSinr(ns3::UanPhyCalcSinr const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanPhyCalcSinr const &', 'arg0')]) + ## uan-phy.h (module 'uan'): double ns3::UanPhyCalcSinr::CalcSinrDb(ns3::Ptr pkt, ns3::Time arrTime, double rxPowerDb, double ambNoiseDb, ns3::UanTxMode mode, ns3::UanPdp pdp, std::list > const & arrivalList) const [member function] + cls.add_method('CalcSinrDb', + 'double', + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Time', 'arrTime'), param('double', 'rxPowerDb'), param('double', 'ambNoiseDb'), param('ns3::UanTxMode', 'mode'), param('ns3::UanPdp', 'pdp'), param('std::list< ns3::UanPacketArrival > const &', 'arrivalList')], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhyCalcSinr::Clear() [member function] + cls.add_method('Clear', + 'void', + [], + is_virtual=True) + ## uan-phy.h (module 'uan'): double ns3::UanPhyCalcSinr::DbToKp(double db) const [member function] + cls.add_method('DbToKp', + 'double', + [param('double', 'db')], + is_const=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhyCalcSinr::DoDispose() [member function] + cls.add_method('DoDispose', + 'void', + [], + is_virtual=True) + ## uan-phy.h (module 'uan'): static ns3::TypeId ns3::UanPhyCalcSinr::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## uan-phy.h (module 'uan'): double ns3::UanPhyCalcSinr::KpToDb(double kp) const [member function] + cls.add_method('KpToDb', + 'double', + [param('double', 'kp')], + is_const=True) + return + +def register_Ns3UanPhyCalcSinrDefault_methods(root_module, cls): + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyCalcSinrDefault::UanPhyCalcSinrDefault(ns3::UanPhyCalcSinrDefault const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanPhyCalcSinrDefault const &', 'arg0')]) + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyCalcSinrDefault::UanPhyCalcSinrDefault() [constructor] + cls.add_constructor([]) + ## uan-phy-gen.h (module 'uan'): double ns3::UanPhyCalcSinrDefault::CalcSinrDb(ns3::Ptr pkt, ns3::Time arrTime, double rxPowerDb, double ambNoiseDb, ns3::UanTxMode mode, ns3::UanPdp pdp, std::list > const & arrivalList) const [member function] + cls.add_method('CalcSinrDb', + 'double', + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Time', 'arrTime'), param('double', 'rxPowerDb'), param('double', 'ambNoiseDb'), param('ns3::UanTxMode', 'mode'), param('ns3::UanPdp', 'pdp'), param('std::list< ns3::UanPacketArrival > const &', 'arrivalList')], + is_const=True, is_virtual=True) + ## uan-phy-gen.h (module 'uan'): static ns3::TypeId ns3::UanPhyCalcSinrDefault::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + return + +def register_Ns3UanPhyCalcSinrDual_methods(root_module, cls): + ## uan-phy-dual.h (module 'uan'): ns3::UanPhyCalcSinrDual::UanPhyCalcSinrDual(ns3::UanPhyCalcSinrDual const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanPhyCalcSinrDual const &', 'arg0')]) + ## uan-phy-dual.h (module 'uan'): ns3::UanPhyCalcSinrDual::UanPhyCalcSinrDual() [constructor] + cls.add_constructor([]) + ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyCalcSinrDual::CalcSinrDb(ns3::Ptr pkt, ns3::Time arrTime, double rxPowerDb, double ambNoiseDb, ns3::UanTxMode mode, ns3::UanPdp pdp, std::list > const & arrivalList) const [member function] + cls.add_method('CalcSinrDb', + 'double', + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Time', 'arrTime'), param('double', 'rxPowerDb'), param('double', 'ambNoiseDb'), param('ns3::UanTxMode', 'mode'), param('ns3::UanPdp', 'pdp'), param('std::list< ns3::UanPacketArrival > const &', 'arrivalList')], + is_const=True, is_virtual=True) + ## uan-phy-dual.h (module 'uan'): static ns3::TypeId ns3::UanPhyCalcSinrDual::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + return + +def register_Ns3UanPhyCalcSinrFhFsk_methods(root_module, cls): + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyCalcSinrFhFsk::UanPhyCalcSinrFhFsk(ns3::UanPhyCalcSinrFhFsk const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanPhyCalcSinrFhFsk const &', 'arg0')]) + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyCalcSinrFhFsk::UanPhyCalcSinrFhFsk() [constructor] + cls.add_constructor([]) + ## uan-phy-gen.h (module 'uan'): double ns3::UanPhyCalcSinrFhFsk::CalcSinrDb(ns3::Ptr pkt, ns3::Time arrTime, double rxPowerDb, double ambNoiseDb, ns3::UanTxMode mode, ns3::UanPdp pdp, std::list > const & arrivalList) const [member function] + cls.add_method('CalcSinrDb', + 'double', + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Time', 'arrTime'), param('double', 'rxPowerDb'), param('double', 'ambNoiseDb'), param('ns3::UanTxMode', 'mode'), param('ns3::UanPdp', 'pdp'), param('std::list< ns3::UanPacketArrival > const &', 'arrivalList')], + is_const=True, is_virtual=True) + ## uan-phy-gen.h (module 'uan'): static ns3::TypeId ns3::UanPhyCalcSinrFhFsk::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + return + +def register_Ns3UanPhyDual_methods(root_module, cls): + ## uan-phy-dual.h (module 'uan'): ns3::UanPhyDual::UanPhyDual(ns3::UanPhyDual const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanPhyDual const &', 'arg0')]) + ## uan-phy-dual.h (module 'uan'): ns3::UanPhyDual::UanPhyDual() [constructor] + cls.add_constructor([]) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::Clear() [member function] + cls.add_method('Clear', + 'void', + [], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::EnergyDepletionHandler() [member function] + cls.add_method('EnergyDepletionHandler', + 'void', + [], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyDual::GetCcaThresholdDb() [member function] + cls.add_method('GetCcaThresholdDb', + 'double', + [], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyDual::GetCcaThresholdPhy1() const [member function] + cls.add_method('GetCcaThresholdPhy1', + 'double', + [], + is_const=True) + ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyDual::GetCcaThresholdPhy2() const [member function] + cls.add_method('GetCcaThresholdPhy2', + 'double', + [], + is_const=True) + ## uan-phy-dual.h (module 'uan'): ns3::Ptr ns3::UanPhyDual::GetChannel() const [member function] + cls.add_method('GetChannel', + 'ns3::Ptr< ns3::UanChannel >', + [], + is_const=True, is_virtual=True) + ## uan-phy-dual.h (module 'uan'): ns3::Ptr ns3::UanPhyDual::GetDevice() [member function] + cls.add_method('GetDevice', + 'ns3::Ptr< ns3::UanNetDevice >', + [], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): ns3::UanTxMode ns3::UanPhyDual::GetMode(uint32_t n) [member function] + cls.add_method('GetMode', + 'ns3::UanTxMode', + [param('uint32_t', 'n')], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): ns3::UanModesList ns3::UanPhyDual::GetModesPhy1() const [member function] + cls.add_method('GetModesPhy1', + 'ns3::UanModesList', + [], + is_const=True) + ## uan-phy-dual.h (module 'uan'): ns3::UanModesList ns3::UanPhyDual::GetModesPhy2() const [member function] + cls.add_method('GetModesPhy2', + 'ns3::UanModesList', + [], + is_const=True) + ## uan-phy-dual.h (module 'uan'): uint32_t ns3::UanPhyDual::GetNModes() [member function] + cls.add_method('GetNModes', + 'uint32_t', + [], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): ns3::Ptr ns3::UanPhyDual::GetPacketRx() const [member function] + cls.add_method('GetPacketRx', + 'ns3::Ptr< ns3::Packet >', + [], + is_const=True, is_virtual=True) + ## uan-phy-dual.h (module 'uan'): ns3::Ptr ns3::UanPhyDual::GetPerModelPhy1() const [member function] + cls.add_method('GetPerModelPhy1', + 'ns3::Ptr< ns3::UanPhyPer >', + [], + is_const=True) + ## uan-phy-dual.h (module 'uan'): ns3::Ptr ns3::UanPhyDual::GetPerModelPhy2() const [member function] + cls.add_method('GetPerModelPhy2', + 'ns3::Ptr< ns3::UanPhyPer >', + [], + is_const=True) + ## uan-phy-dual.h (module 'uan'): ns3::Ptr ns3::UanPhyDual::GetPhy1PacketRx() const [member function] + cls.add_method('GetPhy1PacketRx', + 'ns3::Ptr< ns3::Packet >', + [], + is_const=True) + ## uan-phy-dual.h (module 'uan'): ns3::Ptr ns3::UanPhyDual::GetPhy2PacketRx() const [member function] + cls.add_method('GetPhy2PacketRx', + 'ns3::Ptr< ns3::Packet >', + [], + is_const=True) + ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyDual::GetRxGainDb() [member function] + cls.add_method('GetRxGainDb', + 'double', + [], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyDual::GetRxGainDbPhy1() const [member function] + cls.add_method('GetRxGainDbPhy1', + 'double', + [], + is_const=True) + ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyDual::GetRxGainDbPhy2() const [member function] + cls.add_method('GetRxGainDbPhy2', + 'double', + [], + is_const=True) + ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyDual::GetRxThresholdDb() [member function] + cls.add_method('GetRxThresholdDb', + 'double', + [], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): ns3::Ptr ns3::UanPhyDual::GetSinrModelPhy1() const [member function] + cls.add_method('GetSinrModelPhy1', + 'ns3::Ptr< ns3::UanPhyCalcSinr >', + [], + is_const=True) + ## uan-phy-dual.h (module 'uan'): ns3::Ptr ns3::UanPhyDual::GetSinrModelPhy2() const [member function] + cls.add_method('GetSinrModelPhy2', + 'ns3::Ptr< ns3::UanPhyCalcSinr >', + [], + is_const=True) + ## uan-phy-dual.h (module 'uan'): ns3::Ptr ns3::UanPhyDual::GetTransducer() [member function] + cls.add_method('GetTransducer', + 'ns3::Ptr< ns3::UanTransducer >', + [], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyDual::GetTxPowerDb() [member function] + cls.add_method('GetTxPowerDb', + 'double', + [], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyDual::GetTxPowerDbPhy1() const [member function] + cls.add_method('GetTxPowerDbPhy1', + 'double', + [], + is_const=True) + ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyDual::GetTxPowerDbPhy2() const [member function] + cls.add_method('GetTxPowerDbPhy2', + 'double', + [], + is_const=True) + ## uan-phy-dual.h (module 'uan'): static ns3::TypeId ns3::UanPhyDual::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## uan-phy-dual.h (module 'uan'): bool ns3::UanPhyDual::IsPhy1Idle() [member function] + cls.add_method('IsPhy1Idle', + 'bool', + []) + ## uan-phy-dual.h (module 'uan'): bool ns3::UanPhyDual::IsPhy1Rx() [member function] + cls.add_method('IsPhy1Rx', + 'bool', + []) + ## uan-phy-dual.h (module 'uan'): bool ns3::UanPhyDual::IsPhy1Tx() [member function] + cls.add_method('IsPhy1Tx', + 'bool', + []) + ## uan-phy-dual.h (module 'uan'): bool ns3::UanPhyDual::IsPhy2Idle() [member function] + cls.add_method('IsPhy2Idle', + 'bool', + []) + ## uan-phy-dual.h (module 'uan'): bool ns3::UanPhyDual::IsPhy2Rx() [member function] + cls.add_method('IsPhy2Rx', + 'bool', + []) + ## uan-phy-dual.h (module 'uan'): bool ns3::UanPhyDual::IsPhy2Tx() [member function] + cls.add_method('IsPhy2Tx', + 'bool', + []) + ## uan-phy-dual.h (module 'uan'): bool ns3::UanPhyDual::IsStateBusy() [member function] + cls.add_method('IsStateBusy', + 'bool', + [], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): bool ns3::UanPhyDual::IsStateCcaBusy() [member function] + cls.add_method('IsStateCcaBusy', + 'bool', + [], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): bool ns3::UanPhyDual::IsStateIdle() [member function] + cls.add_method('IsStateIdle', + 'bool', + [], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): bool ns3::UanPhyDual::IsStateRx() [member function] + cls.add_method('IsStateRx', + 'bool', + [], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): bool ns3::UanPhyDual::IsStateSleep() [member function] + cls.add_method('IsStateSleep', + 'bool', + [], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): bool ns3::UanPhyDual::IsStateTx() [member function] + cls.add_method('IsStateTx', + 'bool', + [], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::NotifyIntChange() [member function] + cls.add_method('NotifyIntChange', + 'void', + [], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::NotifyTransStartTx(ns3::Ptr packet, double txPowerDb, ns3::UanTxMode txMode) [member function] + cls.add_method('NotifyTransStartTx', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'packet'), param('double', 'txPowerDb'), param('ns3::UanTxMode', 'txMode')], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::RegisterListener(ns3::UanPhyListener * listener) [member function] + cls.add_method('RegisterListener', + 'void', + [param('ns3::UanPhyListener *', 'listener')], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SendPacket(ns3::Ptr pkt, uint32_t modeNum) [member function] + cls.add_method('SendPacket', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('uint32_t', 'modeNum')], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetCcaThresholdDb(double thresh) [member function] + cls.add_method('SetCcaThresholdDb', + 'void', + [param('double', 'thresh')], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetCcaThresholdPhy1(double thresh) [member function] + cls.add_method('SetCcaThresholdPhy1', + 'void', + [param('double', 'thresh')]) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetCcaThresholdPhy2(double thresh) [member function] + cls.add_method('SetCcaThresholdPhy2', + 'void', + [param('double', 'thresh')]) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetChannel(ns3::Ptr channel) [member function] + cls.add_method('SetChannel', + 'void', + [param('ns3::Ptr< ns3::UanChannel >', 'channel')], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetDevice(ns3::Ptr device) [member function] + cls.add_method('SetDevice', + 'void', + [param('ns3::Ptr< ns3::UanNetDevice >', 'device')], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetEnergyModelCallback(ns3::Callback callback) [member function] + cls.add_method('SetEnergyModelCallback', + 'void', + [param('ns3::Callback< void, int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetMac(ns3::Ptr mac) [member function] + cls.add_method('SetMac', + 'void', + [param('ns3::Ptr< ns3::UanMac >', 'mac')], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetModesPhy1(ns3::UanModesList modes) [member function] + cls.add_method('SetModesPhy1', + 'void', + [param('ns3::UanModesList', 'modes')]) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetModesPhy2(ns3::UanModesList modes) [member function] + cls.add_method('SetModesPhy2', + 'void', + [param('ns3::UanModesList', 'modes')]) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetPerModelPhy1(ns3::Ptr per) [member function] + cls.add_method('SetPerModelPhy1', + 'void', + [param('ns3::Ptr< ns3::UanPhyPer >', 'per')]) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetPerModelPhy2(ns3::Ptr per) [member function] + cls.add_method('SetPerModelPhy2', + 'void', + [param('ns3::Ptr< ns3::UanPhyPer >', 'per')]) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetReceiveErrorCallback(ns3::Callback, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + cls.add_method('SetReceiveErrorCallback', + 'void', + [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetReceiveOkCallback(ns3::Callback, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + cls.add_method('SetReceiveOkCallback', + 'void', + [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetRxGainDb(double gain) [member function] + cls.add_method('SetRxGainDb', + 'void', + [param('double', 'gain')], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetRxGainDbPhy1(double gain) [member function] + cls.add_method('SetRxGainDbPhy1', + 'void', + [param('double', 'gain')]) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetRxGainDbPhy2(double gain) [member function] + cls.add_method('SetRxGainDbPhy2', + 'void', + [param('double', 'gain')]) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetRxThresholdDb(double thresh) [member function] + cls.add_method('SetRxThresholdDb', + 'void', + [param('double', 'thresh')], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetSinrModelPhy1(ns3::Ptr calcSinr) [member function] + cls.add_method('SetSinrModelPhy1', + 'void', + [param('ns3::Ptr< ns3::UanPhyCalcSinr >', 'calcSinr')]) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetSinrModelPhy2(ns3::Ptr calcSinr) [member function] + cls.add_method('SetSinrModelPhy2', + 'void', + [param('ns3::Ptr< ns3::UanPhyCalcSinr >', 'calcSinr')]) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetSleepMode(bool sleep) [member function] + cls.add_method('SetSleepMode', + 'void', + [param('bool', 'sleep')], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetTransducer(ns3::Ptr trans) [member function] + cls.add_method('SetTransducer', + 'void', + [param('ns3::Ptr< ns3::UanTransducer >', 'trans')], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetTxPowerDb(double txpwr) [member function] + cls.add_method('SetTxPowerDb', + 'void', + [param('double', 'txpwr')], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetTxPowerDbPhy1(double arg0) [member function] + cls.add_method('SetTxPowerDbPhy1', + 'void', + [param('double', 'arg0')]) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetTxPowerDbPhy2(double arg0) [member function] + cls.add_method('SetTxPowerDbPhy2', + 'void', + [param('double', 'arg0')]) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::StartRxPacket(ns3::Ptr pkt, double rxPowerDb, ns3::UanTxMode txMode, ns3::UanPdp pdp) [member function] + cls.add_method('StartRxPacket', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('double', 'rxPowerDb'), param('ns3::UanTxMode', 'txMode'), param('ns3::UanPdp', 'pdp')], + is_virtual=True) + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::DoDispose() [member function] + cls.add_method('DoDispose', + 'void', + [], + visibility='protected', is_virtual=True) + return + +def register_Ns3UanPhyGen_methods(root_module, cls): + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyGen::UanPhyGen(ns3::UanPhyGen const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanPhyGen const &', 'arg0')]) + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyGen::UanPhyGen() [constructor] + cls.add_constructor([]) + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::Clear() [member function] + cls.add_method('Clear', + 'void', + [], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::EnergyDepletionHandler() [member function] + cls.add_method('EnergyDepletionHandler', + 'void', + [], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): double ns3::UanPhyGen::GetCcaThresholdDb() [member function] + cls.add_method('GetCcaThresholdDb', + 'double', + [], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): ns3::Ptr ns3::UanPhyGen::GetChannel() const [member function] + cls.add_method('GetChannel', + 'ns3::Ptr< ns3::UanChannel >', + [], + is_const=True, is_virtual=True) + ## uan-phy-gen.h (module 'uan'): static ns3::UanModesList ns3::UanPhyGen::GetDefaultModes() [member function] + cls.add_method('GetDefaultModes', + 'ns3::UanModesList', + [], + is_static=True) + ## uan-phy-gen.h (module 'uan'): ns3::Ptr ns3::UanPhyGen::GetDevice() [member function] + cls.add_method('GetDevice', + 'ns3::Ptr< ns3::UanNetDevice >', + [], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): ns3::UanTxMode ns3::UanPhyGen::GetMode(uint32_t n) [member function] + cls.add_method('GetMode', + 'ns3::UanTxMode', + [param('uint32_t', 'n')], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): uint32_t ns3::UanPhyGen::GetNModes() [member function] + cls.add_method('GetNModes', + 'uint32_t', + [], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): ns3::Ptr ns3::UanPhyGen::GetPacketRx() const [member function] + cls.add_method('GetPacketRx', + 'ns3::Ptr< ns3::Packet >', + [], + is_const=True, is_virtual=True) + ## uan-phy-gen.h (module 'uan'): double ns3::UanPhyGen::GetRxGainDb() [member function] + cls.add_method('GetRxGainDb', + 'double', + [], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): double ns3::UanPhyGen::GetRxThresholdDb() [member function] + cls.add_method('GetRxThresholdDb', + 'double', + [], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): ns3::Ptr ns3::UanPhyGen::GetTransducer() [member function] + cls.add_method('GetTransducer', + 'ns3::Ptr< ns3::UanTransducer >', + [], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): double ns3::UanPhyGen::GetTxPowerDb() [member function] + cls.add_method('GetTxPowerDb', + 'double', + [], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): static ns3::TypeId ns3::UanPhyGen::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## uan-phy-gen.h (module 'uan'): bool ns3::UanPhyGen::IsStateBusy() [member function] + cls.add_method('IsStateBusy', + 'bool', + [], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): bool ns3::UanPhyGen::IsStateCcaBusy() [member function] + cls.add_method('IsStateCcaBusy', + 'bool', + [], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): bool ns3::UanPhyGen::IsStateIdle() [member function] + cls.add_method('IsStateIdle', + 'bool', + [], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): bool ns3::UanPhyGen::IsStateRx() [member function] + cls.add_method('IsStateRx', + 'bool', + [], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): bool ns3::UanPhyGen::IsStateSleep() [member function] + cls.add_method('IsStateSleep', + 'bool', + [], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): bool ns3::UanPhyGen::IsStateTx() [member function] + cls.add_method('IsStateTx', + 'bool', + [], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::NotifyIntChange() [member function] + cls.add_method('NotifyIntChange', + 'void', + [], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::NotifyTransStartTx(ns3::Ptr packet, double txPowerDb, ns3::UanTxMode txMode) [member function] + cls.add_method('NotifyTransStartTx', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'packet'), param('double', 'txPowerDb'), param('ns3::UanTxMode', 'txMode')], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::RegisterListener(ns3::UanPhyListener * listener) [member function] + cls.add_method('RegisterListener', + 'void', + [param('ns3::UanPhyListener *', 'listener')], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SendPacket(ns3::Ptr pkt, uint32_t modeNum) [member function] + cls.add_method('SendPacket', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('uint32_t', 'modeNum')], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetCcaThresholdDb(double thresh) [member function] + cls.add_method('SetCcaThresholdDb', + 'void', + [param('double', 'thresh')], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetChannel(ns3::Ptr channel) [member function] + cls.add_method('SetChannel', + 'void', + [param('ns3::Ptr< ns3::UanChannel >', 'channel')], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetDevice(ns3::Ptr device) [member function] + cls.add_method('SetDevice', + 'void', + [param('ns3::Ptr< ns3::UanNetDevice >', 'device')], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetEnergyModelCallback(ns3::Callback cb) [member function] + cls.add_method('SetEnergyModelCallback', + 'void', + [param('ns3::Callback< void, int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetMac(ns3::Ptr mac) [member function] + cls.add_method('SetMac', + 'void', + [param('ns3::Ptr< ns3::UanMac >', 'mac')], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetReceiveErrorCallback(ns3::Callback, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + cls.add_method('SetReceiveErrorCallback', + 'void', + [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetReceiveOkCallback(ns3::Callback, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + cls.add_method('SetReceiveOkCallback', + 'void', + [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetRxGainDb(double gain) [member function] + cls.add_method('SetRxGainDb', + 'void', + [param('double', 'gain')], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetRxThresholdDb(double thresh) [member function] + cls.add_method('SetRxThresholdDb', + 'void', + [param('double', 'thresh')], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetSleepMode(bool sleep) [member function] + cls.add_method('SetSleepMode', + 'void', + [param('bool', 'sleep')], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetTransducer(ns3::Ptr trans) [member function] + cls.add_method('SetTransducer', + 'void', + [param('ns3::Ptr< ns3::UanTransducer >', 'trans')], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetTxPowerDb(double txpwr) [member function] + cls.add_method('SetTxPowerDb', + 'void', + [param('double', 'txpwr')], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::StartRxPacket(ns3::Ptr pkt, double rxPowerDb, ns3::UanTxMode txMode, ns3::UanPdp pdp) [member function] + cls.add_method('StartRxPacket', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('double', 'rxPowerDb'), param('ns3::UanTxMode', 'txMode'), param('ns3::UanPdp', 'pdp')], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::DoDispose() [member function] + cls.add_method('DoDispose', + 'void', + [], + visibility='protected', is_virtual=True) + return + +def register_Ns3UanPhyPer_methods(root_module, cls): + ## uan-phy.h (module 'uan'): ns3::UanPhyPer::UanPhyPer() [constructor] + cls.add_constructor([]) + ## uan-phy.h (module 'uan'): ns3::UanPhyPer::UanPhyPer(ns3::UanPhyPer const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanPhyPer const &', 'arg0')]) + ## uan-phy.h (module 'uan'): double ns3::UanPhyPer::CalcPer(ns3::Ptr pkt, double sinrDb, ns3::UanTxMode mode) [member function] + cls.add_method('CalcPer', + 'double', + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('double', 'sinrDb'), param('ns3::UanTxMode', 'mode')], + is_pure_virtual=True, is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhyPer::Clear() [member function] + cls.add_method('Clear', + 'void', + [], + is_virtual=True) + ## uan-phy.h (module 'uan'): void ns3::UanPhyPer::DoDispose() [member function] + cls.add_method('DoDispose', + 'void', + [], + is_virtual=True) + ## uan-phy.h (module 'uan'): static ns3::TypeId ns3::UanPhyPer::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + return + +def register_Ns3UanPhyPerGenDefault_methods(root_module, cls): + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerGenDefault::UanPhyPerGenDefault(ns3::UanPhyPerGenDefault const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanPhyPerGenDefault const &', 'arg0')]) + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerGenDefault::UanPhyPerGenDefault() [constructor] + cls.add_constructor([]) + ## uan-phy-gen.h (module 'uan'): double ns3::UanPhyPerGenDefault::CalcPer(ns3::Ptr pkt, double sinrDb, ns3::UanTxMode mode) [member function] + cls.add_method('CalcPer', + 'double', + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('double', 'sinrDb'), param('ns3::UanTxMode', 'mode')], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): static ns3::TypeId ns3::UanPhyPerGenDefault::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + return + +def register_Ns3UanPhyPerUmodem_methods(root_module, cls): + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerUmodem::UanPhyPerUmodem(ns3::UanPhyPerUmodem const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanPhyPerUmodem const &', 'arg0')]) + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerUmodem::UanPhyPerUmodem() [constructor] + cls.add_constructor([]) + ## uan-phy-gen.h (module 'uan'): double ns3::UanPhyPerUmodem::CalcPer(ns3::Ptr pkt, double sinrDb, ns3::UanTxMode mode) [member function] + cls.add_method('CalcPer', + 'double', + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('double', 'sinrDb'), param('ns3::UanTxMode', 'mode')], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): static ns3::TypeId ns3::UanPhyPerUmodem::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + return + +def register_Ns3UanPropModel_methods(root_module, cls): + ## uan-prop-model.h (module 'uan'): ns3::UanPropModel::UanPropModel() [constructor] + cls.add_constructor([]) + ## uan-prop-model.h (module 'uan'): ns3::UanPropModel::UanPropModel(ns3::UanPropModel const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanPropModel const &', 'arg0')]) + ## uan-prop-model.h (module 'uan'): void ns3::UanPropModel::Clear() [member function] + cls.add_method('Clear', + 'void', + [], + is_virtual=True) + ## uan-prop-model.h (module 'uan'): void ns3::UanPropModel::DoDispose() [member function] + cls.add_method('DoDispose', + 'void', + [], + is_virtual=True) + ## uan-prop-model.h (module 'uan'): ns3::Time ns3::UanPropModel::GetDelay(ns3::Ptr a, ns3::Ptr b, ns3::UanTxMode mode) [member function] + cls.add_method('GetDelay', + 'ns3::Time', + [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b'), param('ns3::UanTxMode', 'mode')], + is_pure_virtual=True, is_virtual=True) + ## uan-prop-model.h (module 'uan'): double ns3::UanPropModel::GetPathLossDb(ns3::Ptr a, ns3::Ptr b, ns3::UanTxMode txMode) [member function] + cls.add_method('GetPathLossDb', + 'double', + [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b'), param('ns3::UanTxMode', 'txMode')], + is_pure_virtual=True, is_virtual=True) + ## uan-prop-model.h (module 'uan'): ns3::UanPdp ns3::UanPropModel::GetPdp(ns3::Ptr a, ns3::Ptr b, ns3::UanTxMode mode) [member function] + cls.add_method('GetPdp', + 'ns3::UanPdp', + [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b'), param('ns3::UanTxMode', 'mode')], + is_pure_virtual=True, is_virtual=True) + ## uan-prop-model.h (module 'uan'): static ns3::TypeId ns3::UanPropModel::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + return + +def register_Ns3UanPropModelIdeal_methods(root_module, cls): + ## uan-prop-model-ideal.h (module 'uan'): ns3::UanPropModelIdeal::UanPropModelIdeal(ns3::UanPropModelIdeal const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanPropModelIdeal const &', 'arg0')]) + ## uan-prop-model-ideal.h (module 'uan'): ns3::UanPropModelIdeal::UanPropModelIdeal() [constructor] + cls.add_constructor([]) + ## uan-prop-model-ideal.h (module 'uan'): ns3::Time ns3::UanPropModelIdeal::GetDelay(ns3::Ptr a, ns3::Ptr b, ns3::UanTxMode mode) [member function] + cls.add_method('GetDelay', + 'ns3::Time', + [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b'), param('ns3::UanTxMode', 'mode')], + is_virtual=True) + ## uan-prop-model-ideal.h (module 'uan'): double ns3::UanPropModelIdeal::GetPathLossDb(ns3::Ptr a, ns3::Ptr b, ns3::UanTxMode mode) [member function] + cls.add_method('GetPathLossDb', + 'double', + [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b'), param('ns3::UanTxMode', 'mode')], + is_virtual=True) + ## uan-prop-model-ideal.h (module 'uan'): ns3::UanPdp ns3::UanPropModelIdeal::GetPdp(ns3::Ptr a, ns3::Ptr b, ns3::UanTxMode mode) [member function] + cls.add_method('GetPdp', + 'ns3::UanPdp', + [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b'), param('ns3::UanTxMode', 'mode')], + is_virtual=True) + ## uan-prop-model-ideal.h (module 'uan'): static ns3::TypeId ns3::UanPropModelIdeal::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + return + +def register_Ns3UanPropModelThorp_methods(root_module, cls): + ## uan-prop-model-thorp.h (module 'uan'): ns3::UanPropModelThorp::UanPropModelThorp(ns3::UanPropModelThorp const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanPropModelThorp const &', 'arg0')]) + ## uan-prop-model-thorp.h (module 'uan'): ns3::UanPropModelThorp::UanPropModelThorp() [constructor] + cls.add_constructor([]) + ## uan-prop-model-thorp.h (module 'uan'): ns3::Time ns3::UanPropModelThorp::GetDelay(ns3::Ptr a, ns3::Ptr b, ns3::UanTxMode mode) [member function] + cls.add_method('GetDelay', + 'ns3::Time', + [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b'), param('ns3::UanTxMode', 'mode')], + is_virtual=True) + ## uan-prop-model-thorp.h (module 'uan'): double ns3::UanPropModelThorp::GetPathLossDb(ns3::Ptr a, ns3::Ptr b, ns3::UanTxMode mode) [member function] + cls.add_method('GetPathLossDb', + 'double', + [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b'), param('ns3::UanTxMode', 'mode')], + is_virtual=True) + ## uan-prop-model-thorp.h (module 'uan'): ns3::UanPdp ns3::UanPropModelThorp::GetPdp(ns3::Ptr a, ns3::Ptr b, ns3::UanTxMode mode) [member function] + cls.add_method('GetPdp', + 'ns3::UanPdp', + [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b'), param('ns3::UanTxMode', 'mode')], + is_virtual=True) + ## uan-prop-model-thorp.h (module 'uan'): static ns3::TypeId ns3::UanPropModelThorp::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + return + +def register_Ns3UanTransducer_methods(root_module, cls): + ## uan-transducer.h (module 'uan'): ns3::UanTransducer::UanTransducer() [constructor] + cls.add_constructor([]) + ## uan-transducer.h (module 'uan'): ns3::UanTransducer::UanTransducer(ns3::UanTransducer const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanTransducer const &', 'arg0')]) + ## uan-transducer.h (module 'uan'): void ns3::UanTransducer::AddPhy(ns3::Ptr phy) [member function] + cls.add_method('AddPhy', + 'void', + [param('ns3::Ptr< ns3::UanPhy >', 'phy')], + is_pure_virtual=True, is_virtual=True) + ## uan-transducer.h (module 'uan'): void ns3::UanTransducer::Clear() [member function] + cls.add_method('Clear', + 'void', + [], + is_pure_virtual=True, is_virtual=True) + ## uan-transducer.h (module 'uan'): std::list > const & ns3::UanTransducer::GetArrivalList() const [member function] + cls.add_method('GetArrivalList', + 'std::list< ns3::UanPacketArrival > const &', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## uan-transducer.h (module 'uan'): ns3::Ptr ns3::UanTransducer::GetChannel() const [member function] + cls.add_method('GetChannel', + 'ns3::Ptr< ns3::UanChannel >', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## uan-transducer.h (module 'uan'): std::list, std::allocator > > const & ns3::UanTransducer::GetPhyList() const [member function] + cls.add_method('GetPhyList', + 'std::list< ns3::Ptr< ns3::UanPhy > > const &', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## uan-transducer.h (module 'uan'): ns3::UanTransducer::State ns3::UanTransducer::GetState() const [member function] + cls.add_method('GetState', + 'ns3::UanTransducer::State', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## uan-transducer.h (module 'uan'): static ns3::TypeId ns3::UanTransducer::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## uan-transducer.h (module 'uan'): bool ns3::UanTransducer::IsRx() const [member function] + cls.add_method('IsRx', + 'bool', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## uan-transducer.h (module 'uan'): bool ns3::UanTransducer::IsTx() const [member function] + cls.add_method('IsTx', + 'bool', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## uan-transducer.h (module 'uan'): void ns3::UanTransducer::Receive(ns3::Ptr packet, double rxPowerDb, ns3::UanTxMode txMode, ns3::UanPdp pdp) [member function] + cls.add_method('Receive', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'packet'), param('double', 'rxPowerDb'), param('ns3::UanTxMode', 'txMode'), param('ns3::UanPdp', 'pdp')], + is_pure_virtual=True, is_virtual=True) + ## uan-transducer.h (module 'uan'): void ns3::UanTransducer::SetChannel(ns3::Ptr chan) [member function] + cls.add_method('SetChannel', + 'void', + [param('ns3::Ptr< ns3::UanChannel >', 'chan')], + is_pure_virtual=True, is_virtual=True) + ## uan-transducer.h (module 'uan'): void ns3::UanTransducer::Transmit(ns3::Ptr src, ns3::Ptr packet, double txPowerDb, ns3::UanTxMode txMode) [member function] + cls.add_method('Transmit', + 'void', + [param('ns3::Ptr< ns3::UanPhy >', 'src'), param('ns3::Ptr< ns3::Packet >', 'packet'), param('double', 'txPowerDb'), param('ns3::UanTxMode', 'txMode')], + is_pure_virtual=True, is_virtual=True) + return + +def register_Ns3UanTransducerHd_methods(root_module, cls): + ## uan-transducer-hd.h (module 'uan'): ns3::UanTransducerHd::UanTransducerHd(ns3::UanTransducerHd const & arg0) [copy constructor] + cls.add_constructor([param('ns3::UanTransducerHd const &', 'arg0')]) + ## uan-transducer-hd.h (module 'uan'): ns3::UanTransducerHd::UanTransducerHd() [constructor] + cls.add_constructor([]) + ## uan-transducer-hd.h (module 'uan'): void ns3::UanTransducerHd::AddPhy(ns3::Ptr arg0) [member function] + cls.add_method('AddPhy', + 'void', + [param('ns3::Ptr< ns3::UanPhy >', 'arg0')], + is_virtual=True) + ## uan-transducer-hd.h (module 'uan'): void ns3::UanTransducerHd::Clear() [member function] + cls.add_method('Clear', + 'void', + [], + is_virtual=True) + ## uan-transducer-hd.h (module 'uan'): std::list > const & ns3::UanTransducerHd::GetArrivalList() const [member function] + cls.add_method('GetArrivalList', + 'std::list< ns3::UanPacketArrival > const &', + [], + is_const=True, is_virtual=True) + ## uan-transducer-hd.h (module 'uan'): ns3::Ptr ns3::UanTransducerHd::GetChannel() const [member function] + cls.add_method('GetChannel', + 'ns3::Ptr< ns3::UanChannel >', + [], + is_const=True, is_virtual=True) + ## uan-transducer-hd.h (module 'uan'): std::list, std::allocator > > const & ns3::UanTransducerHd::GetPhyList() const [member function] + cls.add_method('GetPhyList', + 'std::list< ns3::Ptr< ns3::UanPhy > > const &', + [], + is_const=True, is_virtual=True) + ## uan-transducer-hd.h (module 'uan'): ns3::UanTransducer::State ns3::UanTransducerHd::GetState() const [member function] + cls.add_method('GetState', + 'ns3::UanTransducer::State', + [], + is_const=True, is_virtual=True) + ## uan-transducer-hd.h (module 'uan'): static ns3::TypeId ns3::UanTransducerHd::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## uan-transducer-hd.h (module 'uan'): bool ns3::UanTransducerHd::IsRx() const [member function] + cls.add_method('IsRx', + 'bool', + [], + is_const=True, is_virtual=True) + ## uan-transducer-hd.h (module 'uan'): bool ns3::UanTransducerHd::IsTx() const [member function] + cls.add_method('IsTx', + 'bool', + [], + is_const=True, is_virtual=True) + ## uan-transducer-hd.h (module 'uan'): void ns3::UanTransducerHd::Receive(ns3::Ptr packet, double rxPowerDb, ns3::UanTxMode txMode, ns3::UanPdp pdp) [member function] + cls.add_method('Receive', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'packet'), param('double', 'rxPowerDb'), param('ns3::UanTxMode', 'txMode'), param('ns3::UanPdp', 'pdp')], + is_virtual=True) + ## uan-transducer-hd.h (module 'uan'): void ns3::UanTransducerHd::SetChannel(ns3::Ptr chan) [member function] + cls.add_method('SetChannel', + 'void', + [param('ns3::Ptr< ns3::UanChannel >', 'chan')], + is_virtual=True) + ## uan-transducer-hd.h (module 'uan'): void ns3::UanTransducerHd::Transmit(ns3::Ptr src, ns3::Ptr packet, double txPowerDb, ns3::UanTxMode txMode) [member function] + cls.add_method('Transmit', + 'void', + [param('ns3::Ptr< ns3::UanPhy >', 'src'), param('ns3::Ptr< ns3::Packet >', 'packet'), param('double', 'txPowerDb'), param('ns3::UanTxMode', 'txMode')], + is_virtual=True) + ## uan-transducer-hd.h (module 'uan'): void ns3::UanTransducerHd::DoDispose() [member function] + cls.add_method('DoDispose', + 'void', + [], + visibility='protected', is_virtual=True) + return + +def register_Ns3AttributeAccessor_methods(root_module, cls): + ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [copy constructor] + cls.add_constructor([param('ns3::AttributeAccessor const &', 'arg0')]) + ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor() [constructor] + cls.add_constructor([]) + ## attribute.h (module 'core'): bool ns3::AttributeAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & attribute) const [member function] + cls.add_method('Get', + 'bool', + [param('ns3::ObjectBase const *', 'object'), param('ns3::AttributeValue &', 'attribute')], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## attribute.h (module 'core'): bool ns3::AttributeAccessor::HasGetter() const [member function] + cls.add_method('HasGetter', + 'bool', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## attribute.h (module 'core'): bool ns3::AttributeAccessor::HasSetter() const [member function] + cls.add_method('HasSetter', + 'bool', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## attribute.h (module 'core'): bool ns3::AttributeAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function] + cls.add_method('Set', + 'bool', + [param('ns3::ObjectBase *', 'object', transfer_ownership=False), param('ns3::AttributeValue const &', 'value')], + is_pure_virtual=True, is_const=True, is_virtual=True) + return + +def register_Ns3AttributeChecker_methods(root_module, cls): + ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [copy constructor] + cls.add_constructor([param('ns3::AttributeChecker const &', 'arg0')]) + ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker() [constructor] + cls.add_constructor([]) + ## attribute.h (module 'core'): bool ns3::AttributeChecker::Check(ns3::AttributeValue const & value) const [member function] + cls.add_method('Check', + 'bool', + [param('ns3::AttributeValue const &', 'value')], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## attribute.h (module 'core'): bool ns3::AttributeChecker::Copy(ns3::AttributeValue const & source, ns3::AttributeValue & destination) const [member function] + cls.add_method('Copy', + 'bool', + [param('ns3::AttributeValue const &', 'source'), param('ns3::AttributeValue &', 'destination')], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## attribute.h (module 'core'): ns3::Ptr ns3::AttributeChecker::Create() const [member function] + cls.add_method('Create', + 'ns3::Ptr< ns3::AttributeValue >', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## attribute.h (module 'core'): ns3::Ptr ns3::AttributeChecker::CreateValidValue(ns3::AttributeValue const & value) const [member function] + cls.add_method('CreateValidValue', + 'ns3::Ptr< ns3::AttributeValue >', + [param('ns3::AttributeValue const &', 'value')], + is_const=True) + ## attribute.h (module 'core'): std::string ns3::AttributeChecker::GetUnderlyingTypeInformation() const [member function] + cls.add_method('GetUnderlyingTypeInformation', + 'std::string', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## attribute.h (module 'core'): std::string ns3::AttributeChecker::GetValueTypeName() const [member function] + cls.add_method('GetValueTypeName', + 'std::string', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## attribute.h (module 'core'): bool ns3::AttributeChecker::HasUnderlyingTypeInformation() const [member function] + cls.add_method('HasUnderlyingTypeInformation', + 'bool', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + return + +def register_Ns3AttributeValue_methods(root_module, cls): + ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [copy constructor] + cls.add_constructor([param('ns3::AttributeValue const &', 'arg0')]) + ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue() [constructor] + cls.add_constructor([]) + ## attribute.h (module 'core'): ns3::Ptr ns3::AttributeValue::Copy() const [member function] + cls.add_method('Copy', + 'ns3::Ptr< ns3::AttributeValue >', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## attribute.h (module 'core'): bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', + 'bool', + [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], + is_pure_virtual=True, is_virtual=True) + ## attribute.h (module 'core'): std::string ns3::AttributeValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', + 'std::string', + [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], + is_pure_virtual=True, is_const=True, is_virtual=True) + return + +def register_Ns3BooleanChecker_methods(root_module, cls): + ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker() [constructor] + cls.add_constructor([]) + ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [copy constructor] + cls.add_constructor([param('ns3::BooleanChecker const &', 'arg0')]) + return + +def register_Ns3BooleanValue_methods(root_module, cls): + cls.add_output_stream_operator() + ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [copy constructor] + cls.add_constructor([param('ns3::BooleanValue const &', 'arg0')]) + ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue() [constructor] + cls.add_constructor([]) + ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue(bool value) [constructor] + cls.add_constructor([param('bool', 'value')]) + ## boolean.h (module 'core'): ns3::Ptr ns3::BooleanValue::Copy() const [member function] + cls.add_method('Copy', + 'ns3::Ptr< ns3::AttributeValue >', + [], + is_const=True, is_virtual=True) + ## boolean.h (module 'core'): bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', + 'bool', + [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], + is_virtual=True) + ## boolean.h (module 'core'): bool ns3::BooleanValue::Get() const [member function] + cls.add_method('Get', + 'bool', + [], + is_const=True) + ## boolean.h (module 'core'): std::string ns3::BooleanValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', + 'std::string', + [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], + is_const=True, is_virtual=True) + ## boolean.h (module 'core'): void ns3::BooleanValue::Set(bool value) [member function] + cls.add_method('Set', + 'void', + [param('bool', 'value')]) + return + +def register_Ns3CallbackChecker_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [copy constructor] + cls.add_constructor([param('ns3::CallbackChecker const &', 'arg0')]) + return + +def register_Ns3CallbackImplBase_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [copy constructor] + cls.add_constructor([param('ns3::CallbackImplBase const &', 'arg0')]) + ## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr other) const [member function] + cls.add_method('IsEqual', + 'bool', + [param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')], + is_pure_virtual=True, is_const=True, is_virtual=True) + return + +def register_Ns3CallbackValue_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [copy constructor] + cls.add_constructor([param('ns3::CallbackValue const &', 'arg0')]) + ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackBase const & base) [constructor] + cls.add_constructor([param('ns3::CallbackBase const &', 'base')]) + ## callback.h (module 'core'): ns3::Ptr ns3::CallbackValue::Copy() const [member function] + cls.add_method('Copy', + 'ns3::Ptr< ns3::AttributeValue >', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', + 'bool', + [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], + is_virtual=True) + ## callback.h (module 'core'): std::string ns3::CallbackValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', + 'std::string', + [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackValue::Set(ns3::CallbackBase base) [member function] + cls.add_method('Set', + 'void', + [param('ns3::CallbackBase', 'base')]) + return + +def register_Ns3Channel_methods(root_module, cls): + ## channel.h (module 'network'): ns3::Channel::Channel(ns3::Channel const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Channel const &', 'arg0')]) + ## channel.h (module 'network'): ns3::Channel::Channel() [constructor] + cls.add_constructor([]) + ## channel.h (module 'network'): ns3::Ptr ns3::Channel::GetDevice(uint32_t i) const [member function] + cls.add_method('GetDevice', + 'ns3::Ptr< ns3::NetDevice >', + [param('uint32_t', 'i')], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## channel.h (module 'network'): uint32_t ns3::Channel::GetId() const [member function] + cls.add_method('GetId', + 'uint32_t', + [], + is_const=True) + ## channel.h (module 'network'): uint32_t ns3::Channel::GetNDevices() const [member function] + cls.add_method('GetNDevices', + 'uint32_t', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## channel.h (module 'network'): static ns3::TypeId ns3::Channel::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + return + +def register_Ns3DeviceEnergyModel_methods(root_module, cls): + ## device-energy-model.h (module 'energy'): ns3::DeviceEnergyModel::DeviceEnergyModel(ns3::DeviceEnergyModel const & arg0) [copy constructor] + cls.add_constructor([param('ns3::DeviceEnergyModel const &', 'arg0')]) + ## device-energy-model.h (module 'energy'): ns3::DeviceEnergyModel::DeviceEnergyModel() [constructor] + cls.add_constructor([]) + ## device-energy-model.h (module 'energy'): void ns3::DeviceEnergyModel::ChangeState(int newState) [member function] + cls.add_method('ChangeState', + 'void', + [param('int', 'newState')], + is_pure_virtual=True, is_virtual=True) + ## device-energy-model.h (module 'energy'): double ns3::DeviceEnergyModel::GetCurrentA() const [member function] + cls.add_method('GetCurrentA', + 'double', + [], + is_const=True) + ## device-energy-model.h (module 'energy'): double ns3::DeviceEnergyModel::GetTotalEnergyConsumption() const [member function] + cls.add_method('GetTotalEnergyConsumption', + 'double', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## device-energy-model.h (module 'energy'): static ns3::TypeId ns3::DeviceEnergyModel::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## device-energy-model.h (module 'energy'): void ns3::DeviceEnergyModel::HandleEnergyDepletion() [member function] + cls.add_method('HandleEnergyDepletion', + 'void', + [], + is_pure_virtual=True, is_virtual=True) + ## device-energy-model.h (module 'energy'): void ns3::DeviceEnergyModel::SetEnergySource(ns3::Ptr source) [member function] + cls.add_method('SetEnergySource', + 'void', + [param('ns3::Ptr< ns3::EnergySource >', 'source')], + is_pure_virtual=True, is_virtual=True) + ## device-energy-model.h (module 'energy'): double ns3::DeviceEnergyModel::DoGetCurrentA() const [member function] + cls.add_method('DoGetCurrentA', + 'double', + [], + is_const=True, visibility='private', is_virtual=True) + return + +def register_Ns3DoubleValue_methods(root_module, cls): + ## double.h (module 'core'): ns3::DoubleValue::DoubleValue() [constructor] + cls.add_constructor([]) + ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [copy constructor] + cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')]) + ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(double const & value) [constructor] + cls.add_constructor([param('double const &', 'value')]) + ## double.h (module 'core'): ns3::Ptr ns3::DoubleValue::Copy() const [member function] + cls.add_method('Copy', + 'ns3::Ptr< ns3::AttributeValue >', + [], + is_const=True, is_virtual=True) + ## double.h (module 'core'): bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', + 'bool', + [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], + is_virtual=True) + ## double.h (module 'core'): double ns3::DoubleValue::Get() const [member function] + cls.add_method('Get', + 'double', + [], + is_const=True) + ## double.h (module 'core'): std::string ns3::DoubleValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', + 'std::string', + [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], + is_const=True, is_virtual=True) + ## double.h (module 'core'): void ns3::DoubleValue::Set(double const & value) [member function] + cls.add_method('Set', + 'void', + [param('double const &', 'value')]) + return + +def register_Ns3EmptyAttributeValue_methods(root_module, cls): + ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [copy constructor] + cls.add_constructor([param('ns3::EmptyAttributeValue const &', 'arg0')]) + ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor] + cls.add_constructor([]) + ## attribute.h (module 'core'): ns3::Ptr ns3::EmptyAttributeValue::Copy() const [member function] + cls.add_method('Copy', + 'ns3::Ptr< ns3::AttributeValue >', + [], + is_const=True, visibility='private', is_virtual=True) + ## attribute.h (module 'core'): bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', + 'bool', + [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], + visibility='private', is_virtual=True) + ## attribute.h (module 'core'): std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', + 'std::string', + [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], + is_const=True, visibility='private', is_virtual=True) + return + +def register_Ns3EnergySource_methods(root_module, cls): + ## energy-source.h (module 'energy'): ns3::EnergySource::EnergySource(ns3::EnergySource const & arg0) [copy constructor] + cls.add_constructor([param('ns3::EnergySource const &', 'arg0')]) + ## energy-source.h (module 'energy'): ns3::EnergySource::EnergySource() [constructor] + cls.add_constructor([]) + ## energy-source.h (module 'energy'): void ns3::EnergySource::AppendDeviceEnergyModel(ns3::Ptr deviceEnergyModelPtr) [member function] + cls.add_method('AppendDeviceEnergyModel', + 'void', + [param('ns3::Ptr< ns3::DeviceEnergyModel >', 'deviceEnergyModelPtr')]) + ## energy-source.h (module 'energy'): void ns3::EnergySource::DisposeDeviceModels() [member function] + cls.add_method('DisposeDeviceModels', + 'void', + []) + ## energy-source.h (module 'energy'): ns3::DeviceEnergyModelContainer ns3::EnergySource::FindDeviceEnergyModels(ns3::TypeId tid) [member function] + cls.add_method('FindDeviceEnergyModels', + 'ns3::DeviceEnergyModelContainer', + [param('ns3::TypeId', 'tid')]) + ## energy-source.h (module 'energy'): ns3::DeviceEnergyModelContainer ns3::EnergySource::FindDeviceEnergyModels(std::string name) [member function] + cls.add_method('FindDeviceEnergyModels', + 'ns3::DeviceEnergyModelContainer', + [param('std::string', 'name')]) + ## energy-source.h (module 'energy'): double ns3::EnergySource::GetEnergyFraction() [member function] + cls.add_method('GetEnergyFraction', + 'double', + [], + is_pure_virtual=True, is_virtual=True) + ## energy-source.h (module 'energy'): double ns3::EnergySource::GetInitialEnergy() const [member function] + cls.add_method('GetInitialEnergy', + 'double', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## energy-source.h (module 'energy'): ns3::Ptr ns3::EnergySource::GetNode() const [member function] + cls.add_method('GetNode', + 'ns3::Ptr< ns3::Node >', + [], + is_const=True) + ## energy-source.h (module 'energy'): double ns3::EnergySource::GetRemainingEnergy() [member function] + cls.add_method('GetRemainingEnergy', + 'double', + [], + is_pure_virtual=True, is_virtual=True) + ## energy-source.h (module 'energy'): double ns3::EnergySource::GetSupplyVoltage() const [member function] + cls.add_method('GetSupplyVoltage', + 'double', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## energy-source.h (module 'energy'): static ns3::TypeId ns3::EnergySource::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## energy-source.h (module 'energy'): void ns3::EnergySource::SetNode(ns3::Ptr node) [member function] + cls.add_method('SetNode', + 'void', + [param('ns3::Ptr< ns3::Node >', 'node')]) + ## energy-source.h (module 'energy'): void ns3::EnergySource::StartDeviceModels() [member function] + cls.add_method('StartDeviceModels', + 'void', + []) + ## energy-source.h (module 'energy'): void ns3::EnergySource::UpdateEnergySource() [member function] + cls.add_method('UpdateEnergySource', + 'void', + [], + is_pure_virtual=True, is_virtual=True) + ## energy-source.h (module 'energy'): void ns3::EnergySource::BreakDeviceEnergyModelRefCycle() [member function] + cls.add_method('BreakDeviceEnergyModelRefCycle', + 'void', + [], + visibility='protected') + ## energy-source.h (module 'energy'): double ns3::EnergySource::CalculateTotalCurrent() [member function] + cls.add_method('CalculateTotalCurrent', + 'double', + [], + visibility='protected') + ## energy-source.h (module 'energy'): void ns3::EnergySource::NotifyEnergyDrained() [member function] + cls.add_method('NotifyEnergyDrained', + 'void', + [], + visibility='protected') + ## energy-source.h (module 'energy'): void ns3::EnergySource::DoDispose() [member function] + cls.add_method('DoDispose', + 'void', + [], + visibility='private', is_virtual=True) + return + +def register_Ns3EnergySourceContainer_methods(root_module, cls): + ## energy-source-container.h (module 'energy'): ns3::EnergySourceContainer::EnergySourceContainer(ns3::EnergySourceContainer const & arg0) [copy constructor] + cls.add_constructor([param('ns3::EnergySourceContainer const &', 'arg0')]) + ## energy-source-container.h (module 'energy'): ns3::EnergySourceContainer::EnergySourceContainer() [constructor] + cls.add_constructor([]) + ## energy-source-container.h (module 'energy'): ns3::EnergySourceContainer::EnergySourceContainer(ns3::Ptr source) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::EnergySource >', 'source')]) + ## energy-source-container.h (module 'energy'): ns3::EnergySourceContainer::EnergySourceContainer(std::string sourceName) [constructor] + cls.add_constructor([param('std::string', 'sourceName')]) + ## energy-source-container.h (module 'energy'): ns3::EnergySourceContainer::EnergySourceContainer(ns3::EnergySourceContainer const & a, ns3::EnergySourceContainer const & b) [constructor] + cls.add_constructor([param('ns3::EnergySourceContainer const &', 'a'), param('ns3::EnergySourceContainer const &', 'b')]) + ## energy-source-container.h (module 'energy'): void ns3::EnergySourceContainer::Add(ns3::EnergySourceContainer container) [member function] + cls.add_method('Add', + 'void', + [param('ns3::EnergySourceContainer', 'container')]) + ## energy-source-container.h (module 'energy'): void ns3::EnergySourceContainer::Add(ns3::Ptr source) [member function] + cls.add_method('Add', + 'void', + [param('ns3::Ptr< ns3::EnergySource >', 'source')]) + ## energy-source-container.h (module 'energy'): void ns3::EnergySourceContainer::Add(std::string sourceName) [member function] + cls.add_method('Add', + 'void', + [param('std::string', 'sourceName')]) + ## energy-source-container.h (module 'energy'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::EnergySourceContainer::Begin() const [member function] + cls.add_method('Begin', + '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::EnergySource > const, std::vector< ns3::Ptr< ns3::EnergySource > > >', + [], + is_const=True) + ## energy-source-container.h (module 'energy'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::EnergySourceContainer::End() const [member function] + cls.add_method('End', + '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::EnergySource > const, std::vector< ns3::Ptr< ns3::EnergySource > > >', + [], + is_const=True) + ## energy-source-container.h (module 'energy'): ns3::Ptr ns3::EnergySourceContainer::Get(uint32_t i) const [member function] + cls.add_method('Get', + 'ns3::Ptr< ns3::EnergySource >', + [param('uint32_t', 'i')], + is_const=True) + ## energy-source-container.h (module 'energy'): uint32_t ns3::EnergySourceContainer::GetN() const [member function] + cls.add_method('GetN', + 'uint32_t', + [], + is_const=True) + ## energy-source-container.h (module 'energy'): static ns3::TypeId ns3::EnergySourceContainer::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## energy-source-container.h (module 'energy'): void ns3::EnergySourceContainer::DoDispose() [member function] + cls.add_method('DoDispose', + 'void', + [], + visibility='private', is_virtual=True) + ## energy-source-container.h (module 'energy'): void ns3::EnergySourceContainer::DoStart() [member function] + cls.add_method('DoStart', + 'void', + [], + visibility='private', is_virtual=True) + return