from pybindgen import Module, FileCodeSink, write_preamble, param, retval

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'])

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

    module.add_class('NodeList')

    ## 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'])

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

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

    ## 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'])

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

    module.add_class('Ipv4AddressGenerator')

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

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

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

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

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

    module.add_class('Ipv4Route')

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

    module.add_class('Ipv4MulticastRoute')

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

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

    ## 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::Ipv4Mask [class]

    module.add_class('Ipv4Mask')

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

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

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

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

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

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

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

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

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

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

    ## 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'])

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

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

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

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

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

    module.add_class('Socket', allow_subclassing=True, 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'])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    ## 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 TimeStepPrecision

    nested_module = module.add_cpp_namespace('TimeStepPrecision')

    register_types_ns3_TimeStepPrecision(nested_module)

    ## 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 olsr

    nested_module = module.add_cpp_namespace('olsr')

    register_types_ns3_olsr(nested_module)

def register_types_ns3_internal(module):

    root_module = module.get_root()

def register_types_ns3_TimeStepPrecision(module):

    root_module = module.get_root()

def register_types_ns3_Config(module):

    root_module = module.get_root()

def register_types_ns3_olsr(module):

    root_module = module.get_root()

def register_methods(root_module):

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

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

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

    register_Ns3Mac48Address_methods(root_module, root_module['ns3::Mac48Address'])

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

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

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

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

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

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

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

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

    register_Ns3Ipv4Mask_methods(root_module, root_module['ns3::Ipv4Mask'])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return

def register_Ns3NodeList_methods(root_module, cls):

    ## 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]

    cls.add_method('Begin', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::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::End() [member function]

    cls.add_method('End', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', [], is_static=True)

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

    cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [param('uint32_t', 'n')], is_static=True)

    ## node-list.h: static uint32_t ns3::NodeList::GetNNodes() [member function]

    cls.add_method('GetNNodes', 'uint32_t', [], is_static=True)

    cls.add_constructor([])

    return

def register_Ns3Address_methods(root_module, cls):

    ## address.h: ns3::Address::Address() [constructor]

    cls.add_constructor([], visibility='public')

    ## 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 *', 'buffer', transfer_ownership=False, is_const=True), param('uint8_t', 'len')], visibility='public')

    ## address.h: ns3::Address::Address(ns3::Address const & address) [copy constructor]

    cls.add_constructor([param('ns3::Address&', 'address', is_const=True)], visibility='public')

    ## 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 *', 'buffer', transfer_ownership=False, is_const=True), 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 *', 'buffer', transfer_ownership=False, is_const=True), 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)

    cls.add_output_stream_operator()

    return

def register_Ns3Ipv4AddressChecker_methods(root_module, cls):

    cls.add_constructor([])

    return

def register_Ns3Mac48Address_methods(root_module, cls):

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

    cls.add_constructor([param('ns3::Mac48Address&', 'arg0', is_const=True)], visibility='public')

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

    cls.add_constructor([], visibility='public')

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

    cls.add_constructor([param('char *', 'str', transfer_ownership=False, is_const=True)], visibility='public')

    ## 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&', 'address', is_const=True)], is_static=True)

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

    cls.add_method('CopyFrom', 'void', [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True)])

    ## 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: bool ns3::Mac48Address::IsBroadcast() const [member function]

    cls.add_method('IsBroadcast', '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&', 'address', is_const=True)], is_static=True)

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

    cls.add_method('IsMulticast', 'bool', [], is_const=True)

    cls.add_output_stream_operator()

    return

def register_Ns3Mac64Address_methods(root_module, cls):

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

    cls.add_constructor([param('ns3::Mac64Address&', 'arg0', is_const=True)], visibility='public')

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

    cls.add_constructor([], visibility='public')

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

    cls.add_constructor([param('char *', 'str', transfer_ownership=False, is_const=True)], visibility='public')

    ## 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&', 'address', is_const=True)], is_static=True)

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

    cls.add_method('CopyFrom', 'void', [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True)])

    ## 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&', 'address', is_const=True)], is_static=True)

    cls.add_output_stream_operator()

    return

def register_Ns3Ipv4AddressGenerator_methods(root_module, cls):

    ## 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', 'net', is_const=True), param('ns3::Ipv4Mask', 'mask', is_const=True), param('ns3::Ipv4Address', 'addr', default_value='"0.0.0.1"', is_const=True)], 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', 'mask', is_const=True)], 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', 'mask', is_const=True)], 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', 'addr', is_const=True), param('ns3::Ipv4Mask', 'mask', is_const=True)], 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', 'mask', is_const=True)], 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', 'mask', is_const=True)], 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', 'addr', is_const=True)], is_static=True)

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

    cls.add_method('TestMode', 'void', [], is_static=True)

    cls.add_constructor([])

    return

