from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandlers

def register_types(module):

    root_module = module.get_root()

    ## ethernet-header.h: ns3::ethernet_header_t [enumeration]

    module.add_enum('ethernet_header_t', ['LENGTH', 'VLAN', 'QINQ'])

    ## address.h: ns3::Address [class]

    module.add_class('Address')

    ## address.h: ns3::Address::MaxSize_e [enumeration]

    module.add_enum('MaxSize_e', ['MAX_SIZE'], outer_class=root_module['ns3::Address'])

    ## inet6-socket-address.h: ns3::Inet6SocketAddress [class]

    module.add_class('Inet6SocketAddress')

    ## inet6-socket-address.h: ns3::Inet6SocketAddress [class]

    root_module['ns3::Inet6SocketAddress'].implicitly_converts_to(root_module['ns3::Address'])

    ## inet-socket-address.h: ns3::InetSocketAddress [class]

    module.add_class('InetSocketAddress')

    ## inet-socket-address.h: ns3::InetSocketAddress [class]

    root_module['ns3::InetSocketAddress'].implicitly_converts_to(root_module['ns3::Address'])

    ## ipv4-address.h: ns3::Ipv4Address [class]

    module.add_class('Ipv4Address')

    ## ipv4-address.h: ns3::Ipv4Address [class]

    root_module['ns3::Ipv4Address'].implicitly_converts_to(root_module['ns3::Address'])

    ## ipv4-address-generator.h: ns3::Ipv4AddressGenerator [class]

    module.add_class('Ipv4AddressGenerator')

    ## ipv4-interface-address.h: ns3::Ipv4InterfaceAddress [class]

    module.add_class('Ipv4InterfaceAddress')

    ## ipv4-interface-address.h: ns3::Ipv4InterfaceAddress::InterfaceAddressScope_e [enumeration]

    module.add_enum('InterfaceAddressScope_e', ['HOST', 'LINK', 'GLOBAL'], outer_class=root_module['ns3::Ipv4InterfaceAddress'])

    ## ipv4-address.h: ns3::Ipv4Mask [class]

    module.add_class('Ipv4Mask')

    ## ipv6-address.h: ns3::Ipv6Address [class]

    module.add_class('Ipv6Address')

    ## ipv6-address.h: ns3::Ipv6Address [class]

    root_module['ns3::Ipv6Address'].implicitly_converts_to(root_module['ns3::Address'])

    ## ipv6-address.h: ns3::Ipv6Prefix [class]

    module.add_class('Ipv6Prefix')

    ## mac48-address.h: ns3::Mac48Address [class]

    module.add_class('Mac48Address')

    ## mac48-address.h: ns3::Mac48Address [class]

    root_module['ns3::Mac48Address'].implicitly_converts_to(root_module['ns3::Address'])

    ## mac64-address.h: ns3::Mac64Address [class]

    module.add_class('Mac64Address')

    ## mac64-address.h: ns3::Mac64Address [class]

    root_module['ns3::Mac64Address'].implicitly_converts_to(root_module['ns3::Address'])

    ## node-list.h: ns3::NodeList [class]

    module.add_class('NodeList')

    ## packet-socket-address.h: ns3::PacketSocketAddress [class]

    module.add_class('PacketSocketAddress')

    ## packet-socket-address.h: ns3::PacketSocketAddress [class]

    root_module['ns3::PacketSocketAddress'].implicitly_converts_to(root_module['ns3::Address'])

    ## ipv4-address.h: ns3::Ipv4AddressChecker [class]

    module.add_class('Ipv4AddressChecker', parent=root_module['ns3::AttributeChecker'])

    ## ipv4-address.h: ns3::Ipv4AddressValue [class]

    module.add_class('Ipv4AddressValue', parent=root_module['ns3::AttributeValue'])

    ## ipv4-header.h: ns3::Ipv4Header [class]

    module.add_class('Ipv4Header', parent=root_module['ns3::Header'])

    ## ipv4-address.h: ns3::Ipv4MaskChecker [class]

    module.add_class('Ipv4MaskChecker', parent=root_module['ns3::AttributeChecker'])

    ## ipv4-address.h: ns3::Ipv4MaskValue [class]

    module.add_class('Ipv4MaskValue', parent=root_module['ns3::AttributeValue'])

    ## ipv4-route.h: ns3::Ipv4MulticastRoute [class]

    module.add_class('Ipv4MulticastRoute', parent=root_module['ns3::RefCountBase'])

    ## ipv4-route.h: ns3::Ipv4Route [class]

    module.add_class('Ipv4Route', parent=root_module['ns3::RefCountBase'])

    ## ipv6-address.h: ns3::Ipv6AddressChecker [class]

    module.add_class('Ipv6AddressChecker', parent=root_module['ns3::AttributeChecker'])

    ## ipv6-address.h: ns3::Ipv6AddressValue [class]

    module.add_class('Ipv6AddressValue', parent=root_module['ns3::AttributeValue'])

    ## ipv6-header.h: ns3::Ipv6Header [class]

    module.add_class('Ipv6Header', parent=root_module['ns3::Header'])

    ## ipv6-header.h: ns3::Ipv6Header::NextHeader_e [enumeration]

    module.add_enum('NextHeader_e', ['IPV6_EXT_HOP_BY_HOP', 'IPV6_IPV4', 'IPV6_TCP', 'IPV6_UDP', 'IPV6_IPV6', 'IPV6_EXT_ROUTING', 'IPV6_EXT_FRAGMENTATION', 'IPV6_EXT_CONFIDENTIALITY', 'IPV6_EXT_AUTHENTIFICATION', 'IPV6_ICMPV6', 'IPV6_EXT_END', 'IPV6_EXT_DESTINATION', 'IPV6_SCTP', 'IPV6_EXT_MOBILITY', 'IPV6_UDP_LITE'], outer_class=root_module['ns3::Ipv6Header'])

    ## ipv6-address.h: ns3::Ipv6PrefixChecker [class]

    module.add_class('Ipv6PrefixChecker', parent=root_module['ns3::AttributeChecker'])

    ## ipv6-address.h: ns3::Ipv6PrefixValue [class]

    module.add_class('Ipv6PrefixValue', parent=root_module['ns3::AttributeValue'])

    ## llc-snap-header.h: ns3::LlcSnapHeader [class]

    module.add_class('LlcSnapHeader', parent=root_module['ns3::Header'])

    ## mac48-address.h: ns3::Mac48AddressChecker [class]

    module.add_class('Mac48AddressChecker', parent=root_module['ns3::AttributeChecker'])

    ## mac48-address.h: ns3::Mac48AddressValue [class]

    module.add_class('Mac48AddressValue', parent=root_module['ns3::AttributeValue'])

    ## queue.h: ns3::Queue [class]

    module.add_class('Queue', parent=root_module['ns3::Object'])

    ## socket.h: ns3::Socket [class]

    module.add_class('Socket', parent=root_module['ns3::Object'])

    ## socket.h: ns3::Socket::SocketErrno [enumeration]

    module.add_enum('SocketErrno', ['ERROR_NOTERROR', 'ERROR_ISCONN', 'ERROR_NOTCONN', 'ERROR_MSGSIZE', 'ERROR_AGAIN', 'ERROR_SHUTDOWN', 'ERROR_OPNOTSUPP', 'ERROR_AFNOSUPPORT', 'ERROR_INVAL', 'ERROR_BADF', 'ERROR_NOROUTETOHOST', 'SOCKET_ERRNO_LAST'], outer_class=root_module['ns3::Socket'])

    ## socket.h: ns3::SocketAddressTag [class]

    module.add_class('SocketAddressTag', parent=root_module['ns3::Tag'])

    ## socket-factory.h: ns3::SocketFactory [class]

    module.add_class('SocketFactory', parent=root_module['ns3::Object'])

    ## socket.h: ns3::SocketIpTtlTag [class]

    module.add_class('SocketIpTtlTag', parent=root_module['ns3::Tag'])

    ## socket.h: ns3::SocketSetDontFragmentTag [class]

    module.add_class('SocketSetDontFragmentTag', parent=root_module['ns3::Tag'])

    ## tcp-socket.h: ns3::TcpSocket [class]

    module.add_class('TcpSocket', parent=root_module['ns3::Socket'])

    ## tcp-socket-factory.h: ns3::TcpSocketFactory [class]

    module.add_class('TcpSocketFactory', parent=root_module['ns3::SocketFactory'])

    ## udp-socket.h: ns3::UdpSocket [class]

    module.add_class('UdpSocket', parent=root_module['ns3::Socket'])

    ## udp-socket-factory.h: ns3::UdpSocketFactory [class]

    module.add_class('UdpSocketFactory', parent=root_module['ns3::SocketFactory'])

    ## address.h: ns3::AddressChecker [class]

    module.add_class('AddressChecker', parent=root_module['ns3::AttributeChecker'])

    ## address.h: ns3::AddressValue [class]

    module.add_class('AddressValue', parent=root_module['ns3::AttributeValue'])

    ## application.h: ns3::Application [class]

    module.add_class('Application', parent=root_module['ns3::Object'])

    ## channel.h: ns3::Channel [class]

    module.add_class('Channel', parent=root_module['ns3::Object'])

    ## drop-tail-queue.h: ns3::DropTailQueue [class]

    module.add_class('DropTailQueue', parent=root_module['ns3::Queue'])

    ## drop-tail-queue.h: ns3::DropTailQueue::Mode [enumeration]

    module.add_enum('Mode', ['ILLEGAL', 'PACKETS', 'BYTES'], outer_class=root_module['ns3::DropTailQueue'])

    ## ethernet-header.h: ns3::EthernetHeader [class]

    module.add_class('EthernetHeader', parent=root_module['ns3::Header'])

    ## ethernet-trailer.h: ns3::EthernetTrailer [class]

    module.add_class('EthernetTrailer', parent=root_module['ns3::Trailer'])

    ## ipv4.h: ns3::Ipv4 [class]

    module.add_class('Ipv4', parent=root_module['ns3::Object'])

    ## ipv4-raw-socket-factory.h: ns3::Ipv4RawSocketFactory [class]

    module.add_class('Ipv4RawSocketFactory', parent=root_module['ns3::SocketFactory'])

    ## ipv4-routing-protocol.h: ns3::Ipv4RoutingProtocol [class]

    module.add_class('Ipv4RoutingProtocol', parent=root_module['ns3::Object'])

    ## net-device.h: ns3::NetDevice [class]

    module.add_class('NetDevice', parent=root_module['ns3::Object'])

    ## net-device.h: 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'])

    ## node.h: ns3::Node [class]

    module.add_class('Node', parent=root_module['ns3::Object'])

    ## packet-socket-factory.h: ns3::PacketSocketFactory [class]

    module.add_class('PacketSocketFactory', parent=root_module['ns3::SocketFactory'])

    ## simple-channel.h: ns3::SimpleChannel [class]

    module.add_class('SimpleChannel', parent=root_module['ns3::Channel'])

    ## simple-net-device.h: ns3::SimpleNetDevice [class]

    module.add_class('SimpleNetDevice', parent=root_module['ns3::NetDevice'])

    module.add_container('ns3::olsr::MprSet', 'ns3::Ipv4Address', container_type='set')

    module.add_container('std::vector< ns3::Ipv4Address >', 'ns3::Ipv4Address', container_type='vector')

    ## Register a nested module for the namespace Config

    nested_module = module.add_cpp_namespace('Config')

    register_types_ns3_Config(nested_module)

    ## Register a nested module for the namespace TimeStepPrecision

    nested_module = module.add_cpp_namespace('TimeStepPrecision')

    register_types_ns3_TimeStepPrecision(nested_module)

    ## Register a nested module for the namespace addressUtils

    nested_module = module.add_cpp_namespace('addressUtils')

    register_types_ns3_addressUtils(nested_module)

    ## Register a nested module for the namespace internal

    nested_module = module.add_cpp_namespace('internal')

    register_types_ns3_internal(nested_module)

    ## Register a nested module for the namespace olsr

    nested_module = module.add_cpp_namespace('olsr')

    register_types_ns3_olsr(nested_module)

