bindings/python/ns3_module_node.py
changeset 3408 2cc40b3e4fa5
child 3414 48d69d8eac38
equal deleted inserted replaced
3396:0d83aa14b65d 3408:2cc40b3e4fa5
       
     1 from pybindgen import Module, FileCodeSink, write_preamble, param, retval
       
     2 
       
     3 def register_types(module):
       
     4     root_module = module.get_root()
       
     5     
       
     6     ## ethernet-header.h: ns3::ethernet_header_t [enumeration]
       
     7     module.add_enum('ethernet_header_t', ['LENGTH', 'VLAN', 'QINQ'])
       
     8     ## node-list.h: ns3::NodeList [class]
       
     9     module.add_class('NodeList')
       
    10     ## address.h: ns3::Address [class]
       
    11     module.add_class('Address')
       
    12     ## address.h: ns3::Address::MaxSize_e [enumeration]
       
    13     module.add_enum('MaxSize_e', ['MAX_SIZE'], outer_class=root_module['ns3::Address'])
       
    14     ## ipv4-address.h: ns3::Ipv4AddressChecker [class]
       
    15     module.add_class('Ipv4AddressChecker', parent=root_module['ns3::AttributeChecker'])
       
    16     ## mac48-address.h: ns3::Mac48Address [class]
       
    17     module.add_class('Mac48Address')
       
    18     ## mac48-address.h: ns3::Mac48Address [class]
       
    19     root_module['ns3::Mac48Address'].implicitly_converts_to(root_module['ns3::Address'])
       
    20     ## mac64-address.h: ns3::Mac64Address [class]
       
    21     module.add_class('Mac64Address')
       
    22     ## mac64-address.h: ns3::Mac64Address [class]
       
    23     root_module['ns3::Mac64Address'].implicitly_converts_to(root_module['ns3::Address'])
       
    24     ## ipv4-address-generator.h: ns3::Ipv4AddressGenerator [class]
       
    25     module.add_class('Ipv4AddressGenerator')
       
    26     ## mac48-address.h: ns3::Mac48AddressChecker [class]
       
    27     module.add_class('Mac48AddressChecker', parent=root_module['ns3::AttributeChecker'])
       
    28     ## ipv4-address.h: ns3::Ipv4MaskChecker [class]
       
    29     module.add_class('Ipv4MaskChecker', parent=root_module['ns3::AttributeChecker'])
       
    30     ## ipv4-route.h: ns3::Ipv4Route [class]
       
    31     module.add_class('Ipv4Route')
       
    32     ## ipv4-route.h: ns3::Ipv4MulticastRoute [class]
       
    33     module.add_class('Ipv4MulticastRoute')
       
    34     ## address.h: ns3::AddressChecker [class]
       
    35     module.add_class('AddressChecker', parent=root_module['ns3::AttributeChecker'])
       
    36     ## packet-socket-address.h: ns3::PacketSocketAddress [class]
       
    37     module.add_class('PacketSocketAddress')
       
    38     ## packet-socket-address.h: ns3::PacketSocketAddress [class]
       
    39     root_module['ns3::PacketSocketAddress'].implicitly_converts_to(root_module['ns3::Address'])
       
    40     ## ipv4-address.h: ns3::Ipv4Mask [class]
       
    41     module.add_class('Ipv4Mask')
       
    42     ## ipv4-address.h: ns3::Ipv4AddressValue [class]
       
    43     module.add_class('Ipv4AddressValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
       
    44     ## ipv4.h: ns3::Ipv4RoutingProtocol [class]
       
    45     module.add_class('Ipv4RoutingProtocol', allow_subclassing=True, parent=root_module['ns3::Object'])
       
    46     ## mac48-address.h: ns3::Mac48AddressValue [class]
       
    47     module.add_class('Mac48AddressValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
       
    48     ## ipv4-address.h: ns3::Ipv4MaskValue [class]
       
    49     module.add_class('Ipv4MaskValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
       
    50     ## socket.h: ns3::SocketAddressTag [class]
       
    51     module.add_class('SocketAddressTag', allow_subclassing=True, 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', allow_subclassing=True, parent=root_module['ns3::Object'])
       
    62     ## queue.h: ns3::Queue [class]
       
    63     module.add_class('Queue', allow_subclassing=True, parent=root_module['ns3::Object'])
       
    64     ## socket.h: ns3::Socket [class]
       
    65     module.add_class('Socket', allow_subclassing=True, parent=root_module['ns3::Object'])
       
    66     ## 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'])
       
    68     ## ipv4-header.h: ns3::Ipv4Header [class]
       
    69     module.add_class('Ipv4Header', allow_subclassing=True, parent=root_module['ns3::Header'])
       
    70     ## udp-socket.h: ns3::UdpSocket [class]
       
    71     module.add_class('UdpSocket', allow_subclassing=True, parent=root_module['ns3::Socket'])
       
    72     ## net-device.h: ns3::NetDevice [class]
       
    73     module.add_class('NetDevice', allow_subclassing=True, parent=root_module['ns3::Object'])
       
    74     ## channel.h: ns3::Channel [class]
       
    75     module.add_class('Channel', allow_subclassing=True, parent=root_module['ns3::Object'])
       
    76     ## simple-channel.h: ns3::SimpleChannel [class]
       
    77     module.add_class('SimpleChannel', allow_subclassing=True, parent=root_module['ns3::Channel'])
       
    78     ## address.h: ns3::AddressValue [class]
       
    79     module.add_class('AddressValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
       
    80     ## node.h: ns3::Node [class]
       
    81     module.add_class('Node', allow_subclassing=True, parent=root_module['ns3::Object'])
       
    82     ## tcp-socket.h: ns3::TcpSocket [class]
       
    83     module.add_class('TcpSocket', allow_subclassing=True, parent=root_module['ns3::Socket'])
       
    84     ## ethernet-header.h: ns3::EthernetHeader [class]
       
    85     module.add_class('EthernetHeader', allow_subclassing=True, parent=root_module['ns3::Header'])
       
    86     ## socket.h: ns3::SocketIpTtlTag [class]
       
    87     module.add_class('SocketIpTtlTag', allow_subclassing=True, parent=root_module['ns3::Tag'])
       
    88     ## ipv4.h: ns3::Ipv4 [class]
       
    89     module.add_class('Ipv4', allow_subclassing=True, parent=root_module['ns3::Object'])
       
    90     ## socket-factory.h: ns3::SocketFactory [class]
       
    91     module.add_class('SocketFactory', allow_subclassing=True, parent=root_module['ns3::Object'])
       
    92     ## drop-tail-queue.h: ns3::DropTailQueue [class]
       
    93     module.add_class('DropTailQueue', allow_subclassing=True, parent=root_module['ns3::Queue'])
       
    94     ## ethernet-trailer.h: ns3::EthernetTrailer [class]
       
    95     module.add_class('EthernetTrailer', allow_subclassing=True, parent=root_module['ns3::Trailer'])
       
    96     ## llc-snap-header.h: ns3::LlcSnapHeader [class]
       
    97     module.add_class('LlcSnapHeader', allow_subclassing=True, parent=root_module['ns3::Header'])
       
    98     ## udp-socket-factory.h: ns3::UdpSocketFactory [class]
       
    99     module.add_class('UdpSocketFactory', allow_subclassing=True, parent=root_module['ns3::SocketFactory'])
       
   100     ## simple-net-device.h: ns3::SimpleNetDevice [class]
       
   101     module.add_class('SimpleNetDevice', allow_subclassing=True, parent=root_module['ns3::NetDevice'])
       
   102     ## tcp-socket-factory.h: ns3::TcpSocketFactory [class]
       
   103     module.add_class('TcpSocketFactory', allow_subclassing=True, parent=root_module['ns3::SocketFactory'])
       
   104     ## packet-socket-factory.h: ns3::PacketSocketFactory [class]
       
   105     module.add_class('PacketSocketFactory', allow_subclassing=True, parent=root_module['ns3::SocketFactory'])
       
   106     
       
   107     ## Register a nested module for the namespace internal
       
   108     
       
   109     nested_module = module.add_cpp_namespace('internal')
       
   110     register_types_ns3_internal(nested_module)
       
   111     
       
   112     
       
   113     ## Register a nested module for the namespace TimeStepPrecision
       
   114     
       
   115     nested_module = module.add_cpp_namespace('TimeStepPrecision')
       
   116     register_types_ns3_TimeStepPrecision(nested_module)
       
   117     
       
   118     
       
   119     ## Register a nested module for the namespace Config
       
   120     
       
   121     nested_module = module.add_cpp_namespace('Config')
       
   122     register_types_ns3_Config(nested_module)
       
   123     
       
   124     
       
   125     ## Register a nested module for the namespace olsr
       
   126     
       
   127     nested_module = module.add_cpp_namespace('olsr')
       
   128     register_types_ns3_olsr(nested_module)
       
   129     
       
   130 
       
   131 def register_types_ns3_internal(module):
       
   132     root_module = module.get_root()
       
   133     
       
   134 
       
   135 def register_types_ns3_TimeStepPrecision(module):
       
   136     root_module = module.get_root()
       
   137     
       
   138 
       
   139 def register_types_ns3_Config(module):
       
   140     root_module = module.get_root()
       
   141     
       
   142 
       
   143 def register_types_ns3_olsr(module):
       
   144     root_module = module.get_root()
       
   145     
       
   146 
       
   147 def register_methods(root_module):
       
   148     register_Ns3NodeList_methods(root_module, root_module['ns3::NodeList'])
       
   149     register_Ns3Address_methods(root_module, root_module['ns3::Address'])
       
   150     register_Ns3Ipv4AddressChecker_methods(root_module, root_module['ns3::Ipv4AddressChecker'])
       
   151     register_Ns3Mac48Address_methods(root_module, root_module['ns3::Mac48Address'])
       
   152     register_Ns3Mac64Address_methods(root_module, root_module['ns3::Mac64Address'])
       
   153     register_Ns3Ipv4AddressGenerator_methods(root_module, root_module['ns3::Ipv4AddressGenerator'])
       
   154     register_Ns3Mac48AddressChecker_methods(root_module, root_module['ns3::Mac48AddressChecker'])
       
   155     register_Ns3Ipv4MaskChecker_methods(root_module, root_module['ns3::Ipv4MaskChecker'])
       
   156     register_Ns3Ipv4Route_methods(root_module, root_module['ns3::Ipv4Route'])
       
   157     register_Ns3Ipv4MulticastRoute_methods(root_module, root_module['ns3::Ipv4MulticastRoute'])
       
   158     register_Ns3AddressChecker_methods(root_module, root_module['ns3::AddressChecker'])
       
   159     register_Ns3PacketSocketAddress_methods(root_module, root_module['ns3::PacketSocketAddress'])
       
   160     register_Ns3Ipv4Mask_methods(root_module, root_module['ns3::Ipv4Mask'])
       
   161     register_Ns3Ipv4AddressValue_methods(root_module, root_module['ns3::Ipv4AddressValue'])
       
   162     register_Ns3Ipv4RoutingProtocol_methods(root_module, root_module['ns3::Ipv4RoutingProtocol'])
       
   163     register_Ns3Mac48AddressValue_methods(root_module, root_module['ns3::Mac48AddressValue'])
       
   164     register_Ns3Ipv4MaskValue_methods(root_module, root_module['ns3::Ipv4MaskValue'])
       
   165     register_Ns3SocketAddressTag_methods(root_module, root_module['ns3::SocketAddressTag'])
       
   166     register_Ns3InetSocketAddress_methods(root_module, root_module['ns3::InetSocketAddress'])
       
   167     register_Ns3Ipv4Address_methods(root_module, root_module['ns3::Ipv4Address'])
       
   168     register_Ns3Application_methods(root_module, root_module['ns3::Application'])
       
   169     register_Ns3Queue_methods(root_module, root_module['ns3::Queue'])
       
   170     register_Ns3Socket_methods(root_module, root_module['ns3::Socket'])
       
   171     register_Ns3Ipv4Header_methods(root_module, root_module['ns3::Ipv4Header'])
       
   172     register_Ns3UdpSocket_methods(root_module, root_module['ns3::UdpSocket'])
       
   173     register_Ns3NetDevice_methods(root_module, root_module['ns3::NetDevice'])
       
   174     register_Ns3Channel_methods(root_module, root_module['ns3::Channel'])
       
   175     register_Ns3SimpleChannel_methods(root_module, root_module['ns3::SimpleChannel'])
       
   176     register_Ns3AddressValue_methods(root_module, root_module['ns3::AddressValue'])
       
   177     register_Ns3Node_methods(root_module, root_module['ns3::Node'])
       
   178     register_Ns3TcpSocket_methods(root_module, root_module['ns3::TcpSocket'])
       
   179     register_Ns3EthernetHeader_methods(root_module, root_module['ns3::EthernetHeader'])
       
   180     register_Ns3SocketIpTtlTag_methods(root_module, root_module['ns3::SocketIpTtlTag'])
       
   181     register_Ns3Ipv4_methods(root_module, root_module['ns3::Ipv4'])
       
   182     register_Ns3SocketFactory_methods(root_module, root_module['ns3::SocketFactory'])
       
   183     register_Ns3DropTailQueue_methods(root_module, root_module['ns3::DropTailQueue'])
       
   184     register_Ns3EthernetTrailer_methods(root_module, root_module['ns3::EthernetTrailer'])
       
   185     register_Ns3LlcSnapHeader_methods(root_module, root_module['ns3::LlcSnapHeader'])
       
   186     register_Ns3UdpSocketFactory_methods(root_module, root_module['ns3::UdpSocketFactory'])
       
   187     register_Ns3SimpleNetDevice_methods(root_module, root_module['ns3::SimpleNetDevice'])
       
   188     register_Ns3TcpSocketFactory_methods(root_module, root_module['ns3::TcpSocketFactory'])
       
   189     register_Ns3PacketSocketFactory_methods(root_module, root_module['ns3::PacketSocketFactory'])
       
   190     return
       
   191 
       
   192 def register_Ns3NodeList_methods(root_module, cls):
       
   193     ## node-list.h: static uint32_t ns3::NodeList::Add(ns3::Ptr<ns3::Node> node) [member function]
       
   194     cls.add_method('Add', 'uint32_t', [param('ns3::Ptr< ns3::Node >', 'node')], is_static=True)
       
   195     ## 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]
       
   196     cls.add_method('Begin', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', [], is_static=True)
       
   197     ## 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]
       
   198     cls.add_method('End', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', [], is_static=True)
       
   199     ## node-list.h: static ns3::Ptr<ns3::Node> ns3::NodeList::GetNode(uint32_t n) [member function]
       
   200     cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [param('uint32_t', 'n')], is_static=True)
       
   201     ## node-list.h: static uint32_t ns3::NodeList::GetNNodes() [member function]
       
   202     cls.add_method('GetNNodes', 'uint32_t', [], is_static=True)
       
   203     cls.add_constructor([])
       
   204     return
       
   205 
       
   206 def register_Ns3Address_methods(root_module, cls):
       
   207     ## address.h: ns3::Address::Address() [constructor]
       
   208     cls.add_constructor([], visibility='public')
       
   209     ## address.h: ns3::Address::Address(uint8_t type, uint8_t const * buffer, uint8_t len) [constructor]
       
   210     cls.add_constructor([param('uint8_t', 'type'), param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint8_t', 'len')], visibility='public')
       
   211     ## address.h: ns3::Address::Address(ns3::Address const & address) [copy constructor]
       
   212     cls.add_constructor([param('ns3::Address&', 'address', is_const=True)], visibility='public')
       
   213     ## address.h: bool ns3::Address::CheckCompatible(uint8_t type, uint8_t len) const [member function]
       
   214     cls.add_method('CheckCompatible', 'bool', [param('uint8_t', 'type'), param('uint8_t', 'len')], is_const=True)
       
   215     ## address.h: uint32_t ns3::Address::CopyAllFrom(uint8_t const * buffer, uint8_t len) [member function]
       
   216     cls.add_method('CopyAllFrom', 'uint32_t', [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint8_t', 'len')])
       
   217     ## address.h: uint32_t ns3::Address::CopyAllTo(uint8_t * buffer, uint8_t len) const [member function]
       
   218     cls.add_method('CopyAllTo', 'uint32_t', [param('uint8_t *', 'buffer'), param('uint8_t', 'len')], is_const=True)
       
   219     ## address.h: uint32_t ns3::Address::CopyFrom(uint8_t const * buffer, uint8_t len) [member function]
       
   220     cls.add_method('CopyFrom', 'uint32_t', [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint8_t', 'len')])
       
   221     ## address.h: uint32_t ns3::Address::CopyTo(uint8_t * buffer) const [member function]
       
   222     cls.add_method('CopyTo', 'uint32_t', [param('uint8_t *', 'buffer')], is_const=True)
       
   223     ## address.h: void ns3::Address::Deserialize(ns3::TagBuffer buffer) [member function]
       
   224     cls.add_method('Deserialize', 'void', [param('ns3::TagBuffer', 'buffer')])
       
   225     ## address.h: uint8_t ns3::Address::GetLength() const [member function]
       
   226     cls.add_method('GetLength', 'uint8_t', [], is_const=True)
       
   227     ## address.h: uint32_t ns3::Address::GetSerializedSize() const [member function]
       
   228     cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True)
       
   229     ## address.h: bool ns3::Address::IsInvalid() const [member function]
       
   230     cls.add_method('IsInvalid', 'bool', [], is_const=True)
       
   231     ## address.h: bool ns3::Address::IsMatchingType(uint8_t type) const [member function]
       
   232     cls.add_method('IsMatchingType', 'bool', [param('uint8_t', 'type')], is_const=True)
       
   233     ## address.h: static uint8_t ns3::Address::Register() [member function]
       
   234     cls.add_method('Register', 'uint8_t', [], is_static=True)
       
   235     ## address.h: void ns3::Address::Serialize(ns3::TagBuffer buffer) const [member function]
       
   236     cls.add_method('Serialize', 'void', [param('ns3::TagBuffer', 'buffer')], is_const=True)
       
   237     cls.add_output_stream_operator()
       
   238     return
       
   239 
       
   240 def register_Ns3Ipv4AddressChecker_methods(root_module, cls):
       
   241     cls.add_constructor([])
       
   242     return
       
   243 
       
   244 def register_Ns3Mac48Address_methods(root_module, cls):
       
   245     ## mac48-address.h: ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [copy constructor]
       
   246     cls.add_constructor([param('ns3::Mac48Address&', 'arg0', is_const=True)], visibility='public')
       
   247     ## mac48-address.h: ns3::Mac48Address::Mac48Address() [constructor]
       
   248     cls.add_constructor([], visibility='public')
       
   249     ## mac48-address.h: ns3::Mac48Address::Mac48Address(char const * str) [constructor]
       
   250     cls.add_constructor([param('char *', 'str', transfer_ownership=False, is_const=True)], visibility='public')
       
   251     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::Allocate() [member function]
       
   252     cls.add_method('Allocate', 'ns3::Mac48Address', [], is_static=True)
       
   253     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::ConvertFrom(ns3::Address const & address) [member function]
       
   254     cls.add_method('ConvertFrom', 'ns3::Mac48Address', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
       
   255     ## mac48-address.h: void ns3::Mac48Address::CopyFrom(uint8_t const * buffer) [member function]
       
   256     cls.add_method('CopyFrom', 'void', [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True)])
       
   257     ## mac48-address.h: void ns3::Mac48Address::CopyTo(uint8_t * buffer) const [member function]
       
   258     cls.add_method('CopyTo', 'void', [param('uint8_t *', 'buffer')], is_const=True)
       
   259     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetBroadcast() [member function]
       
   260     cls.add_method('GetBroadcast', 'ns3::Mac48Address', [], is_static=True)
       
   261     ## mac48-address.h: bool ns3::Mac48Address::IsBroadcast() const [member function]
       
   262     cls.add_method('IsBroadcast', 'bool', [], is_const=True)
       
   263     ## mac48-address.h: static bool ns3::Mac48Address::IsMatchingType(ns3::Address const & address) [member function]
       
   264     cls.add_method('IsMatchingType', 'bool', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
       
   265     ## mac48-address.h: bool ns3::Mac48Address::IsMulticast() const [member function]
       
   266     cls.add_method('IsMulticast', 'bool', [], is_const=True)
       
   267     cls.add_output_stream_operator()
       
   268     return
       
   269 
       
   270 def register_Ns3Mac64Address_methods(root_module, cls):
       
   271     ## mac64-address.h: ns3::Mac64Address::Mac64Address(ns3::Mac64Address const & arg0) [copy constructor]
       
   272     cls.add_constructor([param('ns3::Mac64Address&', 'arg0', is_const=True)], visibility='public')
       
   273     ## mac64-address.h: ns3::Mac64Address::Mac64Address() [constructor]
       
   274     cls.add_constructor([], visibility='public')
       
   275     ## mac64-address.h: ns3::Mac64Address::Mac64Address(char const * str) [constructor]
       
   276     cls.add_constructor([param('char *', 'str', transfer_ownership=False, is_const=True)], visibility='public')
       
   277     ## mac64-address.h: static ns3::Mac64Address ns3::Mac64Address::Allocate() [member function]
       
   278     cls.add_method('Allocate', 'ns3::Mac64Address', [], is_static=True)
       
   279     ## mac64-address.h: static ns3::Mac64Address ns3::Mac64Address::ConvertFrom(ns3::Address const & address) [member function]
       
   280     cls.add_method('ConvertFrom', 'ns3::Mac64Address', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
       
   281     ## mac64-address.h: void ns3::Mac64Address::CopyFrom(uint8_t const * buffer) [member function]
       
   282     cls.add_method('CopyFrom', 'void', [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True)])
       
   283     ## mac64-address.h: void ns3::Mac64Address::CopyTo(uint8_t * buffer) const [member function]
       
   284     cls.add_method('CopyTo', 'void', [param('uint8_t *', 'buffer')], is_const=True)
       
   285     ## mac64-address.h: static bool ns3::Mac64Address::IsMatchingType(ns3::Address const & address) [member function]
       
   286     cls.add_method('IsMatchingType', 'bool', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
       
   287     cls.add_output_stream_operator()
       
   288     return
       
   289 
       
   290 def register_Ns3Ipv4AddressGenerator_methods(root_module, cls):
       
   291     ## 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]
       
   292     cls.add_method('Init', 'void', [param('ns3::Ipv4Address', 'net', is_const=True), param('ns3::Ipv4Mask', 'mask', is_const=True), param('ns3::Ipv4Address', 'addr', default_value='"0.0.0.1"', is_const=True)], is_static=True)
       
   293     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::NextNetwork(ns3::Ipv4Mask const mask) [member function]
       
   294     cls.add_method('NextNetwork', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask', 'mask', is_const=True)], is_static=True)
       
   295     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::GetNetwork(ns3::Ipv4Mask const mask) [member function]
       
   296     cls.add_method('GetNetwork', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask', 'mask', is_const=True)], is_static=True)
       
   297     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::InitAddress(ns3::Ipv4Address const addr, ns3::Ipv4Mask const mask) [member function]
       
   298     cls.add_method('InitAddress', 'void', [param('ns3::Ipv4Address', 'addr', is_const=True), param('ns3::Ipv4Mask', 'mask', is_const=True)], is_static=True)
       
   299     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::NextAddress(ns3::Ipv4Mask const mask) [member function]
       
   300     cls.add_method('NextAddress', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask', 'mask', is_const=True)], is_static=True)
       
   301     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::GetAddress(ns3::Ipv4Mask const mask) [member function]
       
   302     cls.add_method('GetAddress', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask', 'mask', is_const=True)], is_static=True)
       
   303     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::Reset() [member function]
       
   304     cls.add_method('Reset', 'void', [], is_static=True)
       
   305     ## ipv4-address-generator.h: static bool ns3::Ipv4AddressGenerator::AddAllocated(ns3::Ipv4Address const addr) [member function]
       
   306     cls.add_method('AddAllocated', 'bool', [param('ns3::Ipv4Address', 'addr', is_const=True)], is_static=True)
       
   307     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::TestMode() [member function]
       
   308     cls.add_method('TestMode', 'void', [], is_static=True)
       
   309     cls.add_constructor([])
       
   310     return
       
   311 
       
   312 def register_Ns3Mac48AddressChecker_methods(root_module, cls):
       
   313     cls.add_constructor([])
       
   314     return
       
   315 
       
   316 def register_Ns3Ipv4MaskChecker_methods(root_module, cls):
       
   317     cls.add_constructor([])
       
   318     return
       
   319 
       
   320 def register_Ns3Ipv4Route_methods(root_module, cls):
       
   321     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route() [constructor]
       
   322     cls.add_constructor([], visibility='public')
       
   323     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const & route) [copy constructor]
       
   324     cls.add_constructor([param('ns3::Ipv4Route&', 'route', is_const=True)], visibility='public')
       
   325     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const * route) [constructor]
       
   326     cls.add_constructor([param('ns3::Ipv4Route *', 'route', transfer_ownership=False, is_const=True)], visibility='public')
       
   327     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateDefaultRoute(ns3::Ipv4Address nextHop, uint32_t interface) [member function]
       
   328     cls.add_method('CreateDefaultRoute', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_static=True)
       
   329     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateHostRouteTo(ns3::Ipv4Address dest, ns3::Ipv4Address nextHop, uint32_t interface) [member function]
       
   330     cls.add_method('CreateHostRouteTo', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'dest'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_static=True)
       
   331     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateHostRouteTo(ns3::Ipv4Address dest, uint32_t interface) [member function]
       
   332     cls.add_method('CreateHostRouteTo', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'dest'), param('uint32_t', 'interface')], is_static=True)
       
   333     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, ns3::Ipv4Address nextHop, uint32_t interface) [member function]
       
   334     cls.add_method('CreateNetworkRouteTo', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_static=True)
       
   335     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, uint32_t interface) [member function]
       
   336     cls.add_method('CreateNetworkRouteTo', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('uint32_t', 'interface')], is_static=True)
       
   337     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetDest() const [member function]
       
   338     cls.add_method('GetDest', 'ns3::Ipv4Address', [], is_const=True)
       
   339     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetDestNetwork() const [member function]
       
   340     cls.add_method('GetDestNetwork', 'ns3::Ipv4Address', [], is_const=True)
       
   341     ## ipv4-route.h: ns3::Ipv4Mask ns3::Ipv4Route::GetDestNetworkMask() const [member function]
       
   342     cls.add_method('GetDestNetworkMask', 'ns3::Ipv4Mask', [], is_const=True)
       
   343     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetGateway() const [member function]
       
   344     cls.add_method('GetGateway', 'ns3::Ipv4Address', [], is_const=True)
       
   345     ## ipv4-route.h: uint32_t ns3::Ipv4Route::GetInterface() const [member function]
       
   346     cls.add_method('GetInterface', 'uint32_t', [], is_const=True)
       
   347     ## ipv4-route.h: bool ns3::Ipv4Route::IsDefault() const [member function]
       
   348     cls.add_method('IsDefault', 'bool', [], is_const=True)
       
   349     ## ipv4-route.h: bool ns3::Ipv4Route::IsGateway() const [member function]
       
   350     cls.add_method('IsGateway', 'bool', [], is_const=True)
       
   351     ## ipv4-route.h: bool ns3::Ipv4Route::IsHost() const [member function]
       
   352     cls.add_method('IsHost', 'bool', [], is_const=True)
       
   353     ## ipv4-route.h: bool ns3::Ipv4Route::IsNetwork() const [member function]
       
   354     cls.add_method('IsNetwork', 'bool', [], is_const=True)
       
   355     cls.add_output_stream_operator()
       
   356     return
       
   357 
       
   358 def register_Ns3Ipv4MulticastRoute_methods(root_module, cls):
       
   359     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute() [constructor]
       
   360     cls.add_constructor([], visibility='public')
       
   361     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const & route) [copy constructor]
       
   362     cls.add_constructor([param('ns3::Ipv4MulticastRoute&', 'route', is_const=True)], visibility='public')
       
   363     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const * route) [constructor]
       
   364     cls.add_constructor([param('ns3::Ipv4MulticastRoute *', 'route', transfer_ownership=False, is_const=True)], visibility='public')
       
   365     ## 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]
       
   366     cls.add_method('CreateMulticastRoute', 'ns3::Ipv4MulticastRoute', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int, std::allocator< unsigned int > >', 'outputInterfaces')], is_static=True)
       
   367     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4MulticastRoute::GetGroup() const [member function]
       
   368     cls.add_method('GetGroup', 'ns3::Ipv4Address', [], is_const=True)
       
   369     ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetInputInterface() const [member function]
       
   370     cls.add_method('GetInputInterface', 'uint32_t', [], is_const=True)
       
   371     ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetNOutputInterfaces() const [member function]
       
   372     cls.add_method('GetNOutputInterfaces', 'uint32_t', [], is_const=True)
       
   373     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4MulticastRoute::GetOrigin() const [member function]
       
   374     cls.add_method('GetOrigin', 'ns3::Ipv4Address', [], is_const=True)
       
   375     ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetOutputInterface(uint32_t n) const [member function]
       
   376     cls.add_method('GetOutputInterface', 'uint32_t', [param('uint32_t', 'n')], is_const=True)
       
   377     ## ipv4-route.h: std::vector<unsigned int, std::allocator<unsigned int> > ns3::Ipv4MulticastRoute::GetOutputInterfaces() const [member function]
       
   378     cls.add_method('GetOutputInterfaces', 'std::vector< unsigned int, std::allocator< unsigned int > >', [], is_const=True)
       
   379     cls.add_output_stream_operator()
       
   380     return
       
   381 
       
   382 def register_Ns3AddressChecker_methods(root_module, cls):
       
   383     cls.add_constructor([])
       
   384     return
       
   385 
       
   386 def register_Ns3PacketSocketAddress_methods(root_module, cls):
       
   387     ## packet-socket-address.h: ns3::PacketSocketAddress::PacketSocketAddress() [constructor]
       
   388     cls.add_constructor([], visibility='public')
       
   389     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetProtocol(uint16_t protocol) [member function]
       
   390     cls.add_method('SetProtocol', 'void', [param('uint16_t', 'protocol')])
       
   391     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetAllDevices() [member function]
       
   392     cls.add_method('SetAllDevices', 'void', [])
       
   393     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetSingleDevice(uint32_t device) [member function]
       
   394     cls.add_method('SetSingleDevice', 'void', [param('uint32_t', 'device')])
       
   395     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetPhysicalAddress(ns3::Address const address) [member function]
       
   396     cls.add_method('SetPhysicalAddress', 'void', [param('ns3::Address', 'address', is_const=True)])
       
   397     ## packet-socket-address.h: uint16_t ns3::PacketSocketAddress::GetProtocol() const [member function]
       
   398     cls.add_method('GetProtocol', 'uint16_t', [], is_const=True)
       
   399     ## packet-socket-address.h: uint32_t ns3::PacketSocketAddress::GetSingleDevice() const [member function]
       
   400     cls.add_method('GetSingleDevice', 'uint32_t', [], is_const=True)
       
   401     ## packet-socket-address.h: bool ns3::PacketSocketAddress::IsSingleDevice() const [member function]
       
   402     cls.add_method('IsSingleDevice', 'bool', [], is_const=True)
       
   403     ## packet-socket-address.h: ns3::Address ns3::PacketSocketAddress::GetPhysicalAddress() const [member function]
       
   404     cls.add_method('GetPhysicalAddress', 'ns3::Address', [], is_const=True)
       
   405     ## packet-socket-address.h: static ns3::PacketSocketAddress ns3::PacketSocketAddress::ConvertFrom(ns3::Address const & address) [member function]
       
   406     cls.add_method('ConvertFrom', 'ns3::PacketSocketAddress', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
       
   407     ## packet-socket-address.h: static bool ns3::PacketSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
       
   408     cls.add_method('IsMatchingType', 'bool', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
       
   409     return
       
   410 
       
   411 def register_Ns3Ipv4Mask_methods(root_module, cls):
       
   412     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor]
       
   413     cls.add_constructor([param('ns3::Ipv4Mask&', 'arg0', is_const=True)], visibility='public')
       
   414     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask() [constructor]
       
   415     cls.add_constructor([], visibility='public')
       
   416     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(uint32_t mask) [constructor]
       
   417     cls.add_constructor([param('uint32_t', 'mask')], visibility='public')
       
   418     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(char const * mask) [constructor]
       
   419     cls.add_constructor([param('char *', 'mask', transfer_ownership=False, is_const=True)], visibility='public')
       
   420     ## ipv4-address.h: uint32_t ns3::Ipv4Mask::Get() const [member function]
       
   421     cls.add_method('Get', 'uint32_t', [], is_const=True)
       
   422     ## ipv4-address.h: uint32_t ns3::Ipv4Mask::GetInverse() const [member function]
       
   423     cls.add_method('GetInverse', 'uint32_t', [], is_const=True)
       
   424     ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetLoopback() [member function]
       
   425     cls.add_method('GetLoopback', 'ns3::Ipv4Mask', [], is_static=True)
       
   426     ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetZero() [member function]
       
   427     cls.add_method('GetZero', 'ns3::Ipv4Mask', [], is_static=True)
       
   428     ## ipv4-address.h: bool ns3::Ipv4Mask::IsEqual(ns3::Ipv4Mask other) const [member function]
       
   429     cls.add_method('IsEqual', 'bool', [param('ns3::Ipv4Mask', 'other')], is_const=True)
       
   430     ## ipv4-address.h: bool ns3::Ipv4Mask::IsMatch(ns3::Ipv4Address a, ns3::Ipv4Address b) const [member function]
       
   431     cls.add_method('IsMatch', 'bool', [param('ns3::Ipv4Address', 'a'), param('ns3::Ipv4Address', 'b')], is_const=True)
       
   432     ## ipv4-address.h: void ns3::Ipv4Mask::Print(std::ostream & os) const [member function]
       
   433     cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True)
       
   434     ## ipv4-address.h: void ns3::Ipv4Mask::Set(uint32_t mask) [member function]
       
   435     cls.add_method('Set', 'void', [param('uint32_t', 'mask')])
       
   436     cls.add_output_stream_operator()
       
   437     return
       
   438 
       
   439 def register_Ns3Ipv4AddressValue_methods(root_module, cls):
       
   440     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue() [constructor]
       
   441     cls.add_constructor([], visibility='public')
       
   442     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4Address const & value) [constructor]
       
   443     cls.add_constructor([param('ns3::Ipv4Address&', 'value', is_const=True)], visibility='public')
       
   444     ## ipv4-address.h: void ns3::Ipv4AddressValue::Set(ns3::Ipv4Address const & value) [member function]
       
   445     cls.add_method('Set', 'void', [param('ns3::Ipv4Address&', 'value', is_const=True)])
       
   446     ## ipv4-address.h: ns3::Ipv4Address ns3::Ipv4AddressValue::Get() const [member function]
       
   447     cls.add_method('Get', 'ns3::Ipv4Address', [], is_const=True)
       
   448     ## ipv4-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Ipv4AddressValue::Copy() const [member function]
       
   449     cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
       
   450     ## ipv4-address.h: std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
   451     cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)
       
   452     ## ipv4-address.h: bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
   453     cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)
       
   454     return
       
   455 
       
   456 def register_Ns3Ipv4RoutingProtocol_methods(root_module, cls):
       
   457     ## ipv4.h: ns3::Ipv4RoutingProtocol::IF_INDEX_ANY [variable]
       
   458     cls.add_static_attribute('IF_INDEX_ANY', retval('uint32_t', is_const=True), is_const=True)
       
   459     ## 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]
       
   460     cls.add_method('RequestRoute', 'bool', [param('uint32_t', 'ifIndex'), param('ns3::Ipv4Header&', 'ipHeader', is_const=True), param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Callback< void, bool, const ns3::Ipv4Route&, ns3::Ptr< ns3::Packet >, const ns3::Ipv4Header&, ns3::empty, ns3::empty >', 'routeReply')], is_pure_virtual=True, is_virtual=True)
       
   461     ## ipv4.h: bool ns3::Ipv4RoutingProtocol::RequestIfIndex(ns3::Ipv4Address destination, uint32_t & ifIndex) [member function]
       
   462     cls.add_method('RequestIfIndex', 'bool', [param('ns3::Ipv4Address', 'destination'), param('uint32_t&', 'ifIndex')], is_pure_virtual=True, is_virtual=True)
       
   463     cls.add_constructor([])
       
   464     return
       
   465 
       
   466 def register_Ns3Mac48AddressValue_methods(root_module, cls):
       
   467     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue() [constructor]
       
   468     cls.add_constructor([], visibility='public')
       
   469     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48Address const & value) [constructor]
       
   470     cls.add_constructor([param('ns3::Mac48Address&', 'value', is_const=True)], visibility='public')
       
   471     ## mac48-address.h: void ns3::Mac48AddressValue::Set(ns3::Mac48Address const & value) [member function]
       
   472     cls.add_method('Set', 'void', [param('ns3::Mac48Address&', 'value', is_const=True)])
       
   473     ## mac48-address.h: ns3::Mac48Address ns3::Mac48AddressValue::Get() const [member function]
       
   474     cls.add_method('Get', 'ns3::Mac48Address', [], is_const=True)
       
   475     ## mac48-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Mac48AddressValue::Copy() const [member function]
       
   476     cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
       
   477     ## mac48-address.h: std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
   478     cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)
       
   479     ## mac48-address.h: bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
   480     cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)
       
   481     return
       
   482 
       
   483 def register_Ns3Ipv4MaskValue_methods(root_module, cls):
       
   484     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue() [constructor]
       
   485     cls.add_constructor([], visibility='public')
       
   486     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4Mask const & value) [constructor]
       
   487     cls.add_constructor([param('ns3::Ipv4Mask&', 'value', is_const=True)], visibility='public')
       
   488     ## ipv4-address.h: void ns3::Ipv4MaskValue::Set(ns3::Ipv4Mask const & value) [member function]
       
   489     cls.add_method('Set', 'void', [param('ns3::Ipv4Mask&', 'value', is_const=True)])
       
   490     ## ipv4-address.h: ns3::Ipv4Mask ns3::Ipv4MaskValue::Get() const [member function]
       
   491     cls.add_method('Get', 'ns3::Ipv4Mask', [], is_const=True)
       
   492     ## ipv4-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Ipv4MaskValue::Copy() const [member function]
       
   493     cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
       
   494     ## ipv4-address.h: std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
   495     cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)
       
   496     ## ipv4-address.h: bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
   497     cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)
       
   498     return
       
   499 
       
   500 def register_Ns3SocketAddressTag_methods(root_module, cls):
       
   501     ## socket.h: ns3::SocketAddressTag::SocketAddressTag() [constructor]
       
   502     cls.add_constructor([], visibility='public')
       
   503     ## socket.h: void ns3::SocketAddressTag::SetAddress(ns3::Address addr) [member function]
       
   504     cls.add_method('SetAddress', 'void', [param('ns3::Address', 'addr')])
       
   505     ## socket.h: ns3::Address ns3::SocketAddressTag::GetAddress() const [member function]
       
   506     cls.add_method('GetAddress', 'ns3::Address', [], is_const=True)
       
   507     ## socket.h: static ns3::TypeId ns3::SocketAddressTag::GetTypeId() [member function]
       
   508     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
       
   509     ## socket.h: ns3::TypeId ns3::SocketAddressTag::GetInstanceTypeId() const [member function]
       
   510     cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True)
       
   511     ## socket.h: uint32_t ns3::SocketAddressTag::GetSerializedSize() const [member function]
       
   512     cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True)
       
   513     ## socket.h: void ns3::SocketAddressTag::Serialize(ns3::TagBuffer i) const [member function]
       
   514     cls.add_method('Serialize', 'void', [param('ns3::TagBuffer', 'i')], is_const=True, is_virtual=True)
       
   515     ## socket.h: void ns3::SocketAddressTag::Deserialize(ns3::TagBuffer i) [member function]
       
   516     cls.add_method('Deserialize', 'void', [param('ns3::TagBuffer', 'i')], is_virtual=True)
       
   517     ## socket.h: void ns3::SocketAddressTag::Print(std::ostream & os) const [member function]
       
   518     cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True)
       
   519     return
       
   520 
       
   521 def register_Ns3InetSocketAddress_methods(root_module, cls):
       
   522     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4, uint16_t port) [constructor]
       
   523     cls.add_constructor([param('ns3::Ipv4Address', 'ipv4'), param('uint16_t', 'port')], visibility='public')
       
   524     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4) [constructor]
       
   525     cls.add_constructor([param('ns3::Ipv4Address', 'ipv4')], visibility='public')
       
   526     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(uint16_t port) [constructor]
       
   527     cls.add_constructor([param('uint16_t', 'port')], visibility='public')
       
   528     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(char const * ipv4, uint16_t port) [constructor]
       
   529     cls.add_constructor([param('char *', 'ipv4', transfer_ownership=False, is_const=True), param('uint16_t', 'port')], visibility='public')
       
   530     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(char const * ipv4) [constructor]
       
   531     cls.add_constructor([param('char *', 'ipv4', transfer_ownership=False, is_const=True)], visibility='public')
       
   532     ## inet-socket-address.h: uint16_t ns3::InetSocketAddress::GetPort() const [member function]
       
   533     cls.add_method('GetPort', 'uint16_t', [], is_const=True)
       
   534     ## inet-socket-address.h: ns3::Ipv4Address ns3::InetSocketAddress::GetIpv4() const [member function]
       
   535     cls.add_method('GetIpv4', 'ns3::Ipv4Address', [], is_const=True)
       
   536     ## inet-socket-address.h: void ns3::InetSocketAddress::SetPort(uint16_t port) [member function]
       
   537     cls.add_method('SetPort', 'void', [param('uint16_t', 'port')])
       
   538     ## inet-socket-address.h: void ns3::InetSocketAddress::SetIpv4(ns3::Ipv4Address address) [member function]
       
   539     cls.add_method('SetIpv4', 'void', [param('ns3::Ipv4Address', 'address')])
       
   540     ## inet-socket-address.h: static bool ns3::InetSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
       
   541     cls.add_method('IsMatchingType', 'bool', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
       
   542     ## inet-socket-address.h: static ns3::InetSocketAddress ns3::InetSocketAddress::ConvertFrom(ns3::Address const & address) [member function]
       
   543     cls.add_method('ConvertFrom', 'ns3::InetSocketAddress', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
       
   544     return
       
   545 
       
   546 def register_Ns3Ipv4Address_methods(root_module, cls):
       
   547     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor]
       
   548     cls.add_constructor([param('ns3::Ipv4Address&', 'arg0', is_const=True)], visibility='public')
       
   549     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address() [constructor]
       
   550     cls.add_constructor([], visibility='public')
       
   551     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(uint32_t address) [constructor]
       
   552     cls.add_constructor([param('uint32_t', 'address')], visibility='public')
       
   553     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(char const * address) [constructor]
       
   554     cls.add_constructor([param('char *', 'address', transfer_ownership=False, is_const=True)], visibility='public')
       
   555     ## ipv4-address.h: ns3::Ipv4Address ns3::Ipv4Address::CombineMask(ns3::Ipv4Mask const & mask) const [member function]
       
   556     cls.add_method('CombineMask', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask&', 'mask', is_const=True)], is_const=True)
       
   557     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::ConvertFrom(ns3::Address const & address) [member function]
       
   558     cls.add_method('ConvertFrom', 'ns3::Ipv4Address', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
       
   559     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::Deserialize(uint8_t const * buf) [member function]
       
   560     cls.add_method('Deserialize', 'ns3::Ipv4Address', [param('uint8_t *', 'buf', transfer_ownership=False, is_const=True)], is_static=True)
       
   561     ## ipv4-address.h: uint32_t ns3::Ipv4Address::Get() const [member function]
       
   562     cls.add_method('Get', 'uint32_t', [], is_const=True)
       
   563     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetAny() [member function]
       
   564     cls.add_method('GetAny', 'ns3::Ipv4Address', [], is_static=True)
       
   565     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetBroadcast() [member function]
       
   566     cls.add_method('GetBroadcast', 'ns3::Ipv4Address', [], is_static=True)
       
   567     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetLoopback() [member function]
       
   568     cls.add_method('GetLoopback', 'ns3::Ipv4Address', [], is_static=True)
       
   569     ## ipv4-address.h: ns3::Ipv4Address ns3::Ipv4Address::GetSubnetDirectedBroadcast(ns3::Ipv4Mask const & mask) const [member function]
       
   570     cls.add_method('GetSubnetDirectedBroadcast', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask&', 'mask', is_const=True)], is_const=True)
       
   571     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetZero() [member function]
       
   572     cls.add_method('GetZero', 'ns3::Ipv4Address', [], is_static=True)
       
   573     ## ipv4-address.h: bool ns3::Ipv4Address::IsBroadcast() const [member function]
       
   574     cls.add_method('IsBroadcast', 'bool', [], is_const=True)
       
   575     ## ipv4-address.h: bool ns3::Ipv4Address::IsEqual(ns3::Ipv4Address const & other) const [member function]
       
   576     cls.add_method('IsEqual', 'bool', [param('ns3::Ipv4Address&', 'other', is_const=True)], is_const=True)
       
   577     ## ipv4-address.h: static bool ns3::Ipv4Address::IsMatchingType(ns3::Address const & address) [member function]
       
   578     cls.add_method('IsMatchingType', 'bool', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
       
   579     ## ipv4-address.h: bool ns3::Ipv4Address::IsMulticast() const [member function]
       
   580     cls.add_method('IsMulticast', 'bool', [], is_const=True)
       
   581     ## ipv4-address.h: bool ns3::Ipv4Address::IsSubnetDirectedBroadcast(ns3::Ipv4Mask const & mask) const [member function]
       
   582     cls.add_method('IsSubnetDirectedBroadcast', 'bool', [param('ns3::Ipv4Mask&', 'mask', is_const=True)], is_const=True)
       
   583     ## ipv4-address.h: void ns3::Ipv4Address::Print(std::ostream & os) const [member function]
       
   584     cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True)
       
   585     ## ipv4-address.h: void ns3::Ipv4Address::Serialize(uint8_t * buf) const [member function]
       
   586     cls.add_method('Serialize', 'void', [param('uint8_t *', 'buf')], is_const=True)
       
   587     ## ipv4-address.h: void ns3::Ipv4Address::Set(uint32_t address) [member function]
       
   588     cls.add_method('Set', 'void', [param('uint32_t', 'address')])
       
   589     ## ipv4-address.h: void ns3::Ipv4Address::Set(char const * address) [member function]
       
   590     cls.add_method('Set', 'void', [param('char *', 'address', transfer_ownership=False, is_const=True)])
       
   591     cls.add_output_stream_operator()
       
   592     return
       
   593 
       
   594 def register_Ns3Application_methods(root_module, cls):
       
   595     ## application.h: static ns3::TypeId ns3::Application::GetTypeId() [member function]
       
   596     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
       
   597     ## application.h: ns3::Application::Application() [constructor]
       
   598     cls.add_constructor([], visibility='public')
       
   599     ## application.h: void ns3::Application::Start(ns3::Time const & startTime) [member function]
       
   600     cls.add_method('Start', 'void', [param('ns3::Time&', 'startTime', is_const=True)])
       
   601     ## application.h: void ns3::Application::Start(ns3::RandomVariable const & startVariable) [member function]
       
   602     cls.add_method('Start', 'void', [param('ns3::RandomVariable&', 'startVariable', is_const=True)])
       
   603     ## application.h: void ns3::Application::Stop(ns3::Time const & stopTime) [member function]
       
   604     cls.add_method('Stop', 'void', [param('ns3::Time&', 'stopTime', is_const=True)])
       
   605     ## application.h: void ns3::Application::Stop(ns3::RandomVariable const & stopVariable) [member function]
       
   606     cls.add_method('Stop', 'void', [param('ns3::RandomVariable&', 'stopVariable', is_const=True)])
       
   607     ## application.h: ns3::Ptr<ns3::Node> ns3::Application::GetNode() const [member function]
       
   608     cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [], is_const=True)
       
   609     ## application.h: void ns3::Application::SetNode(ns3::Ptr<ns3::Node> node) [member function]
       
   610     cls.add_method('SetNode', 'void', [param('ns3::Ptr< ns3::Node >', 'node')])
       
   611     ## application.h: void ns3::Application::DoDispose() [member function]
       
   612     cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True)
       
   613     ## application.h: void ns3::Application::StartApplication() [member function]
       
   614     cls.add_method('StartApplication', 'void', [], visibility='private', is_virtual=True)
       
   615     ## application.h: void ns3::Application::StopApplication() [member function]
       
   616     cls.add_method('StopApplication', 'void', [], visibility='private', is_virtual=True)
       
   617     return
       
   618 
       
   619 def register_Ns3Queue_methods(root_module, cls):
       
   620     ## queue.h: static ns3::TypeId ns3::Queue::GetTypeId() [member function]
       
   621     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
       
   622     ## queue.h: ns3::Queue::Queue() [constructor]
       
   623     cls.add_constructor([], visibility='public')
       
   624     ## queue.h: bool ns3::Queue::IsEmpty() const [member function]
       
   625     cls.add_method('IsEmpty', 'bool', [], is_const=True)
       
   626     ## queue.h: bool ns3::Queue::Enqueue(ns3::Ptr<ns3::Packet> p) [member function]
       
   627     cls.add_method('Enqueue', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')])
       
   628     ## queue.h: ns3::Ptr<ns3::Packet> ns3::Queue::Dequeue() [member function]
       
   629     cls.add_method('Dequeue', 'ns3::Ptr< ns3::Packet >', [])
       
   630     ## queue.h: ns3::Ptr<ns3::Packet> ns3::Queue::Peek() const [member function]
       
   631     cls.add_method('Peek', 'ns3::Ptr< ns3::Packet >', [], is_const=True)
       
   632     ## queue.h: void ns3::Queue::DequeueAll() [member function]
       
   633     cls.add_method('DequeueAll', 'void', [])
       
   634     ## queue.h: uint32_t ns3::Queue::GetNPackets() const [member function]
       
   635     cls.add_method('GetNPackets', 'uint32_t', [], is_const=True)
       
   636     ## queue.h: uint32_t ns3::Queue::GetNBytes() const [member function]
       
   637     cls.add_method('GetNBytes', 'uint32_t', [], is_const=True)
       
   638     ## queue.h: uint32_t ns3::Queue::GetTotalReceivedBytes() const [member function]
       
   639     cls.add_method('GetTotalReceivedBytes', 'uint32_t', [], is_const=True)
       
   640     ## queue.h: uint32_t ns3::Queue::GetTotalReceivedPackets() const [member function]
       
   641     cls.add_method('GetTotalReceivedPackets', 'uint32_t', [], is_const=True)
       
   642     ## queue.h: uint32_t ns3::Queue::GetTotalDroppedBytes() const [member function]
       
   643     cls.add_method('GetTotalDroppedBytes', 'uint32_t', [], is_const=True)
       
   644     ## queue.h: uint32_t ns3::Queue::GetTotalDroppedPackets() const [member function]
       
   645     cls.add_method('GetTotalDroppedPackets', 'uint32_t', [], is_const=True)
       
   646     ## queue.h: void ns3::Queue::ResetStatistics() [member function]
       
   647     cls.add_method('ResetStatistics', 'void', [])
       
   648     ## queue.h: void ns3::Queue::Drop(ns3::Ptr<ns3::Packet> packet) [member function]
       
   649     cls.add_method('Drop', 'void', [param('ns3::Ptr< ns3::Packet >', 'packet')], visibility='protected')
       
   650     ## queue.h: bool ns3::Queue::DoEnqueue(ns3::Ptr<ns3::Packet> p) [member function]
       
   651     cls.add_method('DoEnqueue', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')], is_pure_virtual=True, visibility='private', is_virtual=True)
       
   652     ## queue.h: ns3::Ptr<ns3::Packet> ns3::Queue::DoDequeue() [member function]
       
   653     cls.add_method('DoDequeue', 'ns3::Ptr< ns3::Packet >', [], is_pure_virtual=True, visibility='private', is_virtual=True)
       
   654     ## queue.h: ns3::Ptr<ns3::Packet> ns3::Queue::DoPeek() const [member function]
       
   655     cls.add_method('DoPeek', 'ns3::Ptr< ns3::Packet >', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
   656     return
       
   657 
       
   658 def register_Ns3Socket_methods(root_module, cls):
       
   659     ## socket.h: ns3::Socket::Socket() [constructor]
       
   660     cls.add_constructor([], visibility='public')
       
   661     ## socket.h: static ns3::Ptr<ns3::Socket> ns3::Socket::CreateSocket(ns3::Ptr<ns3::Node> node, ns3::TypeId tid) [member function]
       
   662     cls.add_method('CreateSocket', 'ns3::Ptr< ns3::Socket >', [param('ns3::Ptr< ns3::Node >', 'node'), param('ns3::TypeId', 'tid')], is_static=True)
       
   663     ## socket.h: ns3::Socket::SocketErrno ns3::Socket::GetErrno() const [member function]
       
   664     cls.add_method('GetErrno', 'ns3::Socket::SocketErrno', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   665     ## socket.h: ns3::Ptr<ns3::Node> ns3::Socket::GetNode() const [member function]
       
   666     cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   667     ## socket.h: void ns3::Socket::SetConnectCallback(ns3::Callback<void, ns3::Ptr<ns3::Socket>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionSucceeded, ns3::Callback<void, ns3::Ptr<ns3::Socket>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionFailed) [member function]
       
   668     cls.add_method('SetConnectCallback', 'void', [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')])
       
   669     ## 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]
       
   670     cls.add_method('SetAcceptCallback', 'void', [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')])
       
   671     ## 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]
       
   672     cls.add_method('SetDataSentCallback', 'bool', [param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'dataSent')], is_virtual=True)
       
   673     ## 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]
       
   674     cls.add_method('SetSendCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'sendCb')])
       
   675     ## socket.h: void ns3::Socket::SetRecvCallback(ns3::Callback<void, ns3::Ptr<ns3::Socket>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> arg0) [member function]
       
   676     cls.add_method('SetRecvCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'arg0')])
       
   677     ## socket.h: int ns3::Socket::Bind(ns3::Address const & address) [member function]
       
   678     cls.add_method('Bind', 'int', [param('ns3::Address&', 'address', is_const=True)], is_pure_virtual=True, is_virtual=True)
       
   679     ## socket.h: int ns3::Socket::Bind() [member function]
       
   680     cls.add_method('Bind', 'int', [], is_pure_virtual=True, is_virtual=True)
       
   681     ## socket.h: int ns3::Socket::Close() [member function]
       
   682     cls.add_method('Close', 'int', [], is_pure_virtual=True, is_virtual=True)
       
   683     ## socket.h: int ns3::Socket::ShutdownSend() [member function]
       
   684     cls.add_method('ShutdownSend', 'int', [], is_pure_virtual=True, is_virtual=True)
       
   685     ## socket.h: int ns3::Socket::ShutdownRecv() [member function]
       
   686     cls.add_method('ShutdownRecv', 'int', [], is_pure_virtual=True, is_virtual=True)
       
   687     ## socket.h: int ns3::Socket::Connect(ns3::Address const & address) [member function]
       
   688     cls.add_method('Connect', 'int', [param('ns3::Address&', 'address', is_const=True)], is_pure_virtual=True, is_virtual=True)
       
   689     ## socket.h: int ns3::Socket::Listen(uint32_t queueLimit) [member function]
       
   690     cls.add_method('Listen', 'int', [param('uint32_t', 'queueLimit')], is_pure_virtual=True, is_virtual=True)
       
   691     ## socket.h: uint32_t ns3::Socket::GetTxAvailable() const [member function]
       
   692     cls.add_method('GetTxAvailable', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   693     ## socket.h: int ns3::Socket::Send(ns3::Ptr<ns3::Packet> p, uint32_t flags) [member function]
       
   694     cls.add_method('Send', 'int', [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags')], is_pure_virtual=True, is_virtual=True)
       
   695     ## socket.h: int ns3::Socket::SendTo(ns3::Ptr<ns3::Packet> p, uint32_t flags, ns3::Address const & toAddress) [member function]
       
   696     cls.add_method('SendTo', 'int', [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags'), param('ns3::Address&', 'toAddress', is_const=True)], is_pure_virtual=True, is_virtual=True)
       
   697     ## socket.h: uint32_t ns3::Socket::GetRxAvailable() const [member function]
       
   698     cls.add_method('GetRxAvailable', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   699     ## socket.h: ns3::Ptr<ns3::Packet> ns3::Socket::Recv(uint32_t maxSize, uint32_t flags) [member function]
       
   700     cls.add_method('Recv', 'ns3::Ptr< ns3::Packet >', [param('uint32_t', 'maxSize'), param('uint32_t', 'flags')], is_pure_virtual=True, is_virtual=True)
       
   701     ## socket.h: ns3::Ptr<ns3::Packet> ns3::Socket::RecvFrom(uint32_t maxSize, uint32_t flags, ns3::Address & fromAddress) [member function]
       
   702     cls.add_method('RecvFrom', 'ns3::Ptr< ns3::Packet >', [param('uint32_t', 'maxSize'), param('uint32_t', 'flags'), param('ns3::Address&', 'fromAddress')], is_pure_virtual=True, is_virtual=True)
       
   703     ## socket.h: int ns3::Socket::Send(ns3::Ptr<ns3::Packet> p) [member function]
       
   704     cls.add_method('Send', 'int', [param('ns3::Ptr< ns3::Packet >', 'p')])
       
   705     ## socket.h: int ns3::Socket::Send(uint8_t const * buf, uint32_t size, uint32_t flags) [member function]
       
   706     cls.add_method('Send', 'int', [param('uint8_t *', 'buf', transfer_ownership=False, is_const=True), param('uint32_t', 'size'), param('uint32_t', 'flags')])
       
   707     ## socket.h: int ns3::Socket::SendTo(uint8_t const * buf, uint32_t size, uint32_t flags, ns3::Address const & address) [member function]
       
   708     cls.add_method('SendTo', 'int', [param('uint8_t *', 'buf', transfer_ownership=False, is_const=True), param('uint32_t', 'size'), param('uint32_t', 'flags'), param('ns3::Address&', 'address', is_const=True)])
       
   709     ## socket.h: ns3::Ptr<ns3::Packet> ns3::Socket::Recv() [member function]
       
   710     cls.add_method('Recv', 'ns3::Ptr< ns3::Packet >', [])
       
   711     ## socket.h: int ns3::Socket::Recv(uint8_t * buf, uint32_t size, uint32_t flags) [member function]
       
   712     cls.add_method('Recv', 'int', [param('uint8_t *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags')])
       
   713     ## socket.h: ns3::Ptr<ns3::Packet> ns3::Socket::RecvFrom(ns3::Address & fromAddress) [member function]
       
   714     cls.add_method('RecvFrom', 'ns3::Ptr< ns3::Packet >', [param('ns3::Address&', 'fromAddress')])
       
   715     ## socket.h: int ns3::Socket::RecvFrom(uint8_t * buf, uint32_t size, uint32_t flags, ns3::Address & fromAddress) [member function]
       
   716     cls.add_method('RecvFrom', 'int', [param('uint8_t *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags'), param('ns3::Address&', 'fromAddress')])
       
   717     ## socket.h: void ns3::Socket::NotifyConnectionSucceeded() [member function]
       
   718     cls.add_method('NotifyConnectionSucceeded', 'void', [], visibility='protected')
       
   719     ## socket.h: void ns3::Socket::NotifyConnectionFailed() [member function]
       
   720     cls.add_method('NotifyConnectionFailed', 'void', [], visibility='protected')
       
   721     ## socket.h: bool ns3::Socket::NotifyConnectionRequest(ns3::Address const & from) [member function]
       
   722     cls.add_method('NotifyConnectionRequest', 'bool', [param('ns3::Address&', 'from', is_const=True)], visibility='protected')
       
   723     ## socket.h: void ns3::Socket::NotifyNewConnectionCreated(ns3::Ptr<ns3::Socket> socket, ns3::Address const & from) [member function]
       
   724     cls.add_method('NotifyNewConnectionCreated', 'void', [param('ns3::Ptr< ns3::Socket >', 'socket'), param('ns3::Address&', 'from', is_const=True)], visibility='protected')
       
   725     ## socket.h: void ns3::Socket::NotifyDataSent(uint32_t size) [member function]
       
   726     cls.add_method('NotifyDataSent', 'void', [param('uint32_t', 'size')], visibility='protected')
       
   727     ## socket.h: void ns3::Socket::NotifySend(uint32_t spaceAvailable) [member function]
       
   728     cls.add_method('NotifySend', 'void', [param('uint32_t', 'spaceAvailable')], visibility='protected')
       
   729     ## socket.h: void ns3::Socket::NotifyDataRecv() [member function]
       
   730     cls.add_method('NotifyDataRecv', 'void', [], visibility='protected')
       
   731     return
       
   732 
       
   733 def register_Ns3Ipv4Header_methods(root_module, cls):
       
   734     ## ipv4-header.h: ns3::Ipv4Header::Ipv4Header() [constructor]
       
   735     cls.add_constructor([], visibility='public')
       
   736     ## ipv4-header.h: void ns3::Ipv4Header::EnableChecksum() [member function]
       
   737     cls.add_method('EnableChecksum', 'void', [])
       
   738     ## ipv4-header.h: void ns3::Ipv4Header::SetPayloadSize(uint16_t size) [member function]
       
   739     cls.add_method('SetPayloadSize', 'void', [param('uint16_t', 'size')])
       
   740     ## ipv4-header.h: void ns3::Ipv4Header::SetIdentification(uint16_t identification) [member function]
       
   741     cls.add_method('SetIdentification', 'void', [param('uint16_t', 'identification')])
       
   742     ## ipv4-header.h: void ns3::Ipv4Header::SetTos(uint8_t tos) [member function]
       
   743     cls.add_method('SetTos', 'void', [param('uint8_t', 'tos')])
       
   744     ## ipv4-header.h: void ns3::Ipv4Header::SetMoreFragments() [member function]
       
   745     cls.add_method('SetMoreFragments', 'void', [])
       
   746     ## ipv4-header.h: void ns3::Ipv4Header::SetLastFragment() [member function]
       
   747     cls.add_method('SetLastFragment', 'void', [])
       
   748     ## ipv4-header.h: void ns3::Ipv4Header::SetDontFragment() [member function]
       
   749     cls.add_method('SetDontFragment', 'void', [])
       
   750     ## ipv4-header.h: void ns3::Ipv4Header::SetMayFragment() [member function]
       
   751     cls.add_method('SetMayFragment', 'void', [])
       
   752     ## ipv4-header.h: void ns3::Ipv4Header::SetFragmentOffset(uint16_t offset) [member function]
       
   753     cls.add_method('SetFragmentOffset', 'void', [param('uint16_t', 'offset')])
       
   754     ## ipv4-header.h: void ns3::Ipv4Header::SetTtl(uint8_t ttl) [member function]
       
   755     cls.add_method('SetTtl', 'void', [param('uint8_t', 'ttl')])
       
   756     ## ipv4-header.h: void ns3::Ipv4Header::SetProtocol(uint8_t num) [member function]
       
   757     cls.add_method('SetProtocol', 'void', [param('uint8_t', 'num')])
       
   758     ## ipv4-header.h: void ns3::Ipv4Header::SetSource(ns3::Ipv4Address source) [member function]
       
   759     cls.add_method('SetSource', 'void', [param('ns3::Ipv4Address', 'source')])
       
   760     ## ipv4-header.h: void ns3::Ipv4Header::SetDestination(ns3::Ipv4Address destination) [member function]
       
   761     cls.add_method('SetDestination', 'void', [param('ns3::Ipv4Address', 'destination')])
       
   762     ## ipv4-header.h: uint16_t ns3::Ipv4Header::GetPayloadSize() const [member function]
       
   763     cls.add_method('GetPayloadSize', 'uint16_t', [], is_const=True)
       
   764     ## ipv4-header.h: uint16_t ns3::Ipv4Header::GetIdentification() const [member function]
       
   765     cls.add_method('GetIdentification', 'uint16_t', [], is_const=True)
       
   766     ## ipv4-header.h: uint8_t ns3::Ipv4Header::GetTos() const [member function]
       
   767     cls.add_method('GetTos', 'uint8_t', [], is_const=True)
       
   768     ## ipv4-header.h: bool ns3::Ipv4Header::IsLastFragment() const [member function]
       
   769     cls.add_method('IsLastFragment', 'bool', [], is_const=True)
       
   770     ## ipv4-header.h: bool ns3::Ipv4Header::IsDontFragment() const [member function]
       
   771     cls.add_method('IsDontFragment', 'bool', [], is_const=True)
       
   772     ## ipv4-header.h: uint16_t ns3::Ipv4Header::GetFragmentOffset() const [member function]
       
   773     cls.add_method('GetFragmentOffset', 'uint16_t', [], is_const=True)
       
   774     ## ipv4-header.h: uint8_t ns3::Ipv4Header::GetTtl() const [member function]
       
   775     cls.add_method('GetTtl', 'uint8_t', [], is_const=True)
       
   776     ## ipv4-header.h: uint8_t ns3::Ipv4Header::GetProtocol() const [member function]
       
   777     cls.add_method('GetProtocol', 'uint8_t', [], is_const=True)
       
   778     ## ipv4-header.h: ns3::Ipv4Address ns3::Ipv4Header::GetSource() const [member function]
       
   779     cls.add_method('GetSource', 'ns3::Ipv4Address', [], is_const=True)
       
   780     ## ipv4-header.h: ns3::Ipv4Address ns3::Ipv4Header::GetDestination() const [member function]
       
   781     cls.add_method('GetDestination', 'ns3::Ipv4Address', [], is_const=True)
       
   782     ## ipv4-header.h: bool ns3::Ipv4Header::IsChecksumOk() const [member function]
       
   783     cls.add_method('IsChecksumOk', 'bool', [], is_const=True)
       
   784     ## ipv4-header.h: static ns3::TypeId ns3::Ipv4Header::GetTypeId() [member function]
       
   785     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
       
   786     ## ipv4-header.h: ns3::TypeId ns3::Ipv4Header::GetInstanceTypeId() const [member function]
       
   787     cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True)
       
   788     ## ipv4-header.h: void ns3::Ipv4Header::Print(std::ostream & os) const [member function]
       
   789     cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True)
       
   790     ## ipv4-header.h: uint32_t ns3::Ipv4Header::GetSerializedSize() const [member function]
       
   791     cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True)
       
   792     ## ipv4-header.h: void ns3::Ipv4Header::Serialize(ns3::Buffer::Iterator start) const [member function]
       
   793     cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_const=True, is_virtual=True)
       
   794     ## ipv4-header.h: uint32_t ns3::Ipv4Header::Deserialize(ns3::Buffer::Iterator start) [member function]
       
   795     cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_virtual=True)
       
   796     return
       
   797 
       
   798 def register_Ns3UdpSocket_methods(root_module, cls):
       
   799     ## udp-socket.h: static ns3::TypeId ns3::UdpSocket::GetTypeId() [member function]
       
   800     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
       
   801     ## udp-socket.h: ns3::UdpSocket::UdpSocket() [constructor]
       
   802     cls.add_constructor([], visibility='public')
       
   803     ## udp-socket.h: ns3::Socket::SocketErrno ns3::UdpSocket::GetErrno() const [member function]
       
   804     cls.add_method('GetErrno', 'ns3::Socket::SocketErrno', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   805     ## udp-socket.h: ns3::Ptr<ns3::Node> ns3::UdpSocket::GetNode() const [member function]
       
   806     cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   807     ## udp-socket.h: int ns3::UdpSocket::Bind() [member function]
       
   808     cls.add_method('Bind', 'int', [], is_pure_virtual=True, is_virtual=True)
       
   809     ## udp-socket.h: int ns3::UdpSocket::Close() [member function]
       
   810     cls.add_method('Close', 'int', [], is_pure_virtual=True, is_virtual=True)
       
   811     ## udp-socket.h: int ns3::UdpSocket::ShutdownSend() [member function]
       
   812     cls.add_method('ShutdownSend', 'int', [], is_pure_virtual=True, is_virtual=True)
       
   813     ## udp-socket.h: int ns3::UdpSocket::ShutdownRecv() [member function]
       
   814     cls.add_method('ShutdownRecv', 'int', [], is_pure_virtual=True, is_virtual=True)
       
   815     ## udp-socket.h: int ns3::UdpSocket::Connect(ns3::Address const & address) [member function]
       
   816     cls.add_method('Connect', 'int', [param('ns3::Address&', 'address', is_const=True)], is_pure_virtual=True, is_virtual=True)
       
   817     ## udp-socket.h: uint32_t ns3::UdpSocket::GetTxAvailable() const [member function]
       
   818     cls.add_method('GetTxAvailable', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   819     ## udp-socket.h: int ns3::UdpSocket::Send(ns3::Ptr<ns3::Packet> p, uint32_t flags) [member function]
       
   820     cls.add_method('Send', 'int', [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags')], is_pure_virtual=True, is_virtual=True)
       
   821     ## udp-socket.h: int ns3::UdpSocket::SendTo(ns3::Ptr<ns3::Packet> p, uint32_t flags, ns3::Address const & toAddress) [member function]
       
   822     cls.add_method('SendTo', 'int', [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags'), param('ns3::Address&', 'toAddress', is_const=True)], is_pure_virtual=True, is_virtual=True)
       
   823     ## udp-socket.h: uint32_t ns3::UdpSocket::GetRxAvailable() const [member function]
       
   824     cls.add_method('GetRxAvailable', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   825     ## udp-socket.h: ns3::Ptr<ns3::Packet> ns3::UdpSocket::Recv(uint32_t maxSize, uint32_t flags) [member function]
       
   826     cls.add_method('Recv', 'ns3::Ptr< ns3::Packet >', [param('uint32_t', 'maxSize'), param('uint32_t', 'flags')], is_pure_virtual=True, is_virtual=True)
       
   827     ## udp-socket.h: ns3::Ptr<ns3::Packet> ns3::UdpSocket::RecvFrom(uint32_t maxSize, uint32_t flags, ns3::Address & fromAddress) [member function]
       
   828     cls.add_method('RecvFrom', 'ns3::Ptr< ns3::Packet >', [param('uint32_t', 'maxSize'), param('uint32_t', 'flags'), param('ns3::Address&', 'fromAddress')], is_pure_virtual=True, is_virtual=True)
       
   829     ## udp-socket.h: void ns3::UdpSocket::SetRcvBufSize(uint32_t size) [member function]
       
   830     cls.add_method('SetRcvBufSize', 'void', [param('uint32_t', 'size')], is_pure_virtual=True, visibility='private', is_virtual=True)
       
   831     ## udp-socket.h: uint32_t ns3::UdpSocket::GetRcvBufSize() const [member function]
       
   832     cls.add_method('GetRcvBufSize', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
   833     ## udp-socket.h: void ns3::UdpSocket::SetIpTtl(uint32_t ipTtl) [member function]
       
   834     cls.add_method('SetIpTtl', 'void', [param('uint32_t', 'ipTtl')], is_pure_virtual=True, visibility='private', is_virtual=True)
       
   835     ## udp-socket.h: uint32_t ns3::UdpSocket::GetIpTtl() const [member function]
       
   836     cls.add_method('GetIpTtl', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
   837     ## udp-socket.h: void ns3::UdpSocket::SetIpMulticastTtl(uint32_t ipTtl) [member function]
       
   838     cls.add_method('SetIpMulticastTtl', 'void', [param('uint32_t', 'ipTtl')], is_pure_virtual=True, visibility='private', is_virtual=True)
       
   839     ## udp-socket.h: uint32_t ns3::UdpSocket::GetIpMulticastTtl() const [member function]
       
   840     cls.add_method('GetIpMulticastTtl', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
   841     return
       
   842 
       
   843 def register_Ns3NetDevice_methods(root_module, cls):
       
   844     ## net-device.h: static ns3::TypeId ns3::NetDevice::GetTypeId() [member function]
       
   845     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
       
   846     ## net-device.h: void ns3::NetDevice::SetName(std::string const name) [member function]
       
   847     cls.add_method('SetName', 'void', [param('std::string', 'name', is_const=True)], is_pure_virtual=True, is_virtual=True)
       
   848     ## net-device.h: std::string ns3::NetDevice::GetName() const [member function]
       
   849     cls.add_method('GetName', 'std::string', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   850     ## net-device.h: void ns3::NetDevice::SetIfIndex(uint32_t const index) [member function]
       
   851     cls.add_method('SetIfIndex', 'void', [param('uint32_t', 'index', is_const=True)], is_pure_virtual=True, is_virtual=True)
       
   852     ## net-device.h: uint32_t ns3::NetDevice::GetIfIndex() const [member function]
       
   853     cls.add_method('GetIfIndex', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   854     ## net-device.h: ns3::Ptr<ns3::Channel> ns3::NetDevice::GetChannel() const [member function]
       
   855     cls.add_method('GetChannel', 'ns3::Ptr< ns3::Channel >', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   856     ## net-device.h: ns3::Address ns3::NetDevice::GetAddress() const [member function]
       
   857     cls.add_method('GetAddress', 'ns3::Address', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   858     ## net-device.h: bool ns3::NetDevice::SetMtu(uint16_t const mtu) [member function]
       
   859     cls.add_method('SetMtu', 'bool', [param('uint16_t', 'mtu', is_const=True)], is_pure_virtual=True, is_virtual=True)
       
   860     ## net-device.h: uint16_t ns3::NetDevice::GetMtu() const [member function]
       
   861     cls.add_method('GetMtu', 'uint16_t', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   862     ## net-device.h: bool ns3::NetDevice::IsLinkUp() const [member function]
       
   863     cls.add_method('IsLinkUp', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   864     ## 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]
       
   865     cls.add_method('SetLinkChangeCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')], is_pure_virtual=True, is_virtual=True)
       
   866     ## net-device.h: bool ns3::NetDevice::IsBroadcast() const [member function]
       
   867     cls.add_method('IsBroadcast', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   868     ## net-device.h: ns3::Address ns3::NetDevice::GetBroadcast() const [member function]
       
   869     cls.add_method('GetBroadcast', 'ns3::Address', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   870     ## net-device.h: bool ns3::NetDevice::IsMulticast() const [member function]
       
   871     cls.add_method('IsMulticast', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   872     ## net-device.h: ns3::Address ns3::NetDevice::GetMulticast() const [member function]
       
   873     cls.add_method('GetMulticast', 'ns3::Address', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   874     ## net-device.h: ns3::Address ns3::NetDevice::MakeMulticastAddress(ns3::Ipv4Address multicastGroup) const [member function]
       
   875     cls.add_method('MakeMulticastAddress', 'ns3::Address', [param('ns3::Ipv4Address', 'multicastGroup')], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   876     ## net-device.h: bool ns3::NetDevice::IsPointToPoint() const [member function]
       
   877     cls.add_method('IsPointToPoint', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   878     ## net-device.h: bool ns3::NetDevice::Send(ns3::Ptr<ns3::Packet> packet, ns3::Address const & dest, uint16_t protocolNumber) [member function]
       
   879     cls.add_method('Send', 'bool', [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address&', 'dest', is_const=True), param('uint16_t', 'protocolNumber')], is_pure_virtual=True, is_virtual=True)
       
   880     ## net-device.h: ns3::Ptr<ns3::Node> ns3::NetDevice::GetNode() const [member function]
       
   881     cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   882     ## net-device.h: void ns3::NetDevice::SetNode(ns3::Ptr<ns3::Node> node) [member function]
       
   883     cls.add_method('SetNode', 'void', [param('ns3::Ptr< ns3::Node >', 'node')], is_pure_virtual=True, is_virtual=True)
       
   884     ## net-device.h: bool ns3::NetDevice::NeedsArp() const [member function]
       
   885     cls.add_method('NeedsArp', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   886     ## net-device.h: void ns3::NetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function]
       
   887     cls.add_method('SetReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], is_pure_virtual=True, is_virtual=True)
       
   888     cls.add_constructor([])
       
   889     return
       
   890 
       
   891 def register_Ns3Channel_methods(root_module, cls):
       
   892     ## channel.h: static ns3::TypeId ns3::Channel::GetTypeId() [member function]
       
   893     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
       
   894     ## channel.h: ns3::Channel::Channel() [constructor]
       
   895     cls.add_constructor([], visibility='public')
       
   896     ## channel.h: ns3::Channel::Channel(std::string name) [constructor]
       
   897     cls.add_constructor([param('std::string', 'name')], visibility='public')
       
   898     ## channel.h: void ns3::Channel::SetName(std::string arg0) [member function]
       
   899     cls.add_method('SetName', 'void', [param('std::string', 'arg0')])
       
   900     ## channel.h: std::string ns3::Channel::GetName() [member function]
       
   901     cls.add_method('GetName', 'std::string', [])
       
   902     ## channel.h: uint32_t ns3::Channel::GetNDevices() const [member function]
       
   903     cls.add_method('GetNDevices', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   904     ## channel.h: ns3::Ptr<ns3::NetDevice> ns3::Channel::GetDevice(uint32_t i) const [member function]
       
   905     cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', [param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   906     return
       
   907 
       
   908 def register_Ns3SimpleChannel_methods(root_module, cls):
       
   909     ## simple-channel.h: static ns3::TypeId ns3::SimpleChannel::GetTypeId() [member function]
       
   910     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
       
   911     ## simple-channel.h: ns3::SimpleChannel::SimpleChannel() [constructor]
       
   912     cls.add_constructor([], visibility='public')
       
   913     ## simple-channel.h: void ns3::SimpleChannel::Send(ns3::Ptr<ns3::Packet> p, uint16_t protocol, ns3::Mac48Address to, ns3::Mac48Address from, ns3::Ptr<ns3::SimpleNetDevice> sender) [member function]
       
   914     cls.add_method('Send', 'void', [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from'), param('ns3::Ptr< ns3::SimpleNetDevice >', 'sender')])
       
   915     ## simple-channel.h: void ns3::SimpleChannel::Add(ns3::Ptr<ns3::SimpleNetDevice> device) [member function]
       
   916     cls.add_method('Add', 'void', [param('ns3::Ptr< ns3::SimpleNetDevice >', 'device')])
       
   917     ## simple-channel.h: uint32_t ns3::SimpleChannel::GetNDevices() const [member function]
       
   918     cls.add_method('GetNDevices', 'uint32_t', [], is_const=True, is_virtual=True)
       
   919     ## simple-channel.h: ns3::Ptr<ns3::NetDevice> ns3::SimpleChannel::GetDevice(uint32_t i) const [member function]
       
   920     cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', [param('uint32_t', 'i')], is_const=True, is_virtual=True)
       
   921     return
       
   922 
       
   923 def register_Ns3AddressValue_methods(root_module, cls):
       
   924     ## address.h: ns3::AddressValue::AddressValue() [constructor]
       
   925     cls.add_constructor([], visibility='public')
       
   926     ## address.h: ns3::AddressValue::AddressValue(ns3::Address const & value) [constructor]
       
   927     cls.add_constructor([param('ns3::Address&', 'value', is_const=True)], visibility='public')
       
   928     ## address.h: void ns3::AddressValue::Set(ns3::Address const & value) [member function]
       
   929     cls.add_method('Set', 'void', [param('ns3::Address&', 'value', is_const=True)])
       
   930     ## address.h: ns3::Address ns3::AddressValue::Get() const [member function]
       
   931     cls.add_method('Get', 'ns3::Address', [], is_const=True)
       
   932     ## address.h: ns3::Ptr<ns3::AttributeValue> ns3::AddressValue::Copy() const [member function]
       
   933     cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
       
   934     ## address.h: std::string ns3::AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
   935     cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)
       
   936     ## address.h: bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
   937     cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)
       
   938     return
       
   939 
       
   940 def register_Ns3Node_methods(root_module, cls):
       
   941     ## node.h: static ns3::TypeId ns3::Node::GetTypeId() [member function]
       
   942     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
       
   943     ## node.h: ns3::Node::Node() [constructor]
       
   944     cls.add_constructor([], visibility='public')
       
   945     ## node.h: ns3::Node::Node(uint32_t systemId) [constructor]
       
   946     cls.add_constructor([param('uint32_t', 'systemId')], visibility='public')
       
   947     ## node.h: uint32_t ns3::Node::GetId() const [member function]
       
   948     cls.add_method('GetId', 'uint32_t', [], is_const=True)
       
   949     ## node.h: uint32_t ns3::Node::GetSystemId() const [member function]
       
   950     cls.add_method('GetSystemId', 'uint32_t', [], is_const=True)
       
   951     ## node.h: uint32_t ns3::Node::AddDevice(ns3::Ptr<ns3::NetDevice> device) [member function]
       
   952     cls.add_method('AddDevice', 'uint32_t', [param('ns3::Ptr< ns3::NetDevice >', 'device')])
       
   953     ## node.h: ns3::Ptr<ns3::NetDevice> ns3::Node::GetDevice(uint32_t index) const [member function]
       
   954     cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', [param('uint32_t', 'index')], is_const=True)
       
   955     ## node.h: uint32_t ns3::Node::GetNDevices() const [member function]
       
   956     cls.add_method('GetNDevices', 'uint32_t', [], is_const=True)
       
   957     ## node.h: uint32_t ns3::Node::AddApplication(ns3::Ptr<ns3::Application> application) [member function]
       
   958     cls.add_method('AddApplication', 'uint32_t', [param('ns3::Ptr< ns3::Application >', 'application')])
       
   959     ## node.h: ns3::Ptr<ns3::Application> ns3::Node::GetApplication(uint32_t index) const [member function]
       
   960     cls.add_method('GetApplication', 'ns3::Ptr< ns3::Application >', [param('uint32_t', 'index')], is_const=True)
       
   961     ## node.h: ns3::Ptr<ns3::Application> ns3::Node::GetFirstApplication(ns3::TypeId tid) [member function]
       
   962     cls.add_method('GetFirstApplication', 'ns3::Ptr< ns3::Application >', [param('ns3::TypeId', 'tid')])
       
   963     ## node.h: uint32_t ns3::Node::GetNApplications() const [member function]
       
   964     cls.add_method('GetNApplications', 'uint32_t', [], is_const=True)
       
   965     ## node.h: void ns3::Node::RegisterProtocolHandler(ns3::Callback<void, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> handler, uint16_t protocolType, ns3::Ptr<ns3::NetDevice> device) [member function]
       
   966     cls.add_method('RegisterProtocolHandler', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'handler'), param('uint16_t', 'protocolType'), param('ns3::Ptr< ns3::NetDevice >', 'device')])
       
   967     ## node.h: void ns3::Node::UnregisterProtocolHandler(ns3::Callback<void, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> handler) [member function]
       
   968     cls.add_method('UnregisterProtocolHandler', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'handler')])
       
   969     ## node.h: void ns3::Node::DoDispose() [member function]
       
   970     cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True)
       
   971     ## node.h: void ns3::Node::NotifyDeviceAdded(ns3::Ptr<ns3::NetDevice> device) [member function]
       
   972     cls.add_method('NotifyDeviceAdded', 'void', [param('ns3::Ptr< ns3::NetDevice >', 'device')], visibility='private', is_virtual=True)
       
   973     return
       
   974 
       
   975 def register_Ns3TcpSocket_methods(root_module, cls):
       
   976     ## tcp-socket.h: static ns3::TypeId ns3::TcpSocket::GetTypeId() [member function]
       
   977     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
       
   978     ## tcp-socket.h: ns3::TcpSocket::TcpSocket() [constructor]
       
   979     cls.add_constructor([], visibility='public')
       
   980     ## tcp-socket.h: ns3::Socket::SocketErrno ns3::TcpSocket::GetErrno() const [member function]
       
   981     cls.add_method('GetErrno', 'ns3::Socket::SocketErrno', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   982     ## tcp-socket.h: ns3::Ptr<ns3::Node> ns3::TcpSocket::GetNode() const [member function]
       
   983     cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   984     ## tcp-socket.h: int ns3::TcpSocket::Bind() [member function]
       
   985     cls.add_method('Bind', 'int', [], is_pure_virtual=True, is_virtual=True)
       
   986     ## tcp-socket.h: int ns3::TcpSocket::Close() [member function]
       
   987     cls.add_method('Close', 'int', [], is_pure_virtual=True, is_virtual=True)
       
   988     ## tcp-socket.h: int ns3::TcpSocket::ShutdownSend() [member function]
       
   989     cls.add_method('ShutdownSend', 'int', [], is_pure_virtual=True, is_virtual=True)
       
   990     ## tcp-socket.h: int ns3::TcpSocket::ShutdownRecv() [member function]
       
   991     cls.add_method('ShutdownRecv', 'int', [], is_pure_virtual=True, is_virtual=True)
       
   992     ## tcp-socket.h: int ns3::TcpSocket::Connect(ns3::Address const & address) [member function]
       
   993     cls.add_method('Connect', 'int', [param('ns3::Address&', 'address', is_const=True)], is_pure_virtual=True, is_virtual=True)
       
   994     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetTxAvailable() const [member function]
       
   995     cls.add_method('GetTxAvailable', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
   996     ## tcp-socket.h: int ns3::TcpSocket::Send(ns3::Ptr<ns3::Packet> p, uint32_t flags) [member function]
       
   997     cls.add_method('Send', 'int', [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags')], is_pure_virtual=True, is_virtual=True)
       
   998     ## tcp-socket.h: int ns3::TcpSocket::SendTo(ns3::Ptr<ns3::Packet> p, uint32_t flags, ns3::Address const & toAddress) [member function]
       
   999     cls.add_method('SendTo', 'int', [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags'), param('ns3::Address&', 'toAddress', is_const=True)], is_pure_virtual=True, is_virtual=True)
       
  1000     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetRxAvailable() const [member function]
       
  1001     cls.add_method('GetRxAvailable', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1002     ## tcp-socket.h: ns3::Ptr<ns3::Packet> ns3::TcpSocket::Recv(uint32_t maxSize, uint32_t flags) [member function]
       
  1003     cls.add_method('Recv', 'ns3::Ptr< ns3::Packet >', [param('uint32_t', 'maxSize'), param('uint32_t', 'flags')], is_pure_virtual=True, is_virtual=True)
       
  1004     ## tcp-socket.h: ns3::Ptr<ns3::Packet> ns3::TcpSocket::RecvFrom(uint32_t maxSize, uint32_t flags, ns3::Address & fromAddress) [member function]
       
  1005     cls.add_method('RecvFrom', 'ns3::Ptr< ns3::Packet >', [param('uint32_t', 'maxSize'), param('uint32_t', 'flags'), param('ns3::Address&', 'fromAddress')], is_pure_virtual=True, is_virtual=True)
       
  1006     ## tcp-socket.h: void ns3::TcpSocket::SetSndBufSize(uint32_t size) [member function]
       
  1007     cls.add_method('SetSndBufSize', 'void', [param('uint32_t', 'size')], is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1008     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSndBufSize() const [member function]
       
  1009     cls.add_method('GetSndBufSize', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1010     ## tcp-socket.h: void ns3::TcpSocket::SetRcvBufSize(uint32_t size) [member function]
       
  1011     cls.add_method('SetRcvBufSize', 'void', [param('uint32_t', 'size')], is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1012     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetRcvBufSize() const [member function]
       
  1013     cls.add_method('GetRcvBufSize', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1014     ## tcp-socket.h: void ns3::TcpSocket::SetSegSize(uint32_t size) [member function]
       
  1015     cls.add_method('SetSegSize', 'void', [param('uint32_t', 'size')], is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1016     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSegSize() const [member function]
       
  1017     cls.add_method('GetSegSize', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1018     ## tcp-socket.h: void ns3::TcpSocket::SetAdvWin(uint32_t window) [member function]
       
  1019     cls.add_method('SetAdvWin', 'void', [param('uint32_t', 'window')], is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1020     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetAdvWin() const [member function]
       
  1021     cls.add_method('GetAdvWin', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1022     ## tcp-socket.h: void ns3::TcpSocket::SetSSThresh(uint32_t threshold) [member function]
       
  1023     cls.add_method('SetSSThresh', 'void', [param('uint32_t', 'threshold')], is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1024     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSSThresh() const [member function]
       
  1025     cls.add_method('GetSSThresh', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1026     ## tcp-socket.h: void ns3::TcpSocket::SetInitialCwnd(uint32_t count) [member function]
       
  1027     cls.add_method('SetInitialCwnd', 'void', [param('uint32_t', 'count')], is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1028     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetInitialCwnd() const [member function]
       
  1029     cls.add_method('GetInitialCwnd', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1030     ## tcp-socket.h: void ns3::TcpSocket::SetConnTimeout(ns3::Time timeout) [member function]
       
  1031     cls.add_method('SetConnTimeout', 'void', [param('ns3::Time', 'timeout')], is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1032     ## tcp-socket.h: ns3::Time ns3::TcpSocket::GetConnTimeout() const [member function]
       
  1033     cls.add_method('GetConnTimeout', 'ns3::Time', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1034     ## tcp-socket.h: void ns3::TcpSocket::SetConnCount(uint32_t count) [member function]
       
  1035     cls.add_method('SetConnCount', 'void', [param('uint32_t', 'count')], is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1036     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetConnCount() const [member function]
       
  1037     cls.add_method('GetConnCount', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1038     ## tcp-socket.h: void ns3::TcpSocket::SetDelAckTimeout(ns3::Time timeout) [member function]
       
  1039     cls.add_method('SetDelAckTimeout', 'void', [param('ns3::Time', 'timeout')], is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1040     ## tcp-socket.h: ns3::Time ns3::TcpSocket::GetDelAckTimeout() const [member function]
       
  1041     cls.add_method('GetDelAckTimeout', 'ns3::Time', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1042     ## tcp-socket.h: void ns3::TcpSocket::SetDelAckMaxCount(uint32_t count) [member function]
       
  1043     cls.add_method('SetDelAckMaxCount', 'void', [param('uint32_t', 'count')], is_pure_virtual=True, visibility='private', is_virtual=True)
       
  1044     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetDelAckMaxCount() const [member function]
       
  1045     cls.add_method('GetDelAckMaxCount', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1046     return
       
  1047 
       
  1048 def register_Ns3EthernetHeader_methods(root_module, cls):
       
  1049     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader(bool hasPreamble) [constructor]
       
  1050     cls.add_constructor([param('bool', 'hasPreamble')], visibility='public')
       
  1051     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader() [constructor]
       
  1052     cls.add_constructor([], visibility='public')
       
  1053     ## ethernet-header.h: void ns3::EthernetHeader::SetLengthType(uint16_t size) [member function]
       
  1054     cls.add_method('SetLengthType', 'void', [param('uint16_t', 'size')])
       
  1055     ## ethernet-header.h: void ns3::EthernetHeader::SetSource(ns3::Mac48Address source) [member function]
       
  1056     cls.add_method('SetSource', 'void', [param('ns3::Mac48Address', 'source')])
       
  1057     ## ethernet-header.h: void ns3::EthernetHeader::SetDestination(ns3::Mac48Address destination) [member function]
       
  1058     cls.add_method('SetDestination', 'void', [param('ns3::Mac48Address', 'destination')])
       
  1059     ## ethernet-header.h: void ns3::EthernetHeader::SetPreambleSfd(uint64_t preambleSfd) [member function]
       
  1060     cls.add_method('SetPreambleSfd', 'void', [param('uint64_t', 'preambleSfd')])
       
  1061     ## ethernet-header.h: uint16_t ns3::EthernetHeader::GetLengthType() const [member function]
       
  1062     cls.add_method('GetLengthType', 'uint16_t', [], is_const=True)
       
  1063     ## ethernet-header.h: ns3::ethernet_header_t ns3::EthernetHeader::GetPacketType() const [member function]
       
  1064     cls.add_method('GetPacketType', 'ns3::ethernet_header_t', [], is_const=True)
       
  1065     ## ethernet-header.h: ns3::Mac48Address ns3::EthernetHeader::GetSource() const [member function]
       
  1066     cls.add_method('GetSource', 'ns3::Mac48Address', [], is_const=True)
       
  1067     ## ethernet-header.h: ns3::Mac48Address ns3::EthernetHeader::GetDestination() const [member function]
       
  1068     cls.add_method('GetDestination', 'ns3::Mac48Address', [], is_const=True)
       
  1069     ## ethernet-header.h: uint64_t ns3::EthernetHeader::GetPreambleSfd() const [member function]
       
  1070     cls.add_method('GetPreambleSfd', 'uint64_t', [], is_const=True)
       
  1071     ## ethernet-header.h: uint32_t ns3::EthernetHeader::GetHeaderSize() const [member function]
       
  1072     cls.add_method('GetHeaderSize', 'uint32_t', [], is_const=True)
       
  1073     ## ethernet-header.h: static ns3::TypeId ns3::EthernetHeader::GetTypeId() [member function]
       
  1074     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
       
  1075     ## ethernet-header.h: ns3::TypeId ns3::EthernetHeader::GetInstanceTypeId() const [member function]
       
  1076     cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True)
       
  1077     ## ethernet-header.h: void ns3::EthernetHeader::Print(std::ostream & os) const [member function]
       
  1078     cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True)
       
  1079     ## ethernet-header.h: uint32_t ns3::EthernetHeader::GetSerializedSize() const [member function]
       
  1080     cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True)
       
  1081     ## ethernet-header.h: void ns3::EthernetHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
       
  1082     cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_const=True, is_virtual=True)
       
  1083     ## ethernet-header.h: uint32_t ns3::EthernetHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
       
  1084     cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_virtual=True)
       
  1085     return
       
  1086 
       
  1087 def register_Ns3SocketIpTtlTag_methods(root_module, cls):
       
  1088     ## socket.h: ns3::SocketIpTtlTag::SocketIpTtlTag() [constructor]
       
  1089     cls.add_constructor([], visibility='public')
       
  1090     ## socket.h: void ns3::SocketIpTtlTag::SetTtl(uint8_t ttl) [member function]
       
  1091     cls.add_method('SetTtl', 'void', [param('uint8_t', 'ttl')])
       
  1092     ## socket.h: uint8_t ns3::SocketIpTtlTag::GetTtl() const [member function]
       
  1093     cls.add_method('GetTtl', 'uint8_t', [], is_const=True)
       
  1094     ## socket.h: static ns3::TypeId ns3::SocketIpTtlTag::GetTypeId() [member function]
       
  1095     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
       
  1096     ## socket.h: ns3::TypeId ns3::SocketIpTtlTag::GetInstanceTypeId() const [member function]
       
  1097     cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True)
       
  1098     ## socket.h: uint32_t ns3::SocketIpTtlTag::GetSerializedSize() const [member function]
       
  1099     cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True)
       
  1100     ## socket.h: void ns3::SocketIpTtlTag::Serialize(ns3::TagBuffer i) const [member function]
       
  1101     cls.add_method('Serialize', 'void', [param('ns3::TagBuffer', 'i')], is_const=True, is_virtual=True)
       
  1102     ## socket.h: void ns3::SocketIpTtlTag::Deserialize(ns3::TagBuffer i) [member function]
       
  1103     cls.add_method('Deserialize', 'void', [param('ns3::TagBuffer', 'i')], is_virtual=True)
       
  1104     ## socket.h: void ns3::SocketIpTtlTag::Print(std::ostream & os) const [member function]
       
  1105     cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True)
       
  1106     return
       
  1107 
       
  1108 def register_Ns3Ipv4_methods(root_module, cls):
       
  1109     ## ipv4.h: static ns3::TypeId ns3::Ipv4::GetTypeId() [member function]
       
  1110     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
       
  1111     ## ipv4.h: ns3::Ipv4::Ipv4() [constructor]
       
  1112     cls.add_constructor([], visibility='public')
       
  1113     ## ipv4.h: void ns3::Ipv4::AddRoutingProtocol(ns3::Ptr<ns3::Ipv4RoutingProtocol> routingProtocol, int16_t priority) [member function]
       
  1114     cls.add_method('AddRoutingProtocol', 'void', [param('ns3::Ptr< ns3::Ipv4RoutingProtocol >', 'routingProtocol'), param('int16_t', 'priority')], is_pure_virtual=True, is_virtual=True)
       
  1115     ## ipv4.h: void ns3::Ipv4::AddHostRouteTo(ns3::Ipv4Address dest, ns3::Ipv4Address nextHop, uint32_t interface) [member function]
       
  1116     cls.add_method('AddHostRouteTo', 'void', [param('ns3::Ipv4Address', 'dest'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_pure_virtual=True, is_virtual=True)
       
  1117     ## ipv4.h: void ns3::Ipv4::AddHostRouteTo(ns3::Ipv4Address dest, uint32_t interface) [member function]
       
  1118     cls.add_method('AddHostRouteTo', 'void', [param('ns3::Ipv4Address', 'dest'), param('uint32_t', 'interface')], is_pure_virtual=True, is_virtual=True)
       
  1119     ## ipv4.h: void ns3::Ipv4::AddNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, ns3::Ipv4Address nextHop, uint32_t interface) [member function]
       
  1120     cls.add_method('AddNetworkRouteTo', 'void', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_pure_virtual=True, is_virtual=True)
       
  1121     ## ipv4.h: void ns3::Ipv4::AddNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, uint32_t interface) [member function]
       
  1122     cls.add_method('AddNetworkRouteTo', 'void', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('uint32_t', 'interface')], is_pure_virtual=True, is_virtual=True)
       
  1123     ## ipv4.h: void ns3::Ipv4::SetDefaultRoute(ns3::Ipv4Address nextHop, uint32_t interface) [member function]
       
  1124     cls.add_method('SetDefaultRoute', 'void', [param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_pure_virtual=True, is_virtual=True)
       
  1125     ## ipv4.h: uint32_t ns3::Ipv4::GetNRoutes() [member function]
       
  1126     cls.add_method('GetNRoutes', 'uint32_t', [], is_pure_virtual=True, is_virtual=True)
       
  1127     ## ipv4.h: ns3::Ipv4Route ns3::Ipv4::GetRoute(uint32_t i) [member function]
       
  1128     cls.add_method('GetRoute', 'ns3::Ipv4Route', [param('uint32_t', 'i')], is_pure_virtual=True, is_virtual=True)
       
  1129     ## ipv4.h: void ns3::Ipv4::RemoveRoute(uint32_t i) [member function]
       
  1130     cls.add_method('RemoveRoute', 'void', [param('uint32_t', 'i')], is_pure_virtual=True, is_virtual=True)
       
  1131     ## ipv4.h: void ns3::Ipv4::AddMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface, std::vector<unsigned int, std::allocator<unsigned int> > outputInterfaces) [member function]
       
  1132     cls.add_method('AddMulticastRoute', 'void', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int, std::allocator< unsigned int > >', 'outputInterfaces')], is_pure_virtual=True, is_virtual=True)
       
  1133     ## ipv4.h: void ns3::Ipv4::RemoveMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface) [member function]
       
  1134     cls.add_method('RemoveMulticastRoute', 'void', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface')], is_pure_virtual=True, is_virtual=True)
       
  1135     ## ipv4.h: void ns3::Ipv4::SetDefaultMulticastRoute(uint32_t outputInterface) [member function]
       
  1136     cls.add_method('SetDefaultMulticastRoute', 'void', [param('uint32_t', 'outputInterface')], is_pure_virtual=True, is_virtual=True)
       
  1137     ## ipv4.h: uint32_t ns3::Ipv4::GetNMulticastRoutes() const [member function]
       
  1138     cls.add_method('GetNMulticastRoutes', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1139     ## ipv4.h: ns3::Ipv4MulticastRoute ns3::Ipv4::GetMulticastRoute(uint32_t i) const [member function]
       
  1140     cls.add_method('GetMulticastRoute', 'ns3::Ipv4MulticastRoute', [param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1141     ## ipv4.h: void ns3::Ipv4::RemoveMulticastRoute(uint32_t i) [member function]
       
  1142     cls.add_method('RemoveMulticastRoute', 'void', [param('uint32_t', 'i')], is_pure_virtual=True, is_virtual=True)
       
  1143     ## ipv4.h: uint32_t ns3::Ipv4::AddInterface(ns3::Ptr<ns3::NetDevice> device) [member function]
       
  1144     cls.add_method('AddInterface', 'uint32_t', [param('ns3::Ptr< ns3::NetDevice >', 'device')], is_pure_virtual=True, is_virtual=True)
       
  1145     ## ipv4.h: uint32_t ns3::Ipv4::GetNInterfaces() [member function]
       
  1146     cls.add_method('GetNInterfaces', 'uint32_t', [], is_pure_virtual=True, is_virtual=True)
       
  1147     ## ipv4.h: uint32_t ns3::Ipv4::FindInterfaceForAddr(ns3::Ipv4Address addr) const [member function]
       
  1148     cls.add_method('FindInterfaceForAddr', 'uint32_t', [param('ns3::Ipv4Address', 'addr')], is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1149     ## ipv4.h: uint32_t ns3::Ipv4::FindInterfaceForAddr(ns3::Ipv4Address addr, ns3::Ipv4Mask mask) const [member function]
       
  1150     cls.add_method('FindInterfaceForAddr', 'uint32_t', [param('ns3::Ipv4Address', 'addr'), param('ns3::Ipv4Mask', 'mask')], is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1151     ## ipv4.h: int32_t ns3::Ipv4::FindInterfaceForDevice(ns3::Ptr<ns3::NetDevice> nd) const [member function]
       
  1152     cls.add_method('FindInterfaceForDevice', 'int32_t', [param('ns3::Ptr< ns3::NetDevice >', 'nd')], is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1153     ## ipv4.h: ns3::Ptr<ns3::NetDevice> ns3::Ipv4::GetNetDevice(uint32_t i) [member function]
       
  1154     cls.add_method('GetNetDevice', 'ns3::Ptr< ns3::NetDevice >', [param('uint32_t', 'i')], is_pure_virtual=True, is_virtual=True)
       
  1155     ## ipv4.h: void ns3::Ipv4::JoinMulticastGroup(ns3::Ipv4Address origin, ns3::Ipv4Address group) [member function]
       
  1156     cls.add_method('JoinMulticastGroup', 'void', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group')], is_pure_virtual=True, is_virtual=True)
       
  1157     ## ipv4.h: void ns3::Ipv4::LeaveMulticastGroup(ns3::Ipv4Address origin, ns3::Ipv4Address group) [member function]
       
  1158     cls.add_method('LeaveMulticastGroup', 'void', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group')], is_pure_virtual=True, is_virtual=True)
       
  1159     ## ipv4.h: void ns3::Ipv4::SetAddress(uint32_t i, ns3::Ipv4Address address) [member function]
       
  1160     cls.add_method('SetAddress', 'void', [param('uint32_t', 'i'), param('ns3::Ipv4Address', 'address')], is_pure_virtual=True, is_virtual=True)
       
  1161     ## ipv4.h: void ns3::Ipv4::SetNetworkMask(uint32_t i, ns3::Ipv4Mask mask) [member function]
       
  1162     cls.add_method('SetNetworkMask', 'void', [param('uint32_t', 'i'), param('ns3::Ipv4Mask', 'mask')], is_pure_virtual=True, is_virtual=True)
       
  1163     ## ipv4.h: ns3::Ipv4Mask ns3::Ipv4::GetNetworkMask(uint32_t i) const [member function]
       
  1164     cls.add_method('GetNetworkMask', 'ns3::Ipv4Mask', [param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1165     ## ipv4.h: void ns3::Ipv4::SetMetric(uint32_t i, uint16_t metric) [member function]
       
  1166     cls.add_method('SetMetric', 'void', [param('uint32_t', 'i'), param('uint16_t', 'metric')], is_pure_virtual=True, is_virtual=True)
       
  1167     ## ipv4.h: uint16_t ns3::Ipv4::GetMetric(uint32_t i) const [member function]
       
  1168     cls.add_method('GetMetric', 'uint16_t', [param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1169     ## ipv4.h: ns3::Ipv4Address ns3::Ipv4::GetAddress(uint32_t i) const [member function]
       
  1170     cls.add_method('GetAddress', 'ns3::Ipv4Address', [param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1171     ## ipv4.h: ns3::Ipv4Address ns3::Ipv4::GetSourceAddress(ns3::Ipv4Address destination) const [member function]
       
  1172     cls.add_method('GetSourceAddress', 'ns3::Ipv4Address', [param('ns3::Ipv4Address', 'destination')], is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1173     ## ipv4.h: bool ns3::Ipv4::GetIfIndexForDestination(ns3::Ipv4Address dest, uint32_t & ifIndex) const [member function]
       
  1174     cls.add_method('GetIfIndexForDestination', 'bool', [param('ns3::Ipv4Address', 'dest'), param('uint32_t&', 'ifIndex')], is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1175     ## ipv4.h: uint16_t ns3::Ipv4::GetMtu(uint32_t i) const [member function]
       
  1176     cls.add_method('GetMtu', 'uint16_t', [param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1177     ## ipv4.h: bool ns3::Ipv4::IsUp(uint32_t i) const [member function]
       
  1178     cls.add_method('IsUp', 'bool', [param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1179     ## ipv4.h: void ns3::Ipv4::SetUp(uint32_t i) [member function]
       
  1180     cls.add_method('SetUp', 'void', [param('uint32_t', 'i')], is_pure_virtual=True, is_virtual=True)
       
  1181     ## ipv4.h: void ns3::Ipv4::SetDown(uint32_t i) [member function]
       
  1182     cls.add_method('SetDown', 'void', [param('uint32_t', 'i')], is_pure_virtual=True, is_virtual=True)
       
  1183     ## ipv4.h: uint32_t ns3::Ipv4::GetIfIndexByAddress(ns3::Ipv4Address addr, ns3::Ipv4Mask mask=ns3::Ipv4Mask(((const char*)"255.255.255.255"))) [member function]
       
  1184     cls.add_method('GetIfIndexByAddress', 'uint32_t', [param('ns3::Ipv4Address', 'addr'), param('ns3::Ipv4Mask', 'mask', default_value='ns3::Ipv4Mask(((const char*)"255.255.255.255"))')], is_virtual=True)
       
  1185     return
       
  1186 
       
  1187 def register_Ns3SocketFactory_methods(root_module, cls):
       
  1188     ## socket-factory.h: static ns3::TypeId ns3::SocketFactory::GetTypeId() [member function]
       
  1189     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
       
  1190     ## socket-factory.h: ns3::SocketFactory::SocketFactory() [constructor]
       
  1191     cls.add_constructor([], visibility='public')
       
  1192     ## socket-factory.h: ns3::Ptr<ns3::Socket> ns3::SocketFactory::CreateSocket() [member function]
       
  1193     cls.add_method('CreateSocket', 'ns3::Ptr< ns3::Socket >', [], is_pure_virtual=True, is_virtual=True)
       
  1194     return
       
  1195 
       
  1196 def register_Ns3DropTailQueue_methods(root_module, cls):
       
  1197     ## drop-tail-queue.h: static ns3::TypeId ns3::DropTailQueue::GetTypeId() [member function]
       
  1198     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
       
  1199     ## drop-tail-queue.h: ns3::DropTailQueue::DropTailQueue() [constructor]
       
  1200     cls.add_constructor([], visibility='public')
       
  1201     ## drop-tail-queue.h: bool ns3::DropTailQueue::DoEnqueue(ns3::Ptr<ns3::Packet> p) [member function]
       
  1202     cls.add_method('DoEnqueue', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')], visibility='private', is_virtual=True)
       
  1203     ## drop-tail-queue.h: ns3::Ptr<ns3::Packet> ns3::DropTailQueue::DoDequeue() [member function]
       
  1204     cls.add_method('DoDequeue', 'ns3::Ptr< ns3::Packet >', [], visibility='private', is_virtual=True)
       
  1205     ## drop-tail-queue.h: ns3::Ptr<ns3::Packet> ns3::DropTailQueue::DoPeek() const [member function]
       
  1206     cls.add_method('DoPeek', 'ns3::Ptr< ns3::Packet >', [], is_const=True, visibility='private', is_virtual=True)
       
  1207     return
       
  1208 
       
  1209 def register_Ns3EthernetTrailer_methods(root_module, cls):
       
  1210     ## ethernet-trailer.h: ns3::EthernetTrailer::EthernetTrailer() [constructor]
       
  1211     cls.add_constructor([], visibility='public')
       
  1212     ## ethernet-trailer.h: static void ns3::EthernetTrailer::EnableFcs(bool enable) [member function]
       
  1213     cls.add_method('EnableFcs', 'void', [param('bool', 'enable')], is_static=True)
       
  1214     ## ethernet-trailer.h: void ns3::EthernetTrailer::CalcFcs(ns3::Ptr<ns3::Packet> p) [member function]
       
  1215     cls.add_method('CalcFcs', 'void', [param('ns3::Ptr< ns3::Packet >', 'p')])
       
  1216     ## ethernet-trailer.h: void ns3::EthernetTrailer::SetFcs(uint32_t fcs) [member function]
       
  1217     cls.add_method('SetFcs', 'void', [param('uint32_t', 'fcs')])
       
  1218     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetFcs() [member function]
       
  1219     cls.add_method('GetFcs', 'uint32_t', [])
       
  1220     ## ethernet-trailer.h: bool ns3::EthernetTrailer::CheckFcs(ns3::Ptr<ns3::Packet> p) const [member function]
       
  1221     cls.add_method('CheckFcs', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')], is_const=True)
       
  1222     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetTrailerSize() const [member function]
       
  1223     cls.add_method('GetTrailerSize', 'uint32_t', [], is_const=True)
       
  1224     ## ethernet-trailer.h: static ns3::TypeId ns3::EthernetTrailer::GetTypeId() [member function]
       
  1225     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
       
  1226     ## ethernet-trailer.h: ns3::TypeId ns3::EthernetTrailer::GetInstanceTypeId() const [member function]
       
  1227     cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True)
       
  1228     ## ethernet-trailer.h: void ns3::EthernetTrailer::Print(std::ostream & os) const [member function]
       
  1229     cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True)
       
  1230     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetSerializedSize() const [member function]
       
  1231     cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True)
       
  1232     ## ethernet-trailer.h: void ns3::EthernetTrailer::Serialize(ns3::Buffer::Iterator end) const [member function]
       
  1233     cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'end')], is_const=True, is_virtual=True)
       
  1234     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::Deserialize(ns3::Buffer::Iterator end) [member function]
       
  1235     cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'end')], is_virtual=True)
       
  1236     return
       
  1237 
       
  1238 def register_Ns3LlcSnapHeader_methods(root_module, cls):
       
  1239     ## llc-snap-header.h: ns3::LlcSnapHeader::LlcSnapHeader() [constructor]
       
  1240     cls.add_constructor([], visibility='public')
       
  1241     ## llc-snap-header.h: void ns3::LlcSnapHeader::SetType(uint16_t type) [member function]
       
  1242     cls.add_method('SetType', 'void', [param('uint16_t', 'type')])
       
  1243     ## llc-snap-header.h: uint16_t ns3::LlcSnapHeader::GetType() [member function]
       
  1244     cls.add_method('GetType', 'uint16_t', [])
       
  1245     ## llc-snap-header.h: static ns3::TypeId ns3::LlcSnapHeader::GetTypeId() [member function]
       
  1246     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
       
  1247     ## llc-snap-header.h: ns3::TypeId ns3::LlcSnapHeader::GetInstanceTypeId() const [member function]
       
  1248     cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True)
       
  1249     ## llc-snap-header.h: void ns3::LlcSnapHeader::Print(std::ostream & os) const [member function]
       
  1250     cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True)
       
  1251     ## llc-snap-header.h: uint32_t ns3::LlcSnapHeader::GetSerializedSize() const [member function]
       
  1252     cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True)
       
  1253     ## llc-snap-header.h: void ns3::LlcSnapHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
       
  1254     cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_const=True, is_virtual=True)
       
  1255     ## llc-snap-header.h: uint32_t ns3::LlcSnapHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
       
  1256     cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_virtual=True)
       
  1257     return
       
  1258 
       
  1259 def register_Ns3UdpSocketFactory_methods(root_module, cls):
       
  1260     ## udp-socket-factory.h: static ns3::TypeId ns3::UdpSocketFactory::GetTypeId() [member function]
       
  1261     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
       
  1262     ## udp-socket-factory.h: ns3::Ptr<ns3::Socket> ns3::UdpSocketFactory::CreateSocket() [member function]
       
  1263     cls.add_method('CreateSocket', 'ns3::Ptr< ns3::Socket >', [], is_pure_virtual=True, is_virtual=True)
       
  1264     cls.add_constructor([])
       
  1265     return
       
  1266 
       
  1267 def register_Ns3SimpleNetDevice_methods(root_module, cls):
       
  1268     ## simple-net-device.h: static ns3::TypeId ns3::SimpleNetDevice::GetTypeId() [member function]
       
  1269     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
       
  1270     ## simple-net-device.h: ns3::SimpleNetDevice::SimpleNetDevice() [constructor]
       
  1271     cls.add_constructor([], visibility='public')
       
  1272     ## simple-net-device.h: void ns3::SimpleNetDevice::Receive(ns3::Ptr<ns3::Packet> packet, uint16_t protocol, ns3::Mac48Address to, ns3::Mac48Address from) [member function]
       
  1273     cls.add_method('Receive', 'void', [param('ns3::Ptr< ns3::Packet >', 'packet'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from')])
       
  1274     ## simple-net-device.h: void ns3::SimpleNetDevice::SetChannel(ns3::Ptr<ns3::SimpleChannel> channel) [member function]
       
  1275     cls.add_method('SetChannel', 'void', [param('ns3::Ptr< ns3::SimpleChannel >', 'channel')])
       
  1276     ## simple-net-device.h: void ns3::SimpleNetDevice::SetAddress(ns3::Mac48Address address) [member function]
       
  1277     cls.add_method('SetAddress', 'void', [param('ns3::Mac48Address', 'address')])
       
  1278     ## simple-net-device.h: void ns3::SimpleNetDevice::SetName(std::string const name) [member function]
       
  1279     cls.add_method('SetName', 'void', [param('std::string', 'name', is_const=True)], is_virtual=True)
       
  1280     ## simple-net-device.h: std::string ns3::SimpleNetDevice::GetName() const [member function]
       
  1281     cls.add_method('GetName', 'std::string', [], is_const=True, is_virtual=True)
       
  1282     ## simple-net-device.h: void ns3::SimpleNetDevice::SetIfIndex(uint32_t const index) [member function]
       
  1283     cls.add_method('SetIfIndex', 'void', [param('uint32_t', 'index', is_const=True)], is_virtual=True)
       
  1284     ## simple-net-device.h: uint32_t ns3::SimpleNetDevice::GetIfIndex() const [member function]
       
  1285     cls.add_method('GetIfIndex', 'uint32_t', [], is_const=True, is_virtual=True)
       
  1286     ## simple-net-device.h: ns3::Ptr<ns3::Channel> ns3::SimpleNetDevice::GetChannel() const [member function]
       
  1287     cls.add_method('GetChannel', 'ns3::Ptr< ns3::Channel >', [], is_const=True, is_virtual=True)
       
  1288     ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::GetAddress() const [member function]
       
  1289     cls.add_method('GetAddress', 'ns3::Address', [], is_const=True, is_virtual=True)
       
  1290     ## simple-net-device.h: bool ns3::SimpleNetDevice::SetMtu(uint16_t const mtu) [member function]
       
  1291     cls.add_method('SetMtu', 'bool', [param('uint16_t', 'mtu', is_const=True)], is_virtual=True)
       
  1292     ## simple-net-device.h: uint16_t ns3::SimpleNetDevice::GetMtu() const [member function]
       
  1293     cls.add_method('GetMtu', 'uint16_t', [], is_const=True, is_virtual=True)
       
  1294     ## simple-net-device.h: bool ns3::SimpleNetDevice::IsLinkUp() const [member function]
       
  1295     cls.add_method('IsLinkUp', 'bool', [], is_const=True, is_virtual=True)
       
  1296     ## simple-net-device.h: void ns3::SimpleNetDevice::SetLinkChangeCallback(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]
       
  1297     cls.add_method('SetLinkChangeCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')], is_virtual=True)
       
  1298     ## simple-net-device.h: bool ns3::SimpleNetDevice::IsBroadcast() const [member function]
       
  1299     cls.add_method('IsBroadcast', 'bool', [], is_const=True, is_virtual=True)
       
  1300     ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::GetBroadcast() const [member function]
       
  1301     cls.add_method('GetBroadcast', 'ns3::Address', [], is_const=True, is_virtual=True)
       
  1302     ## simple-net-device.h: bool ns3::SimpleNetDevice::IsMulticast() const [member function]
       
  1303     cls.add_method('IsMulticast', 'bool', [], is_const=True, is_virtual=True)
       
  1304     ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::GetMulticast() const [member function]
       
  1305     cls.add_method('GetMulticast', 'ns3::Address', [], is_const=True, is_virtual=True)
       
  1306     ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::MakeMulticastAddress(ns3::Ipv4Address multicastGroup) const [member function]
       
  1307     cls.add_method('MakeMulticastAddress', 'ns3::Address', [param('ns3::Ipv4Address', 'multicastGroup')], is_const=True, is_virtual=True)
       
  1308     ## simple-net-device.h: bool ns3::SimpleNetDevice::IsPointToPoint() const [member function]
       
  1309     cls.add_method('IsPointToPoint', 'bool', [], is_const=True, is_virtual=True)
       
  1310     ## simple-net-device.h: bool ns3::SimpleNetDevice::Send(ns3::Ptr<ns3::Packet> packet, ns3::Address const & dest, uint16_t protocolNumber) [member function]
       
  1311     cls.add_method('Send', 'bool', [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address&', 'dest', is_const=True), param('uint16_t', 'protocolNumber')], is_virtual=True)
       
  1312     ## simple-net-device.h: ns3::Ptr<ns3::Node> ns3::SimpleNetDevice::GetNode() const [member function]
       
  1313     cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [], is_const=True, is_virtual=True)
       
  1314     ## simple-net-device.h: void ns3::SimpleNetDevice::SetNode(ns3::Ptr<ns3::Node> node) [member function]
       
  1315     cls.add_method('SetNode', 'void', [param('ns3::Ptr< ns3::Node >', 'node')], is_virtual=True)
       
  1316     ## simple-net-device.h: bool ns3::SimpleNetDevice::NeedsArp() const [member function]
       
  1317     cls.add_method('NeedsArp', 'bool', [], is_const=True, is_virtual=True)
       
  1318     ## simple-net-device.h: void ns3::SimpleNetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function]
       
  1319     cls.add_method('SetReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], is_virtual=True)
       
  1320     ## simple-net-device.h: void ns3::SimpleNetDevice::DoDispose() [member function]
       
  1321     cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True)
       
  1322     return
       
  1323 
       
  1324 def register_Ns3TcpSocketFactory_methods(root_module, cls):
       
  1325     ## tcp-socket-factory.h: static ns3::TypeId ns3::TcpSocketFactory::GetTypeId() [member function]
       
  1326     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
       
  1327     ## tcp-socket-factory.h: ns3::Ptr<ns3::Socket> ns3::TcpSocketFactory::CreateSocket() [member function]
       
  1328     cls.add_method('CreateSocket', 'ns3::Ptr< ns3::Socket >', [], is_pure_virtual=True, is_virtual=True)
       
  1329     cls.add_constructor([])
       
  1330     return
       
  1331 
       
  1332 def register_Ns3PacketSocketFactory_methods(root_module, cls):
       
  1333     ## packet-socket-factory.h: static ns3::TypeId ns3::PacketSocketFactory::GetTypeId() [member function]
       
  1334     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
       
  1335     ## packet-socket-factory.h: ns3::PacketSocketFactory::PacketSocketFactory() [constructor]
       
  1336     cls.add_constructor([], visibility='public')
       
  1337     ## packet-socket-factory.h: ns3::Ptr<ns3::Socket> ns3::PacketSocketFactory::CreateSocket() [member function]
       
  1338     cls.add_method('CreateSocket', 'ns3::Ptr< ns3::Socket >', [], is_virtual=True)
       
  1339     return
       
  1340 
       
  1341 def register_functions(root_module):
       
  1342     module = root_module
       
  1343     ## mac48-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeMac48AddressChecker() [free function]
       
  1344     module.add_function('MakeMac48AddressChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [])
       
  1345     ## ipv4-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeIpv4AddressChecker() [free function]
       
  1346     module.add_function('MakeIpv4AddressChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [])
       
  1347     ## address-utils.h: extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Mac48Address ad) [free function]
       
  1348     module.add_function('WriteTo', 'void', [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Mac48Address', 'ad')])
       
  1349     ## address-utils.h: extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Address const & ad) [free function]
       
  1350     module.add_function('WriteTo', 'void', [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Address&', 'ad', is_const=True)])
       
  1351     ## address-utils.h: extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Ipv4Address ad) [free function]
       
  1352     module.add_function('WriteTo', 'void', [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Ipv4Address', 'ad')])
       
  1353     ## address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeAddressChecker() [free function]
       
  1354     module.add_function('MakeAddressChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [])
       
  1355     ## ipv4-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeIpv4MaskChecker() [free function]
       
  1356     module.add_function('MakeIpv4MaskChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [])
       
  1357     ## address-utils.h: extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Mac48Address & ad) [free function]
       
  1358     module.add_function('ReadFrom', 'void', [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Mac48Address&', 'ad')])
       
  1359     ## address-utils.h: extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Address & ad, uint32_t len) [free function]
       
  1360     module.add_function('ReadFrom', 'void', [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Address&', 'ad'), param('uint32_t', 'len')])
       
  1361     ## address-utils.h: extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Ipv4Address & ad) [free function]
       
  1362     module.add_function('ReadFrom', 'void', [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Ipv4Address&', 'ad')])
       
  1363     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
       
  1364     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
       
  1365     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
       
  1366     register_functions_ns3_olsr(module.get_submodule('olsr'), root_module)
       
  1367     return
       
  1368 
       
  1369 def register_functions_ns3_internal(module, root_module):
       
  1370     return
       
  1371 
       
  1372 def register_functions_ns3_TimeStepPrecision(module, root_module):
       
  1373     return
       
  1374 
       
  1375 def register_functions_ns3_Config(module, root_module):
       
  1376     return
       
  1377 
       
  1378 def register_functions_ns3_olsr(module, root_module):
       
  1379     return
       
  1380