bindings/python/ns3_module_node.py
changeset 3731 317f9dbccc2b
parent 3584 4eb48239b4dc
child 3745 73e7bb607014
equal deleted inserted replaced
3730:ee3519505ec2 3731:317f9dbccc2b
     3 def register_types(module):
     3 def register_types(module):
     4     root_module = module.get_root()
     4     root_module = module.get_root()
     5     
     5     
     6     ## ethernet-header.h: ns3::ethernet_header_t [enumeration]
     6     ## ethernet-header.h: ns3::ethernet_header_t [enumeration]
     7     module.add_enum('ethernet_header_t', ['LENGTH', 'VLAN', 'QINQ'])
     7     module.add_enum('ethernet_header_t', ['LENGTH', 'VLAN', 'QINQ'])
     8     ## ipv4-address.h: ns3::Ipv4Mask [class]
       
     9     module.add_class('Ipv4Mask')
       
    10     ## node-list.h: ns3::NodeList [class]
       
    11     module.add_class('NodeList')
       
    12     ## address.h: ns3::Address [class]
     8     ## address.h: ns3::Address [class]
    13     module.add_class('Address')
     9     module.add_class('Address')
    14     ## address.h: ns3::Address::MaxSize_e [enumeration]
    10     ## address.h: ns3::Address::MaxSize_e [enumeration]
    15     module.add_enum('MaxSize_e', ['MAX_SIZE'], outer_class=root_module['ns3::Address'])
    11     module.add_enum('MaxSize_e', ['MAX_SIZE'], outer_class=root_module['ns3::Address'])
    16     ## ipv4-address.h: ns3::Ipv4AddressChecker [class]
    12     ## inet-socket-address.h: ns3::InetSocketAddress [class]
    17     module.add_class('Ipv4AddressChecker', parent=root_module['ns3::AttributeChecker'])
    13     module.add_class('InetSocketAddress')
       
    14     ## inet-socket-address.h: ns3::InetSocketAddress [class]
       
    15     root_module['ns3::InetSocketAddress'].implicitly_converts_to(root_module['ns3::Address'])
       
    16     ## ipv4-address.h: ns3::Ipv4Address [class]
       
    17     module.add_class('Ipv4Address')
       
    18     ## ipv4-address.h: ns3::Ipv4Address [class]
       
    19     root_module['ns3::Ipv4Address'].implicitly_converts_to(root_module['ns3::Address'])
       
    20     ## ipv4-address-generator.h: ns3::Ipv4AddressGenerator [class]
       
    21     module.add_class('Ipv4AddressGenerator')
       
    22     ## ipv4-address.h: ns3::Ipv4Mask [class]
       
    23     module.add_class('Ipv4Mask')
       
    24     ## ipv4-route.h: ns3::Ipv4MulticastRoute [class]
       
    25     module.add_class('Ipv4MulticastRoute')
       
    26     ## ipv4-route.h: ns3::Ipv4Route [class]
       
    27     module.add_class('Ipv4Route')
    18     ## mac48-address.h: ns3::Mac48Address [class]
    28     ## mac48-address.h: ns3::Mac48Address [class]
    19     module.add_class('Mac48Address')
    29     module.add_class('Mac48Address')
    20     ## mac48-address.h: ns3::Mac48Address [class]
    30     ## mac48-address.h: ns3::Mac48Address [class]
    21     root_module['ns3::Mac48Address'].implicitly_converts_to(root_module['ns3::Address'])
    31     root_module['ns3::Mac48Address'].implicitly_converts_to(root_module['ns3::Address'])
    22     ## mac64-address.h: ns3::Mac64Address [class]
    32     ## mac64-address.h: ns3::Mac64Address [class]
    23     module.add_class('Mac64Address')
    33     module.add_class('Mac64Address')
    24     ## mac64-address.h: ns3::Mac64Address [class]
    34     ## mac64-address.h: ns3::Mac64Address [class]
    25     root_module['ns3::Mac64Address'].implicitly_converts_to(root_module['ns3::Address'])
    35     root_module['ns3::Mac64Address'].implicitly_converts_to(root_module['ns3::Address'])
    26     ## ipv4-address-generator.h: ns3::Ipv4AddressGenerator [class]
    36     ## node-list.h: ns3::NodeList [class]
    27     module.add_class('Ipv4AddressGenerator')
    37     module.add_class('NodeList')
    28     ## mac48-address.h: ns3::Mac48AddressChecker [class]
       
    29     module.add_class('Mac48AddressChecker', parent=root_module['ns3::AttributeChecker'])
       
    30     ## ipv4-address.h: ns3::Ipv4MaskChecker [class]
       
    31     module.add_class('Ipv4MaskChecker', parent=root_module['ns3::AttributeChecker'])
       
    32     ## ipv4-route.h: ns3::Ipv4Route [class]
       
    33     module.add_class('Ipv4Route')
       
    34     ## ipv4-route.h: ns3::Ipv4MulticastRoute [class]
       
    35     module.add_class('Ipv4MulticastRoute')
       
    36     ## address.h: ns3::AddressChecker [class]
       
    37     module.add_class('AddressChecker', parent=root_module['ns3::AttributeChecker'])
       
    38     ## packet-socket-address.h: ns3::PacketSocketAddress [class]
    38     ## packet-socket-address.h: ns3::PacketSocketAddress [class]
    39     module.add_class('PacketSocketAddress')
    39     module.add_class('PacketSocketAddress')
    40     ## packet-socket-address.h: ns3::PacketSocketAddress [class]
    40     ## packet-socket-address.h: ns3::PacketSocketAddress [class]
    41     root_module['ns3::PacketSocketAddress'].implicitly_converts_to(root_module['ns3::Address'])
    41     root_module['ns3::PacketSocketAddress'].implicitly_converts_to(root_module['ns3::Address'])
       
    42     ## ipv4-address.h: ns3::Ipv4AddressChecker [class]
       
    43     module.add_class('Ipv4AddressChecker', parent=root_module['ns3::AttributeChecker'])
    42     ## ipv4-address.h: ns3::Ipv4AddressValue [class]
    44     ## ipv4-address.h: ns3::Ipv4AddressValue [class]
    43     module.add_class('Ipv4AddressValue', parent=root_module['ns3::AttributeValue'])
    45     module.add_class('Ipv4AddressValue', parent=root_module['ns3::AttributeValue'])
    44     ## ipv4.h: ns3::Ipv4RoutingProtocol [class]
    46     ## ipv4-header.h: ns3::Ipv4Header [class]
    45     module.add_class('Ipv4RoutingProtocol', parent=root_module['ns3::Object'])
    47     module.add_class('Ipv4Header', parent=root_module['ns3::Header'])
       
    48     ## ipv4-address.h: ns3::Ipv4MaskChecker [class]
       
    49     module.add_class('Ipv4MaskChecker', parent=root_module['ns3::AttributeChecker'])
       
    50     ## ipv4-address.h: ns3::Ipv4MaskValue [class]
       
    51     module.add_class('Ipv4MaskValue', parent=root_module['ns3::AttributeValue'])
       
    52     ## llc-snap-header.h: ns3::LlcSnapHeader [class]
       
    53     module.add_class('LlcSnapHeader', parent=root_module['ns3::Header'])
       
    54     ## mac48-address.h: ns3::Mac48AddressChecker [class]
       
    55     module.add_class('Mac48AddressChecker', parent=root_module['ns3::AttributeChecker'])
    46     ## mac48-address.h: ns3::Mac48AddressValue [class]
    56     ## mac48-address.h: ns3::Mac48AddressValue [class]
    47     module.add_class('Mac48AddressValue', parent=root_module['ns3::AttributeValue'])
    57     module.add_class('Mac48AddressValue', parent=root_module['ns3::AttributeValue'])
    48     ## ipv4-address.h: ns3::Ipv4MaskValue [class]
       
    49     module.add_class('Ipv4MaskValue', parent=root_module['ns3::AttributeValue'])
       
    50     ## socket.h: ns3::SocketAddressTag [class]
       
    51     module.add_class('SocketAddressTag', parent=root_module['ns3::Tag'])
       
    52     ## inet-socket-address.h: ns3::InetSocketAddress [class]
       
    53     module.add_class('InetSocketAddress')
       
    54     ## inet-socket-address.h: ns3::InetSocketAddress [class]
       
    55     root_module['ns3::InetSocketAddress'].implicitly_converts_to(root_module['ns3::Address'])
       
    56     ## ipv4-address.h: ns3::Ipv4Address [class]
       
    57     module.add_class('Ipv4Address')
       
    58     ## ipv4-address.h: ns3::Ipv4Address [class]
       
    59     root_module['ns3::Ipv4Address'].implicitly_converts_to(root_module['ns3::Address'])
       
    60     ## application.h: ns3::Application [class]
       
    61     module.add_class('Application', parent=root_module['ns3::Object'])
       
    62     ## queue.h: ns3::Queue [class]
    58     ## queue.h: ns3::Queue [class]
    63     module.add_class('Queue', parent=root_module['ns3::Object'])
    59     module.add_class('Queue', parent=root_module['ns3::Object'])
    64     ## socket.h: ns3::Socket [class]
    60     ## socket.h: ns3::Socket [class]
    65     module.add_class('Socket', parent=root_module['ns3::Object'])
    61     module.add_class('Socket', parent=root_module['ns3::Object'])
    66     ## socket.h: ns3::Socket::SocketErrno [enumeration]
    62     ## socket.h: ns3::Socket::SocketErrno [enumeration]
    67     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'])
    63     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'])
    68     ## ipv4-header.h: ns3::Ipv4Header [class]
    64     ## socket.h: ns3::SocketAddressTag [class]
    69     module.add_class('Ipv4Header', parent=root_module['ns3::Header'])
    65     module.add_class('SocketAddressTag', parent=root_module['ns3::Tag'])
       
    66     ## socket-factory.h: ns3::SocketFactory [class]
       
    67     module.add_class('SocketFactory', parent=root_module['ns3::Object'])
       
    68     ## socket.h: ns3::SocketIpTtlTag [class]
       
    69     module.add_class('SocketIpTtlTag', parent=root_module['ns3::Tag'])
       
    70     ## tcp-socket.h: ns3::TcpSocket [class]
       
    71     module.add_class('TcpSocket', parent=root_module['ns3::Socket'])
       
    72     ## tcp-socket-factory.h: ns3::TcpSocketFactory [class]
       
    73     module.add_class('TcpSocketFactory', parent=root_module['ns3::SocketFactory'])
    70     ## udp-socket.h: ns3::UdpSocket [class]
    74     ## udp-socket.h: ns3::UdpSocket [class]
    71     module.add_class('UdpSocket', parent=root_module['ns3::Socket'])
    75     module.add_class('UdpSocket', parent=root_module['ns3::Socket'])
       
    76     ## udp-socket-factory.h: ns3::UdpSocketFactory [class]
       
    77     module.add_class('UdpSocketFactory', parent=root_module['ns3::SocketFactory'])
       
    78     ## address.h: ns3::AddressChecker [class]
       
    79     module.add_class('AddressChecker', parent=root_module['ns3::AttributeChecker'])
       
    80     ## address.h: ns3::AddressValue [class]
       
    81     module.add_class('AddressValue', parent=root_module['ns3::AttributeValue'])
       
    82     ## application.h: ns3::Application [class]
       
    83     module.add_class('Application', parent=root_module['ns3::Object'])
       
    84     ## channel.h: ns3::Channel [class]
       
    85     module.add_class('Channel', parent=root_module['ns3::Object'])
       
    86     ## drop-tail-queue.h: ns3::DropTailQueue [class]
       
    87     module.add_class('DropTailQueue', parent=root_module['ns3::Queue'])
       
    88     ## ethernet-header.h: ns3::EthernetHeader [class]
       
    89     module.add_class('EthernetHeader', parent=root_module['ns3::Header'])
       
    90     ## ethernet-trailer.h: ns3::EthernetTrailer [class]
       
    91     module.add_class('EthernetTrailer', parent=root_module['ns3::Trailer'])
       
    92     ## ipv4.h: ns3::Ipv4 [class]
       
    93     module.add_class('Ipv4', parent=root_module['ns3::Object'])
       
    94     ## ipv4.h: ns3::Ipv4RoutingProtocol [class]
       
    95     module.add_class('Ipv4RoutingProtocol', parent=root_module['ns3::Object'])
    72     ## net-device.h: ns3::NetDevice [class]
    96     ## net-device.h: ns3::NetDevice [class]
    73     module.add_class('NetDevice', parent=root_module['ns3::Object'])
    97     module.add_class('NetDevice', parent=root_module['ns3::Object'])
    74     ## net-device.h: ns3::NetDevice::PacketType [enumeration]
    98     ## net-device.h: ns3::NetDevice::PacketType [enumeration]
    75     module.add_enum('PacketType', ['PACKET_HOST', 'PACKET_BROADCAST', 'PACKET_MULTICAST', 'PACKET_OTHERHOST'], outer_class=root_module['ns3::NetDevice'])
    99     module.add_enum('PacketType', ['PACKET_HOST', 'PACKET_BROADCAST', 'PACKET_MULTICAST', 'PACKET_OTHERHOST'], outer_class=root_module['ns3::NetDevice'])
    76     ## drop-tail-queue.h: ns3::DropTailQueue [class]
       
    77     module.add_class('DropTailQueue', parent=root_module['ns3::Queue'])
       
    78     ## address.h: ns3::AddressValue [class]
       
    79     module.add_class('AddressValue', parent=root_module['ns3::AttributeValue'])
       
    80     ## node.h: ns3::Node [class]
   100     ## node.h: ns3::Node [class]
    81     module.add_class('Node', parent=root_module['ns3::Object'])
   101     module.add_class('Node', parent=root_module['ns3::Object'])
    82     ## channel.h: ns3::Channel [class]
   102     ## packet-socket-factory.h: ns3::PacketSocketFactory [class]
    83     module.add_class('Channel', parent=root_module['ns3::Object'])
   103     module.add_class('PacketSocketFactory', parent=root_module['ns3::SocketFactory'])
    84     ## tcp-socket.h: ns3::TcpSocket [class]
       
    85     module.add_class('TcpSocket', parent=root_module['ns3::Socket'])
       
    86     ## ethernet-header.h: ns3::EthernetHeader [class]
       
    87     module.add_class('EthernetHeader', parent=root_module['ns3::Header'])
       
    88     ## socket.h: ns3::SocketIpTtlTag [class]
       
    89     module.add_class('SocketIpTtlTag', parent=root_module['ns3::Tag'])
       
    90     ## ipv4.h: ns3::Ipv4 [class]
       
    91     module.add_class('Ipv4', parent=root_module['ns3::Object'])
       
    92     ## socket-factory.h: ns3::SocketFactory [class]
       
    93     module.add_class('SocketFactory', parent=root_module['ns3::Object'])
       
    94     ## ethernet-trailer.h: ns3::EthernetTrailer [class]
       
    95     module.add_class('EthernetTrailer', parent=root_module['ns3::Trailer'])
       
    96     ## simple-channel.h: ns3::SimpleChannel [class]
   104     ## simple-channel.h: ns3::SimpleChannel [class]
    97     module.add_class('SimpleChannel', parent=root_module['ns3::Channel'])
   105     module.add_class('SimpleChannel', parent=root_module['ns3::Channel'])
    98     ## llc-snap-header.h: ns3::LlcSnapHeader [class]
       
    99     module.add_class('LlcSnapHeader', parent=root_module['ns3::Header'])
       
   100     ## udp-socket-factory.h: ns3::UdpSocketFactory [class]
       
   101     module.add_class('UdpSocketFactory', parent=root_module['ns3::SocketFactory'])
       
   102     ## simple-net-device.h: ns3::SimpleNetDevice [class]
   106     ## simple-net-device.h: ns3::SimpleNetDevice [class]
   103     module.add_class('SimpleNetDevice', parent=root_module['ns3::NetDevice'])
   107     module.add_class('SimpleNetDevice', parent=root_module['ns3::NetDevice'])
   104     ## tcp-socket-factory.h: ns3::TcpSocketFactory [class]
       
   105     module.add_class('TcpSocketFactory', parent=root_module['ns3::SocketFactory'])
       
   106     ## packet-socket-factory.h: ns3::PacketSocketFactory [class]
       
   107     module.add_class('PacketSocketFactory', parent=root_module['ns3::SocketFactory'])
       
   108     
   108     
   109     ## Register a nested module for the namespace internal
   109     ## Register a nested module for the namespace internal
   110     
   110     
   111     nested_module = module.add_cpp_namespace('internal')
   111     nested_module = module.add_cpp_namespace('internal')
   112     register_types_ns3_internal(nested_module)
   112     register_types_ns3_internal(nested_module)
   143     
   143     
   144 
   144 
   145 def register_types_ns3_olsr(module):
   145 def register_types_ns3_olsr(module):
   146     root_module = module.get_root()
   146     root_module = module.get_root()
   147     
   147     
       
   148     module.add_container('std::vector< ns3::Ipv4Address >', 'ns3::Ipv4Address', container_type='vector')
   148 
   149 
   149 def register_methods(root_module):
   150 def register_methods(root_module):
       
   151     register_Ns3Address_methods(root_module, root_module['ns3::Address'])
       
   152     register_Ns3InetSocketAddress_methods(root_module, root_module['ns3::InetSocketAddress'])
       
   153     register_Ns3Ipv4Address_methods(root_module, root_module['ns3::Ipv4Address'])
       
   154     register_Ns3Ipv4AddressGenerator_methods(root_module, root_module['ns3::Ipv4AddressGenerator'])
   150     register_Ns3Ipv4Mask_methods(root_module, root_module['ns3::Ipv4Mask'])
   155     register_Ns3Ipv4Mask_methods(root_module, root_module['ns3::Ipv4Mask'])
   151     register_Ns3NodeList_methods(root_module, root_module['ns3::NodeList'])
   156     register_Ns3Ipv4MulticastRoute_methods(root_module, root_module['ns3::Ipv4MulticastRoute'])
   152     register_Ns3Address_methods(root_module, root_module['ns3::Address'])
   157     register_Ns3Ipv4Route_methods(root_module, root_module['ns3::Ipv4Route'])
   153     register_Ns3Ipv4AddressChecker_methods(root_module, root_module['ns3::Ipv4AddressChecker'])
       
   154     register_Ns3Mac48Address_methods(root_module, root_module['ns3::Mac48Address'])
   158     register_Ns3Mac48Address_methods(root_module, root_module['ns3::Mac48Address'])
   155     register_Ns3Mac64Address_methods(root_module, root_module['ns3::Mac64Address'])
   159     register_Ns3Mac64Address_methods(root_module, root_module['ns3::Mac64Address'])
   156     register_Ns3Ipv4AddressGenerator_methods(root_module, root_module['ns3::Ipv4AddressGenerator'])
   160     register_Ns3NodeList_methods(root_module, root_module['ns3::NodeList'])
       
   161     register_Ns3PacketSocketAddress_methods(root_module, root_module['ns3::PacketSocketAddress'])
       
   162     register_Ns3Ipv4AddressChecker_methods(root_module, root_module['ns3::Ipv4AddressChecker'])
       
   163     register_Ns3Ipv4AddressValue_methods(root_module, root_module['ns3::Ipv4AddressValue'])
       
   164     register_Ns3Ipv4Header_methods(root_module, root_module['ns3::Ipv4Header'])
       
   165     register_Ns3Ipv4MaskChecker_methods(root_module, root_module['ns3::Ipv4MaskChecker'])
       
   166     register_Ns3Ipv4MaskValue_methods(root_module, root_module['ns3::Ipv4MaskValue'])
       
   167     register_Ns3LlcSnapHeader_methods(root_module, root_module['ns3::LlcSnapHeader'])
   157     register_Ns3Mac48AddressChecker_methods(root_module, root_module['ns3::Mac48AddressChecker'])
   168     register_Ns3Mac48AddressChecker_methods(root_module, root_module['ns3::Mac48AddressChecker'])
   158     register_Ns3Ipv4MaskChecker_methods(root_module, root_module['ns3::Ipv4MaskChecker'])
       
   159     register_Ns3Ipv4Route_methods(root_module, root_module['ns3::Ipv4Route'])
       
   160     register_Ns3Ipv4MulticastRoute_methods(root_module, root_module['ns3::Ipv4MulticastRoute'])
       
   161     register_Ns3AddressChecker_methods(root_module, root_module['ns3::AddressChecker'])
       
   162     register_Ns3PacketSocketAddress_methods(root_module, root_module['ns3::PacketSocketAddress'])
       
   163     register_Ns3Ipv4AddressValue_methods(root_module, root_module['ns3::Ipv4AddressValue'])
       
   164     register_Ns3Ipv4RoutingProtocol_methods(root_module, root_module['ns3::Ipv4RoutingProtocol'])
       
   165     register_Ns3Mac48AddressValue_methods(root_module, root_module['ns3::Mac48AddressValue'])
   169     register_Ns3Mac48AddressValue_methods(root_module, root_module['ns3::Mac48AddressValue'])
   166     register_Ns3Ipv4MaskValue_methods(root_module, root_module['ns3::Ipv4MaskValue'])
       
   167     register_Ns3SocketAddressTag_methods(root_module, root_module['ns3::SocketAddressTag'])
       
   168     register_Ns3InetSocketAddress_methods(root_module, root_module['ns3::InetSocketAddress'])
       
   169     register_Ns3Ipv4Address_methods(root_module, root_module['ns3::Ipv4Address'])
       
   170     register_Ns3Application_methods(root_module, root_module['ns3::Application'])
       
   171     register_Ns3Queue_methods(root_module, root_module['ns3::Queue'])
   170     register_Ns3Queue_methods(root_module, root_module['ns3::Queue'])
   172     register_Ns3Socket_methods(root_module, root_module['ns3::Socket'])
   171     register_Ns3Socket_methods(root_module, root_module['ns3::Socket'])
   173     register_Ns3Ipv4Header_methods(root_module, root_module['ns3::Ipv4Header'])
   172     register_Ns3SocketAddressTag_methods(root_module, root_module['ns3::SocketAddressTag'])
       
   173     register_Ns3SocketFactory_methods(root_module, root_module['ns3::SocketFactory'])
       
   174     register_Ns3SocketIpTtlTag_methods(root_module, root_module['ns3::SocketIpTtlTag'])
       
   175     register_Ns3TcpSocket_methods(root_module, root_module['ns3::TcpSocket'])
       
   176     register_Ns3TcpSocketFactory_methods(root_module, root_module['ns3::TcpSocketFactory'])
   174     register_Ns3UdpSocket_methods(root_module, root_module['ns3::UdpSocket'])
   177     register_Ns3UdpSocket_methods(root_module, root_module['ns3::UdpSocket'])
       
   178     register_Ns3UdpSocketFactory_methods(root_module, root_module['ns3::UdpSocketFactory'])
       
   179     register_Ns3AddressChecker_methods(root_module, root_module['ns3::AddressChecker'])
       
   180     register_Ns3AddressValue_methods(root_module, root_module['ns3::AddressValue'])
       
   181     register_Ns3Application_methods(root_module, root_module['ns3::Application'])
       
   182     register_Ns3Channel_methods(root_module, root_module['ns3::Channel'])
       
   183     register_Ns3DropTailQueue_methods(root_module, root_module['ns3::DropTailQueue'])
       
   184     register_Ns3EthernetHeader_methods(root_module, root_module['ns3::EthernetHeader'])
       
   185     register_Ns3EthernetTrailer_methods(root_module, root_module['ns3::EthernetTrailer'])
       
   186     register_Ns3Ipv4_methods(root_module, root_module['ns3::Ipv4'])
       
   187     register_Ns3Ipv4RoutingProtocol_methods(root_module, root_module['ns3::Ipv4RoutingProtocol'])
   175     register_Ns3NetDevice_methods(root_module, root_module['ns3::NetDevice'])
   188     register_Ns3NetDevice_methods(root_module, root_module['ns3::NetDevice'])
   176     register_Ns3DropTailQueue_methods(root_module, root_module['ns3::DropTailQueue'])
       
   177     register_Ns3AddressValue_methods(root_module, root_module['ns3::AddressValue'])
       
   178     register_Ns3Node_methods(root_module, root_module['ns3::Node'])
   189     register_Ns3Node_methods(root_module, root_module['ns3::Node'])
   179     register_Ns3Channel_methods(root_module, root_module['ns3::Channel'])
   190     register_Ns3PacketSocketFactory_methods(root_module, root_module['ns3::PacketSocketFactory'])
   180     register_Ns3TcpSocket_methods(root_module, root_module['ns3::TcpSocket'])
       
   181     register_Ns3EthernetHeader_methods(root_module, root_module['ns3::EthernetHeader'])
       
   182     register_Ns3SocketIpTtlTag_methods(root_module, root_module['ns3::SocketIpTtlTag'])
       
   183     register_Ns3Ipv4_methods(root_module, root_module['ns3::Ipv4'])
       
   184     register_Ns3SocketFactory_methods(root_module, root_module['ns3::SocketFactory'])
       
   185     register_Ns3EthernetTrailer_methods(root_module, root_module['ns3::EthernetTrailer'])
       
   186     register_Ns3SimpleChannel_methods(root_module, root_module['ns3::SimpleChannel'])
   191     register_Ns3SimpleChannel_methods(root_module, root_module['ns3::SimpleChannel'])
   187     register_Ns3LlcSnapHeader_methods(root_module, root_module['ns3::LlcSnapHeader'])
       
   188     register_Ns3UdpSocketFactory_methods(root_module, root_module['ns3::UdpSocketFactory'])
       
   189     register_Ns3SimpleNetDevice_methods(root_module, root_module['ns3::SimpleNetDevice'])
   192     register_Ns3SimpleNetDevice_methods(root_module, root_module['ns3::SimpleNetDevice'])
   190     register_Ns3TcpSocketFactory_methods(root_module, root_module['ns3::TcpSocketFactory'])
   193     return
   191     register_Ns3PacketSocketFactory_methods(root_module, root_module['ns3::PacketSocketFactory'])
   194 
   192     return
   195 def register_Ns3Address_methods(root_module, cls):
   193 
   196     cls.add_binary_comparison_operator('!=')
   194 def register_Ns3Ipv4Mask_methods(root_module, cls):
   197     cls.add_binary_comparison_operator('<')
   195     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor]
       
   196     cls.add_constructor([param('ns3::Ipv4Mask const &', 'arg0')])
       
   197     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask() [constructor]
       
   198     cls.add_constructor([])
       
   199     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(uint32_t mask) [constructor]
       
   200     cls.add_constructor([param('uint32_t', 'mask')])
       
   201     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(char const * mask) [constructor]
       
   202     cls.add_constructor([param('char const *', 'mask')])
       
   203     ## ipv4-address.h: uint32_t ns3::Ipv4Mask::Get() const [member function]
       
   204     cls.add_method('Get', 
       
   205                    'uint32_t', 
       
   206                    [], 
       
   207                    is_const=True)
       
   208     ## ipv4-address.h: uint32_t ns3::Ipv4Mask::GetInverse() const [member function]
       
   209     cls.add_method('GetInverse', 
       
   210                    'uint32_t', 
       
   211                    [], 
       
   212                    is_const=True)
       
   213     ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetLoopback() [member function]
       
   214     cls.add_method('GetLoopback', 
       
   215                    'ns3::Ipv4Mask', 
       
   216                    [], 
       
   217                    is_static=True)
       
   218     ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetZero() [member function]
       
   219     cls.add_method('GetZero', 
       
   220                    'ns3::Ipv4Mask', 
       
   221                    [], 
       
   222                    is_static=True)
       
   223     ## ipv4-address.h: bool ns3::Ipv4Mask::IsEqual(ns3::Ipv4Mask other) const [member function]
       
   224     cls.add_method('IsEqual', 
       
   225                    'bool', 
       
   226                    [param('ns3::Ipv4Mask', 'other')], 
       
   227                    is_const=True)
       
   228     ## ipv4-address.h: bool ns3::Ipv4Mask::IsMatch(ns3::Ipv4Address a, ns3::Ipv4Address b) const [member function]
       
   229     cls.add_method('IsMatch', 
       
   230                    'bool', 
       
   231                    [param('ns3::Ipv4Address', 'a'), param('ns3::Ipv4Address', 'b')], 
       
   232                    is_const=True)
       
   233     ## ipv4-address.h: void ns3::Ipv4Mask::Print(std::ostream & os) const [member function]
       
   234     cls.add_method('Print', 
       
   235                    'void', 
       
   236                    [param('std::ostream &', 'os')], 
       
   237                    is_const=True)
       
   238     ## ipv4-address.h: void ns3::Ipv4Mask::Set(uint32_t mask) [member function]
       
   239     cls.add_method('Set', 
       
   240                    'void', 
       
   241                    [param('uint32_t', 'mask')])
       
   242     cls.add_output_stream_operator()
   198     cls.add_output_stream_operator()
   243     return
   199     cls.add_binary_comparison_operator('==')
   244 
       
   245 def register_Ns3NodeList_methods(root_module, cls):
       
   246     ## node-list.h: ns3::NodeList::NodeList(ns3::NodeList const & arg0) [copy constructor]
       
   247     cls.add_constructor([param('ns3::NodeList const &', 'arg0')])
       
   248     ## node-list.h: ns3::NodeList::NodeList() [constructor]
       
   249     cls.add_constructor([])
       
   250     ## node-list.h: static uint32_t ns3::NodeList::Add(ns3::Ptr<ns3::Node> node) [member function]
       
   251     cls.add_method('Add', 
       
   252                    'uint32_t', 
       
   253                    [param('ns3::Ptr< ns3::Node >', 'node')], 
       
   254                    is_static=True)
       
   255     ## 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]
       
   256     cls.add_method('Begin', 
       
   257                    '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node > > >', 
       
   258                    [], 
       
   259                    is_static=True)
       
   260     ## 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]
       
   261     cls.add_method('End', 
       
   262                    '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node > > >', 
       
   263                    [], 
       
   264                    is_static=True)
       
   265     ## node-list.h: static ns3::Ptr<ns3::Node> ns3::NodeList::GetNode(uint32_t n) [member function]
       
   266     cls.add_method('GetNode', 
       
   267                    'ns3::Ptr< ns3::Node >', 
       
   268                    [param('uint32_t', 'n')], 
       
   269                    is_static=True)
       
   270     ## node-list.h: static uint32_t ns3::NodeList::GetNNodes() [member function]
       
   271     cls.add_method('GetNNodes', 
       
   272                    'uint32_t', 
       
   273                    [], 
       
   274                    is_static=True)
       
   275     return
       
   276 
       
   277 def register_Ns3Address_methods(root_module, cls):
       
   278     ## address.h: ns3::Address::Address() [constructor]
   200     ## address.h: ns3::Address::Address() [constructor]
   279     cls.add_constructor([])
   201     cls.add_constructor([])
   280     ## address.h: ns3::Address::Address(uint8_t type, uint8_t const * buffer, uint8_t len) [constructor]
   202     ## address.h: ns3::Address::Address(uint8_t type, uint8_t const * buffer, uint8_t len) [constructor]
   281     cls.add_constructor([param('uint8_t', 'type'), param('uint8_t const *', 'buffer'), param('uint8_t', 'len')])
   203     cls.add_constructor([param('uint8_t', 'type'), param('uint8_t const *', 'buffer'), param('uint8_t', 'len')])
   282     ## address.h: ns3::Address::Address(ns3::Address const & address) [copy constructor]
   204     ## address.h: ns3::Address::Address(ns3::Address const & address) [copy constructor]
   336     ## address.h: void ns3::Address::Serialize(ns3::TagBuffer buffer) const [member function]
   258     ## address.h: void ns3::Address::Serialize(ns3::TagBuffer buffer) const [member function]
   337     cls.add_method('Serialize', 
   259     cls.add_method('Serialize', 
   338                    'void', 
   260                    'void', 
   339                    [param('ns3::TagBuffer', 'buffer')], 
   261                    [param('ns3::TagBuffer', 'buffer')], 
   340                    is_const=True)
   262                    is_const=True)
   341     cls.add_output_stream_operator()
       
   342     return
       
   343 
       
   344 def register_Ns3Ipv4AddressChecker_methods(root_module, cls):
       
   345     ## ipv4-address.h: ns3::Ipv4AddressChecker::Ipv4AddressChecker(ns3::Ipv4AddressChecker const & arg0) [copy constructor]
       
   346     cls.add_constructor([param('ns3::Ipv4AddressChecker const &', 'arg0')])
       
   347     ## ipv4-address.h: ns3::Ipv4AddressChecker::Ipv4AddressChecker() [constructor]
       
   348     cls.add_constructor([])
       
   349     return
       
   350 
       
   351 def register_Ns3Mac48Address_methods(root_module, cls):
       
   352     ## mac48-address.h: ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [copy constructor]
       
   353     cls.add_constructor([param('ns3::Mac48Address const &', 'arg0')])
       
   354     ## mac48-address.h: ns3::Mac48Address::Mac48Address() [constructor]
       
   355     cls.add_constructor([])
       
   356     ## mac48-address.h: ns3::Mac48Address::Mac48Address(char const * str) [constructor]
       
   357     cls.add_constructor([param('char const *', 'str')])
       
   358     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::Allocate() [member function]
       
   359     cls.add_method('Allocate', 
       
   360                    'ns3::Mac48Address', 
       
   361                    [], 
       
   362                    is_static=True)
       
   363     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::ConvertFrom(ns3::Address const & address) [member function]
       
   364     cls.add_method('ConvertFrom', 
       
   365                    'ns3::Mac48Address', 
       
   366                    [param('ns3::Address const &', 'address')], 
       
   367                    is_static=True)
       
   368     ## mac48-address.h: void ns3::Mac48Address::CopyFrom(uint8_t const * buffer) [member function]
       
   369     cls.add_method('CopyFrom', 
       
   370                    'void', 
       
   371                    [param('uint8_t const *', 'buffer')])
       
   372     ## mac48-address.h: void ns3::Mac48Address::CopyTo(uint8_t * buffer) const [member function]
       
   373     cls.add_method('CopyTo', 
       
   374                    'void', 
       
   375                    [param('uint8_t *', 'buffer')], 
       
   376                    is_const=True)
       
   377     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetBroadcast() [member function]
       
   378     cls.add_method('GetBroadcast', 
       
   379                    'ns3::Mac48Address', 
       
   380                    [], 
       
   381                    is_static=True)
       
   382     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetMulticast(ns3::Ipv4Address address) [member function]
       
   383     cls.add_method('GetMulticast', 
       
   384                    'ns3::Mac48Address', 
       
   385                    [param('ns3::Ipv4Address', 'address')], 
       
   386                    is_static=True)
       
   387     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetMulticastPrefix() [member function]
       
   388     cls.add_method('GetMulticastPrefix', 
       
   389                    'ns3::Mac48Address', 
       
   390                    [], 
       
   391                    is_static=True)
       
   392     ## mac48-address.h: bool ns3::Mac48Address::IsBroadcast() const [member function]
       
   393     cls.add_method('IsBroadcast', 
       
   394                    'bool', 
       
   395                    [], 
       
   396                    is_const=True)
       
   397     ## mac48-address.h: bool ns3::Mac48Address::IsGroup() const [member function]
       
   398     cls.add_method('IsGroup', 
       
   399                    'bool', 
       
   400                    [], 
       
   401                    is_const=True)
       
   402     ## mac48-address.h: static bool ns3::Mac48Address::IsMatchingType(ns3::Address const & address) [member function]
       
   403     cls.add_method('IsMatchingType', 
       
   404                    'bool', 
       
   405                    [param('ns3::Address const &', 'address')], 
       
   406                    is_static=True)
       
   407     ## mac48-address.h: bool ns3::Mac48Address::IsMulticast() const [member function]
       
   408     cls.add_method('IsMulticast', 
       
   409                    'bool', 
       
   410                    [], 
       
   411                    is_const=True)
       
   412     cls.add_output_stream_operator()
       
   413     return
       
   414 
       
   415 def register_Ns3Mac64Address_methods(root_module, cls):
       
   416     ## mac64-address.h: ns3::Mac64Address::Mac64Address(ns3::Mac64Address const & arg0) [copy constructor]
       
   417     cls.add_constructor([param('ns3::Mac64Address const &', 'arg0')])
       
   418     ## mac64-address.h: ns3::Mac64Address::Mac64Address() [constructor]
       
   419     cls.add_constructor([])
       
   420     ## mac64-address.h: ns3::Mac64Address::Mac64Address(char const * str) [constructor]
       
   421     cls.add_constructor([param('char const *', 'str')])
       
   422     ## mac64-address.h: static ns3::Mac64Address ns3::Mac64Address::Allocate() [member function]
       
   423     cls.add_method('Allocate', 
       
   424                    'ns3::Mac64Address', 
       
   425                    [], 
       
   426                    is_static=True)
       
   427     ## mac64-address.h: static ns3::Mac64Address ns3::Mac64Address::ConvertFrom(ns3::Address const & address) [member function]
       
   428     cls.add_method('ConvertFrom', 
       
   429                    'ns3::Mac64Address', 
       
   430                    [param('ns3::Address const &', 'address')], 
       
   431                    is_static=True)
       
   432     ## mac64-address.h: void ns3::Mac64Address::CopyFrom(uint8_t const * buffer) [member function]
       
   433     cls.add_method('CopyFrom', 
       
   434                    'void', 
       
   435                    [param('uint8_t const *', 'buffer')])
       
   436     ## mac64-address.h: void ns3::Mac64Address::CopyTo(uint8_t * buffer) const [member function]
       
   437     cls.add_method('CopyTo', 
       
   438                    'void', 
       
   439                    [param('uint8_t *', 'buffer')], 
       
   440                    is_const=True)
       
   441     ## mac64-address.h: static bool ns3::Mac64Address::IsMatchingType(ns3::Address const & address) [member function]
       
   442     cls.add_method('IsMatchingType', 
       
   443                    'bool', 
       
   444                    [param('ns3::Address const &', 'address')], 
       
   445                    is_static=True)
       
   446     cls.add_output_stream_operator()
       
   447     return
       
   448 
       
   449 def register_Ns3Ipv4AddressGenerator_methods(root_module, cls):
       
   450     ## ipv4-address-generator.h: ns3::Ipv4AddressGenerator::Ipv4AddressGenerator(ns3::Ipv4AddressGenerator const & arg0) [copy constructor]
       
   451     cls.add_constructor([param('ns3::Ipv4AddressGenerator const &', 'arg0')])
       
   452     ## ipv4-address-generator.h: ns3::Ipv4AddressGenerator::Ipv4AddressGenerator() [constructor]
       
   453     cls.add_constructor([])
       
   454     ## 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]
       
   455     cls.add_method('Init', 
       
   456                    'void', 
       
   457                    [param('ns3::Ipv4Address const', 'net'), param('ns3::Ipv4Mask const', 'mask'), param('ns3::Ipv4Address const', 'addr', default_value='"0.0.0.1"')], 
       
   458                    is_static=True)
       
   459     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::NextNetwork(ns3::Ipv4Mask const mask) [member function]
       
   460     cls.add_method('NextNetwork', 
       
   461                    'ns3::Ipv4Address', 
       
   462                    [param('ns3::Ipv4Mask const', 'mask')], 
       
   463                    is_static=True)
       
   464     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::GetNetwork(ns3::Ipv4Mask const mask) [member function]
       
   465     cls.add_method('GetNetwork', 
       
   466                    'ns3::Ipv4Address', 
       
   467                    [param('ns3::Ipv4Mask const', 'mask')], 
       
   468                    is_static=True)
       
   469     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::InitAddress(ns3::Ipv4Address const addr, ns3::Ipv4Mask const mask) [member function]
       
   470     cls.add_method('InitAddress', 
       
   471                    'void', 
       
   472                    [param('ns3::Ipv4Address const', 'addr'), param('ns3::Ipv4Mask const', 'mask')], 
       
   473                    is_static=True)
       
   474     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::NextAddress(ns3::Ipv4Mask const mask) [member function]
       
   475     cls.add_method('NextAddress', 
       
   476                    'ns3::Ipv4Address', 
       
   477                    [param('ns3::Ipv4Mask const', 'mask')], 
       
   478                    is_static=True)
       
   479     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::GetAddress(ns3::Ipv4Mask const mask) [member function]
       
   480     cls.add_method('GetAddress', 
       
   481                    'ns3::Ipv4Address', 
       
   482                    [param('ns3::Ipv4Mask const', 'mask')], 
       
   483                    is_static=True)
       
   484     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::Reset() [member function]
       
   485     cls.add_method('Reset', 
       
   486                    'void', 
       
   487                    [], 
       
   488                    is_static=True)
       
   489     ## ipv4-address-generator.h: static bool ns3::Ipv4AddressGenerator::AddAllocated(ns3::Ipv4Address const addr) [member function]
       
   490     cls.add_method('AddAllocated', 
       
   491                    'bool', 
       
   492                    [param('ns3::Ipv4Address const', 'addr')], 
       
   493                    is_static=True)
       
   494     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::TestMode() [member function]
       
   495     cls.add_method('TestMode', 
       
   496                    'void', 
       
   497                    [], 
       
   498                    is_static=True)
       
   499     return
       
   500 
       
   501 def register_Ns3Mac48AddressChecker_methods(root_module, cls):
       
   502     ## mac48-address.h: ns3::Mac48AddressChecker::Mac48AddressChecker(ns3::Mac48AddressChecker const & arg0) [copy constructor]
       
   503     cls.add_constructor([param('ns3::Mac48AddressChecker const &', 'arg0')])
       
   504     ## mac48-address.h: ns3::Mac48AddressChecker::Mac48AddressChecker() [constructor]
       
   505     cls.add_constructor([])
       
   506     return
       
   507 
       
   508 def register_Ns3Ipv4MaskChecker_methods(root_module, cls):
       
   509     ## ipv4-address.h: ns3::Ipv4MaskChecker::Ipv4MaskChecker(ns3::Ipv4MaskChecker const & arg0) [copy constructor]
       
   510     cls.add_constructor([param('ns3::Ipv4MaskChecker const &', 'arg0')])
       
   511     ## ipv4-address.h: ns3::Ipv4MaskChecker::Ipv4MaskChecker() [constructor]
       
   512     cls.add_constructor([])
       
   513     return
       
   514 
       
   515 def register_Ns3Ipv4Route_methods(root_module, cls):
       
   516     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route() [constructor]
       
   517     cls.add_constructor([])
       
   518     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const & route) [copy constructor]
       
   519     cls.add_constructor([param('ns3::Ipv4Route const &', 'route')])
       
   520     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const * route) [constructor]
       
   521     cls.add_constructor([param('ns3::Ipv4Route const *', 'route')])
       
   522     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateDefaultRoute(ns3::Ipv4Address nextHop, uint32_t interface) [member function]
       
   523     cls.add_method('CreateDefaultRoute', 
       
   524                    'ns3::Ipv4Route', 
       
   525                    [param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], 
       
   526                    is_static=True)
       
   527     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateHostRouteTo(ns3::Ipv4Address dest, ns3::Ipv4Address nextHop, uint32_t interface) [member function]
       
   528     cls.add_method('CreateHostRouteTo', 
       
   529                    'ns3::Ipv4Route', 
       
   530                    [param('ns3::Ipv4Address', 'dest'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], 
       
   531                    is_static=True)
       
   532     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateHostRouteTo(ns3::Ipv4Address dest, uint32_t interface) [member function]
       
   533     cls.add_method('CreateHostRouteTo', 
       
   534                    'ns3::Ipv4Route', 
       
   535                    [param('ns3::Ipv4Address', 'dest'), param('uint32_t', 'interface')], 
       
   536                    is_static=True)
       
   537     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, ns3::Ipv4Address nextHop, uint32_t interface) [member function]
       
   538     cls.add_method('CreateNetworkRouteTo', 
       
   539                    'ns3::Ipv4Route', 
       
   540                    [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], 
       
   541                    is_static=True)
       
   542     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, uint32_t interface) [member function]
       
   543     cls.add_method('CreateNetworkRouteTo', 
       
   544                    'ns3::Ipv4Route', 
       
   545                    [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('uint32_t', 'interface')], 
       
   546                    is_static=True)
       
   547     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetDest() const [member function]
       
   548     cls.add_method('GetDest', 
       
   549                    'ns3::Ipv4Address', 
       
   550                    [], 
       
   551                    is_const=True)
       
   552     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetDestNetwork() const [member function]
       
   553     cls.add_method('GetDestNetwork', 
       
   554                    'ns3::Ipv4Address', 
       
   555                    [], 
       
   556                    is_const=True)
       
   557     ## ipv4-route.h: ns3::Ipv4Mask ns3::Ipv4Route::GetDestNetworkMask() const [member function]
       
   558     cls.add_method('GetDestNetworkMask', 
       
   559                    'ns3::Ipv4Mask', 
       
   560                    [], 
       
   561                    is_const=True)
       
   562     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetGateway() const [member function]
       
   563     cls.add_method('GetGateway', 
       
   564                    'ns3::Ipv4Address', 
       
   565                    [], 
       
   566                    is_const=True)
       
   567     ## ipv4-route.h: uint32_t ns3::Ipv4Route::GetInterface() const [member function]
       
   568     cls.add_method('GetInterface', 
       
   569                    'uint32_t', 
       
   570                    [], 
       
   571                    is_const=True)
       
   572     ## ipv4-route.h: bool ns3::Ipv4Route::IsDefault() const [member function]
       
   573     cls.add_method('IsDefault', 
       
   574                    'bool', 
       
   575                    [], 
       
   576                    is_const=True)
       
   577     ## ipv4-route.h: bool ns3::Ipv4Route::IsGateway() const [member function]
       
   578     cls.add_method('IsGateway', 
       
   579                    'bool', 
       
   580                    [], 
       
   581                    is_const=True)
       
   582     ## ipv4-route.h: bool ns3::Ipv4Route::IsHost() const [member function]
       
   583     cls.add_method('IsHost', 
       
   584                    'bool', 
       
   585                    [], 
       
   586                    is_const=True)
       
   587     ## ipv4-route.h: bool ns3::Ipv4Route::IsNetwork() const [member function]
       
   588     cls.add_method('IsNetwork', 
       
   589                    'bool', 
       
   590                    [], 
       
   591                    is_const=True)
       
   592     cls.add_output_stream_operator()
       
   593     return
       
   594 
       
   595 def register_Ns3Ipv4MulticastRoute_methods(root_module, cls):
       
   596     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute() [constructor]
       
   597     cls.add_constructor([])
       
   598     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const & route) [copy constructor]
       
   599     cls.add_constructor([param('ns3::Ipv4MulticastRoute const &', 'route')])
       
   600     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const * route) [constructor]
       
   601     cls.add_constructor([param('ns3::Ipv4MulticastRoute const *', 'route')])
       
   602     ## 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]
       
   603     cls.add_method('CreateMulticastRoute', 
       
   604                    'ns3::Ipv4MulticastRoute', 
       
   605                    [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int >', 'outputInterfaces')], 
       
   606                    is_static=True)
       
   607     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4MulticastRoute::GetGroup() const [member function]
       
   608     cls.add_method('GetGroup', 
       
   609                    'ns3::Ipv4Address', 
       
   610                    [], 
       
   611                    is_const=True)
       
   612     ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetInputInterface() const [member function]
       
   613     cls.add_method('GetInputInterface', 
       
   614                    'uint32_t', 
       
   615                    [], 
       
   616                    is_const=True)
       
   617     ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetNOutputInterfaces() const [member function]
       
   618     cls.add_method('GetNOutputInterfaces', 
       
   619                    'uint32_t', 
       
   620                    [], 
       
   621                    is_const=True)
       
   622     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4MulticastRoute::GetOrigin() const [member function]
       
   623     cls.add_method('GetOrigin', 
       
   624                    'ns3::Ipv4Address', 
       
   625                    [], 
       
   626                    is_const=True)
       
   627     ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetOutputInterface(uint32_t n) const [member function]
       
   628     cls.add_method('GetOutputInterface', 
       
   629                    'uint32_t', 
       
   630                    [param('uint32_t', 'n')], 
       
   631                    is_const=True)
       
   632     ## ipv4-route.h: std::vector<unsigned int, std::allocator<unsigned int> > ns3::Ipv4MulticastRoute::GetOutputInterfaces() const [member function]
       
   633     cls.add_method('GetOutputInterfaces', 
       
   634                    'std::vector< unsigned int >', 
       
   635                    [], 
       
   636                    is_const=True)
       
   637     cls.add_output_stream_operator()
       
   638     return
       
   639 
       
   640 def register_Ns3AddressChecker_methods(root_module, cls):
       
   641     ## address.h: ns3::AddressChecker::AddressChecker(ns3::AddressChecker const & arg0) [copy constructor]
       
   642     cls.add_constructor([param('ns3::AddressChecker const &', 'arg0')])
       
   643     ## address.h: ns3::AddressChecker::AddressChecker() [constructor]
       
   644     cls.add_constructor([])
       
   645     return
       
   646 
       
   647 def register_Ns3PacketSocketAddress_methods(root_module, cls):
       
   648     ## packet-socket-address.h: ns3::PacketSocketAddress::PacketSocketAddress(ns3::PacketSocketAddress const & arg0) [copy constructor]
       
   649     cls.add_constructor([param('ns3::PacketSocketAddress const &', 'arg0')])
       
   650     ## packet-socket-address.h: ns3::PacketSocketAddress::PacketSocketAddress() [constructor]
       
   651     cls.add_constructor([])
       
   652     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetProtocol(uint16_t protocol) [member function]
       
   653     cls.add_method('SetProtocol', 
       
   654                    'void', 
       
   655                    [param('uint16_t', 'protocol')])
       
   656     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetAllDevices() [member function]
       
   657     cls.add_method('SetAllDevices', 
       
   658                    'void', 
       
   659                    [])
       
   660     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetSingleDevice(uint32_t device) [member function]
       
   661     cls.add_method('SetSingleDevice', 
       
   662                    'void', 
       
   663                    [param('uint32_t', 'device')])
       
   664     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetPhysicalAddress(ns3::Address const address) [member function]
       
   665     cls.add_method('SetPhysicalAddress', 
       
   666                    'void', 
       
   667                    [param('ns3::Address const', 'address')])
       
   668     ## packet-socket-address.h: uint16_t ns3::PacketSocketAddress::GetProtocol() const [member function]
       
   669     cls.add_method('GetProtocol', 
       
   670                    'uint16_t', 
       
   671                    [], 
       
   672                    is_const=True)
       
   673     ## packet-socket-address.h: uint32_t ns3::PacketSocketAddress::GetSingleDevice() const [member function]
       
   674     cls.add_method('GetSingleDevice', 
       
   675                    'uint32_t', 
       
   676                    [], 
       
   677                    is_const=True)
       
   678     ## packet-socket-address.h: bool ns3::PacketSocketAddress::IsSingleDevice() const [member function]
       
   679     cls.add_method('IsSingleDevice', 
       
   680                    'bool', 
       
   681                    [], 
       
   682                    is_const=True)
       
   683     ## packet-socket-address.h: ns3::Address ns3::PacketSocketAddress::GetPhysicalAddress() const [member function]
       
   684     cls.add_method('GetPhysicalAddress', 
       
   685                    'ns3::Address', 
       
   686                    [], 
       
   687                    is_const=True)
       
   688     ## packet-socket-address.h: static ns3::PacketSocketAddress ns3::PacketSocketAddress::ConvertFrom(ns3::Address const & address) [member function]
       
   689     cls.add_method('ConvertFrom', 
       
   690                    'ns3::PacketSocketAddress', 
       
   691                    [param('ns3::Address const &', 'address')], 
       
   692                    is_static=True)
       
   693     ## packet-socket-address.h: static bool ns3::PacketSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
       
   694     cls.add_method('IsMatchingType', 
       
   695                    'bool', 
       
   696                    [param('ns3::Address const &', 'address')], 
       
   697                    is_static=True)
       
   698     return
       
   699 
       
   700 def register_Ns3Ipv4AddressValue_methods(root_module, cls):
       
   701     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4AddressValue const & arg0) [copy constructor]
       
   702     cls.add_constructor([param('ns3::Ipv4AddressValue const &', 'arg0')])
       
   703     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue() [constructor]
       
   704     cls.add_constructor([])
       
   705     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4Address const & value) [constructor]
       
   706     cls.add_constructor([param('ns3::Ipv4Address const &', 'value')])
       
   707     ## ipv4-address.h: void ns3::Ipv4AddressValue::Set(ns3::Ipv4Address const & value) [member function]
       
   708     cls.add_method('Set', 
       
   709                    'void', 
       
   710                    [param('ns3::Ipv4Address const &', 'value')])
       
   711     ## ipv4-address.h: ns3::Ipv4Address ns3::Ipv4AddressValue::Get() const [member function]
       
   712     cls.add_method('Get', 
       
   713                    'ns3::Ipv4Address', 
       
   714                    [], 
       
   715                    is_const=True)
       
   716     ## ipv4-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Ipv4AddressValue::Copy() const [member function]
       
   717     cls.add_method('Copy', 
       
   718                    'ns3::Ptr< ns3::AttributeValue >', 
       
   719                    [], 
       
   720                    is_const=True, is_virtual=True)
       
   721     ## ipv4-address.h: std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
   722     cls.add_method('SerializeToString', 
       
   723                    'std::string', 
       
   724                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
   725                    is_const=True, is_virtual=True)
       
   726     ## ipv4-address.h: bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
   727     cls.add_method('DeserializeFromString', 
       
   728                    'bool', 
       
   729                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
   730                    is_virtual=True)
       
   731     return
       
   732 
       
   733 def register_Ns3Ipv4RoutingProtocol_methods(root_module, cls):
       
   734     ## ipv4.h: ns3::Ipv4RoutingProtocol::IF_INDEX_ANY [variable]
       
   735     cls.add_static_attribute('IF_INDEX_ANY', 'uint32_t const', is_const=True)
       
   736     ## ipv4.h: ns3::Ipv4RoutingProtocol::Ipv4RoutingProtocol(ns3::Ipv4RoutingProtocol const & arg0) [copy constructor]
       
   737     cls.add_constructor([param('ns3::Ipv4RoutingProtocol const &', 'arg0')])
       
   738     ## ipv4.h: ns3::Ipv4RoutingProtocol::Ipv4RoutingProtocol() [constructor]
       
   739     cls.add_constructor([])
       
   740     ## 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]
       
   741     cls.add_method('RequestRoute', 
       
   742                    'bool', 
       
   743                    [param('uint32_t', 'ifIndex'), param('ns3::Ipv4Header const &', 'ipHeader'), 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')], 
       
   744                    is_pure_virtual=True, is_virtual=True)
       
   745     ## ipv4.h: bool ns3::Ipv4RoutingProtocol::RequestIfIndex(ns3::Ipv4Address destination, uint32_t & ifIndex) [member function]
       
   746     cls.add_method('RequestIfIndex', 
       
   747                    'bool', 
       
   748                    [param('ns3::Ipv4Address', 'destination'), param('uint32_t &', 'ifIndex')], 
       
   749                    is_pure_virtual=True, is_virtual=True)
       
   750     return
       
   751 
       
   752 def register_Ns3Mac48AddressValue_methods(root_module, cls):
       
   753     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48AddressValue const & arg0) [copy constructor]
       
   754     cls.add_constructor([param('ns3::Mac48AddressValue const &', 'arg0')])
       
   755     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue() [constructor]
       
   756     cls.add_constructor([])
       
   757     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48Address const & value) [constructor]
       
   758     cls.add_constructor([param('ns3::Mac48Address const &', 'value')])
       
   759     ## mac48-address.h: void ns3::Mac48AddressValue::Set(ns3::Mac48Address const & value) [member function]
       
   760     cls.add_method('Set', 
       
   761                    'void', 
       
   762                    [param('ns3::Mac48Address const &', 'value')])
       
   763     ## mac48-address.h: ns3::Mac48Address ns3::Mac48AddressValue::Get() const [member function]
       
   764     cls.add_method('Get', 
       
   765                    'ns3::Mac48Address', 
       
   766                    [], 
       
   767                    is_const=True)
       
   768     ## mac48-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Mac48AddressValue::Copy() const [member function]
       
   769     cls.add_method('Copy', 
       
   770                    'ns3::Ptr< ns3::AttributeValue >', 
       
   771                    [], 
       
   772                    is_const=True, is_virtual=True)
       
   773     ## mac48-address.h: std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
   774     cls.add_method('SerializeToString', 
       
   775                    'std::string', 
       
   776                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
   777                    is_const=True, is_virtual=True)
       
   778     ## mac48-address.h: bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
   779     cls.add_method('DeserializeFromString', 
       
   780                    'bool', 
       
   781                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
   782                    is_virtual=True)
       
   783     return
       
   784 
       
   785 def register_Ns3Ipv4MaskValue_methods(root_module, cls):
       
   786     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4MaskValue const & arg0) [copy constructor]
       
   787     cls.add_constructor([param('ns3::Ipv4MaskValue const &', 'arg0')])
       
   788     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue() [constructor]
       
   789     cls.add_constructor([])
       
   790     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4Mask const & value) [constructor]
       
   791     cls.add_constructor([param('ns3::Ipv4Mask const &', 'value')])
       
   792     ## ipv4-address.h: void ns3::Ipv4MaskValue::Set(ns3::Ipv4Mask const & value) [member function]
       
   793     cls.add_method('Set', 
       
   794                    'void', 
       
   795                    [param('ns3::Ipv4Mask const &', 'value')])
       
   796     ## ipv4-address.h: ns3::Ipv4Mask ns3::Ipv4MaskValue::Get() const [member function]
       
   797     cls.add_method('Get', 
       
   798                    'ns3::Ipv4Mask', 
       
   799                    [], 
       
   800                    is_const=True)
       
   801     ## ipv4-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Ipv4MaskValue::Copy() const [member function]
       
   802     cls.add_method('Copy', 
       
   803                    'ns3::Ptr< ns3::AttributeValue >', 
       
   804                    [], 
       
   805                    is_const=True, is_virtual=True)
       
   806     ## ipv4-address.h: std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
   807     cls.add_method('SerializeToString', 
       
   808                    'std::string', 
       
   809                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
   810                    is_const=True, is_virtual=True)
       
   811     ## ipv4-address.h: bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
   812     cls.add_method('DeserializeFromString', 
       
   813                    'bool', 
       
   814                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
   815                    is_virtual=True)
       
   816     return
       
   817 
       
   818 def register_Ns3SocketAddressTag_methods(root_module, cls):
       
   819     ## socket.h: ns3::SocketAddressTag::SocketAddressTag(ns3::SocketAddressTag const & arg0) [copy constructor]
       
   820     cls.add_constructor([param('ns3::SocketAddressTag const &', 'arg0')])
       
   821     ## socket.h: ns3::SocketAddressTag::SocketAddressTag() [constructor]
       
   822     cls.add_constructor([])
       
   823     ## socket.h: void ns3::SocketAddressTag::SetAddress(ns3::Address addr) [member function]
       
   824     cls.add_method('SetAddress', 
       
   825                    'void', 
       
   826                    [param('ns3::Address', 'addr')])
       
   827     ## socket.h: ns3::Address ns3::SocketAddressTag::GetAddress() const [member function]
       
   828     cls.add_method('GetAddress', 
       
   829                    'ns3::Address', 
       
   830                    [], 
       
   831                    is_const=True)
       
   832     ## socket.h: static ns3::TypeId ns3::SocketAddressTag::GetTypeId() [member function]
       
   833     cls.add_method('GetTypeId', 
       
   834                    'ns3::TypeId', 
       
   835                    [], 
       
   836                    is_static=True)
       
   837     ## socket.h: ns3::TypeId ns3::SocketAddressTag::GetInstanceTypeId() const [member function]
       
   838     cls.add_method('GetInstanceTypeId', 
       
   839                    'ns3::TypeId', 
       
   840                    [], 
       
   841                    is_const=True, is_virtual=True)
       
   842     ## socket.h: uint32_t ns3::SocketAddressTag::GetSerializedSize() const [member function]
       
   843     cls.add_method('GetSerializedSize', 
       
   844                    'uint32_t', 
       
   845                    [], 
       
   846                    is_const=True, is_virtual=True)
       
   847     ## socket.h: void ns3::SocketAddressTag::Serialize(ns3::TagBuffer i) const [member function]
       
   848     cls.add_method('Serialize', 
       
   849                    'void', 
       
   850                    [param('ns3::TagBuffer', 'i')], 
       
   851                    is_const=True, is_virtual=True)
       
   852     ## socket.h: void ns3::SocketAddressTag::Deserialize(ns3::TagBuffer i) [member function]
       
   853     cls.add_method('Deserialize', 
       
   854                    'void', 
       
   855                    [param('ns3::TagBuffer', 'i')], 
       
   856                    is_virtual=True)
       
   857     ## socket.h: void ns3::SocketAddressTag::Print(std::ostream & os) const [member function]
       
   858     cls.add_method('Print', 
       
   859                    'void', 
       
   860                    [param('std::ostream &', 'os')], 
       
   861                    is_const=True, is_virtual=True)
       
   862     return
   263     return
   863 
   264 
   864 def register_Ns3InetSocketAddress_methods(root_module, cls):
   265 def register_Ns3InetSocketAddress_methods(root_module, cls):
   865     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::InetSocketAddress const & arg0) [copy constructor]
   266     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::InetSocketAddress const & arg0) [copy constructor]
   866     cls.add_constructor([param('ns3::InetSocketAddress const &', 'arg0')])
   267     cls.add_constructor([param('ns3::InetSocketAddress const &', 'arg0')])
   903                    [param('ns3::Address const &', 'address')], 
   304                    [param('ns3::Address const &', 'address')], 
   904                    is_static=True)
   305                    is_static=True)
   905     return
   306     return
   906 
   307 
   907 def register_Ns3Ipv4Address_methods(root_module, cls):
   308 def register_Ns3Ipv4Address_methods(root_module, cls):
       
   309     cls.add_binary_comparison_operator('!=')
       
   310     cls.add_binary_comparison_operator('<')
       
   311     cls.add_output_stream_operator()
       
   312     cls.add_binary_comparison_operator('==')
   908     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor]
   313     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor]
   909     cls.add_constructor([param('ns3::Ipv4Address const &', 'arg0')])
   314     cls.add_constructor([param('ns3::Ipv4Address const &', 'arg0')])
   910     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address() [constructor]
   315     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address() [constructor]
   911     cls.add_constructor([])
   316     cls.add_constructor([])
   912     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(uint32_t address) [constructor]
   317     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(uint32_t address) [constructor]
   999                    [param('uint32_t', 'address')])
   404                    [param('uint32_t', 'address')])
  1000     ## ipv4-address.h: void ns3::Ipv4Address::Set(char const * address) [member function]
   405     ## ipv4-address.h: void ns3::Ipv4Address::Set(char const * address) [member function]
  1001     cls.add_method('Set', 
   406     cls.add_method('Set', 
  1002                    'void', 
   407                    'void', 
  1003                    [param('char const *', 'address')])
   408                    [param('char const *', 'address')])
       
   409     return
       
   410 
       
   411 def register_Ns3Ipv4AddressGenerator_methods(root_module, cls):
       
   412     ## ipv4-address-generator.h: ns3::Ipv4AddressGenerator::Ipv4AddressGenerator(ns3::Ipv4AddressGenerator const & arg0) [copy constructor]
       
   413     cls.add_constructor([param('ns3::Ipv4AddressGenerator const &', 'arg0')])
       
   414     ## ipv4-address-generator.h: ns3::Ipv4AddressGenerator::Ipv4AddressGenerator() [constructor]
       
   415     cls.add_constructor([])
       
   416     ## 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]
       
   417     cls.add_method('Init', 
       
   418                    'void', 
       
   419                    [param('ns3::Ipv4Address const', 'net'), param('ns3::Ipv4Mask const', 'mask'), param('ns3::Ipv4Address const', 'addr', default_value='"0.0.0.1"')], 
       
   420                    is_static=True)
       
   421     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::NextNetwork(ns3::Ipv4Mask const mask) [member function]
       
   422     cls.add_method('NextNetwork', 
       
   423                    'ns3::Ipv4Address', 
       
   424                    [param('ns3::Ipv4Mask const', 'mask')], 
       
   425                    is_static=True)
       
   426     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::GetNetwork(ns3::Ipv4Mask const mask) [member function]
       
   427     cls.add_method('GetNetwork', 
       
   428                    'ns3::Ipv4Address', 
       
   429                    [param('ns3::Ipv4Mask const', 'mask')], 
       
   430                    is_static=True)
       
   431     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::InitAddress(ns3::Ipv4Address const addr, ns3::Ipv4Mask const mask) [member function]
       
   432     cls.add_method('InitAddress', 
       
   433                    'void', 
       
   434                    [param('ns3::Ipv4Address const', 'addr'), param('ns3::Ipv4Mask const', 'mask')], 
       
   435                    is_static=True)
       
   436     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::NextAddress(ns3::Ipv4Mask const mask) [member function]
       
   437     cls.add_method('NextAddress', 
       
   438                    'ns3::Ipv4Address', 
       
   439                    [param('ns3::Ipv4Mask const', 'mask')], 
       
   440                    is_static=True)
       
   441     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::GetAddress(ns3::Ipv4Mask const mask) [member function]
       
   442     cls.add_method('GetAddress', 
       
   443                    'ns3::Ipv4Address', 
       
   444                    [param('ns3::Ipv4Mask const', 'mask')], 
       
   445                    is_static=True)
       
   446     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::Reset() [member function]
       
   447     cls.add_method('Reset', 
       
   448                    'void', 
       
   449                    [], 
       
   450                    is_static=True)
       
   451     ## ipv4-address-generator.h: static bool ns3::Ipv4AddressGenerator::AddAllocated(ns3::Ipv4Address const addr) [member function]
       
   452     cls.add_method('AddAllocated', 
       
   453                    'bool', 
       
   454                    [param('ns3::Ipv4Address const', 'addr')], 
       
   455                    is_static=True)
       
   456     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::TestMode() [member function]
       
   457     cls.add_method('TestMode', 
       
   458                    'void', 
       
   459                    [], 
       
   460                    is_static=True)
       
   461     return
       
   462 
       
   463 def register_Ns3Ipv4Mask_methods(root_module, cls):
       
   464     cls.add_binary_comparison_operator('!=')
  1004     cls.add_output_stream_operator()
   465     cls.add_output_stream_operator()
  1005     return
   466     cls.add_binary_comparison_operator('==')
  1006 
   467     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor]
  1007 def register_Ns3Application_methods(root_module, cls):
   468     cls.add_constructor([param('ns3::Ipv4Mask const &', 'arg0')])
  1008     ## application.h: ns3::Application::Application(ns3::Application const & arg0) [copy constructor]
   469     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask() [constructor]
  1009     cls.add_constructor([param('ns3::Application const &', 'arg0')])
   470     cls.add_constructor([])
  1010     ## application.h: static ns3::TypeId ns3::Application::GetTypeId() [member function]
   471     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(uint32_t mask) [constructor]
       
   472     cls.add_constructor([param('uint32_t', 'mask')])
       
   473     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(char const * mask) [constructor]
       
   474     cls.add_constructor([param('char const *', 'mask')])
       
   475     ## ipv4-address.h: uint32_t ns3::Ipv4Mask::Get() const [member function]
       
   476     cls.add_method('Get', 
       
   477                    'uint32_t', 
       
   478                    [], 
       
   479                    is_const=True)
       
   480     ## ipv4-address.h: uint32_t ns3::Ipv4Mask::GetInverse() const [member function]
       
   481     cls.add_method('GetInverse', 
       
   482                    'uint32_t', 
       
   483                    [], 
       
   484                    is_const=True)
       
   485     ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetLoopback() [member function]
       
   486     cls.add_method('GetLoopback', 
       
   487                    'ns3::Ipv4Mask', 
       
   488                    [], 
       
   489                    is_static=True)
       
   490     ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetZero() [member function]
       
   491     cls.add_method('GetZero', 
       
   492                    'ns3::Ipv4Mask', 
       
   493                    [], 
       
   494                    is_static=True)
       
   495     ## ipv4-address.h: bool ns3::Ipv4Mask::IsEqual(ns3::Ipv4Mask other) const [member function]
       
   496     cls.add_method('IsEqual', 
       
   497                    'bool', 
       
   498                    [param('ns3::Ipv4Mask', 'other')], 
       
   499                    is_const=True)
       
   500     ## ipv4-address.h: bool ns3::Ipv4Mask::IsMatch(ns3::Ipv4Address a, ns3::Ipv4Address b) const [member function]
       
   501     cls.add_method('IsMatch', 
       
   502                    'bool', 
       
   503                    [param('ns3::Ipv4Address', 'a'), param('ns3::Ipv4Address', 'b')], 
       
   504                    is_const=True)
       
   505     ## ipv4-address.h: void ns3::Ipv4Mask::Print(std::ostream & os) const [member function]
       
   506     cls.add_method('Print', 
       
   507                    'void', 
       
   508                    [param('std::ostream &', 'os')], 
       
   509                    is_const=True)
       
   510     ## ipv4-address.h: void ns3::Ipv4Mask::Set(uint32_t mask) [member function]
       
   511     cls.add_method('Set', 
       
   512                    'void', 
       
   513                    [param('uint32_t', 'mask')])
       
   514     return
       
   515 
       
   516 def register_Ns3Ipv4MulticastRoute_methods(root_module, cls):
       
   517     cls.add_output_stream_operator()
       
   518     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute() [constructor]
       
   519     cls.add_constructor([])
       
   520     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const & route) [copy constructor]
       
   521     cls.add_constructor([param('ns3::Ipv4MulticastRoute const &', 'route')])
       
   522     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const * route) [constructor]
       
   523     cls.add_constructor([param('ns3::Ipv4MulticastRoute const *', 'route')])
       
   524     ## 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]
       
   525     cls.add_method('CreateMulticastRoute', 
       
   526                    'ns3::Ipv4MulticastRoute', 
       
   527                    [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int >', 'outputInterfaces')], 
       
   528                    is_static=True)
       
   529     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4MulticastRoute::GetGroup() const [member function]
       
   530     cls.add_method('GetGroup', 
       
   531                    'ns3::Ipv4Address', 
       
   532                    [], 
       
   533                    is_const=True)
       
   534     ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetInputInterface() const [member function]
       
   535     cls.add_method('GetInputInterface', 
       
   536                    'uint32_t', 
       
   537                    [], 
       
   538                    is_const=True)
       
   539     ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetNOutputInterfaces() const [member function]
       
   540     cls.add_method('GetNOutputInterfaces', 
       
   541                    'uint32_t', 
       
   542                    [], 
       
   543                    is_const=True)
       
   544     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4MulticastRoute::GetOrigin() const [member function]
       
   545     cls.add_method('GetOrigin', 
       
   546                    'ns3::Ipv4Address', 
       
   547                    [], 
       
   548                    is_const=True)
       
   549     ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetOutputInterface(uint32_t n) const [member function]
       
   550     cls.add_method('GetOutputInterface', 
       
   551                    'uint32_t', 
       
   552                    [param('uint32_t', 'n')], 
       
   553                    is_const=True)
       
   554     ## ipv4-route.h: std::vector<unsigned int, std::allocator<unsigned int> > ns3::Ipv4MulticastRoute::GetOutputInterfaces() const [member function]
       
   555     cls.add_method('GetOutputInterfaces', 
       
   556                    'std::vector< unsigned int >', 
       
   557                    [], 
       
   558                    is_const=True)
       
   559     return
       
   560 
       
   561 def register_Ns3Ipv4Route_methods(root_module, cls):
       
   562     cls.add_output_stream_operator()
       
   563     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route() [constructor]
       
   564     cls.add_constructor([])
       
   565     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const & route) [copy constructor]
       
   566     cls.add_constructor([param('ns3::Ipv4Route const &', 'route')])
       
   567     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const * route) [constructor]
       
   568     cls.add_constructor([param('ns3::Ipv4Route const *', 'route')])
       
   569     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateDefaultRoute(ns3::Ipv4Address nextHop, uint32_t interface) [member function]
       
   570     cls.add_method('CreateDefaultRoute', 
       
   571                    'ns3::Ipv4Route', 
       
   572                    [param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], 
       
   573                    is_static=True)
       
   574     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateHostRouteTo(ns3::Ipv4Address dest, ns3::Ipv4Address nextHop, uint32_t interface) [member function]
       
   575     cls.add_method('CreateHostRouteTo', 
       
   576                    'ns3::Ipv4Route', 
       
   577                    [param('ns3::Ipv4Address', 'dest'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], 
       
   578                    is_static=True)
       
   579     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateHostRouteTo(ns3::Ipv4Address dest, uint32_t interface) [member function]
       
   580     cls.add_method('CreateHostRouteTo', 
       
   581                    'ns3::Ipv4Route', 
       
   582                    [param('ns3::Ipv4Address', 'dest'), param('uint32_t', 'interface')], 
       
   583                    is_static=True)
       
   584     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, ns3::Ipv4Address nextHop, uint32_t interface) [member function]
       
   585     cls.add_method('CreateNetworkRouteTo', 
       
   586                    'ns3::Ipv4Route', 
       
   587                    [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], 
       
   588                    is_static=True)
       
   589     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, uint32_t interface) [member function]
       
   590     cls.add_method('CreateNetworkRouteTo', 
       
   591                    'ns3::Ipv4Route', 
       
   592                    [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('uint32_t', 'interface')], 
       
   593                    is_static=True)
       
   594     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetDest() const [member function]
       
   595     cls.add_method('GetDest', 
       
   596                    'ns3::Ipv4Address', 
       
   597                    [], 
       
   598                    is_const=True)
       
   599     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetDestNetwork() const [member function]
       
   600     cls.add_method('GetDestNetwork', 
       
   601                    'ns3::Ipv4Address', 
       
   602                    [], 
       
   603                    is_const=True)
       
   604     ## ipv4-route.h: ns3::Ipv4Mask ns3::Ipv4Route::GetDestNetworkMask() const [member function]
       
   605     cls.add_method('GetDestNetworkMask', 
       
   606                    'ns3::Ipv4Mask', 
       
   607                    [], 
       
   608                    is_const=True)
       
   609     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetGateway() const [member function]
       
   610     cls.add_method('GetGateway', 
       
   611                    'ns3::Ipv4Address', 
       
   612                    [], 
       
   613                    is_const=True)
       
   614     ## ipv4-route.h: uint32_t ns3::Ipv4Route::GetInterface() const [member function]
       
   615     cls.add_method('GetInterface', 
       
   616                    'uint32_t', 
       
   617                    [], 
       
   618                    is_const=True)
       
   619     ## ipv4-route.h: bool ns3::Ipv4Route::IsDefault() const [member function]
       
   620     cls.add_method('IsDefault', 
       
   621                    'bool', 
       
   622                    [], 
       
   623                    is_const=True)
       
   624     ## ipv4-route.h: bool ns3::Ipv4Route::IsGateway() const [member function]
       
   625     cls.add_method('IsGateway', 
       
   626                    'bool', 
       
   627                    [], 
       
   628                    is_const=True)
       
   629     ## ipv4-route.h: bool ns3::Ipv4Route::IsHost() const [member function]
       
   630     cls.add_method('IsHost', 
       
   631                    'bool', 
       
   632                    [], 
       
   633                    is_const=True)
       
   634     ## ipv4-route.h: bool ns3::Ipv4Route::IsNetwork() const [member function]
       
   635     cls.add_method('IsNetwork', 
       
   636                    'bool', 
       
   637                    [], 
       
   638                    is_const=True)
       
   639     return
       
   640 
       
   641 def register_Ns3Mac48Address_methods(root_module, cls):
       
   642     cls.add_binary_comparison_operator('!=')
       
   643     cls.add_binary_comparison_operator('<')
       
   644     cls.add_output_stream_operator()
       
   645     cls.add_binary_comparison_operator('==')
       
   646     ## mac48-address.h: ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [copy constructor]
       
   647     cls.add_constructor([param('ns3::Mac48Address const &', 'arg0')])
       
   648     ## mac48-address.h: ns3::Mac48Address::Mac48Address() [constructor]
       
   649     cls.add_constructor([])
       
   650     ## mac48-address.h: ns3::Mac48Address::Mac48Address(char const * str) [constructor]
       
   651     cls.add_constructor([param('char const *', 'str')])
       
   652     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::Allocate() [member function]
       
   653     cls.add_method('Allocate', 
       
   654                    'ns3::Mac48Address', 
       
   655                    [], 
       
   656                    is_static=True)
       
   657     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::ConvertFrom(ns3::Address const & address) [member function]
       
   658     cls.add_method('ConvertFrom', 
       
   659                    'ns3::Mac48Address', 
       
   660                    [param('ns3::Address const &', 'address')], 
       
   661                    is_static=True)
       
   662     ## mac48-address.h: void ns3::Mac48Address::CopyFrom(uint8_t const * buffer) [member function]
       
   663     cls.add_method('CopyFrom', 
       
   664                    'void', 
       
   665                    [param('uint8_t const *', 'buffer')])
       
   666     ## mac48-address.h: void ns3::Mac48Address::CopyTo(uint8_t * buffer) const [member function]
       
   667     cls.add_method('CopyTo', 
       
   668                    'void', 
       
   669                    [param('uint8_t *', 'buffer')], 
       
   670                    is_const=True)
       
   671     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetBroadcast() [member function]
       
   672     cls.add_method('GetBroadcast', 
       
   673                    'ns3::Mac48Address', 
       
   674                    [], 
       
   675                    is_static=True)
       
   676     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetMulticast(ns3::Ipv4Address address) [member function]
       
   677     cls.add_method('GetMulticast', 
       
   678                    'ns3::Mac48Address', 
       
   679                    [param('ns3::Ipv4Address', 'address')], 
       
   680                    is_static=True)
       
   681     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetMulticastPrefix() [member function]
       
   682     cls.add_method('GetMulticastPrefix', 
       
   683                    'ns3::Mac48Address', 
       
   684                    [], 
       
   685                    is_static=True)
       
   686     ## mac48-address.h: bool ns3::Mac48Address::IsBroadcast() const [member function]
       
   687     cls.add_method('IsBroadcast', 
       
   688                    'bool', 
       
   689                    [], 
       
   690                    is_const=True)
       
   691     ## mac48-address.h: bool ns3::Mac48Address::IsGroup() const [member function]
       
   692     cls.add_method('IsGroup', 
       
   693                    'bool', 
       
   694                    [], 
       
   695                    is_const=True)
       
   696     ## mac48-address.h: static bool ns3::Mac48Address::IsMatchingType(ns3::Address const & address) [member function]
       
   697     cls.add_method('IsMatchingType', 
       
   698                    'bool', 
       
   699                    [param('ns3::Address const &', 'address')], 
       
   700                    is_static=True)
       
   701     ## mac48-address.h: bool ns3::Mac48Address::IsMulticast() const [member function]
       
   702     cls.add_method('IsMulticast', 
       
   703                    'bool', 
       
   704                    [], 
       
   705                    is_const=True)
       
   706     return
       
   707 
       
   708 def register_Ns3Mac64Address_methods(root_module, cls):
       
   709     cls.add_binary_comparison_operator('!=')
       
   710     cls.add_output_stream_operator()
       
   711     cls.add_binary_comparison_operator('==')
       
   712     ## mac64-address.h: ns3::Mac64Address::Mac64Address(ns3::Mac64Address const & arg0) [copy constructor]
       
   713     cls.add_constructor([param('ns3::Mac64Address const &', 'arg0')])
       
   714     ## mac64-address.h: ns3::Mac64Address::Mac64Address() [constructor]
       
   715     cls.add_constructor([])
       
   716     ## mac64-address.h: ns3::Mac64Address::Mac64Address(char const * str) [constructor]
       
   717     cls.add_constructor([param('char const *', 'str')])
       
   718     ## mac64-address.h: static ns3::Mac64Address ns3::Mac64Address::Allocate() [member function]
       
   719     cls.add_method('Allocate', 
       
   720                    'ns3::Mac64Address', 
       
   721                    [], 
       
   722                    is_static=True)
       
   723     ## mac64-address.h: static ns3::Mac64Address ns3::Mac64Address::ConvertFrom(ns3::Address const & address) [member function]
       
   724     cls.add_method('ConvertFrom', 
       
   725                    'ns3::Mac64Address', 
       
   726                    [param('ns3::Address const &', 'address')], 
       
   727                    is_static=True)
       
   728     ## mac64-address.h: void ns3::Mac64Address::CopyFrom(uint8_t const * buffer) [member function]
       
   729     cls.add_method('CopyFrom', 
       
   730                    'void', 
       
   731                    [param('uint8_t const *', 'buffer')])
       
   732     ## mac64-address.h: void ns3::Mac64Address::CopyTo(uint8_t * buffer) const [member function]
       
   733     cls.add_method('CopyTo', 
       
   734                    'void', 
       
   735                    [param('uint8_t *', 'buffer')], 
       
   736                    is_const=True)
       
   737     ## mac64-address.h: static bool ns3::Mac64Address::IsMatchingType(ns3::Address const & address) [member function]
       
   738     cls.add_method('IsMatchingType', 
       
   739                    'bool', 
       
   740                    [param('ns3::Address const &', 'address')], 
       
   741                    is_static=True)
       
   742     return
       
   743 
       
   744 def register_Ns3NodeList_methods(root_module, cls):
       
   745     ## node-list.h: ns3::NodeList::NodeList(ns3::NodeList const & arg0) [copy constructor]
       
   746     cls.add_constructor([param('ns3::NodeList const &', 'arg0')])
       
   747     ## node-list.h: ns3::NodeList::NodeList() [constructor]
       
   748     cls.add_constructor([])
       
   749     ## node-list.h: static uint32_t ns3::NodeList::Add(ns3::Ptr<ns3::Node> node) [member function]
       
   750     cls.add_method('Add', 
       
   751                    'uint32_t', 
       
   752                    [param('ns3::Ptr< ns3::Node >', 'node')], 
       
   753                    is_static=True)
       
   754     ## 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]
       
   755     cls.add_method('Begin', 
       
   756                    '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', 
       
   757                    [], 
       
   758                    is_static=True)
       
   759     ## 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]
       
   760     cls.add_method('End', 
       
   761                    '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', 
       
   762                    [], 
       
   763                    is_static=True)
       
   764     ## node-list.h: static ns3::Ptr<ns3::Node> ns3::NodeList::GetNode(uint32_t n) [member function]
       
   765     cls.add_method('GetNode', 
       
   766                    'ns3::Ptr< ns3::Node >', 
       
   767                    [param('uint32_t', 'n')], 
       
   768                    is_static=True)
       
   769     ## node-list.h: static uint32_t ns3::NodeList::GetNNodes() [member function]
       
   770     cls.add_method('GetNNodes', 
       
   771                    'uint32_t', 
       
   772                    [], 
       
   773                    is_static=True)
       
   774     return
       
   775 
       
   776 def register_Ns3PacketSocketAddress_methods(root_module, cls):
       
   777     ## packet-socket-address.h: ns3::PacketSocketAddress::PacketSocketAddress(ns3::PacketSocketAddress const & arg0) [copy constructor]
       
   778     cls.add_constructor([param('ns3::PacketSocketAddress const &', 'arg0')])
       
   779     ## packet-socket-address.h: ns3::PacketSocketAddress::PacketSocketAddress() [constructor]
       
   780     cls.add_constructor([])
       
   781     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetProtocol(uint16_t protocol) [member function]
       
   782     cls.add_method('SetProtocol', 
       
   783                    'void', 
       
   784                    [param('uint16_t', 'protocol')])
       
   785     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetAllDevices() [member function]
       
   786     cls.add_method('SetAllDevices', 
       
   787                    'void', 
       
   788                    [])
       
   789     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetSingleDevice(uint32_t device) [member function]
       
   790     cls.add_method('SetSingleDevice', 
       
   791                    'void', 
       
   792                    [param('uint32_t', 'device')])
       
   793     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetPhysicalAddress(ns3::Address const address) [member function]
       
   794     cls.add_method('SetPhysicalAddress', 
       
   795                    'void', 
       
   796                    [param('ns3::Address const', 'address')])
       
   797     ## packet-socket-address.h: uint16_t ns3::PacketSocketAddress::GetProtocol() const [member function]
       
   798     cls.add_method('GetProtocol', 
       
   799                    'uint16_t', 
       
   800                    [], 
       
   801                    is_const=True)
       
   802     ## packet-socket-address.h: uint32_t ns3::PacketSocketAddress::GetSingleDevice() const [member function]
       
   803     cls.add_method('GetSingleDevice', 
       
   804                    'uint32_t', 
       
   805                    [], 
       
   806                    is_const=True)
       
   807     ## packet-socket-address.h: bool ns3::PacketSocketAddress::IsSingleDevice() const [member function]
       
   808     cls.add_method('IsSingleDevice', 
       
   809                    'bool', 
       
   810                    [], 
       
   811                    is_const=True)
       
   812     ## packet-socket-address.h: ns3::Address ns3::PacketSocketAddress::GetPhysicalAddress() const [member function]
       
   813     cls.add_method('GetPhysicalAddress', 
       
   814                    'ns3::Address', 
       
   815                    [], 
       
   816                    is_const=True)
       
   817     ## packet-socket-address.h: static ns3::PacketSocketAddress ns3::PacketSocketAddress::ConvertFrom(ns3::Address const & address) [member function]
       
   818     cls.add_method('ConvertFrom', 
       
   819                    'ns3::PacketSocketAddress', 
       
   820                    [param('ns3::Address const &', 'address')], 
       
   821                    is_static=True)
       
   822     ## packet-socket-address.h: static bool ns3::PacketSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
       
   823     cls.add_method('IsMatchingType', 
       
   824                    'bool', 
       
   825                    [param('ns3::Address const &', 'address')], 
       
   826                    is_static=True)
       
   827     return
       
   828 
       
   829 def register_Ns3Ipv4AddressChecker_methods(root_module, cls):
       
   830     ## ipv4-address.h: ns3::Ipv4AddressChecker::Ipv4AddressChecker(ns3::Ipv4AddressChecker const & arg0) [copy constructor]
       
   831     cls.add_constructor([param('ns3::Ipv4AddressChecker const &', 'arg0')])
       
   832     ## ipv4-address.h: ns3::Ipv4AddressChecker::Ipv4AddressChecker() [constructor]
       
   833     cls.add_constructor([])
       
   834     return
       
   835 
       
   836 def register_Ns3Ipv4AddressValue_methods(root_module, cls):
       
   837     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4AddressValue const & arg0) [copy constructor]
       
   838     cls.add_constructor([param('ns3::Ipv4AddressValue const &', 'arg0')])
       
   839     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue() [constructor]
       
   840     cls.add_constructor([])
       
   841     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4Address const & value) [constructor]
       
   842     cls.add_constructor([param('ns3::Ipv4Address const &', 'value')])
       
   843     ## ipv4-address.h: void ns3::Ipv4AddressValue::Set(ns3::Ipv4Address const & value) [member function]
       
   844     cls.add_method('Set', 
       
   845                    'void', 
       
   846                    [param('ns3::Ipv4Address const &', 'value')])
       
   847     ## ipv4-address.h: ns3::Ipv4Address ns3::Ipv4AddressValue::Get() const [member function]
       
   848     cls.add_method('Get', 
       
   849                    'ns3::Ipv4Address', 
       
   850                    [], 
       
   851                    is_const=True)
       
   852     ## ipv4-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Ipv4AddressValue::Copy() const [member function]
       
   853     cls.add_method('Copy', 
       
   854                    'ns3::Ptr< ns3::AttributeValue >', 
       
   855                    [], 
       
   856                    is_const=True, is_virtual=True)
       
   857     ## ipv4-address.h: std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
   858     cls.add_method('SerializeToString', 
       
   859                    'std::string', 
       
   860                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
   861                    is_const=True, is_virtual=True)
       
   862     ## ipv4-address.h: bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
   863     cls.add_method('DeserializeFromString', 
       
   864                    'bool', 
       
   865                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
   866                    is_virtual=True)
       
   867     return
       
   868 
       
   869 def register_Ns3Ipv4Header_methods(root_module, cls):
       
   870     ## ipv4-header.h: ns3::Ipv4Header::Ipv4Header(ns3::Ipv4Header const & arg0) [copy constructor]
       
   871     cls.add_constructor([param('ns3::Ipv4Header const &', 'arg0')])
       
   872     ## ipv4-header.h: ns3::Ipv4Header::Ipv4Header() [constructor]
       
   873     cls.add_constructor([])
       
   874     ## ipv4-header.h: void ns3::Ipv4Header::EnableChecksum() [member function]
       
   875     cls.add_method('EnableChecksum', 
       
   876                    'void', 
       
   877                    [])
       
   878     ## ipv4-header.h: void ns3::Ipv4Header::SetPayloadSize(uint16_t size) [member function]
       
   879     cls.add_method('SetPayloadSize', 
       
   880                    'void', 
       
   881                    [param('uint16_t', 'size')])
       
   882     ## ipv4-header.h: void ns3::Ipv4Header::SetIdentification(uint16_t identification) [member function]
       
   883     cls.add_method('SetIdentification', 
       
   884                    'void', 
       
   885                    [param('uint16_t', 'identification')])
       
   886     ## ipv4-header.h: void ns3::Ipv4Header::SetTos(uint8_t tos) [member function]
       
   887     cls.add_method('SetTos', 
       
   888                    'void', 
       
   889                    [param('uint8_t', 'tos')])
       
   890     ## ipv4-header.h: void ns3::Ipv4Header::SetMoreFragments() [member function]
       
   891     cls.add_method('SetMoreFragments', 
       
   892                    'void', 
       
   893                    [])
       
   894     ## ipv4-header.h: void ns3::Ipv4Header::SetLastFragment() [member function]
       
   895     cls.add_method('SetLastFragment', 
       
   896                    'void', 
       
   897                    [])
       
   898     ## ipv4-header.h: void ns3::Ipv4Header::SetDontFragment() [member function]
       
   899     cls.add_method('SetDontFragment', 
       
   900                    'void', 
       
   901                    [])
       
   902     ## ipv4-header.h: void ns3::Ipv4Header::SetMayFragment() [member function]
       
   903     cls.add_method('SetMayFragment', 
       
   904                    'void', 
       
   905                    [])
       
   906     ## ipv4-header.h: void ns3::Ipv4Header::SetFragmentOffset(uint16_t offset) [member function]
       
   907     cls.add_method('SetFragmentOffset', 
       
   908                    'void', 
       
   909                    [param('uint16_t', 'offset')])
       
   910     ## ipv4-header.h: void ns3::Ipv4Header::SetTtl(uint8_t ttl) [member function]
       
   911     cls.add_method('SetTtl', 
       
   912                    'void', 
       
   913                    [param('uint8_t', 'ttl')])
       
   914     ## ipv4-header.h: void ns3::Ipv4Header::SetProtocol(uint8_t num) [member function]
       
   915     cls.add_method('SetProtocol', 
       
   916                    'void', 
       
   917                    [param('uint8_t', 'num')])
       
   918     ## ipv4-header.h: void ns3::Ipv4Header::SetSource(ns3::Ipv4Address source) [member function]
       
   919     cls.add_method('SetSource', 
       
   920                    'void', 
       
   921                    [param('ns3::Ipv4Address', 'source')])
       
   922     ## ipv4-header.h: void ns3::Ipv4Header::SetDestination(ns3::Ipv4Address destination) [member function]
       
   923     cls.add_method('SetDestination', 
       
   924                    'void', 
       
   925                    [param('ns3::Ipv4Address', 'destination')])
       
   926     ## ipv4-header.h: uint16_t ns3::Ipv4Header::GetPayloadSize() const [member function]
       
   927     cls.add_method('GetPayloadSize', 
       
   928                    'uint16_t', 
       
   929                    [], 
       
   930                    is_const=True)
       
   931     ## ipv4-header.h: uint16_t ns3::Ipv4Header::GetIdentification() const [member function]
       
   932     cls.add_method('GetIdentification', 
       
   933                    'uint16_t', 
       
   934                    [], 
       
   935                    is_const=True)
       
   936     ## ipv4-header.h: uint8_t ns3::Ipv4Header::GetTos() const [member function]
       
   937     cls.add_method('GetTos', 
       
   938                    'uint8_t', 
       
   939                    [], 
       
   940                    is_const=True)
       
   941     ## ipv4-header.h: bool ns3::Ipv4Header::IsLastFragment() const [member function]
       
   942     cls.add_method('IsLastFragment', 
       
   943                    'bool', 
       
   944                    [], 
       
   945                    is_const=True)
       
   946     ## ipv4-header.h: bool ns3::Ipv4Header::IsDontFragment() const [member function]
       
   947     cls.add_method('IsDontFragment', 
       
   948                    'bool', 
       
   949                    [], 
       
   950                    is_const=True)
       
   951     ## ipv4-header.h: uint16_t ns3::Ipv4Header::GetFragmentOffset() const [member function]
       
   952     cls.add_method('GetFragmentOffset', 
       
   953                    'uint16_t', 
       
   954                    [], 
       
   955                    is_const=True)
       
   956     ## ipv4-header.h: uint8_t ns3::Ipv4Header::GetTtl() const [member function]
       
   957     cls.add_method('GetTtl', 
       
   958                    'uint8_t', 
       
   959                    [], 
       
   960                    is_const=True)
       
   961     ## ipv4-header.h: uint8_t ns3::Ipv4Header::GetProtocol() const [member function]
       
   962     cls.add_method('GetProtocol', 
       
   963                    'uint8_t', 
       
   964                    [], 
       
   965                    is_const=True)
       
   966     ## ipv4-header.h: ns3::Ipv4Address ns3::Ipv4Header::GetSource() const [member function]
       
   967     cls.add_method('GetSource', 
       
   968                    'ns3::Ipv4Address', 
       
   969                    [], 
       
   970                    is_const=True)
       
   971     ## ipv4-header.h: ns3::Ipv4Address ns3::Ipv4Header::GetDestination() const [member function]
       
   972     cls.add_method('GetDestination', 
       
   973                    'ns3::Ipv4Address', 
       
   974                    [], 
       
   975                    is_const=True)
       
   976     ## ipv4-header.h: bool ns3::Ipv4Header::IsChecksumOk() const [member function]
       
   977     cls.add_method('IsChecksumOk', 
       
   978                    'bool', 
       
   979                    [], 
       
   980                    is_const=True)
       
   981     ## ipv4-header.h: static ns3::TypeId ns3::Ipv4Header::GetTypeId() [member function]
  1011     cls.add_method('GetTypeId', 
   982     cls.add_method('GetTypeId', 
  1012                    'ns3::TypeId', 
   983                    'ns3::TypeId', 
  1013                    [], 
   984                    [], 
  1014                    is_static=True)
   985                    is_static=True)
  1015     ## application.h: ns3::Application::Application() [constructor]
   986     ## ipv4-header.h: ns3::TypeId ns3::Ipv4Header::GetInstanceTypeId() const [member function]
  1016     cls.add_constructor([])
   987     cls.add_method('GetInstanceTypeId', 
  1017     ## application.h: void ns3::Application::Start(ns3::Time const & startTime) [member function]
   988                    'ns3::TypeId', 
  1018     cls.add_method('Start', 
   989                    [], 
  1019                    'void', 
   990                    is_const=True, is_virtual=True)
  1020                    [param('ns3::Time const &', 'startTime')])
   991     ## ipv4-header.h: void ns3::Ipv4Header::Print(std::ostream & os) const [member function]
  1021     ## application.h: void ns3::Application::Start(ns3::RandomVariable const & startVariable) [member function]
   992     cls.add_method('Print', 
  1022     cls.add_method('Start', 
   993                    'void', 
  1023                    'void', 
   994                    [param('std::ostream &', 'os')], 
  1024                    [param('ns3::RandomVariable const &', 'startVariable')])
   995                    is_const=True, is_virtual=True)
  1025     ## application.h: void ns3::Application::Stop(ns3::Time const & stopTime) [member function]
   996     ## ipv4-header.h: uint32_t ns3::Ipv4Header::GetSerializedSize() const [member function]
  1026     cls.add_method('Stop', 
   997     cls.add_method('GetSerializedSize', 
  1027                    'void', 
   998                    'uint32_t', 
  1028                    [param('ns3::Time const &', 'stopTime')])
   999                    [], 
  1029     ## application.h: void ns3::Application::Stop(ns3::RandomVariable const & stopVariable) [member function]
  1000                    is_const=True, is_virtual=True)
  1030     cls.add_method('Stop', 
  1001     ## ipv4-header.h: void ns3::Ipv4Header::Serialize(ns3::Buffer::Iterator start) const [member function]
  1031                    'void', 
  1002     cls.add_method('Serialize', 
  1032                    [param('ns3::RandomVariable const &', 'stopVariable')])
  1003                    'void', 
  1033     ## application.h: ns3::Ptr<ns3::Node> ns3::Application::GetNode() const [member function]
  1004                    [param('ns3::Buffer::Iterator', 'start')], 
  1034     cls.add_method('GetNode', 
  1005                    is_const=True, is_virtual=True)
  1035                    'ns3::Ptr< ns3::Node >', 
  1006     ## ipv4-header.h: uint32_t ns3::Ipv4Header::Deserialize(ns3::Buffer::Iterator start) [member function]
  1036                    [], 
  1007     cls.add_method('Deserialize', 
  1037                    is_const=True)
  1008                    'uint32_t', 
  1038     ## application.h: void ns3::Application::SetNode(ns3::Ptr<ns3::Node> node) [member function]
  1009                    [param('ns3::Buffer::Iterator', 'start')], 
  1039     cls.add_method('SetNode', 
  1010                    is_virtual=True)
  1040                    'void', 
  1011     return
  1041                    [param('ns3::Ptr< ns3::Node >', 'node')])
  1012 
  1042     ## application.h: void ns3::Application::DoDispose() [member function]
  1013 def register_Ns3Ipv4MaskChecker_methods(root_module, cls):
  1043     cls.add_method('DoDispose', 
  1014     ## ipv4-address.h: ns3::Ipv4MaskChecker::Ipv4MaskChecker(ns3::Ipv4MaskChecker const & arg0) [copy constructor]
  1044                    'void', 
  1015     cls.add_constructor([param('ns3::Ipv4MaskChecker const &', 'arg0')])
  1045                    [], 
  1016     ## ipv4-address.h: ns3::Ipv4MaskChecker::Ipv4MaskChecker() [constructor]
  1046                    visibility='protected', is_virtual=True)
  1017     cls.add_constructor([])
  1047     ## application.h: void ns3::Application::StartApplication() [member function]
  1018     return
  1048     cls.add_method('StartApplication', 
  1019 
  1049                    'void', 
  1020 def register_Ns3Ipv4MaskValue_methods(root_module, cls):
  1050                    [], 
  1021     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4MaskValue const & arg0) [copy constructor]
  1051                    visibility='private', is_virtual=True)
  1022     cls.add_constructor([param('ns3::Ipv4MaskValue const &', 'arg0')])
  1052     ## application.h: void ns3::Application::StopApplication() [member function]
  1023     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue() [constructor]
  1053     cls.add_method('StopApplication', 
  1024     cls.add_constructor([])
  1054                    'void', 
  1025     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4Mask const & value) [constructor]
  1055                    [], 
  1026     cls.add_constructor([param('ns3::Ipv4Mask const &', 'value')])
  1056                    visibility='private', is_virtual=True)
  1027     ## ipv4-address.h: void ns3::Ipv4MaskValue::Set(ns3::Ipv4Mask const & value) [member function]
       
  1028     cls.add_method('Set', 
       
  1029                    'void', 
       
  1030                    [param('ns3::Ipv4Mask const &', 'value')])
       
  1031     ## ipv4-address.h: ns3::Ipv4Mask ns3::Ipv4MaskValue::Get() const [member function]
       
  1032     cls.add_method('Get', 
       
  1033                    'ns3::Ipv4Mask', 
       
  1034                    [], 
       
  1035                    is_const=True)
       
  1036     ## ipv4-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Ipv4MaskValue::Copy() const [member function]
       
  1037     cls.add_method('Copy', 
       
  1038                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1039                    [], 
       
  1040                    is_const=True, is_virtual=True)
       
  1041     ## ipv4-address.h: std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
  1042     cls.add_method('SerializeToString', 
       
  1043                    'std::string', 
       
  1044                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1045                    is_const=True, is_virtual=True)
       
  1046     ## ipv4-address.h: bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
  1047     cls.add_method('DeserializeFromString', 
       
  1048                    'bool', 
       
  1049                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1050                    is_virtual=True)
       
  1051     return
       
  1052 
       
  1053 def register_Ns3LlcSnapHeader_methods(root_module, cls):
       
  1054     ## llc-snap-header.h: ns3::LlcSnapHeader::LlcSnapHeader(ns3::LlcSnapHeader const & arg0) [copy constructor]
       
  1055     cls.add_constructor([param('ns3::LlcSnapHeader const &', 'arg0')])
       
  1056     ## llc-snap-header.h: ns3::LlcSnapHeader::LlcSnapHeader() [constructor]
       
  1057     cls.add_constructor([])
       
  1058     ## llc-snap-header.h: void ns3::LlcSnapHeader::SetType(uint16_t type) [member function]
       
  1059     cls.add_method('SetType', 
       
  1060                    'void', 
       
  1061                    [param('uint16_t', 'type')])
       
  1062     ## llc-snap-header.h: uint16_t ns3::LlcSnapHeader::GetType() [member function]
       
  1063     cls.add_method('GetType', 
       
  1064                    'uint16_t', 
       
  1065                    [])
       
  1066     ## llc-snap-header.h: static ns3::TypeId ns3::LlcSnapHeader::GetTypeId() [member function]
       
  1067     cls.add_method('GetTypeId', 
       
  1068                    'ns3::TypeId', 
       
  1069                    [], 
       
  1070                    is_static=True)
       
  1071     ## llc-snap-header.h: ns3::TypeId ns3::LlcSnapHeader::GetInstanceTypeId() const [member function]
       
  1072     cls.add_method('GetInstanceTypeId', 
       
  1073                    'ns3::TypeId', 
       
  1074                    [], 
       
  1075                    is_const=True, is_virtual=True)
       
  1076     ## llc-snap-header.h: void ns3::LlcSnapHeader::Print(std::ostream & os) const [member function]
       
  1077     cls.add_method('Print', 
       
  1078                    'void', 
       
  1079                    [param('std::ostream &', 'os')], 
       
  1080                    is_const=True, is_virtual=True)
       
  1081     ## llc-snap-header.h: uint32_t ns3::LlcSnapHeader::GetSerializedSize() const [member function]
       
  1082     cls.add_method('GetSerializedSize', 
       
  1083                    'uint32_t', 
       
  1084                    [], 
       
  1085                    is_const=True, is_virtual=True)
       
  1086     ## llc-snap-header.h: void ns3::LlcSnapHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
       
  1087     cls.add_method('Serialize', 
       
  1088                    'void', 
       
  1089                    [param('ns3::Buffer::Iterator', 'start')], 
       
  1090                    is_const=True, is_virtual=True)
       
  1091     ## llc-snap-header.h: uint32_t ns3::LlcSnapHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
       
  1092     cls.add_method('Deserialize', 
       
  1093                    'uint32_t', 
       
  1094                    [param('ns3::Buffer::Iterator', 'start')], 
       
  1095                    is_virtual=True)
       
  1096     return
       
  1097 
       
  1098 def register_Ns3Mac48AddressChecker_methods(root_module, cls):
       
  1099     ## mac48-address.h: ns3::Mac48AddressChecker::Mac48AddressChecker(ns3::Mac48AddressChecker const & arg0) [copy constructor]
       
  1100     cls.add_constructor([param('ns3::Mac48AddressChecker const &', 'arg0')])
       
  1101     ## mac48-address.h: ns3::Mac48AddressChecker::Mac48AddressChecker() [constructor]
       
  1102     cls.add_constructor([])
       
  1103     return
       
  1104 
       
  1105 def register_Ns3Mac48AddressValue_methods(root_module, cls):
       
  1106     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48AddressValue const & arg0) [copy constructor]
       
  1107     cls.add_constructor([param('ns3::Mac48AddressValue const &', 'arg0')])
       
  1108     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue() [constructor]
       
  1109     cls.add_constructor([])
       
  1110     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48Address const & value) [constructor]
       
  1111     cls.add_constructor([param('ns3::Mac48Address const &', 'value')])
       
  1112     ## mac48-address.h: void ns3::Mac48AddressValue::Set(ns3::Mac48Address const & value) [member function]
       
  1113     cls.add_method('Set', 
       
  1114                    'void', 
       
  1115                    [param('ns3::Mac48Address const &', 'value')])
       
  1116     ## mac48-address.h: ns3::Mac48Address ns3::Mac48AddressValue::Get() const [member function]
       
  1117     cls.add_method('Get', 
       
  1118                    'ns3::Mac48Address', 
       
  1119                    [], 
       
  1120                    is_const=True)
       
  1121     ## mac48-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Mac48AddressValue::Copy() const [member function]
       
  1122     cls.add_method('Copy', 
       
  1123                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1124                    [], 
       
  1125                    is_const=True, is_virtual=True)
       
  1126     ## mac48-address.h: std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
  1127     cls.add_method('SerializeToString', 
       
  1128                    'std::string', 
       
  1129                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1130                    is_const=True, is_virtual=True)
       
  1131     ## mac48-address.h: bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
  1132     cls.add_method('DeserializeFromString', 
       
  1133                    'bool', 
       
  1134                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1135                    is_virtual=True)
  1057     return
  1136     return
  1058 
  1137 
  1059 def register_Ns3Queue_methods(root_module, cls):
  1138 def register_Ns3Queue_methods(root_module, cls):
  1060     ## queue.h: ns3::Queue::Queue(ns3::Queue const & arg0) [copy constructor]
  1139     ## queue.h: ns3::Queue::Queue(ns3::Queue const & arg0) [copy constructor]
  1061     cls.add_constructor([param('ns3::Queue const &', 'arg0')])
  1140     cls.add_constructor([param('ns3::Queue const &', 'arg0')])
  1079     cls.add_method('Dequeue', 
  1158     cls.add_method('Dequeue', 
  1080                    'ns3::Ptr< ns3::Packet >', 
  1159                    'ns3::Ptr< ns3::Packet >', 
  1081                    [])
  1160                    [])
  1082     ## queue.h: ns3::Ptr<const ns3::Packet> ns3::Queue::Peek() const [member function]
  1161     ## queue.h: ns3::Ptr<const ns3::Packet> ns3::Queue::Peek() const [member function]
  1083     cls.add_method('Peek', 
  1162     cls.add_method('Peek', 
  1084                    'ns3::Ptr< const ns3::Packet >', 
  1163                    'ns3::Ptr< ns3::Packet const >', 
  1085                    [], 
  1164                    [], 
  1086                    is_const=True)
  1165                    is_const=True)
  1087     ## queue.h: void ns3::Queue::DequeueAll() [member function]
  1166     ## queue.h: void ns3::Queue::DequeueAll() [member function]
  1088     cls.add_method('DequeueAll', 
  1167     cls.add_method('DequeueAll', 
  1089                    'void', 
  1168                    'void', 
  1137                    'ns3::Ptr< ns3::Packet >', 
  1216                    'ns3::Ptr< ns3::Packet >', 
  1138                    [], 
  1217                    [], 
  1139                    is_pure_virtual=True, visibility='private', is_virtual=True)
  1218                    is_pure_virtual=True, visibility='private', is_virtual=True)
  1140     ## queue.h: ns3::Ptr<const ns3::Packet> ns3::Queue::DoPeek() const [member function]
  1219     ## queue.h: ns3::Ptr<const ns3::Packet> ns3::Queue::DoPeek() const [member function]
  1141     cls.add_method('DoPeek', 
  1220     cls.add_method('DoPeek', 
  1142                    'ns3::Ptr< const ns3::Packet >', 
  1221                    'ns3::Ptr< ns3::Packet const >', 
  1143                    [], 
  1222                    [], 
  1144                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1223                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1145     return
  1224     return
  1146 
  1225 
  1147 def register_Ns3Socket_methods(root_module, cls):
  1226 def register_Ns3Socket_methods(root_module, cls):
  1169                    'void', 
  1248                    'void', 
  1170                    [param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'connectionSucceeded'), param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'connectionFailed')])
  1249                    [param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'connectionSucceeded'), param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'connectionFailed')])
  1171     ## socket.h: void ns3::Socket::SetAcceptCallback(ns3::Callback<bool, ns3::Ptr<ns3::Socket>, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionRequest, ns3::Callback<void, ns3::Ptr<ns3::Socket>, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty> newConnectionCreated) [member function]
  1250     ## socket.h: void ns3::Socket::SetAcceptCallback(ns3::Callback<bool, ns3::Ptr<ns3::Socket>, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionRequest, ns3::Callback<void, ns3::Ptr<ns3::Socket>, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty> newConnectionCreated) [member function]
  1172     cls.add_method('SetAcceptCallback', 
  1251     cls.add_method('SetAcceptCallback', 
  1173                    'void', 
  1252                    'void', 
  1174                    [param('ns3::Callback< bool, ns3::Ptr< ns3::Socket >, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'connectionRequest'), param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'newConnectionCreated')])
  1253                    [param('ns3::Callback< bool, ns3::Ptr< ns3::Socket >, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'connectionRequest'), param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'newConnectionCreated')])
  1175     ## socket.h: bool ns3::Socket::SetDataSentCallback(ns3::Callback<void, ns3::Ptr<ns3::Socket>, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty> dataSent) [member function]
  1254     ## socket.h: bool ns3::Socket::SetDataSentCallback(ns3::Callback<void, ns3::Ptr<ns3::Socket>, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty> dataSent) [member function]
  1176     cls.add_method('SetDataSentCallback', 
  1255     cls.add_method('SetDataSentCallback', 
  1177                    'bool', 
  1256                    'bool', 
  1178                    [param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'dataSent')])
  1257                    [param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'dataSent')])
  1179     ## socket.h: void ns3::Socket::SetSendCallback(ns3::Callback<void, ns3::Ptr<ns3::Socket>, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty> sendCb) [member function]
  1258     ## socket.h: void ns3::Socket::SetSendCallback(ns3::Callback<void, ns3::Ptr<ns3::Socket>, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty> sendCb) [member function]
  1312                    'void', 
  1391                    'void', 
  1313                    [], 
  1392                    [], 
  1314                    visibility='protected')
  1393                    visibility='protected')
  1315     return
  1394     return
  1316 
  1395 
  1317 def register_Ns3Ipv4Header_methods(root_module, cls):
  1396 def register_Ns3SocketAddressTag_methods(root_module, cls):
  1318     ## ipv4-header.h: ns3::Ipv4Header::Ipv4Header(ns3::Ipv4Header const & arg0) [copy constructor]
  1397     ## socket.h: ns3::SocketAddressTag::SocketAddressTag(ns3::SocketAddressTag const & arg0) [copy constructor]
  1319     cls.add_constructor([param('ns3::Ipv4Header const &', 'arg0')])
  1398     cls.add_constructor([param('ns3::SocketAddressTag const &', 'arg0')])
  1320     ## ipv4-header.h: ns3::Ipv4Header::Ipv4Header() [constructor]
  1399     ## socket.h: ns3::SocketAddressTag::SocketAddressTag() [constructor]
  1321     cls.add_constructor([])
  1400     cls.add_constructor([])
  1322     ## ipv4-header.h: void ns3::Ipv4Header::EnableChecksum() [member function]
  1401     ## socket.h: void ns3::SocketAddressTag::SetAddress(ns3::Address addr) [member function]
  1323     cls.add_method('EnableChecksum', 
  1402     cls.add_method('SetAddress', 
  1324                    'void', 
  1403                    'void', 
  1325                    [])
  1404                    [param('ns3::Address', 'addr')])
  1326     ## ipv4-header.h: void ns3::Ipv4Header::SetPayloadSize(uint16_t size) [member function]
  1405     ## socket.h: ns3::Address ns3::SocketAddressTag::GetAddress() const [member function]
  1327     cls.add_method('SetPayloadSize', 
  1406     cls.add_method('GetAddress', 
  1328                    'void', 
  1407                    'ns3::Address', 
  1329                    [param('uint16_t', 'size')])
  1408                    [], 
  1330     ## ipv4-header.h: void ns3::Ipv4Header::SetIdentification(uint16_t identification) [member function]
  1409                    is_const=True)
  1331     cls.add_method('SetIdentification', 
  1410     ## socket.h: static ns3::TypeId ns3::SocketAddressTag::GetTypeId() [member function]
  1332                    'void', 
  1411     cls.add_method('GetTypeId', 
  1333                    [param('uint16_t', 'identification')])
  1412                    'ns3::TypeId', 
  1334     ## ipv4-header.h: void ns3::Ipv4Header::SetTos(uint8_t tos) [member function]
  1413                    [], 
  1335     cls.add_method('SetTos', 
  1414                    is_static=True)
  1336                    'void', 
  1415     ## socket.h: ns3::TypeId ns3::SocketAddressTag::GetInstanceTypeId() const [member function]
  1337                    [param('uint8_t', 'tos')])
  1416     cls.add_method('GetInstanceTypeId', 
  1338     ## ipv4-header.h: void ns3::Ipv4Header::SetMoreFragments() [member function]
  1417                    'ns3::TypeId', 
  1339     cls.add_method('SetMoreFragments', 
  1418                    [], 
  1340                    'void', 
  1419                    is_const=True, is_virtual=True)
  1341                    [])
  1420     ## socket.h: uint32_t ns3::SocketAddressTag::GetSerializedSize() const [member function]
  1342     ## ipv4-header.h: void ns3::Ipv4Header::SetLastFragment() [member function]
  1421     cls.add_method('GetSerializedSize', 
  1343     cls.add_method('SetLastFragment', 
  1422                    'uint32_t', 
  1344                    'void', 
  1423                    [], 
  1345                    [])
  1424                    is_const=True, is_virtual=True)
  1346     ## ipv4-header.h: void ns3::Ipv4Header::SetDontFragment() [member function]
  1425     ## socket.h: void ns3::SocketAddressTag::Serialize(ns3::TagBuffer i) const [member function]
  1347     cls.add_method('SetDontFragment', 
  1426     cls.add_method('Serialize', 
  1348                    'void', 
  1427                    'void', 
  1349                    [])
  1428                    [param('ns3::TagBuffer', 'i')], 
  1350     ## ipv4-header.h: void ns3::Ipv4Header::SetMayFragment() [member function]
  1429                    is_const=True, is_virtual=True)
  1351     cls.add_method('SetMayFragment', 
  1430     ## socket.h: void ns3::SocketAddressTag::Deserialize(ns3::TagBuffer i) [member function]
  1352                    'void', 
  1431     cls.add_method('Deserialize', 
  1353                    [])
  1432                    'void', 
  1354     ## ipv4-header.h: void ns3::Ipv4Header::SetFragmentOffset(uint16_t offset) [member function]
  1433                    [param('ns3::TagBuffer', 'i')], 
  1355     cls.add_method('SetFragmentOffset', 
  1434                    is_virtual=True)
  1356                    'void', 
  1435     ## socket.h: void ns3::SocketAddressTag::Print(std::ostream & os) const [member function]
  1357                    [param('uint16_t', 'offset')])
  1436     cls.add_method('Print', 
  1358     ## ipv4-header.h: void ns3::Ipv4Header::SetTtl(uint8_t ttl) [member function]
  1437                    'void', 
       
  1438                    [param('std::ostream &', 'os')], 
       
  1439                    is_const=True, is_virtual=True)
       
  1440     return
       
  1441 
       
  1442 def register_Ns3SocketFactory_methods(root_module, cls):
       
  1443     ## socket-factory.h: ns3::SocketFactory::SocketFactory(ns3::SocketFactory const & arg0) [copy constructor]
       
  1444     cls.add_constructor([param('ns3::SocketFactory const &', 'arg0')])
       
  1445     ## socket-factory.h: static ns3::TypeId ns3::SocketFactory::GetTypeId() [member function]
       
  1446     cls.add_method('GetTypeId', 
       
  1447                    'ns3::TypeId', 
       
  1448                    [], 
       
  1449                    is_static=True)
       
  1450     ## socket-factory.h: ns3::SocketFactory::SocketFactory() [constructor]
       
  1451     cls.add_constructor([])
       
  1452     ## socket-factory.h: ns3::Ptr<ns3::Socket> ns3::SocketFactory::CreateSocket() [member function]
       
  1453     cls.add_method('CreateSocket', 
       
  1454                    'ns3::Ptr< ns3::Socket >', 
       
  1455                    [], 
       
  1456                    is_pure_virtual=True, is_virtual=True)
       
  1457     return
       
  1458 
       
  1459 def register_Ns3SocketIpTtlTag_methods(root_module, cls):
       
  1460     ## socket.h: ns3::SocketIpTtlTag::SocketIpTtlTag(ns3::SocketIpTtlTag const & arg0) [copy constructor]
       
  1461     cls.add_constructor([param('ns3::SocketIpTtlTag const &', 'arg0')])
       
  1462     ## socket.h: ns3::SocketIpTtlTag::SocketIpTtlTag() [constructor]
       
  1463     cls.add_constructor([])
       
  1464     ## socket.h: void ns3::SocketIpTtlTag::SetTtl(uint8_t ttl) [member function]
  1359     cls.add_method('SetTtl', 
  1465     cls.add_method('SetTtl', 
  1360                    'void', 
  1466                    'void', 
  1361                    [param('uint8_t', 'ttl')])
  1467                    [param('uint8_t', 'ttl')])
  1362     ## ipv4-header.h: void ns3::Ipv4Header::SetProtocol(uint8_t num) [member function]
  1468     ## socket.h: uint8_t ns3::SocketIpTtlTag::GetTtl() const [member function]
  1363     cls.add_method('SetProtocol', 
       
  1364                    'void', 
       
  1365                    [param('uint8_t', 'num')])
       
  1366     ## ipv4-header.h: void ns3::Ipv4Header::SetSource(ns3::Ipv4Address source) [member function]
       
  1367     cls.add_method('SetSource', 
       
  1368                    'void', 
       
  1369                    [param('ns3::Ipv4Address', 'source')])
       
  1370     ## ipv4-header.h: void ns3::Ipv4Header::SetDestination(ns3::Ipv4Address destination) [member function]
       
  1371     cls.add_method('SetDestination', 
       
  1372                    'void', 
       
  1373                    [param('ns3::Ipv4Address', 'destination')])
       
  1374     ## ipv4-header.h: uint16_t ns3::Ipv4Header::GetPayloadSize() const [member function]
       
  1375     cls.add_method('GetPayloadSize', 
       
  1376                    'uint16_t', 
       
  1377                    [], 
       
  1378                    is_const=True)
       
  1379     ## ipv4-header.h: uint16_t ns3::Ipv4Header::GetIdentification() const [member function]
       
  1380     cls.add_method('GetIdentification', 
       
  1381                    'uint16_t', 
       
  1382                    [], 
       
  1383                    is_const=True)
       
  1384     ## ipv4-header.h: uint8_t ns3::Ipv4Header::GetTos() const [member function]
       
  1385     cls.add_method('GetTos', 
       
  1386                    'uint8_t', 
       
  1387                    [], 
       
  1388                    is_const=True)
       
  1389     ## ipv4-header.h: bool ns3::Ipv4Header::IsLastFragment() const [member function]
       
  1390     cls.add_method('IsLastFragment', 
       
  1391                    'bool', 
       
  1392                    [], 
       
  1393                    is_const=True)
       
  1394     ## ipv4-header.h: bool ns3::Ipv4Header::IsDontFragment() const [member function]
       
  1395     cls.add_method('IsDontFragment', 
       
  1396                    'bool', 
       
  1397                    [], 
       
  1398                    is_const=True)
       
  1399     ## ipv4-header.h: uint16_t ns3::Ipv4Header::GetFragmentOffset() const [member function]
       
  1400     cls.add_method('GetFragmentOffset', 
       
  1401                    'uint16_t', 
       
  1402                    [], 
       
  1403                    is_const=True)
       
  1404     ## ipv4-header.h: uint8_t ns3::Ipv4Header::GetTtl() const [member function]
       
  1405     cls.add_method('GetTtl', 
  1469     cls.add_method('GetTtl', 
  1406                    'uint8_t', 
  1470                    'uint8_t', 
  1407                    [], 
  1471                    [], 
  1408                    is_const=True)
  1472                    is_const=True)
  1409     ## ipv4-header.h: uint8_t ns3::Ipv4Header::GetProtocol() const [member function]
  1473     ## socket.h: static ns3::TypeId ns3::SocketIpTtlTag::GetTypeId() [member function]
  1410     cls.add_method('GetProtocol', 
       
  1411                    'uint8_t', 
       
  1412                    [], 
       
  1413                    is_const=True)
       
  1414     ## ipv4-header.h: ns3::Ipv4Address ns3::Ipv4Header::GetSource() const [member function]
       
  1415     cls.add_method('GetSource', 
       
  1416                    'ns3::Ipv4Address', 
       
  1417                    [], 
       
  1418                    is_const=True)
       
  1419     ## ipv4-header.h: ns3::Ipv4Address ns3::Ipv4Header::GetDestination() const [member function]
       
  1420     cls.add_method('GetDestination', 
       
  1421                    'ns3::Ipv4Address', 
       
  1422                    [], 
       
  1423                    is_const=True)
       
  1424     ## ipv4-header.h: bool ns3::Ipv4Header::IsChecksumOk() const [member function]
       
  1425     cls.add_method('IsChecksumOk', 
       
  1426                    'bool', 
       
  1427                    [], 
       
  1428                    is_const=True)
       
  1429     ## ipv4-header.h: static ns3::TypeId ns3::Ipv4Header::GetTypeId() [member function]
       
  1430     cls.add_method('GetTypeId', 
  1474     cls.add_method('GetTypeId', 
  1431                    'ns3::TypeId', 
  1475                    'ns3::TypeId', 
  1432                    [], 
  1476                    [], 
  1433                    is_static=True)
  1477                    is_static=True)
  1434     ## ipv4-header.h: ns3::TypeId ns3::Ipv4Header::GetInstanceTypeId() const [member function]
  1478     ## socket.h: ns3::TypeId ns3::SocketIpTtlTag::GetInstanceTypeId() const [member function]
  1435     cls.add_method('GetInstanceTypeId', 
  1479     cls.add_method('GetInstanceTypeId', 
  1436                    'ns3::TypeId', 
  1480                    'ns3::TypeId', 
  1437                    [], 
  1481                    [], 
  1438                    is_const=True, is_virtual=True)
  1482                    is_const=True, is_virtual=True)
  1439     ## ipv4-header.h: void ns3::Ipv4Header::Print(std::ostream & os) const [member function]
  1483     ## socket.h: uint32_t ns3::SocketIpTtlTag::GetSerializedSize() const [member function]
       
  1484     cls.add_method('GetSerializedSize', 
       
  1485                    'uint32_t', 
       
  1486                    [], 
       
  1487                    is_const=True, is_virtual=True)
       
  1488     ## socket.h: void ns3::SocketIpTtlTag::Serialize(ns3::TagBuffer i) const [member function]
       
  1489     cls.add_method('Serialize', 
       
  1490                    'void', 
       
  1491                    [param('ns3::TagBuffer', 'i')], 
       
  1492                    is_const=True, is_virtual=True)
       
  1493     ## socket.h: void ns3::SocketIpTtlTag::Deserialize(ns3::TagBuffer i) [member function]
       
  1494     cls.add_method('Deserialize', 
       
  1495                    'void', 
       
  1496                    [param('ns3::TagBuffer', 'i')], 
       
  1497                    is_virtual=True)
       
  1498     ## socket.h: void ns3::SocketIpTtlTag::Print(std::ostream & os) const [member function]
  1440     cls.add_method('Print', 
  1499     cls.add_method('Print', 
  1441                    'void', 
  1500                    'void', 
  1442                    [param('std::ostream &', 'os')], 
  1501                    [param('std::ostream &', 'os')], 
  1443                    is_const=True, is_virtual=True)
  1502                    is_const=True, is_virtual=True)
  1444     ## ipv4-header.h: uint32_t ns3::Ipv4Header::GetSerializedSize() const [member function]
  1503     return
  1445     cls.add_method('GetSerializedSize', 
  1504 
  1446                    'uint32_t', 
  1505 def register_Ns3TcpSocket_methods(root_module, cls):
  1447                    [], 
  1506     ## tcp-socket.h: ns3::TcpSocket::TcpSocket(ns3::TcpSocket const & arg0) [copy constructor]
  1448                    is_const=True, is_virtual=True)
  1507     cls.add_constructor([param('ns3::TcpSocket const &', 'arg0')])
  1449     ## ipv4-header.h: void ns3::Ipv4Header::Serialize(ns3::Buffer::Iterator start) const [member function]
  1508     ## tcp-socket.h: static ns3::TypeId ns3::TcpSocket::GetTypeId() [member function]
  1450     cls.add_method('Serialize', 
  1509     cls.add_method('GetTypeId', 
  1451                    'void', 
  1510                    'ns3::TypeId', 
  1452                    [param('ns3::Buffer::Iterator', 'start')], 
  1511                    [], 
  1453                    is_const=True, is_virtual=True)
  1512                    is_static=True)
  1454     ## ipv4-header.h: uint32_t ns3::Ipv4Header::Deserialize(ns3::Buffer::Iterator start) [member function]
  1513     ## tcp-socket.h: ns3::TcpSocket::TcpSocket() [constructor]
  1455     cls.add_method('Deserialize', 
  1514     cls.add_constructor([])
  1456                    'uint32_t', 
  1515     ## tcp-socket.h: void ns3::TcpSocket::SetSndBufSize(uint32_t size) [member function]
  1457                    [param('ns3::Buffer::Iterator', 'start')], 
  1516     cls.add_method('SetSndBufSize', 
  1458                    is_virtual=True)
  1517                    'void', 
       
  1518                    [param('uint32_t', 'size')], 
       
  1519                    is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1520     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSndBufSize() const [member function]
       
  1521     cls.add_method('GetSndBufSize', 
       
  1522                    'uint32_t', 
       
  1523                    [], 
       
  1524                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1525     ## tcp-socket.h: void ns3::TcpSocket::SetRcvBufSize(uint32_t size) [member function]
       
  1526     cls.add_method('SetRcvBufSize', 
       
  1527                    'void', 
       
  1528                    [param('uint32_t', 'size')], 
       
  1529                    is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1530     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetRcvBufSize() const [member function]
       
  1531     cls.add_method('GetRcvBufSize', 
       
  1532                    'uint32_t', 
       
  1533                    [], 
       
  1534                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1535     ## tcp-socket.h: void ns3::TcpSocket::SetSegSize(uint32_t size) [member function]
       
  1536     cls.add_method('SetSegSize', 
       
  1537                    'void', 
       
  1538                    [param('uint32_t', 'size')], 
       
  1539                    is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1540     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSegSize() const [member function]
       
  1541     cls.add_method('GetSegSize', 
       
  1542                    'uint32_t', 
       
  1543                    [], 
       
  1544                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1545     ## tcp-socket.h: void ns3::TcpSocket::SetSSThresh(uint32_t threshold) [member function]
       
  1546     cls.add_method('SetSSThresh', 
       
  1547                    'void', 
       
  1548                    [param('uint32_t', 'threshold')], 
       
  1549                    is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1550     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSSThresh() const [member function]
       
  1551     cls.add_method('GetSSThresh', 
       
  1552                    'uint32_t', 
       
  1553                    [], 
       
  1554                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1555     ## tcp-socket.h: void ns3::TcpSocket::SetInitialCwnd(uint32_t count) [member function]
       
  1556     cls.add_method('SetInitialCwnd', 
       
  1557                    'void', 
       
  1558                    [param('uint32_t', 'count')], 
       
  1559                    is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1560     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetInitialCwnd() const [member function]
       
  1561     cls.add_method('GetInitialCwnd', 
       
  1562                    'uint32_t', 
       
  1563                    [], 
       
  1564                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1565     ## tcp-socket.h: void ns3::TcpSocket::SetConnTimeout(ns3::Time timeout) [member function]
       
  1566     cls.add_method('SetConnTimeout', 
       
  1567                    'void', 
       
  1568                    [param('ns3::Time', 'timeout')], 
       
  1569                    is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1570     ## tcp-socket.h: ns3::Time ns3::TcpSocket::GetConnTimeout() const [member function]
       
  1571     cls.add_method('GetConnTimeout', 
       
  1572                    'ns3::Time', 
       
  1573                    [], 
       
  1574                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1575     ## tcp-socket.h: void ns3::TcpSocket::SetConnCount(uint32_t count) [member function]
       
  1576     cls.add_method('SetConnCount', 
       
  1577                    'void', 
       
  1578                    [param('uint32_t', 'count')], 
       
  1579                    is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1580     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetConnCount() const [member function]
       
  1581     cls.add_method('GetConnCount', 
       
  1582                    'uint32_t', 
       
  1583                    [], 
       
  1584                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1585     ## tcp-socket.h: void ns3::TcpSocket::SetDelAckTimeout(ns3::Time timeout) [member function]
       
  1586     cls.add_method('SetDelAckTimeout', 
       
  1587                    'void', 
       
  1588                    [param('ns3::Time', 'timeout')], 
       
  1589                    is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1590     ## tcp-socket.h: ns3::Time ns3::TcpSocket::GetDelAckTimeout() const [member function]
       
  1591     cls.add_method('GetDelAckTimeout', 
       
  1592                    'ns3::Time', 
       
  1593                    [], 
       
  1594                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1595     ## tcp-socket.h: void ns3::TcpSocket::SetDelAckMaxCount(uint32_t count) [member function]
       
  1596     cls.add_method('SetDelAckMaxCount', 
       
  1597                    'void', 
       
  1598                    [param('uint32_t', 'count')], 
       
  1599                    is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1600     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetDelAckMaxCount() const [member function]
       
  1601     cls.add_method('GetDelAckMaxCount', 
       
  1602                    'uint32_t', 
       
  1603                    [], 
       
  1604                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1605     return
       
  1606 
       
  1607 def register_Ns3TcpSocketFactory_methods(root_module, cls):
       
  1608     ## tcp-socket-factory.h: ns3::TcpSocketFactory::TcpSocketFactory(ns3::TcpSocketFactory const & arg0) [copy constructor]
       
  1609     cls.add_constructor([param('ns3::TcpSocketFactory const &', 'arg0')])
       
  1610     ## tcp-socket-factory.h: ns3::TcpSocketFactory::TcpSocketFactory() [constructor]
       
  1611     cls.add_constructor([])
       
  1612     ## tcp-socket-factory.h: static ns3::TypeId ns3::TcpSocketFactory::GetTypeId() [member function]
       
  1613     cls.add_method('GetTypeId', 
       
  1614                    'ns3::TypeId', 
       
  1615                    [], 
       
  1616                    is_static=True)
  1459     return
  1617     return
  1460 
  1618 
  1461 def register_Ns3UdpSocket_methods(root_module, cls):
  1619 def register_Ns3UdpSocket_methods(root_module, cls):
  1462     ## udp-socket.h: ns3::UdpSocket::UdpSocket(ns3::UdpSocket const & arg0) [copy constructor]
  1620     ## udp-socket.h: ns3::UdpSocket::UdpSocket(ns3::UdpSocket const & arg0) [copy constructor]
  1463     cls.add_constructor([param('ns3::UdpSocket const &', 'arg0')])
  1621     cls.add_constructor([param('ns3::UdpSocket const &', 'arg0')])
  1498                    'uint32_t', 
  1656                    'uint32_t', 
  1499                    [], 
  1657                    [], 
  1500                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1658                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1501     return
  1659     return
  1502 
  1660 
  1503 def register_Ns3NetDevice_methods(root_module, cls):
  1661 def register_Ns3UdpSocketFactory_methods(root_module, cls):
  1504     ## net-device.h: ns3::NetDevice::NetDevice(ns3::NetDevice const & arg0) [copy constructor]
  1662     ## udp-socket-factory.h: ns3::UdpSocketFactory::UdpSocketFactory(ns3::UdpSocketFactory const & arg0) [copy constructor]
  1505     cls.add_constructor([param('ns3::NetDevice const &', 'arg0')])
  1663     cls.add_constructor([param('ns3::UdpSocketFactory const &', 'arg0')])
  1506     ## net-device.h: ns3::NetDevice::NetDevice() [constructor]
  1664     ## udp-socket-factory.h: ns3::UdpSocketFactory::UdpSocketFactory() [constructor]
  1507     cls.add_constructor([])
  1665     cls.add_constructor([])
  1508     ## net-device.h: static ns3::TypeId ns3::NetDevice::GetTypeId() [member function]
  1666     ## udp-socket-factory.h: static ns3::TypeId ns3::UdpSocketFactory::GetTypeId() [member function]
  1509     cls.add_method('GetTypeId', 
  1667     cls.add_method('GetTypeId', 
  1510                    'ns3::TypeId', 
  1668                    'ns3::TypeId', 
  1511                    [], 
  1669                    [], 
  1512                    is_static=True)
  1670                    is_static=True)
  1513     ## net-device.h: void ns3::NetDevice::SetName(std::string const name) [member function]
  1671     return
  1514     cls.add_method('SetName', 
  1672 
  1515                    'void', 
  1673 def register_Ns3AddressChecker_methods(root_module, cls):
  1516                    [param('std::string const', 'name')], 
  1674     ## address.h: ns3::AddressChecker::AddressChecker(ns3::AddressChecker const & arg0) [copy constructor]
  1517                    is_pure_virtual=True, is_virtual=True)
  1675     cls.add_constructor([param('ns3::AddressChecker const &', 'arg0')])
  1518     ## net-device.h: std::string ns3::NetDevice::GetName() const [member function]
  1676     ## address.h: ns3::AddressChecker::AddressChecker() [constructor]
  1519     cls.add_method('GetName', 
  1677     cls.add_constructor([])
  1520                    'std::string', 
       
  1521                    [], 
       
  1522                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1523     ## net-device.h: void ns3::NetDevice::SetIfIndex(uint32_t const index) [member function]
       
  1524     cls.add_method('SetIfIndex', 
       
  1525                    'void', 
       
  1526                    [param('uint32_t const', 'index')], 
       
  1527                    is_pure_virtual=True, is_virtual=True)
       
  1528     ## net-device.h: uint32_t ns3::NetDevice::GetIfIndex() const [member function]
       
  1529     cls.add_method('GetIfIndex', 
       
  1530                    'uint32_t', 
       
  1531                    [], 
       
  1532                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1533     ## net-device.h: ns3::Ptr<ns3::Channel> ns3::NetDevice::GetChannel() const [member function]
       
  1534     cls.add_method('GetChannel', 
       
  1535                    'ns3::Ptr< ns3::Channel >', 
       
  1536                    [], 
       
  1537                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1538     ## net-device.h: ns3::Address ns3::NetDevice::GetAddress() const [member function]
       
  1539     cls.add_method('GetAddress', 
       
  1540                    'ns3::Address', 
       
  1541                    [], 
       
  1542                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1543     ## net-device.h: bool ns3::NetDevice::SetMtu(uint16_t const mtu) [member function]
       
  1544     cls.add_method('SetMtu', 
       
  1545                    'bool', 
       
  1546                    [param('uint16_t const', 'mtu')], 
       
  1547                    is_pure_virtual=True, is_virtual=True)
       
  1548     ## net-device.h: uint16_t ns3::NetDevice::GetMtu() const [member function]
       
  1549     cls.add_method('GetMtu', 
       
  1550                    'uint16_t', 
       
  1551                    [], 
       
  1552                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1553     ## net-device.h: bool ns3::NetDevice::IsLinkUp() const [member function]
       
  1554     cls.add_method('IsLinkUp', 
       
  1555                    'bool', 
       
  1556                    [], 
       
  1557                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1558     ## net-device.h: void ns3::NetDevice::SetLinkChangeCallback(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]
       
  1559     cls.add_method('SetLinkChangeCallback', 
       
  1560                    'void', 
       
  1561                    [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')], 
       
  1562                    is_pure_virtual=True, is_virtual=True)
       
  1563     ## net-device.h: bool ns3::NetDevice::IsBroadcast() const [member function]
       
  1564     cls.add_method('IsBroadcast', 
       
  1565                    'bool', 
       
  1566                    [], 
       
  1567                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1568     ## net-device.h: ns3::Address ns3::NetDevice::GetBroadcast() const [member function]
       
  1569     cls.add_method('GetBroadcast', 
       
  1570                    'ns3::Address', 
       
  1571                    [], 
       
  1572                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1573     ## net-device.h: bool ns3::NetDevice::IsMulticast() const [member function]
       
  1574     cls.add_method('IsMulticast', 
       
  1575                    'bool', 
       
  1576                    [], 
       
  1577                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1578     ## net-device.h: ns3::Address ns3::NetDevice::GetMulticast() const [member function]
       
  1579     cls.add_method('GetMulticast', 
       
  1580                    'ns3::Address', 
       
  1581                    [], 
       
  1582                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1583     ## net-device.h: ns3::Address ns3::NetDevice::MakeMulticastAddress(ns3::Ipv4Address multicastGroup) const [member function]
       
  1584     cls.add_method('MakeMulticastAddress', 
       
  1585                    'ns3::Address', 
       
  1586                    [param('ns3::Ipv4Address', 'multicastGroup')], 
       
  1587                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1588     ## net-device.h: bool ns3::NetDevice::IsPointToPoint() const [member function]
       
  1589     cls.add_method('IsPointToPoint', 
       
  1590                    'bool', 
       
  1591                    [], 
       
  1592                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1593     ## net-device.h: bool ns3::NetDevice::Send(ns3::Ptr<ns3::Packet> packet, ns3::Address const & dest, uint16_t protocolNumber) [member function]
       
  1594     cls.add_method('Send', 
       
  1595                    'bool', 
       
  1596                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], 
       
  1597                    is_pure_virtual=True, is_virtual=True)
       
  1598     ## net-device.h: bool ns3::NetDevice::SendFrom(ns3::Ptr<ns3::Packet> packet, ns3::Address const & source, ns3::Address const & dest, uint16_t protocolNumber) [member function]
       
  1599     cls.add_method('SendFrom', 
       
  1600                    'bool', 
       
  1601                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], 
       
  1602                    is_pure_virtual=True, is_virtual=True)
       
  1603     ## net-device.h: ns3::Ptr<ns3::Node> ns3::NetDevice::GetNode() const [member function]
       
  1604     cls.add_method('GetNode', 
       
  1605                    'ns3::Ptr< ns3::Node >', 
       
  1606                    [], 
       
  1607                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1608     ## net-device.h: void ns3::NetDevice::SetNode(ns3::Ptr<ns3::Node> node) [member function]
       
  1609     cls.add_method('SetNode', 
       
  1610                    'void', 
       
  1611                    [param('ns3::Ptr< ns3::Node >', 'node')], 
       
  1612                    is_pure_virtual=True, is_virtual=True)
       
  1613     ## net-device.h: bool ns3::NetDevice::NeedsArp() const [member function]
       
  1614     cls.add_method('NeedsArp', 
       
  1615                    'bool', 
       
  1616                    [], 
       
  1617                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1618     ## net-device.h: void ns3::NetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function]
       
  1619     cls.add_method('SetReceiveCallback', 
       
  1620                    'void', 
       
  1621                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
       
  1622                    is_pure_virtual=True, is_virtual=True)
       
  1623     ## net-device.h: void ns3::NetDevice::SetPromiscReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> cb) [member function]
       
  1624     cls.add_method('SetPromiscReceiveCallback', 
       
  1625                    'void', 
       
  1626                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'cb')], 
       
  1627                    is_pure_virtual=True, is_virtual=True)
       
  1628     ## net-device.h: bool ns3::NetDevice::SupportsSendFrom() const [member function]
       
  1629     cls.add_method('SupportsSendFrom', 
       
  1630                    'bool', 
       
  1631                    [], 
       
  1632                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1633     return
       
  1634 
       
  1635 def register_Ns3DropTailQueue_methods(root_module, cls):
       
  1636     ## drop-tail-queue.h: ns3::DropTailQueue::DropTailQueue(ns3::DropTailQueue const & arg0) [copy constructor]
       
  1637     cls.add_constructor([param('ns3::DropTailQueue const &', 'arg0')])
       
  1638     ## drop-tail-queue.h: static ns3::TypeId ns3::DropTailQueue::GetTypeId() [member function]
       
  1639     cls.add_method('GetTypeId', 
       
  1640                    'ns3::TypeId', 
       
  1641                    [], 
       
  1642                    is_static=True)
       
  1643     ## drop-tail-queue.h: ns3::DropTailQueue::DropTailQueue() [constructor]
       
  1644     cls.add_constructor([])
       
  1645     ## drop-tail-queue.h: bool ns3::DropTailQueue::DoEnqueue(ns3::Ptr<ns3::Packet> p) [member function]
       
  1646     cls.add_method('DoEnqueue', 
       
  1647                    'bool', 
       
  1648                    [param('ns3::Ptr< ns3::Packet >', 'p')], 
       
  1649                    visibility='private', is_virtual=True)
       
  1650     ## drop-tail-queue.h: ns3::Ptr<ns3::Packet> ns3::DropTailQueue::DoDequeue() [member function]
       
  1651     cls.add_method('DoDequeue', 
       
  1652                    'ns3::Ptr< ns3::Packet >', 
       
  1653                    [], 
       
  1654                    visibility='private', is_virtual=True)
       
  1655     ## drop-tail-queue.h: ns3::Ptr<const ns3::Packet> ns3::DropTailQueue::DoPeek() const [member function]
       
  1656     cls.add_method('DoPeek', 
       
  1657                    'ns3::Ptr< const ns3::Packet >', 
       
  1658                    [], 
       
  1659                    is_const=True, visibility='private', is_virtual=True)
       
  1660     return
  1678     return
  1661 
  1679 
  1662 def register_Ns3AddressValue_methods(root_module, cls):
  1680 def register_Ns3AddressValue_methods(root_module, cls):
  1663     ## address.h: ns3::AddressValue::AddressValue(ns3::AddressValue const & arg0) [copy constructor]
  1681     ## address.h: ns3::AddressValue::AddressValue(ns3::AddressValue const & arg0) [copy constructor]
  1664     cls.add_constructor([param('ns3::AddressValue const &', 'arg0')])
  1682     cls.add_constructor([param('ns3::AddressValue const &', 'arg0')])
  1690                    'bool', 
  1708                    'bool', 
  1691                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1709                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1692                    is_virtual=True)
  1710                    is_virtual=True)
  1693     return
  1711     return
  1694 
  1712 
  1695 def register_Ns3Node_methods(root_module, cls):
  1713 def register_Ns3Application_methods(root_module, cls):
  1696     ## node.h: ns3::Node::Node(ns3::Node const & arg0) [copy constructor]
  1714     ## application.h: ns3::Application::Application(ns3::Application const & arg0) [copy constructor]
  1697     cls.add_constructor([param('ns3::Node const &', 'arg0')])
  1715     cls.add_constructor([param('ns3::Application const &', 'arg0')])
  1698     ## node.h: static ns3::TypeId ns3::Node::GetTypeId() [member function]
  1716     ## application.h: static ns3::TypeId ns3::Application::GetTypeId() [member function]
  1699     cls.add_method('GetTypeId', 
  1717     cls.add_method('GetTypeId', 
  1700                    'ns3::TypeId', 
  1718                    'ns3::TypeId', 
  1701                    [], 
  1719                    [], 
  1702                    is_static=True)
  1720                    is_static=True)
  1703     ## node.h: ns3::Node::Node() [constructor]
  1721     ## application.h: ns3::Application::Application() [constructor]
  1704     cls.add_constructor([])
  1722     cls.add_constructor([])
  1705     ## node.h: ns3::Node::Node(uint32_t systemId) [constructor]
  1723     ## application.h: void ns3::Application::Start(ns3::Time const & startTime) [member function]
  1706     cls.add_constructor([param('uint32_t', 'systemId')])
  1724     cls.add_method('Start', 
  1707     ## node.h: uint32_t ns3::Node::GetId() const [member function]
  1725                    'void', 
  1708     cls.add_method('GetId', 
  1726                    [param('ns3::Time const &', 'startTime')])
  1709                    'uint32_t', 
  1727     ## application.h: void ns3::Application::Start(ns3::RandomVariable const & startVariable) [member function]
  1710                    [], 
  1728     cls.add_method('Start', 
  1711                    is_const=True)
  1729                    'void', 
  1712     ## node.h: uint32_t ns3::Node::GetSystemId() const [member function]
  1730                    [param('ns3::RandomVariable const &', 'startVariable')])
  1713     cls.add_method('GetSystemId', 
  1731     ## application.h: void ns3::Application::Stop(ns3::Time const & stopTime) [member function]
  1714                    'uint32_t', 
  1732     cls.add_method('Stop', 
  1715                    [], 
  1733                    'void', 
  1716                    is_const=True)
  1734                    [param('ns3::Time const &', 'stopTime')])
  1717     ## node.h: uint32_t ns3::Node::AddDevice(ns3::Ptr<ns3::NetDevice> device) [member function]
  1735     ## application.h: void ns3::Application::Stop(ns3::RandomVariable const & stopVariable) [member function]
  1718     cls.add_method('AddDevice', 
  1736     cls.add_method('Stop', 
  1719                    'uint32_t', 
  1737                    'void', 
  1720                    [param('ns3::Ptr< ns3::NetDevice >', 'device')])
  1738                    [param('ns3::RandomVariable const &', 'stopVariable')])
  1721     ## node.h: ns3::Ptr<ns3::NetDevice> ns3::Node::GetDevice(uint32_t index) const [member function]
  1739     ## application.h: ns3::Ptr<ns3::Node> ns3::Application::GetNode() const [member function]
  1722     cls.add_method('GetDevice', 
  1740     cls.add_method('GetNode', 
  1723                    'ns3::Ptr< ns3::NetDevice >', 
  1741                    'ns3::Ptr< ns3::Node >', 
  1724                    [param('uint32_t', 'index')], 
  1742                    [], 
  1725                    is_const=True)
  1743                    is_const=True)
  1726     ## node.h: uint32_t ns3::Node::GetNDevices() const [member function]
  1744     ## application.h: void ns3::Application::SetNode(ns3::Ptr<ns3::Node> node) [member function]
  1727     cls.add_method('GetNDevices', 
  1745     cls.add_method('SetNode', 
  1728                    'uint32_t', 
  1746                    'void', 
  1729                    [], 
  1747                    [param('ns3::Ptr< ns3::Node >', 'node')])
  1730                    is_const=True)
  1748     ## application.h: void ns3::Application::DoDispose() [member function]
  1731     ## node.h: uint32_t ns3::Node::AddApplication(ns3::Ptr<ns3::Application> application) [member function]
       
  1732     cls.add_method('AddApplication', 
       
  1733                    'uint32_t', 
       
  1734                    [param('ns3::Ptr< ns3::Application >', 'application')])
       
  1735     ## node.h: ns3::Ptr<ns3::Application> ns3::Node::GetApplication(uint32_t index) const [member function]
       
  1736     cls.add_method('GetApplication', 
       
  1737                    'ns3::Ptr< ns3::Application >', 
       
  1738                    [param('uint32_t', 'index')], 
       
  1739                    is_const=True)
       
  1740     ## node.h: uint32_t ns3::Node::GetNApplications() const [member function]
       
  1741     cls.add_method('GetNApplications', 
       
  1742                    'uint32_t', 
       
  1743                    [], 
       
  1744                    is_const=True)
       
  1745     ## node.h: void ns3::Node::RegisterProtocolHandler(ns3::Callback<void, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> handler, uint16_t protocolType, ns3::Ptr<ns3::NetDevice> device, bool promiscuous=false) [member function]
       
  1746     cls.add_method('RegisterProtocolHandler', 
       
  1747                    'void', 
       
  1748                    [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'handler'), param('uint16_t', 'protocolType'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'promiscuous', default_value='false')])
       
  1749     ## node.h: void ns3::Node::UnregisterProtocolHandler(ns3::Callback<void, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> handler) [member function]
       
  1750     cls.add_method('UnregisterProtocolHandler', 
       
  1751                    'void', 
       
  1752                    [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'handler')])
       
  1753     ## node.h: void ns3::Node::DoDispose() [member function]
       
  1754     cls.add_method('DoDispose', 
  1749     cls.add_method('DoDispose', 
  1755                    'void', 
  1750                    'void', 
  1756                    [], 
  1751                    [], 
  1757                    visibility='protected', is_virtual=True)
  1752                    visibility='protected', is_virtual=True)
  1758     ## node.h: void ns3::Node::NotifyDeviceAdded(ns3::Ptr<ns3::NetDevice> device) [member function]
  1753     ## application.h: void ns3::Application::StartApplication() [member function]
  1759     cls.add_method('NotifyDeviceAdded', 
  1754     cls.add_method('StartApplication', 
  1760                    'void', 
  1755                    'void', 
  1761                    [param('ns3::Ptr< ns3::NetDevice >', 'device')], 
  1756                    [], 
       
  1757                    visibility='private', is_virtual=True)
       
  1758     ## application.h: void ns3::Application::StopApplication() [member function]
       
  1759     cls.add_method('StopApplication', 
       
  1760                    'void', 
       
  1761                    [], 
  1762                    visibility='private', is_virtual=True)
  1762                    visibility='private', is_virtual=True)
  1763     return
  1763     return
  1764 
  1764 
  1765 def register_Ns3Channel_methods(root_module, cls):
  1765 def register_Ns3Channel_methods(root_module, cls):
  1766     ## channel.h: ns3::Channel::Channel(ns3::Channel const & arg0) [copy constructor]
  1766     ## channel.h: ns3::Channel::Channel(ns3::Channel const & arg0) [copy constructor]
  1792                    'ns3::Ptr< ns3::NetDevice >', 
  1792                    'ns3::Ptr< ns3::NetDevice >', 
  1793                    [param('uint32_t', 'i')], 
  1793                    [param('uint32_t', 'i')], 
  1794                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1794                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1795     return
  1795     return
  1796 
  1796 
  1797 def register_Ns3TcpSocket_methods(root_module, cls):
  1797 def register_Ns3DropTailQueue_methods(root_module, cls):
  1798     ## tcp-socket.h: ns3::TcpSocket::TcpSocket(ns3::TcpSocket const & arg0) [copy constructor]
  1798     ## drop-tail-queue.h: ns3::DropTailQueue::DropTailQueue(ns3::DropTailQueue const & arg0) [copy constructor]
  1799     cls.add_constructor([param('ns3::TcpSocket const &', 'arg0')])
  1799     cls.add_constructor([param('ns3::DropTailQueue const &', 'arg0')])
  1800     ## tcp-socket.h: static ns3::TypeId ns3::TcpSocket::GetTypeId() [member function]
  1800     ## drop-tail-queue.h: static ns3::TypeId ns3::DropTailQueue::GetTypeId() [member function]
  1801     cls.add_method('GetTypeId', 
  1801     cls.add_method('GetTypeId', 
  1802                    'ns3::TypeId', 
  1802                    'ns3::TypeId', 
  1803                    [], 
  1803                    [], 
  1804                    is_static=True)
  1804                    is_static=True)
  1805     ## tcp-socket.h: ns3::TcpSocket::TcpSocket() [constructor]
  1805     ## drop-tail-queue.h: ns3::DropTailQueue::DropTailQueue() [constructor]
  1806     cls.add_constructor([])
  1806     cls.add_constructor([])
  1807     ## tcp-socket.h: void ns3::TcpSocket::SetSndBufSize(uint32_t size) [member function]
  1807     ## drop-tail-queue.h: bool ns3::DropTailQueue::DoEnqueue(ns3::Ptr<ns3::Packet> p) [member function]
  1808     cls.add_method('SetSndBufSize', 
  1808     cls.add_method('DoEnqueue', 
  1809                    'void', 
  1809                    'bool', 
  1810                    [param('uint32_t', 'size')], 
  1810                    [param('ns3::Ptr< ns3::Packet >', 'p')], 
  1811                    is_pure_virtual=True, visibility='private', is_virtual=True)
  1811                    visibility='private', is_virtual=True)
  1812     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSndBufSize() const [member function]
  1812     ## drop-tail-queue.h: ns3::Ptr<ns3::Packet> ns3::DropTailQueue::DoDequeue() [member function]
  1813     cls.add_method('GetSndBufSize', 
  1813     cls.add_method('DoDequeue', 
  1814                    'uint32_t', 
  1814                    'ns3::Ptr< ns3::Packet >', 
  1815                    [], 
  1815                    [], 
  1816                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1816                    visibility='private', is_virtual=True)
  1817     ## tcp-socket.h: void ns3::TcpSocket::SetRcvBufSize(uint32_t size) [member function]
  1817     ## drop-tail-queue.h: ns3::Ptr<const ns3::Packet> ns3::DropTailQueue::DoPeek() const [member function]
  1818     cls.add_method('SetRcvBufSize', 
  1818     cls.add_method('DoPeek', 
  1819                    'void', 
  1819                    'ns3::Ptr< ns3::Packet const >', 
  1820                    [param('uint32_t', 'size')], 
  1820                    [], 
  1821                    is_pure_virtual=True, visibility='private', is_virtual=True)
  1821                    is_const=True, visibility='private', is_virtual=True)
  1822     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetRcvBufSize() const [member function]
       
  1823     cls.add_method('GetRcvBufSize', 
       
  1824                    'uint32_t', 
       
  1825                    [], 
       
  1826                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1827     ## tcp-socket.h: void ns3::TcpSocket::SetSegSize(uint32_t size) [member function]
       
  1828     cls.add_method('SetSegSize', 
       
  1829                    'void', 
       
  1830                    [param('uint32_t', 'size')], 
       
  1831                    is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1832     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSegSize() const [member function]
       
  1833     cls.add_method('GetSegSize', 
       
  1834                    'uint32_t', 
       
  1835                    [], 
       
  1836                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1837     ## tcp-socket.h: void ns3::TcpSocket::SetAdvWin(uint32_t window) [member function]
       
  1838     cls.add_method('SetAdvWin', 
       
  1839                    'void', 
       
  1840                    [param('uint32_t', 'window')], 
       
  1841                    is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1842     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetAdvWin() const [member function]
       
  1843     cls.add_method('GetAdvWin', 
       
  1844                    'uint32_t', 
       
  1845                    [], 
       
  1846                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1847     ## tcp-socket.h: void ns3::TcpSocket::SetSSThresh(uint32_t threshold) [member function]
       
  1848     cls.add_method('SetSSThresh', 
       
  1849                    'void', 
       
  1850                    [param('uint32_t', 'threshold')], 
       
  1851                    is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1852     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSSThresh() const [member function]
       
  1853     cls.add_method('GetSSThresh', 
       
  1854                    'uint32_t', 
       
  1855                    [], 
       
  1856                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1857     ## tcp-socket.h: void ns3::TcpSocket::SetInitialCwnd(uint32_t count) [member function]
       
  1858     cls.add_method('SetInitialCwnd', 
       
  1859                    'void', 
       
  1860                    [param('uint32_t', 'count')], 
       
  1861                    is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1862     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetInitialCwnd() const [member function]
       
  1863     cls.add_method('GetInitialCwnd', 
       
  1864                    'uint32_t', 
       
  1865                    [], 
       
  1866                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1867     ## tcp-socket.h: void ns3::TcpSocket::SetConnTimeout(ns3::Time timeout) [member function]
       
  1868     cls.add_method('SetConnTimeout', 
       
  1869                    'void', 
       
  1870                    [param('ns3::Time', 'timeout')], 
       
  1871                    is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1872     ## tcp-socket.h: ns3::Time ns3::TcpSocket::GetConnTimeout() const [member function]
       
  1873     cls.add_method('GetConnTimeout', 
       
  1874                    'ns3::Time', 
       
  1875                    [], 
       
  1876                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1877     ## tcp-socket.h: void ns3::TcpSocket::SetConnCount(uint32_t count) [member function]
       
  1878     cls.add_method('SetConnCount', 
       
  1879                    'void', 
       
  1880                    [param('uint32_t', 'count')], 
       
  1881                    is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1882     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetConnCount() const [member function]
       
  1883     cls.add_method('GetConnCount', 
       
  1884                    'uint32_t', 
       
  1885                    [], 
       
  1886                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1887     ## tcp-socket.h: void ns3::TcpSocket::SetDelAckTimeout(ns3::Time timeout) [member function]
       
  1888     cls.add_method('SetDelAckTimeout', 
       
  1889                    'void', 
       
  1890                    [param('ns3::Time', 'timeout')], 
       
  1891                    is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1892     ## tcp-socket.h: ns3::Time ns3::TcpSocket::GetDelAckTimeout() const [member function]
       
  1893     cls.add_method('GetDelAckTimeout', 
       
  1894                    'ns3::Time', 
       
  1895                    [], 
       
  1896                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1897     ## tcp-socket.h: void ns3::TcpSocket::SetDelAckMaxCount(uint32_t count) [member function]
       
  1898     cls.add_method('SetDelAckMaxCount', 
       
  1899                    'void', 
       
  1900                    [param('uint32_t', 'count')], 
       
  1901                    is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1902     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetDelAckMaxCount() const [member function]
       
  1903     cls.add_method('GetDelAckMaxCount', 
       
  1904                    'uint32_t', 
       
  1905                    [], 
       
  1906                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1907     return
  1822     return
  1908 
  1823 
  1909 def register_Ns3EthernetHeader_methods(root_module, cls):
  1824 def register_Ns3EthernetHeader_methods(root_module, cls):
  1910     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader(ns3::EthernetHeader const & arg0) [copy constructor]
  1825     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader(ns3::EthernetHeader const & arg0) [copy constructor]
  1911     cls.add_constructor([param('ns3::EthernetHeader const &', 'arg0')])
  1826     cls.add_constructor([param('ns3::EthernetHeader const &', 'arg0')])
  1989                    'uint32_t', 
  1904                    'uint32_t', 
  1990                    [param('ns3::Buffer::Iterator', 'start')], 
  1905                    [param('ns3::Buffer::Iterator', 'start')], 
  1991                    is_virtual=True)
  1906                    is_virtual=True)
  1992     return
  1907     return
  1993 
  1908 
  1994 def register_Ns3SocketIpTtlTag_methods(root_module, cls):
  1909 def register_Ns3EthernetTrailer_methods(root_module, cls):
  1995     ## socket.h: ns3::SocketIpTtlTag::SocketIpTtlTag(ns3::SocketIpTtlTag const & arg0) [copy constructor]
  1910     ## ethernet-trailer.h: ns3::EthernetTrailer::EthernetTrailer(ns3::EthernetTrailer const & arg0) [copy constructor]
  1996     cls.add_constructor([param('ns3::SocketIpTtlTag const &', 'arg0')])
  1911     cls.add_constructor([param('ns3::EthernetTrailer const &', 'arg0')])
  1997     ## socket.h: ns3::SocketIpTtlTag::SocketIpTtlTag() [constructor]
  1912     ## ethernet-trailer.h: ns3::EthernetTrailer::EthernetTrailer() [constructor]
  1998     cls.add_constructor([])
  1913     cls.add_constructor([])
  1999     ## socket.h: void ns3::SocketIpTtlTag::SetTtl(uint8_t ttl) [member function]
  1914     ## ethernet-trailer.h: static void ns3::EthernetTrailer::EnableFcs(bool enable) [member function]
  2000     cls.add_method('SetTtl', 
  1915     cls.add_method('EnableFcs', 
  2001                    'void', 
  1916                    'void', 
  2002                    [param('uint8_t', 'ttl')])
  1917                    [param('bool', 'enable')], 
  2003     ## socket.h: uint8_t ns3::SocketIpTtlTag::GetTtl() const [member function]
  1918                    is_static=True)
  2004     cls.add_method('GetTtl', 
  1919     ## ethernet-trailer.h: void ns3::EthernetTrailer::CalcFcs(ns3::Ptr<ns3::Packet> p) [member function]
  2005                    'uint8_t', 
  1920     cls.add_method('CalcFcs', 
  2006                    [], 
  1921                    'void', 
  2007                    is_const=True)
  1922                    [param('ns3::Ptr< ns3::Packet >', 'p')])
  2008     ## socket.h: static ns3::TypeId ns3::SocketIpTtlTag::GetTypeId() [member function]
  1923     ## ethernet-trailer.h: void ns3::EthernetTrailer::SetFcs(uint32_t fcs) [member function]
       
  1924     cls.add_method('SetFcs', 
       
  1925                    'void', 
       
  1926                    [param('uint32_t', 'fcs')])
       
  1927     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetFcs() [member function]
       
  1928     cls.add_method('GetFcs', 
       
  1929                    'uint32_t', 
       
  1930                    [])
       
  1931     ## ethernet-trailer.h: bool ns3::EthernetTrailer::CheckFcs(ns3::Ptr<ns3::Packet> p) const [member function]
       
  1932     cls.add_method('CheckFcs', 
       
  1933                    'bool', 
       
  1934                    [param('ns3::Ptr< ns3::Packet >', 'p')], 
       
  1935                    is_const=True)
       
  1936     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetTrailerSize() const [member function]
       
  1937     cls.add_method('GetTrailerSize', 
       
  1938                    'uint32_t', 
       
  1939                    [], 
       
  1940                    is_const=True)
       
  1941     ## ethernet-trailer.h: static ns3::TypeId ns3::EthernetTrailer::GetTypeId() [member function]
  2009     cls.add_method('GetTypeId', 
  1942     cls.add_method('GetTypeId', 
  2010                    'ns3::TypeId', 
  1943                    'ns3::TypeId', 
  2011                    [], 
  1944                    [], 
  2012                    is_static=True)
  1945                    is_static=True)
  2013     ## socket.h: ns3::TypeId ns3::SocketIpTtlTag::GetInstanceTypeId() const [member function]
  1946     ## ethernet-trailer.h: ns3::TypeId ns3::EthernetTrailer::GetInstanceTypeId() const [member function]
  2014     cls.add_method('GetInstanceTypeId', 
  1947     cls.add_method('GetInstanceTypeId', 
  2015                    'ns3::TypeId', 
  1948                    'ns3::TypeId', 
  2016                    [], 
  1949                    [], 
  2017                    is_const=True, is_virtual=True)
  1950                    is_const=True, is_virtual=True)
  2018     ## socket.h: uint32_t ns3::SocketIpTtlTag::GetSerializedSize() const [member function]
  1951     ## ethernet-trailer.h: void ns3::EthernetTrailer::Print(std::ostream & os) const [member function]
       
  1952     cls.add_method('Print', 
       
  1953                    'void', 
       
  1954                    [param('std::ostream &', 'os')], 
       
  1955                    is_const=True, is_virtual=True)
       
  1956     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetSerializedSize() const [member function]
  2019     cls.add_method('GetSerializedSize', 
  1957     cls.add_method('GetSerializedSize', 
  2020                    'uint32_t', 
  1958                    'uint32_t', 
  2021                    [], 
  1959                    [], 
  2022                    is_const=True, is_virtual=True)
  1960                    is_const=True, is_virtual=True)
  2023     ## socket.h: void ns3::SocketIpTtlTag::Serialize(ns3::TagBuffer i) const [member function]
  1961     ## ethernet-trailer.h: void ns3::EthernetTrailer::Serialize(ns3::Buffer::Iterator end) const [member function]
  2024     cls.add_method('Serialize', 
  1962     cls.add_method('Serialize', 
  2025                    'void', 
  1963                    'void', 
  2026                    [param('ns3::TagBuffer', 'i')], 
  1964                    [param('ns3::Buffer::Iterator', 'end')], 
  2027                    is_const=True, is_virtual=True)
  1965                    is_const=True, is_virtual=True)
  2028     ## socket.h: void ns3::SocketIpTtlTag::Deserialize(ns3::TagBuffer i) [member function]
  1966     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::Deserialize(ns3::Buffer::Iterator end) [member function]
  2029     cls.add_method('Deserialize', 
  1967     cls.add_method('Deserialize', 
  2030                    'void', 
  1968                    'uint32_t', 
  2031                    [param('ns3::TagBuffer', 'i')], 
  1969                    [param('ns3::Buffer::Iterator', 'end')], 
  2032                    is_virtual=True)
  1970                    is_virtual=True)
  2033     ## socket.h: void ns3::SocketIpTtlTag::Print(std::ostream & os) const [member function]
       
  2034     cls.add_method('Print', 
       
  2035                    'void', 
       
  2036                    [param('std::ostream &', 'os')], 
       
  2037                    is_const=True, is_virtual=True)
       
  2038     return
  1971     return
  2039 
  1972 
  2040 def register_Ns3Ipv4_methods(root_module, cls):
  1973 def register_Ns3Ipv4_methods(root_module, cls):
  2041     ## ipv4.h: ns3::Ipv4::Ipv4(ns3::Ipv4 const & arg0) [copy constructor]
  1974     ## ipv4.h: ns3::Ipv4::Ipv4(ns3::Ipv4 const & arg0) [copy constructor]
  2042     cls.add_constructor([param('ns3::Ipv4 const &', 'arg0')])
  1975     cls.add_constructor([param('ns3::Ipv4 const &', 'arg0')])
  2227                    'uint32_t', 
  2160                    'uint32_t', 
  2228                    [param('ns3::Ipv4Address', 'addr'), param('ns3::Ipv4Mask', 'mask', default_value='ns3::Ipv4Mask(((const char*)"255.255.255.255"))')], 
  2161                    [param('ns3::Ipv4Address', 'addr'), param('ns3::Ipv4Mask', 'mask', default_value='ns3::Ipv4Mask(((const char*)"255.255.255.255"))')], 
  2229                    is_virtual=True)
  2162                    is_virtual=True)
  2230     return
  2163     return
  2231 
  2164 
  2232 def register_Ns3SocketFactory_methods(root_module, cls):
  2165 def register_Ns3Ipv4RoutingProtocol_methods(root_module, cls):
  2233     ## socket-factory.h: ns3::SocketFactory::SocketFactory(ns3::SocketFactory const & arg0) [copy constructor]
  2166     ## ipv4.h: ns3::Ipv4RoutingProtocol::IF_INDEX_ANY [variable]
  2234     cls.add_constructor([param('ns3::SocketFactory const &', 'arg0')])
  2167     cls.add_static_attribute('IF_INDEX_ANY', 'uint32_t const', is_const=True)
  2235     ## socket-factory.h: static ns3::TypeId ns3::SocketFactory::GetTypeId() [member function]
  2168     ## ipv4.h: ns3::Ipv4RoutingProtocol::Ipv4RoutingProtocol(ns3::Ipv4RoutingProtocol const & arg0) [copy constructor]
       
  2169     cls.add_constructor([param('ns3::Ipv4RoutingProtocol const &', 'arg0')])
       
  2170     ## ipv4.h: ns3::Ipv4RoutingProtocol::Ipv4RoutingProtocol() [constructor]
       
  2171     cls.add_constructor([])
       
  2172     ## 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]
       
  2173     cls.add_method('RequestRoute', 
       
  2174                    'bool', 
       
  2175                    [param('uint32_t', 'ifIndex'), param('ns3::Ipv4Header const &', 'ipHeader'), param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Callback< void, bool, ns3::Ipv4Route const &, ns3::Ptr< ns3::Packet >, ns3::Ipv4Header const &, ns3::empty, ns3::empty >', 'routeReply')], 
       
  2176                    is_pure_virtual=True, is_virtual=True)
       
  2177     ## ipv4.h: bool ns3::Ipv4RoutingProtocol::RequestIfIndex(ns3::Ipv4Address destination, uint32_t & ifIndex) [member function]
       
  2178     cls.add_method('RequestIfIndex', 
       
  2179                    'bool', 
       
  2180                    [param('ns3::Ipv4Address', 'destination'), param('uint32_t &', 'ifIndex')], 
       
  2181                    is_pure_virtual=True, is_virtual=True)
       
  2182     return
       
  2183 
       
  2184 def register_Ns3NetDevice_methods(root_module, cls):
       
  2185     ## net-device.h: ns3::NetDevice::NetDevice(ns3::NetDevice const & arg0) [copy constructor]
       
  2186     cls.add_constructor([param('ns3::NetDevice const &', 'arg0')])
       
  2187     ## net-device.h: ns3::NetDevice::NetDevice() [constructor]
       
  2188     cls.add_constructor([])
       
  2189     ## net-device.h: static ns3::TypeId ns3::NetDevice::GetTypeId() [member function]
  2236     cls.add_method('GetTypeId', 
  2190     cls.add_method('GetTypeId', 
  2237                    'ns3::TypeId', 
  2191                    'ns3::TypeId', 
  2238                    [], 
  2192                    [], 
  2239                    is_static=True)
  2193                    is_static=True)
  2240     ## socket-factory.h: ns3::SocketFactory::SocketFactory() [constructor]
  2194     ## net-device.h: void ns3::NetDevice::SetName(std::string const name) [member function]
  2241     cls.add_constructor([])
  2195     cls.add_method('SetName', 
  2242     ## socket-factory.h: ns3::Ptr<ns3::Socket> ns3::SocketFactory::CreateSocket() [member function]
  2196                    'void', 
       
  2197                    [param('std::string const', 'name')], 
       
  2198                    is_pure_virtual=True, is_virtual=True)
       
  2199     ## net-device.h: std::string ns3::NetDevice::GetName() const [member function]
       
  2200     cls.add_method('GetName', 
       
  2201                    'std::string', 
       
  2202                    [], 
       
  2203                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  2204     ## net-device.h: void ns3::NetDevice::SetIfIndex(uint32_t const index) [member function]
       
  2205     cls.add_method('SetIfIndex', 
       
  2206                    'void', 
       
  2207                    [param('uint32_t const', 'index')], 
       
  2208                    is_pure_virtual=True, is_virtual=True)
       
  2209     ## net-device.h: uint32_t ns3::NetDevice::GetIfIndex() const [member function]
       
  2210     cls.add_method('GetIfIndex', 
       
  2211                    'uint32_t', 
       
  2212                    [], 
       
  2213                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  2214     ## net-device.h: ns3::Ptr<ns3::Channel> ns3::NetDevice::GetChannel() const [member function]
       
  2215     cls.add_method('GetChannel', 
       
  2216                    'ns3::Ptr< ns3::Channel >', 
       
  2217                    [], 
       
  2218                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  2219     ## net-device.h: ns3::Address ns3::NetDevice::GetAddress() const [member function]
       
  2220     cls.add_method('GetAddress', 
       
  2221                    'ns3::Address', 
       
  2222                    [], 
       
  2223                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  2224     ## net-device.h: bool ns3::NetDevice::SetMtu(uint16_t const mtu) [member function]
       
  2225     cls.add_method('SetMtu', 
       
  2226                    'bool', 
       
  2227                    [param('uint16_t const', 'mtu')], 
       
  2228                    is_pure_virtual=True, is_virtual=True)
       
  2229     ## net-device.h: uint16_t ns3::NetDevice::GetMtu() const [member function]
       
  2230     cls.add_method('GetMtu', 
       
  2231                    'uint16_t', 
       
  2232                    [], 
       
  2233                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  2234     ## net-device.h: bool ns3::NetDevice::IsLinkUp() const [member function]
       
  2235     cls.add_method('IsLinkUp', 
       
  2236                    'bool', 
       
  2237                    [], 
       
  2238                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  2239     ## net-device.h: void ns3::NetDevice::SetLinkChangeCallback(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]
       
  2240     cls.add_method('SetLinkChangeCallback', 
       
  2241                    'void', 
       
  2242                    [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')], 
       
  2243                    is_pure_virtual=True, is_virtual=True)
       
  2244     ## net-device.h: bool ns3::NetDevice::IsBroadcast() const [member function]
       
  2245     cls.add_method('IsBroadcast', 
       
  2246                    'bool', 
       
  2247                    [], 
       
  2248                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  2249     ## net-device.h: ns3::Address ns3::NetDevice::GetBroadcast() const [member function]
       
  2250     cls.add_method('GetBroadcast', 
       
  2251                    'ns3::Address', 
       
  2252                    [], 
       
  2253                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  2254     ## net-device.h: bool ns3::NetDevice::IsMulticast() const [member function]
       
  2255     cls.add_method('IsMulticast', 
       
  2256                    'bool', 
       
  2257                    [], 
       
  2258                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  2259     ## net-device.h: ns3::Address ns3::NetDevice::GetMulticast() const [member function]
       
  2260     cls.add_method('GetMulticast', 
       
  2261                    'ns3::Address', 
       
  2262                    [], 
       
  2263                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  2264     ## net-device.h: ns3::Address ns3::NetDevice::MakeMulticastAddress(ns3::Ipv4Address multicastGroup) const [member function]
       
  2265     cls.add_method('MakeMulticastAddress', 
       
  2266                    'ns3::Address', 
       
  2267                    [param('ns3::Ipv4Address', 'multicastGroup')], 
       
  2268                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  2269     ## net-device.h: bool ns3::NetDevice::IsPointToPoint() const [member function]
       
  2270     cls.add_method('IsPointToPoint', 
       
  2271                    'bool', 
       
  2272                    [], 
       
  2273                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  2274     ## net-device.h: bool ns3::NetDevice::Send(ns3::Ptr<ns3::Packet> packet, ns3::Address const & dest, uint16_t protocolNumber) [member function]
       
  2275     cls.add_method('Send', 
       
  2276                    'bool', 
       
  2277                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], 
       
  2278                    is_pure_virtual=True, is_virtual=True)
       
  2279     ## net-device.h: bool ns3::NetDevice::SendFrom(ns3::Ptr<ns3::Packet> packet, ns3::Address const & source, ns3::Address const & dest, uint16_t protocolNumber) [member function]
       
  2280     cls.add_method('SendFrom', 
       
  2281                    'bool', 
       
  2282                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], 
       
  2283                    is_pure_virtual=True, is_virtual=True)
       
  2284     ## net-device.h: ns3::Ptr<ns3::Node> ns3::NetDevice::GetNode() const [member function]
       
  2285     cls.add_method('GetNode', 
       
  2286                    'ns3::Ptr< ns3::Node >', 
       
  2287                    [], 
       
  2288                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  2289     ## net-device.h: void ns3::NetDevice::SetNode(ns3::Ptr<ns3::Node> node) [member function]
       
  2290     cls.add_method('SetNode', 
       
  2291                    'void', 
       
  2292                    [param('ns3::Ptr< ns3::Node >', 'node')], 
       
  2293                    is_pure_virtual=True, is_virtual=True)
       
  2294     ## net-device.h: bool ns3::NetDevice::NeedsArp() const [member function]
       
  2295     cls.add_method('NeedsArp', 
       
  2296                    'bool', 
       
  2297                    [], 
       
  2298                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  2299     ## net-device.h: void ns3::NetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function]
       
  2300     cls.add_method('SetReceiveCallback', 
       
  2301                    'void', 
       
  2302                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty >', 'cb')], 
       
  2303                    is_pure_virtual=True, is_virtual=True)
       
  2304     ## net-device.h: void ns3::NetDevice::SetPromiscReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> cb) [member function]
       
  2305     cls.add_method('SetPromiscReceiveCallback', 
       
  2306                    'void', 
       
  2307                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType >', 'cb')], 
       
  2308                    is_pure_virtual=True, is_virtual=True)
       
  2309     ## net-device.h: bool ns3::NetDevice::SupportsSendFrom() const [member function]
       
  2310     cls.add_method('SupportsSendFrom', 
       
  2311                    'bool', 
       
  2312                    [], 
       
  2313                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  2314     return
       
  2315 
       
  2316 def register_Ns3Node_methods(root_module, cls):
       
  2317     ## node.h: ns3::Node::Node(ns3::Node const & arg0) [copy constructor]
       
  2318     cls.add_constructor([param('ns3::Node const &', 'arg0')])
       
  2319     ## node.h: static ns3::TypeId ns3::Node::GetTypeId() [member function]
       
  2320     cls.add_method('GetTypeId', 
       
  2321                    'ns3::TypeId', 
       
  2322                    [], 
       
  2323                    is_static=True)
       
  2324     ## node.h: ns3::Node::Node() [constructor]
       
  2325     cls.add_constructor([])
       
  2326     ## node.h: ns3::Node::Node(uint32_t systemId) [constructor]
       
  2327     cls.add_constructor([param('uint32_t', 'systemId')])
       
  2328     ## node.h: uint32_t ns3::Node::GetId() const [member function]
       
  2329     cls.add_method('GetId', 
       
  2330                    'uint32_t', 
       
  2331                    [], 
       
  2332                    is_const=True)
       
  2333     ## node.h: uint32_t ns3::Node::GetSystemId() const [member function]
       
  2334     cls.add_method('GetSystemId', 
       
  2335                    'uint32_t', 
       
  2336                    [], 
       
  2337                    is_const=True)
       
  2338     ## node.h: uint32_t ns3::Node::AddDevice(ns3::Ptr<ns3::NetDevice> device) [member function]
       
  2339     cls.add_method('AddDevice', 
       
  2340                    'uint32_t', 
       
  2341                    [param('ns3::Ptr< ns3::NetDevice >', 'device')])
       
  2342     ## node.h: ns3::Ptr<ns3::NetDevice> ns3::Node::GetDevice(uint32_t index) const [member function]
       
  2343     cls.add_method('GetDevice', 
       
  2344                    'ns3::Ptr< ns3::NetDevice >', 
       
  2345                    [param('uint32_t', 'index')], 
       
  2346                    is_const=True)
       
  2347     ## node.h: uint32_t ns3::Node::GetNDevices() const [member function]
       
  2348     cls.add_method('GetNDevices', 
       
  2349                    'uint32_t', 
       
  2350                    [], 
       
  2351                    is_const=True)
       
  2352     ## node.h: uint32_t ns3::Node::AddApplication(ns3::Ptr<ns3::Application> application) [member function]
       
  2353     cls.add_method('AddApplication', 
       
  2354                    'uint32_t', 
       
  2355                    [param('ns3::Ptr< ns3::Application >', 'application')])
       
  2356     ## node.h: ns3::Ptr<ns3::Application> ns3::Node::GetApplication(uint32_t index) const [member function]
       
  2357     cls.add_method('GetApplication', 
       
  2358                    'ns3::Ptr< ns3::Application >', 
       
  2359                    [param('uint32_t', 'index')], 
       
  2360                    is_const=True)
       
  2361     ## node.h: uint32_t ns3::Node::GetNApplications() const [member function]
       
  2362     cls.add_method('GetNApplications', 
       
  2363                    'uint32_t', 
       
  2364                    [], 
       
  2365                    is_const=True)
       
  2366     ## node.h: void ns3::Node::RegisterProtocolHandler(ns3::Callback<void, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> handler, uint16_t protocolType, ns3::Ptr<ns3::NetDevice> device, bool promiscuous=false) [member function]
       
  2367     cls.add_method('RegisterProtocolHandler', 
       
  2368                    'void', 
       
  2369                    [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType >', 'handler'), param('uint16_t', 'protocolType'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'promiscuous', default_value='false')])
       
  2370     ## node.h: void ns3::Node::UnregisterProtocolHandler(ns3::Callback<void, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> handler) [member function]
       
  2371     cls.add_method('UnregisterProtocolHandler', 
       
  2372                    'void', 
       
  2373                    [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType >', 'handler')])
       
  2374     ## node.h: void ns3::Node::DoDispose() [member function]
       
  2375     cls.add_method('DoDispose', 
       
  2376                    'void', 
       
  2377                    [], 
       
  2378                    visibility='protected', is_virtual=True)
       
  2379     ## node.h: void ns3::Node::NotifyDeviceAdded(ns3::Ptr<ns3::NetDevice> device) [member function]
       
  2380     cls.add_method('NotifyDeviceAdded', 
       
  2381                    'void', 
       
  2382                    [param('ns3::Ptr< ns3::NetDevice >', 'device')], 
       
  2383                    visibility='private', is_virtual=True)
       
  2384     return
       
  2385 
       
  2386 def register_Ns3PacketSocketFactory_methods(root_module, cls):
       
  2387     ## packet-socket-factory.h: ns3::PacketSocketFactory::PacketSocketFactory(ns3::PacketSocketFactory const & arg0) [copy constructor]
       
  2388     cls.add_constructor([param('ns3::PacketSocketFactory const &', 'arg0')])
       
  2389     ## packet-socket-factory.h: static ns3::TypeId ns3::PacketSocketFactory::GetTypeId() [member function]
       
  2390     cls.add_method('GetTypeId', 
       
  2391                    'ns3::TypeId', 
       
  2392                    [], 
       
  2393                    is_static=True)
       
  2394     ## packet-socket-factory.h: ns3::PacketSocketFactory::PacketSocketFactory() [constructor]
       
  2395     cls.add_constructor([])
       
  2396     ## packet-socket-factory.h: ns3::Ptr<ns3::Socket> ns3::PacketSocketFactory::CreateSocket() [member function]
  2243     cls.add_method('CreateSocket', 
  2397     cls.add_method('CreateSocket', 
  2244                    'ns3::Ptr< ns3::Socket >', 
  2398                    'ns3::Ptr< ns3::Socket >', 
  2245                    [], 
  2399                    [], 
  2246                    is_pure_virtual=True, is_virtual=True)
       
  2247     return
       
  2248 
       
  2249 def register_Ns3EthernetTrailer_methods(root_module, cls):
       
  2250     ## ethernet-trailer.h: ns3::EthernetTrailer::EthernetTrailer(ns3::EthernetTrailer const & arg0) [copy constructor]
       
  2251     cls.add_constructor([param('ns3::EthernetTrailer const &', 'arg0')])
       
  2252     ## ethernet-trailer.h: ns3::EthernetTrailer::EthernetTrailer() [constructor]
       
  2253     cls.add_constructor([])
       
  2254     ## ethernet-trailer.h: static void ns3::EthernetTrailer::EnableFcs(bool enable) [member function]
       
  2255     cls.add_method('EnableFcs', 
       
  2256                    'void', 
       
  2257                    [param('bool', 'enable')], 
       
  2258                    is_static=True)
       
  2259     ## ethernet-trailer.h: void ns3::EthernetTrailer::CalcFcs(ns3::Ptr<ns3::Packet> p) [member function]
       
  2260     cls.add_method('CalcFcs', 
       
  2261                    'void', 
       
  2262                    [param('ns3::Ptr< ns3::Packet >', 'p')])
       
  2263     ## ethernet-trailer.h: void ns3::EthernetTrailer::SetFcs(uint32_t fcs) [member function]
       
  2264     cls.add_method('SetFcs', 
       
  2265                    'void', 
       
  2266                    [param('uint32_t', 'fcs')])
       
  2267     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetFcs() [member function]
       
  2268     cls.add_method('GetFcs', 
       
  2269                    'uint32_t', 
       
  2270                    [])
       
  2271     ## ethernet-trailer.h: bool ns3::EthernetTrailer::CheckFcs(ns3::Ptr<ns3::Packet> p) const [member function]
       
  2272     cls.add_method('CheckFcs', 
       
  2273                    'bool', 
       
  2274                    [param('ns3::Ptr< ns3::Packet >', 'p')], 
       
  2275                    is_const=True)
       
  2276     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetTrailerSize() const [member function]
       
  2277     cls.add_method('GetTrailerSize', 
       
  2278                    'uint32_t', 
       
  2279                    [], 
       
  2280                    is_const=True)
       
  2281     ## ethernet-trailer.h: static ns3::TypeId ns3::EthernetTrailer::GetTypeId() [member function]
       
  2282     cls.add_method('GetTypeId', 
       
  2283                    'ns3::TypeId', 
       
  2284                    [], 
       
  2285                    is_static=True)
       
  2286     ## ethernet-trailer.h: ns3::TypeId ns3::EthernetTrailer::GetInstanceTypeId() const [member function]
       
  2287     cls.add_method('GetInstanceTypeId', 
       
  2288                    'ns3::TypeId', 
       
  2289                    [], 
       
  2290                    is_const=True, is_virtual=True)
       
  2291     ## ethernet-trailer.h: void ns3::EthernetTrailer::Print(std::ostream & os) const [member function]
       
  2292     cls.add_method('Print', 
       
  2293                    'void', 
       
  2294                    [param('std::ostream &', 'os')], 
       
  2295                    is_const=True, is_virtual=True)
       
  2296     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetSerializedSize() const [member function]
       
  2297     cls.add_method('GetSerializedSize', 
       
  2298                    'uint32_t', 
       
  2299                    [], 
       
  2300                    is_const=True, is_virtual=True)
       
  2301     ## ethernet-trailer.h: void ns3::EthernetTrailer::Serialize(ns3::Buffer::Iterator end) const [member function]
       
  2302     cls.add_method('Serialize', 
       
  2303                    'void', 
       
  2304                    [param('ns3::Buffer::Iterator', 'end')], 
       
  2305                    is_const=True, is_virtual=True)
       
  2306     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::Deserialize(ns3::Buffer::Iterator end) [member function]
       
  2307     cls.add_method('Deserialize', 
       
  2308                    'uint32_t', 
       
  2309                    [param('ns3::Buffer::Iterator', 'end')], 
       
  2310                    is_virtual=True)
  2400                    is_virtual=True)
  2311     return
  2401     return
  2312 
  2402 
  2313 def register_Ns3SimpleChannel_methods(root_module, cls):
  2403 def register_Ns3SimpleChannel_methods(root_module, cls):
  2314     ## simple-channel.h: ns3::SimpleChannel::SimpleChannel(ns3::SimpleChannel const & arg0) [copy constructor]
  2404     ## simple-channel.h: ns3::SimpleChannel::SimpleChannel(ns3::SimpleChannel const & arg0) [copy constructor]
  2338                    'ns3::Ptr< ns3::NetDevice >', 
  2428                    'ns3::Ptr< ns3::NetDevice >', 
  2339                    [param('uint32_t', 'i')], 
  2429                    [param('uint32_t', 'i')], 
  2340                    is_const=True, is_virtual=True)
  2430                    is_const=True, is_virtual=True)
  2341     return
  2431     return
  2342 
  2432 
  2343 def register_Ns3LlcSnapHeader_methods(root_module, cls):
       
  2344     ## llc-snap-header.h: ns3::LlcSnapHeader::LlcSnapHeader(ns3::LlcSnapHeader const & arg0) [copy constructor]
       
  2345     cls.add_constructor([param('ns3::LlcSnapHeader const &', 'arg0')])
       
  2346     ## llc-snap-header.h: ns3::LlcSnapHeader::LlcSnapHeader() [constructor]
       
  2347     cls.add_constructor([])
       
  2348     ## llc-snap-header.h: void ns3::LlcSnapHeader::SetType(uint16_t type) [member function]
       
  2349     cls.add_method('SetType', 
       
  2350                    'void', 
       
  2351                    [param('uint16_t', 'type')])
       
  2352     ## llc-snap-header.h: uint16_t ns3::LlcSnapHeader::GetType() [member function]
       
  2353     cls.add_method('GetType', 
       
  2354                    'uint16_t', 
       
  2355                    [])
       
  2356     ## llc-snap-header.h: static ns3::TypeId ns3::LlcSnapHeader::GetTypeId() [member function]
       
  2357     cls.add_method('GetTypeId', 
       
  2358                    'ns3::TypeId', 
       
  2359                    [], 
       
  2360                    is_static=True)
       
  2361     ## llc-snap-header.h: ns3::TypeId ns3::LlcSnapHeader::GetInstanceTypeId() const [member function]
       
  2362     cls.add_method('GetInstanceTypeId', 
       
  2363                    'ns3::TypeId', 
       
  2364                    [], 
       
  2365                    is_const=True, is_virtual=True)
       
  2366     ## llc-snap-header.h: void ns3::LlcSnapHeader::Print(std::ostream & os) const [member function]
       
  2367     cls.add_method('Print', 
       
  2368                    'void', 
       
  2369                    [param('std::ostream &', 'os')], 
       
  2370                    is_const=True, is_virtual=True)
       
  2371     ## llc-snap-header.h: uint32_t ns3::LlcSnapHeader::GetSerializedSize() const [member function]
       
  2372     cls.add_method('GetSerializedSize', 
       
  2373                    'uint32_t', 
       
  2374                    [], 
       
  2375                    is_const=True, is_virtual=True)
       
  2376     ## llc-snap-header.h: void ns3::LlcSnapHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
       
  2377     cls.add_method('Serialize', 
       
  2378                    'void', 
       
  2379                    [param('ns3::Buffer::Iterator', 'start')], 
       
  2380                    is_const=True, is_virtual=True)
       
  2381     ## llc-snap-header.h: uint32_t ns3::LlcSnapHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
       
  2382     cls.add_method('Deserialize', 
       
  2383                    'uint32_t', 
       
  2384                    [param('ns3::Buffer::Iterator', 'start')], 
       
  2385                    is_virtual=True)
       
  2386     return
       
  2387 
       
  2388 def register_Ns3UdpSocketFactory_methods(root_module, cls):
       
  2389     ## udp-socket-factory.h: ns3::UdpSocketFactory::UdpSocketFactory(ns3::UdpSocketFactory const & arg0) [copy constructor]
       
  2390     cls.add_constructor([param('ns3::UdpSocketFactory const &', 'arg0')])
       
  2391     ## udp-socket-factory.h: ns3::UdpSocketFactory::UdpSocketFactory() [constructor]
       
  2392     cls.add_constructor([])
       
  2393     ## udp-socket-factory.h: static ns3::TypeId ns3::UdpSocketFactory::GetTypeId() [member function]
       
  2394     cls.add_method('GetTypeId', 
       
  2395                    'ns3::TypeId', 
       
  2396                    [], 
       
  2397                    is_static=True)
       
  2398     return
       
  2399 
       
  2400 def register_Ns3SimpleNetDevice_methods(root_module, cls):
  2433 def register_Ns3SimpleNetDevice_methods(root_module, cls):
  2401     ## simple-net-device.h: ns3::SimpleNetDevice::SimpleNetDevice(ns3::SimpleNetDevice const & arg0) [copy constructor]
  2434     ## simple-net-device.h: ns3::SimpleNetDevice::SimpleNetDevice(ns3::SimpleNetDevice const & arg0) [copy constructor]
  2402     cls.add_constructor([param('ns3::SimpleNetDevice const &', 'arg0')])
  2435     cls.add_constructor([param('ns3::SimpleNetDevice const &', 'arg0')])
  2403     ## simple-net-device.h: static ns3::TypeId ns3::SimpleNetDevice::GetTypeId() [member function]
  2436     ## simple-net-device.h: static ns3::TypeId ns3::SimpleNetDevice::GetTypeId() [member function]
  2404     cls.add_method('GetTypeId', 
  2437     cls.add_method('GetTypeId', 
  2525                    [], 
  2558                    [], 
  2526                    is_const=True, is_virtual=True)
  2559                    is_const=True, is_virtual=True)
  2527     ## simple-net-device.h: void ns3::SimpleNetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function]
  2560     ## simple-net-device.h: void ns3::SimpleNetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function]
  2528     cls.add_method('SetReceiveCallback', 
  2561     cls.add_method('SetReceiveCallback', 
  2529                    'void', 
  2562                    'void', 
  2530                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
  2563                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty >', 'cb')], 
  2531                    is_virtual=True)
  2564                    is_virtual=True)
  2532     ## simple-net-device.h: void ns3::SimpleNetDevice::SetPromiscReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> cb) [member function]
  2565     ## simple-net-device.h: void ns3::SimpleNetDevice::SetPromiscReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> cb) [member function]
  2533     cls.add_method('SetPromiscReceiveCallback', 
  2566     cls.add_method('SetPromiscReceiveCallback', 
  2534                    'void', 
  2567                    'void', 
  2535                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'cb')], 
  2568                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType >', 'cb')], 
  2536                    is_virtual=True)
  2569                    is_virtual=True)
  2537     ## simple-net-device.h: bool ns3::SimpleNetDevice::SupportsSendFrom() const [member function]
  2570     ## simple-net-device.h: bool ns3::SimpleNetDevice::SupportsSendFrom() const [member function]
  2538     cls.add_method('SupportsSendFrom', 
  2571     cls.add_method('SupportsSendFrom', 
  2539                    'bool', 
  2572                    'bool', 
  2540                    [], 
  2573                    [], 
  2542     ## simple-net-device.h: void ns3::SimpleNetDevice::DoDispose() [member function]
  2575     ## simple-net-device.h: void ns3::SimpleNetDevice::DoDispose() [member function]
  2543     cls.add_method('DoDispose', 
  2576     cls.add_method('DoDispose', 
  2544                    'void', 
  2577                    'void', 
  2545                    [], 
  2578                    [], 
  2546                    visibility='protected', is_virtual=True)
  2579                    visibility='protected', is_virtual=True)
  2547     return
       
  2548 
       
  2549 def register_Ns3TcpSocketFactory_methods(root_module, cls):
       
  2550     ## tcp-socket-factory.h: ns3::TcpSocketFactory::TcpSocketFactory(ns3::TcpSocketFactory const & arg0) [copy constructor]
       
  2551     cls.add_constructor([param('ns3::TcpSocketFactory const &', 'arg0')])
       
  2552     ## tcp-socket-factory.h: ns3::TcpSocketFactory::TcpSocketFactory() [constructor]
       
  2553     cls.add_constructor([])
       
  2554     ## tcp-socket-factory.h: static ns3::TypeId ns3::TcpSocketFactory::GetTypeId() [member function]
       
  2555     cls.add_method('GetTypeId', 
       
  2556                    'ns3::TypeId', 
       
  2557                    [], 
       
  2558                    is_static=True)
       
  2559     return
       
  2560 
       
  2561 def register_Ns3PacketSocketFactory_methods(root_module, cls):
       
  2562     ## packet-socket-factory.h: ns3::PacketSocketFactory::PacketSocketFactory(ns3::PacketSocketFactory const & arg0) [copy constructor]
       
  2563     cls.add_constructor([param('ns3::PacketSocketFactory const &', 'arg0')])
       
  2564     ## packet-socket-factory.h: static ns3::TypeId ns3::PacketSocketFactory::GetTypeId() [member function]
       
  2565     cls.add_method('GetTypeId', 
       
  2566                    'ns3::TypeId', 
       
  2567                    [], 
       
  2568                    is_static=True)
       
  2569     ## packet-socket-factory.h: ns3::PacketSocketFactory::PacketSocketFactory() [constructor]
       
  2570     cls.add_constructor([])
       
  2571     ## packet-socket-factory.h: ns3::Ptr<ns3::Socket> ns3::PacketSocketFactory::CreateSocket() [member function]
       
  2572     cls.add_method('CreateSocket', 
       
  2573                    'ns3::Ptr< ns3::Socket >', 
       
  2574                    [], 
       
  2575                    is_virtual=True)
       
  2576     return
  2580     return
  2577 
  2581 
  2578 def register_functions(root_module):
  2582 def register_functions(root_module):
  2579     module = root_module
  2583     module = root_module
  2580     ## mac48-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeMac48AddressChecker() [free function]
  2584     ## mac48-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeMac48AddressChecker() [free function]