def register_Ns3Mac48AddressChecker_methods(root_module, cls):

    cls.add_constructor([])

    return

def register_Ns3Ipv4MaskChecker_methods(root_module, cls):

    cls.add_constructor([])

    return

def register_Ns3Ipv4Route_methods(root_module, cls):

    ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route() [constructor]

    cls.add_constructor([], visibility='public')

    ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const & route) [copy constructor]

    cls.add_constructor([param('ns3::Ipv4Route&', 'route', is_const=True)], visibility='public')

    ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const * route) [constructor]

    cls.add_constructor([param('ns3::Ipv4Route *', 'route', transfer_ownership=False, is_const=True)], visibility='public')

    ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateDefaultRoute(ns3::Ipv4Address nextHop, uint32_t interface) [member function]

    cls.add_method('CreateDefaultRoute', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_static=True)

    ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateHostRouteTo(ns3::Ipv4Address dest, ns3::Ipv4Address nextHop, uint32_t interface) [member function]

    cls.add_method('CreateHostRouteTo', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'dest'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_static=True)

    ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateHostRouteTo(ns3::Ipv4Address dest, uint32_t interface) [member function]

    cls.add_method('CreateHostRouteTo', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'dest'), param('uint32_t', 'interface')], is_static=True)

    ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, ns3::Ipv4Address nextHop, uint32_t interface) [member function]

    cls.add_method('CreateNetworkRouteTo', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_static=True)

    ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, uint32_t interface) [member function]

    cls.add_method('CreateNetworkRouteTo', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('uint32_t', 'interface')], is_static=True)

    ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetDest() const [member function]

    cls.add_method('GetDest', 'ns3::Ipv4Address', [], is_const=True)

    ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetDestNetwork() const [member function]

    cls.add_method('GetDestNetwork', 'ns3::Ipv4Address', [], is_const=True)

    ## ipv4-route.h: ns3::Ipv4Mask ns3::Ipv4Route::GetDestNetworkMask() const [member function]

    cls.add_method('GetDestNetworkMask', 'ns3::Ipv4Mask', [], is_const=True)

    ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetGateway() const [member function]

    cls.add_method('GetGateway', 'ns3::Ipv4Address', [], is_const=True)

    ## ipv4-route.h: uint32_t ns3::Ipv4Route::GetInterface() const [member function]

    cls.add_method('GetInterface', 'uint32_t', [], is_const=True)

    ## ipv4-route.h: bool ns3::Ipv4Route::IsDefault() const [member function]

    cls.add_method('IsDefault', 'bool', [], is_const=True)

    ## ipv4-route.h: bool ns3::Ipv4Route::IsGateway() const [member function]

    cls.add_method('IsGateway', 'bool', [], is_const=True)

    ## ipv4-route.h: bool ns3::Ipv4Route::IsHost() const [member function]

    cls.add_method('IsHost', 'bool', [], is_const=True)

    ## ipv4-route.h: bool ns3::Ipv4Route::IsNetwork() const [member function]

    cls.add_method('IsNetwork', 'bool', [], is_const=True)

    cls.add_output_stream_operator()

    return

