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

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

    ## 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-address.h: ns3::Ipv4Mask [class]

    module.add_class('Ipv4Mask')

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

    module.add_class('Ipv4MulticastRoute')

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

    module.add_class('Ipv4Route')

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

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

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

    ## 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.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', 'PACKET_BROADCAST', 'PACKET_MULTICAST', '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'])

    ## 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()

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

def register_methods(root_module):

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

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

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

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

    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_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_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_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_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_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::GetZero() [member function]

    cls.add_method('GetZero', 

                   'ns3::Ipv4Mask',