def register_types_ns3_Config(module):

    root_module = module.get_root()

def register_types_ns3_TimeStepPrecision(module):

    root_module = module.get_root()

def register_types_ns3_addressUtils(module):

    root_module = module.get_root()

def register_types_ns3_internal(module):

    root_module = module.get_root()

def register_types_ns3_olsr(module):

    root_module = module.get_root()

def register_methods(root_module):

    register_Ns3Address_methods(root_module, root_module['ns3::Address'])

    register_Ns3Inet6SocketAddress_methods(root_module, root_module['ns3::Inet6SocketAddress'])

    register_Ns3InetSocketAddress_methods(root_module, root_module['ns3::InetSocketAddress'])

    register_Ns3Ipv4Address_methods(root_module, root_module['ns3::Ipv4Address'])

    register_Ns3Ipv4AddressGenerator_methods(root_module, root_module['ns3::Ipv4AddressGenerator'])

    register_Ns3Ipv4InterfaceAddress_methods(root_module, root_module['ns3::Ipv4InterfaceAddress'])

    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_Ns3Mac48Address_methods(root_module, root_module['ns3::Mac48Address'])

    register_Ns3Mac64Address_methods(root_module, root_module['ns3::Mac64Address'])

    register_Ns3NodeList_methods(root_module, root_module['ns3::NodeList'])

    register_Ns3PacketSocketAddress_methods(root_module, root_module['ns3::PacketSocketAddress'])

    register_Ns3Ipv4AddressChecker_methods(root_module, root_module['ns3::Ipv4AddressChecker'])

    register_Ns3Ipv4AddressValue_methods(root_module, root_module['ns3::Ipv4AddressValue'])

    register_Ns3Ipv4Header_methods(root_module, root_module['ns3::Ipv4Header'])

    register_Ns3Ipv4MaskChecker_methods(root_module, root_module['ns3::Ipv4MaskChecker'])

    register_Ns3Ipv4MaskValue_methods(root_module, root_module['ns3::Ipv4MaskValue'])

    register_Ns3Ipv4MulticastRoute_methods(root_module, root_module['ns3::Ipv4MulticastRoute'])

    register_Ns3Ipv4Route_methods(root_module, root_module['ns3::Ipv4Route'])

    register_Ns3Ipv6AddressChecker_methods(root_module, root_module['ns3::Ipv6AddressChecker'])

    register_Ns3Ipv6AddressValue_methods(root_module, root_module['ns3::Ipv6AddressValue'])

    register_Ns3Ipv6Header_methods(root_module, root_module['ns3::Ipv6Header'])

    register_Ns3Ipv6PrefixChecker_methods(root_module, root_module['ns3::Ipv6PrefixChecker'])

    register_Ns3Ipv6PrefixValue_methods(root_module, root_module['ns3::Ipv6PrefixValue'])

    register_Ns3LlcSnapHeader_methods(root_module, root_module['ns3::LlcSnapHeader'])

    register_Ns3Mac48AddressChecker_methods(root_module, root_module['ns3::Mac48AddressChecker'])

    register_Ns3Mac48AddressValue_methods(root_module, root_module['ns3::Mac48AddressValue'])

    register_Ns3Queue_methods(root_module, root_module['ns3::Queue'])

    register_Ns3Socket_methods(root_module, root_module['ns3::Socket'])

    register_Ns3SocketAddressTag_methods(root_module, root_module['ns3::SocketAddressTag'])

    register_Ns3SocketFactory_methods(root_module, root_module['ns3::SocketFactory'])

    register_Ns3SocketIpTtlTag_methods(root_module, root_module['ns3::SocketIpTtlTag'])

    register_Ns3SocketSetDontFragmentTag_methods(root_module, root_module['ns3::SocketSetDontFragmentTag'])

    register_Ns3TcpSocket_methods(root_module, root_module['ns3::TcpSocket'])

    register_Ns3TcpSocketFactory_methods(root_module, root_module['ns3::TcpSocketFactory'])

    register_Ns3UdpSocket_methods(root_module, root_module['ns3::UdpSocket'])

    register_Ns3UdpSocketFactory_methods(root_module, root_module['ns3::UdpSocketFactory'])

    register_Ns3AddressChecker_methods(root_module, root_module['ns3::AddressChecker'])

    register_Ns3AddressValue_methods(root_module, root_module['ns3::AddressValue'])

    register_Ns3Application_methods(root_module, root_module['ns3::Application'])

    register_Ns3Channel_methods(root_module, root_module['ns3::Channel'])

    register_Ns3DropTailQueue_methods(root_module, root_module['ns3::DropTailQueue'])

    register_Ns3EthernetHeader_methods(root_module, root_module['ns3::EthernetHeader'])

    register_Ns3EthernetTrailer_methods(root_module, root_module['ns3::EthernetTrailer'])

    register_Ns3Ipv4_methods(root_module, root_module['ns3::Ipv4'])

    register_Ns3Ipv4RawSocketFactory_methods(root_module, root_module['ns3::Ipv4RawSocketFactory'])

    register_Ns3Ipv4RoutingProtocol_methods(root_module, root_module['ns3::Ipv4RoutingProtocol'])

    register_Ns3NetDevice_methods(root_module, root_module['ns3::NetDevice'])

    register_Ns3Node_methods(root_module, root_module['ns3::Node'])

    register_Ns3PacketSocketFactory_methods(root_module, root_module['ns3::PacketSocketFactory'])

    register_Ns3SimpleChannel_methods(root_module, root_module['ns3::SimpleChannel'])

    register_Ns3SimpleNetDevice_methods(root_module, root_module['ns3::SimpleNetDevice'])

    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: ns3::Address::Address() [constructor]

    cls.add_constructor([])

    ## address.h: 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: ns3::Address::Address(ns3::Address const & address) [copy constructor]

    cls.add_constructor([param('ns3::Address const &', 'address')])

    ## address.h: 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: 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: 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: 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: 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: void ns3::Address::Deserialize(ns3::TagBuffer buffer) [member function]

    cls.add_method('Deserialize', 

                   'void', 

                   [param('ns3::TagBuffer', 'buffer')])

    ## address.h: uint8_t ns3::Address::GetLength() const [member function]

    cls.add_method('GetLength', 

                   'uint8_t', 

                   [], 

                   is_const=True)

    ## address.h: uint32_t ns3::Address::GetSerializedSize() const [member function]

    cls.add_method('GetSerializedSize', 

                   'uint32_t', 

                   [], 

                   is_const=True)

    ## address.h: bool ns3::Address::IsInvalid() const [member function]

    cls.add_method('IsInvalid', 

                   'bool', 

                   [], 

                   is_const=True)

    ## address.h: bool ns3::Address::IsMatchingType(uint8_t type) const [member function]

    cls.add_method('IsMatchingType', 

                   'bool', 

                   [param('uint8_t', 'type')], 

                   is_const=True)

    ## address.h: static uint8_t ns3::Address::Register() [member function]

    cls.add_method('Register', 

                   'uint8_t', 

                   [], 

                   is_static=True)

    ## address.h: 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_Ns3Inet6SocketAddress_methods(root_module, cls):

    ## inet6-socket-address.h: ns3::Inet6SocketAddress::Inet6SocketAddress(ns3::Inet6SocketAddress const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::Inet6SocketAddress const &', 'arg0')])

    ## inet6-socket-address.h: ns3::Inet6SocketAddress::Inet6SocketAddress(ns3::Ipv6Address ipv6, uint16_t port) [constructor]

    cls.add_constructor([param('ns3::Ipv6Address', 'ipv6'), param('uint16_t', 'port')])

    ## inet6-socket-address.h: ns3::Inet6SocketAddress::Inet6SocketAddress(ns3::Ipv6Address ipv6) [constructor]

    cls.add_constructor([param('ns3::Ipv6Address', 'ipv6')])

    ## inet6-socket-address.h: ns3::Inet6SocketAddress::Inet6SocketAddress(uint16_t port) [constructor]

    cls.add_constructor([param('uint16_t', 'port')])

    ## inet6-socket-address.h: ns3::Inet6SocketAddress::Inet6SocketAddress(char const * ipv6, uint16_t port) [constructor]

    cls.add_constructor([param('char const *', 'ipv6'), param('uint16_t', 'port')])

    ## inet6-socket-address.h: ns3::Inet6SocketAddress::Inet6SocketAddress(char const * ipv6) [constructor]

    cls.add_constructor([param('char const *', 'ipv6')])

    ## inet6-socket-address.h: uint16_t ns3::Inet6SocketAddress::GetPort() const [member function]

    cls.add_method('GetPort', 

                   'uint16_t', 

                   [], 

                   is_const=True)

    ## inet6-socket-address.h: void ns3::Inet6SocketAddress::SetPort(uint16_t port) [member function]

    cls.add_method('SetPort', 

                   'void', 

                   [param('uint16_t', 'port')])

    ## inet6-socket-address.h: ns3::Ipv6Address ns3::Inet6SocketAddress::GetIpv6() const [member function]

    cls.add_method('GetIpv6', 

                   'ns3::Ipv6Address', 

                   [], 

                   is_const=True)

    ## inet6-socket-address.h: void ns3::Inet6SocketAddress::SetIpv6(ns3::Ipv6Address ipv6) [member function]

    cls.add_method('SetIpv6', 

                   'void', 

                   [param('ns3::Ipv6Address', 'ipv6')])

    ## inet6-socket-address.h: static bool ns3::Inet6SocketAddress::IsMatchingType(ns3::Address const & addr) [member function]

    cls.add_method('IsMatchingType', 

                   'bool', 

                   [param('ns3::Address const &', 'addr')], 

                   is_static=True)

    ## inet6-socket-address.h: static ns3::Inet6SocketAddress ns3::Inet6SocketAddress::ConvertFrom(ns3::Address const & addr) [member function]

    cls.add_method('ConvertFrom', 

                   'ns3::Inet6SocketAddress', 

                   [param('ns3::Address const &', 'addr')], 

                   is_static=True)

    return