def register_Ns3Ipv4MulticastRoute_methods(root_module, cls):

    ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute() [constructor]

    cls.add_constructor([], visibility='public')

    ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const & route) [copy constructor]

    cls.add_constructor([param('ns3::Ipv4MulticastRoute&', 'route', is_const=True)], visibility='public')

    ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const * route) [constructor]

    cls.add_constructor([param('ns3::Ipv4MulticastRoute *', 'route', transfer_ownership=False, is_const=True)], visibility='public')

    ## ipv4-route.h: static ns3::Ipv4MulticastRoute ns3::Ipv4MulticastRoute::CreateMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface, std::vector<unsigned int, std::allocator<unsigned int> > outputInterfaces) [member function]

    cls.add_method('CreateMulticastRoute', 'ns3::Ipv4MulticastRoute', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int, std::allocator< unsigned int > >', 'outputInterfaces')], is_static=True)

    ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4MulticastRoute::GetGroup() const [member function]

    cls.add_method('GetGroup', 'ns3::Ipv4Address', [], is_const=True)

    ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetInputInterface() const [member function]

    cls.add_method('GetInputInterface', 'uint32_t', [], is_const=True)

    ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetNOutputInterfaces() const [member function]

    cls.add_method('GetNOutputInterfaces', 'uint32_t', [], is_const=True)

    ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4MulticastRoute::GetOrigin() const [member function]

    cls.add_method('GetOrigin', 'ns3::Ipv4Address', [], is_const=True)

    ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetOutputInterface(uint32_t n) const [member function]

    cls.add_method('GetOutputInterface', 'uint32_t', [param('uint32_t', 'n')], is_const=True)

    ## ipv4-route.h: std::vector<unsigned int, std::allocator<unsigned int> > ns3::Ipv4MulticastRoute::GetOutputInterfaces() const [member function]

    cls.add_method('GetOutputInterfaces', 'std::vector< unsigned int, std::allocator< unsigned int > >', [], is_const=True)

    cls.add_output_stream_operator()

    return

def register_Ns3AddressChecker_methods(root_module, cls):

    cls.add_constructor([])

    return

def register_Ns3PacketSocketAddress_methods(root_module, cls):

    ## packet-socket-address.h: ns3::PacketSocketAddress::PacketSocketAddress() [constructor]

    cls.add_constructor([], visibility='public')

    ## packet-socket-address.h: void ns3::PacketSocketAddress::SetProtocol(uint16_t protocol) [member function]

    cls.add_method('SetProtocol', 'void', [param('uint16_t', 'protocol')])

    ## packet-socket-address.h: void ns3::PacketSocketAddress::SetAllDevices() [member function]

    cls.add_method('SetAllDevices', 'void', [])

    ## packet-socket-address.h: void ns3::PacketSocketAddress::SetSingleDevice(uint32_t device) [member function]

    cls.add_method('SetSingleDevice', 'void', [param('uint32_t', 'device')])

    ## packet-socket-address.h: void ns3::PacketSocketAddress::SetPhysicalAddress(ns3::Address const address) [member function]

    cls.add_method('SetPhysicalAddress', 'void', [param('ns3::Address', 'address', is_const=True)])

    ## packet-socket-address.h: uint16_t ns3::PacketSocketAddress::GetProtocol() const [member function]

    cls.add_method('GetProtocol', 'uint16_t', [], is_const=True)

    ## packet-socket-address.h: uint32_t ns3::PacketSocketAddress::GetSingleDevice() const [member function]

    cls.add_method('GetSingleDevice', 'uint32_t', [], is_const=True)

    ## packet-socket-address.h: bool ns3::PacketSocketAddress::IsSingleDevice() const [member function]

    cls.add_method('IsSingleDevice', 'bool', [], is_const=True)

    ## packet-socket-address.h: ns3::Address ns3::PacketSocketAddress::GetPhysicalAddress() const [member function]

    cls.add_method('GetPhysicalAddress', 'ns3::Address', [], is_const=True)

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

    cls.add_method('ConvertFrom', 'ns3::PacketSocketAddress', [param('ns3::Address&', 'address', is_const=True)], is_static=True)

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

    cls.add_method('IsMatchingType', 'bool', [param('ns3::Address&', 'address', is_const=True)], is_static=True)

    return

def register_Ns3Ipv4Mask_methods(root_module, cls):

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

    cls.add_constructor([param('ns3::Ipv4Mask&', 'arg0', is_const=True)], visibility='public')

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

    cls.add_constructor([], visibility='public')

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

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

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

    cls.add_constructor([param('char *', 'mask', transfer_ownership=False, is_const=True)], visibility='public')

    ## 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::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')])

    cls.add_output_stream_operator()

    return

def register_Ns3Ipv4AddressValue_methods(root_module, cls):

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

    cls.add_constructor([], visibility='public')

    ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4Address const & value) [constructor]

    cls.add_constructor([param('ns3::Ipv4Address&', 'value', is_const=True)], visibility='public')

    ## ipv4-address.h: void ns3::Ipv4AddressValue::Set(ns3::Ipv4Address const & value) [member function]

    cls.add_method('Set', 'void', [param('ns3::Ipv4Address&', 'value', is_const=True)])

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

    cls.add_method('Get', 'ns3::Ipv4Address', [], is_const=True)

    ## ipv4-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Ipv4AddressValue::Copy() const [member function]

    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)

    ## ipv4-address.h: std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

    cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)

    ## ipv4-address.h: bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

    cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)

    return

def register_Ns3Ipv4RoutingProtocol_methods(root_module, cls):

    ## ipv4.h: ns3::Ipv4RoutingProtocol::IF_INDEX_ANY [variable]

    cls.add_static_attribute('IF_INDEX_ANY', retval('uint32_t', is_const=True), is_const=True)

    ## ipv4.h: bool ns3::Ipv4RoutingProtocol::RequestRoute(uint32_t ifIndex, ns3::Ipv4Header const & ipHeader, ns3::Ptr<ns3::Packet> packet, ns3::Callback<void,bool,const ns3::Ipv4Route&,ns3::Ptr<ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty> routeReply) [member function]

    cls.add_method('RequestRoute', 'bool', [param('uint32_t', 'ifIndex'), param('ns3::Ipv4Header&', 'ipHeader', is_const=True), param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Callback< void, bool, const ns3::Ipv4Route&, ns3::Ptr< ns3::Packet >, const ns3::Ipv4Header&, ns3::empty, ns3::empty >', 'routeReply')], is_pure_virtual=True, is_virtual=True)

    ## ipv4.h: bool ns3::Ipv4RoutingProtocol::RequestIfIndex(ns3::Ipv4Address destination, uint32_t & ifIndex) [member function]

    cls.add_method('RequestIfIndex', 'bool', [param('ns3::Ipv4Address', 'destination'), param('uint32_t&', 'ifIndex')], is_pure_virtual=True, is_virtual=True)

    cls.add_constructor([])

    return

def register_Ns3Mac48AddressValue_methods(root_module, cls):

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

    cls.add_constructor([], visibility='public')

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

    cls.add_constructor([param('ns3::Mac48Address&', 'value', is_const=True)], visibility='public')

    ## mac48-address.h: void ns3::Mac48AddressValue::Set(ns3::Mac48Address const & value) [member function]

    cls.add_method('Set', 'void', [param('ns3::Mac48Address&', 'value', is_const=True)])

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

    cls.add_method('Get', 'ns3::Mac48Address', [], is_const=True)

    ## mac48-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Mac48AddressValue::Copy() const [member function]

    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)

    ## mac48-address.h: std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

    cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)

    ## mac48-address.h: bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

    cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)

    return

def register_Ns3Ipv4MaskValue_methods(root_module, cls):

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

    cls.add_constructor([], visibility='public')

    ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4Mask const & value) [constructor]

    cls.add_constructor([param('ns3::Ipv4Mask&', 'value', is_const=True)], visibility='public')

    ## ipv4-address.h: void ns3::Ipv4MaskValue::Set(ns3::Ipv4Mask const & value) [member function]

    cls.add_method('Set', 'void', [param('ns3::Ipv4Mask&', 'value', is_const=True)])

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

    cls.add_method('Get', 'ns3::Ipv4Mask', [], is_const=True)

    ## ipv4-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Ipv4MaskValue::Copy() const [member function]

    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)

    ## ipv4-address.h: std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

    cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)

    ## ipv4-address.h: bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

    cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)

    return

def register_Ns3SocketAddressTag_methods(root_module, cls):

    ## socket.h: ns3::SocketAddressTag::SocketAddressTag() [constructor]

    cls.add_constructor([], visibility='public')

    ## socket.h: void ns3::SocketAddressTag::SetAddress(ns3::Address addr) [member function]

    cls.add_method('SetAddress', 'void', [param('ns3::Address', 'addr')])

    ## socket.h: ns3::Address ns3::SocketAddressTag::GetAddress() const [member function]

    cls.add_method('GetAddress', 'ns3::Address', [], is_const=True)

    ## socket.h: static ns3::TypeId ns3::SocketAddressTag::GetTypeId() [member function]

    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)

    ## socket.h: ns3::TypeId ns3::SocketAddressTag::GetInstanceTypeId() const [member function]

    cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True)

    ## socket.h: uint32_t ns3::SocketAddressTag::GetSerializedSize() const [member function]

    cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True)

    ## socket.h: void ns3::SocketAddressTag::Serialize(ns3::TagBuffer i) const [member function]

    cls.add_method('Serialize', 'void', [param('ns3::TagBuffer', 'i')], is_const=True, is_virtual=True)

    ## socket.h: void ns3::SocketAddressTag::Deserialize(ns3::TagBuffer i) [member function]

    cls.add_method('Deserialize', 'void', [param('ns3::TagBuffer', 'i')], is_virtual=True)

    ## socket.h: void ns3::SocketAddressTag::Print(std::ostream & os) const [member function]

    cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True)

    return

def register_Ns3InetSocketAddress_methods(root_module, cls):

    ## 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')], visibility='public')

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

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

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

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

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

    cls.add_constructor([param('char *', 'ipv4', transfer_ownership=False, is_const=True), param('uint16_t', 'port')], visibility='public')