def register_Ns3InetSocketAddress_methods(root_module, cls):

    ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::InetSocketAddress const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::InetSocketAddress const &', 'arg0')])

    ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4, uint16_t port) [constructor]

    cls.add_constructor([param('ns3::Ipv4Address', 'ipv4'), param('uint16_t', 'port')])

    ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4) [constructor]

    cls.add_constructor([param('ns3::Ipv4Address', 'ipv4')])

    ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(uint16_t port) [constructor]

    cls.add_constructor([param('uint16_t', 'port')])

    ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(char const * ipv4, uint16_t port) [constructor]

    cls.add_constructor([param('char const *', 'ipv4'), param('uint16_t', 'port')])

    ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(char const * ipv4) [constructor]

    cls.add_constructor([param('char const *', 'ipv4')])

    ## inet-socket-address.h: uint16_t ns3::InetSocketAddress::GetPort() const [member function]

    cls.add_method('GetPort', 

                   'uint16_t', 

                   [], 

                   is_const=True)

    ## inet-socket-address.h: ns3::Ipv4Address ns3::InetSocketAddress::GetIpv4() const [member function]

    cls.add_method('GetIpv4', 

                   'ns3::Ipv4Address', 

                   [], 

                   is_const=True)

    ## inet-socket-address.h: void ns3::InetSocketAddress::SetPort(uint16_t port) [member function]

    cls.add_method('SetPort', 

                   'void', 

                   [param('uint16_t', 'port')])

    ## inet-socket-address.h: void ns3::InetSocketAddress::SetIpv4(ns3::Ipv4Address address) [member function]

    cls.add_method('SetIpv4', 

                   'void', 

                   [param('ns3::Ipv4Address', 'address')])

    ## inet-socket-address.h: static bool ns3::InetSocketAddress::IsMatchingType(ns3::Address const & address) [member function]

    cls.add_method('IsMatchingType', 

                   'bool', 

                   [param('ns3::Address const &', 'address')], 

                   is_static=True)

    ## inet-socket-address.h: static ns3::InetSocketAddress ns3::InetSocketAddress::ConvertFrom(ns3::Address const & address) [member function]

    cls.add_method('ConvertFrom', 

                   'ns3::InetSocketAddress', 

                   [param('ns3::Address const &', 'address')], 

                   is_static=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: ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::Ipv4Address const &', 'arg0')])

    ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address() [constructor]

    cls.add_constructor([])

    ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(uint32_t address) [constructor]

    cls.add_constructor([param('uint32_t', 'address')])

    ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(char const * address) [constructor]

    cls.add_constructor([param('char const *', 'address')])

    ## ipv4-address.h: 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: 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: 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: uint32_t ns3::Ipv4Address::Get() const [member function]

    cls.add_method('Get', 

                   'uint32_t', 

                   [], 

                   is_const=True)

    ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetAny() [member function]

    cls.add_method('GetAny', 

                   'ns3::Ipv4Address', 

                   [], 

                   is_static=True)

    ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetBroadcast() [member function]

    cls.add_method('GetBroadcast', 

                   'ns3::Ipv4Address', 

                   [], 

                   is_static=True)

    ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetLoopback() [member function]

    cls.add_method('GetLoopback', 

                   'ns3::Ipv4Address', 

                   [], 

                   is_static=True)

    ## ipv4-address.h: 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: static ns3::Ipv4Address ns3::Ipv4Address::GetZero() [member function]

    cls.add_method('GetZero', 

                   'ns3::Ipv4Address', 

                   [], 

                   is_static=True)

    ## ipv4-address.h: bool ns3::Ipv4Address::IsBroadcast() const [member function]

    cls.add_method('IsBroadcast', 

                   'bool', 

                   [], 

                   is_const=True)

    ## ipv4-address.h: 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: 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: bool ns3::Ipv4Address::IsMulticast() const [member function]

    cls.add_method('IsMulticast', 

                   'bool', 

                   [], 

                   is_const=True)

    ## ipv4-address.h: 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: 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: 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: void ns3::Ipv4Address::Set(uint32_t address) [member function]

    cls.add_method('Set', 

                   'void', 

                   [param('uint32_t', 'address')])

    ## ipv4-address.h: void ns3::Ipv4Address::Set(char const * address) [member function]

    cls.add_method('Set', 

                   'void', 

                   [param('char const *', 'address')])

    return

def register_Ns3Ipv4AddressGenerator_methods(root_module, cls):

    ## ipv4-address-generator.h: ns3::Ipv4AddressGenerator::Ipv4AddressGenerator(ns3::Ipv4AddressGenerator const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::Ipv4AddressGenerator const &', 'arg0')])

    ## ipv4-address-generator.h: ns3::Ipv4AddressGenerator::Ipv4AddressGenerator() [constructor]

    cls.add_constructor([])

    ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::Init(ns3::Ipv4Address const net, ns3::Ipv4Mask const mask, ns3::Ipv4Address const addr="0.0.0.1") [member function]

    cls.add_method('Init', 

                   'void', 

                   [param('ns3::Ipv4Address const', 'net'), param('ns3::Ipv4Mask const', 'mask'), param('ns3::Ipv4Address const', 'addr', default_value='"0.0.0.1"')], 

                   is_static=True)

    ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::NextNetwork(ns3::Ipv4Mask const mask) [member function]

    cls.add_method('NextNetwork', 

                   'ns3::Ipv4Address', 

                   [param('ns3::Ipv4Mask const', 'mask')], 

                   is_static=True)

    ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::GetNetwork(ns3::Ipv4Mask const mask) [member function]

    cls.add_method('GetNetwork', 

                   'ns3::Ipv4Address', 

                   [param('ns3::Ipv4Mask const', 'mask')], 

                   is_static=True)

    ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::InitAddress(ns3::Ipv4Address const addr, ns3::Ipv4Mask const mask) [member function]

    cls.add_method('InitAddress', 

                   'void', 

                   [param('ns3::Ipv4Address const', 'addr'), param('ns3::Ipv4Mask const', 'mask')], 

                   is_static=True)

    ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::NextAddress(ns3::Ipv4Mask const mask) [member function]

    cls.add_method('NextAddress', 

                   'ns3::Ipv4Address', 

                   [param('ns3::Ipv4Mask const', 'mask')], 

                   is_static=True)

    ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::GetAddress(ns3::Ipv4Mask const mask) [member function]

    cls.add_method('GetAddress', 

                   'ns3::Ipv4Address', 

                   [param('ns3::Ipv4Mask const', 'mask')], 

                   is_static=True)

    ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::Reset() [member function]

    cls.add_method('Reset', 

                   'void', 

                   [], 

                   is_static=True)

    ## ipv4-address-generator.h: static bool ns3::Ipv4AddressGenerator::AddAllocated(ns3::Ipv4Address const addr) [member function]

    cls.add_method('AddAllocated', 

                   'bool', 

                   [param('ns3::Ipv4Address const', 'addr')], 

                   is_static=True)

    ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::TestMode() [member function]

    cls.add_method('TestMode', 

                   'void', 

                   [], 

                   is_static=True)

    return

def register_Ns3Ipv4InterfaceAddress_methods(root_module, cls):

    cls.add_binary_comparison_operator('!=')

    cls.add_output_stream_operator()

    cls.add_binary_comparison_operator('==')

    ## ipv4-interface-address.h: ns3::Ipv4InterfaceAddress::Ipv4InterfaceAddress() [constructor]

    cls.add_constructor([])

    ## ipv4-interface-address.h: ns3::Ipv4InterfaceAddress::Ipv4InterfaceAddress(ns3::Ipv4Address local, ns3::Ipv4Mask mask) [constructor]

    cls.add_constructor([param('ns3::Ipv4Address', 'local'), param('ns3::Ipv4Mask', 'mask')])

    ## ipv4-interface-address.h: ns3::Ipv4InterfaceAddress::Ipv4InterfaceAddress(ns3::Ipv4InterfaceAddress const & o) [copy constructor]

    cls.add_constructor([param('ns3::Ipv4InterfaceAddress const &', 'o')])

    ## ipv4-interface-address.h: ns3::Ipv4Address ns3::Ipv4InterfaceAddress::GetBroadcast() const [member function]

    cls.add_method('GetBroadcast', 

                   'ns3::Ipv4Address', 

                   [], 

                   is_const=True)

    ## ipv4-interface-address.h: ns3::Ipv4Address ns3::Ipv4InterfaceAddress::GetLocal() const [member function]

    cls.add_method('GetLocal', 

                   'ns3::Ipv4Address', 

                   [], 

                   is_const=True)

    ## ipv4-interface-address.h: ns3::Ipv4Mask ns3::Ipv4InterfaceAddress::GetMask() const [member function]

    cls.add_method('GetMask', 

                   'ns3::Ipv4Mask', 

                   [], 

                   is_const=True)

    ## ipv4-interface-address.h: ns3::Ipv4InterfaceAddress::InterfaceAddressScope_e ns3::Ipv4InterfaceAddress::GetScope() const [member function]

    cls.add_method('GetScope', 

                   'ns3::Ipv4InterfaceAddress::InterfaceAddressScope_e', 

                   [], 

                   is_const=True)

    ## ipv4-interface-address.h: bool ns3::Ipv4InterfaceAddress::IsSecondary() const [member function]

    cls.add_method('IsSecondary', 

                   'bool', 

                   [], 

                   is_const=True)

    ## ipv4-interface-address.h: void ns3::Ipv4InterfaceAddress::SetBroadcast(ns3::Ipv4Address broadcast) [member function]

    cls.add_method('SetBroadcast', 

                   'void', 

                   [param('ns3::Ipv4Address', 'broadcast')])

    ## ipv4-interface-address.h: void ns3::Ipv4InterfaceAddress::SetLocal(ns3::Ipv4Address local) [member function]

    cls.add_method('SetLocal', 

                   'void', 

                   [param('ns3::Ipv4Address', 'local')])

    ## ipv4-interface-address.h: void ns3::Ipv4InterfaceAddress::SetMask(ns3::Ipv4Mask mask) [member function]

    cls.add_method('SetMask', 

                   'void', 

                   [param('ns3::Ipv4Mask', 'mask')])

    ## ipv4-interface-address.h: void ns3::Ipv4InterfaceAddress::SetPrimary() [member function]

    cls.add_method('SetPrimary', 

                   'void', 

                   [])

    ## ipv4-interface-address.h: void ns3::Ipv4InterfaceAddress::SetScope(ns3::Ipv4InterfaceAddress::InterfaceAddressScope_e scope) [member function]

    cls.add_method('SetScope', 

                   'void', 

                   [param('ns3::Ipv4InterfaceAddress::InterfaceAddressScope_e', 'scope')])

    ## ipv4-interface-address.h: void ns3::Ipv4InterfaceAddress::SetSecondary() [member function]

    cls.add_method('SetSecondary', 

                   'void', 

                   [])

    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: ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::Ipv4Mask const &', 'arg0')])

    ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask() [constructor]

    cls.add_constructor([])

    ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(uint32_t mask) [constructor]

    cls.add_constructor([param('uint32_t', 'mask')])

    ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(char const * mask) [constructor]

    cls.add_constructor([param('char const *', 'mask')])

    ## ipv4-address.h: uint32_t ns3::Ipv4Mask::Get() const [member function]

    cls.add_method('Get', 

                   'uint32_t', 

                   [], 

                   is_const=True)

    ## ipv4-address.h: uint32_t ns3::Ipv4Mask::GetInverse() const [member function]

    cls.add_method('GetInverse', 

                   'uint32_t', 

                   [], 

                   is_const=True)

    ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetLoopback() [member function]

    cls.add_method('GetLoopback', 

                   'ns3::Ipv4Mask', 

                   [], 

                   is_static=True)

    ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetOnes() [member function]

    cls.add_method('GetOnes', 

                   'ns3::Ipv4Mask', 

                   [], 

                   is_static=True)

    ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetZero() [member function]

    cls.add_method('GetZero', 

                   'ns3::Ipv4Mask', 

                   [], 

                   is_static=True)

    ## ipv4-address.h: 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: 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: 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: 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: ns3::Ipv6Address::Ipv6Address() [constructor]

    cls.add_constructor([])

    ## ipv6-address.h: ns3::Ipv6Address::Ipv6Address(char const * address) [constructor]

    cls.add_constructor([param('char const *', 'address')])

    ## ipv6-address.h: ns3::Ipv6Address::Ipv6Address(uint8_t * address) [constructor]

    cls.add_constructor([param('uint8_t *', 'address')])

    ## ipv6-address.h: ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const & addr) [copy constructor]

    cls.add_constructor([param('ns3::Ipv6Address const &', 'addr')])

    ## ipv6-address.h: ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const * addr) [constructor]

    cls.add_constructor([param('ns3::Ipv6Address const *', 'addr')])

    ## ipv6-address.h: 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: 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: 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: static ns3::Ipv6Address ns3::Ipv6Address::GetAllHostsMulticast() [member function]

    cls.add_method('GetAllHostsMulticast', 

                   'ns3::Ipv6Address', 

                   [], 

                   is_static=True)

    ## ipv6-address.h: static ns3::Ipv6Address ns3::Ipv6Address::GetAllNodesMulticast() [member function]

    cls.add_method('GetAllNodesMulticast', 

                   'ns3::Ipv6Address', 

                   [], 

                   is_static=True)

    ## ipv6-address.h: static ns3::Ipv6Address ns3::Ipv6Address::GetAllRoutersMulticast() [member function]

    cls.add_method('GetAllRoutersMulticast', 

                   'ns3::Ipv6Address', 

                   [], 

                   is_static=True)

    ## ipv6-address.h: static ns3::Ipv6Address ns3::Ipv6Address::GetAny() [member function]

    cls.add_method('GetAny', 

                   'ns3::Ipv6Address', 

                   [], 

                   is_static=True)

    ## ipv6-address.h: 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: static ns3::Ipv6Address ns3::Ipv6Address::GetLoopback() [member function]

    cls.add_method('GetLoopback', 

                   'ns3::Ipv6Address', 

                   [], 

                   is_static=True)

    ## ipv6-address.h: static ns3::Ipv6Address ns3::Ipv6Address::GetZero() [member function]

    cls.add_method('GetZero', 

                   'ns3::Ipv6Address', 

                   [], 

                   is_static=True)

    ## ipv6-address.h: bool ns3::Ipv6Address::IsAllHostsMulticast() const [member function]

    cls.add_method('IsAllHostsMulticast', 

                   'bool', 

                   [], 

                   is_const=True)

    ## ipv6-address.h: bool ns3::Ipv6Address::IsAllNodesMulticast() const [member function]

    cls.add_method('IsAllNodesMulticast', 

                   'bool', 

                   [], 

                   is_const=True)

    ## ipv6-address.h: bool ns3::Ipv6Address::IsAllRoutersMulticast() const [member function]

    cls.add_method('IsAllRoutersMulticast', 

                   'bool', 

                   [], 

                   is_const=True)

    ## ipv6-address.h: bool ns3::Ipv6Address::IsAny() const [member function]

    cls.add_method('IsAny', 

                   'bool', 

                   [], 

                   is_const=True)

    ## ipv6-address.h: 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: bool ns3::Ipv6Address::IsLinkLocal() const [member function]

    cls.add_method('IsLinkLocal', 

                   'bool', 

                   [], 

                   is_const=True)

    ## ipv6-address.h: bool ns3::Ipv6Address::IsLocalhost() const [member function]

    cls.add_method('IsLocalhost', 

                   'bool', 

                   [], 

                   is_const=True)

    ## ipv6-address.h: 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: bool ns3::Ipv6Address::IsMulticast() const [member function]

    cls.add_method('IsMulticast', 

                   'bool', 

                   [], 

                   is_const=True)

    ## ipv6-address.h: bool ns3::Ipv6Address::IsSolicitedMulticast() const [member function]

    cls.add_method('IsSolicitedMulticast', 

                   'bool', 

                   [], 

                   is_const=True)

    ## ipv6-address.h: 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: 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: 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: 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: 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: void ns3::Ipv6Address::Set(char const * address) [member function]

    cls.add_method('Set', 

                   'void', 

                   [param('char const *', 'address')])

    ## ipv6-address.h: 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: ns3::Ipv6Prefix::Ipv6Prefix() [constructor]

    cls.add_constructor([])

    ## ipv6-address.h: ns3::Ipv6Prefix::Ipv6Prefix(uint8_t * prefix) [constructor]

    cls.add_constructor([param('uint8_t *', 'prefix')])

    ## ipv6-address.h: ns3::Ipv6Prefix::Ipv6Prefix(char const * prefix) [constructor]

    cls.add_constructor([param('char const *', 'prefix')])

    ## ipv6-address.h: ns3::Ipv6Prefix::Ipv6Prefix(uint8_t prefix) [constructor]

    cls.add_constructor([param('uint8_t', 'prefix')])

    ## ipv6-address.h: ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const & prefix) [copy constructor]

    cls.add_constructor([param('ns3::Ipv6Prefix const &', 'prefix')])

    ## ipv6-address.h: ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const * prefix) [constructor]

    cls.add_constructor([param('ns3::Ipv6Prefix const *', 'prefix')])

    ## ipv6-address.h: 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: static ns3::Ipv6Prefix ns3::Ipv6Prefix::GetLoopback() [member function]

    cls.add_method('GetLoopback', 

                   'ns3::Ipv6Prefix', 

                   [], 

                   is_static=True)

    ## ipv6-address.h: static ns3::Ipv6Prefix ns3::Ipv6Prefix::GetZero() [member function]

    cls.add_method('GetZero', 

                   'ns3::Ipv6Prefix', 

                   [], 

                   is_static=True)

    ## ipv6-address.h: 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: 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: 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_Ns3Mac48Address_methods(root_module, cls):

    cls.add_binary_comparison_operator('!=')

    cls.add_binary_comparison_operator('<')

    cls.add_output_stream_operator()

    cls.add_binary_comparison_operator('==')

    ## mac48-address.h: ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::Mac48Address const &', 'arg0')])

    ## mac48-address.h: ns3::Mac48Address::Mac48Address() [constructor]

    cls.add_constructor([])

    ## mac48-address.h: ns3::Mac48Address::Mac48Address(char const * str) [constructor]

    cls.add_constructor([param('char const *', 'str')])

    ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::Allocate() [member function]

    cls.add_method('Allocate', 

                   'ns3::Mac48Address', 

                   [], 

                   is_static=True)

    ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::ConvertFrom(ns3::Address const & address) [member function]

    cls.add_method('ConvertFrom', 

                   'ns3::Mac48Address', 

                   [param('ns3::Address const &', 'address')], 

                   is_static=True)

    ## mac48-address.h: void ns3::Mac48Address::CopyFrom(uint8_t const * buffer) [member function]

    cls.add_method('CopyFrom', 

                   'void', 

                   [param('uint8_t const *', 'buffer')])

    ## mac48-address.h: void ns3::Mac48Address::CopyTo(uint8_t * buffer) const [member function]

    cls.add_method('CopyTo', 

                   'void', 

                   [param('uint8_t *', 'buffer')], 

                   is_const=True)

    ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetBroadcast() [member function]

    cls.add_method('GetBroadcast', 

                   'ns3::Mac48Address', 

                   [], 

                   is_static=True)

    ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetMulticast(ns3::Ipv4Address address) [member function]

    cls.add_method('GetMulticast', 

                   'ns3::Mac48Address', 

                   [param('ns3::Ipv4Address', 'address')], 

                   is_static=True)

    ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetMulticast(ns3::Ipv6Address address) [member function]

    cls.add_method('GetMulticast', 

                   'ns3::Mac48Address', 

                   [param('ns3::Ipv6Address', 'address')], 

                   is_static=True)

    ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetMulticast6Prefix() [member function]

    cls.add_method('GetMulticast6Prefix', 

                   'ns3::Mac48Address', 

                   [], 

                   is_static=True)

    ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetMulticastPrefix() [member function]

    cls.add_method('GetMulticastPrefix', 

                   'ns3::Mac48Address', 

                   [], 

                   is_static=True)

    ## mac48-address.h: bool ns3::Mac48Address::IsBroadcast() const [member function]

    cls.add_method('IsBroadcast', 

                   'bool', 

                   [], 

                   is_const=True)

    ## mac48-address.h: bool ns3::Mac48Address::IsGroup() const [member function]

    cls.add_method('IsGroup', 

                   'bool', 

                   [], 

                   is_const=True)

    ## mac48-address.h: static bool ns3::Mac48Address::IsMatchingType(ns3::Address const & address) [member function]

    cls.add_method('IsMatchingType', 

                   'bool', 

                   [param('ns3::Address const &', 'address')], 

                   is_static=True)

    return

def register_Ns3Mac64Address_methods(root_module, cls):

    cls.add_binary_comparison_operator('!=')

    cls.add_output_stream_operator()

    cls.add_binary_comparison_operator('==')

    ## mac64-address.h: ns3::Mac64Address::Mac64Address(ns3::Mac64Address const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::Mac64Address const &', 'arg0')])

    ## mac64-address.h: ns3::Mac64Address::Mac64Address() [constructor]

    cls.add_constructor([])

    ## mac64-address.h: ns3::Mac64Address::Mac64Address(char const * str) [constructor]

    cls.add_constructor([param('char const *', 'str')])

    ## mac64-address.h: static ns3::Mac64Address ns3::Mac64Address::Allocate() [member function]

    cls.add_method('Allocate', 

                   'ns3::Mac64Address', 

                   [], 

                   is_static=True)

    ## mac64-address.h: static ns3::Mac64Address ns3::Mac64Address::ConvertFrom(ns3::Address const & address) [member function]

    cls.add_method('ConvertFrom', 

                   'ns3::Mac64Address', 

                   [param('ns3::Address const &', 'address')], 

                   is_static=True)

    ## mac64-address.h: void ns3::Mac64Address::CopyFrom(uint8_t const * buffer) [member function]

    cls.add_method('CopyFrom', 

                   'void', 

                   [param('uint8_t const *', 'buffer')])

    ## mac64-address.h: void ns3::Mac64Address::CopyTo(uint8_t * buffer) const [member function]

    cls.add_method('CopyTo', 

                   'void', 

                   [param('uint8_t *', 'buffer')], 

                   is_const=True)

    ## mac64-address.h: static bool ns3::Mac64Address::IsMatchingType(ns3::Address const & address) [member function]

    cls.add_method('IsMatchingType', 

                   'bool', 

                   [param('ns3::Address const &', 'address')], 

                   is_static=True)

    return

def register_Ns3NodeList_methods(root_module, cls):

    ## node-list.h: ns3::NodeList::NodeList(ns3::NodeList const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::NodeList const &', 'arg0')])

    ## node-list.h: ns3::NodeList::NodeList() [constructor]

    cls.add_constructor([])

    ## node-list.h: static uint32_t ns3::NodeList::Add(ns3::Ptr<ns3::Node> node) [member function]

    cls.add_method('Add', 

                   'uint32_t', 

                   [param('ns3::Ptr< ns3::Node >', 'node')], 

                   is_static=True)

    ## node-list.h: static __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Node>*,std::vector<ns3::Ptr<ns3::Node>, std::allocator<ns3::Ptr<ns3::Node> > > > ns3::NodeList::Begin() [member function]