# HG changeset patch # User Gustavo J. A. M. Carneiro # Date 1215539038 25200 # Node ID 2cc40b3e4fa5f3ac5b0f5ecb0814951268865b7f # Parent 0d83aa14b65da4836f6369c0e0aa2ad7aa3dd779 python bindings diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/callbacks_list.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/callbacks_list.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,12 @@ +callback_classes = [ + ['void', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['bool', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'ns3::Address const&', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::Ptr', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::Ptr', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['bool', 'ns3::Ptr', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::Ptr', 'ns3::Mac48Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'ns3::Address const&', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::Ptr', 'double', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::Ptr', 'double', 'ns3::WifiMode', 'ns3::WifiPreamble', 'ns3::empty', 'ns3::empty'], +] diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/my_extra_api_definitions.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/my_extra_api_definitions.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,13 @@ +from pybindgen import Module, FileCodeSink, write_preamble, param, retval + +def register_types(module): + module.add_class('MyClass') + +def register_methods(root_module): + MyClass = root_module['MyClass'] + MyClass.add_constructor([], visibility='public') + MyClass.add_constructor([param('double', 's'), param('double', 'l'), param('double', 'mean')], visibility='public') + +def register_functions(module): + module.add_function('SomeFunction', 'int', [param('int', 'xpto')]) + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/ns3/__init__.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/ns3/__init__.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,4 @@ + +from _ns3 import * + + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/ns3_module_common.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/ns3_module_common.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,575 @@ +from pybindgen import Module, FileCodeSink, write_preamble, param, retval + +def register_types(module): + root_module = module.get_root() + + ## error-model.h: ns3::ErrorUnit [enumeration] + module.add_enum('ErrorUnit', ['EU_BIT', 'EU_BYTE', 'EU_PKT']) + ## packet.h: ns3::Packet [class] + module.add_class('Packet', incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount') + ## packet.h: ns3::TagIterator [class] + module.add_class('TagIterator') + ## packet.h: ns3::TagIterator::Item [class] + module.add_class('Item', outer_class=root_module['ns3::TagIterator']) + ## tag-list.h: ns3::TagList [class] + module.add_class('TagList') + ## tag-list.h: ns3::TagList::Iterator [class] + module.add_class('Iterator', outer_class=root_module['ns3::TagList']) + ## tag-list.h: ns3::TagList::Iterator::Item [struct] + module.add_class('Item', outer_class=root_module['ns3::TagList::Iterator']) + ## tag-buffer.h: ns3::TagBuffer [class] + module.add_class('TagBuffer') + ## buffer.h: ns3::Buffer [class] + module.add_class('Buffer') + ## buffer.h: ns3::Buffer::Iterator [class] + module.add_class('Iterator', outer_class=root_module['ns3::Buffer']) + ## chunk.h: ns3::Chunk [class] + module.add_class('Chunk', allow_subclassing=True, parent=root_module['ns3::ObjectBase']) + ## data-rate.h: ns3::DataRate [class] + module.add_class('DataRate') + ## tag.h: ns3::Tag [class] + module.add_class('Tag', allow_subclassing=True, parent=root_module['ns3::ObjectBase']) + ## pcap-writer.h: ns3::PcapWriter [class] + module.add_class('PcapWriter', parent=root_module['ns3::RefCountBase']) + ## data-rate.h: ns3::DataRateChecker [class] + module.add_class('DataRateChecker', parent=root_module['ns3::AttributeChecker']) + ## error-model.h: ns3::ErrorModel [class] + module.add_class('ErrorModel', allow_subclassing=True, parent=root_module['ns3::Object']) + ## header.h: ns3::Header [class] + module.add_class('Header', allow_subclassing=True, parent=root_module['ns3::Chunk']) + ## trailer.h: ns3::Trailer [class] + module.add_class('Trailer', allow_subclassing=True, parent=root_module['ns3::Chunk']) + ## error-model.h: ns3::ListErrorModel [class] + module.add_class('ListErrorModel', allow_subclassing=True, parent=root_module['ns3::ErrorModel']) + ## data-rate.h: ns3::DataRateValue [class] + module.add_class('DataRateValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue']) + ## error-model.h: ns3::RateErrorModel [class] + module.add_class('RateErrorModel', allow_subclassing=True, parent=root_module['ns3::ErrorModel']) + + ## Register a nested module for the namespace internal + + nested_module = module.add_cpp_namespace('internal') + register_types_ns3_internal(nested_module) + + + ## Register a nested module for the namespace TimeStepPrecision + + nested_module = module.add_cpp_namespace('TimeStepPrecision') + register_types_ns3_TimeStepPrecision(nested_module) + + + ## Register a nested module for the namespace Config + + nested_module = module.add_cpp_namespace('Config') + register_types_ns3_Config(nested_module) + + + ## Register a nested module for the namespace olsr + + nested_module = module.add_cpp_namespace('olsr') + register_types_ns3_olsr(nested_module) + + +def register_types_ns3_internal(module): + root_module = module.get_root() + + +def register_types_ns3_TimeStepPrecision(module): + root_module = module.get_root() + + +def register_types_ns3_Config(module): + root_module = module.get_root() + + +def register_types_ns3_olsr(module): + root_module = module.get_root() + + +def register_methods(root_module): + register_Ns3Packet_methods(root_module, root_module['ns3::Packet']) + register_Ns3TagIterator_methods(root_module, root_module['ns3::TagIterator']) + register_Ns3TagIteratorItem_methods(root_module, root_module['ns3::TagIterator::Item']) + register_Ns3TagList_methods(root_module, root_module['ns3::TagList']) + register_Ns3TagListIterator_methods(root_module, root_module['ns3::TagList::Iterator']) + register_Ns3TagListIteratorItem_methods(root_module, root_module['ns3::TagList::Iterator::Item']) + register_Ns3TagBuffer_methods(root_module, root_module['ns3::TagBuffer']) + register_Ns3Buffer_methods(root_module, root_module['ns3::Buffer']) + register_Ns3BufferIterator_methods(root_module, root_module['ns3::Buffer::Iterator']) + register_Ns3Chunk_methods(root_module, root_module['ns3::Chunk']) + register_Ns3DataRate_methods(root_module, root_module['ns3::DataRate']) + register_Ns3Tag_methods(root_module, root_module['ns3::Tag']) + register_Ns3PcapWriter_methods(root_module, root_module['ns3::PcapWriter']) + register_Ns3DataRateChecker_methods(root_module, root_module['ns3::DataRateChecker']) + register_Ns3ErrorModel_methods(root_module, root_module['ns3::ErrorModel']) + register_Ns3Header_methods(root_module, root_module['ns3::Header']) + register_Ns3Trailer_methods(root_module, root_module['ns3::Trailer']) + register_Ns3ListErrorModel_methods(root_module, root_module['ns3::ListErrorModel']) + register_Ns3DataRateValue_methods(root_module, root_module['ns3::DataRateValue']) + register_Ns3RateErrorModel_methods(root_module, root_module['ns3::RateErrorModel']) + return + +def register_Ns3Packet_methods(root_module, cls): + ## packet.h: ns3::Packet::Packet() [constructor] + cls.add_constructor([], visibility='public') + ## packet.h: ns3::Packet::Packet(ns3::Packet const & o) [copy constructor] + cls.add_constructor([param('ns3::Packet&', 'o', is_const=True)], visibility='public') + ## packet.h: ns3::Packet::Packet(uint32_t size) [constructor] + cls.add_constructor([param('uint32_t', 'size')], visibility='public') + ## packet.h: ns3::Packet::Packet(uint8_t const * buffer, uint32_t size) [constructor] + cls.add_constructor([param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint32_t', 'size')], visibility='public') + ## packet.h: void ns3::Packet::AddAtEnd(ns3::Ptr packet) [member function] + cls.add_method('AddAtEnd', 'void', [param('ns3::Ptr< const ns3::Packet >', 'packet')]) + ## packet.h: void ns3::Packet::AddHeader(ns3::Header const & header) [member function] + cls.add_method('AddHeader', 'void', [param('ns3::Header&', 'header', is_const=True)]) + ## packet.h: void ns3::Packet::AddPaddingAtEnd(uint32_t size) [member function] + cls.add_method('AddPaddingAtEnd', 'void', [param('uint32_t', 'size')]) + ## packet.h: void ns3::Packet::AddTag(ns3::Tag const & tag) const [member function] + cls.add_method('AddTag', 'void', [param('ns3::Tag&', 'tag', is_const=True)], is_const=True) + ## packet.h: void ns3::Packet::AddTrailer(ns3::Trailer const & trailer) [member function] + cls.add_method('AddTrailer', 'void', [param('ns3::Trailer&', 'trailer', is_const=True)]) + ## packet.h: ns3::PacketMetadata::ItemIterator ns3::Packet::BeginItem() const [member function] + cls.add_method('BeginItem', 'ns3::PacketMetadata::ItemIterator', [], is_const=True) + ## packet.h: ns3::Ptr ns3::Packet::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::Packet >', [], is_const=True) + ## packet.h: ns3::Ptr ns3::Packet::CreateFragment(uint32_t start, uint32_t length) const [member function] + cls.add_method('CreateFragment', 'ns3::Ptr< ns3::Packet >', [param('uint32_t', 'start'), param('uint32_t', 'length')], is_const=True) + ## packet.h: void ns3::Packet::Deserialize(ns3::Buffer buffer) [member function] + cls.add_method('Deserialize', 'void', [param('ns3::Buffer', 'buffer')]) + ## packet.h: static void ns3::Packet::EnableMetadata() [member function] + cls.add_method('EnableMetadata', 'void', [], is_static=True) + ## packet.h: bool ns3::Packet::FindFirstMatchingTag(ns3::Tag & tag) const [member function] + cls.add_method('FindFirstMatchingTag', 'bool', [param('ns3::Tag&', 'tag')], is_const=True) + ## packet.h: uint32_t ns3::Packet::GetSize() const [member function] + cls.add_method('GetSize', 'uint32_t', [], is_const=True) + ## packet.h: ns3::TagIterator ns3::Packet::GetTagIterator() const [member function] + cls.add_method('GetTagIterator', 'ns3::TagIterator', [], is_const=True) + ## packet.h: uint32_t ns3::Packet::GetUid() const [member function] + cls.add_method('GetUid', 'uint32_t', [], is_const=True) + ## packet.h: uint8_t const * ns3::Packet::PeekData() const [member function] + cls.add_method('PeekData', retval('uint8_t *', is_const=True, caller_owns_return=False), [], is_const=True) + ## packet.h: uint32_t ns3::Packet::PeekHeader(ns3::Header & header) [member function] + cls.add_method('PeekHeader', 'uint32_t', [param('ns3::Header&', 'header')]) + ## packet.h: uint32_t ns3::Packet::PeekTrailer(ns3::Trailer & trailer) [member function] + cls.add_method('PeekTrailer', 'uint32_t', [param('ns3::Trailer&', 'trailer')]) + ## packet.h: void ns3::Packet::Print(std::ostream & os) const [member function] + cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True) + ## packet.h: void ns3::Packet::PrintTags(std::ostream & os) const [member function] + cls.add_method('PrintTags', 'void', [param('std::ostream&', 'os')], is_const=True) + ## packet.h: void ns3::Packet::RemoveAllTags() [member function] + cls.add_method('RemoveAllTags', 'void', []) + ## packet.h: void ns3::Packet::RemoveAtEnd(uint32_t size) [member function] + cls.add_method('RemoveAtEnd', 'void', [param('uint32_t', 'size')]) + ## packet.h: void ns3::Packet::RemoveAtStart(uint32_t size) [member function] + cls.add_method('RemoveAtStart', 'void', [param('uint32_t', 'size')]) + ## packet.h: uint32_t ns3::Packet::RemoveHeader(ns3::Header & header) [member function] + cls.add_method('RemoveHeader', 'uint32_t', [param('ns3::Header&', 'header')]) + ## packet.h: uint32_t ns3::Packet::RemoveTrailer(ns3::Trailer & trailer) [member function] + cls.add_method('RemoveTrailer', 'uint32_t', [param('ns3::Trailer&', 'trailer')]) + ## packet.h: ns3::Buffer ns3::Packet::Serialize() const [member function] + cls.add_method('Serialize', 'ns3::Buffer', [], is_const=True) + cls.add_output_stream_operator() + return + +def register_Ns3TagIterator_methods(root_module, cls): + ## packet.h: bool ns3::TagIterator::HasNext() const [member function] + cls.add_method('HasNext', 'bool', [], is_const=True) + ## packet.h: ns3::TagIterator::Item ns3::TagIterator::Next() [member function] + cls.add_method('Next', 'ns3::TagIterator::Item', []) + return + +def register_Ns3TagIteratorItem_methods(root_module, cls): + ## packet.h: ns3::TypeId ns3::TagIterator::Item::GetTypeId() const [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_const=True) + ## packet.h: uint32_t ns3::TagIterator::Item::GetStart() const [member function] + cls.add_method('GetStart', 'uint32_t', [], is_const=True) + ## packet.h: uint32_t ns3::TagIterator::Item::GetEnd() const [member function] + cls.add_method('GetEnd', 'uint32_t', [], is_const=True) + ## packet.h: void ns3::TagIterator::Item::GetTag(ns3::Tag & tag) const [member function] + cls.add_method('GetTag', 'void', [param('ns3::Tag&', 'tag')], is_const=True) + return + +def register_Ns3TagList_methods(root_module, cls): + ## tag-list.h: ns3::TagList::TagList() [constructor] + cls.add_constructor([], visibility='public') + ## tag-list.h: ns3::TagList::TagList(ns3::TagList const & o) [copy constructor] + cls.add_constructor([param('ns3::TagList&', 'o', is_const=True)], visibility='public') + ## tag-list.h: ns3::TagBuffer ns3::TagList::Add(ns3::TypeId tid, uint32_t bufferSize, int32_t start, int32_t end) [member function] + cls.add_method('Add', 'ns3::TagBuffer', [param('ns3::TypeId', 'tid'), param('uint32_t', 'bufferSize'), param('int32_t', 'start'), param('int32_t', 'end')]) + ## tag-list.h: void ns3::TagList::Add(ns3::TagList const & o) [member function] + cls.add_method('Add', 'void', [param('ns3::TagList&', 'o', is_const=True)]) + ## tag-list.h: void ns3::TagList::RemoveAll() [member function] + cls.add_method('RemoveAll', 'void', []) + ## tag-list.h: ns3::TagList::Iterator ns3::TagList::Begin(int32_t offsetStart, int32_t offsetEnd) const [member function] + cls.add_method('Begin', 'ns3::TagList::Iterator', [param('int32_t', 'offsetStart'), param('int32_t', 'offsetEnd')], is_const=True) + ## tag-list.h: void ns3::TagList::AddAtEnd(int32_t adjustment, int32_t appendOffset) [member function] + cls.add_method('AddAtEnd', 'void', [param('int32_t', 'adjustment'), param('int32_t', 'appendOffset')]) + ## tag-list.h: void ns3::TagList::AddAtStart(int32_t adjustment, int32_t prependOffset) [member function] + cls.add_method('AddAtStart', 'void', [param('int32_t', 'adjustment'), param('int32_t', 'prependOffset')]) + return + +def register_Ns3TagListIterator_methods(root_module, cls): + ## tag-list.h: bool ns3::TagList::Iterator::HasNext() const [member function] + cls.add_method('HasNext', 'bool', [], is_const=True) + ## tag-list.h: ns3::TagList::Iterator::Item ns3::TagList::Iterator::Next() [member function] + cls.add_method('Next', 'ns3::TagList::Iterator::Item', []) + ## tag-list.h: uint32_t ns3::TagList::Iterator::GetOffsetStart() const [member function] + cls.add_method('GetOffsetStart', 'uint32_t', [], is_const=True) + return + +def register_Ns3TagListIteratorItem_methods(root_module, cls): + ## tag-list.h: ns3::TagList::Iterator::Item::tid [variable] + cls.add_instance_attribute('tid', 'ns3::TypeId', is_const=False) + ## tag-list.h: ns3::TagList::Iterator::Item::size [variable] + cls.add_instance_attribute('size', 'uint32_t', is_const=False) + ## tag-list.h: ns3::TagList::Iterator::Item::start [variable] + cls.add_instance_attribute('start', 'int32_t', is_const=False) + ## tag-list.h: ns3::TagList::Iterator::Item::end [variable] + cls.add_instance_attribute('end', 'int32_t', is_const=False) + ## tag-list.h: ns3::TagList::Iterator::Item::buf [variable] + cls.add_instance_attribute('buf', 'ns3::TagBuffer', is_const=False) + ## tag-list.h: ns3::TagList::Iterator::Item::Item(ns3::TagBuffer buf) [constructor] + cls.add_constructor([param('ns3::TagBuffer', 'buf')], visibility='public') + return + +def register_Ns3TagBuffer_methods(root_module, cls): + ## tag-buffer.h: ns3::TagBuffer::TagBuffer(uint8_t * start, uint8_t * end) [constructor] + cls.add_constructor([param('uint8_t *', 'start'), param('uint8_t *', 'end')], visibility='public') + ## tag-buffer.h: void ns3::TagBuffer::TrimAtEnd(uint32_t trim) [member function] + cls.add_method('TrimAtEnd', 'void', [param('uint32_t', 'trim')]) + ## tag-buffer.h: void ns3::TagBuffer::CopyFrom(ns3::TagBuffer o) [member function] + cls.add_method('CopyFrom', 'void', [param('ns3::TagBuffer', 'o')]) + ## tag-buffer.h: void ns3::TagBuffer::WriteU8(uint8_t v) [member function] + cls.add_method('WriteU8', 'void', [param('uint8_t', 'v')]) + ## tag-buffer.h: void ns3::TagBuffer::WriteU16(uint16_t data) [member function] + cls.add_method('WriteU16', 'void', [param('uint16_t', 'data')]) + ## tag-buffer.h: void ns3::TagBuffer::WriteU32(uint32_t data) [member function] + cls.add_method('WriteU32', 'void', [param('uint32_t', 'data')]) + ## tag-buffer.h: void ns3::TagBuffer::WriteU64(uint64_t v) [member function] + cls.add_method('WriteU64', 'void', [param('uint64_t', 'v')]) + ## tag-buffer.h: void ns3::TagBuffer::WriteDouble(double v) [member function] + cls.add_method('WriteDouble', 'void', [param('double', 'v')]) + ## tag-buffer.h: void ns3::TagBuffer::Write(uint8_t const * buffer, uint32_t size) [member function] + cls.add_method('Write', 'void', [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint32_t', 'size')]) + ## tag-buffer.h: uint8_t ns3::TagBuffer::ReadU8() [member function] + cls.add_method('ReadU8', 'uint8_t', []) + ## tag-buffer.h: uint16_t ns3::TagBuffer::ReadU16() [member function] + cls.add_method('ReadU16', 'uint16_t', []) + ## tag-buffer.h: uint32_t ns3::TagBuffer::ReadU32() [member function] + cls.add_method('ReadU32', 'uint32_t', []) + ## tag-buffer.h: uint64_t ns3::TagBuffer::ReadU64() [member function] + cls.add_method('ReadU64', 'uint64_t', []) + ## tag-buffer.h: double ns3::TagBuffer::ReadDouble() [member function] + cls.add_method('ReadDouble', 'double', []) + ## tag-buffer.h: void ns3::TagBuffer::Read(uint8_t * buffer, uint32_t size) [member function] + cls.add_method('Read', 'void', [param('uint8_t *', 'buffer'), param('uint32_t', 'size')]) + return + +def register_Ns3Buffer_methods(root_module, cls): + ## buffer.h: uint32_t ns3::Buffer::GetSize() const [member function] + cls.add_method('GetSize', 'uint32_t', [], is_const=True) + ## buffer.h: uint8_t const * ns3::Buffer::PeekData() const [member function] + cls.add_method('PeekData', retval('uint8_t *', is_const=True, caller_owns_return=False), [], is_const=True) + ## buffer.h: bool ns3::Buffer::AddAtStart(uint32_t start) [member function] + cls.add_method('AddAtStart', 'bool', [param('uint32_t', 'start')]) + ## buffer.h: bool ns3::Buffer::AddAtEnd(uint32_t end) [member function] + cls.add_method('AddAtEnd', 'bool', [param('uint32_t', 'end')]) + ## buffer.h: void ns3::Buffer::AddAtEnd(ns3::Buffer const & o) [member function] + cls.add_method('AddAtEnd', 'void', [param('ns3::Buffer&', 'o', is_const=True)]) + ## buffer.h: void ns3::Buffer::RemoveAtStart(uint32_t start) [member function] + cls.add_method('RemoveAtStart', 'void', [param('uint32_t', 'start')]) + ## buffer.h: void ns3::Buffer::RemoveAtEnd(uint32_t end) [member function] + cls.add_method('RemoveAtEnd', 'void', [param('uint32_t', 'end')]) + ## buffer.h: ns3::Buffer ns3::Buffer::CreateFragment(uint32_t start, uint32_t length) const [member function] + cls.add_method('CreateFragment', 'ns3::Buffer', [param('uint32_t', 'start'), param('uint32_t', 'length')], is_const=True) + ## buffer.h: ns3::Buffer::Iterator ns3::Buffer::Begin() const [member function] + cls.add_method('Begin', 'ns3::Buffer::Iterator', [], is_const=True) + ## buffer.h: ns3::Buffer::Iterator ns3::Buffer::End() const [member function] + cls.add_method('End', 'ns3::Buffer::Iterator', [], is_const=True) + ## buffer.h: ns3::Buffer ns3::Buffer::CreateFullCopy() const [member function] + cls.add_method('CreateFullCopy', 'ns3::Buffer', [], is_const=True) + ## buffer.h: int32_t ns3::Buffer::GetCurrentStartOffset() const [member function] + cls.add_method('GetCurrentStartOffset', 'int32_t', [], is_const=True) + ## buffer.h: int32_t ns3::Buffer::GetCurrentEndOffset() const [member function] + cls.add_method('GetCurrentEndOffset', 'int32_t', [], is_const=True) + ## buffer.h: ns3::Buffer::Buffer(ns3::Buffer const & o) [copy constructor] + cls.add_constructor([param('ns3::Buffer&', 'o', is_const=True)], visibility='public') + ## buffer.h: ns3::Buffer::Buffer() [constructor] + cls.add_constructor([], visibility='public') + ## buffer.h: ns3::Buffer::Buffer(uint32_t dataSize) [constructor] + cls.add_constructor([param('uint32_t', 'dataSize')], visibility='public') + return + +def register_Ns3BufferIterator_methods(root_module, cls): + ## buffer.h: ns3::Buffer::Iterator::Iterator() [constructor] + cls.add_constructor([], visibility='public') + ## buffer.h: void ns3::Buffer::Iterator::Next() [member function] + cls.add_method('Next', 'void', []) + ## buffer.h: void ns3::Buffer::Iterator::Prev() [member function] + cls.add_method('Prev', 'void', []) + ## buffer.h: void ns3::Buffer::Iterator::Next(uint32_t delta) [member function] + cls.add_method('Next', 'void', [param('uint32_t', 'delta')]) + ## buffer.h: void ns3::Buffer::Iterator::Prev(uint32_t delta) [member function] + cls.add_method('Prev', 'void', [param('uint32_t', 'delta')]) + ## buffer.h: uint32_t ns3::Buffer::Iterator::GetDistanceFrom(ns3::Buffer::Iterator const & o) const [member function] + cls.add_method('GetDistanceFrom', 'uint32_t', [param('ns3::Buffer::Iterator&', 'o', is_const=True)], is_const=True) + ## buffer.h: bool ns3::Buffer::Iterator::IsEnd() const [member function] + cls.add_method('IsEnd', 'bool', [], is_const=True) + ## buffer.h: bool ns3::Buffer::Iterator::IsStart() const [member function] + cls.add_method('IsStart', 'bool', [], is_const=True) + ## buffer.h: void ns3::Buffer::Iterator::WriteU8(uint8_t data) [member function] + cls.add_method('WriteU8', 'void', [param('uint8_t', 'data')]) + ## buffer.h: void ns3::Buffer::Iterator::WriteU8(uint8_t data, uint32_t len) [member function] + cls.add_method('WriteU8', 'void', [param('uint8_t', 'data'), param('uint32_t', 'len')]) + ## buffer.h: void ns3::Buffer::Iterator::WriteU16(uint16_t data) [member function] + cls.add_method('WriteU16', 'void', [param('uint16_t', 'data')]) + ## buffer.h: void ns3::Buffer::Iterator::WriteU32(uint32_t data) [member function] + cls.add_method('WriteU32', 'void', [param('uint32_t', 'data')]) + ## buffer.h: void ns3::Buffer::Iterator::WriteU64(uint64_t data) [member function] + cls.add_method('WriteU64', 'void', [param('uint64_t', 'data')]) + ## buffer.h: void ns3::Buffer::Iterator::WriteHtolsbU16(uint16_t data) [member function] + cls.add_method('WriteHtolsbU16', 'void', [param('uint16_t', 'data')]) + ## buffer.h: void ns3::Buffer::Iterator::WriteHtolsbU32(uint32_t data) [member function] + cls.add_method('WriteHtolsbU32', 'void', [param('uint32_t', 'data')]) + ## buffer.h: void ns3::Buffer::Iterator::WriteHtolsbU64(uint64_t data) [member function] + cls.add_method('WriteHtolsbU64', 'void', [param('uint64_t', 'data')]) + ## buffer.h: void ns3::Buffer::Iterator::WriteHtonU16(uint16_t data) [member function] + cls.add_method('WriteHtonU16', 'void', [param('uint16_t', 'data')]) + ## buffer.h: void ns3::Buffer::Iterator::WriteHtonU32(uint32_t data) [member function] + cls.add_method('WriteHtonU32', 'void', [param('uint32_t', 'data')]) + ## buffer.h: void ns3::Buffer::Iterator::WriteHtonU64(uint64_t data) [member function] + cls.add_method('WriteHtonU64', 'void', [param('uint64_t', 'data')]) + ## buffer.h: void ns3::Buffer::Iterator::Write(uint8_t const * buffer, uint32_t size) [member function] + cls.add_method('Write', 'void', [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint32_t', 'size')]) + ## buffer.h: void ns3::Buffer::Iterator::Write(ns3::Buffer::Iterator start, ns3::Buffer::Iterator end) [member function] + cls.add_method('Write', 'void', [param('ns3::Buffer::Iterator', 'start'), param('ns3::Buffer::Iterator', 'end')]) + ## buffer.h: uint8_t ns3::Buffer::Iterator::ReadU8() [member function] + cls.add_method('ReadU8', 'uint8_t', []) + ## buffer.h: uint16_t ns3::Buffer::Iterator::ReadU16() [member function] + cls.add_method('ReadU16', 'uint16_t', []) + ## buffer.h: uint32_t ns3::Buffer::Iterator::ReadU32() [member function] + cls.add_method('ReadU32', 'uint32_t', []) + ## buffer.h: uint64_t ns3::Buffer::Iterator::ReadU64() [member function] + cls.add_method('ReadU64', 'uint64_t', []) + ## buffer.h: uint16_t ns3::Buffer::Iterator::ReadNtohU16() [member function] + cls.add_method('ReadNtohU16', 'uint16_t', []) + ## buffer.h: uint32_t ns3::Buffer::Iterator::ReadNtohU32() [member function] + cls.add_method('ReadNtohU32', 'uint32_t', []) + ## buffer.h: uint64_t ns3::Buffer::Iterator::ReadNtohU64() [member function] + cls.add_method('ReadNtohU64', 'uint64_t', []) + ## buffer.h: uint16_t ns3::Buffer::Iterator::ReadLsbtohU16() [member function] + cls.add_method('ReadLsbtohU16', 'uint16_t', []) + ## buffer.h: uint32_t ns3::Buffer::Iterator::ReadLsbtohU32() [member function] + cls.add_method('ReadLsbtohU32', 'uint32_t', []) + ## buffer.h: uint64_t ns3::Buffer::Iterator::ReadLsbtohU64() [member function] + cls.add_method('ReadLsbtohU64', 'uint64_t', []) + ## buffer.h: void ns3::Buffer::Iterator::Read(uint8_t * buffer, uint32_t size) [member function] + cls.add_method('Read', 'void', [param('uint8_t *', 'buffer'), param('uint32_t', 'size')]) + ## buffer.h: uint16_t ns3::Buffer::Iterator::CalculateIpChecksum(uint16_t size) [member function] + cls.add_method('CalculateIpChecksum', 'uint16_t', [param('uint16_t', 'size')]) + ## buffer.h: uint16_t ns3::Buffer::Iterator::CalculateIpChecksum(uint16_t size, uint32_t initialChecksum) [member function] + cls.add_method('CalculateIpChecksum', 'uint16_t', [param('uint16_t', 'size'), param('uint32_t', 'initialChecksum')]) + return + +def register_Ns3Chunk_methods(root_module, cls): + ## chunk.h: ns3::Chunk::Chunk() [constructor] + cls.add_constructor([], visibility='public') + ## chunk.h: ns3::Chunk::Chunk(ns3::Chunk const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Chunk&', 'arg0', is_const=True)], visibility='public') + ## chunk.h: static ns3::TypeId ns3::Chunk::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## chunk.h: uint32_t ns3::Chunk::Deserialize(ns3::Buffer::Iterator start) [member function] + cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_pure_virtual=True, is_virtual=True) + ## chunk.h: void ns3::Chunk::Print(std::ostream & os) const [member function] + cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_pure_virtual=True, is_const=True, is_virtual=True) + return + +def register_Ns3DataRate_methods(root_module, cls): + ## data-rate.h: ns3::DataRate::DataRate(ns3::DataRate const & arg0) [copy constructor] + cls.add_constructor([param('ns3::DataRate&', 'arg0', is_const=True)], visibility='public') + ## data-rate.h: ns3::DataRate::DataRate() [constructor] + cls.add_constructor([], visibility='public') + ## data-rate.h: ns3::DataRate::DataRate(uint64_t bps) [constructor] + cls.add_constructor([param('uint64_t', 'bps')], visibility='public') + ## data-rate.h: ns3::DataRate::DataRate(std::string rate) [constructor] + cls.add_constructor([param('std::string', 'rate')], visibility='public') + ## data-rate.h: double ns3::DataRate::CalculateTxTime(uint32_t bytes) const [member function] + cls.add_method('CalculateTxTime', 'double', [param('uint32_t', 'bytes')], is_const=True) + ## data-rate.h: uint64_t ns3::DataRate::GetBitRate() const [member function] + cls.add_method('GetBitRate', 'uint64_t', [], is_const=True) + cls.add_output_stream_operator() + return + +def register_Ns3Tag_methods(root_module, cls): + ## tag.h: static ns3::TypeId ns3::Tag::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## tag.h: uint32_t ns3::Tag::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## tag.h: void ns3::Tag::Serialize(ns3::TagBuffer i) const [member function] + cls.add_method('Serialize', 'void', [param('ns3::TagBuffer', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True) + ## tag.h: void ns3::Tag::Deserialize(ns3::TagBuffer i) [member function] + cls.add_method('Deserialize', 'void', [param('ns3::TagBuffer', 'i')], is_pure_virtual=True, is_virtual=True) + ## tag.h: void ns3::Tag::Print(std::ostream & os) const [member function] + cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_pure_virtual=True, is_const=True, is_virtual=True) + cls.add_constructor([]) + return + +def register_Ns3PcapWriter_methods(root_module, cls): + ## pcap-writer.h: ns3::PcapWriter::PcapWriter() [constructor] + cls.add_constructor([], visibility='public') + ## pcap-writer.h: void ns3::PcapWriter::Open(std::string const & name) [member function] + cls.add_method('Open', 'void', [param('std::string&', 'name', is_const=True)]) + ## pcap-writer.h: void ns3::PcapWriter::WriteEthernetHeader() [member function] + cls.add_method('WriteEthernetHeader', 'void', []) + ## pcap-writer.h: void ns3::PcapWriter::WriteIpHeader() [member function] + cls.add_method('WriteIpHeader', 'void', []) + ## pcap-writer.h: void ns3::PcapWriter::WriteWifiHeader() [member function] + cls.add_method('WriteWifiHeader', 'void', []) + ## pcap-writer.h: void ns3::PcapWriter::WritePppHeader() [member function] + cls.add_method('WritePppHeader', 'void', []) + ## pcap-writer.h: void ns3::PcapWriter::WritePacket(ns3::Ptr packet) [member function] + cls.add_method('WritePacket', 'void', [param('ns3::Ptr< const ns3::Packet >', 'packet')]) + return + +def register_Ns3DataRateChecker_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3ErrorModel_methods(root_module, cls): + ## error-model.h: static ns3::TypeId ns3::ErrorModel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## error-model.h: ns3::ErrorModel::ErrorModel() [constructor] + cls.add_constructor([], visibility='public') + ## error-model.h: bool ns3::ErrorModel::IsCorrupt(ns3::Ptr pkt) [member function] + cls.add_method('IsCorrupt', 'bool', [param('ns3::Ptr< ns3::Packet >', 'pkt')]) + ## error-model.h: void ns3::ErrorModel::Reset() [member function] + cls.add_method('Reset', 'void', []) + ## error-model.h: void ns3::ErrorModel::Enable() [member function] + cls.add_method('Enable', 'void', []) + ## error-model.h: void ns3::ErrorModel::Disable() [member function] + cls.add_method('Disable', 'void', []) + ## error-model.h: bool ns3::ErrorModel::IsEnabled() const [member function] + cls.add_method('IsEnabled', 'bool', [], is_const=True) + ## error-model.h: bool ns3::ErrorModel::DoCorrupt(ns3::Ptr arg0) [member function] + cls.add_method('DoCorrupt', 'bool', [param('ns3::Ptr< ns3::Packet >', 'arg0')], is_pure_virtual=True, visibility='private', is_virtual=True) + ## error-model.h: void ns3::ErrorModel::DoReset() [member function] + cls.add_method('DoReset', 'void', [], is_pure_virtual=True, visibility='private', is_virtual=True) + return + +def register_Ns3Header_methods(root_module, cls): + ## header.h: ns3::Header::Header() [constructor] + cls.add_constructor([], visibility='public') + ## header.h: ns3::Header::Header(ns3::Header const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Header&', 'arg0', is_const=True)], visibility='public') + ## header.h: uint32_t ns3::Header::Deserialize(ns3::Buffer::Iterator start) [member function] + cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_pure_virtual=True, is_virtual=True) + ## header.h: uint32_t ns3::Header::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## header.h: static ns3::TypeId ns3::Header::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## header.h: void ns3::Header::Print(std::ostream & os) const [member function] + cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_pure_virtual=True, is_const=True, is_virtual=True) + ## header.h: void ns3::Header::Serialize(ns3::Buffer::Iterator start) const [member function] + cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_pure_virtual=True, is_const=True, is_virtual=True) + cls.add_output_stream_operator() + return + +def register_Ns3Trailer_methods(root_module, cls): + ## trailer.h: ns3::Trailer::Trailer() [constructor] + cls.add_constructor([], visibility='public') + ## trailer.h: ns3::Trailer::Trailer(ns3::Trailer const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Trailer&', 'arg0', is_const=True)], visibility='public') + ## trailer.h: uint32_t ns3::Trailer::Deserialize(ns3::Buffer::Iterator end) [member function] + cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'end')], is_pure_virtual=True, is_virtual=True) + ## trailer.h: uint32_t ns3::Trailer::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## trailer.h: static ns3::TypeId ns3::Trailer::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## trailer.h: void ns3::Trailer::Print(std::ostream & os) const [member function] + cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_pure_virtual=True, is_const=True, is_virtual=True) + ## trailer.h: void ns3::Trailer::Serialize(ns3::Buffer::Iterator start) const [member function] + cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_pure_virtual=True, is_const=True, is_virtual=True) + cls.add_output_stream_operator() + return + +def register_Ns3ListErrorModel_methods(root_module, cls): + ## error-model.h: static ns3::TypeId ns3::ListErrorModel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## error-model.h: ns3::ListErrorModel::ListErrorModel() [constructor] + cls.add_constructor([], visibility='public') + ## error-model.h: std::list > ns3::ListErrorModel::GetList() const [member function] + cls.add_method('GetList', 'std::list< unsigned int, std::allocator< unsigned int > >', [], is_const=True) + ## error-model.h: void ns3::ListErrorModel::SetList(std::list > const & packetlist) [member function] + cls.add_method('SetList', 'void', [param('std::list< unsigned int, std::allocator< unsigned int > >&', 'packetlist', is_const=True)]) + ## error-model.h: bool ns3::ListErrorModel::DoCorrupt(ns3::Ptr p) [member function] + cls.add_method('DoCorrupt', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')], visibility='private', is_virtual=True) + ## error-model.h: void ns3::ListErrorModel::DoReset() [member function] + cls.add_method('DoReset', 'void', [], visibility='private', is_virtual=True) + return + +def register_Ns3DataRateValue_methods(root_module, cls): + ## data-rate.h: ns3::DataRateValue::DataRateValue() [constructor] + cls.add_constructor([], visibility='public') + ## data-rate.h: ns3::DataRateValue::DataRateValue(ns3::DataRate const & value) [constructor] + cls.add_constructor([param('ns3::DataRate&', 'value', is_const=True)], visibility='public') + ## data-rate.h: void ns3::DataRateValue::Set(ns3::DataRate const & value) [member function] + cls.add_method('Set', 'void', [param('ns3::DataRate&', 'value', is_const=True)]) + ## data-rate.h: ns3::DataRate ns3::DataRateValue::Get() const [member function] + cls.add_method('Get', 'ns3::DataRate', [], is_const=True) + ## data-rate.h: ns3::Ptr ns3::DataRateValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) + ## data-rate.h: std::string ns3::DataRateValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True) + ## data-rate.h: bool ns3::DataRateValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) + return + +def register_Ns3RateErrorModel_methods(root_module, cls): + ## error-model.h: static ns3::TypeId ns3::RateErrorModel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## error-model.h: ns3::RateErrorModel::RateErrorModel() [constructor] + cls.add_constructor([], visibility='public') + ## error-model.h: ns3::ErrorUnit ns3::RateErrorModel::GetUnit() const [member function] + cls.add_method('GetUnit', 'ns3::ErrorUnit', [], is_const=True) + ## error-model.h: void ns3::RateErrorModel::SetUnit(ns3::ErrorUnit error_unit) [member function] + cls.add_method('SetUnit', 'void', [param('ns3::ErrorUnit', 'error_unit')]) + ## error-model.h: double ns3::RateErrorModel::GetRate() const [member function] + cls.add_method('GetRate', 'double', [], is_const=True) + ## error-model.h: void ns3::RateErrorModel::SetRate(double rate) [member function] + cls.add_method('SetRate', 'void', [param('double', 'rate')]) + ## error-model.h: void ns3::RateErrorModel::SetRandomVariable(ns3::RandomVariable const & ranvar) [member function] + cls.add_method('SetRandomVariable', 'void', [param('ns3::RandomVariable&', 'ranvar', is_const=True)]) + ## error-model.h: bool ns3::RateErrorModel::DoCorrupt(ns3::Ptr p) [member function] + cls.add_method('DoCorrupt', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')], visibility='private', is_virtual=True) + ## error-model.h: bool ns3::RateErrorModel::DoCorruptPkt(ns3::Ptr p) [member function] + cls.add_method('DoCorruptPkt', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')], visibility='private', is_virtual=True) + ## error-model.h: bool ns3::RateErrorModel::DoCorruptByte(ns3::Ptr p) [member function] + cls.add_method('DoCorruptByte', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')], visibility='private', is_virtual=True) + ## error-model.h: bool ns3::RateErrorModel::DoCorruptBit(ns3::Ptr p) [member function] + cls.add_method('DoCorruptBit', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')], visibility='private', is_virtual=True) + ## error-model.h: void ns3::RateErrorModel::DoReset() [member function] + cls.add_method('DoReset', 'void', [], visibility='private', is_virtual=True) + return + +def register_functions(root_module): + module = root_module + ## data-rate.h: extern ns3::Ptr ns3::MakeDataRateChecker() [free function] + module.add_function('MakeDataRateChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) + register_functions_ns3_internal(module.get_submodule('internal'), root_module) + register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module) + register_functions_ns3_Config(module.get_submodule('Config'), root_module) + register_functions_ns3_olsr(module.get_submodule('olsr'), root_module) + return + +def register_functions_ns3_internal(module, root_module): + return + +def register_functions_ns3_TimeStepPrecision(module, root_module): + return + +def register_functions_ns3_Config(module, root_module): + return + +def register_functions_ns3_olsr(module, root_module): + return + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/ns3_module_contrib.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/ns3_module_contrib.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,155 @@ +from pybindgen import Module, FileCodeSink, write_preamble, param, retval + +def register_types(module): + root_module = module.get_root() + + ## gnuplot.h: ns3::Gnuplot [class] + module.add_class('Gnuplot') + ## event-garbage-collector.h: ns3::EventGarbageCollector [class] + module.add_class('EventGarbageCollector') + ## gnuplot.h: ns3::GnuplotDataset [class] + module.add_class('GnuplotDataset') + ## gnuplot.h: ns3::GnuplotDataset::Style [enumeration] + module.add_enum('Style', ['LINES', 'POINTS', 'LINES_POINTS', 'DOTS', 'IMPULSES', 'STEPS', 'FSTEPS', 'HISTEPS'], outer_class=root_module['ns3::GnuplotDataset']) + ## gnuplot.h: ns3::GnuplotDataset::ErrorBars [enumeration] + module.add_enum('ErrorBars', ['NONE', 'X', 'Y', 'XY'], outer_class=root_module['ns3::GnuplotDataset']) + ## gtk-config-store.h: ns3::GtkConfigStore [class] + module.add_class('GtkConfigStore') + ## config-store.h: ns3::ConfigStore [class] + module.add_class('ConfigStore', allow_subclassing=True, parent=root_module['ns3::ObjectBase']) + ## delay-jitter-estimation.h: ns3::DelayJitterEstimation [class] + module.add_class('DelayJitterEstimation') + + ## Register a nested module for the namespace internal + + nested_module = module.add_cpp_namespace('internal') + register_types_ns3_internal(nested_module) + + + ## Register a nested module for the namespace TimeStepPrecision + + nested_module = module.add_cpp_namespace('TimeStepPrecision') + register_types_ns3_TimeStepPrecision(nested_module) + + + ## Register a nested module for the namespace Config + + nested_module = module.add_cpp_namespace('Config') + register_types_ns3_Config(nested_module) + + + ## Register a nested module for the namespace olsr + + nested_module = module.add_cpp_namespace('olsr') + register_types_ns3_olsr(nested_module) + + +def register_types_ns3_internal(module): + root_module = module.get_root() + + +def register_types_ns3_TimeStepPrecision(module): + root_module = module.get_root() + + +def register_types_ns3_Config(module): + root_module = module.get_root() + + +def register_types_ns3_olsr(module): + root_module = module.get_root() + + +def register_methods(root_module): + register_Ns3Gnuplot_methods(root_module, root_module['ns3::Gnuplot']) + register_Ns3EventGarbageCollector_methods(root_module, root_module['ns3::EventGarbageCollector']) + register_Ns3GnuplotDataset_methods(root_module, root_module['ns3::GnuplotDataset']) + register_Ns3GtkConfigStore_methods(root_module, root_module['ns3::GtkConfigStore']) + register_Ns3ConfigStore_methods(root_module, root_module['ns3::ConfigStore']) + register_Ns3DelayJitterEstimation_methods(root_module, root_module['ns3::DelayJitterEstimation']) + return + +def register_Ns3Gnuplot_methods(root_module, cls): + ## gnuplot.h: ns3::Gnuplot::Gnuplot(std::string pngFilename) [constructor] + cls.add_constructor([param('std::string', 'pngFilename')], visibility='public') + ## gnuplot.h: void ns3::Gnuplot::SetLegend(std::string xLegend, std::string yLegend) [member function] + cls.add_method('SetLegend', 'void', [param('std::string', 'xLegend'), param('std::string', 'yLegend')]) + ## gnuplot.h: void ns3::Gnuplot::AddDataset(ns3::GnuplotDataset const & dataset) [member function] + cls.add_method('AddDataset', 'void', [param('ns3::GnuplotDataset&', 'dataset', is_const=True)]) + ## gnuplot.h: void ns3::Gnuplot::GenerateOutput(std::ostream & os) [member function] + cls.add_method('GenerateOutput', 'void', [param('std::ostream&', 'os')]) + return + +def register_Ns3EventGarbageCollector_methods(root_module, cls): + ## event-garbage-collector.h: ns3::EventGarbageCollector::EventGarbageCollector() [constructor] + cls.add_constructor([], visibility='public') + ## event-garbage-collector.h: void ns3::EventGarbageCollector::Track(ns3::EventId event) [member function] + cls.add_method('Track', 'void', [param('ns3::EventId', 'event')]) + return + +def register_Ns3GnuplotDataset_methods(root_module, cls): + ## gnuplot.h: ns3::GnuplotDataset::GnuplotDataset() [constructor] + cls.add_constructor([], visibility='public') + ## gnuplot.h: ns3::GnuplotDataset::GnuplotDataset(std::string title) [constructor] + cls.add_constructor([param('std::string', 'title')], visibility='public') + ## gnuplot.h: void ns3::GnuplotDataset::SetStyle(ns3::GnuplotDataset::Style style) [member function] + cls.add_method('SetStyle', 'void', [param('ns3::GnuplotDataset::Style', 'style')]) + ## gnuplot.h: void ns3::GnuplotDataset::SetErrorBars(ns3::GnuplotDataset::ErrorBars errorBars) [member function] + cls.add_method('SetErrorBars', 'void', [param('ns3::GnuplotDataset::ErrorBars', 'errorBars')]) + ## gnuplot.h: void ns3::GnuplotDataset::Add(double x, double y) [member function] + cls.add_method('Add', 'void', [param('double', 'x'), param('double', 'y')]) + ## gnuplot.h: void ns3::GnuplotDataset::Add(double x, double y, double errorDelta) [member function] + cls.add_method('Add', 'void', [param('double', 'x'), param('double', 'y'), param('double', 'errorDelta')]) + return + +def register_Ns3GtkConfigStore_methods(root_module, cls): + ## gtk-config-store.h: ns3::GtkConfigStore::GtkConfigStore() [constructor] + cls.add_constructor([], visibility='public') + ## gtk-config-store.h: void ns3::GtkConfigStore::Configure() [member function] + cls.add_method('Configure', 'void', []) + return + +def register_Ns3ConfigStore_methods(root_module, cls): + ## config-store.h: static ns3::TypeId ns3::ConfigStore::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## config-store.h: ns3::TypeId ns3::ConfigStore::GetInstanceTypeId() const [member function] + cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True) + ## config-store.h: ns3::ConfigStore::ConfigStore() [constructor] + cls.add_constructor([], visibility='public') + ## config-store.h: void ns3::ConfigStore::Configure() [member function] + cls.add_method('Configure', 'void', []) + return + +def register_Ns3DelayJitterEstimation_methods(root_module, cls): + ## delay-jitter-estimation.h: ns3::DelayJitterEstimation::DelayJitterEstimation() [constructor] + cls.add_constructor([], visibility='public') + ## delay-jitter-estimation.h: static void ns3::DelayJitterEstimation::PrepareTx(ns3::Ptr packet) [member function] + cls.add_method('PrepareTx', 'void', [param('ns3::Ptr< const ns3::Packet >', 'packet')], is_static=True) + ## delay-jitter-estimation.h: void ns3::DelayJitterEstimation::RecordRx(ns3::Ptr packet) [member function] + cls.add_method('RecordRx', 'void', [param('ns3::Ptr< const ns3::Packet >', 'packet')]) + ## delay-jitter-estimation.h: ns3::Time ns3::DelayJitterEstimation::GetLastDelay() const [member function] + cls.add_method('GetLastDelay', 'ns3::Time', [], is_const=True) + ## delay-jitter-estimation.h: ns3::Time ns3::DelayJitterEstimation::GetLastJitter() const [member function] + cls.add_method('GetLastJitter', 'ns3::Time', [], is_const=True) + return + +def register_functions(root_module): + module = root_module + register_functions_ns3_internal(module.get_submodule('internal'), root_module) + register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module) + register_functions_ns3_Config(module.get_submodule('Config'), root_module) + register_functions_ns3_olsr(module.get_submodule('olsr'), root_module) + return + +def register_functions_ns3_internal(module, root_module): + return + +def register_functions_ns3_TimeStepPrecision(module, root_module): + return + +def register_functions_ns3_Config(module, root_module): + return + +def register_functions_ns3_olsr(module, root_module): + return + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/ns3_module_core.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/ns3_module_core.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,1317 @@ +from pybindgen import Module, FileCodeSink, write_preamble, param, retval + +def register_types(module): + root_module = module.get_root() + + ## random-variable.h: ns3::RandomVariable [class] + module.add_class('RandomVariable') + ## random-variable.h: ns3::TriangularVariable [class] + module.add_class('TriangularVariable', parent=root_module['ns3::RandomVariable']) + ## global-value.h: ns3::GlobalValue [class] + module.add_class('GlobalValue') + ## ref-count-base.h: ns3::RefCountBase [class] + module.add_class('RefCountBase', incref_method='Ref', automatic_type_narrowing=True, decref_method='Unref', peekref_method='GetReferenceCount') + ## type-id.h: ns3::TypeId [class] + module.add_class('TypeId') + ## type-id.h: ns3::TypeId::AttributeFlag [enumeration] + module.add_enum('AttributeFlag', ['ATTR_GET', 'ATTR_SET', 'ATTR_CONSTRUCT', 'ATTR_SGC'], outer_class=root_module['ns3::TypeId']) + ## type-id.h: ns3::TypeId::AttributeInfo [struct] + module.add_class('AttributeInfo', outer_class=root_module['ns3::TypeId']) + ## system-wall-clock-ms.h: ns3::SystemWallClockMs [class] + module.add_class('SystemWallClockMs') + ## callback.h: ns3::CallbackImplBase [class] + module.add_class('CallbackImplBase', incref_method='Ref', allow_subclassing=True, decref_method='Unref', peekref_method='GetReferenceCount') + ## trace-source-accessor.h: ns3::TraceSourceAccessor [class] + module.add_class('TraceSourceAccessor', allow_subclassing=True) + ## attribute.h: ns3::AttributeChecker [class] + module.add_class('AttributeChecker', incref_method='Ref', allow_subclassing=False, automatic_type_narrowing=True, decref_method='Unref', parent=root_module['ns3::RefCountBase']) + ## random-variable.h: ns3::RandomVariableChecker [class] + module.add_class('RandomVariableChecker', parent=root_module['ns3::AttributeChecker']) + ## random-variable.h: ns3::NormalVariable [class] + module.add_class('NormalVariable', parent=root_module['ns3::RandomVariable']) + ## object-factory.h: ns3::ObjectFactory [class] + module.add_class('ObjectFactory') + ## attribute.h: ns3::AttributeAccessor [class] + module.add_class('AttributeAccessor', allow_subclassing=True, parent=root_module['ns3::RefCountBase']) + ## random-variable.h: ns3::ParetoVariable [class] + module.add_class('ParetoVariable', parent=root_module['ns3::RandomVariable']) + ## random-variable.h: ns3::ConstantVariable [class] + module.add_class('ConstantVariable', parent=root_module['ns3::RandomVariable']) + ## random-variable.h: ns3::EmpiricalVariable [class] + module.add_class('EmpiricalVariable', parent=root_module['ns3::RandomVariable']) + ## enum.h: ns3::EnumChecker [class] + module.add_class('EnumChecker', allow_subclassing=True, parent=root_module['ns3::AttributeChecker']) + ## empty.h: ns3::empty [class] + module.add_class('empty') + ## object-base.h: ns3::ObjectBase [class] + module.add_class('ObjectBase', allow_subclassing=True) + ## command-line.h: ns3::CommandLine [class] + module.add_class('CommandLine') + ## int-to-type.h: ns3::IntToType<6> [struct] + module.add_class('IntToType', template_parameters=['6']) + ## int-to-type.h: ns3::IntToType<6>::v_e [enumeration] + module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 6 >']) + ## int-to-type.h: ns3::IntToType<5> [struct] + module.add_class('IntToType', template_parameters=['5']) + ## int-to-type.h: ns3::IntToType<5>::v_e [enumeration] + module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 5 >']) + ## int-to-type.h: ns3::IntToType<4> [struct] + module.add_class('IntToType', template_parameters=['4']) + ## int-to-type.h: ns3::IntToType<4>::v_e [enumeration] + module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 4 >']) + ## int-to-type.h: ns3::IntToType<3> [struct] + module.add_class('IntToType', template_parameters=['3']) + ## int-to-type.h: ns3::IntToType<3>::v_e [enumeration] + module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 3 >']) + ## int-to-type.h: ns3::IntToType<2> [struct] + module.add_class('IntToType', template_parameters=['2']) + ## int-to-type.h: ns3::IntToType<2>::v_e [enumeration] + module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 2 >']) + ## int-to-type.h: ns3::IntToType<1> [struct] + module.add_class('IntToType', template_parameters=['1']) + ## int-to-type.h: ns3::IntToType<1>::v_e [enumeration] + module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 1 >']) + ## int-to-type.h: ns3::IntToType<0> [struct] + module.add_class('IntToType', template_parameters=['0']) + ## int-to-type.h: ns3::IntToType<0>::v_e [enumeration] + module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 0 >']) + ## rng-stream.h: ns3::RngStream [class] + module.add_class('RngStream') + ## random-variable.h: ns3::LogNormalVariable [class] + module.add_class('LogNormalVariable', parent=root_module['ns3::RandomVariable']) + ## random-variable.h: ns3::IntEmpiricalVariable [class] + module.add_class('IntEmpiricalVariable', parent=root_module['ns3::EmpiricalVariable']) + ## pointer.h: ns3::PointerChecker [class] + module.add_class('PointerChecker', allow_subclassing=True, parent=root_module['ns3::AttributeChecker']) + ## random-variable.h: ns3::WeibullVariable [class] + module.add_class('WeibullVariable', parent=root_module['ns3::RandomVariable']) + ## callback.h: ns3::CallbackBase [class] + module.add_class('CallbackBase') + ## random-variable.h: ns3::ExponentialVariable [class] + module.add_class('ExponentialVariable', parent=root_module['ns3::RandomVariable']) + ## traced-callback.h: ns3::TracedCallback, ns3::Mac48Address, ns3::empty, ns3::empty> [class] + module.add_class('TracedCallback', template_parameters=['ns3::Ptr', 'ns3::Mac48Address', 'ns3::empty', 'ns3::empty']) + ## traced-callback.h: ns3::TracedCallback, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('TracedCallback', template_parameters=['ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty']) + ## traced-callback.h: ns3::TracedCallback, ns3::Address const&, ns3::empty, ns3::empty> [class] + module.add_class('TracedCallback', template_parameters=['ns3::Ptr', 'ns3::Address const&', 'ns3::empty', 'ns3::empty']) + ## traced-callback.h: ns3::TracedCallback, unsigned int, ns3::empty, ns3::empty> [class] + module.add_class('TracedCallback', template_parameters=['ns3::Ptr', 'unsigned int', 'ns3::empty', 'ns3::empty']) + ## traced-callback.h: ns3::TracedCallback, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('TracedCallback', template_parameters=['ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty']) + ## traced-callback.h: ns3::TracedCallback, ns3::TimeUnit<1>, ns3::WifiPhy::State, ns3::empty> [class] + module.add_class('TracedCallback', template_parameters=['ns3::TimeUnit<1>', 'ns3::TimeUnit<1>', 'ns3::WifiPhy::State', 'ns3::empty']) + ## traced-callback.h: ns3::TracedCallback, ns3::WifiMode, ns3::WifiPreamble, unsigned char> [class] + module.add_class('TracedCallback', template_parameters=['ns3::Ptr', 'ns3::WifiMode', 'ns3::WifiPreamble', 'unsigned char']) + ## traced-callback.h: ns3::TracedCallback, double, ns3::empty, ns3::empty> [class] + module.add_class('TracedCallback', template_parameters=['ns3::Ptr', 'double', 'ns3::empty', 'ns3::empty']) + ## traced-callback.h: ns3::TracedCallback, double, ns3::WifiMode, ns3::WifiPreamble> [class] + module.add_class('TracedCallback', template_parameters=['ns3::Ptr', 'double', 'ns3::WifiMode', 'ns3::WifiPreamble']) + ## traced-callback.h: ns3::TracedCallback [class] + module.add_class('TracedCallback', template_parameters=['unsigned int', 'unsigned int', 'ns3::empty', 'ns3::empty']) + ## random-variable.h: ns3::DeterministicVariable [class] + module.add_class('DeterministicVariable', parent=root_module['ns3::RandomVariable']) + ## attribute-list.h: ns3::AttributeList [class] + module.add_class('AttributeList') + ## attribute.h: ns3::AttributeValue [class] + module.add_class('AttributeValue', incref_method='Ref', allow_subclassing=False, automatic_type_narrowing=True, decref_method='Unref', parent=root_module['ns3::RefCountBase']) + ## random-variable.h: ns3::UniformVariable [class] + module.add_class('UniformVariable', parent=root_module['ns3::RandomVariable']) + ## object.h: ns3::Object [class] + module.add_class('Object', peekref_method='GetReferenceCount', parent=root_module['ns3::ObjectBase'], incref_method='Ref', decref_method='Unref', allow_subclassing=True, automatic_type_narrowing=True) + ## object.h: ns3::Object::AggregateIterator [class] + module.add_class('AggregateIterator', outer_class=root_module['ns3::Object']) + ## random-variable.h: ns3::SequentialVariable [class] + module.add_class('SequentialVariable', parent=root_module['ns3::RandomVariable']) + ## object-vector.h: ns3::ObjectVectorChecker [class] + module.add_class('ObjectVectorChecker', allow_subclassing=True, parent=root_module['ns3::AttributeChecker']) + ## string.h: ns3::StringChecker [class] + module.add_class('StringChecker', parent=root_module['ns3::AttributeChecker']) + ## object-vector.h: ns3::ObjectVectorValue [class] + module.add_class('ObjectVectorValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue']) + ## boolean.h: ns3::BooleanChecker [class] + module.add_class('BooleanChecker', parent=root_module['ns3::AttributeChecker']) + ## uinteger.h: ns3::UintegerValue [class] + module.add_class('UintegerValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue']) + ## object-vector.h: ns3::ObjectVectorAccessor [class] + module.add_class('ObjectVectorAccessor', allow_subclassing=True, parent=root_module['ns3::AttributeAccessor']) + ## pointer.h: ns3::PointerValue [class] + module.add_class('PointerValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue']) + ## object-factory.h: ns3::ObjectFactoryChecker [class] + module.add_class('ObjectFactoryChecker', parent=root_module['ns3::AttributeChecker']) + ## type-id.h: ns3::TypeIdChecker [class] + module.add_class('TypeIdChecker', parent=root_module['ns3::AttributeChecker']) + ## double.h: ns3::DoubleValue [class] + module.add_class('DoubleValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue']) + ## string.h: ns3::StringValue [class] + module.add_class('StringValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue']) + ## type-id.h: ns3::TypeIdValue [class] + module.add_class('TypeIdValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue']) + ## enum.h: ns3::EnumValue [class] + module.add_class('EnumValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue']) + ## random-variable.h: ns3::RandomVariableValue [class] + module.add_class('RandomVariableValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue']) + ## object-factory.h: ns3::ObjectFactoryValue [class] + module.add_class('ObjectFactoryValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue']) + ## integer.h: ns3::IntegerValue [class] + module.add_class('IntegerValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue']) + ## attribute.h: ns3::EmptyAttributeValue [class] + module.add_class('EmptyAttributeValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue']) + ## boolean.h: ns3::BooleanValue [class] + module.add_class('BooleanValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue']) + ## traced-value.h: ns3::TracedValue [class] + module.add_class('TracedValue', template_parameters=['unsigned int']) + ## traced-value.h: ns3::TracedValue [class] + root_module['ns3::TracedValue< unsigned int >'].implicitly_converts_to(root_module['ns3::IntegerValue']) + ## traced-value.h: ns3::TracedValue [class] + root_module['ns3::TracedValue< unsigned int >'].implicitly_converts_to(root_module['ns3::UintegerValue']) + ## traced-value.h: ns3::TracedValue [class] + root_module['ns3::TracedValue< unsigned int >'].implicitly_converts_to(root_module['ns3::BooleanValue']) + ## traced-value.h: ns3::TracedValue [class] + root_module['ns3::TracedValue< unsigned int >'].implicitly_converts_to(root_module['ns3::EnumValue']) + + ## Register a nested module for the namespace internal + + nested_module = module.add_cpp_namespace('internal') + register_types_ns3_internal(nested_module) + + + ## Register a nested module for the namespace TimeStepPrecision + + nested_module = module.add_cpp_namespace('TimeStepPrecision') + register_types_ns3_TimeStepPrecision(nested_module) + + + ## Register a nested module for the namespace Config + + nested_module = module.add_cpp_namespace('Config') + register_types_ns3_Config(nested_module) + + + ## Register a nested module for the namespace olsr + + nested_module = module.add_cpp_namespace('olsr') + register_types_ns3_olsr(nested_module) + + +def register_types_ns3_internal(module): + root_module = module.get_root() + + +def register_types_ns3_TimeStepPrecision(module): + root_module = module.get_root() + + +def register_types_ns3_Config(module): + root_module = module.get_root() + + +def register_types_ns3_olsr(module): + root_module = module.get_root() + + +def register_methods(root_module): + register_Ns3RandomVariable_methods(root_module, root_module['ns3::RandomVariable']) + register_Ns3TriangularVariable_methods(root_module, root_module['ns3::TriangularVariable']) + register_Ns3GlobalValue_methods(root_module, root_module['ns3::GlobalValue']) + register_Ns3RefCountBase_methods(root_module, root_module['ns3::RefCountBase']) + register_Ns3TypeId_methods(root_module, root_module['ns3::TypeId']) + register_Ns3TypeIdAttributeInfo_methods(root_module, root_module['ns3::TypeId::AttributeInfo']) + register_Ns3SystemWallClockMs_methods(root_module, root_module['ns3::SystemWallClockMs']) + register_Ns3CallbackImplBase_methods(root_module, root_module['ns3::CallbackImplBase']) + register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor']) + register_Ns3AttributeChecker_methods(root_module, root_module['ns3::AttributeChecker']) + register_Ns3RandomVariableChecker_methods(root_module, root_module['ns3::RandomVariableChecker']) + register_Ns3NormalVariable_methods(root_module, root_module['ns3::NormalVariable']) + register_Ns3ObjectFactory_methods(root_module, root_module['ns3::ObjectFactory']) + register_Ns3AttributeAccessor_methods(root_module, root_module['ns3::AttributeAccessor']) + register_Ns3ParetoVariable_methods(root_module, root_module['ns3::ParetoVariable']) + register_Ns3ConstantVariable_methods(root_module, root_module['ns3::ConstantVariable']) + register_Ns3EmpiricalVariable_methods(root_module, root_module['ns3::EmpiricalVariable']) + register_Ns3EnumChecker_methods(root_module, root_module['ns3::EnumChecker']) + register_Ns3Empty_methods(root_module, root_module['ns3::empty']) + register_Ns3ObjectBase_methods(root_module, root_module['ns3::ObjectBase']) + register_Ns3CommandLine_methods(root_module, root_module['ns3::CommandLine']) + register_Ns3IntToType__6_methods(root_module, root_module['ns3::IntToType< 6 >']) + register_Ns3IntToType__5_methods(root_module, root_module['ns3::IntToType< 5 >']) + register_Ns3IntToType__4_methods(root_module, root_module['ns3::IntToType< 4 >']) + register_Ns3IntToType__3_methods(root_module, root_module['ns3::IntToType< 3 >']) + register_Ns3IntToType__2_methods(root_module, root_module['ns3::IntToType< 2 >']) + register_Ns3IntToType__1_methods(root_module, root_module['ns3::IntToType< 1 >']) + register_Ns3IntToType__0_methods(root_module, root_module['ns3::IntToType< 0 >']) + register_Ns3RngStream_methods(root_module, root_module['ns3::RngStream']) + register_Ns3LogNormalVariable_methods(root_module, root_module['ns3::LogNormalVariable']) + register_Ns3IntEmpiricalVariable_methods(root_module, root_module['ns3::IntEmpiricalVariable']) + register_Ns3PointerChecker_methods(root_module, root_module['ns3::PointerChecker']) + register_Ns3WeibullVariable_methods(root_module, root_module['ns3::WeibullVariable']) + register_Ns3CallbackBase_methods(root_module, root_module['ns3::CallbackBase']) + register_Ns3ExponentialVariable_methods(root_module, root_module['ns3::ExponentialVariable']) + register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Ns3Mac48Address_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::TracedCallback< ns3::Ptr, ns3::Mac48Address, ns3::empty, ns3::empty >']) + register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::TracedCallback< ns3::Ptr, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Ns3Address_const__amp___Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::TracedCallback< ns3::Ptr, ns3::Address const&, ns3::empty, ns3::empty >']) + register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Unsigned_int_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::TracedCallback< ns3::Ptr, unsigned int, ns3::empty, ns3::empty >']) + register_Ns3TracedCallback__Ns3Ptr__lt__ns3MobilityModel_const__gt___Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::TracedCallback< ns3::Ptr, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3TracedCallback__Ns3TimeUnit__lt__1__gt___Ns3TimeUnit__lt__1__gt___Ns3WifiPhyState_Ns3Empty_methods(root_module, root_module['ns3::TracedCallback< ns3::TimeUnit<1>, ns3::TimeUnit<1>, ns3::WifiPhy::State, ns3::empty >']) + register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Ns3WifiMode_Ns3WifiPreamble_Unsigned_char_methods(root_module, root_module['ns3::TracedCallback< ns3::Ptr, ns3::WifiMode, ns3::WifiPreamble, unsigned char >']) + register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Double_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::TracedCallback< ns3::Ptr, double, ns3::empty, ns3::empty >']) + register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Double_Ns3WifiMode_Ns3WifiPreamble_methods(root_module, root_module['ns3::TracedCallback< ns3::Ptr, double, ns3::WifiMode, ns3::WifiPreamble >']) + register_Ns3TracedCallback__Unsigned_int_Unsigned_int_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::TracedCallback< unsigned int, unsigned int, ns3::empty, ns3::empty >']) + register_Ns3DeterministicVariable_methods(root_module, root_module['ns3::DeterministicVariable']) + register_Ns3AttributeList_methods(root_module, root_module['ns3::AttributeList']) + register_Ns3AttributeValue_methods(root_module, root_module['ns3::AttributeValue']) + register_Ns3UniformVariable_methods(root_module, root_module['ns3::UniformVariable']) + register_Ns3Object_methods(root_module, root_module['ns3::Object']) + register_Ns3ObjectAggregateIterator_methods(root_module, root_module['ns3::Object::AggregateIterator']) + register_Ns3SequentialVariable_methods(root_module, root_module['ns3::SequentialVariable']) + register_Ns3ObjectVectorChecker_methods(root_module, root_module['ns3::ObjectVectorChecker']) + register_Ns3StringChecker_methods(root_module, root_module['ns3::StringChecker']) + register_Ns3ObjectVectorValue_methods(root_module, root_module['ns3::ObjectVectorValue']) + register_Ns3BooleanChecker_methods(root_module, root_module['ns3::BooleanChecker']) + register_Ns3UintegerValue_methods(root_module, root_module['ns3::UintegerValue']) + register_Ns3ObjectVectorAccessor_methods(root_module, root_module['ns3::ObjectVectorAccessor']) + register_Ns3PointerValue_methods(root_module, root_module['ns3::PointerValue']) + register_Ns3ObjectFactoryChecker_methods(root_module, root_module['ns3::ObjectFactoryChecker']) + register_Ns3TypeIdChecker_methods(root_module, root_module['ns3::TypeIdChecker']) + register_Ns3DoubleValue_methods(root_module, root_module['ns3::DoubleValue']) + register_Ns3StringValue_methods(root_module, root_module['ns3::StringValue']) + register_Ns3TypeIdValue_methods(root_module, root_module['ns3::TypeIdValue']) + register_Ns3EnumValue_methods(root_module, root_module['ns3::EnumValue']) + register_Ns3RandomVariableValue_methods(root_module, root_module['ns3::RandomVariableValue']) + register_Ns3ObjectFactoryValue_methods(root_module, root_module['ns3::ObjectFactoryValue']) + register_Ns3IntegerValue_methods(root_module, root_module['ns3::IntegerValue']) + register_Ns3EmptyAttributeValue_methods(root_module, root_module['ns3::EmptyAttributeValue']) + register_Ns3BooleanValue_methods(root_module, root_module['ns3::BooleanValue']) + register_Ns3TracedValue__Unsigned_int_methods(root_module, root_module['ns3::TracedValue< unsigned int >']) + return + +def register_Ns3RandomVariable_methods(root_module, cls): + ## random-variable.h: ns3::RandomVariable::RandomVariable() [constructor] + cls.add_constructor([], visibility='public') + ## random-variable.h: ns3::RandomVariable::RandomVariable(ns3::RandomVariable const & o) [copy constructor] + cls.add_constructor([param('ns3::RandomVariable&', 'o', is_const=True)], visibility='public') + ## random-variable.h: uint32_t ns3::RandomVariable::GetInteger() const [member function] + cls.add_method('GetInteger', 'uint32_t', [], is_const=True) + ## random-variable.h: void ns3::RandomVariable::GetSeed(uint32_t * seed) const [member function] + cls.add_method('GetSeed', 'void', [param('uint32_t *', 'seed', direction=2, array_length=6)], is_const=True) + ## random-variable.h: double ns3::RandomVariable::GetValue() const [member function] + cls.add_method('GetValue', 'double', [], is_const=True) + ## random-variable.h: static void ns3::RandomVariable::SetRunNumber(uint32_t n) [member function] + cls.add_method('SetRunNumber', 'void', [param('uint32_t', 'n')], is_static=True) + ## random-variable.h: static void ns3::RandomVariable::UseDevRandom(bool udr=true) [member function] + cls.add_method('UseDevRandom', 'void', [param('bool', 'udr', default_value='true')], is_static=True) + ## random-variable.h: static void ns3::RandomVariable::UseGlobalSeed(uint32_t s0, uint32_t s1, uint32_t s2, uint32_t s3, uint32_t s4, uint32_t s5) [member function] + cls.add_method('UseGlobalSeed', 'void', [param('uint32_t', 's0'), param('uint32_t', 's1'), param('uint32_t', 's2'), param('uint32_t', 's3'), param('uint32_t', 's4'), param('uint32_t', 's5')], is_static=True) + cls.add_output_stream_operator() + return + +def register_Ns3TriangularVariable_methods(root_module, cls): + ## random-variable.h: ns3::TriangularVariable::TriangularVariable() [constructor] + cls.add_constructor([], visibility='public') + ## random-variable.h: ns3::TriangularVariable::TriangularVariable(double s, double l, double mean) [constructor] + cls.add_constructor([param('double', 's'), param('double', 'l'), param('double', 'mean')], visibility='public') + ## random-variable.h: static double ns3::TriangularVariable::GetSingleValue(double s, double l, double mean) [member function] + cls.add_method('GetSingleValue', 'double', [param('double', 's'), param('double', 'l'), param('double', 'mean')], is_static=True) + return + +def register_Ns3GlobalValue_methods(root_module, cls): + ## global-value.h: ns3::GlobalValue::GlobalValue(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr checker) [constructor] + cls.add_constructor([param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue&', 'initialValue', is_const=True), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], visibility='public') + ## global-value.h: std::string ns3::GlobalValue::GetName() const [member function] + cls.add_method('GetName', 'std::string', [], is_const=True) + ## global-value.h: std::string ns3::GlobalValue::GetHelp() const [member function] + cls.add_method('GetHelp', 'std::string', [], is_const=True) + ## global-value.h: void ns3::GlobalValue::GetValue(ns3::AttributeValue & value) const [member function] + cls.add_method('GetValue', 'void', [param('ns3::AttributeValue&', 'value')], is_const=True) + ## global-value.h: ns3::Ptr ns3::GlobalValue::GetChecker() const [member function] + cls.add_method('GetChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [], is_const=True) + ## global-value.h: bool ns3::GlobalValue::SetValue(ns3::AttributeValue const & value) [member function] + cls.add_method('SetValue', 'bool', [param('ns3::AttributeValue&', 'value', is_const=True)]) + ## global-value.h: static void ns3::GlobalValue::Bind(std::string name, ns3::AttributeValue const & value) [member function] + cls.add_method('Bind', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)], is_static=True) + ## global-value.h: static bool ns3::GlobalValue::BindFailSafe(std::string name, ns3::AttributeValue const & value) [member function] + cls.add_method('BindFailSafe', 'bool', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)], is_static=True) + ## global-value.h: static __gnu_cxx::__normal_iterator > > ns3::GlobalValue::Begin() [member function] + cls.add_method('Begin', '__gnu_cxx::__normal_iterator< ns3::GlobalValue* const*, std::vector< ns3::GlobalValue*, std::allocator< ns3::GlobalValue* > > >', [], is_static=True) + ## global-value.h: static __gnu_cxx::__normal_iterator > > ns3::GlobalValue::End() [member function] + cls.add_method('End', '__gnu_cxx::__normal_iterator< ns3::GlobalValue* const*, std::vector< ns3::GlobalValue*, std::allocator< ns3::GlobalValue* > > >', [], is_static=True) + return + +def register_Ns3RefCountBase_methods(root_module, cls): + ## ref-count-base.h: ns3::RefCountBase::RefCountBase() [constructor] + cls.add_constructor([], visibility='public') + ## ref-count-base.h: ns3::RefCountBase::RefCountBase(ns3::RefCountBase const & o) [copy constructor] + cls.add_constructor([param('ns3::RefCountBase&', 'o', is_const=True)], visibility='public') + return + +def register_Ns3TypeId_methods(root_module, cls): + ## type-id.h: ns3::TypeId::TypeId(ns3::TypeId const & arg0) [copy constructor] + cls.add_constructor([param('ns3::TypeId&', 'arg0', is_const=True)], visibility='public') + ## type-id.h: ns3::TypeId::TypeId(char const * name) [constructor] + cls.add_constructor([param('char *', 'name', transfer_ownership=False, is_const=True)], visibility='public') + ## type-id.h: ns3::TypeId::TypeId() [constructor] + cls.add_constructor([], visibility='public') + ## type-id.h: ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker) [member function] + cls.add_method('AddAttribute', 'ns3::TypeId', [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue&', 'initialValue', is_const=True), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')]) + ## type-id.h: ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker) [member function] + cls.add_method('AddAttribute', 'ns3::TypeId', [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue&', 'initialValue', is_const=True), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')]) + ## type-id.h: ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor) [member function] + cls.add_method('AddTraceSource', 'ns3::TypeId', [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')]) + ## type-id.h: ns3::Ptr ns3::TypeId::GetAttributeAccessor(uint32_t i) const [member function] + cls.add_method('GetAttributeAccessor', 'ns3::Ptr< ns3::AttributeAccessor const >', [param('uint32_t', 'i')], is_const=True) + ## type-id.h: ns3::Ptr ns3::TypeId::GetAttributeChecker(uint32_t i) const [member function] + cls.add_method('GetAttributeChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('uint32_t', 'i')], is_const=True) + ## type-id.h: uint32_t ns3::TypeId::GetAttributeFlags(uint32_t i) const [member function] + cls.add_method('GetAttributeFlags', 'uint32_t', [param('uint32_t', 'i')], is_const=True) + ## type-id.h: std::string ns3::TypeId::GetAttributeFullName(uint32_t i) const [member function] + cls.add_method('GetAttributeFullName', 'std::string', [param('uint32_t', 'i')], is_const=True) + ## type-id.h: std::string ns3::TypeId::GetAttributeHelp(uint32_t i) const [member function] + cls.add_method('GetAttributeHelp', 'std::string', [param('uint32_t', 'i')], is_const=True) + ## type-id.h: ns3::Ptr ns3::TypeId::GetAttributeInitialValue(uint32_t i) const [member function] + cls.add_method('GetAttributeInitialValue', 'ns3::Ptr< ns3::AttributeValue const >', [param('uint32_t', 'i')], is_const=True) + ## type-id.h: uint32_t ns3::TypeId::GetAttributeN() const [member function] + cls.add_method('GetAttributeN', 'uint32_t', [], is_const=True) + ## type-id.h: std::string ns3::TypeId::GetAttributeName(uint32_t i) const [member function] + cls.add_method('GetAttributeName', 'std::string', [param('uint32_t', 'i')], is_const=True) + ## type-id.h: ns3::Callback ns3::TypeId::GetConstructor() const [member function] + cls.add_method('GetConstructor', 'ns3::Callback< ns3::ObjectBase*, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', [], is_const=True) + ## type-id.h: std::string ns3::TypeId::GetGroupName() const [member function] + cls.add_method('GetGroupName', 'std::string', [], is_const=True) + ## type-id.h: std::string ns3::TypeId::GetName() const [member function] + cls.add_method('GetName', 'std::string', [], is_const=True) + ## type-id.h: ns3::TypeId ns3::TypeId::GetParent() const [member function] + cls.add_method('GetParent', 'ns3::TypeId', [], is_const=True) + ## type-id.h: static ns3::TypeId ns3::TypeId::GetRegistered(uint32_t i) [member function] + cls.add_method('GetRegistered', 'ns3::TypeId', [param('uint32_t', 'i')], is_static=True) + ## type-id.h: static uint32_t ns3::TypeId::GetRegisteredN() [member function] + cls.add_method('GetRegisteredN', 'uint32_t', [], is_static=True) + ## type-id.h: ns3::Ptr ns3::TypeId::GetTraceSourceAccessor(uint32_t i) const [member function] + cls.add_method('GetTraceSourceAccessor', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('uint32_t', 'i')], is_const=True) + ## type-id.h: std::string ns3::TypeId::GetTraceSourceHelp(uint32_t i) const [member function] + cls.add_method('GetTraceSourceHelp', 'std::string', [param('uint32_t', 'i')], is_const=True) + ## type-id.h: uint32_t ns3::TypeId::GetTraceSourceN() const [member function] + cls.add_method('GetTraceSourceN', 'uint32_t', [], is_const=True) + ## type-id.h: std::string ns3::TypeId::GetTraceSourceName(uint32_t i) const [member function] + cls.add_method('GetTraceSourceName', 'std::string', [param('uint32_t', 'i')], is_const=True) + ## type-id.h: uint16_t ns3::TypeId::GetUid() const [member function] + cls.add_method('GetUid', 'uint16_t', [], is_const=True) + ## type-id.h: bool ns3::TypeId::HasConstructor() const [member function] + cls.add_method('HasConstructor', 'bool', [], is_const=True) + ## type-id.h: bool ns3::TypeId::HasParent() const [member function] + cls.add_method('HasParent', 'bool', [], is_const=True) + ## type-id.h: ns3::TypeId ns3::TypeId::HideFromDocumentation() [member function] + cls.add_method('HideFromDocumentation', 'ns3::TypeId', []) + ## type-id.h: bool ns3::TypeId::IsChildOf(ns3::TypeId other) const [member function] + cls.add_method('IsChildOf', 'bool', [param('ns3::TypeId', 'other')], is_const=True) + ## type-id.h: bool ns3::TypeId::LookupAttributeByName(std::string name, ns3::TypeId::AttributeInfo * info) const [member function] + cls.add_method('LookupAttributeByName', 'bool', [param('std::string', 'name'), param('ns3::TypeId::AttributeInfo *', 'info', transfer_ownership=False)], is_const=True) + ## type-id.h: static ns3::TypeId ns3::TypeId::LookupByName(std::string name) [member function] + cls.add_method('LookupByName', 'ns3::TypeId', [param('std::string', 'name')], is_static=True) + ## type-id.h: static bool ns3::TypeId::LookupByNameFailSafe(std::string name, ns3::TypeId * tid) [member function] + cls.add_method('LookupByNameFailSafe', 'bool', [param('std::string', 'name'), param('ns3::TypeId *', 'tid', transfer_ownership=False)], is_static=True) + ## type-id.h: ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function] + cls.add_method('LookupTraceSourceByName', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('std::string', 'name')], is_const=True) + ## type-id.h: bool ns3::TypeId::MustHideFromDocumentation() const [member function] + cls.add_method('MustHideFromDocumentation', 'bool', [], is_const=True) + ## type-id.h: ns3::TypeId ns3::TypeId::SetGroupName(std::string groupName) [member function] + cls.add_method('SetGroupName', 'ns3::TypeId', [param('std::string', 'groupName')]) + ## type-id.h: ns3::TypeId ns3::TypeId::SetParent(ns3::TypeId tid) [member function] + cls.add_method('SetParent', 'ns3::TypeId', [param('ns3::TypeId', 'tid')]) + ## type-id.h: void ns3::TypeId::SetUid(uint16_t tid) [member function] + cls.add_method('SetUid', 'void', [param('uint16_t', 'tid')]) + cls.add_output_stream_operator() + return + +def register_Ns3TypeIdAttributeInfo_methods(root_module, cls): + ## type-id.h: ns3::TypeId::AttributeInfo::accessor [variable] + cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::AttributeAccessor const >', is_const=False) + ## type-id.h: ns3::TypeId::AttributeInfo::initialValue [variable] + cls.add_instance_attribute('initialValue', 'ns3::Ptr< ns3::AttributeValue const >', is_const=False) + ## type-id.h: ns3::TypeId::AttributeInfo::flags [variable] + cls.add_instance_attribute('flags', 'uint32_t', is_const=False) + ## type-id.h: ns3::TypeId::AttributeInfo::checker [variable] + cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False) + cls.add_constructor([]) + return + +def register_Ns3SystemWallClockMs_methods(root_module, cls): + ## system-wall-clock-ms.h: ns3::SystemWallClockMs::SystemWallClockMs() [constructor] + cls.add_constructor([], visibility='public') + ## system-wall-clock-ms.h: void ns3::SystemWallClockMs::Start() [member function] + cls.add_method('Start', 'void', []) + ## system-wall-clock-ms.h: long long unsigned int ns3::SystemWallClockMs::End() [member function] + cls.add_method('End', 'long long unsigned int', []) + return + +def register_Ns3CallbackImplBase_methods(root_module, cls): + ## callback.h: ns3::CallbackImplBase::CallbackImplBase() [constructor] + cls.add_constructor([], visibility='public') + ## callback.h: bool ns3::CallbackImplBase::IsEqual(ns3::Ptr other) const [member function] + cls.add_method('IsEqual', 'bool', [param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')], is_pure_virtual=True, is_const=True, is_virtual=True) + return + +def register_Ns3TraceSourceAccessor_methods(root_module, cls): + ## trace-source-accessor.h: ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor] + cls.add_constructor([], visibility='public') + ## trace-source-accessor.h: void ns3::TraceSourceAccessor::Ref() const [member function] + cls.add_method('Ref', 'void', [], is_const=True) + ## trace-source-accessor.h: void ns3::TraceSourceAccessor::Unref() const [member function] + cls.add_method('Unref', 'void', [], is_const=True) + ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::ConnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function] + cls.add_method('ConnectWithoutContext', 'bool', [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase&', 'cb', is_const=True)], is_pure_virtual=True, is_const=True, is_virtual=True) + ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::Connect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function] + cls.add_method('Connect', 'bool', [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase&', 'cb', is_const=True)], is_pure_virtual=True, is_const=True, is_virtual=True) + ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::DisconnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function] + cls.add_method('DisconnectWithoutContext', 'bool', [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase&', 'cb', is_const=True)], is_pure_virtual=True, is_const=True, is_virtual=True) + ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::Disconnect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function] + cls.add_method('Disconnect', 'bool', [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase&', 'cb', is_const=True)], is_pure_virtual=True, is_const=True, is_virtual=True) + return + +def register_Ns3AttributeChecker_methods(root_module, cls): + ## attribute.h: ns3::AttributeChecker::AttributeChecker() [constructor] + cls.add_constructor([], visibility='public') + ## attribute.h: bool ns3::AttributeChecker::Check(ns3::AttributeValue const & value) const [member function] + cls.add_method('Check', 'bool', [param('ns3::AttributeValue&', 'value', is_const=True)], is_pure_virtual=True, is_const=True, is_virtual=True) + ## attribute.h: std::string ns3::AttributeChecker::GetValueTypeName() const [member function] + cls.add_method('GetValueTypeName', 'std::string', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## attribute.h: bool ns3::AttributeChecker::HasUnderlyingTypeInformation() const [member function] + cls.add_method('HasUnderlyingTypeInformation', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## attribute.h: std::string ns3::AttributeChecker::GetUnderlyingTypeInformation() const [member function] + cls.add_method('GetUnderlyingTypeInformation', 'std::string', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## attribute.h: ns3::Ptr ns3::AttributeChecker::Create() const [member function] + cls.add_method('Create', 'ns3::Ptr< ns3::AttributeValue >', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## attribute.h: bool ns3::AttributeChecker::Copy(ns3::AttributeValue const & source, ns3::AttributeValue & destination) const [member function] + cls.add_method('Copy', 'bool', [param('ns3::AttributeValue&', 'source', is_const=True), param('ns3::AttributeValue&', 'destination')], is_pure_virtual=True, is_const=True, is_virtual=True) + return + +def register_Ns3RandomVariableChecker_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3NormalVariable_methods(root_module, cls): + ## random-variable.h: ns3::NormalVariable::NormalVariable() [constructor] + cls.add_constructor([], visibility='public') + ## random-variable.h: ns3::NormalVariable::NormalVariable(double m, double v) [constructor] + cls.add_constructor([param('double', 'm'), param('double', 'v')], visibility='public') + ## random-variable.h: ns3::NormalVariable::NormalVariable(double m, double v, double b) [constructor] + cls.add_constructor([param('double', 'm'), param('double', 'v'), param('double', 'b')], visibility='public') + ## random-variable.h: static double ns3::NormalVariable::GetSingleValue(double m, double v) [member function] + cls.add_method('GetSingleValue', 'double', [param('double', 'm'), param('double', 'v')], is_static=True) + ## random-variable.h: static double ns3::NormalVariable::GetSingleValue(double m, double v, double b) [member function] + cls.add_method('GetSingleValue', 'double', [param('double', 'm'), param('double', 'v'), param('double', 'b')], is_static=True) + return + +def register_Ns3ObjectFactory_methods(root_module, cls): + ## object-factory.h: ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [copy constructor] + cls.add_constructor([param('ns3::ObjectFactory&', 'arg0', is_const=True)], visibility='public') + ## object-factory.h: ns3::ObjectFactory::ObjectFactory() [constructor] + cls.add_constructor([], visibility='public') + ## object-factory.h: ns3::Ptr ns3::ObjectFactory::Create() const [member function] + cls.add_method('Create', 'ns3::Ptr< ns3::Object >', [], is_const=True) + ## object-factory.h: ns3::TypeId ns3::ObjectFactory::GetTypeId() const [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_const=True) + ## object-factory.h: void ns3::ObjectFactory::Set(std::string name, ns3::AttributeValue const & value) [member function] + cls.add_method('Set', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)]) + ## object-factory.h: void ns3::ObjectFactory::SetTypeId(ns3::TypeId tid) [member function] + cls.add_method('SetTypeId', 'void', [param('ns3::TypeId', 'tid')]) + ## object-factory.h: void ns3::ObjectFactory::SetTypeId(char const * tid) [member function] + cls.add_method('SetTypeId', 'void', [param('char *', 'tid', transfer_ownership=False, is_const=True)]) + ## object-factory.h: void ns3::ObjectFactory::SetTypeId(std::string tid) [member function] + cls.add_method('SetTypeId', 'void', [param('std::string', 'tid')]) + cls.add_output_stream_operator() + return + +def register_Ns3AttributeAccessor_methods(root_module, cls): + ## attribute.h: ns3::AttributeAccessor::AttributeAccessor() [constructor] + cls.add_constructor([], visibility='public') + ## attribute.h: bool ns3::AttributeAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function] + cls.add_method('Set', 'bool', [param('ns3::ObjectBase *', 'object', transfer_ownership=False), param('ns3::AttributeValue&', 'value', is_const=True)], is_pure_virtual=True, is_const=True, is_virtual=True) + ## attribute.h: bool ns3::AttributeAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & attribute) const [member function] + cls.add_method('Get', 'bool', [param('ns3::ObjectBase *', 'object', transfer_ownership=False, is_const=True), param('ns3::AttributeValue&', 'attribute')], is_pure_virtual=True, is_const=True, is_virtual=True) + ## attribute.h: bool ns3::AttributeAccessor::HasGetter() const [member function] + cls.add_method('HasGetter', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## attribute.h: bool ns3::AttributeAccessor::HasSetter() const [member function] + cls.add_method('HasSetter', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True) + return + +def register_Ns3ParetoVariable_methods(root_module, cls): + ## random-variable.h: ns3::ParetoVariable::ParetoVariable() [constructor] + cls.add_constructor([], visibility='public') + ## random-variable.h: ns3::ParetoVariable::ParetoVariable(double m) [constructor] + cls.add_constructor([param('double', 'm')], visibility='public') + ## random-variable.h: ns3::ParetoVariable::ParetoVariable(double m, double s) [constructor] + cls.add_constructor([param('double', 'm'), param('double', 's')], visibility='public') + ## random-variable.h: ns3::ParetoVariable::ParetoVariable(double m, double s, double b) [constructor] + cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')], visibility='public') + ## random-variable.h: static double ns3::ParetoVariable::GetSingleValue(double m, double s, double b=0) [member function] + cls.add_method('GetSingleValue', 'double', [param('double', 'm'), param('double', 's'), param('double', 'b', default_value='0')], is_static=True) + return + +def register_Ns3ConstantVariable_methods(root_module, cls): + ## random-variable.h: ns3::ConstantVariable::ConstantVariable() [constructor] + cls.add_constructor([], visibility='public') + ## random-variable.h: ns3::ConstantVariable::ConstantVariable(double c) [constructor] + cls.add_constructor([param('double', 'c')], visibility='public') + ## random-variable.h: void ns3::ConstantVariable::SetConstant(double c) [member function] + cls.add_method('SetConstant', 'void', [param('double', 'c')]) + return + +def register_Ns3EmpiricalVariable_methods(root_module, cls): + ## random-variable.h: ns3::EmpiricalVariable::EmpiricalVariable() [constructor] + cls.add_constructor([], visibility='public') + ## random-variable.h: void ns3::EmpiricalVariable::CDF(double v, double c) [member function] + cls.add_method('CDF', 'void', [param('double', 'v'), param('double', 'c')]) + return + +def register_Ns3EnumChecker_methods(root_module, cls): + ## enum.h: ns3::EnumChecker::EnumChecker() [constructor] + cls.add_constructor([], visibility='public') + ## enum.h: void ns3::EnumChecker::AddDefault(int v, std::string name) [member function] + cls.add_method('AddDefault', 'void', [param('int', 'v'), param('std::string', 'name')]) + ## enum.h: void ns3::EnumChecker::Add(int v, std::string name) [member function] + cls.add_method('Add', 'void', [param('int', 'v'), param('std::string', 'name')]) + ## enum.h: bool ns3::EnumChecker::Check(ns3::AttributeValue const & value) const [member function] + cls.add_method('Check', 'bool', [param('ns3::AttributeValue&', 'value', is_const=True)], is_const=True, is_virtual=True) + ## enum.h: std::string ns3::EnumChecker::GetValueTypeName() const [member function] + cls.add_method('GetValueTypeName', 'std::string', [], is_const=True, is_virtual=True) + ## enum.h: bool ns3::EnumChecker::HasUnderlyingTypeInformation() const [member function] + cls.add_method('HasUnderlyingTypeInformation', 'bool', [], is_const=True, is_virtual=True) + ## enum.h: std::string ns3::EnumChecker::GetUnderlyingTypeInformation() const [member function] + cls.add_method('GetUnderlyingTypeInformation', 'std::string', [], is_const=True, is_virtual=True) + ## enum.h: ns3::Ptr ns3::EnumChecker::Create() const [member function] + cls.add_method('Create', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) + ## enum.h: bool ns3::EnumChecker::Copy(ns3::AttributeValue const & src, ns3::AttributeValue & dst) const [member function] + cls.add_method('Copy', 'bool', [param('ns3::AttributeValue&', 'src', is_const=True), param('ns3::AttributeValue&', 'dst')], is_const=True, is_virtual=True) + return + +def register_Ns3Empty_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3ObjectBase_methods(root_module, cls): + ## object-base.h: ns3::ObjectBase::ObjectBase() [constructor] + cls.add_constructor([], visibility='public') + ## object-base.h: ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor] + cls.add_constructor([param('ns3::ObjectBase&', 'arg0', is_const=True)], visibility='public') + ## object-base.h: static ns3::TypeId ns3::ObjectBase::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## object-base.h: ns3::TypeId ns3::ObjectBase::GetInstanceTypeId() const [member function] + cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## object-base.h: void ns3::ObjectBase::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function] + cls.add_method('SetAttribute', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)]) + ## object-base.h: bool ns3::ObjectBase::SetAttributeFailSafe(std::string name, ns3::AttributeValue const & value) [member function] + cls.add_method('SetAttributeFailSafe', 'bool', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)]) + ## object-base.h: void ns3::ObjectBase::GetAttribute(std::string name, ns3::AttributeValue & value) const [member function] + cls.add_method('GetAttribute', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value')], is_const=True) + ## object-base.h: bool ns3::ObjectBase::GetAttributeFailSafe(std::string name, ns3::AttributeValue & attribute) const [member function] + cls.add_method('GetAttributeFailSafe', 'bool', [param('std::string', 'name'), param('ns3::AttributeValue&', 'attribute')], is_const=True) + ## object-base.h: bool ns3::ObjectBase::TraceConnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function] + cls.add_method('TraceConnect', 'bool', [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase&', 'cb', is_const=True)]) + ## object-base.h: bool ns3::ObjectBase::TraceConnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function] + cls.add_method('TraceConnectWithoutContext', 'bool', [param('std::string', 'name'), param('ns3::CallbackBase&', 'cb', is_const=True)]) + ## object-base.h: bool ns3::ObjectBase::TraceDisconnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function] + cls.add_method('TraceDisconnect', 'bool', [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase&', 'cb', is_const=True)]) + ## object-base.h: bool ns3::ObjectBase::TraceDisconnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function] + cls.add_method('TraceDisconnectWithoutContext', 'bool', [param('std::string', 'name'), param('ns3::CallbackBase&', 'cb', is_const=True)]) + ## object-base.h: void ns3::ObjectBase::NotifyConstructionCompleted() [member function] + cls.add_method('NotifyConstructionCompleted', 'void', [], visibility='protected', is_virtual=True) + ## object-base.h: void ns3::ObjectBase::ConstructSelf(ns3::AttributeList const & attributes) [member function] + cls.add_method('ConstructSelf', 'void', [param('ns3::AttributeList&', 'attributes', is_const=True)], visibility='protected') + return + +def register_Ns3CommandLine_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3IntToType__6_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3IntToType__5_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3IntToType__4_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3IntToType__3_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3IntToType__2_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3IntToType__1_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3IntToType__0_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3RngStream_methods(root_module, cls): + ## rng-stream.h: ns3::RngStream::RngStream() [constructor] + cls.add_constructor([], visibility='public') + ## rng-stream.h: ns3::RngStream::RngStream(ns3::RngStream const & arg0) [copy constructor] + cls.add_constructor([param('ns3::RngStream&', 'arg0', is_const=True)], visibility='public') + ## rng-stream.h: void ns3::RngStream::InitializeStream() [member function] + cls.add_method('InitializeStream', 'void', []) + ## rng-stream.h: void ns3::RngStream::ResetStartStream() [member function] + cls.add_method('ResetStartStream', 'void', []) + ## rng-stream.h: void ns3::RngStream::ResetStartSubstream() [member function] + cls.add_method('ResetStartSubstream', 'void', []) + ## rng-stream.h: void ns3::RngStream::ResetNextSubstream() [member function] + cls.add_method('ResetNextSubstream', 'void', []) + ## rng-stream.h: void ns3::RngStream::ResetNthSubstream(uint32_t N) [member function] + cls.add_method('ResetNthSubstream', 'void', [param('uint32_t', 'N')]) + ## rng-stream.h: void ns3::RngStream::SetAntithetic(bool a) [member function] + cls.add_method('SetAntithetic', 'void', [param('bool', 'a')]) + ## rng-stream.h: void ns3::RngStream::IncreasedPrecis(bool incp) [member function] + cls.add_method('IncreasedPrecis', 'void', [param('bool', 'incp')]) + ## rng-stream.h: bool ns3::RngStream::SetSeeds(uint32_t const * seed) [member function] + cls.add_method('SetSeeds', 'bool', [param('uint32_t *', 'seed', transfer_ownership=False, is_const=True)]) + ## rng-stream.h: void ns3::RngStream::AdvanceState(int32_t e, int32_t c) [member function] + cls.add_method('AdvanceState', 'void', [param('int32_t', 'e'), param('int32_t', 'c')]) + ## rng-stream.h: void ns3::RngStream::GetState(uint32_t * seed) const [member function] + cls.add_method('GetState', 'void', [param('uint32_t *', 'seed')], is_const=True) + ## rng-stream.h: double ns3::RngStream::RandU01() [member function] + cls.add_method('RandU01', 'double', []) + ## rng-stream.h: int32_t ns3::RngStream::RandInt(int32_t i, int32_t j) [member function] + cls.add_method('RandInt', 'int32_t', [param('int32_t', 'i'), param('int32_t', 'j')]) + ## rng-stream.h: static bool ns3::RngStream::SetPackageSeed(uint32_t const * seed) [member function] + cls.add_method('SetPackageSeed', 'bool', [param('uint32_t *', 'seed', transfer_ownership=False, is_const=True)], is_static=True) + ## rng-stream.h: static bool ns3::RngStream::CheckSeed(uint32_t const * seed) [member function] + cls.add_method('CheckSeed', 'bool', [param('uint32_t *', 'seed', transfer_ownership=False, is_const=True)], is_static=True) + return + +def register_Ns3LogNormalVariable_methods(root_module, cls): + ## random-variable.h: ns3::LogNormalVariable::LogNormalVariable(double mu, double sigma) [constructor] + cls.add_constructor([param('double', 'mu'), param('double', 'sigma')], visibility='public') + ## random-variable.h: static double ns3::LogNormalVariable::GetSingleValue(double mu, double sigma) [member function] + cls.add_method('GetSingleValue', 'double', [param('double', 'mu'), param('double', 'sigma')], is_static=True) + return + +def register_Ns3IntEmpiricalVariable_methods(root_module, cls): + ## random-variable.h: ns3::IntEmpiricalVariable::IntEmpiricalVariable() [constructor] + cls.add_constructor([], visibility='public') + return + +def register_Ns3PointerChecker_methods(root_module, cls): + ## pointer.h: ns3::TypeId ns3::PointerChecker::GetPointeeTypeId() const [member function] + cls.add_method('GetPointeeTypeId', 'ns3::TypeId', [], is_pure_virtual=True, is_const=True, is_virtual=True) + cls.add_constructor([]) + return + +def register_Ns3WeibullVariable_methods(root_module, cls): + ## random-variable.h: ns3::WeibullVariable::WeibullVariable() [constructor] + cls.add_constructor([], visibility='public') + ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m) [constructor] + cls.add_constructor([param('double', 'm')], visibility='public') + ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m, double s) [constructor] + cls.add_constructor([param('double', 'm'), param('double', 's')], visibility='public') + ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m, double s, double b) [constructor] + cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')], visibility='public') + ## random-variable.h: static double ns3::WeibullVariable::GetSingleValue(double m, double s, double b=0) [member function] + cls.add_method('GetSingleValue', 'double', [param('double', 'm'), param('double', 's'), param('double', 'b', default_value='0')], is_static=True) + return + +def register_Ns3CallbackBase_methods(root_module, cls): + ## callback.h: ns3::CallbackBase::CallbackBase() [constructor] + cls.add_constructor([], visibility='public') + ## callback.h: ns3::Ptr ns3::CallbackBase::GetImpl() const [member function] + cls.add_method('GetImpl', 'ns3::Ptr< ns3::CallbackImplBase >', [], is_const=True) + ## callback.h: ns3::CallbackBase::CallbackBase(ns3::Ptr impl) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::CallbackImplBase >', 'impl')], visibility='protected') + return + +def register_Ns3ExponentialVariable_methods(root_module, cls): + ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable() [constructor] + cls.add_constructor([], visibility='public') + ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(double m) [constructor] + cls.add_constructor([param('double', 'm')], visibility='public') + ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(double m, double b) [constructor] + cls.add_constructor([param('double', 'm'), param('double', 'b')], visibility='public') + ## random-variable.h: static double ns3::ExponentialVariable::GetSingleValue(double m, double b=0) [member function] + cls.add_method('GetSingleValue', 'double', [param('double', 'm'), param('double', 'b', default_value='0')], is_static=True) + return + +def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Ns3Mac48Address_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## traced-callback.h: ns3::TracedCallback, ns3::Mac48Address, ns3::empty, ns3::empty>::TracedCallback() [constructor] + cls.add_constructor([], visibility='public') + ## traced-callback.h: void ns3::TracedCallback, ns3::Mac48Address, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function] + cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)]) + ## traced-callback.h: void ns3::TracedCallback, ns3::Mac48Address, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function] + cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')]) + ## traced-callback.h: void ns3::TracedCallback, ns3::Mac48Address, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function] + cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)]) + ## traced-callback.h: void ns3::TracedCallback, ns3::Mac48Address, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function] + cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')]) + return + +def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## traced-callback.h: ns3::TracedCallback, ns3::empty, ns3::empty, ns3::empty>::TracedCallback() [constructor] + cls.add_constructor([], visibility='public') + ## traced-callback.h: void ns3::TracedCallback, ns3::empty, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function] + cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)]) + ## traced-callback.h: void ns3::TracedCallback, ns3::empty, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function] + cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')]) + ## traced-callback.h: void ns3::TracedCallback, ns3::empty, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function] + cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)]) + ## traced-callback.h: void ns3::TracedCallback, ns3::empty, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function] + cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')]) + return + +def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Ns3Address_const__amp___Ns3Empty_Ns3Empty_methods(root_module, cls): + ## traced-callback.h: ns3::TracedCallback, ns3::Address const&, ns3::empty, ns3::empty>::TracedCallback() [constructor] + cls.add_constructor([], visibility='public') + ## traced-callback.h: void ns3::TracedCallback, ns3::Address const&, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function] + cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)]) + ## traced-callback.h: void ns3::TracedCallback, ns3::Address const&, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function] + cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')]) + ## traced-callback.h: void ns3::TracedCallback, ns3::Address const&, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function] + cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)]) + ## traced-callback.h: void ns3::TracedCallback, ns3::Address const&, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function] + cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')]) + return + +def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Unsigned_int_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## traced-callback.h: ns3::TracedCallback, unsigned int, ns3::empty, ns3::empty>::TracedCallback() [constructor] + cls.add_constructor([], visibility='public') + ## traced-callback.h: void ns3::TracedCallback, unsigned int, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function] + cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)]) + ## traced-callback.h: void ns3::TracedCallback, unsigned int, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function] + cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')]) + ## traced-callback.h: void ns3::TracedCallback, unsigned int, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function] + cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)]) + ## traced-callback.h: void ns3::TracedCallback, unsigned int, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function] + cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')]) + return + +def register_Ns3TracedCallback__Ns3Ptr__lt__ns3MobilityModel_const__gt___Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## traced-callback.h: ns3::TracedCallback, ns3::empty, ns3::empty, ns3::empty>::TracedCallback() [constructor] + cls.add_constructor([], visibility='public') + ## traced-callback.h: void ns3::TracedCallback, ns3::empty, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function] + cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)]) + ## traced-callback.h: void ns3::TracedCallback, ns3::empty, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function] + cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')]) + ## traced-callback.h: void ns3::TracedCallback, ns3::empty, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function] + cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)]) + ## traced-callback.h: void ns3::TracedCallback, ns3::empty, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function] + cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')]) + return + +def register_Ns3TracedCallback__Ns3TimeUnit__lt__1__gt___Ns3TimeUnit__lt__1__gt___Ns3WifiPhyState_Ns3Empty_methods(root_module, cls): + ## traced-callback.h: ns3::TracedCallback, ns3::TimeUnit<1>, ns3::WifiPhy::State, ns3::empty>::TracedCallback() [constructor] + cls.add_constructor([], visibility='public') + ## traced-callback.h: void ns3::TracedCallback, ns3::TimeUnit<1>, ns3::WifiPhy::State, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function] + cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)]) + ## traced-callback.h: void ns3::TracedCallback, ns3::TimeUnit<1>, ns3::WifiPhy::State, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function] + cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')]) + ## traced-callback.h: void ns3::TracedCallback, ns3::TimeUnit<1>, ns3::WifiPhy::State, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function] + cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)]) + ## traced-callback.h: void ns3::TracedCallback, ns3::TimeUnit<1>, ns3::WifiPhy::State, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function] + cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')]) + return + +def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Ns3WifiMode_Ns3WifiPreamble_Unsigned_char_methods(root_module, cls): + ## traced-callback.h: ns3::TracedCallback, ns3::WifiMode, ns3::WifiPreamble, unsigned char>::TracedCallback() [constructor] + cls.add_constructor([], visibility='public') + ## traced-callback.h: void ns3::TracedCallback, ns3::WifiMode, ns3::WifiPreamble, unsigned char>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function] + cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)]) + ## traced-callback.h: void ns3::TracedCallback, ns3::WifiMode, ns3::WifiPreamble, unsigned char>::Connect(ns3::CallbackBase const & callback, std::string path) [member function] + cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')]) + ## traced-callback.h: void ns3::TracedCallback, ns3::WifiMode, ns3::WifiPreamble, unsigned char>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function] + cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)]) + ## traced-callback.h: void ns3::TracedCallback, ns3::WifiMode, ns3::WifiPreamble, unsigned char>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function] + cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')]) + return + +def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Double_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## traced-callback.h: ns3::TracedCallback, double, ns3::empty, ns3::empty>::TracedCallback() [constructor] + cls.add_constructor([], visibility='public') + ## traced-callback.h: void ns3::TracedCallback, double, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function] + cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)]) + ## traced-callback.h: void ns3::TracedCallback, double, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function] + cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')]) + ## traced-callback.h: void ns3::TracedCallback, double, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function] + cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)]) + ## traced-callback.h: void ns3::TracedCallback, double, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function] + cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')]) + return + +def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Double_Ns3WifiMode_Ns3WifiPreamble_methods(root_module, cls): + ## traced-callback.h: ns3::TracedCallback, double, ns3::WifiMode, ns3::WifiPreamble>::TracedCallback() [constructor] + cls.add_constructor([], visibility='public') + ## traced-callback.h: void ns3::TracedCallback, double, ns3::WifiMode, ns3::WifiPreamble>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function] + cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)]) + ## traced-callback.h: void ns3::TracedCallback, double, ns3::WifiMode, ns3::WifiPreamble>::Connect(ns3::CallbackBase const & callback, std::string path) [member function] + cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')]) + ## traced-callback.h: void ns3::TracedCallback, double, ns3::WifiMode, ns3::WifiPreamble>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function] + cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)]) + ## traced-callback.h: void ns3::TracedCallback, double, ns3::WifiMode, ns3::WifiPreamble>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function] + cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')]) + return + +def register_Ns3TracedCallback__Unsigned_int_Unsigned_int_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## traced-callback.h: ns3::TracedCallback::TracedCallback() [constructor] + cls.add_constructor([], visibility='public') + ## traced-callback.h: void ns3::TracedCallback::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function] + cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)]) + ## traced-callback.h: void ns3::TracedCallback::Connect(ns3::CallbackBase const & callback, std::string path) [member function] + cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')]) + ## traced-callback.h: void ns3::TracedCallback::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function] + cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)]) + ## traced-callback.h: void ns3::TracedCallback::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function] + cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')]) + return + +def register_Ns3DeterministicVariable_methods(root_module, cls): + ## random-variable.h: ns3::DeterministicVariable::DeterministicVariable(double * d, uint32_t c) [constructor] + cls.add_constructor([param('double *', 'd'), param('uint32_t', 'c')], visibility='public') + return + +def register_Ns3AttributeList_methods(root_module, cls): + ## attribute-list.h: ns3::AttributeList::AttributeList() [constructor] + cls.add_constructor([], visibility='public') + ## attribute-list.h: ns3::AttributeList::AttributeList(ns3::AttributeList const & o) [copy constructor] + cls.add_constructor([param('ns3::AttributeList&', 'o', is_const=True)], visibility='public') + ## attribute-list.h: void ns3::AttributeList::Set(std::string name, ns3::AttributeValue const & value) [member function] + cls.add_method('Set', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)]) + ## attribute-list.h: bool ns3::AttributeList::SetFailSafe(std::string name, ns3::AttributeValue const & value) [member function] + cls.add_method('SetFailSafe', 'bool', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)]) + ## attribute-list.h: void ns3::AttributeList::SetWithTid(ns3::TypeId tid, std::string name, ns3::AttributeValue const & value) [member function] + cls.add_method('SetWithTid', 'void', [param('ns3::TypeId', 'tid'), param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)]) + ## attribute-list.h: void ns3::AttributeList::Reset() [member function] + cls.add_method('Reset', 'void', []) + ## attribute-list.h: static ns3::AttributeList * ns3::AttributeList::GetGlobal() [member function] + cls.add_method('GetGlobal', 'ns3::AttributeList *', [], is_static=True) + ## attribute-list.h: std::string ns3::AttributeList::SerializeToString() const [member function] + cls.add_method('SerializeToString', 'std::string', [], is_const=True) + ## attribute-list.h: bool ns3::AttributeList::DeserializeFromString(std::string value) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value')]) + return + +def register_Ns3AttributeValue_methods(root_module, cls): + ## attribute.h: ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [copy constructor] + cls.add_constructor([param('ns3::AttributeValue&', 'arg0', is_const=True)], visibility='public') + ## attribute.h: ns3::AttributeValue::AttributeValue() [constructor] + cls.add_constructor([], visibility='public') + ## attribute.h: ns3::Ptr ns3::AttributeValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## attribute.h: std::string ns3::AttributeValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_pure_virtual=True, is_const=True, is_virtual=True) + ## attribute.h: bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_pure_virtual=True, is_virtual=True) + return + +def register_Ns3UniformVariable_methods(root_module, cls): + ## random-variable.h: ns3::UniformVariable::UniformVariable() [constructor] + cls.add_constructor([], visibility='public') + ## random-variable.h: ns3::UniformVariable::UniformVariable(double s, double l) [constructor] + cls.add_constructor([param('double', 's'), param('double', 'l')], visibility='public') + ## random-variable.h: static double ns3::UniformVariable::GetSingleValue(double s, double l) [member function] + cls.add_method('GetSingleValue', 'double', [param('double', 's'), param('double', 'l')], is_static=True) + return + +def register_Ns3Object_methods(root_module, cls): + ## object.h: static ns3::TypeId ns3::Object::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## object.h: ns3::Object::Object() [constructor] + cls.add_constructor([], visibility='public') + ## object.h: ns3::TypeId ns3::Object::GetInstanceTypeId() const [member function] + cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True) + ## object.h: ns3::Ptr ns3::Object::GetObject(ns3::TypeId tid) const [member function] + cls.add_method('GetObject', 'ns3::Ptr< ns3::Object >', [param('ns3::TypeId', 'tid')], is_const=True, template_parameters=['ns3::Object'], custom_template_method_name='GetObject') + ## object.h: void ns3::Object::Dispose() [member function] + cls.add_method('Dispose', 'void', []) + ## object.h: void ns3::Object::AggregateObject(ns3::Ptr other) [member function] + cls.add_method('AggregateObject', 'void', [param('ns3::Ptr< ns3::Object >', 'other')]) + ## object.h: ns3::Object::AggregateIterator ns3::Object::GetAggregateIterator() const [member function] + cls.add_method('GetAggregateIterator', 'ns3::Object::AggregateIterator', [], is_const=True) + ## object.h: void ns3::Object::DoDispose() [member function] + cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True) + ## object.h: ns3::Object::Object(ns3::Object const & o) [copy constructor] + cls.add_constructor([param('ns3::Object&', 'o', is_const=True)], visibility='protected') + return + +def register_Ns3ObjectAggregateIterator_methods(root_module, cls): + ## object.h: ns3::Object::AggregateIterator::AggregateIterator() [constructor] + cls.add_constructor([], visibility='public') + ## object.h: bool ns3::Object::AggregateIterator::HasNext() const [member function] + cls.add_method('HasNext', 'bool', [], is_const=True) + ## object.h: ns3::Ptr ns3::Object::AggregateIterator::Next() [member function] + cls.add_method('Next', 'ns3::Ptr< ns3::Object const >', []) + return + +def register_Ns3SequentialVariable_methods(root_module, cls): + ## random-variable.h: ns3::SequentialVariable::SequentialVariable(double f, double l, double i=1, uint32_t c=1) [constructor] + cls.add_constructor([param('double', 'f'), param('double', 'l'), param('double', 'i', default_value='1'), param('uint32_t', 'c', default_value='1')], visibility='public') + ## random-variable.h: ns3::SequentialVariable::SequentialVariable(double f, double l, ns3::RandomVariable const & i, uint32_t c=1) [constructor] + cls.add_constructor([param('double', 'f'), param('double', 'l'), param('ns3::RandomVariable&', 'i', is_const=True), param('uint32_t', 'c', default_value='1')], visibility='public') + return + +def register_Ns3ObjectVectorChecker_methods(root_module, cls): + ## object-vector.h: ns3::TypeId ns3::ObjectVectorChecker::GetItemTypeId() const [member function] + cls.add_method('GetItemTypeId', 'ns3::TypeId', [], is_pure_virtual=True, is_const=True, is_virtual=True) + cls.add_constructor([]) + return + +def register_Ns3StringChecker_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3ObjectVectorValue_methods(root_module, cls): + ## object-vector.h: ns3::ObjectVectorValue::ObjectVectorValue() [constructor] + cls.add_constructor([], visibility='public') + ## object-vector.h: __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::ObjectVectorValue::Begin() const [member function] + cls.add_method('Begin', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Object >, std::vector< ns3::Ptr< ns3::Object >, std::allocator< ns3::Ptr< ns3::Object > > > >', [], is_const=True) + ## object-vector.h: __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::ObjectVectorValue::End() const [member function] + cls.add_method('End', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Object >, std::vector< ns3::Ptr< ns3::Object >, std::allocator< ns3::Ptr< ns3::Object > > > >', [], is_const=True) + ## object-vector.h: uint32_t ns3::ObjectVectorValue::GetN() const [member function] + cls.add_method('GetN', 'uint32_t', [], is_const=True) + ## object-vector.h: ns3::Ptr ns3::ObjectVectorValue::Get(uint32_t i) const [member function] + cls.add_method('Get', 'ns3::Ptr< ns3::Object >', [param('uint32_t', 'i')], is_const=True) + ## object-vector.h: ns3::Ptr ns3::ObjectVectorValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) + ## object-vector.h: std::string ns3::ObjectVectorValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True) + ## object-vector.h: bool ns3::ObjectVectorValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) + return + +def register_Ns3BooleanChecker_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3UintegerValue_methods(root_module, cls): + ## uinteger.h: ns3::UintegerValue::UintegerValue() [constructor] + cls.add_constructor([], visibility='public') + ## uinteger.h: ns3::UintegerValue::UintegerValue(uint64_t const & value) [constructor] + cls.add_constructor([param('uint64_t&', 'value', is_const=True)], visibility='public') + ## uinteger.h: void ns3::UintegerValue::Set(uint64_t const & value) [member function] + cls.add_method('Set', 'void', [param('uint64_t&', 'value', is_const=True)]) + ## uinteger.h: uint64_t ns3::UintegerValue::Get() const [member function] + cls.add_method('Get', 'uint64_t', [], is_const=True) + ## uinteger.h: ns3::Ptr ns3::UintegerValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) + ## uinteger.h: std::string ns3::UintegerValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True) + ## uinteger.h: bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) + return + +def register_Ns3ObjectVectorAccessor_methods(root_module, cls): + ## object-vector.h: bool ns3::ObjectVectorAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function] + cls.add_method('Set', 'bool', [param('ns3::ObjectBase *', 'object'), param('ns3::AttributeValue&', 'value', is_const=True)], is_const=True, is_virtual=True) + ## object-vector.h: bool ns3::ObjectVectorAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & value) const [member function] + cls.add_method('Get', 'bool', [param('ns3::ObjectBase *', 'object', transfer_ownership=False, is_const=True), param('ns3::AttributeValue&', 'value')], is_const=True, is_virtual=True) + ## object-vector.h: bool ns3::ObjectVectorAccessor::HasGetter() const [member function] + cls.add_method('HasGetter', 'bool', [], is_const=True, is_virtual=True) + ## object-vector.h: bool ns3::ObjectVectorAccessor::HasSetter() const [member function] + cls.add_method('HasSetter', 'bool', [], is_const=True, is_virtual=True) + ## object-vector.h: bool ns3::ObjectVectorAccessor::DoGetN(ns3::ObjectBase const * object, uint32_t * n) const [member function] + cls.add_method('DoGetN', 'bool', [param('ns3::ObjectBase *', 'object', transfer_ownership=False, is_const=True), param('uint32_t *', 'n')], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + ## object-vector.h: ns3::Ptr ns3::ObjectVectorAccessor::DoGet(ns3::ObjectBase const * object, uint32_t i) const [member function] + cls.add_method('DoGet', 'ns3::Ptr< ns3::Object >', [param('ns3::ObjectBase *', 'object', transfer_ownership=False, is_const=True), param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + cls.add_constructor([]) + return + +def register_Ns3PointerValue_methods(root_module, cls): + ## pointer.h: ns3::PointerValue::PointerValue(ns3::PointerValue const & arg0) [copy constructor] + cls.add_constructor([param('ns3::PointerValue&', 'arg0', is_const=True)], visibility='public') + ## pointer.h: ns3::PointerValue::PointerValue() [constructor] + cls.add_constructor([], visibility='public') + ## pointer.h: ns3::PointerValue::PointerValue(ns3::Ptr object) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::Object >', 'object')], visibility='public') + ## pointer.h: void ns3::PointerValue::SetObject(ns3::Ptr object) [member function] + cls.add_method('SetObject', 'void', [param('ns3::Ptr< ns3::Object >', 'object')]) + ## pointer.h: ns3::Ptr ns3::PointerValue::GetObject() const [member function] + cls.add_method('GetObject', 'ns3::Ptr< ns3::Object >', [], is_const=True) + ## pointer.h: ns3::Ptr ns3::PointerValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) + ## pointer.h: std::string ns3::PointerValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True) + ## pointer.h: bool ns3::PointerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) + return + +def register_Ns3ObjectFactoryChecker_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3TypeIdChecker_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3DoubleValue_methods(root_module, cls): + ## double.h: ns3::DoubleValue::DoubleValue() [constructor] + cls.add_constructor([], visibility='public') + ## double.h: ns3::DoubleValue::DoubleValue(double const & value) [constructor] + cls.add_constructor([param('double&', 'value', is_const=True)], visibility='public') + ## double.h: void ns3::DoubleValue::Set(double const & value) [member function] + cls.add_method('Set', 'void', [param('double&', 'value', is_const=True)]) + ## double.h: double ns3::DoubleValue::Get() const [member function] + cls.add_method('Get', 'double', [], is_const=True) + ## double.h: ns3::Ptr ns3::DoubleValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) + ## double.h: std::string ns3::DoubleValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True) + ## double.h: bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) + return + +def register_Ns3StringValue_methods(root_module, cls): + ## string.h: ns3::StringValue::StringValue() [constructor] + cls.add_constructor([], visibility='public') + ## string.h: ns3::StringValue::StringValue(std::string const & value) [constructor] + cls.add_constructor([param('std::string&', 'value', is_const=True)], visibility='public') + ## string.h: void ns3::StringValue::Set(std::string const & value) [member function] + cls.add_method('Set', 'void', [param('std::string&', 'value', is_const=True)]) + ## string.h: std::string ns3::StringValue::Get() const [member function] + cls.add_method('Get', 'std::string', [], is_const=True) + ## string.h: ns3::Ptr ns3::StringValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) + ## string.h: std::string ns3::StringValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True) + ## string.h: bool ns3::StringValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) + return + +def register_Ns3TypeIdValue_methods(root_module, cls): + ## type-id.h: ns3::TypeIdValue::TypeIdValue() [constructor] + cls.add_constructor([], visibility='public') + ## type-id.h: ns3::TypeIdValue::TypeIdValue(ns3::TypeId const & value) [constructor] + cls.add_constructor([param('ns3::TypeId&', 'value', is_const=True)], visibility='public') + ## type-id.h: void ns3::TypeIdValue::Set(ns3::TypeId const & value) [member function] + cls.add_method('Set', 'void', [param('ns3::TypeId&', 'value', is_const=True)]) + ## type-id.h: ns3::TypeId ns3::TypeIdValue::Get() const [member function] + cls.add_method('Get', 'ns3::TypeId', [], is_const=True) + ## type-id.h: ns3::Ptr ns3::TypeIdValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) + ## type-id.h: std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True) + ## type-id.h: bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) + return + +def register_Ns3EnumValue_methods(root_module, cls): + ## enum.h: ns3::EnumValue::EnumValue() [constructor] + cls.add_constructor([], visibility='public') + ## enum.h: ns3::EnumValue::EnumValue(int v) [constructor] + cls.add_constructor([param('int', 'v')], visibility='public') + ## enum.h: void ns3::EnumValue::Set(int v) [member function] + cls.add_method('Set', 'void', [param('int', 'v')]) + ## enum.h: int ns3::EnumValue::Get() const [member function] + cls.add_method('Get', 'int', [], is_const=True) + ## enum.h: ns3::Ptr ns3::EnumValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) + ## enum.h: std::string ns3::EnumValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True) + ## enum.h: bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) + return + +def register_Ns3RandomVariableValue_methods(root_module, cls): + ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue() [constructor] + cls.add_constructor([], visibility='public') + ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue(ns3::RandomVariable const & value) [constructor] + cls.add_constructor([param('ns3::RandomVariable&', 'value', is_const=True)], visibility='public') + ## random-variable.h: void ns3::RandomVariableValue::Set(ns3::RandomVariable const & value) [member function] + cls.add_method('Set', 'void', [param('ns3::RandomVariable&', 'value', is_const=True)]) + ## random-variable.h: ns3::RandomVariable ns3::RandomVariableValue::Get() const [member function] + cls.add_method('Get', 'ns3::RandomVariable', [], is_const=True) + ## random-variable.h: ns3::Ptr ns3::RandomVariableValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) + ## random-variable.h: std::string ns3::RandomVariableValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True) + ## random-variable.h: bool ns3::RandomVariableValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) + return + +def register_Ns3ObjectFactoryValue_methods(root_module, cls): + ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue() [constructor] + cls.add_constructor([], visibility='public') + ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactory const & value) [constructor] + cls.add_constructor([param('ns3::ObjectFactory&', 'value', is_const=True)], visibility='public') + ## object-factory.h: void ns3::ObjectFactoryValue::Set(ns3::ObjectFactory const & value) [member function] + cls.add_method('Set', 'void', [param('ns3::ObjectFactory&', 'value', is_const=True)]) + ## object-factory.h: ns3::ObjectFactory ns3::ObjectFactoryValue::Get() const [member function] + cls.add_method('Get', 'ns3::ObjectFactory', [], is_const=True) + ## object-factory.h: ns3::Ptr ns3::ObjectFactoryValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) + ## object-factory.h: std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True) + ## object-factory.h: bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) + return + +def register_Ns3IntegerValue_methods(root_module, cls): + ## integer.h: ns3::IntegerValue::IntegerValue() [constructor] + cls.add_constructor([], visibility='public') + ## integer.h: ns3::IntegerValue::IntegerValue(int64_t const & value) [constructor] + cls.add_constructor([param('int64_t&', 'value', is_const=True)], visibility='public') + ## integer.h: void ns3::IntegerValue::Set(int64_t const & value) [member function] + cls.add_method('Set', 'void', [param('int64_t&', 'value', is_const=True)]) + ## integer.h: int64_t ns3::IntegerValue::Get() const [member function] + cls.add_method('Get', 'int64_t', [], is_const=True) + ## integer.h: ns3::Ptr ns3::IntegerValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) + ## integer.h: std::string ns3::IntegerValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True) + ## integer.h: bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) + return + +def register_Ns3EmptyAttributeValue_methods(root_module, cls): + ## attribute.h: ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [copy constructor] + cls.add_constructor([param('ns3::EmptyAttributeValue&', 'arg0', is_const=True)], visibility='public') + ## attribute.h: ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor] + cls.add_constructor([], visibility='public') + ## attribute.h: ns3::Ptr ns3::EmptyAttributeValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, visibility='private', is_virtual=True) + ## attribute.h: std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, visibility='private', is_virtual=True) + ## attribute.h: bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], visibility='private', is_virtual=True) + return + +def register_Ns3BooleanValue_methods(root_module, cls): + ## boolean.h: ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [copy constructor] + cls.add_constructor([param('ns3::BooleanValue&', 'arg0', is_const=True)], visibility='public') + ## boolean.h: ns3::BooleanValue::BooleanValue() [constructor] + cls.add_constructor([], visibility='public') + ## boolean.h: ns3::BooleanValue::BooleanValue(bool value) [constructor] + cls.add_constructor([param('bool', 'value')], visibility='public') + ## boolean.h: ns3::Ptr ns3::BooleanValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) + ## boolean.h: bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) + ## boolean.h: bool ns3::BooleanValue::Get() const [member function] + cls.add_method('Get', 'bool', [], is_const=True) + ## boolean.h: std::string ns3::BooleanValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True) + ## boolean.h: void ns3::BooleanValue::Set(bool value) [member function] + cls.add_method('Set', 'void', [param('bool', 'value')]) + cls.add_output_stream_operator() + return + +def register_Ns3TracedValue__Unsigned_int_methods(root_module, cls): + ## traced-value.h: ns3::TracedValue::TracedValue() [constructor] + cls.add_constructor([], visibility='public') + ## traced-value.h: ns3::TracedValue::TracedValue(ns3::TracedValue const & o) [copy constructor] + cls.add_constructor([param('ns3::TracedValue< unsigned int >&', 'o', is_const=True)], visibility='public') + ## traced-value.h: ns3::TracedValue::TracedValue(unsigned int const & v) [constructor] + cls.add_constructor([param('unsigned int&', 'v', is_const=True)], visibility='public') + ## traced-value.h: ns3::TracedValue::TracedValue(ns3::IntegerValue const & value) [constructor] + cls.add_constructor([param('ns3::IntegerValue&', 'value', is_const=True)], visibility='public') + ## traced-value.h: ns3::TracedValue::TracedValue(ns3::UintegerValue const & value) [constructor] + cls.add_constructor([param('ns3::UintegerValue&', 'value', is_const=True)], visibility='public') + ## traced-value.h: ns3::TracedValue::TracedValue(ns3::BooleanValue const & value) [constructor] + cls.add_constructor([param('ns3::BooleanValue&', 'value', is_const=True)], visibility='public') + ## traced-value.h: ns3::TracedValue::TracedValue(ns3::EnumValue const & value) [constructor] + cls.add_constructor([param('ns3::EnumValue&', 'value', is_const=True)], visibility='public') + ## traced-value.h: void ns3::TracedValue::ConnectWithoutContext(ns3::CallbackBase const & cb) [member function] + cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'cb', is_const=True)]) + ## traced-value.h: void ns3::TracedValue::Connect(ns3::CallbackBase const & cb, std::string path) [member function] + cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'cb', is_const=True), param('std::string', 'path')]) + ## traced-value.h: void ns3::TracedValue::DisconnectWithoutContext(ns3::CallbackBase const & cb) [member function] + cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'cb', is_const=True)]) + ## traced-value.h: void ns3::TracedValue::Disconnect(ns3::CallbackBase const & cb, std::string path) [member function] + cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'cb', is_const=True), param('std::string', 'path')]) + ## traced-value.h: void ns3::TracedValue::Set(unsigned int const & v) [member function] + cls.add_method('Set', 'void', [param('unsigned int&', 'v', is_const=True)]) + ## traced-value.h: unsigned int ns3::TracedValue::Get() const [member function] + cls.add_method('Get', 'unsigned int', [], is_const=True) + return + +def register_functions(root_module): + module = root_module + ## boolean.h: extern ns3::Ptr ns3::MakeBooleanChecker() [free function] + module.add_function('MakeBooleanChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) + ## type-name.h: extern std::string ns3::TypeNameGet() [free function] + module.add_function('TypeNameGet', 'std::string', [], template_parameters=['double']) + ## type-name.h: extern std::string ns3::TypeNameGet() [free function] + module.add_function('TypeNameGet', 'std::string', [], template_parameters=['float']) + ## type-name.h: extern std::string ns3::TypeNameGet() [free function] + module.add_function('TypeNameGet', 'std::string', [], template_parameters=['long']) + ## type-name.h: extern std::string ns3::TypeNameGet() [free function] + module.add_function('TypeNameGet', 'std::string', [], template_parameters=['int']) + ## type-name.h: extern std::string ns3::TypeNameGet() [free function] + module.add_function('TypeNameGet', 'std::string', [], template_parameters=['short']) + ## type-name.h: extern std::string ns3::TypeNameGet() [free function] + module.add_function('TypeNameGet', 'std::string', [], template_parameters=['signed char']) + ## type-name.h: extern std::string ns3::TypeNameGet() [free function] + module.add_function('TypeNameGet', 'std::string', [], template_parameters=['unsigned long']) + ## type-name.h: extern std::string ns3::TypeNameGet() [free function] + module.add_function('TypeNameGet', 'std::string', [], template_parameters=['unsigned int']) + ## type-name.h: extern std::string ns3::TypeNameGet() [free function] + module.add_function('TypeNameGet', 'std::string', [], template_parameters=['unsigned short']) + ## type-name.h: extern std::string ns3::TypeNameGet() [free function] + module.add_function('TypeNameGet', 'std::string', [], template_parameters=['unsigned char']) + ## string.h: extern ns3::Ptr ns3::MakeStringChecker() [free function] + module.add_function('MakeStringChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) + ## enum.h: extern ns3::Ptr ns3::MakeEnumChecker(int v1, std::string n1, int v2=0, std::string n2="", int v3=0, std::string n3="", int v4=0, std::string n4="", int v5=0, std::string n5="", int v6=0, std::string n6="", int v7=0, std::string n7="", int v8=0, std::string n8="", int v9=0, std::string n9="", int v10=0, std::string n10="", int v11=0, std::string n11="", int v12=0, std::string n12="") [free function] + module.add_function('MakeEnumChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('int', 'v1'), param('std::string', 'n1'), param('int', 'v2', default_value='0'), param('std::string', 'n2', default_value='""'), param('int', 'v3', default_value='0'), param('std::string', 'n3', default_value='""'), param('int', 'v4', default_value='0'), param('std::string', 'n4', default_value='""'), param('int', 'v5', default_value='0'), param('std::string', 'n5', default_value='""'), param('int', 'v6', default_value='0'), param('std::string', 'n6', default_value='""'), param('int', 'v7', default_value='0'), param('std::string', 'n7', default_value='""'), param('int', 'v8', default_value='0'), param('std::string', 'n8', default_value='""'), param('int', 'v9', default_value='0'), param('std::string', 'n9', default_value='""'), param('int', 'v10', default_value='0'), param('std::string', 'n10', default_value='""'), param('int', 'v11', default_value='0'), param('std::string', 'n11', default_value='""'), param('int', 'v12', default_value='0'), param('std::string', 'n12', default_value='""')]) + ## type-id.h: extern ns3::Ptr ns3::MakeTypeIdChecker() [free function] + module.add_function('MakeTypeIdChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) + ## ptr.h: extern ns3::Ptr ns3::Create() [free function] + module.add_function('Create', 'ns3::Ptr< ns3::PointerValue >', [], template_parameters=['ns3::PointerValue']) + ## ptr.h: extern ns3::Ptr ns3::Create() [free function] + module.add_function('Create', 'ns3::Ptr< ns3::ObjectVectorValue >', [], template_parameters=['ns3::ObjectVectorValue']) + ## object-factory.h: extern ns3::Ptr ns3::MakeObjectFactoryChecker() [free function] + module.add_function('MakeObjectFactoryChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) + ## breakpoint.h: extern void ns3::BreakpointFallback() [free function] + module.add_function('BreakpointFallback', 'void', []) + ## random-variable.h: extern ns3::Ptr ns3::MakeRandomVariableChecker() [free function] + module.add_function('MakeRandomVariableChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) + register_functions_ns3_internal(module.get_submodule('internal'), root_module) + register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module) + register_functions_ns3_Config(module.get_submodule('Config'), root_module) + register_functions_ns3_olsr(module.get_submodule('olsr'), root_module) + return + +def register_functions_ns3_internal(module, root_module): + ## uinteger.h: extern ns3::Ptr ns3::internal::MakeUintegerChecker(uint64_t min, uint64_t max, std::string name) [free function] + module.add_function('MakeUintegerChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('uint64_t', 'min'), param('uint64_t', 'max'), param('std::string', 'name')]) + ## integer.h: extern ns3::Ptr ns3::internal::MakeIntegerChecker(int64_t min, int64_t max, std::string name) [free function] + module.add_function('MakeIntegerChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('int64_t', 'min'), param('int64_t', 'max'), param('std::string', 'name')]) + ## double.h: extern ns3::Ptr ns3::internal::MakeDoubleChecker(double min, double max, std::string name) [free function] + module.add_function('MakeDoubleChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('double', 'min'), param('double', 'max'), param('std::string', 'name')]) + return + +def register_functions_ns3_TimeStepPrecision(module, root_module): + return + +def register_functions_ns3_Config(module, root_module): + ## config.h: extern bool ns3::Config::SetDefaultFailSafe(std::string name, ns3::AttributeValue const & value) [free function] + module.add_function('SetDefaultFailSafe', 'bool', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)]) + ## config.h: extern void ns3::Config::DisconnectWithoutContext(std::string path, ns3::CallbackBase const & cb) [free function] + module.add_function('DisconnectWithoutContext', 'void', [param('std::string', 'path'), param('ns3::CallbackBase&', 'cb', is_const=True)]) + ## config.h: extern void ns3::Config::SetDefault(std::string name, ns3::AttributeValue const & value) [free function] + module.add_function('SetDefault', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)]) + ## config.h: extern void ns3::Config::Connect(std::string path, ns3::CallbackBase const & cb) [free function] + module.add_function('Connect', 'void', [param('std::string', 'path'), param('ns3::CallbackBase&', 'cb', is_const=True)]) + ## config.h: extern ns3::Ptr ns3::Config::GetRootNamespaceObject(uint32_t i) [free function] + module.add_function('GetRootNamespaceObject', 'ns3::Ptr< ns3::Object >', [param('uint32_t', 'i')]) + ## config.h: extern void ns3::Config::ConnectWithoutContext(std::string path, ns3::CallbackBase const & cb) [free function] + module.add_function('ConnectWithoutContext', 'void', [param('std::string', 'path'), param('ns3::CallbackBase&', 'cb', is_const=True)]) + ## config.h: extern void ns3::Config::UnregisterRootNamespaceObject(ns3::Ptr obj) [free function] + module.add_function('UnregisterRootNamespaceObject', 'void', [param('ns3::Ptr< ns3::Object >', 'obj')]) + ## config.h: extern bool ns3::Config::SetGlobalFailSafe(std::string name, ns3::AttributeValue const & value) [free function] + module.add_function('SetGlobalFailSafe', 'bool', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)]) + ## config.h: extern uint32_t ns3::Config::GetRootNamespaceObjectN() [free function] + module.add_function('GetRootNamespaceObjectN', 'uint32_t', []) + ## config.h: extern void ns3::Config::Set(std::string path, ns3::AttributeValue const & value) [free function] + module.add_function('Set', 'void', [param('std::string', 'path'), param('ns3::AttributeValue&', 'value', is_const=True)]) + ## config.h: extern void ns3::Config::SetGlobal(std::string name, ns3::AttributeValue const & value) [free function] + module.add_function('SetGlobal', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)]) + ## config.h: extern void ns3::Config::RegisterRootNamespaceObject(ns3::Ptr obj) [free function] + module.add_function('RegisterRootNamespaceObject', 'void', [param('ns3::Ptr< ns3::Object >', 'obj')]) + ## config.h: extern void ns3::Config::Disconnect(std::string path, ns3::CallbackBase const & cb) [free function] + module.add_function('Disconnect', 'void', [param('std::string', 'path'), param('ns3::CallbackBase&', 'cb', is_const=True)]) + return + +def register_functions_ns3_olsr(module, root_module): + return + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/ns3_module_csma.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/ns3_module_csma.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,245 @@ +from pybindgen import Module, FileCodeSink, write_preamble, param, retval + +def register_types(module): + root_module = module.get_root() + + ## csma-channel.h: ns3::WireState [enumeration] + module.add_enum('WireState', ['IDLE', 'TRANSMITTING', 'PROPAGATING']) + ## csma-channel.h: ns3::CsmaDeviceRec [class] + module.add_class('CsmaDeviceRec') + ## backoff.h: ns3::Backoff [class] + module.add_class('Backoff') + ## csma-channel.h: ns3::CsmaChannel [class] + module.add_class('CsmaChannel', allow_subclassing=True, parent=root_module['ns3::Channel']) + ## csma-net-device.h: ns3::CsmaNetDevice [class] + module.add_class('CsmaNetDevice', allow_subclassing=True, parent=root_module['ns3::NetDevice']) + ## csma-net-device.h: ns3::CsmaNetDevice::CsmaEncapsulationMode [enumeration] + module.add_enum('CsmaEncapsulationMode', ['ETHERNET_V1', 'IP_ARP', 'RAW', 'LLC'], outer_class=root_module['ns3::CsmaNetDevice']) + + ## Register a nested module for the namespace internal + + nested_module = module.add_cpp_namespace('internal') + register_types_ns3_internal(nested_module) + + + ## Register a nested module for the namespace TimeStepPrecision + + nested_module = module.add_cpp_namespace('TimeStepPrecision') + register_types_ns3_TimeStepPrecision(nested_module) + + + ## Register a nested module for the namespace Config + + nested_module = module.add_cpp_namespace('Config') + register_types_ns3_Config(nested_module) + + + ## Register a nested module for the namespace olsr + + nested_module = module.add_cpp_namespace('olsr') + register_types_ns3_olsr(nested_module) + + +def register_types_ns3_internal(module): + root_module = module.get_root() + + +def register_types_ns3_TimeStepPrecision(module): + root_module = module.get_root() + + +def register_types_ns3_Config(module): + root_module = module.get_root() + + +def register_types_ns3_olsr(module): + root_module = module.get_root() + + +def register_methods(root_module): + register_Ns3CsmaDeviceRec_methods(root_module, root_module['ns3::CsmaDeviceRec']) + register_Ns3Backoff_methods(root_module, root_module['ns3::Backoff']) + register_Ns3CsmaChannel_methods(root_module, root_module['ns3::CsmaChannel']) + register_Ns3CsmaNetDevice_methods(root_module, root_module['ns3::CsmaNetDevice']) + return + +def register_Ns3CsmaDeviceRec_methods(root_module, cls): + ## csma-channel.h: ns3::CsmaDeviceRec::devicePtr [variable] + cls.add_instance_attribute('devicePtr', 'ns3::Ptr< ns3::CsmaNetDevice >', is_const=False) + ## csma-channel.h: ns3::CsmaDeviceRec::active [variable] + cls.add_instance_attribute('active', 'bool', is_const=False) + ## csma-channel.h: ns3::CsmaDeviceRec::CsmaDeviceRec() [constructor] + cls.add_constructor([], visibility='public') + ## csma-channel.h: ns3::CsmaDeviceRec::CsmaDeviceRec(ns3::Ptr device) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::CsmaNetDevice >', 'device')], visibility='public') + ## csma-channel.h: bool ns3::CsmaDeviceRec::IsActive() [member function] + cls.add_method('IsActive', 'bool', []) + return + +def register_Ns3Backoff_methods(root_module, cls): + ## backoff.h: ns3::Backoff::m_minSlots [variable] + cls.add_instance_attribute('m_minSlots', 'uint32_t', is_const=False) + ## backoff.h: ns3::Backoff::m_maxSlots [variable] + cls.add_instance_attribute('m_maxSlots', 'uint32_t', is_const=False) + ## backoff.h: ns3::Backoff::m_ceiling [variable] + cls.add_instance_attribute('m_ceiling', 'uint32_t', is_const=False) + ## backoff.h: ns3::Backoff::m_maxRetries [variable] + cls.add_instance_attribute('m_maxRetries', 'uint32_t', is_const=False) + ## backoff.h: ns3::Backoff::m_slotTime [variable] + cls.add_instance_attribute('m_slotTime', 'ns3::Time', is_const=False) + ## backoff.h: ns3::Backoff::Backoff() [constructor] + cls.add_constructor([], visibility='public') + ## backoff.h: ns3::Backoff::Backoff(ns3::Time slotTime, uint32_t minSlots, uint32_t maxSlots, uint32_t ceiling, uint32_t maxRetries) [constructor] + cls.add_constructor([param('ns3::Time', 'slotTime'), param('uint32_t', 'minSlots'), param('uint32_t', 'maxSlots'), param('uint32_t', 'ceiling'), param('uint32_t', 'maxRetries')], visibility='public') + ## backoff.h: ns3::Time ns3::Backoff::GetBackoffTime() [member function] + cls.add_method('GetBackoffTime', 'ns3::Time', []) + ## backoff.h: void ns3::Backoff::ResetBackoffTime() [member function] + cls.add_method('ResetBackoffTime', 'void', []) + ## backoff.h: bool ns3::Backoff::MaxRetriesReached() [member function] + cls.add_method('MaxRetriesReached', 'bool', []) + ## backoff.h: void ns3::Backoff::IncrNumRetries() [member function] + cls.add_method('IncrNumRetries', 'void', []) + return + +def register_Ns3CsmaChannel_methods(root_module, cls): + ## csma-channel.h: static ns3::TypeId ns3::CsmaChannel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## csma-channel.h: ns3::CsmaChannel::CsmaChannel() [constructor] + cls.add_constructor([], visibility='public') + ## csma-channel.h: int32_t ns3::CsmaChannel::Attach(ns3::Ptr device) [member function] + cls.add_method('Attach', 'int32_t', [param('ns3::Ptr< ns3::CsmaNetDevice >', 'device')]) + ## csma-channel.h: bool ns3::CsmaChannel::Detach(ns3::Ptr device) [member function] + cls.add_method('Detach', 'bool', [param('ns3::Ptr< ns3::CsmaNetDevice >', 'device')]) + ## csma-channel.h: bool ns3::CsmaChannel::Detach(uint32_t deviceId) [member function] + cls.add_method('Detach', 'bool', [param('uint32_t', 'deviceId')]) + ## csma-channel.h: bool ns3::CsmaChannel::Reattach(uint32_t deviceId) [member function] + cls.add_method('Reattach', 'bool', [param('uint32_t', 'deviceId')]) + ## csma-channel.h: bool ns3::CsmaChannel::Reattach(ns3::Ptr device) [member function] + cls.add_method('Reattach', 'bool', [param('ns3::Ptr< ns3::CsmaNetDevice >', 'device')]) + ## csma-channel.h: bool ns3::CsmaChannel::TransmitStart(ns3::Ptr p, uint32_t srcId) [member function] + cls.add_method('TransmitStart', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'srcId')]) + ## csma-channel.h: bool ns3::CsmaChannel::TransmitEnd() [member function] + cls.add_method('TransmitEnd', 'bool', []) + ## csma-channel.h: void ns3::CsmaChannel::PropagationCompleteEvent() [member function] + cls.add_method('PropagationCompleteEvent', 'void', []) + ## csma-channel.h: int32_t ns3::CsmaChannel::GetDeviceNum(ns3::Ptr device) [member function] + cls.add_method('GetDeviceNum', 'int32_t', [param('ns3::Ptr< ns3::CsmaNetDevice >', 'device')]) + ## csma-channel.h: ns3::WireState ns3::CsmaChannel::GetState() [member function] + cls.add_method('GetState', 'ns3::WireState', []) + ## csma-channel.h: bool ns3::CsmaChannel::IsBusy() [member function] + cls.add_method('IsBusy', 'bool', []) + ## csma-channel.h: bool ns3::CsmaChannel::IsActive(uint32_t deviceId) [member function] + cls.add_method('IsActive', 'bool', [param('uint32_t', 'deviceId')]) + ## csma-channel.h: uint32_t ns3::CsmaChannel::GetNumActDevices() [member function] + cls.add_method('GetNumActDevices', 'uint32_t', []) + ## csma-channel.h: uint32_t ns3::CsmaChannel::GetNDevices() const [member function] + cls.add_method('GetNDevices', 'uint32_t', [], is_const=True, is_virtual=True) + ## csma-channel.h: ns3::Ptr ns3::CsmaChannel::GetDevice(uint32_t i) const [member function] + cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', [param('uint32_t', 'i')], is_const=True, is_virtual=True) + ## csma-channel.h: ns3::Ptr ns3::CsmaChannel::GetCsmaDevice(uint32_t i) const [member function] + cls.add_method('GetCsmaDevice', 'ns3::Ptr< ns3::CsmaNetDevice >', [param('uint32_t', 'i')], is_const=True) + ## csma-channel.h: ns3::DataRate ns3::CsmaChannel::GetDataRate() [member function] + cls.add_method('GetDataRate', 'ns3::DataRate', [], is_virtual=True) + ## csma-channel.h: ns3::Time ns3::CsmaChannel::GetDelay() [member function] + cls.add_method('GetDelay', 'ns3::Time', [], is_virtual=True) + return + +def register_Ns3CsmaNetDevice_methods(root_module, cls): + ## csma-net-device.h: static ns3::TypeId ns3::CsmaNetDevice::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## csma-net-device.h: ns3::CsmaNetDevice::CsmaNetDevice() [constructor] + cls.add_constructor([], visibility='public') + ## csma-net-device.h: void ns3::CsmaNetDevice::SetInterframeGap(ns3::Time t) [member function] + cls.add_method('SetInterframeGap', 'void', [param('ns3::Time', 't')]) + ## csma-net-device.h: void ns3::CsmaNetDevice::SetBackoffParams(ns3::Time slotTime, uint32_t minSlots, uint32_t maxSlots, uint32_t maxRetries, uint32_t ceiling) [member function] + cls.add_method('SetBackoffParams', 'void', [param('ns3::Time', 'slotTime'), param('uint32_t', 'minSlots'), param('uint32_t', 'maxSlots'), param('uint32_t', 'maxRetries'), param('uint32_t', 'ceiling')]) + ## csma-net-device.h: bool ns3::CsmaNetDevice::Attach(ns3::Ptr ch) [member function] + cls.add_method('Attach', 'bool', [param('ns3::Ptr< ns3::CsmaChannel >', 'ch')]) + ## csma-net-device.h: void ns3::CsmaNetDevice::SetQueue(ns3::Ptr queue) [member function] + cls.add_method('SetQueue', 'void', [param('ns3::Ptr< ns3::Queue >', 'queue')]) + ## csma-net-device.h: void ns3::CsmaNetDevice::SetReceiveErrorModel(ns3::Ptr em) [member function] + cls.add_method('SetReceiveErrorModel', 'void', [param('ns3::Ptr< ns3::ErrorModel >', 'em')]) + ## csma-net-device.h: void ns3::CsmaNetDevice::Receive(ns3::Ptr p) [member function] + cls.add_method('Receive', 'void', [param('ns3::Ptr< ns3::Packet >', 'p')]) + ## csma-net-device.h: bool ns3::CsmaNetDevice::IsSendEnabled() [member function] + cls.add_method('IsSendEnabled', 'bool', []) + ## csma-net-device.h: void ns3::CsmaNetDevice::SetSendEnable(bool enable) [member function] + cls.add_method('SetSendEnable', 'void', [param('bool', 'enable')]) + ## csma-net-device.h: bool ns3::CsmaNetDevice::IsReceiveEnabled() [member function] + cls.add_method('IsReceiveEnabled', 'bool', []) + ## csma-net-device.h: void ns3::CsmaNetDevice::SetReceiveEnable(bool enable) [member function] + cls.add_method('SetReceiveEnable', 'void', [param('bool', 'enable')]) + ## csma-net-device.h: void ns3::CsmaNetDevice::SetAddress(ns3::Mac48Address addr) [member function] + cls.add_method('SetAddress', 'void', [param('ns3::Mac48Address', 'addr')]) + ## csma-net-device.h: void ns3::CsmaNetDevice::SetName(std::string const name) [member function] + cls.add_method('SetName', 'void', [param('std::string', 'name', is_const=True)], is_virtual=True) + ## csma-net-device.h: std::string ns3::CsmaNetDevice::GetName() const [member function] + cls.add_method('GetName', 'std::string', [], is_const=True, is_virtual=True) + ## csma-net-device.h: void ns3::CsmaNetDevice::SetIfIndex(uint32_t const index) [member function] + cls.add_method('SetIfIndex', 'void', [param('uint32_t', 'index', is_const=True)], is_virtual=True) + ## csma-net-device.h: uint32_t ns3::CsmaNetDevice::GetIfIndex() const [member function] + cls.add_method('GetIfIndex', 'uint32_t', [], is_const=True, is_virtual=True) + ## csma-net-device.h: ns3::Ptr ns3::CsmaNetDevice::GetChannel() const [member function] + cls.add_method('GetChannel', 'ns3::Ptr< ns3::Channel >', [], is_const=True, is_virtual=True) + ## csma-net-device.h: ns3::Address ns3::CsmaNetDevice::GetAddress() const [member function] + cls.add_method('GetAddress', 'ns3::Address', [], is_const=True, is_virtual=True) + ## csma-net-device.h: bool ns3::CsmaNetDevice::SetMtu(uint16_t const mtu) [member function] + cls.add_method('SetMtu', 'bool', [param('uint16_t', 'mtu', is_const=True)], is_virtual=True) + ## csma-net-device.h: uint16_t ns3::CsmaNetDevice::GetMtu() const [member function] + cls.add_method('GetMtu', 'uint16_t', [], is_const=True, is_virtual=True) + ## csma-net-device.h: bool ns3::CsmaNetDevice::IsLinkUp() const [member function] + cls.add_method('IsLinkUp', 'bool', [], is_const=True, is_virtual=True) + ## csma-net-device.h: void ns3::CsmaNetDevice::SetLinkChangeCallback(ns3::Callback callback) [member function] + 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) + ## csma-net-device.h: bool ns3::CsmaNetDevice::IsBroadcast() const [member function] + cls.add_method('IsBroadcast', 'bool', [], is_const=True, is_virtual=True) + ## csma-net-device.h: ns3::Address ns3::CsmaNetDevice::GetBroadcast() const [member function] + cls.add_method('GetBroadcast', 'ns3::Address', [], is_const=True, is_virtual=True) + ## csma-net-device.h: bool ns3::CsmaNetDevice::IsMulticast() const [member function] + cls.add_method('IsMulticast', 'bool', [], is_const=True, is_virtual=True) + ## csma-net-device.h: ns3::Address ns3::CsmaNetDevice::GetMulticast() const [member function] + cls.add_method('GetMulticast', 'ns3::Address', [], is_const=True, is_virtual=True) + ## csma-net-device.h: ns3::Address ns3::CsmaNetDevice::MakeMulticastAddress(ns3::Ipv4Address multicastGroup) const [member function] + cls.add_method('MakeMulticastAddress', 'ns3::Address', [param('ns3::Ipv4Address', 'multicastGroup')], is_const=True, is_virtual=True) + ## csma-net-device.h: bool ns3::CsmaNetDevice::IsPointToPoint() const [member function] + cls.add_method('IsPointToPoint', 'bool', [], is_const=True, is_virtual=True) + ## csma-net-device.h: bool ns3::CsmaNetDevice::Send(ns3::Ptr packet, ns3::Address const & dest, uint16_t protocolNumber) [member function] + 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) + ## csma-net-device.h: ns3::Ptr ns3::CsmaNetDevice::GetNode() const [member function] + cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [], is_const=True, is_virtual=True) + ## csma-net-device.h: void ns3::CsmaNetDevice::SetNode(ns3::Ptr node) [member function] + cls.add_method('SetNode', 'void', [param('ns3::Ptr< ns3::Node >', 'node')], is_virtual=True) + ## csma-net-device.h: bool ns3::CsmaNetDevice::NeedsArp() const [member function] + cls.add_method('NeedsArp', 'bool', [], is_const=True, is_virtual=True) + ## csma-net-device.h: void ns3::CsmaNetDevice::SetReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function] + 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) + ## csma-net-device.h: void ns3::CsmaNetDevice::DoDispose() [member function] + cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True) + ## csma-net-device.h: ns3::Ptr ns3::CsmaNetDevice::GetQueue() const [member function] + cls.add_method('GetQueue', 'ns3::Ptr< ns3::Queue >', [], is_const=True, visibility='protected') + ## csma-net-device.h: void ns3::CsmaNetDevice::AddHeader(ns3::Ptr p, ns3::Mac48Address dest, uint16_t protocolNumber) [member function] + cls.add_method('AddHeader', 'void', [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Mac48Address', 'dest'), param('uint16_t', 'protocolNumber')], visibility='protected') + ## csma-net-device.h: bool ns3::CsmaNetDevice::ProcessHeader(ns3::Ptr p, uint16_t & param) [member function] + cls.add_method('ProcessHeader', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint16_t&', 'param')], visibility='protected') + return + +def register_functions(root_module): + module = root_module + register_functions_ns3_internal(module.get_submodule('internal'), root_module) + register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module) + register_functions_ns3_Config(module.get_submodule('Config'), root_module) + register_functions_ns3_olsr(module.get_submodule('olsr'), root_module) + return + +def register_functions_ns3_internal(module, root_module): + return + +def register_functions_ns3_TimeStepPrecision(module, root_module): + return + +def register_functions_ns3_Config(module, root_module): + return + +def register_functions_ns3_olsr(module, root_module): + return + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/ns3_module_global_routing.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/ns3_module_global_routing.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,184 @@ +from pybindgen import Module, FileCodeSink, write_preamble, param, retval + +def register_types(module): + root_module = module.get_root() + + ## global-route-manager.h: ns3::GlobalRouteManager [class] + module.add_class('GlobalRouteManager') + ## global-router-interface.h: ns3::GlobalRoutingLSA [class] + module.add_class('GlobalRoutingLSA') + ## global-router-interface.h: ns3::GlobalRoutingLSA::LSType [enumeration] + module.add_enum('LSType', ['Unknown', 'RouterLSA', 'NetworkLSA', 'SummaryLSA', 'SummaryLSA_ASBR', 'ASExternalLSAs'], outer_class=root_module['ns3::GlobalRoutingLSA']) + ## global-router-interface.h: ns3::GlobalRoutingLSA::SPFStatus [enumeration] + module.add_enum('SPFStatus', ['LSA_SPF_NOT_EXPLORED', 'LSA_SPF_CANDIDATE', 'LSA_SPF_IN_SPFTREE'], outer_class=root_module['ns3::GlobalRoutingLSA']) + ## global-router-interface.h: ns3::GlobalRoutingLinkRecord [class] + module.add_class('GlobalRoutingLinkRecord') + ## global-router-interface.h: ns3::GlobalRoutingLinkRecord::LinkType [enumeration] + module.add_enum('LinkType', ['Unknown', 'PointToPoint', 'TransitNetwork', 'StubNetwork', 'VirtualLink'], outer_class=root_module['ns3::GlobalRoutingLinkRecord']) + ## global-router-interface.h: ns3::GlobalRouter [class] + module.add_class('GlobalRouter', allow_subclassing=True, is_singleton=True, parent=root_module['ns3::Object']) + + ## Register a nested module for the namespace internal + + nested_module = module.add_cpp_namespace('internal') + register_types_ns3_internal(nested_module) + + + ## Register a nested module for the namespace TimeStepPrecision + + nested_module = module.add_cpp_namespace('TimeStepPrecision') + register_types_ns3_TimeStepPrecision(nested_module) + + + ## Register a nested module for the namespace Config + + nested_module = module.add_cpp_namespace('Config') + register_types_ns3_Config(nested_module) + + + ## Register a nested module for the namespace olsr + + nested_module = module.add_cpp_namespace('olsr') + register_types_ns3_olsr(nested_module) + + +def register_types_ns3_internal(module): + root_module = module.get_root() + + +def register_types_ns3_TimeStepPrecision(module): + root_module = module.get_root() + + +def register_types_ns3_Config(module): + root_module = module.get_root() + + +def register_types_ns3_olsr(module): + root_module = module.get_root() + + +def register_methods(root_module): + register_Ns3GlobalRouteManager_methods(root_module, root_module['ns3::GlobalRouteManager']) + register_Ns3GlobalRoutingLSA_methods(root_module, root_module['ns3::GlobalRoutingLSA']) + register_Ns3GlobalRoutingLinkRecord_methods(root_module, root_module['ns3::GlobalRoutingLinkRecord']) + register_Ns3GlobalRouter_methods(root_module, root_module['ns3::GlobalRouter']) + return + +def register_Ns3GlobalRouteManager_methods(root_module, cls): + ## global-route-manager.h: static void ns3::GlobalRouteManager::PopulateRoutingTables() [member function] + cls.add_method('PopulateRoutingTables', 'void', [], is_static=True) + ## global-route-manager.h: static uint32_t ns3::GlobalRouteManager::AllocateRouterId() [member function] + cls.add_method('AllocateRouterId', 'uint32_t', [], is_static=True) + return + +def register_Ns3GlobalRoutingLSA_methods(root_module, cls): + ## global-router-interface.h: ns3::GlobalRoutingLSA::GlobalRoutingLSA() [constructor] + cls.add_constructor([], visibility='public') + ## global-router-interface.h: ns3::GlobalRoutingLSA::GlobalRoutingLSA(ns3::GlobalRoutingLSA::SPFStatus status, ns3::Ipv4Address linkStateId, ns3::Ipv4Address advertisingRtr) [constructor] + cls.add_constructor([param('ns3::GlobalRoutingLSA::SPFStatus', 'status'), param('ns3::Ipv4Address', 'linkStateId'), param('ns3::Ipv4Address', 'advertisingRtr')], visibility='public') + ## global-router-interface.h: ns3::GlobalRoutingLSA::GlobalRoutingLSA(ns3::GlobalRoutingLSA & lsa) [constructor] + cls.add_constructor([param('ns3::GlobalRoutingLSA&', 'lsa')], visibility='public') + ## global-router-interface.h: uint32_t ns3::GlobalRoutingLSA::AddAttachedRouter(ns3::Ipv4Address addr) [member function] + cls.add_method('AddAttachedRouter', 'uint32_t', [param('ns3::Ipv4Address', 'addr')]) + ## global-router-interface.h: uint32_t ns3::GlobalRoutingLSA::AddLinkRecord(ns3::GlobalRoutingLinkRecord * lr) [member function] + cls.add_method('AddLinkRecord', 'uint32_t', [param('ns3::GlobalRoutingLinkRecord *', 'lr')]) + ## global-router-interface.h: void ns3::GlobalRoutingLSA::ClearLinkRecords() [member function] + cls.add_method('ClearLinkRecords', 'void', []) + ## global-router-interface.h: void ns3::GlobalRoutingLSA::CopyLinkRecords(ns3::GlobalRoutingLSA const & lsa) [member function] + cls.add_method('CopyLinkRecords', 'void', [param('ns3::GlobalRoutingLSA&', 'lsa', is_const=True)]) + ## global-router-interface.h: ns3::Ipv4Address ns3::GlobalRoutingLSA::GetAdvertisingRouter() const [member function] + cls.add_method('GetAdvertisingRouter', 'ns3::Ipv4Address', [], is_const=True) + ## global-router-interface.h: ns3::Ipv4Address ns3::GlobalRoutingLSA::GetAttachedRouter(uint32_t n) const [member function] + cls.add_method('GetAttachedRouter', 'ns3::Ipv4Address', [param('uint32_t', 'n')], is_const=True) + ## global-router-interface.h: ns3::GlobalRoutingLSA::LSType ns3::GlobalRoutingLSA::GetLSType() const [member function] + cls.add_method('GetLSType', 'ns3::GlobalRoutingLSA::LSType', [], is_const=True) + ## global-router-interface.h: ns3::GlobalRoutingLinkRecord * ns3::GlobalRoutingLSA::GetLinkRecord(uint32_t n) const [member function] + cls.add_method('GetLinkRecord', 'ns3::GlobalRoutingLinkRecord *', [param('uint32_t', 'n')], is_const=True) + ## global-router-interface.h: ns3::Ipv4Address ns3::GlobalRoutingLSA::GetLinkStateId() const [member function] + cls.add_method('GetLinkStateId', 'ns3::Ipv4Address', [], is_const=True) + ## global-router-interface.h: uint32_t ns3::GlobalRoutingLSA::GetNAttachedRouters() const [member function] + cls.add_method('GetNAttachedRouters', 'uint32_t', [], is_const=True) + ## global-router-interface.h: uint32_t ns3::GlobalRoutingLSA::GetNLinkRecords() const [member function] + cls.add_method('GetNLinkRecords', 'uint32_t', [], is_const=True) + ## global-router-interface.h: ns3::Ipv4Mask ns3::GlobalRoutingLSA::GetNetworkLSANetworkMask() const [member function] + cls.add_method('GetNetworkLSANetworkMask', 'ns3::Ipv4Mask', [], is_const=True) + ## global-router-interface.h: ns3::GlobalRoutingLSA::SPFStatus ns3::GlobalRoutingLSA::GetStatus() const [member function] + cls.add_method('GetStatus', 'ns3::GlobalRoutingLSA::SPFStatus', [], is_const=True) + ## global-router-interface.h: bool ns3::GlobalRoutingLSA::IsEmpty() const [member function] + cls.add_method('IsEmpty', 'bool', [], is_const=True) + ## global-router-interface.h: void ns3::GlobalRoutingLSA::Print(std::ostream & os) const [member function] + cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True) + ## global-router-interface.h: void ns3::GlobalRoutingLSA::SetAdvertisingRouter(ns3::Ipv4Address rtr) [member function] + cls.add_method('SetAdvertisingRouter', 'void', [param('ns3::Ipv4Address', 'rtr')]) + ## global-router-interface.h: void ns3::GlobalRoutingLSA::SetLSType(ns3::GlobalRoutingLSA::LSType typ) [member function] + cls.add_method('SetLSType', 'void', [param('ns3::GlobalRoutingLSA::LSType', 'typ')]) + ## global-router-interface.h: void ns3::GlobalRoutingLSA::SetLinkStateId(ns3::Ipv4Address addr) [member function] + cls.add_method('SetLinkStateId', 'void', [param('ns3::Ipv4Address', 'addr')]) + ## global-router-interface.h: void ns3::GlobalRoutingLSA::SetNetworkLSANetworkMask(ns3::Ipv4Mask mask) [member function] + cls.add_method('SetNetworkLSANetworkMask', 'void', [param('ns3::Ipv4Mask', 'mask')]) + ## global-router-interface.h: void ns3::GlobalRoutingLSA::SetStatus(ns3::GlobalRoutingLSA::SPFStatus status) [member function] + cls.add_method('SetStatus', 'void', [param('ns3::GlobalRoutingLSA::SPFStatus', 'status')]) + cls.add_output_stream_operator() + return + +def register_Ns3GlobalRoutingLinkRecord_methods(root_module, cls): + ## global-router-interface.h: ns3::GlobalRoutingLinkRecord::GlobalRoutingLinkRecord() [constructor] + cls.add_constructor([], visibility='public') + ## global-router-interface.h: ns3::GlobalRoutingLinkRecord::GlobalRoutingLinkRecord(ns3::GlobalRoutingLinkRecord::LinkType linkType, ns3::Ipv4Address linkId, ns3::Ipv4Address linkData, uint16_t metric) [constructor] + cls.add_constructor([param('ns3::GlobalRoutingLinkRecord::LinkType', 'linkType'), param('ns3::Ipv4Address', 'linkId'), param('ns3::Ipv4Address', 'linkData'), param('uint16_t', 'metric')], visibility='public') + ## global-router-interface.h: ns3::Ipv4Address ns3::GlobalRoutingLinkRecord::GetLinkId() const [member function] + cls.add_method('GetLinkId', 'ns3::Ipv4Address', [], is_const=True) + ## global-router-interface.h: void ns3::GlobalRoutingLinkRecord::SetLinkId(ns3::Ipv4Address addr) [member function] + cls.add_method('SetLinkId', 'void', [param('ns3::Ipv4Address', 'addr')]) + ## global-router-interface.h: ns3::Ipv4Address ns3::GlobalRoutingLinkRecord::GetLinkData() const [member function] + cls.add_method('GetLinkData', 'ns3::Ipv4Address', [], is_const=True) + ## global-router-interface.h: void ns3::GlobalRoutingLinkRecord::SetLinkData(ns3::Ipv4Address addr) [member function] + cls.add_method('SetLinkData', 'void', [param('ns3::Ipv4Address', 'addr')]) + ## global-router-interface.h: ns3::GlobalRoutingLinkRecord::LinkType ns3::GlobalRoutingLinkRecord::GetLinkType() const [member function] + cls.add_method('GetLinkType', 'ns3::GlobalRoutingLinkRecord::LinkType', [], is_const=True) + ## global-router-interface.h: void ns3::GlobalRoutingLinkRecord::SetLinkType(ns3::GlobalRoutingLinkRecord::LinkType linkType) [member function] + cls.add_method('SetLinkType', 'void', [param('ns3::GlobalRoutingLinkRecord::LinkType', 'linkType')]) + ## global-router-interface.h: uint16_t ns3::GlobalRoutingLinkRecord::GetMetric() const [member function] + cls.add_method('GetMetric', 'uint16_t', [], is_const=True) + ## global-router-interface.h: void ns3::GlobalRoutingLinkRecord::SetMetric(uint16_t metric) [member function] + cls.add_method('SetMetric', 'void', [param('uint16_t', 'metric')]) + return + +def register_Ns3GlobalRouter_methods(root_module, cls): + ## global-router-interface.h: static ns3::TypeId ns3::GlobalRouter::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## global-router-interface.h: ns3::GlobalRouter::GlobalRouter() [constructor] + cls.add_constructor([], visibility='public') + ## global-router-interface.h: ns3::Ipv4Address ns3::GlobalRouter::GetRouterId() const [member function] + cls.add_method('GetRouterId', 'ns3::Ipv4Address', [], is_const=True) + ## global-router-interface.h: uint32_t ns3::GlobalRouter::DiscoverLSAs() [member function] + cls.add_method('DiscoverLSAs', 'uint32_t', []) + ## global-router-interface.h: uint32_t ns3::GlobalRouter::GetNumLSAs() const [member function] + cls.add_method('GetNumLSAs', 'uint32_t', [], is_const=True) + ## global-router-interface.h: bool ns3::GlobalRouter::GetLSA(uint32_t n, ns3::GlobalRoutingLSA & lsa) const [member function] + cls.add_method('GetLSA', 'bool', [param('uint32_t', 'n'), param('ns3::GlobalRoutingLSA&', 'lsa')], is_const=True) + ## global-router-interface.h: void ns3::GlobalRouter::DoDispose() [member function] + cls.add_method('DoDispose', 'void', [], visibility='private', is_virtual=True) + return + +def register_functions(root_module): + module = root_module + register_functions_ns3_internal(module.get_submodule('internal'), root_module) + register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module) + register_functions_ns3_Config(module.get_submodule('Config'), root_module) + register_functions_ns3_olsr(module.get_submodule('olsr'), root_module) + return + +def register_functions_ns3_internal(module, root_module): + return + +def register_functions_ns3_TimeStepPrecision(module, root_module): + return + +def register_functions_ns3_Config(module, root_module): + return + +def register_functions_ns3_olsr(module, root_module): + return + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/ns3_module_helper.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/ns3_module_helper.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,409 @@ +from pybindgen import Module, FileCodeSink, write_preamble, param, retval + +def register_types(module): + root_module = module.get_root() + + ## mobility-helper.h: ns3::MobilityHelper [class] + module.add_class('MobilityHelper', allow_subclassing=False) + ## internet-stack-helper.h: ns3::InternetStackHelper [class] + module.add_class('InternetStackHelper', allow_subclassing=False) + ## node-container.h: ns3::NodeContainer [class] + module.add_class('NodeContainer') + ## point-to-point-helper.h: ns3::PointToPointHelper [class] + module.add_class('PointToPointHelper', allow_subclassing=False) + ## net-device-container.h: ns3::NetDeviceContainer [class] + module.add_class('NetDeviceContainer') + ## csma-helper.h: ns3::CsmaHelper [class] + module.add_class('CsmaHelper', allow_subclassing=False) + ## udp-echo-helper.h: ns3::UdpEchoServerHelper [class] + module.add_class('UdpEchoServerHelper', allow_subclassing=False) + ## olsr-helper.h: ns3::OlsrHelper [class] + module.add_class('OlsrHelper', allow_subclassing=False) + ## packet-socket-helper.h: ns3::PacketSocketHelper [class] + module.add_class('PacketSocketHelper', allow_subclassing=False) + ## on-off-helper.h: ns3::OnOffHelper [class] + module.add_class('OnOffHelper', allow_subclassing=False) + ## udp-echo-helper.h: ns3::UdpEchoClientHelper [class] + module.add_class('UdpEchoClientHelper', allow_subclassing=False) + ## static-multicast-route-helper.h: ns3::StaticMulticastRouteHelper [class] + module.add_class('StaticMulticastRouteHelper', allow_subclassing=False) + ## ipv4-interface-container.h: ns3::Ipv4InterfaceContainer [class] + module.add_class('Ipv4InterfaceContainer') + ## application-container.h: ns3::ApplicationContainer [class] + module.add_class('ApplicationContainer') + ## wifi-helper.h: ns3::WifiHelper [class] + module.add_class('WifiHelper', allow_subclassing=False) + ## ipv4-address-helper.h: ns3::Ipv4AddressHelper [class] + module.add_class('Ipv4AddressHelper', allow_subclassing=False) + ## packet-sink-helper.h: ns3::PacketSinkHelper [class] + module.add_class('PacketSinkHelper', allow_subclassing=False) + ## ns2-mobility-helper.h: ns3::Ns2MobilityHelper [class] + module.add_class('Ns2MobilityHelper', allow_subclassing=False) + + ## Register a nested module for the namespace internal + + nested_module = module.add_cpp_namespace('internal') + register_types_ns3_internal(nested_module) + + + ## Register a nested module for the namespace TimeStepPrecision + + nested_module = module.add_cpp_namespace('TimeStepPrecision') + register_types_ns3_TimeStepPrecision(nested_module) + + + ## Register a nested module for the namespace Config + + nested_module = module.add_cpp_namespace('Config') + register_types_ns3_Config(nested_module) + + + ## Register a nested module for the namespace olsr + + nested_module = module.add_cpp_namespace('olsr') + register_types_ns3_olsr(nested_module) + + +def register_types_ns3_internal(module): + root_module = module.get_root() + + +def register_types_ns3_TimeStepPrecision(module): + root_module = module.get_root() + + +def register_types_ns3_Config(module): + root_module = module.get_root() + + +def register_types_ns3_olsr(module): + root_module = module.get_root() + + +def register_methods(root_module): + register_Ns3MobilityHelper_methods(root_module, root_module['ns3::MobilityHelper']) + register_Ns3InternetStackHelper_methods(root_module, root_module['ns3::InternetStackHelper']) + register_Ns3NodeContainer_methods(root_module, root_module['ns3::NodeContainer']) + register_Ns3PointToPointHelper_methods(root_module, root_module['ns3::PointToPointHelper']) + register_Ns3NetDeviceContainer_methods(root_module, root_module['ns3::NetDeviceContainer']) + register_Ns3CsmaHelper_methods(root_module, root_module['ns3::CsmaHelper']) + register_Ns3UdpEchoServerHelper_methods(root_module, root_module['ns3::UdpEchoServerHelper']) + register_Ns3OlsrHelper_methods(root_module, root_module['ns3::OlsrHelper']) + register_Ns3PacketSocketHelper_methods(root_module, root_module['ns3::PacketSocketHelper']) + register_Ns3OnOffHelper_methods(root_module, root_module['ns3::OnOffHelper']) + register_Ns3UdpEchoClientHelper_methods(root_module, root_module['ns3::UdpEchoClientHelper']) + register_Ns3StaticMulticastRouteHelper_methods(root_module, root_module['ns3::StaticMulticastRouteHelper']) + register_Ns3Ipv4InterfaceContainer_methods(root_module, root_module['ns3::Ipv4InterfaceContainer']) + register_Ns3ApplicationContainer_methods(root_module, root_module['ns3::ApplicationContainer']) + register_Ns3WifiHelper_methods(root_module, root_module['ns3::WifiHelper']) + register_Ns3Ipv4AddressHelper_methods(root_module, root_module['ns3::Ipv4AddressHelper']) + register_Ns3PacketSinkHelper_methods(root_module, root_module['ns3::PacketSinkHelper']) + register_Ns3Ns2MobilityHelper_methods(root_module, root_module['ns3::Ns2MobilityHelper']) + return + +def register_Ns3MobilityHelper_methods(root_module, cls): + ## mobility-helper.h: ns3::MobilityHelper::MobilityHelper() [constructor] + cls.add_constructor([], visibility='public') + ## mobility-helper.h: void ns3::MobilityHelper::SetPositionAllocator(ns3::Ptr allocator) [member function] + cls.add_method('SetPositionAllocator', 'void', [param('ns3::Ptr< ns3::PositionAllocator >', 'allocator')]) + ## mobility-helper.h: void ns3::MobilityHelper::SetPositionAllocator(std::string type, std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue(), std::string n5="", ns3::AttributeValue const & v5=ns3::EmptyAttributeValue(), std::string n6="", ns3::AttributeValue const & v6=ns3::EmptyAttributeValue(), std::string n7="", ns3::AttributeValue const & v7=ns3::EmptyAttributeValue(), std::string n8="", ns3::AttributeValue const & v8=ns3::EmptyAttributeValue(), std::string n9="", ns3::AttributeValue const & v9=ns3::EmptyAttributeValue()) [member function] + cls.add_method('SetPositionAllocator', 'void', [param('std::string', 'type'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue&', 'v5', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue&', 'v6', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue&', 'v7', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n8', default_value='""'), param('ns3::AttributeValue&', 'v8', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n9', default_value='""'), param('ns3::AttributeValue&', 'v9', default_value='ns3::EmptyAttributeValue()', is_const=True)]) + ## mobility-helper.h: void ns3::MobilityHelper::SetMobilityModel(std::string type, std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue(), std::string n5="", ns3::AttributeValue const & v5=ns3::EmptyAttributeValue(), std::string n6="", ns3::AttributeValue const & v6=ns3::EmptyAttributeValue(), std::string n7="", ns3::AttributeValue const & v7=ns3::EmptyAttributeValue(), std::string n8="", ns3::AttributeValue const & v8=ns3::EmptyAttributeValue(), std::string n9="", ns3::AttributeValue const & v9=ns3::EmptyAttributeValue()) [member function] + cls.add_method('SetMobilityModel', 'void', [param('std::string', 'type'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue&', 'v5', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue&', 'v6', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue&', 'v7', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n8', default_value='""'), param('ns3::AttributeValue&', 'v8', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n9', default_value='""'), param('ns3::AttributeValue&', 'v9', default_value='ns3::EmptyAttributeValue()', is_const=True)]) + ## mobility-helper.h: void ns3::MobilityHelper::PushReferenceMobilityModel(ns3::Ptr reference) [member function] + cls.add_method('PushReferenceMobilityModel', 'void', [param('ns3::Ptr< ns3::Object >', 'reference')]) + ## mobility-helper.h: void ns3::MobilityHelper::PopReferenceMobilityModel() [member function] + cls.add_method('PopReferenceMobilityModel', 'void', []) + ## mobility-helper.h: std::string ns3::MobilityHelper::GetMobilityModelType() const [member function] + cls.add_method('GetMobilityModelType', 'std::string', [], is_const=True) + ## mobility-helper.h: void ns3::MobilityHelper::Install(ns3::NodeContainer container) [member function] + cls.add_method('Install', 'void', [param('ns3::NodeContainer', 'container')]) + ## mobility-helper.h: void ns3::MobilityHelper::InstallAll() [member function] + cls.add_method('InstallAll', 'void', []) + return + +def register_Ns3InternetStackHelper_methods(root_module, cls): + ## internet-stack-helper.h: void ns3::InternetStackHelper::Install(ns3::NodeContainer c) [member function] + cls.add_method('Install', 'void', [param('ns3::NodeContainer', 'c')]) + ## internet-stack-helper.h: static void ns3::InternetStackHelper::EnablePcapAll(std::string filename) [member function] + cls.add_method('EnablePcapAll', 'void', [param('std::string', 'filename')], is_static=True) + cls.add_constructor([]) + return + +def register_Ns3NodeContainer_methods(root_module, cls): + ## node-container.h: ns3::NodeContainer::NodeContainer() [constructor] + cls.add_constructor([], visibility='public') + ## node-container.h: ns3::NodeContainer::NodeContainer(ns3::Ptr node) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::Node >', 'node')], visibility='public') + ## node-container.h: ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & a, ns3::NodeContainer const & b) [constructor] + cls.add_constructor([param('ns3::NodeContainer&', 'a', is_const=True), param('ns3::NodeContainer&', 'b', is_const=True)], visibility='public') + ## node-container.h: ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & a, ns3::NodeContainer const & b, ns3::NodeContainer const & c) [constructor] + cls.add_constructor([param('ns3::NodeContainer&', 'a', is_const=True), param('ns3::NodeContainer&', 'b', is_const=True), param('ns3::NodeContainer&', 'c', is_const=True)], visibility='public') + ## node-container.h: ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & a, ns3::NodeContainer const & b, ns3::NodeContainer const & c, ns3::NodeContainer const & d) [constructor] + cls.add_constructor([param('ns3::NodeContainer&', 'a', is_const=True), param('ns3::NodeContainer&', 'b', is_const=True), param('ns3::NodeContainer&', 'c', is_const=True), param('ns3::NodeContainer&', 'd', is_const=True)], visibility='public') + ## node-container.h: __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeContainer::Begin() const [member function] + cls.add_method('Begin', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', [], is_const=True) + ## node-container.h: __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeContainer::End() const [member function] + cls.add_method('End', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', [], is_const=True) + ## node-container.h: uint32_t ns3::NodeContainer::GetN() const [member function] + cls.add_method('GetN', 'uint32_t', [], is_const=True) + ## node-container.h: ns3::Ptr ns3::NodeContainer::Get(uint32_t i) const [member function] + cls.add_method('Get', 'ns3::Ptr< ns3::Node >', [param('uint32_t', 'i')], is_const=True) + ## node-container.h: void ns3::NodeContainer::Create(uint32_t n) [member function] + cls.add_method('Create', 'void', [param('uint32_t', 'n')]) + ## node-container.h: void ns3::NodeContainer::Add(ns3::NodeContainer other) [member function] + cls.add_method('Add', 'void', [param('ns3::NodeContainer', 'other')]) + ## node-container.h: void ns3::NodeContainer::Add(ns3::Ptr node) [member function] + cls.add_method('Add', 'void', [param('ns3::Ptr< ns3::Node >', 'node')]) + ## node-container.h: static ns3::NodeContainer ns3::NodeContainer::GetGlobal() [member function] + cls.add_method('GetGlobal', 'ns3::NodeContainer', [], is_static=True) + return + +def register_Ns3PointToPointHelper_methods(root_module, cls): + ## point-to-point-helper.h: ns3::PointToPointHelper::PointToPointHelper() [constructor] + cls.add_constructor([], visibility='public') + ## point-to-point-helper.h: void ns3::PointToPointHelper::SetQueue(std::string type, std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue()) [member function] + cls.add_method('SetQueue', 'void', [param('std::string', 'type'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True)]) + ## point-to-point-helper.h: void ns3::PointToPointHelper::SetDeviceAttribute(std::string name, ns3::AttributeValue const & value) [member function] + cls.add_method('SetDeviceAttribute', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)]) + ## point-to-point-helper.h: void ns3::PointToPointHelper::SetChannelAttribute(std::string name, ns3::AttributeValue const & value) [member function] + cls.add_method('SetChannelAttribute', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)]) + ## point-to-point-helper.h: static void ns3::PointToPointHelper::EnablePcap(std::string filename, uint32_t nodeid, uint32_t deviceid) [member function] + cls.add_method('EnablePcap', 'void', [param('std::string', 'filename'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')], is_static=True) + ## point-to-point-helper.h: static void ns3::PointToPointHelper::EnablePcap(std::string filename, ns3::NetDeviceContainer d) [member function] + cls.add_method('EnablePcap', 'void', [param('std::string', 'filename'), param('ns3::NetDeviceContainer', 'd')], is_static=True) + ## point-to-point-helper.h: static void ns3::PointToPointHelper::EnablePcap(std::string filename, ns3::NodeContainer n) [member function] + cls.add_method('EnablePcap', 'void', [param('std::string', 'filename'), param('ns3::NodeContainer', 'n')], is_static=True) + ## point-to-point-helper.h: static void ns3::PointToPointHelper::EnablePcapAll(std::string filename) [member function] + cls.add_method('EnablePcapAll', 'void', [param('std::string', 'filename')], is_static=True) + ## point-to-point-helper.h: static void ns3::PointToPointHelper::EnableAscii(std::ostream & os, uint32_t nodeid, uint32_t deviceid) [member function] + cls.add_method('EnableAscii', 'void', [param('std::ostream&', 'os'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')], is_static=True) + ## point-to-point-helper.h: static void ns3::PointToPointHelper::EnableAscii(std::ostream & os, ns3::NetDeviceContainer d) [member function] + cls.add_method('EnableAscii', 'void', [param('std::ostream&', 'os'), param('ns3::NetDeviceContainer', 'd')], is_static=True) + ## point-to-point-helper.h: static void ns3::PointToPointHelper::EnableAscii(std::ostream & os, ns3::NodeContainer n) [member function] + cls.add_method('EnableAscii', 'void', [param('std::ostream&', 'os'), param('ns3::NodeContainer', 'n')], is_static=True) + ## point-to-point-helper.h: static void ns3::PointToPointHelper::EnableAsciiAll(std::ostream & os) [member function] + cls.add_method('EnableAsciiAll', 'void', [param('std::ostream&', 'os')], is_static=True) + ## point-to-point-helper.h: ns3::NetDeviceContainer ns3::PointToPointHelper::Install(ns3::NodeContainer c) [member function] + cls.add_method('Install', 'ns3::NetDeviceContainer', [param('ns3::NodeContainer', 'c')]) + ## point-to-point-helper.h: ns3::NetDeviceContainer ns3::PointToPointHelper::Install(ns3::Ptr a, ns3::Ptr b) [member function] + cls.add_method('Install', 'ns3::NetDeviceContainer', [param('ns3::Ptr< ns3::Node >', 'a'), param('ns3::Ptr< ns3::Node >', 'b')]) + return + +def register_Ns3NetDeviceContainer_methods(root_module, cls): + ## net-device-container.h: __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NetDeviceContainer::Begin() const [member function] + cls.add_method('Begin', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::NetDevice >, std::vector< ns3::Ptr< ns3::NetDevice >, std::allocator< ns3::Ptr< ns3::NetDevice > > > >', [], is_const=True) + ## net-device-container.h: __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NetDeviceContainer::End() const [member function] + cls.add_method('End', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::NetDevice >, std::vector< ns3::Ptr< ns3::NetDevice >, std::allocator< ns3::Ptr< ns3::NetDevice > > > >', [], is_const=True) + ## net-device-container.h: uint32_t ns3::NetDeviceContainer::GetN() const [member function] + cls.add_method('GetN', 'uint32_t', [], is_const=True) + ## net-device-container.h: ns3::Ptr ns3::NetDeviceContainer::Get(uint32_t i) const [member function] + cls.add_method('Get', 'ns3::Ptr< ns3::NetDevice >', [param('uint32_t', 'i')], is_const=True) + ## net-device-container.h: void ns3::NetDeviceContainer::Add(ns3::NetDeviceContainer other) [member function] + cls.add_method('Add', 'void', [param('ns3::NetDeviceContainer', 'other')]) + ## net-device-container.h: void ns3::NetDeviceContainer::Add(ns3::Ptr device) [member function] + cls.add_method('Add', 'void', [param('ns3::Ptr< ns3::NetDevice >', 'device')]) + cls.add_constructor([]) + return + +def register_Ns3CsmaHelper_methods(root_module, cls): + ## csma-helper.h: ns3::CsmaHelper::CsmaHelper() [constructor] + cls.add_constructor([], visibility='public') + ## csma-helper.h: void ns3::CsmaHelper::SetQueue(std::string type, std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue()) [member function] + cls.add_method('SetQueue', 'void', [param('std::string', 'type'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True)]) + ## csma-helper.h: void ns3::CsmaHelper::SetDeviceAttribute(std::string n1, ns3::AttributeValue const & v1) [member function] + cls.add_method('SetDeviceAttribute', 'void', [param('std::string', 'n1'), param('ns3::AttributeValue&', 'v1', is_const=True)]) + ## csma-helper.h: void ns3::CsmaHelper::SetChannelAttribute(std::string n1, ns3::AttributeValue const & v1) [member function] + cls.add_method('SetChannelAttribute', 'void', [param('std::string', 'n1'), param('ns3::AttributeValue&', 'v1', is_const=True)]) + ## csma-helper.h: static void ns3::CsmaHelper::EnablePcap(std::string filename, uint32_t nodeid, uint32_t deviceid) [member function] + cls.add_method('EnablePcap', 'void', [param('std::string', 'filename'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')], is_static=True) + ## csma-helper.h: static void ns3::CsmaHelper::EnablePcap(std::string filename, ns3::NetDeviceContainer d) [member function] + cls.add_method('EnablePcap', 'void', [param('std::string', 'filename'), param('ns3::NetDeviceContainer', 'd')], is_static=True) + ## csma-helper.h: static void ns3::CsmaHelper::EnablePcap(std::string filename, ns3::NodeContainer n) [member function] + cls.add_method('EnablePcap', 'void', [param('std::string', 'filename'), param('ns3::NodeContainer', 'n')], is_static=True) + ## csma-helper.h: static void ns3::CsmaHelper::EnablePcapAll(std::string filename) [member function] + cls.add_method('EnablePcapAll', 'void', [param('std::string', 'filename')], is_static=True) + ## csma-helper.h: static void ns3::CsmaHelper::EnableAscii(std::ostream & os, uint32_t nodeid, uint32_t deviceid) [member function] + cls.add_method('EnableAscii', 'void', [param('std::ostream&', 'os'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')], is_static=True) + ## csma-helper.h: static void ns3::CsmaHelper::EnableAscii(std::ostream & os, ns3::NetDeviceContainer d) [member function] + cls.add_method('EnableAscii', 'void', [param('std::ostream&', 'os'), param('ns3::NetDeviceContainer', 'd')], is_static=True) + ## csma-helper.h: static void ns3::CsmaHelper::EnableAscii(std::ostream & os, ns3::NodeContainer n) [member function] + cls.add_method('EnableAscii', 'void', [param('std::ostream&', 'os'), param('ns3::NodeContainer', 'n')], is_static=True) + ## csma-helper.h: static void ns3::CsmaHelper::EnableAsciiAll(std::ostream & os) [member function] + cls.add_method('EnableAsciiAll', 'void', [param('std::ostream&', 'os')], is_static=True) + ## csma-helper.h: ns3::NetDeviceContainer ns3::CsmaHelper::Install(ns3::NodeContainer const & c) [member function] + cls.add_method('Install', 'ns3::NetDeviceContainer', [param('ns3::NodeContainer&', 'c', is_const=True)]) + ## csma-helper.h: ns3::NetDeviceContainer ns3::CsmaHelper::Install(ns3::NodeContainer const & c, ns3::Ptr channel) [member function] + cls.add_method('Install', 'ns3::NetDeviceContainer', [param('ns3::NodeContainer&', 'c', is_const=True), param('ns3::Ptr< ns3::CsmaChannel >', 'channel')]) + return + +def register_Ns3UdpEchoServerHelper_methods(root_module, cls): + ## udp-echo-helper.h: ns3::UdpEchoServerHelper::UdpEchoServerHelper(uint16_t port) [constructor] + cls.add_constructor([param('uint16_t', 'port')], visibility='public') + ## udp-echo-helper.h: void ns3::UdpEchoServerHelper::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function] + cls.add_method('SetAttribute', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)]) + ## udp-echo-helper.h: ns3::ApplicationContainer ns3::UdpEchoServerHelper::Install(ns3::NodeContainer c) [member function] + cls.add_method('Install', 'ns3::ApplicationContainer', [param('ns3::NodeContainer', 'c')]) + return + +def register_Ns3OlsrHelper_methods(root_module, cls): + ## olsr-helper.h: ns3::OlsrHelper::OlsrHelper() [constructor] + cls.add_constructor([], visibility='public') + ## olsr-helper.h: void ns3::OlsrHelper::SetAgent(std::string tid, std::string n0="", ns3::AttributeValue const & v0=ns3::EmptyAttributeValue(), std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue(), std::string n5="", ns3::AttributeValue const & v5=ns3::EmptyAttributeValue(), std::string n6="", ns3::AttributeValue const & v6=ns3::EmptyAttributeValue(), std::string n7="", ns3::AttributeValue const & v7=ns3::EmptyAttributeValue()) [member function] + cls.add_method('SetAgent', 'void', [param('std::string', 'tid'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue&', 'v0', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue&', 'v5', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue&', 'v6', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue&', 'v7', default_value='ns3::EmptyAttributeValue()', is_const=True)]) + ## olsr-helper.h: void ns3::OlsrHelper::Install(ns3::NodeContainer container) [member function] + cls.add_method('Install', 'void', [param('ns3::NodeContainer', 'container')]) + ## olsr-helper.h: void ns3::OlsrHelper::Install(ns3::Ptr node) [member function] + cls.add_method('Install', 'void', [param('ns3::Ptr< ns3::Node >', 'node')]) + ## olsr-helper.h: void ns3::OlsrHelper::InstallAll() [member function] + cls.add_method('InstallAll', 'void', []) + return + +def register_Ns3PacketSocketHelper_methods(root_module, cls): + ## packet-socket-helper.h: void ns3::PacketSocketHelper::Install(ns3::NodeContainer c) [member function] + cls.add_method('Install', 'void', [param('ns3::NodeContainer', 'c')]) + cls.add_constructor([]) + return + +def register_Ns3OnOffHelper_methods(root_module, cls): + ## on-off-helper.h: ns3::OnOffHelper::OnOffHelper(std::string protocol, ns3::Address address) [constructor] + cls.add_constructor([param('std::string', 'protocol'), param('ns3::Address', 'address')], visibility='public') + ## on-off-helper.h: void ns3::OnOffHelper::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function] + cls.add_method('SetAttribute', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)]) + ## on-off-helper.h: ns3::ApplicationContainer ns3::OnOffHelper::Install(ns3::NodeContainer c) [member function] + cls.add_method('Install', 'ns3::ApplicationContainer', [param('ns3::NodeContainer', 'c')]) + return + +def register_Ns3UdpEchoClientHelper_methods(root_module, cls): + ## udp-echo-helper.h: ns3::UdpEchoClientHelper::UdpEchoClientHelper(ns3::Ipv4Address ip, uint16_t port) [constructor] + cls.add_constructor([param('ns3::Ipv4Address', 'ip'), param('uint16_t', 'port')], visibility='public') + ## udp-echo-helper.h: void ns3::UdpEchoClientHelper::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function] + cls.add_method('SetAttribute', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)]) + ## udp-echo-helper.h: ns3::ApplicationContainer ns3::UdpEchoClientHelper::Install(ns3::NodeContainer c) [member function] + cls.add_method('Install', 'ns3::ApplicationContainer', [param('ns3::NodeContainer', 'c')]) + return + +def register_Ns3StaticMulticastRouteHelper_methods(root_module, cls): + ## static-multicast-route-helper.h: ns3::StaticMulticastRouteHelper::StaticMulticastRouteHelper() [constructor] + cls.add_constructor([], visibility='public') + ## static-multicast-route-helper.h: void ns3::StaticMulticastRouteHelper::AddMulticastRoute(ns3::Ptr arg0, ns3::Ipv4Address source, ns3::Ipv4Address group, ns3::Ptr input, ns3::NetDeviceContainer output) [member function] + cls.add_method('AddMulticastRoute', 'void', [param('ns3::Ptr< ns3::Node >', 'arg0'), param('ns3::Ipv4Address', 'source'), param('ns3::Ipv4Address', 'group'), param('ns3::Ptr< ns3::NetDevice >', 'input'), param('ns3::NetDeviceContainer', 'output')]) + ## static-multicast-route-helper.h: void ns3::StaticMulticastRouteHelper::SetDefaultMulticastRoute(ns3::Ptr n, ns3::Ptr nd) [member function] + cls.add_method('SetDefaultMulticastRoute', 'void', [param('ns3::Ptr< ns3::Node >', 'n'), param('ns3::Ptr< ns3::NetDevice >', 'nd')]) + ## static-multicast-route-helper.h: void ns3::StaticMulticastRouteHelper::JoinMulticastGroup(ns3::Ptr n, ns3::Ipv4Address source, ns3::Ipv4Address group) [member function] + cls.add_method('JoinMulticastGroup', 'void', [param('ns3::Ptr< ns3::Node >', 'n'), param('ns3::Ipv4Address', 'source'), param('ns3::Ipv4Address', 'group')]) + return + +def register_Ns3Ipv4InterfaceContainer_methods(root_module, cls): + ## ipv4-interface-container.h: ns3::Ipv4InterfaceContainer::Ipv4InterfaceContainer() [constructor] + cls.add_constructor([], visibility='public') + ## ipv4-interface-container.h: uint32_t ns3::Ipv4InterfaceContainer::GetN() const [member function] + cls.add_method('GetN', 'uint32_t', [], is_const=True) + ## ipv4-interface-container.h: ns3::Ipv4Address ns3::Ipv4InterfaceContainer::GetAddress(uint32_t i) const [member function] + cls.add_method('GetAddress', 'ns3::Ipv4Address', [param('uint32_t', 'i')], is_const=True) + ## ipv4-interface-container.h: void ns3::Ipv4InterfaceContainer::SetMetric(uint32_t i, uint16_t metric) [member function] + cls.add_method('SetMetric', 'void', [param('uint32_t', 'i'), param('uint16_t', 'metric')]) + ## ipv4-interface-container.h: void ns3::Ipv4InterfaceContainer::Add(ns3::Ptr ipv4, uint32_t interface) [member function] + cls.add_method('Add', 'void', [param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')]) + return + +def register_Ns3ApplicationContainer_methods(root_module, cls): + ## application-container.h: __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::ApplicationContainer::Begin() const [member function] + cls.add_method('Begin', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Application >, std::vector< ns3::Ptr< ns3::Application >, std::allocator< ns3::Ptr< ns3::Application > > > >', [], is_const=True) + ## application-container.h: __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::ApplicationContainer::End() const [member function] + cls.add_method('End', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Application >, std::vector< ns3::Ptr< ns3::Application >, std::allocator< ns3::Ptr< ns3::Application > > > >', [], is_const=True) + ## application-container.h: uint32_t ns3::ApplicationContainer::GetN() const [member function] + cls.add_method('GetN', 'uint32_t', [], is_const=True) + ## application-container.h: ns3::Ptr ns3::ApplicationContainer::Get(uint32_t i) const [member function] + cls.add_method('Get', 'ns3::Ptr< ns3::Application >', [param('uint32_t', 'i')], is_const=True) + ## application-container.h: void ns3::ApplicationContainer::Add(ns3::ApplicationContainer other) [member function] + cls.add_method('Add', 'void', [param('ns3::ApplicationContainer', 'other')]) + ## application-container.h: void ns3::ApplicationContainer::Add(ns3::Ptr application) [member function] + cls.add_method('Add', 'void', [param('ns3::Ptr< ns3::Application >', 'application')]) + ## application-container.h: void ns3::ApplicationContainer::Start(ns3::Time start) [member function] + cls.add_method('Start', 'void', [param('ns3::Time', 'start')]) + ## application-container.h: void ns3::ApplicationContainer::Stop(ns3::Time stop) [member function] + cls.add_method('Stop', 'void', [param('ns3::Time', 'stop')]) + cls.add_constructor([]) + return + +def register_Ns3WifiHelper_methods(root_module, cls): + ## wifi-helper.h: ns3::WifiHelper::WifiHelper() [constructor] + cls.add_constructor([], visibility='public') + ## wifi-helper.h: void ns3::WifiHelper::SetRemoteStationManager(std::string type, std::string n0="", ns3::AttributeValue const & v0=ns3::EmptyAttributeValue(), std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue(), std::string n5="", ns3::AttributeValue const & v5=ns3::EmptyAttributeValue(), std::string n6="", ns3::AttributeValue const & v6=ns3::EmptyAttributeValue(), std::string n7="", ns3::AttributeValue const & v7=ns3::EmptyAttributeValue()) [member function] + cls.add_method('SetRemoteStationManager', 'void', [param('std::string', 'type'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue&', 'v0', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue&', 'v5', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue&', 'v6', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue&', 'v7', default_value='ns3::EmptyAttributeValue()', is_const=True)]) + ## wifi-helper.h: void ns3::WifiHelper::SetMac(std::string type, std::string n0="", ns3::AttributeValue const & v0=ns3::EmptyAttributeValue(), std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue(), std::string n5="", ns3::AttributeValue const & v5=ns3::EmptyAttributeValue(), std::string n6="", ns3::AttributeValue const & v6=ns3::EmptyAttributeValue(), std::string n7="", ns3::AttributeValue const & v7=ns3::EmptyAttributeValue()) [member function] + cls.add_method('SetMac', 'void', [param('std::string', 'type'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue&', 'v0', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue&', 'v5', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue&', 'v6', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue&', 'v7', default_value='ns3::EmptyAttributeValue()', is_const=True)]) + ## wifi-helper.h: void ns3::WifiHelper::SetPhy(std::string phyType, std::string n0="", ns3::AttributeValue const & v0=ns3::EmptyAttributeValue(), std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue(), std::string n5="", ns3::AttributeValue const & v5=ns3::EmptyAttributeValue(), std::string n6="", ns3::AttributeValue const & v6=ns3::EmptyAttributeValue(), std::string n7="", ns3::AttributeValue const & v7=ns3::EmptyAttributeValue()) [member function] + cls.add_method('SetPhy', 'void', [param('std::string', 'phyType'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue&', 'v0', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue&', 'v5', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue&', 'v6', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue&', 'v7', default_value='ns3::EmptyAttributeValue()', is_const=True)]) + ## wifi-helper.h: static void ns3::WifiHelper::EnablePcap(std::string filename, uint32_t nodeid, uint32_t deviceid) [member function] + cls.add_method('EnablePcap', 'void', [param('std::string', 'filename'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')], is_static=True) + ## wifi-helper.h: static void ns3::WifiHelper::EnablePcap(std::string filename, ns3::NetDeviceContainer d) [member function] + cls.add_method('EnablePcap', 'void', [param('std::string', 'filename'), param('ns3::NetDeviceContainer', 'd')], is_static=True) + ## wifi-helper.h: static void ns3::WifiHelper::EnablePcap(std::string filename, ns3::NodeContainer n) [member function] + cls.add_method('EnablePcap', 'void', [param('std::string', 'filename'), param('ns3::NodeContainer', 'n')], is_static=True) + ## wifi-helper.h: static void ns3::WifiHelper::EnablePcapAll(std::string filename) [member function] + cls.add_method('EnablePcapAll', 'void', [param('std::string', 'filename')], is_static=True) + ## wifi-helper.h: static void ns3::WifiHelper::EnableAscii(std::ostream & os, uint32_t nodeid, uint32_t deviceid) [member function] + cls.add_method('EnableAscii', 'void', [param('std::ostream&', 'os'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')], is_static=True) + ## wifi-helper.h: static void ns3::WifiHelper::EnableAscii(std::ostream & os, ns3::NetDeviceContainer d) [member function] + cls.add_method('EnableAscii', 'void', [param('std::ostream&', 'os'), param('ns3::NetDeviceContainer', 'd')], is_static=True) + ## wifi-helper.h: static void ns3::WifiHelper::EnableAscii(std::ostream & os, ns3::NodeContainer n) [member function] + cls.add_method('EnableAscii', 'void', [param('std::ostream&', 'os'), param('ns3::NodeContainer', 'n')], is_static=True) + ## wifi-helper.h: static void ns3::WifiHelper::EnableAsciiAll(std::ostream & os) [member function] + cls.add_method('EnableAsciiAll', 'void', [param('std::ostream&', 'os')], is_static=True) + ## wifi-helper.h: ns3::NetDeviceContainer ns3::WifiHelper::Install(ns3::NodeContainer c) const [member function] + cls.add_method('Install', 'ns3::NetDeviceContainer', [param('ns3::NodeContainer', 'c')], is_const=True) + ## wifi-helper.h: ns3::NetDeviceContainer ns3::WifiHelper::Install(ns3::NodeContainer c, ns3::Ptr channel) const [member function] + cls.add_method('Install', 'ns3::NetDeviceContainer', [param('ns3::NodeContainer', 'c'), param('ns3::Ptr< ns3::WifiChannel >', 'channel')], is_const=True) + return + +def register_Ns3Ipv4AddressHelper_methods(root_module, cls): + ## ipv4-address-helper.h: ns3::Ipv4AddressHelper::Ipv4AddressHelper() [constructor] + cls.add_constructor([], visibility='public') + ## ipv4-address-helper.h: void ns3::Ipv4AddressHelper::SetBase(ns3::Ipv4Address network, ns3::Ipv4Mask mask, ns3::Ipv4Address base="0.0.0.1") [member function] + cls.add_method('SetBase', 'void', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'mask'), param('ns3::Ipv4Address', 'base', default_value='"0.0.0.1"')]) + ## ipv4-address-helper.h: ns3::Ipv4Address ns3::Ipv4AddressHelper::NewNetwork() [member function] + cls.add_method('NewNetwork', 'ns3::Ipv4Address', []) + ## ipv4-address-helper.h: ns3::Ipv4Address ns3::Ipv4AddressHelper::NewAddress() [member function] + cls.add_method('NewAddress', 'ns3::Ipv4Address', []) + ## ipv4-address-helper.h: ns3::Ipv4InterfaceContainer ns3::Ipv4AddressHelper::Assign(ns3::NetDeviceContainer const & c) [member function] + cls.add_method('Assign', 'ns3::Ipv4InterfaceContainer', [param('ns3::NetDeviceContainer&', 'c', is_const=True)]) + return + +def register_Ns3PacketSinkHelper_methods(root_module, cls): + ## packet-sink-helper.h: ns3::PacketSinkHelper::PacketSinkHelper(std::string protocol, ns3::Address address) [constructor] + cls.add_constructor([param('std::string', 'protocol'), param('ns3::Address', 'address')], visibility='public') + ## packet-sink-helper.h: void ns3::PacketSinkHelper::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function] + cls.add_method('SetAttribute', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)]) + ## packet-sink-helper.h: ns3::ApplicationContainer ns3::PacketSinkHelper::Install(ns3::NodeContainer c) [member function] + cls.add_method('Install', 'ns3::ApplicationContainer', [param('ns3::NodeContainer', 'c')]) + return + +def register_Ns3Ns2MobilityHelper_methods(root_module, cls): + ## ns2-mobility-helper.h: ns3::Ns2MobilityHelper::Ns2MobilityHelper(std::string filename) [constructor] + cls.add_constructor([param('std::string', 'filename')], visibility='public') + ## ns2-mobility-helper.h: void ns3::Ns2MobilityHelper::Install() const [member function] + cls.add_method('Install', 'void', [], is_const=True) + return + +def register_functions(root_module): + module = root_module + register_functions_ns3_internal(module.get_submodule('internal'), root_module) + register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module) + register_functions_ns3_Config(module.get_submodule('Config'), root_module) + register_functions_ns3_olsr(module.get_submodule('olsr'), root_module) + return + +def register_functions_ns3_internal(module, root_module): + return + +def register_functions_ns3_TimeStepPrecision(module, root_module): + return + +def register_functions_ns3_Config(module, root_module): + return + +def register_functions_ns3_olsr(module, root_module): + return + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/ns3_module_internet_stack.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/ns3_module_internet_stack.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,355 @@ +from pybindgen import Module, FileCodeSink, write_preamble, param, retval + +def register_types(module): + root_module = module.get_root() + + ## ipv4-interface.h: ns3::Ipv4Interface [class] + module.add_class('Ipv4Interface', allow_subclassing=True, parent=root_module['ns3::Object']) + ## udp-header.h: ns3::UdpHeader [class] + module.add_class('UdpHeader', allow_subclassing=True, parent=root_module['ns3::Header']) + ## tcp-header.h: ns3::TcpHeader [class] + module.add_class('TcpHeader', allow_subclassing=True, parent=root_module['ns3::Header']) + ## tcp-header.h: ns3::TcpHeader::Flags_t [enumeration] + module.add_enum('Flags_t', ['NONE', 'FIN', 'SYN', 'RST', 'PSH', 'ACK', 'URG'], outer_class=root_module['ns3::TcpHeader']) + ## ipv4-static-routing.h: ns3::Ipv4StaticRouting [class] + module.add_class('Ipv4StaticRouting', allow_subclassing=True, parent=root_module['ns3::Ipv4RoutingProtocol']) + ## ipv4-l3-protocol.h: ns3::Ipv4L3Protocol [class] + module.add_class('Ipv4L3Protocol', allow_subclassing=True, parent=root_module['ns3::Object']) + + ## Register a nested module for the namespace internal + + nested_module = module.add_cpp_namespace('internal') + register_types_ns3_internal(nested_module) + + + ## Register a nested module for the namespace TimeStepPrecision + + nested_module = module.add_cpp_namespace('TimeStepPrecision') + register_types_ns3_TimeStepPrecision(nested_module) + + + ## Register a nested module for the namespace Config + + nested_module = module.add_cpp_namespace('Config') + register_types_ns3_Config(nested_module) + + + ## Register a nested module for the namespace olsr + + nested_module = module.add_cpp_namespace('olsr') + register_types_ns3_olsr(nested_module) + + +def register_types_ns3_internal(module): + root_module = module.get_root() + + +def register_types_ns3_TimeStepPrecision(module): + root_module = module.get_root() + + +def register_types_ns3_Config(module): + root_module = module.get_root() + + +def register_types_ns3_olsr(module): + root_module = module.get_root() + + +def register_methods(root_module): + register_Ns3Ipv4Interface_methods(root_module, root_module['ns3::Ipv4Interface']) + register_Ns3UdpHeader_methods(root_module, root_module['ns3::UdpHeader']) + register_Ns3TcpHeader_methods(root_module, root_module['ns3::TcpHeader']) + register_Ns3Ipv4StaticRouting_methods(root_module, root_module['ns3::Ipv4StaticRouting']) + register_Ns3Ipv4L3Protocol_methods(root_module, root_module['ns3::Ipv4L3Protocol']) + return + +def register_Ns3Ipv4Interface_methods(root_module, cls): + ## ipv4-interface.h: static ns3::TypeId ns3::Ipv4Interface::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## ipv4-interface.h: ns3::Ipv4Interface::Ipv4Interface() [constructor] + cls.add_constructor([], visibility='public') + ## ipv4-interface.h: ns3::Ptr ns3::Ipv4Interface::GetDevice() const [member function] + cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## ipv4-interface.h: void ns3::Ipv4Interface::SetAddress(ns3::Ipv4Address a) [member function] + cls.add_method('SetAddress', 'void', [param('ns3::Ipv4Address', 'a')]) + ## ipv4-interface.h: void ns3::Ipv4Interface::SetNetworkMask(ns3::Ipv4Mask mask) [member function] + cls.add_method('SetNetworkMask', 'void', [param('ns3::Ipv4Mask', 'mask')]) + ## ipv4-interface.h: ns3::Ipv4Address ns3::Ipv4Interface::GetBroadcast() const [member function] + cls.add_method('GetBroadcast', 'ns3::Ipv4Address', [], is_const=True) + ## ipv4-interface.h: ns3::Ipv4Mask ns3::Ipv4Interface::GetNetworkMask() const [member function] + cls.add_method('GetNetworkMask', 'ns3::Ipv4Mask', [], is_const=True) + ## ipv4-interface.h: void ns3::Ipv4Interface::SetMetric(uint16_t metric) [member function] + cls.add_method('SetMetric', 'void', [param('uint16_t', 'metric')]) + ## ipv4-interface.h: uint16_t ns3::Ipv4Interface::GetMetric() const [member function] + cls.add_method('GetMetric', 'uint16_t', [], is_const=True) + ## ipv4-interface.h: ns3::Ipv4Address ns3::Ipv4Interface::GetAddress() const [member function] + cls.add_method('GetAddress', 'ns3::Ipv4Address', [], is_const=True) + ## ipv4-interface.h: uint16_t ns3::Ipv4Interface::GetMtu() const [member function] + cls.add_method('GetMtu', 'uint16_t', [], is_const=True) + ## ipv4-interface.h: bool ns3::Ipv4Interface::IsUp() const [member function] + cls.add_method('IsUp', 'bool', [], is_const=True) + ## ipv4-interface.h: bool ns3::Ipv4Interface::IsDown() const [member function] + cls.add_method('IsDown', 'bool', [], is_const=True) + ## ipv4-interface.h: void ns3::Ipv4Interface::SetUp() [member function] + cls.add_method('SetUp', 'void', []) + ## ipv4-interface.h: void ns3::Ipv4Interface::SetDown() [member function] + cls.add_method('SetDown', 'void', []) + ## ipv4-interface.h: void ns3::Ipv4Interface::Send(ns3::Ptr p, ns3::Ipv4Address dest) [member function] + cls.add_method('Send', 'void', [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Address', 'dest')]) + ## ipv4-interface.h: void ns3::Ipv4Interface::DoDispose() [member function] + cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True) + ## ipv4-interface.h: void ns3::Ipv4Interface::SendTo(ns3::Ptr p, ns3::Ipv4Address dest) [member function] + cls.add_method('SendTo', 'void', [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Address', 'dest')], is_pure_virtual=True, visibility='private', is_virtual=True) + return + +def register_Ns3UdpHeader_methods(root_module, cls): + ## udp-header.h: ns3::UdpHeader::UdpHeader() [constructor] + cls.add_constructor([], visibility='public') + ## udp-header.h: void ns3::UdpHeader::EnableChecksums() [member function] + cls.add_method('EnableChecksums', 'void', []) + ## udp-header.h: void ns3::UdpHeader::SetDestinationPort(uint16_t port) [member function] + cls.add_method('SetDestinationPort', 'void', [param('uint16_t', 'port')]) + ## udp-header.h: void ns3::UdpHeader::SetSourcePort(uint16_t port) [member function] + cls.add_method('SetSourcePort', 'void', [param('uint16_t', 'port')]) + ## udp-header.h: uint16_t ns3::UdpHeader::GetSourcePort() const [member function] + cls.add_method('GetSourcePort', 'uint16_t', [], is_const=True) + ## udp-header.h: uint16_t ns3::UdpHeader::GetDestinationPort() const [member function] + cls.add_method('GetDestinationPort', 'uint16_t', [], is_const=True) + ## udp-header.h: void ns3::UdpHeader::SetPayloadSize(uint16_t size) [member function] + cls.add_method('SetPayloadSize', 'void', [param('uint16_t', 'size')]) + ## udp-header.h: void ns3::UdpHeader::InitializeChecksum(ns3::Ipv4Address source, ns3::Ipv4Address destination, uint8_t protocol) [member function] + cls.add_method('InitializeChecksum', 'void', [param('ns3::Ipv4Address', 'source'), param('ns3::Ipv4Address', 'destination'), param('uint8_t', 'protocol')]) + ## udp-header.h: static ns3::TypeId ns3::UdpHeader::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## udp-header.h: ns3::TypeId ns3::UdpHeader::GetInstanceTypeId() const [member function] + cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True) + ## udp-header.h: void ns3::UdpHeader::Print(std::ostream & os) const [member function] + cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True) + ## udp-header.h: uint32_t ns3::UdpHeader::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True) + ## udp-header.h: void ns3::UdpHeader::Serialize(ns3::Buffer::Iterator start) const [member function] + cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_const=True, is_virtual=True) + ## udp-header.h: uint32_t ns3::UdpHeader::Deserialize(ns3::Buffer::Iterator start) [member function] + cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_virtual=True) + ## udp-header.h: bool ns3::UdpHeader::IsChecksumOk() const [member function] + cls.add_method('IsChecksumOk', 'bool', [], is_const=True) + return + +def register_Ns3TcpHeader_methods(root_module, cls): + ## tcp-header.h: ns3::TcpHeader::TcpHeader() [constructor] + cls.add_constructor([], visibility='public') + ## tcp-header.h: void ns3::TcpHeader::EnableChecksums() [member function] + cls.add_method('EnableChecksums', 'void', []) + ## tcp-header.h: void ns3::TcpHeader::SetSourcePort(uint16_t port) [member function] + cls.add_method('SetSourcePort', 'void', [param('uint16_t', 'port')]) + ## tcp-header.h: void ns3::TcpHeader::SetDestinationPort(uint16_t port) [member function] + cls.add_method('SetDestinationPort', 'void', [param('uint16_t', 'port')]) + ## tcp-header.h: void ns3::TcpHeader::SetSequenceNumber(SequenceNumber sequenceNumber) [member function] + cls.add_method('SetSequenceNumber', 'void', [param('SequenceNumber', 'sequenceNumber')]) + ## tcp-header.h: void ns3::TcpHeader::SetAckNumber(SequenceNumber ackNumber) [member function] + cls.add_method('SetAckNumber', 'void', [param('SequenceNumber', 'ackNumber')]) + ## tcp-header.h: void ns3::TcpHeader::SetLength(uint8_t length) [member function] + cls.add_method('SetLength', 'void', [param('uint8_t', 'length')]) + ## tcp-header.h: void ns3::TcpHeader::SetFlags(uint8_t flags) [member function] + cls.add_method('SetFlags', 'void', [param('uint8_t', 'flags')]) + ## tcp-header.h: void ns3::TcpHeader::SetWindowSize(uint16_t windowSize) [member function] + cls.add_method('SetWindowSize', 'void', [param('uint16_t', 'windowSize')]) + ## tcp-header.h: void ns3::TcpHeader::SetChecksum(uint16_t checksum) [member function] + cls.add_method('SetChecksum', 'void', [param('uint16_t', 'checksum')]) + ## tcp-header.h: void ns3::TcpHeader::SetUrgentPointer(uint16_t urgentPointer) [member function] + cls.add_method('SetUrgentPointer', 'void', [param('uint16_t', 'urgentPointer')]) + ## tcp-header.h: uint16_t ns3::TcpHeader::GetSourcePort() const [member function] + cls.add_method('GetSourcePort', 'uint16_t', [], is_const=True) + ## tcp-header.h: uint16_t ns3::TcpHeader::GetDestinationPort() const [member function] + cls.add_method('GetDestinationPort', 'uint16_t', [], is_const=True) + ## tcp-header.h: SequenceNumber ns3::TcpHeader::GetSequenceNumber() const [member function] + cls.add_method('GetSequenceNumber', 'SequenceNumber', [], is_const=True) + ## tcp-header.h: SequenceNumber ns3::TcpHeader::GetAckNumber() const [member function] + cls.add_method('GetAckNumber', 'SequenceNumber', [], is_const=True) + ## tcp-header.h: uint8_t ns3::TcpHeader::GetLength() const [member function] + cls.add_method('GetLength', 'uint8_t', [], is_const=True) + ## tcp-header.h: uint8_t ns3::TcpHeader::GetFlags() const [member function] + cls.add_method('GetFlags', 'uint8_t', [], is_const=True) + ## tcp-header.h: uint16_t ns3::TcpHeader::GetWindowSize() const [member function] + cls.add_method('GetWindowSize', 'uint16_t', [], is_const=True) + ## tcp-header.h: uint16_t ns3::TcpHeader::GetChecksum() const [member function] + cls.add_method('GetChecksum', 'uint16_t', [], is_const=True) + ## tcp-header.h: uint16_t ns3::TcpHeader::GetUrgentPointer() const [member function] + cls.add_method('GetUrgentPointer', 'uint16_t', [], is_const=True) + ## tcp-header.h: void ns3::TcpHeader::InitializeChecksum(ns3::Ipv4Address source, ns3::Ipv4Address destination, uint8_t protocol) [member function] + cls.add_method('InitializeChecksum', 'void', [param('ns3::Ipv4Address', 'source'), param('ns3::Ipv4Address', 'destination'), param('uint8_t', 'protocol')]) + ## tcp-header.h: static ns3::TypeId ns3::TcpHeader::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## tcp-header.h: ns3::TypeId ns3::TcpHeader::GetInstanceTypeId() const [member function] + cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True) + ## tcp-header.h: void ns3::TcpHeader::Print(std::ostream & os) const [member function] + cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True) + ## tcp-header.h: uint32_t ns3::TcpHeader::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True) + ## tcp-header.h: void ns3::TcpHeader::Serialize(ns3::Buffer::Iterator start) const [member function] + cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_const=True, is_virtual=True) + ## tcp-header.h: uint32_t ns3::TcpHeader::Deserialize(ns3::Buffer::Iterator start) [member function] + cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_virtual=True) + ## tcp-header.h: void ns3::TcpHeader::SetPayloadSize(uint16_t size) [member function] + cls.add_method('SetPayloadSize', 'void', [param('uint16_t', 'size')]) + ## tcp-header.h: bool ns3::TcpHeader::IsChecksumOk() const [member function] + cls.add_method('IsChecksumOk', 'bool', [], is_const=True) + return + +def register_Ns3Ipv4StaticRouting_methods(root_module, cls): + ## ipv4-static-routing.h: ns3::Ipv4StaticRouting::Ipv4StaticRouting() [constructor] + cls.add_constructor([], visibility='public') + ## ipv4-static-routing.h: bool ns3::Ipv4StaticRouting::RequestRoute(uint32_t ifIndex, ns3::Ipv4Header const & ipHeader, ns3::Ptr packet, ns3::Callback,const ns3::Ipv4Header&,ns3::empty,ns3::empty> routeReply) [member function] + cls.add_method('RequestRoute', 'bool', [param('uint32_t', 'ifIndex'), param('ns3::Ipv4Header&', 'ipHeader', is_const=True), param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Callback< void, bool, const ns3::Ipv4Route&, ns3::Ptr< ns3::Packet >, const ns3::Ipv4Header&, ns3::empty, ns3::empty >', 'routeReply')], is_virtual=True) + ## ipv4-static-routing.h: bool ns3::Ipv4StaticRouting::RequestIfIndex(ns3::Ipv4Address destination, uint32_t & ifIndex) [member function] + cls.add_method('RequestIfIndex', 'bool', [param('ns3::Ipv4Address', 'destination'), param('uint32_t&', 'ifIndex')], is_virtual=True) + ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::AddHostRouteTo(ns3::Ipv4Address dest, ns3::Ipv4Address nextHop, uint32_t interface) [member function] + cls.add_method('AddHostRouteTo', 'void', [param('ns3::Ipv4Address', 'dest'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')]) + ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::AddHostRouteTo(ns3::Ipv4Address dest, uint32_t interface) [member function] + cls.add_method('AddHostRouteTo', 'void', [param('ns3::Ipv4Address', 'dest'), param('uint32_t', 'interface')]) + ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::AddNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, ns3::Ipv4Address nextHop, uint32_t interface) [member function] + cls.add_method('AddNetworkRouteTo', 'void', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')]) + ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::AddNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, uint32_t interface) [member function] + cls.add_method('AddNetworkRouteTo', 'void', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('uint32_t', 'interface')]) + ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::SetDefaultRoute(ns3::Ipv4Address nextHop, uint32_t interface) [member function] + cls.add_method('SetDefaultRoute', 'void', [param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')]) + ## ipv4-static-routing.h: uint32_t ns3::Ipv4StaticRouting::GetNRoutes() [member function] + cls.add_method('GetNRoutes', 'uint32_t', []) + ## ipv4-static-routing.h: ns3::Ipv4Route * ns3::Ipv4StaticRouting::GetDefaultRoute() [member function] + cls.add_method('GetDefaultRoute', 'ns3::Ipv4Route *', []) + ## ipv4-static-routing.h: ns3::Ipv4Route * ns3::Ipv4StaticRouting::GetRoute(uint32_t i) [member function] + cls.add_method('GetRoute', 'ns3::Ipv4Route *', [param('uint32_t', 'i')]) + ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::RemoveRoute(uint32_t i) [member function] + cls.add_method('RemoveRoute', 'void', [param('uint32_t', 'i')]) + ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::AddMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface, std::vector > outputInterfaces) [member function] + 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')]) + ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::SetDefaultMulticastRoute(uint32_t outputInterface) [member function] + cls.add_method('SetDefaultMulticastRoute', 'void', [param('uint32_t', 'outputInterface')]) + ## ipv4-static-routing.h: uint32_t ns3::Ipv4StaticRouting::GetNMulticastRoutes() const [member function] + cls.add_method('GetNMulticastRoutes', 'uint32_t', [], is_const=True) + ## ipv4-static-routing.h: ns3::Ipv4MulticastRoute * ns3::Ipv4StaticRouting::GetMulticastRoute(uint32_t i) const [member function] + cls.add_method('GetMulticastRoute', 'ns3::Ipv4MulticastRoute *', [param('uint32_t', 'i')], is_const=True) + ## ipv4-static-routing.h: ns3::Ipv4MulticastRoute * ns3::Ipv4StaticRouting::GetDefaultMulticastRoute() const [member function] + cls.add_method('GetDefaultMulticastRoute', 'ns3::Ipv4MulticastRoute *', [], is_const=True) + ## ipv4-static-routing.h: bool ns3::Ipv4StaticRouting::RemoveMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface) [member function] + cls.add_method('RemoveMulticastRoute', 'bool', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface')]) + ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::RemoveMulticastRoute(uint32_t index) [member function] + cls.add_method('RemoveMulticastRoute', 'void', [param('uint32_t', 'index')]) + ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::DoDispose() [member function] + cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True) + return + +def register_Ns3Ipv4L3Protocol_methods(root_module, cls): + ## ipv4-l3-protocol.h: ns3::Ipv4L3Protocol::PROT_NUMBER [variable] + cls.add_static_attribute('PROT_NUMBER', retval('uint16_t', is_const=True), is_const=True) + ## ipv4-l3-protocol.h: static ns3::TypeId ns3::Ipv4L3Protocol::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## ipv4-l3-protocol.h: ns3::Ipv4L3Protocol::Ipv4L3Protocol() [constructor] + cls.add_constructor([], visibility='public') + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetNode(ns3::Ptr node) [member function] + cls.add_method('SetNode', 'void', [param('ns3::Ptr< ns3::Node >', 'node')]) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetDefaultTtl(uint8_t ttl) [member function] + cls.add_method('SetDefaultTtl', 'void', [param('uint8_t', 'ttl')]) + ## ipv4-l3-protocol.h: ns3::Ptr ns3::Ipv4L3Protocol::FindInterfaceForDevice(ns3::Ptr device) [member function] + cls.add_method('FindInterfaceForDevice', 'ns3::Ptr< ns3::Ipv4Interface >', [param('ns3::Ptr< const ns3::NetDevice >', 'device')]) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::Receive(ns3::Ptr device, ns3::Ptr p, uint16_t protocol, ns3::Address const & from) [member function] + cls.add_method('Receive', 'void', [param('ns3::Ptr< ns3::NetDevice >', 'device'), param('ns3::Ptr< ns3::Packet >', 'p'), param('uint16_t', 'protocol'), param('ns3::Address&', 'from', is_const=True)]) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::Send(ns3::Ptr packet, ns3::Ipv4Address source, ns3::Ipv4Address destination, uint8_t protocol) [member function] + cls.add_method('Send', 'void', [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Ipv4Address', 'source'), param('ns3::Ipv4Address', 'destination'), param('uint8_t', 'protocol')]) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::AddHostRouteTo(ns3::Ipv4Address dest, ns3::Ipv4Address nextHop, uint32_t interface) [member function] + cls.add_method('AddHostRouteTo', 'void', [param('ns3::Ipv4Address', 'dest'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')]) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::AddHostRouteTo(ns3::Ipv4Address dest, uint32_t interface) [member function] + cls.add_method('AddHostRouteTo', 'void', [param('ns3::Ipv4Address', 'dest'), param('uint32_t', 'interface')]) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::AddNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, ns3::Ipv4Address nextHop, uint32_t interface) [member function] + cls.add_method('AddNetworkRouteTo', 'void', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')]) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::AddNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, uint32_t interface) [member function] + cls.add_method('AddNetworkRouteTo', 'void', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('uint32_t', 'interface')]) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetDefaultRoute(ns3::Ipv4Address nextHop, uint32_t interface) [member function] + cls.add_method('SetDefaultRoute', 'void', [param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')]) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::Lookup(ns3::Ipv4Header const & ipHeader, ns3::Ptr packet, ns3::Callback,const ns3::Ipv4Header&,ns3::empty,ns3::empty> routeReply) [member function] + cls.add_method('Lookup', 'void', [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')]) + ## ipv4-l3-protocol.h: uint32_t ns3::Ipv4L3Protocol::GetNRoutes() [member function] + cls.add_method('GetNRoutes', 'uint32_t', []) + ## ipv4-l3-protocol.h: ns3::Ipv4Route * ns3::Ipv4L3Protocol::GetRoute(uint32_t i) [member function] + cls.add_method('GetRoute', 'ns3::Ipv4Route *', [param('uint32_t', 'i')]) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::RemoveRoute(uint32_t i) [member function] + cls.add_method('RemoveRoute', 'void', [param('uint32_t', 'i')]) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::AddMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface, std::vector > outputInterfaces) [member function] + 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')]) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetDefaultMulticastRoute(uint32_t onputInterface) [member function] + cls.add_method('SetDefaultMulticastRoute', 'void', [param('uint32_t', 'onputInterface')]) + ## ipv4-l3-protocol.h: uint32_t ns3::Ipv4L3Protocol::GetNMulticastRoutes() const [member function] + cls.add_method('GetNMulticastRoutes', 'uint32_t', [], is_const=True) + ## ipv4-l3-protocol.h: ns3::Ipv4MulticastRoute * ns3::Ipv4L3Protocol::GetMulticastRoute(uint32_t i) const [member function] + cls.add_method('GetMulticastRoute', 'ns3::Ipv4MulticastRoute *', [param('uint32_t', 'i')], is_const=True) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::RemoveMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface) [member function] + cls.add_method('RemoveMulticastRoute', 'void', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface')]) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::RemoveMulticastRoute(uint32_t i) [member function] + cls.add_method('RemoveMulticastRoute', 'void', [param('uint32_t', 'i')]) + ## ipv4-l3-protocol.h: uint32_t ns3::Ipv4L3Protocol::AddInterface(ns3::Ptr device) [member function] + cls.add_method('AddInterface', 'uint32_t', [param('ns3::Ptr< ns3::NetDevice >', 'device')]) + ## ipv4-l3-protocol.h: ns3::Ptr ns3::Ipv4L3Protocol::GetInterface(uint32_t i) const [member function] + cls.add_method('GetInterface', 'ns3::Ptr< ns3::Ipv4Interface >', [param('uint32_t', 'i')], is_const=True) + ## ipv4-l3-protocol.h: uint32_t ns3::Ipv4L3Protocol::GetNInterfaces() const [member function] + cls.add_method('GetNInterfaces', 'uint32_t', [], is_const=True) + ## ipv4-l3-protocol.h: uint32_t ns3::Ipv4L3Protocol::FindInterfaceForAddr(ns3::Ipv4Address addr) const [member function] + cls.add_method('FindInterfaceForAddr', 'uint32_t', [param('ns3::Ipv4Address', 'addr')], is_const=True) + ## ipv4-l3-protocol.h: uint32_t ns3::Ipv4L3Protocol::FindInterfaceForAddr(ns3::Ipv4Address addr, ns3::Ipv4Mask mask) const [member function] + cls.add_method('FindInterfaceForAddr', 'uint32_t', [param('ns3::Ipv4Address', 'addr'), param('ns3::Ipv4Mask', 'mask')], is_const=True) + ## ipv4-l3-protocol.h: int32_t ns3::Ipv4L3Protocol::FindInterfaceIndexForDevice(ns3::Ptr device) const [member function] + cls.add_method('FindInterfaceIndexForDevice', 'int32_t', [param('ns3::Ptr< ns3::NetDevice >', 'device')], is_const=True) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::JoinMulticastGroup(ns3::Ipv4Address origin, ns3::Ipv4Address group) [member function] + cls.add_method('JoinMulticastGroup', 'void', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group')]) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::LeaveMulticastGroup(ns3::Ipv4Address origin, ns3::Ipv4Address group) [member function] + cls.add_method('LeaveMulticastGroup', 'void', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group')]) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetAddress(uint32_t i, ns3::Ipv4Address address) [member function] + cls.add_method('SetAddress', 'void', [param('uint32_t', 'i'), param('ns3::Ipv4Address', 'address')]) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetNetworkMask(uint32_t i, ns3::Ipv4Mask mask) [member function] + cls.add_method('SetNetworkMask', 'void', [param('uint32_t', 'i'), param('ns3::Ipv4Mask', 'mask')]) + ## ipv4-l3-protocol.h: ns3::Ipv4Mask ns3::Ipv4L3Protocol::GetNetworkMask(uint32_t t) const [member function] + cls.add_method('GetNetworkMask', 'ns3::Ipv4Mask', [param('uint32_t', 't')], is_const=True) + ## ipv4-l3-protocol.h: ns3::Ipv4Address ns3::Ipv4L3Protocol::GetAddress(uint32_t i) const [member function] + cls.add_method('GetAddress', 'ns3::Ipv4Address', [param('uint32_t', 'i')], is_const=True) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetMetric(uint32_t i, uint16_t metric) [member function] + cls.add_method('SetMetric', 'void', [param('uint32_t', 'i'), param('uint16_t', 'metric')]) + ## ipv4-l3-protocol.h: uint16_t ns3::Ipv4L3Protocol::GetMetric(uint32_t i) const [member function] + cls.add_method('GetMetric', 'uint16_t', [param('uint32_t', 'i')], is_const=True) + ## ipv4-l3-protocol.h: bool ns3::Ipv4L3Protocol::GetIfIndexForDestination(ns3::Ipv4Address destination, uint32_t & ifIndex) const [member function] + cls.add_method('GetIfIndexForDestination', 'bool', [param('ns3::Ipv4Address', 'destination'), param('uint32_t&', 'ifIndex')], is_const=True) + ## ipv4-l3-protocol.h: uint16_t ns3::Ipv4L3Protocol::GetMtu(uint32_t i) const [member function] + cls.add_method('GetMtu', 'uint16_t', [param('uint32_t', 'i')], is_const=True) + ## ipv4-l3-protocol.h: bool ns3::Ipv4L3Protocol::IsUp(uint32_t i) const [member function] + cls.add_method('IsUp', 'bool', [param('uint32_t', 'i')], is_const=True) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetUp(uint32_t i) [member function] + cls.add_method('SetUp', 'void', [param('uint32_t', 'i')]) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetDown(uint32_t i) [member function] + cls.add_method('SetDown', 'void', [param('uint32_t', 'i')]) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::AddRoutingProtocol(ns3::Ptr routingProtocol, int priority) [member function] + cls.add_method('AddRoutingProtocol', 'void', [param('ns3::Ptr< ns3::Ipv4RoutingProtocol >', 'routingProtocol'), param('int', 'priority')]) + ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::DoDispose() [member function] + cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True) + return + +def register_functions(root_module): + module = root_module + ## internet-stack.h: extern void ns3::AddInternetStack(ns3::Ptr node) [free function] + module.add_function('AddInternetStack', 'void', [param('ns3::Ptr< ns3::Node >', 'node')]) + register_functions_ns3_internal(module.get_submodule('internal'), root_module) + register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module) + register_functions_ns3_Config(module.get_submodule('Config'), root_module) + register_functions_ns3_olsr(module.get_submodule('olsr'), root_module) + return + +def register_functions_ns3_internal(module, root_module): + return + +def register_functions_ns3_TimeStepPrecision(module, root_module): + return + +def register_functions_ns3_Config(module, root_module): + return + +def register_functions_ns3_olsr(module, root_module): + return + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/ns3_module_mobility.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/ns3_module_mobility.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,439 @@ +from pybindgen import Module, FileCodeSink, write_preamble, param, retval + +def register_types(module): + root_module = module.get_root() + + ## static-speed-helper.h: ns3::StaticSpeedHelper [class] + module.add_class('StaticSpeedHelper', allow_subclassing=False) + ## vector.h: ns3::Vector [class] + module.add_class('Vector') + ## vector.h: ns3::VectorChecker [class] + module.add_class('VectorChecker', parent=root_module['ns3::AttributeChecker']) + ## rectangle.h: ns3::RectangleChecker [class] + module.add_class('RectangleChecker', parent=root_module['ns3::AttributeChecker']) + ## rectangle.h: ns3::Rectangle [class] + module.add_class('Rectangle') + ## rectangle.h: ns3::Rectangle::Side [enumeration] + module.add_enum('Side', ['RIGHT', 'LEFT', 'TOP', 'BOTTOM'], outer_class=root_module['ns3::Rectangle']) + ## position-allocator.h: ns3::PositionAllocator [class] + module.add_class('PositionAllocator', allow_subclassing=True, parent=root_module['ns3::Object']) + ## position-allocator.h: ns3::ListPositionAllocator [class] + module.add_class('ListPositionAllocator', allow_subclassing=True, parent=root_module['ns3::PositionAllocator']) + ## rectangle.h: ns3::RectangleValue [class] + module.add_class('RectangleValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue']) + ## position-allocator.h: ns3::RandomRectanglePositionAllocator [class] + module.add_class('RandomRectanglePositionAllocator', allow_subclassing=True, parent=root_module['ns3::PositionAllocator']) + ## vector.h: ns3::VectorValue [class] + module.add_class('VectorValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue']) + ## position-allocator.h: ns3::RandomDiscPositionAllocator [class] + module.add_class('RandomDiscPositionAllocator', allow_subclassing=True, parent=root_module['ns3::PositionAllocator']) + ## mobility-model.h: ns3::MobilityModel [class] + module.add_class('MobilityModel', allow_subclassing=True, parent=root_module['ns3::Object']) + ## random-direction-2d-mobility-model.h: ns3::RandomDirection2dMobilityModel [class] + module.add_class('RandomDirection2dMobilityModel', allow_subclassing=True, parent=root_module['ns3::MobilityModel']) + ## position-allocator.h: ns3::GridPositionAllocator [class] + module.add_class('GridPositionAllocator', allow_subclassing=True, parent=root_module['ns3::PositionAllocator']) + ## position-allocator.h: ns3::GridPositionAllocator::LayoutType [enumeration] + module.add_enum('LayoutType', ['ROW_FIRST', 'COLUMN_FIRST'], outer_class=root_module['ns3::GridPositionAllocator']) + ## random-waypoint-mobility-model.h: ns3::RandomWaypointMobilityModel [class] + module.add_class('RandomWaypointMobilityModel', allow_subclassing=True, parent=root_module['ns3::MobilityModel']) + ## random-walk-2d-mobility-model.h: ns3::RandomWalk2dMobilityModel [class] + module.add_class('RandomWalk2dMobilityModel', allow_subclassing=True, parent=root_module['ns3::MobilityModel']) + ## random-walk-2d-mobility-model.h: ns3::RandomWalk2dMobilityModel::Mode [enumeration] + module.add_enum('Mode', ['MODE_DISTANCE', 'MODE_TIME'], outer_class=root_module['ns3::RandomWalk2dMobilityModel']) + ## static-speed-mobility-model.h: ns3::StaticSpeedMobilityModel [class] + module.add_class('StaticSpeedMobilityModel', allow_subclassing=True, parent=root_module['ns3::MobilityModel']) + ## hierarchical-mobility-model.h: ns3::HierarchicalMobilityModel [class] + module.add_class('HierarchicalMobilityModel', allow_subclassing=True, parent=root_module['ns3::MobilityModel']) + ## static-mobility-model.h: ns3::StaticMobilityModel [class] + module.add_class('StaticMobilityModel', allow_subclassing=True, parent=root_module['ns3::MobilityModel']) + + ## Register a nested module for the namespace internal + + nested_module = module.add_cpp_namespace('internal') + register_types_ns3_internal(nested_module) + + + ## Register a nested module for the namespace TimeStepPrecision + + nested_module = module.add_cpp_namespace('TimeStepPrecision') + register_types_ns3_TimeStepPrecision(nested_module) + + + ## Register a nested module for the namespace Config + + nested_module = module.add_cpp_namespace('Config') + register_types_ns3_Config(nested_module) + + + ## Register a nested module for the namespace olsr + + nested_module = module.add_cpp_namespace('olsr') + register_types_ns3_olsr(nested_module) + + +def register_types_ns3_internal(module): + root_module = module.get_root() + + +def register_types_ns3_TimeStepPrecision(module): + root_module = module.get_root() + + +def register_types_ns3_Config(module): + root_module = module.get_root() + + +def register_types_ns3_olsr(module): + root_module = module.get_root() + + +def register_methods(root_module): + register_Ns3StaticSpeedHelper_methods(root_module, root_module['ns3::StaticSpeedHelper']) + register_Ns3Vector_methods(root_module, root_module['ns3::Vector']) + register_Ns3VectorChecker_methods(root_module, root_module['ns3::VectorChecker']) + register_Ns3RectangleChecker_methods(root_module, root_module['ns3::RectangleChecker']) + register_Ns3Rectangle_methods(root_module, root_module['ns3::Rectangle']) + register_Ns3PositionAllocator_methods(root_module, root_module['ns3::PositionAllocator']) + register_Ns3ListPositionAllocator_methods(root_module, root_module['ns3::ListPositionAllocator']) + register_Ns3RectangleValue_methods(root_module, root_module['ns3::RectangleValue']) + register_Ns3RandomRectanglePositionAllocator_methods(root_module, root_module['ns3::RandomRectanglePositionAllocator']) + register_Ns3VectorValue_methods(root_module, root_module['ns3::VectorValue']) + register_Ns3RandomDiscPositionAllocator_methods(root_module, root_module['ns3::RandomDiscPositionAllocator']) + register_Ns3MobilityModel_methods(root_module, root_module['ns3::MobilityModel']) + register_Ns3RandomDirection2dMobilityModel_methods(root_module, root_module['ns3::RandomDirection2dMobilityModel']) + register_Ns3GridPositionAllocator_methods(root_module, root_module['ns3::GridPositionAllocator']) + register_Ns3RandomWaypointMobilityModel_methods(root_module, root_module['ns3::RandomWaypointMobilityModel']) + register_Ns3RandomWalk2dMobilityModel_methods(root_module, root_module['ns3::RandomWalk2dMobilityModel']) + register_Ns3StaticSpeedMobilityModel_methods(root_module, root_module['ns3::StaticSpeedMobilityModel']) + register_Ns3HierarchicalMobilityModel_methods(root_module, root_module['ns3::HierarchicalMobilityModel']) + register_Ns3StaticMobilityModel_methods(root_module, root_module['ns3::StaticMobilityModel']) + return + +def register_Ns3StaticSpeedHelper_methods(root_module, cls): + ## static-speed-helper.h: ns3::StaticSpeedHelper::StaticSpeedHelper() [constructor] + cls.add_constructor([], visibility='public') + ## static-speed-helper.h: ns3::StaticSpeedHelper::StaticSpeedHelper(ns3::Vector const & position) [constructor] + cls.add_constructor([param('ns3::Vector&', 'position', is_const=True)], visibility='public') + ## static-speed-helper.h: ns3::StaticSpeedHelper::StaticSpeedHelper(ns3::Vector const & position, ns3::Vector const & speed) [constructor] + cls.add_constructor([param('ns3::Vector&', 'position', is_const=True), param('ns3::Vector&', 'speed', is_const=True)], visibility='public') + ## static-speed-helper.h: void ns3::StaticSpeedHelper::InitializePosition(ns3::Vector const & position) [member function] + cls.add_method('InitializePosition', 'void', [param('ns3::Vector&', 'position', is_const=True)]) + ## static-speed-helper.h: void ns3::StaticSpeedHelper::Reset(ns3::Vector const & speed) [member function] + cls.add_method('Reset', 'void', [param('ns3::Vector&', 'speed', is_const=True)]) + ## static-speed-helper.h: ns3::Vector ns3::StaticSpeedHelper::GetCurrentPosition(ns3::Rectangle const & bounds) const [member function] + cls.add_method('GetCurrentPosition', 'ns3::Vector', [param('ns3::Rectangle&', 'bounds', is_const=True)], is_const=True) + ## static-speed-helper.h: ns3::Vector ns3::StaticSpeedHelper::GetCurrentPosition() const [member function] + cls.add_method('GetCurrentPosition', 'ns3::Vector', [], is_const=True) + ## static-speed-helper.h: ns3::Vector ns3::StaticSpeedHelper::GetVelocity() const [member function] + cls.add_method('GetVelocity', 'ns3::Vector', [], is_const=True) + ## static-speed-helper.h: void ns3::StaticSpeedHelper::SetSpeed(ns3::Vector const & speed) [member function] + cls.add_method('SetSpeed', 'void', [param('ns3::Vector&', 'speed', is_const=True)]) + ## static-speed-helper.h: void ns3::StaticSpeedHelper::Pause() [member function] + cls.add_method('Pause', 'void', []) + ## static-speed-helper.h: void ns3::StaticSpeedHelper::Unpause() [member function] + cls.add_method('Unpause', 'void', []) + return + +def register_Ns3Vector_methods(root_module, cls): + ## vector.h: ns3::Vector::Vector(ns3::Vector const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Vector&', 'arg0', is_const=True)], visibility='public') + ## vector.h: ns3::Vector::Vector(double _x, double _y, double _z) [constructor] + cls.add_constructor([param('double', '_x'), param('double', '_y'), param('double', '_z')], visibility='public') + ## vector.h: ns3::Vector::Vector() [constructor] + cls.add_constructor([], visibility='public') + ## vector.h: ns3::Vector::x [variable] + cls.add_instance_attribute('x', 'double', is_const=False) + ## vector.h: ns3::Vector::y [variable] + cls.add_instance_attribute('y', 'double', is_const=False) + ## vector.h: ns3::Vector::z [variable] + cls.add_instance_attribute('z', 'double', is_const=False) + cls.add_output_stream_operator() + return + +def register_Ns3VectorChecker_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3RectangleChecker_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3Rectangle_methods(root_module, cls): + ## rectangle.h: ns3::Rectangle::Rectangle(ns3::Rectangle const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Rectangle&', 'arg0', is_const=True)], visibility='public') + ## rectangle.h: ns3::Rectangle::Rectangle(double _xMin, double _xMax, double _yMin, double _yMax) [constructor] + cls.add_constructor([param('double', '_xMin'), param('double', '_xMax'), param('double', '_yMin'), param('double', '_yMax')], visibility='public') + ## rectangle.h: ns3::Rectangle::Rectangle() [constructor] + cls.add_constructor([], visibility='public') + ## rectangle.h: ns3::Vector ns3::Rectangle::CalculateIntersection(ns3::Vector const & current, ns3::Vector const & speed) const [member function] + cls.add_method('CalculateIntersection', 'ns3::Vector', [param('ns3::Vector&', 'current', is_const=True), param('ns3::Vector&', 'speed', is_const=True)], is_const=True) + ## rectangle.h: ns3::Rectangle::Side ns3::Rectangle::GetClosestSide(ns3::Vector const & position) const [member function] + cls.add_method('GetClosestSide', 'ns3::Rectangle::Side', [param('ns3::Vector&', 'position', is_const=True)], is_const=True) + ## rectangle.h: bool ns3::Rectangle::IsInside(ns3::Vector const & position) const [member function] + cls.add_method('IsInside', 'bool', [param('ns3::Vector&', 'position', is_const=True)], is_const=True) + ## rectangle.h: ns3::Rectangle::xMax [variable] + cls.add_instance_attribute('xMax', 'double', is_const=False) + ## rectangle.h: ns3::Rectangle::xMin [variable] + cls.add_instance_attribute('xMin', 'double', is_const=False) + ## rectangle.h: ns3::Rectangle::yMax [variable] + cls.add_instance_attribute('yMax', 'double', is_const=False) + ## rectangle.h: ns3::Rectangle::yMin [variable] + cls.add_instance_attribute('yMin', 'double', is_const=False) + cls.add_output_stream_operator() + return + +def register_Ns3PositionAllocator_methods(root_module, cls): + ## position-allocator.h: static ns3::TypeId ns3::PositionAllocator::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## position-allocator.h: ns3::PositionAllocator::PositionAllocator() [constructor] + cls.add_constructor([], visibility='public') + ## position-allocator.h: ns3::Vector ns3::PositionAllocator::GetNext() const [member function] + cls.add_method('GetNext', 'ns3::Vector', [], is_pure_virtual=True, is_const=True, is_virtual=True) + return + +def register_Ns3ListPositionAllocator_methods(root_module, cls): + ## position-allocator.h: static ns3::TypeId ns3::ListPositionAllocator::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## position-allocator.h: ns3::ListPositionAllocator::ListPositionAllocator() [constructor] + cls.add_constructor([], visibility='public') + ## position-allocator.h: void ns3::ListPositionAllocator::Add(ns3::Vector v) [member function] + cls.add_method('Add', 'void', [param('ns3::Vector', 'v')]) + ## position-allocator.h: ns3::Vector ns3::ListPositionAllocator::GetNext() const [member function] + cls.add_method('GetNext', 'ns3::Vector', [], is_const=True, is_virtual=True) + return + +def register_Ns3RectangleValue_methods(root_module, cls): + ## rectangle.h: ns3::RectangleValue::RectangleValue() [constructor] + cls.add_constructor([], visibility='public') + ## rectangle.h: ns3::RectangleValue::RectangleValue(ns3::Rectangle const & value) [constructor] + cls.add_constructor([param('ns3::Rectangle&', 'value', is_const=True)], visibility='public') + ## rectangle.h: void ns3::RectangleValue::Set(ns3::Rectangle const & value) [member function] + cls.add_method('Set', 'void', [param('ns3::Rectangle&', 'value', is_const=True)]) + ## rectangle.h: ns3::Rectangle ns3::RectangleValue::Get() const [member function] + cls.add_method('Get', 'ns3::Rectangle', [], is_const=True) + ## rectangle.h: ns3::Ptr ns3::RectangleValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) + ## rectangle.h: std::string ns3::RectangleValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True) + ## rectangle.h: bool ns3::RectangleValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) + return + +def register_Ns3RandomRectanglePositionAllocator_methods(root_module, cls): + ## position-allocator.h: static ns3::TypeId ns3::RandomRectanglePositionAllocator::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## position-allocator.h: ns3::RandomRectanglePositionAllocator::RandomRectanglePositionAllocator() [constructor] + cls.add_constructor([], visibility='public') + ## position-allocator.h: void ns3::RandomRectanglePositionAllocator::SetX(ns3::RandomVariable x) [member function] + cls.add_method('SetX', 'void', [param('ns3::RandomVariable', 'x')]) + ## position-allocator.h: void ns3::RandomRectanglePositionAllocator::SetY(ns3::RandomVariable y) [member function] + cls.add_method('SetY', 'void', [param('ns3::RandomVariable', 'y')]) + ## position-allocator.h: ns3::Vector ns3::RandomRectanglePositionAllocator::GetNext() const [member function] + cls.add_method('GetNext', 'ns3::Vector', [], is_const=True, is_virtual=True) + return + +def register_Ns3VectorValue_methods(root_module, cls): + ## vector.h: ns3::VectorValue::VectorValue() [constructor] + cls.add_constructor([], visibility='public') + ## vector.h: ns3::VectorValue::VectorValue(ns3::Vector const & value) [constructor] + cls.add_constructor([param('ns3::Vector&', 'value', is_const=True)], visibility='public') + ## vector.h: void ns3::VectorValue::Set(ns3::Vector const & value) [member function] + cls.add_method('Set', 'void', [param('ns3::Vector&', 'value', is_const=True)]) + ## vector.h: ns3::Vector ns3::VectorValue::Get() const [member function] + cls.add_method('Get', 'ns3::Vector', [], is_const=True) + ## vector.h: ns3::Ptr ns3::VectorValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) + ## vector.h: std::string ns3::VectorValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True) + ## vector.h: bool ns3::VectorValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) + return + +def register_Ns3RandomDiscPositionAllocator_methods(root_module, cls): + ## position-allocator.h: static ns3::TypeId ns3::RandomDiscPositionAllocator::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## position-allocator.h: ns3::RandomDiscPositionAllocator::RandomDiscPositionAllocator() [constructor] + cls.add_constructor([], visibility='public') + ## position-allocator.h: void ns3::RandomDiscPositionAllocator::SetTheta(ns3::RandomVariable theta) [member function] + cls.add_method('SetTheta', 'void', [param('ns3::RandomVariable', 'theta')]) + ## position-allocator.h: void ns3::RandomDiscPositionAllocator::SetRho(ns3::RandomVariable rho) [member function] + cls.add_method('SetRho', 'void', [param('ns3::RandomVariable', 'rho')]) + ## position-allocator.h: void ns3::RandomDiscPositionAllocator::SetX(double x) [member function] + cls.add_method('SetX', 'void', [param('double', 'x')]) + ## position-allocator.h: void ns3::RandomDiscPositionAllocator::SetY(double y) [member function] + cls.add_method('SetY', 'void', [param('double', 'y')]) + ## position-allocator.h: ns3::Vector ns3::RandomDiscPositionAllocator::GetNext() const [member function] + cls.add_method('GetNext', 'ns3::Vector', [], is_const=True, is_virtual=True) + return + +def register_Ns3MobilityModel_methods(root_module, cls): + ## mobility-model.h: static ns3::TypeId ns3::MobilityModel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## mobility-model.h: ns3::MobilityModel::MobilityModel() [constructor] + cls.add_constructor([], visibility='public') + ## mobility-model.h: ns3::Vector ns3::MobilityModel::GetPosition() const [member function] + cls.add_method('GetPosition', 'ns3::Vector', [], is_const=True) + ## mobility-model.h: void ns3::MobilityModel::SetPosition(ns3::Vector const & position) [member function] + cls.add_method('SetPosition', 'void', [param('ns3::Vector&', 'position', is_const=True)]) + ## mobility-model.h: ns3::Vector ns3::MobilityModel::GetVelocity() const [member function] + cls.add_method('GetVelocity', 'ns3::Vector', [], is_const=True) + ## mobility-model.h: double ns3::MobilityModel::GetDistanceFrom(ns3::Ptr position) const [member function] + cls.add_method('GetDistanceFrom', 'double', [param('ns3::Ptr< const ns3::MobilityModel >', 'position')], is_const=True) + ## mobility-model.h: void ns3::MobilityModel::NotifyCourseChange() const [member function] + cls.add_method('NotifyCourseChange', 'void', [], is_const=True, visibility='protected') + ## mobility-model.h: ns3::Vector ns3::MobilityModel::DoGetPosition() const [member function] + cls.add_method('DoGetPosition', 'ns3::Vector', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + ## mobility-model.h: void ns3::MobilityModel::DoSetPosition(ns3::Vector const & position) [member function] + cls.add_method('DoSetPosition', 'void', [param('ns3::Vector&', 'position', is_const=True)], is_pure_virtual=True, visibility='private', is_virtual=True) + ## mobility-model.h: ns3::Vector ns3::MobilityModel::DoGetVelocity() const [member function] + cls.add_method('DoGetVelocity', 'ns3::Vector', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + return + +def register_Ns3RandomDirection2dMobilityModel_methods(root_module, cls): + ## random-direction-2d-mobility-model.h: static ns3::TypeId ns3::RandomDirection2dMobilityModel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## random-direction-2d-mobility-model.h: ns3::RandomDirection2dMobilityModel::RandomDirection2dMobilityModel() [constructor] + cls.add_constructor([], visibility='public') + ## random-direction-2d-mobility-model.h: void ns3::RandomDirection2dMobilityModel::DoDispose() [member function] + cls.add_method('DoDispose', 'void', [], visibility='private', is_virtual=True) + ## random-direction-2d-mobility-model.h: ns3::Vector ns3::RandomDirection2dMobilityModel::DoGetPosition() const [member function] + cls.add_method('DoGetPosition', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True) + ## random-direction-2d-mobility-model.h: void ns3::RandomDirection2dMobilityModel::DoSetPosition(ns3::Vector const & position) [member function] + cls.add_method('DoSetPosition', 'void', [param('ns3::Vector&', 'position', is_const=True)], visibility='private', is_virtual=True) + ## random-direction-2d-mobility-model.h: ns3::Vector ns3::RandomDirection2dMobilityModel::DoGetVelocity() const [member function] + cls.add_method('DoGetVelocity', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True) + return + +def register_Ns3GridPositionAllocator_methods(root_module, cls): + ## position-allocator.h: static ns3::TypeId ns3::GridPositionAllocator::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## position-allocator.h: ns3::GridPositionAllocator::GridPositionAllocator() [constructor] + cls.add_constructor([], visibility='public') + ## position-allocator.h: void ns3::GridPositionAllocator::SetMinX(double xMin) [member function] + cls.add_method('SetMinX', 'void', [param('double', 'xMin')]) + ## position-allocator.h: void ns3::GridPositionAllocator::SetMinY(double yMin) [member function] + cls.add_method('SetMinY', 'void', [param('double', 'yMin')]) + ## position-allocator.h: void ns3::GridPositionAllocator::SetDeltaX(double deltaX) [member function] + cls.add_method('SetDeltaX', 'void', [param('double', 'deltaX')]) + ## position-allocator.h: void ns3::GridPositionAllocator::SetDeltaY(double deltaY) [member function] + cls.add_method('SetDeltaY', 'void', [param('double', 'deltaY')]) + ## position-allocator.h: void ns3::GridPositionAllocator::SetN(uint32_t n) [member function] + cls.add_method('SetN', 'void', [param('uint32_t', 'n')]) + ## position-allocator.h: void ns3::GridPositionAllocator::SetLayoutType(ns3::GridPositionAllocator::LayoutType layoutType) [member function] + cls.add_method('SetLayoutType', 'void', [param('ns3::GridPositionAllocator::LayoutType', 'layoutType')]) + ## position-allocator.h: double ns3::GridPositionAllocator::GetMinX() const [member function] + cls.add_method('GetMinX', 'double', [], is_const=True) + ## position-allocator.h: double ns3::GridPositionAllocator::GetMinY() const [member function] + cls.add_method('GetMinY', 'double', [], is_const=True) + ## position-allocator.h: double ns3::GridPositionAllocator::GetDeltaX() const [member function] + cls.add_method('GetDeltaX', 'double', [], is_const=True) + ## position-allocator.h: double ns3::GridPositionAllocator::GetDeltaY() const [member function] + cls.add_method('GetDeltaY', 'double', [], is_const=True) + ## position-allocator.h: uint32_t ns3::GridPositionAllocator::GetN() const [member function] + cls.add_method('GetN', 'uint32_t', [], is_const=True) + ## position-allocator.h: ns3::GridPositionAllocator::LayoutType ns3::GridPositionAllocator::GetLayoutType() const [member function] + cls.add_method('GetLayoutType', 'ns3::GridPositionAllocator::LayoutType', [], is_const=True) + ## position-allocator.h: ns3::Vector ns3::GridPositionAllocator::GetNext() const [member function] + cls.add_method('GetNext', 'ns3::Vector', [], is_const=True, is_virtual=True) + return + +def register_Ns3RandomWaypointMobilityModel_methods(root_module, cls): + ## random-waypoint-mobility-model.h: static ns3::TypeId ns3::RandomWaypointMobilityModel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## random-waypoint-mobility-model.h: ns3::RandomWaypointMobilityModel::RandomWaypointMobilityModel() [constructor] + cls.add_constructor([], visibility='public') + ## random-waypoint-mobility-model.h: ns3::Vector ns3::RandomWaypointMobilityModel::DoGetPosition() const [member function] + cls.add_method('DoGetPosition', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True) + ## random-waypoint-mobility-model.h: void ns3::RandomWaypointMobilityModel::DoSetPosition(ns3::Vector const & position) [member function] + cls.add_method('DoSetPosition', 'void', [param('ns3::Vector&', 'position', is_const=True)], visibility='private', is_virtual=True) + ## random-waypoint-mobility-model.h: ns3::Vector ns3::RandomWaypointMobilityModel::DoGetVelocity() const [member function] + cls.add_method('DoGetVelocity', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True) + return + +def register_Ns3RandomWalk2dMobilityModel_methods(root_module, cls): + ## random-walk-2d-mobility-model.h: static ns3::TypeId ns3::RandomWalk2dMobilityModel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## random-walk-2d-mobility-model.h: ns3::RandomWalk2dMobilityModel::RandomWalk2dMobilityModel() [constructor] + cls.add_constructor([], visibility='public') + ## random-walk-2d-mobility-model.h: void ns3::RandomWalk2dMobilityModel::DoDispose() [member function] + cls.add_method('DoDispose', 'void', [], visibility='private', is_virtual=True) + ## random-walk-2d-mobility-model.h: ns3::Vector ns3::RandomWalk2dMobilityModel::DoGetPosition() const [member function] + cls.add_method('DoGetPosition', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True) + ## random-walk-2d-mobility-model.h: void ns3::RandomWalk2dMobilityModel::DoSetPosition(ns3::Vector const & position) [member function] + cls.add_method('DoSetPosition', 'void', [param('ns3::Vector&', 'position', is_const=True)], visibility='private', is_virtual=True) + ## random-walk-2d-mobility-model.h: ns3::Vector ns3::RandomWalk2dMobilityModel::DoGetVelocity() const [member function] + cls.add_method('DoGetVelocity', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True) + return + +def register_Ns3StaticSpeedMobilityModel_methods(root_module, cls): + ## static-speed-mobility-model.h: static ns3::TypeId ns3::StaticSpeedMobilityModel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## static-speed-mobility-model.h: ns3::StaticSpeedMobilityModel::StaticSpeedMobilityModel() [constructor] + cls.add_constructor([], visibility='public') + ## static-speed-mobility-model.h: void ns3::StaticSpeedMobilityModel::SetSpeed(ns3::Vector const & speed) [member function] + cls.add_method('SetSpeed', 'void', [param('ns3::Vector&', 'speed', is_const=True)]) + ## static-speed-mobility-model.h: ns3::Vector ns3::StaticSpeedMobilityModel::DoGetPosition() const [member function] + cls.add_method('DoGetPosition', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True) + ## static-speed-mobility-model.h: void ns3::StaticSpeedMobilityModel::DoSetPosition(ns3::Vector const & position) [member function] + cls.add_method('DoSetPosition', 'void', [param('ns3::Vector&', 'position', is_const=True)], visibility='private', is_virtual=True) + ## static-speed-mobility-model.h: ns3::Vector ns3::StaticSpeedMobilityModel::DoGetVelocity() const [member function] + cls.add_method('DoGetVelocity', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True) + return + +def register_Ns3HierarchicalMobilityModel_methods(root_module, cls): + ## hierarchical-mobility-model.h: static ns3::TypeId ns3::HierarchicalMobilityModel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## hierarchical-mobility-model.h: ns3::HierarchicalMobilityModel::HierarchicalMobilityModel() [constructor] + cls.add_constructor([], visibility='public') + ## hierarchical-mobility-model.h: ns3::Ptr ns3::HierarchicalMobilityModel::GetChild() const [member function] + cls.add_method('GetChild', 'ns3::Ptr< ns3::MobilityModel >', [], is_const=True) + ## hierarchical-mobility-model.h: ns3::Ptr ns3::HierarchicalMobilityModel::GetParent() const [member function] + cls.add_method('GetParent', 'ns3::Ptr< ns3::MobilityModel >', [], is_const=True) + ## hierarchical-mobility-model.h: ns3::Vector ns3::HierarchicalMobilityModel::DoGetPosition() const [member function] + cls.add_method('DoGetPosition', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True) + ## hierarchical-mobility-model.h: void ns3::HierarchicalMobilityModel::DoSetPosition(ns3::Vector const & position) [member function] + cls.add_method('DoSetPosition', 'void', [param('ns3::Vector&', 'position', is_const=True)], visibility='private', is_virtual=True) + ## hierarchical-mobility-model.h: ns3::Vector ns3::HierarchicalMobilityModel::DoGetVelocity() const [member function] + cls.add_method('DoGetVelocity', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True) + return + +def register_Ns3StaticMobilityModel_methods(root_module, cls): + ## static-mobility-model.h: static ns3::TypeId ns3::StaticMobilityModel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## static-mobility-model.h: ns3::StaticMobilityModel::StaticMobilityModel() [constructor] + cls.add_constructor([], visibility='public') + ## static-mobility-model.h: ns3::Vector ns3::StaticMobilityModel::DoGetPosition() const [member function] + cls.add_method('DoGetPosition', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True) + ## static-mobility-model.h: void ns3::StaticMobilityModel::DoSetPosition(ns3::Vector const & position) [member function] + cls.add_method('DoSetPosition', 'void', [param('ns3::Vector&', 'position', is_const=True)], visibility='private', is_virtual=True) + ## static-mobility-model.h: ns3::Vector ns3::StaticMobilityModel::DoGetVelocity() const [member function] + cls.add_method('DoGetVelocity', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True) + return + +def register_functions(root_module): + module = root_module + ## rectangle.h: extern ns3::Ptr ns3::MakeRectangleChecker() [free function] + module.add_function('MakeRectangleChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) + ## vector.h: extern double ns3::CalculateDistance(ns3::Vector const & a, ns3::Vector const & b) [free function] + module.add_function('CalculateDistance', 'double', [param('ns3::Vector&', 'a', is_const=True), param('ns3::Vector&', 'b', is_const=True)]) + ## vector.h: extern ns3::Ptr ns3::MakeVectorChecker() [free function] + module.add_function('MakeVectorChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) + register_functions_ns3_internal(module.get_submodule('internal'), root_module) + register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module) + register_functions_ns3_Config(module.get_submodule('Config'), root_module) + register_functions_ns3_olsr(module.get_submodule('olsr'), root_module) + return + +def register_functions_ns3_internal(module, root_module): + return + +def register_functions_ns3_TimeStepPrecision(module, root_module): + return + +def register_functions_ns3_Config(module, root_module): + return + +def register_functions_ns3_olsr(module, root_module): + return + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/ns3_module_node.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/ns3_module_node.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,1380 @@ +from pybindgen import Module, FileCodeSink, write_preamble, param, retval + +def register_types(module): + root_module = module.get_root() + + ## ethernet-header.h: ns3::ethernet_header_t [enumeration] + module.add_enum('ethernet_header_t', ['LENGTH', 'VLAN', 'QINQ']) + ## node-list.h: ns3::NodeList [class] + module.add_class('NodeList') + ## address.h: ns3::Address [class] + module.add_class('Address') + ## address.h: ns3::Address::MaxSize_e [enumeration] + module.add_enum('MaxSize_e', ['MAX_SIZE'], outer_class=root_module['ns3::Address']) + ## ipv4-address.h: ns3::Ipv4AddressChecker [class] + module.add_class('Ipv4AddressChecker', parent=root_module['ns3::AttributeChecker']) + ## mac48-address.h: ns3::Mac48Address [class] + module.add_class('Mac48Address') + ## mac48-address.h: ns3::Mac48Address [class] + root_module['ns3::Mac48Address'].implicitly_converts_to(root_module['ns3::Address']) + ## mac64-address.h: ns3::Mac64Address [class] + module.add_class('Mac64Address') + ## mac64-address.h: ns3::Mac64Address [class] + root_module['ns3::Mac64Address'].implicitly_converts_to(root_module['ns3::Address']) + ## ipv4-address-generator.h: ns3::Ipv4AddressGenerator [class] + module.add_class('Ipv4AddressGenerator') + ## mac48-address.h: ns3::Mac48AddressChecker [class] + module.add_class('Mac48AddressChecker', parent=root_module['ns3::AttributeChecker']) + ## ipv4-address.h: ns3::Ipv4MaskChecker [class] + module.add_class('Ipv4MaskChecker', parent=root_module['ns3::AttributeChecker']) + ## ipv4-route.h: ns3::Ipv4Route [class] + module.add_class('Ipv4Route') + ## ipv4-route.h: ns3::Ipv4MulticastRoute [class] + module.add_class('Ipv4MulticastRoute') + ## address.h: ns3::AddressChecker [class] + module.add_class('AddressChecker', parent=root_module['ns3::AttributeChecker']) + ## packet-socket-address.h: ns3::PacketSocketAddress [class] + module.add_class('PacketSocketAddress') + ## packet-socket-address.h: ns3::PacketSocketAddress [class] + root_module['ns3::PacketSocketAddress'].implicitly_converts_to(root_module['ns3::Address']) + ## ipv4-address.h: ns3::Ipv4Mask [class] + module.add_class('Ipv4Mask') + ## ipv4-address.h: ns3::Ipv4AddressValue [class] + module.add_class('Ipv4AddressValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue']) + ## ipv4.h: ns3::Ipv4RoutingProtocol [class] + module.add_class('Ipv4RoutingProtocol', allow_subclassing=True, parent=root_module['ns3::Object']) + ## mac48-address.h: ns3::Mac48AddressValue [class] + module.add_class('Mac48AddressValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue']) + ## ipv4-address.h: ns3::Ipv4MaskValue [class] + module.add_class('Ipv4MaskValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue']) + ## socket.h: ns3::SocketAddressTag [class] + module.add_class('SocketAddressTag', allow_subclassing=True, parent=root_module['ns3::Tag']) + ## inet-socket-address.h: ns3::InetSocketAddress [class] + module.add_class('InetSocketAddress') + ## inet-socket-address.h: ns3::InetSocketAddress [class] + root_module['ns3::InetSocketAddress'].implicitly_converts_to(root_module['ns3::Address']) + ## ipv4-address.h: ns3::Ipv4Address [class] + module.add_class('Ipv4Address') + ## ipv4-address.h: ns3::Ipv4Address [class] + root_module['ns3::Ipv4Address'].implicitly_converts_to(root_module['ns3::Address']) + ## application.h: ns3::Application [class] + module.add_class('Application', allow_subclassing=True, parent=root_module['ns3::Object']) + ## queue.h: ns3::Queue [class] + module.add_class('Queue', allow_subclassing=True, parent=root_module['ns3::Object']) + ## socket.h: ns3::Socket [class] + module.add_class('Socket', allow_subclassing=True, parent=root_module['ns3::Object']) + ## socket.h: ns3::Socket::SocketErrno [enumeration] + module.add_enum('SocketErrno', ['ERROR_NOTERROR', 'ERROR_ISCONN', 'ERROR_NOTCONN', 'ERROR_MSGSIZE', 'ERROR_AGAIN', 'ERROR_SHUTDOWN', 'ERROR_OPNOTSUPP', 'ERROR_AFNOSUPPORT', 'ERROR_INVAL', 'ERROR_BADF', 'ERROR_NOROUTETOHOST', 'SOCKET_ERRNO_LAST'], outer_class=root_module['ns3::Socket']) + ## ipv4-header.h: ns3::Ipv4Header [class] + module.add_class('Ipv4Header', allow_subclassing=True, parent=root_module['ns3::Header']) + ## udp-socket.h: ns3::UdpSocket [class] + module.add_class('UdpSocket', allow_subclassing=True, parent=root_module['ns3::Socket']) + ## net-device.h: ns3::NetDevice [class] + module.add_class('NetDevice', allow_subclassing=True, parent=root_module['ns3::Object']) + ## channel.h: ns3::Channel [class] + module.add_class('Channel', allow_subclassing=True, parent=root_module['ns3::Object']) + ## simple-channel.h: ns3::SimpleChannel [class] + module.add_class('SimpleChannel', allow_subclassing=True, parent=root_module['ns3::Channel']) + ## address.h: ns3::AddressValue [class] + module.add_class('AddressValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue']) + ## node.h: ns3::Node [class] + module.add_class('Node', allow_subclassing=True, parent=root_module['ns3::Object']) + ## tcp-socket.h: ns3::TcpSocket [class] + module.add_class('TcpSocket', allow_subclassing=True, parent=root_module['ns3::Socket']) + ## ethernet-header.h: ns3::EthernetHeader [class] + module.add_class('EthernetHeader', allow_subclassing=True, parent=root_module['ns3::Header']) + ## socket.h: ns3::SocketIpTtlTag [class] + module.add_class('SocketIpTtlTag', allow_subclassing=True, parent=root_module['ns3::Tag']) + ## ipv4.h: ns3::Ipv4 [class] + module.add_class('Ipv4', allow_subclassing=True, parent=root_module['ns3::Object']) + ## socket-factory.h: ns3::SocketFactory [class] + module.add_class('SocketFactory', allow_subclassing=True, parent=root_module['ns3::Object']) + ## drop-tail-queue.h: ns3::DropTailQueue [class] + module.add_class('DropTailQueue', allow_subclassing=True, parent=root_module['ns3::Queue']) + ## ethernet-trailer.h: ns3::EthernetTrailer [class] + module.add_class('EthernetTrailer', allow_subclassing=True, parent=root_module['ns3::Trailer']) + ## llc-snap-header.h: ns3::LlcSnapHeader [class] + module.add_class('LlcSnapHeader', allow_subclassing=True, parent=root_module['ns3::Header']) + ## udp-socket-factory.h: ns3::UdpSocketFactory [class] + module.add_class('UdpSocketFactory', allow_subclassing=True, parent=root_module['ns3::SocketFactory']) + ## simple-net-device.h: ns3::SimpleNetDevice [class] + module.add_class('SimpleNetDevice', allow_subclassing=True, parent=root_module['ns3::NetDevice']) + ## tcp-socket-factory.h: ns3::TcpSocketFactory [class] + module.add_class('TcpSocketFactory', allow_subclassing=True, parent=root_module['ns3::SocketFactory']) + ## packet-socket-factory.h: ns3::PacketSocketFactory [class] + module.add_class('PacketSocketFactory', allow_subclassing=True, parent=root_module['ns3::SocketFactory']) + + ## Register a nested module for the namespace internal + + nested_module = module.add_cpp_namespace('internal') + register_types_ns3_internal(nested_module) + + + ## Register a nested module for the namespace TimeStepPrecision + + nested_module = module.add_cpp_namespace('TimeStepPrecision') + register_types_ns3_TimeStepPrecision(nested_module) + + + ## Register a nested module for the namespace Config + + nested_module = module.add_cpp_namespace('Config') + register_types_ns3_Config(nested_module) + + + ## Register a nested module for the namespace olsr + + nested_module = module.add_cpp_namespace('olsr') + register_types_ns3_olsr(nested_module) + + +def register_types_ns3_internal(module): + root_module = module.get_root() + + +def register_types_ns3_TimeStepPrecision(module): + root_module = module.get_root() + + +def register_types_ns3_Config(module): + root_module = module.get_root() + + +def register_types_ns3_olsr(module): + root_module = module.get_root() + + +def register_methods(root_module): + register_Ns3NodeList_methods(root_module, root_module['ns3::NodeList']) + register_Ns3Address_methods(root_module, root_module['ns3::Address']) + register_Ns3Ipv4AddressChecker_methods(root_module, root_module['ns3::Ipv4AddressChecker']) + register_Ns3Mac48Address_methods(root_module, root_module['ns3::Mac48Address']) + register_Ns3Mac64Address_methods(root_module, root_module['ns3::Mac64Address']) + register_Ns3Ipv4AddressGenerator_methods(root_module, root_module['ns3::Ipv4AddressGenerator']) + register_Ns3Mac48AddressChecker_methods(root_module, root_module['ns3::Mac48AddressChecker']) + register_Ns3Ipv4MaskChecker_methods(root_module, root_module['ns3::Ipv4MaskChecker']) + register_Ns3Ipv4Route_methods(root_module, root_module['ns3::Ipv4Route']) + register_Ns3Ipv4MulticastRoute_methods(root_module, root_module['ns3::Ipv4MulticastRoute']) + register_Ns3AddressChecker_methods(root_module, root_module['ns3::AddressChecker']) + register_Ns3PacketSocketAddress_methods(root_module, root_module['ns3::PacketSocketAddress']) + register_Ns3Ipv4Mask_methods(root_module, root_module['ns3::Ipv4Mask']) + register_Ns3Ipv4AddressValue_methods(root_module, root_module['ns3::Ipv4AddressValue']) + register_Ns3Ipv4RoutingProtocol_methods(root_module, root_module['ns3::Ipv4RoutingProtocol']) + register_Ns3Mac48AddressValue_methods(root_module, root_module['ns3::Mac48AddressValue']) + register_Ns3Ipv4MaskValue_methods(root_module, root_module['ns3::Ipv4MaskValue']) + register_Ns3SocketAddressTag_methods(root_module, root_module['ns3::SocketAddressTag']) + register_Ns3InetSocketAddress_methods(root_module, root_module['ns3::InetSocketAddress']) + register_Ns3Ipv4Address_methods(root_module, root_module['ns3::Ipv4Address']) + register_Ns3Application_methods(root_module, root_module['ns3::Application']) + register_Ns3Queue_methods(root_module, root_module['ns3::Queue']) + register_Ns3Socket_methods(root_module, root_module['ns3::Socket']) + register_Ns3Ipv4Header_methods(root_module, root_module['ns3::Ipv4Header']) + register_Ns3UdpSocket_methods(root_module, root_module['ns3::UdpSocket']) + register_Ns3NetDevice_methods(root_module, root_module['ns3::NetDevice']) + register_Ns3Channel_methods(root_module, root_module['ns3::Channel']) + register_Ns3SimpleChannel_methods(root_module, root_module['ns3::SimpleChannel']) + register_Ns3AddressValue_methods(root_module, root_module['ns3::AddressValue']) + register_Ns3Node_methods(root_module, root_module['ns3::Node']) + register_Ns3TcpSocket_methods(root_module, root_module['ns3::TcpSocket']) + register_Ns3EthernetHeader_methods(root_module, root_module['ns3::EthernetHeader']) + register_Ns3SocketIpTtlTag_methods(root_module, root_module['ns3::SocketIpTtlTag']) + register_Ns3Ipv4_methods(root_module, root_module['ns3::Ipv4']) + register_Ns3SocketFactory_methods(root_module, root_module['ns3::SocketFactory']) + register_Ns3DropTailQueue_methods(root_module, root_module['ns3::DropTailQueue']) + register_Ns3EthernetTrailer_methods(root_module, root_module['ns3::EthernetTrailer']) + register_Ns3LlcSnapHeader_methods(root_module, root_module['ns3::LlcSnapHeader']) + register_Ns3UdpSocketFactory_methods(root_module, root_module['ns3::UdpSocketFactory']) + register_Ns3SimpleNetDevice_methods(root_module, root_module['ns3::SimpleNetDevice']) + register_Ns3TcpSocketFactory_methods(root_module, root_module['ns3::TcpSocketFactory']) + register_Ns3PacketSocketFactory_methods(root_module, root_module['ns3::PacketSocketFactory']) + return + +def register_Ns3NodeList_methods(root_module, cls): + ## node-list.h: static uint32_t ns3::NodeList::Add(ns3::Ptr node) [member function] + cls.add_method('Add', 'uint32_t', [param('ns3::Ptr< ns3::Node >', 'node')], is_static=True) + ## node-list.h: static __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeList::Begin() [member function] + cls.add_method('Begin', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', [], is_static=True) + ## node-list.h: static __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeList::End() [member function] + cls.add_method('End', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', [], is_static=True) + ## node-list.h: static ns3::Ptr ns3::NodeList::GetNode(uint32_t n) [member function] + cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [param('uint32_t', 'n')], is_static=True) + ## node-list.h: static uint32_t ns3::NodeList::GetNNodes() [member function] + cls.add_method('GetNNodes', 'uint32_t', [], is_static=True) + cls.add_constructor([]) + return + +def register_Ns3Address_methods(root_module, cls): + ## address.h: ns3::Address::Address() [constructor] + cls.add_constructor([], visibility='public') + ## address.h: ns3::Address::Address(uint8_t type, uint8_t const * buffer, uint8_t len) [constructor] + cls.add_constructor([param('uint8_t', 'type'), param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint8_t', 'len')], visibility='public') + ## address.h: ns3::Address::Address(ns3::Address const & address) [copy constructor] + cls.add_constructor([param('ns3::Address&', 'address', is_const=True)], visibility='public') + ## address.h: bool ns3::Address::CheckCompatible(uint8_t type, uint8_t len) const [member function] + cls.add_method('CheckCompatible', 'bool', [param('uint8_t', 'type'), param('uint8_t', 'len')], is_const=True) + ## address.h: uint32_t ns3::Address::CopyAllFrom(uint8_t const * buffer, uint8_t len) [member function] + cls.add_method('CopyAllFrom', 'uint32_t', [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint8_t', 'len')]) + ## address.h: uint32_t ns3::Address::CopyAllTo(uint8_t * buffer, uint8_t len) const [member function] + cls.add_method('CopyAllTo', 'uint32_t', [param('uint8_t *', 'buffer'), param('uint8_t', 'len')], is_const=True) + ## address.h: uint32_t ns3::Address::CopyFrom(uint8_t const * buffer, uint8_t len) [member function] + cls.add_method('CopyFrom', 'uint32_t', [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint8_t', 'len')]) + ## address.h: uint32_t ns3::Address::CopyTo(uint8_t * buffer) const [member function] + cls.add_method('CopyTo', 'uint32_t', [param('uint8_t *', 'buffer')], is_const=True) + ## address.h: void ns3::Address::Deserialize(ns3::TagBuffer buffer) [member function] + cls.add_method('Deserialize', 'void', [param('ns3::TagBuffer', 'buffer')]) + ## address.h: uint8_t ns3::Address::GetLength() const [member function] + cls.add_method('GetLength', 'uint8_t', [], is_const=True) + ## address.h: uint32_t ns3::Address::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True) + ## address.h: bool ns3::Address::IsInvalid() const [member function] + cls.add_method('IsInvalid', 'bool', [], is_const=True) + ## address.h: bool ns3::Address::IsMatchingType(uint8_t type) const [member function] + cls.add_method('IsMatchingType', 'bool', [param('uint8_t', 'type')], is_const=True) + ## address.h: static uint8_t ns3::Address::Register() [member function] + cls.add_method('Register', 'uint8_t', [], is_static=True) + ## address.h: void ns3::Address::Serialize(ns3::TagBuffer buffer) const [member function] + cls.add_method('Serialize', 'void', [param('ns3::TagBuffer', 'buffer')], is_const=True) + cls.add_output_stream_operator() + return + +def register_Ns3Ipv4AddressChecker_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3Mac48Address_methods(root_module, cls): + ## mac48-address.h: ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Mac48Address&', 'arg0', is_const=True)], visibility='public') + ## mac48-address.h: ns3::Mac48Address::Mac48Address() [constructor] + cls.add_constructor([], visibility='public') + ## mac48-address.h: ns3::Mac48Address::Mac48Address(char const * str) [constructor] + cls.add_constructor([param('char *', 'str', transfer_ownership=False, is_const=True)], visibility='public') + ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::Allocate() [member function] + cls.add_method('Allocate', 'ns3::Mac48Address', [], is_static=True) + ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::ConvertFrom(ns3::Address const & address) [member function] + cls.add_method('ConvertFrom', 'ns3::Mac48Address', [param('ns3::Address&', 'address', is_const=True)], is_static=True) + ## mac48-address.h: void ns3::Mac48Address::CopyFrom(uint8_t const * buffer) [member function] + cls.add_method('CopyFrom', 'void', [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True)]) + ## mac48-address.h: void ns3::Mac48Address::CopyTo(uint8_t * buffer) const [member function] + cls.add_method('CopyTo', 'void', [param('uint8_t *', 'buffer')], is_const=True) + ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetBroadcast() [member function] + cls.add_method('GetBroadcast', 'ns3::Mac48Address', [], is_static=True) + ## mac48-address.h: bool ns3::Mac48Address::IsBroadcast() const [member function] + cls.add_method('IsBroadcast', 'bool', [], is_const=True) + ## mac48-address.h: static bool ns3::Mac48Address::IsMatchingType(ns3::Address const & address) [member function] + cls.add_method('IsMatchingType', 'bool', [param('ns3::Address&', 'address', is_const=True)], is_static=True) + ## mac48-address.h: bool ns3::Mac48Address::IsMulticast() const [member function] + cls.add_method('IsMulticast', 'bool', [], is_const=True) + cls.add_output_stream_operator() + return + +def register_Ns3Mac64Address_methods(root_module, cls): + ## mac64-address.h: ns3::Mac64Address::Mac64Address(ns3::Mac64Address const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Mac64Address&', 'arg0', is_const=True)], visibility='public') + ## mac64-address.h: ns3::Mac64Address::Mac64Address() [constructor] + cls.add_constructor([], visibility='public') + ## mac64-address.h: ns3::Mac64Address::Mac64Address(char const * str) [constructor] + cls.add_constructor([param('char *', 'str', transfer_ownership=False, is_const=True)], visibility='public') + ## mac64-address.h: static ns3::Mac64Address ns3::Mac64Address::Allocate() [member function] + cls.add_method('Allocate', 'ns3::Mac64Address', [], is_static=True) + ## mac64-address.h: static ns3::Mac64Address ns3::Mac64Address::ConvertFrom(ns3::Address const & address) [member function] + cls.add_method('ConvertFrom', 'ns3::Mac64Address', [param('ns3::Address&', 'address', is_const=True)], is_static=True) + ## mac64-address.h: void ns3::Mac64Address::CopyFrom(uint8_t const * buffer) [member function] + cls.add_method('CopyFrom', 'void', [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True)]) + ## mac64-address.h: void ns3::Mac64Address::CopyTo(uint8_t * buffer) const [member function] + cls.add_method('CopyTo', 'void', [param('uint8_t *', 'buffer')], is_const=True) + ## mac64-address.h: static bool ns3::Mac64Address::IsMatchingType(ns3::Address const & address) [member function] + cls.add_method('IsMatchingType', 'bool', [param('ns3::Address&', 'address', is_const=True)], is_static=True) + cls.add_output_stream_operator() + return + +def register_Ns3Ipv4AddressGenerator_methods(root_module, cls): + ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::Init(ns3::Ipv4Address const net, ns3::Ipv4Mask const mask, ns3::Ipv4Address const addr="0.0.0.1") [member function] + cls.add_method('Init', 'void', [param('ns3::Ipv4Address', 'net', is_const=True), param('ns3::Ipv4Mask', 'mask', is_const=True), param('ns3::Ipv4Address', 'addr', default_value='"0.0.0.1"', is_const=True)], is_static=True) + ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::NextNetwork(ns3::Ipv4Mask const mask) [member function] + cls.add_method('NextNetwork', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask', 'mask', is_const=True)], is_static=True) + ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::GetNetwork(ns3::Ipv4Mask const mask) [member function] + cls.add_method('GetNetwork', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask', 'mask', is_const=True)], is_static=True) + ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::InitAddress(ns3::Ipv4Address const addr, ns3::Ipv4Mask const mask) [member function] + cls.add_method('InitAddress', 'void', [param('ns3::Ipv4Address', 'addr', is_const=True), param('ns3::Ipv4Mask', 'mask', is_const=True)], is_static=True) + ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::NextAddress(ns3::Ipv4Mask const mask) [member function] + cls.add_method('NextAddress', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask', 'mask', is_const=True)], is_static=True) + ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::GetAddress(ns3::Ipv4Mask const mask) [member function] + cls.add_method('GetAddress', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask', 'mask', is_const=True)], is_static=True) + ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::Reset() [member function] + cls.add_method('Reset', 'void', [], is_static=True) + ## ipv4-address-generator.h: static bool ns3::Ipv4AddressGenerator::AddAllocated(ns3::Ipv4Address const addr) [member function] + cls.add_method('AddAllocated', 'bool', [param('ns3::Ipv4Address', 'addr', is_const=True)], is_static=True) + ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::TestMode() [member function] + cls.add_method('TestMode', 'void', [], is_static=True) + cls.add_constructor([]) + return + +def register_Ns3Mac48AddressChecker_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3Ipv4MaskChecker_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3Ipv4Route_methods(root_module, cls): + ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route() [constructor] + cls.add_constructor([], visibility='public') + ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const & route) [copy constructor] + cls.add_constructor([param('ns3::Ipv4Route&', 'route', is_const=True)], visibility='public') + ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const * route) [constructor] + cls.add_constructor([param('ns3::Ipv4Route *', 'route', transfer_ownership=False, is_const=True)], visibility='public') + ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateDefaultRoute(ns3::Ipv4Address nextHop, uint32_t interface) [member function] + cls.add_method('CreateDefaultRoute', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_static=True) + ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateHostRouteTo(ns3::Ipv4Address dest, ns3::Ipv4Address nextHop, uint32_t interface) [member function] + cls.add_method('CreateHostRouteTo', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'dest'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_static=True) + ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateHostRouteTo(ns3::Ipv4Address dest, uint32_t interface) [member function] + cls.add_method('CreateHostRouteTo', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'dest'), param('uint32_t', 'interface')], is_static=True) + ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, ns3::Ipv4Address nextHop, uint32_t interface) [member function] + cls.add_method('CreateNetworkRouteTo', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_static=True) + ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, uint32_t interface) [member function] + cls.add_method('CreateNetworkRouteTo', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('uint32_t', 'interface')], is_static=True) + ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetDest() const [member function] + cls.add_method('GetDest', 'ns3::Ipv4Address', [], is_const=True) + ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetDestNetwork() const [member function] + cls.add_method('GetDestNetwork', 'ns3::Ipv4Address', [], is_const=True) + ## ipv4-route.h: ns3::Ipv4Mask ns3::Ipv4Route::GetDestNetworkMask() const [member function] + cls.add_method('GetDestNetworkMask', 'ns3::Ipv4Mask', [], is_const=True) + ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetGateway() const [member function] + cls.add_method('GetGateway', 'ns3::Ipv4Address', [], is_const=True) + ## ipv4-route.h: uint32_t ns3::Ipv4Route::GetInterface() const [member function] + cls.add_method('GetInterface', 'uint32_t', [], is_const=True) + ## ipv4-route.h: bool ns3::Ipv4Route::IsDefault() const [member function] + cls.add_method('IsDefault', 'bool', [], is_const=True) + ## ipv4-route.h: bool ns3::Ipv4Route::IsGateway() const [member function] + cls.add_method('IsGateway', 'bool', [], is_const=True) + ## ipv4-route.h: bool ns3::Ipv4Route::IsHost() const [member function] + cls.add_method('IsHost', 'bool', [], is_const=True) + ## ipv4-route.h: bool ns3::Ipv4Route::IsNetwork() const [member function] + cls.add_method('IsNetwork', 'bool', [], is_const=True) + cls.add_output_stream_operator() + return + +def register_Ns3Ipv4MulticastRoute_methods(root_module, cls): + ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute() [constructor] + cls.add_constructor([], visibility='public') + ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const & route) [copy constructor] + cls.add_constructor([param('ns3::Ipv4MulticastRoute&', 'route', is_const=True)], visibility='public') + ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const * route) [constructor] + cls.add_constructor([param('ns3::Ipv4MulticastRoute *', 'route', transfer_ownership=False, is_const=True)], visibility='public') + ## ipv4-route.h: static ns3::Ipv4MulticastRoute ns3::Ipv4MulticastRoute::CreateMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface, std::vector > outputInterfaces) [member function] + cls.add_method('CreateMulticastRoute', 'ns3::Ipv4MulticastRoute', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int, std::allocator< unsigned int > >', 'outputInterfaces')], is_static=True) + ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4MulticastRoute::GetGroup() const [member function] + cls.add_method('GetGroup', 'ns3::Ipv4Address', [], is_const=True) + ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetInputInterface() const [member function] + cls.add_method('GetInputInterface', 'uint32_t', [], is_const=True) + ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetNOutputInterfaces() const [member function] + cls.add_method('GetNOutputInterfaces', 'uint32_t', [], is_const=True) + ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4MulticastRoute::GetOrigin() const [member function] + cls.add_method('GetOrigin', 'ns3::Ipv4Address', [], is_const=True) + ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetOutputInterface(uint32_t n) const [member function] + cls.add_method('GetOutputInterface', 'uint32_t', [param('uint32_t', 'n')], is_const=True) + ## ipv4-route.h: std::vector > ns3::Ipv4MulticastRoute::GetOutputInterfaces() const [member function] + cls.add_method('GetOutputInterfaces', 'std::vector< unsigned int, std::allocator< unsigned int > >', [], is_const=True) + cls.add_output_stream_operator() + return + +def register_Ns3AddressChecker_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3PacketSocketAddress_methods(root_module, cls): + ## packet-socket-address.h: ns3::PacketSocketAddress::PacketSocketAddress() [constructor] + cls.add_constructor([], visibility='public') + ## packet-socket-address.h: void ns3::PacketSocketAddress::SetProtocol(uint16_t protocol) [member function] + cls.add_method('SetProtocol', 'void', [param('uint16_t', 'protocol')]) + ## packet-socket-address.h: void ns3::PacketSocketAddress::SetAllDevices() [member function] + cls.add_method('SetAllDevices', 'void', []) + ## packet-socket-address.h: void ns3::PacketSocketAddress::SetSingleDevice(uint32_t device) [member function] + cls.add_method('SetSingleDevice', 'void', [param('uint32_t', 'device')]) + ## packet-socket-address.h: void ns3::PacketSocketAddress::SetPhysicalAddress(ns3::Address const address) [member function] + cls.add_method('SetPhysicalAddress', 'void', [param('ns3::Address', 'address', is_const=True)]) + ## packet-socket-address.h: uint16_t ns3::PacketSocketAddress::GetProtocol() const [member function] + cls.add_method('GetProtocol', 'uint16_t', [], is_const=True) + ## packet-socket-address.h: uint32_t ns3::PacketSocketAddress::GetSingleDevice() const [member function] + cls.add_method('GetSingleDevice', 'uint32_t', [], is_const=True) + ## packet-socket-address.h: bool ns3::PacketSocketAddress::IsSingleDevice() const [member function] + cls.add_method('IsSingleDevice', 'bool', [], is_const=True) + ## packet-socket-address.h: ns3::Address ns3::PacketSocketAddress::GetPhysicalAddress() const [member function] + cls.add_method('GetPhysicalAddress', 'ns3::Address', [], is_const=True) + ## packet-socket-address.h: static ns3::PacketSocketAddress ns3::PacketSocketAddress::ConvertFrom(ns3::Address const & address) [member function] + cls.add_method('ConvertFrom', 'ns3::PacketSocketAddress', [param('ns3::Address&', 'address', is_const=True)], is_static=True) + ## packet-socket-address.h: static bool ns3::PacketSocketAddress::IsMatchingType(ns3::Address const & address) [member function] + cls.add_method('IsMatchingType', 'bool', [param('ns3::Address&', 'address', is_const=True)], is_static=True) + return + +def register_Ns3Ipv4Mask_methods(root_module, cls): + ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Ipv4Mask&', 'arg0', is_const=True)], visibility='public') + ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask() [constructor] + cls.add_constructor([], visibility='public') + ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(uint32_t mask) [constructor] + cls.add_constructor([param('uint32_t', 'mask')], visibility='public') + ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(char const * mask) [constructor] + cls.add_constructor([param('char *', 'mask', transfer_ownership=False, is_const=True)], visibility='public') + ## ipv4-address.h: uint32_t ns3::Ipv4Mask::Get() const [member function] + cls.add_method('Get', 'uint32_t', [], is_const=True) + ## ipv4-address.h: uint32_t ns3::Ipv4Mask::GetInverse() const [member function] + cls.add_method('GetInverse', 'uint32_t', [], is_const=True) + ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetLoopback() [member function] + cls.add_method('GetLoopback', 'ns3::Ipv4Mask', [], is_static=True) + ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetZero() [member function] + cls.add_method('GetZero', 'ns3::Ipv4Mask', [], is_static=True) + ## ipv4-address.h: bool ns3::Ipv4Mask::IsEqual(ns3::Ipv4Mask other) const [member function] + cls.add_method('IsEqual', 'bool', [param('ns3::Ipv4Mask', 'other')], is_const=True) + ## ipv4-address.h: bool ns3::Ipv4Mask::IsMatch(ns3::Ipv4Address a, ns3::Ipv4Address b) const [member function] + cls.add_method('IsMatch', 'bool', [param('ns3::Ipv4Address', 'a'), param('ns3::Ipv4Address', 'b')], is_const=True) + ## ipv4-address.h: void ns3::Ipv4Mask::Print(std::ostream & os) const [member function] + cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True) + ## ipv4-address.h: void ns3::Ipv4Mask::Set(uint32_t mask) [member function] + cls.add_method('Set', 'void', [param('uint32_t', 'mask')]) + cls.add_output_stream_operator() + return + +def register_Ns3Ipv4AddressValue_methods(root_module, cls): + ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue() [constructor] + cls.add_constructor([], visibility='public') + ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4Address const & value) [constructor] + cls.add_constructor([param('ns3::Ipv4Address&', 'value', is_const=True)], visibility='public') + ## ipv4-address.h: void ns3::Ipv4AddressValue::Set(ns3::Ipv4Address const & value) [member function] + cls.add_method('Set', 'void', [param('ns3::Ipv4Address&', 'value', is_const=True)]) + ## ipv4-address.h: ns3::Ipv4Address ns3::Ipv4AddressValue::Get() const [member function] + cls.add_method('Get', 'ns3::Ipv4Address', [], is_const=True) + ## ipv4-address.h: ns3::Ptr ns3::Ipv4AddressValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) + ## ipv4-address.h: std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True) + ## ipv4-address.h: bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) + return + +def register_Ns3Ipv4RoutingProtocol_methods(root_module, cls): + ## ipv4.h: ns3::Ipv4RoutingProtocol::IF_INDEX_ANY [variable] + cls.add_static_attribute('IF_INDEX_ANY', retval('uint32_t', is_const=True), is_const=True) + ## ipv4.h: bool ns3::Ipv4RoutingProtocol::RequestRoute(uint32_t ifIndex, ns3::Ipv4Header const & ipHeader, ns3::Ptr packet, ns3::Callback,const ns3::Ipv4Header&,ns3::empty,ns3::empty> routeReply) [member function] + cls.add_method('RequestRoute', 'bool', [param('uint32_t', 'ifIndex'), param('ns3::Ipv4Header&', 'ipHeader', is_const=True), param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Callback< void, bool, const ns3::Ipv4Route&, ns3::Ptr< ns3::Packet >, const ns3::Ipv4Header&, ns3::empty, ns3::empty >', 'routeReply')], is_pure_virtual=True, is_virtual=True) + ## ipv4.h: bool ns3::Ipv4RoutingProtocol::RequestIfIndex(ns3::Ipv4Address destination, uint32_t & ifIndex) [member function] + cls.add_method('RequestIfIndex', 'bool', [param('ns3::Ipv4Address', 'destination'), param('uint32_t&', 'ifIndex')], is_pure_virtual=True, is_virtual=True) + cls.add_constructor([]) + return + +def register_Ns3Mac48AddressValue_methods(root_module, cls): + ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue() [constructor] + cls.add_constructor([], visibility='public') + ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48Address const & value) [constructor] + cls.add_constructor([param('ns3::Mac48Address&', 'value', is_const=True)], visibility='public') + ## mac48-address.h: void ns3::Mac48AddressValue::Set(ns3::Mac48Address const & value) [member function] + cls.add_method('Set', 'void', [param('ns3::Mac48Address&', 'value', is_const=True)]) + ## mac48-address.h: ns3::Mac48Address ns3::Mac48AddressValue::Get() const [member function] + cls.add_method('Get', 'ns3::Mac48Address', [], is_const=True) + ## mac48-address.h: ns3::Ptr ns3::Mac48AddressValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) + ## mac48-address.h: std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True) + ## mac48-address.h: bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) + return + +def register_Ns3Ipv4MaskValue_methods(root_module, cls): + ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue() [constructor] + cls.add_constructor([], visibility='public') + ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4Mask const & value) [constructor] + cls.add_constructor([param('ns3::Ipv4Mask&', 'value', is_const=True)], visibility='public') + ## ipv4-address.h: void ns3::Ipv4MaskValue::Set(ns3::Ipv4Mask const & value) [member function] + cls.add_method('Set', 'void', [param('ns3::Ipv4Mask&', 'value', is_const=True)]) + ## ipv4-address.h: ns3::Ipv4Mask ns3::Ipv4MaskValue::Get() const [member function] + cls.add_method('Get', 'ns3::Ipv4Mask', [], is_const=True) + ## ipv4-address.h: ns3::Ptr ns3::Ipv4MaskValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) + ## ipv4-address.h: std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True) + ## ipv4-address.h: bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) + return + +def register_Ns3SocketAddressTag_methods(root_module, cls): + ## socket.h: ns3::SocketAddressTag::SocketAddressTag() [constructor] + cls.add_constructor([], visibility='public') + ## socket.h: void ns3::SocketAddressTag::SetAddress(ns3::Address addr) [member function] + cls.add_method('SetAddress', 'void', [param('ns3::Address', 'addr')]) + ## socket.h: ns3::Address ns3::SocketAddressTag::GetAddress() const [member function] + cls.add_method('GetAddress', 'ns3::Address', [], is_const=True) + ## socket.h: static ns3::TypeId ns3::SocketAddressTag::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## socket.h: ns3::TypeId ns3::SocketAddressTag::GetInstanceTypeId() const [member function] + cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True) + ## socket.h: uint32_t ns3::SocketAddressTag::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True) + ## socket.h: void ns3::SocketAddressTag::Serialize(ns3::TagBuffer i) const [member function] + cls.add_method('Serialize', 'void', [param('ns3::TagBuffer', 'i')], is_const=True, is_virtual=True) + ## socket.h: void ns3::SocketAddressTag::Deserialize(ns3::TagBuffer i) [member function] + cls.add_method('Deserialize', 'void', [param('ns3::TagBuffer', 'i')], is_virtual=True) + ## socket.h: void ns3::SocketAddressTag::Print(std::ostream & os) const [member function] + cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True) + return + +def register_Ns3InetSocketAddress_methods(root_module, cls): + ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4, uint16_t port) [constructor] + cls.add_constructor([param('ns3::Ipv4Address', 'ipv4'), param('uint16_t', 'port')], visibility='public') + ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4) [constructor] + cls.add_constructor([param('ns3::Ipv4Address', 'ipv4')], visibility='public') + ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(uint16_t port) [constructor] + cls.add_constructor([param('uint16_t', 'port')], visibility='public') + ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(char const * ipv4, uint16_t port) [constructor] + cls.add_constructor([param('char *', 'ipv4', transfer_ownership=False, is_const=True), param('uint16_t', 'port')], visibility='public') + ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(char const * ipv4) [constructor] + cls.add_constructor([param('char *', 'ipv4', transfer_ownership=False, is_const=True)], visibility='public') + ## inet-socket-address.h: uint16_t ns3::InetSocketAddress::GetPort() const [member function] + cls.add_method('GetPort', 'uint16_t', [], is_const=True) + ## inet-socket-address.h: ns3::Ipv4Address ns3::InetSocketAddress::GetIpv4() const [member function] + cls.add_method('GetIpv4', 'ns3::Ipv4Address', [], is_const=True) + ## inet-socket-address.h: void ns3::InetSocketAddress::SetPort(uint16_t port) [member function] + cls.add_method('SetPort', 'void', [param('uint16_t', 'port')]) + ## inet-socket-address.h: void ns3::InetSocketAddress::SetIpv4(ns3::Ipv4Address address) [member function] + cls.add_method('SetIpv4', 'void', [param('ns3::Ipv4Address', 'address')]) + ## inet-socket-address.h: static bool ns3::InetSocketAddress::IsMatchingType(ns3::Address const & address) [member function] + cls.add_method('IsMatchingType', 'bool', [param('ns3::Address&', 'address', is_const=True)], is_static=True) + ## inet-socket-address.h: static ns3::InetSocketAddress ns3::InetSocketAddress::ConvertFrom(ns3::Address const & address) [member function] + cls.add_method('ConvertFrom', 'ns3::InetSocketAddress', [param('ns3::Address&', 'address', is_const=True)], is_static=True) + return + +def register_Ns3Ipv4Address_methods(root_module, cls): + ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Ipv4Address&', 'arg0', is_const=True)], visibility='public') + ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address() [constructor] + cls.add_constructor([], visibility='public') + ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(uint32_t address) [constructor] + cls.add_constructor([param('uint32_t', 'address')], visibility='public') + ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(char const * address) [constructor] + cls.add_constructor([param('char *', 'address', transfer_ownership=False, is_const=True)], visibility='public') + ## ipv4-address.h: ns3::Ipv4Address ns3::Ipv4Address::CombineMask(ns3::Ipv4Mask const & mask) const [member function] + cls.add_method('CombineMask', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask&', 'mask', is_const=True)], is_const=True) + ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::ConvertFrom(ns3::Address const & address) [member function] + cls.add_method('ConvertFrom', 'ns3::Ipv4Address', [param('ns3::Address&', 'address', is_const=True)], is_static=True) + ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::Deserialize(uint8_t const * buf) [member function] + cls.add_method('Deserialize', 'ns3::Ipv4Address', [param('uint8_t *', 'buf', transfer_ownership=False, is_const=True)], is_static=True) + ## ipv4-address.h: uint32_t ns3::Ipv4Address::Get() const [member function] + cls.add_method('Get', 'uint32_t', [], is_const=True) + ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetAny() [member function] + cls.add_method('GetAny', 'ns3::Ipv4Address', [], is_static=True) + ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetBroadcast() [member function] + cls.add_method('GetBroadcast', 'ns3::Ipv4Address', [], is_static=True) + ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetLoopback() [member function] + cls.add_method('GetLoopback', 'ns3::Ipv4Address', [], is_static=True) + ## ipv4-address.h: ns3::Ipv4Address ns3::Ipv4Address::GetSubnetDirectedBroadcast(ns3::Ipv4Mask const & mask) const [member function] + cls.add_method('GetSubnetDirectedBroadcast', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask&', 'mask', is_const=True)], is_const=True) + ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetZero() [member function] + cls.add_method('GetZero', 'ns3::Ipv4Address', [], is_static=True) + ## ipv4-address.h: bool ns3::Ipv4Address::IsBroadcast() const [member function] + cls.add_method('IsBroadcast', 'bool', [], is_const=True) + ## ipv4-address.h: bool ns3::Ipv4Address::IsEqual(ns3::Ipv4Address const & other) const [member function] + cls.add_method('IsEqual', 'bool', [param('ns3::Ipv4Address&', 'other', is_const=True)], is_const=True) + ## ipv4-address.h: static bool ns3::Ipv4Address::IsMatchingType(ns3::Address const & address) [member function] + cls.add_method('IsMatchingType', 'bool', [param('ns3::Address&', 'address', is_const=True)], is_static=True) + ## ipv4-address.h: bool ns3::Ipv4Address::IsMulticast() const [member function] + cls.add_method('IsMulticast', 'bool', [], is_const=True) + ## ipv4-address.h: bool ns3::Ipv4Address::IsSubnetDirectedBroadcast(ns3::Ipv4Mask const & mask) const [member function] + cls.add_method('IsSubnetDirectedBroadcast', 'bool', [param('ns3::Ipv4Mask&', 'mask', is_const=True)], is_const=True) + ## ipv4-address.h: void ns3::Ipv4Address::Print(std::ostream & os) const [member function] + cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True) + ## ipv4-address.h: void ns3::Ipv4Address::Serialize(uint8_t * buf) const [member function] + cls.add_method('Serialize', 'void', [param('uint8_t *', 'buf')], is_const=True) + ## ipv4-address.h: void ns3::Ipv4Address::Set(uint32_t address) [member function] + cls.add_method('Set', 'void', [param('uint32_t', 'address')]) + ## ipv4-address.h: void ns3::Ipv4Address::Set(char const * address) [member function] + cls.add_method('Set', 'void', [param('char *', 'address', transfer_ownership=False, is_const=True)]) + cls.add_output_stream_operator() + return + +def register_Ns3Application_methods(root_module, cls): + ## application.h: static ns3::TypeId ns3::Application::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## application.h: ns3::Application::Application() [constructor] + cls.add_constructor([], visibility='public') + ## application.h: void ns3::Application::Start(ns3::Time const & startTime) [member function] + cls.add_method('Start', 'void', [param('ns3::Time&', 'startTime', is_const=True)]) + ## application.h: void ns3::Application::Start(ns3::RandomVariable const & startVariable) [member function] + cls.add_method('Start', 'void', [param('ns3::RandomVariable&', 'startVariable', is_const=True)]) + ## application.h: void ns3::Application::Stop(ns3::Time const & stopTime) [member function] + cls.add_method('Stop', 'void', [param('ns3::Time&', 'stopTime', is_const=True)]) + ## application.h: void ns3::Application::Stop(ns3::RandomVariable const & stopVariable) [member function] + cls.add_method('Stop', 'void', [param('ns3::RandomVariable&', 'stopVariable', is_const=True)]) + ## application.h: ns3::Ptr ns3::Application::GetNode() const [member function] + cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [], is_const=True) + ## application.h: void ns3::Application::SetNode(ns3::Ptr node) [member function] + cls.add_method('SetNode', 'void', [param('ns3::Ptr< ns3::Node >', 'node')]) + ## application.h: void ns3::Application::DoDispose() [member function] + cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True) + ## application.h: void ns3::Application::StartApplication() [member function] + cls.add_method('StartApplication', 'void', [], visibility='private', is_virtual=True) + ## application.h: void ns3::Application::StopApplication() [member function] + cls.add_method('StopApplication', 'void', [], visibility='private', is_virtual=True) + return + +def register_Ns3Queue_methods(root_module, cls): + ## queue.h: static ns3::TypeId ns3::Queue::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## queue.h: ns3::Queue::Queue() [constructor] + cls.add_constructor([], visibility='public') + ## queue.h: bool ns3::Queue::IsEmpty() const [member function] + cls.add_method('IsEmpty', 'bool', [], is_const=True) + ## queue.h: bool ns3::Queue::Enqueue(ns3::Ptr p) [member function] + cls.add_method('Enqueue', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')]) + ## queue.h: ns3::Ptr ns3::Queue::Dequeue() [member function] + cls.add_method('Dequeue', 'ns3::Ptr< ns3::Packet >', []) + ## queue.h: ns3::Ptr ns3::Queue::Peek() const [member function] + cls.add_method('Peek', 'ns3::Ptr< ns3::Packet >', [], is_const=True) + ## queue.h: void ns3::Queue::DequeueAll() [member function] + cls.add_method('DequeueAll', 'void', []) + ## queue.h: uint32_t ns3::Queue::GetNPackets() const [member function] + cls.add_method('GetNPackets', 'uint32_t', [], is_const=True) + ## queue.h: uint32_t ns3::Queue::GetNBytes() const [member function] + cls.add_method('GetNBytes', 'uint32_t', [], is_const=True) + ## queue.h: uint32_t ns3::Queue::GetTotalReceivedBytes() const [member function] + cls.add_method('GetTotalReceivedBytes', 'uint32_t', [], is_const=True) + ## queue.h: uint32_t ns3::Queue::GetTotalReceivedPackets() const [member function] + cls.add_method('GetTotalReceivedPackets', 'uint32_t', [], is_const=True) + ## queue.h: uint32_t ns3::Queue::GetTotalDroppedBytes() const [member function] + cls.add_method('GetTotalDroppedBytes', 'uint32_t', [], is_const=True) + ## queue.h: uint32_t ns3::Queue::GetTotalDroppedPackets() const [member function] + cls.add_method('GetTotalDroppedPackets', 'uint32_t', [], is_const=True) + ## queue.h: void ns3::Queue::ResetStatistics() [member function] + cls.add_method('ResetStatistics', 'void', []) + ## queue.h: void ns3::Queue::Drop(ns3::Ptr packet) [member function] + cls.add_method('Drop', 'void', [param('ns3::Ptr< ns3::Packet >', 'packet')], visibility='protected') + ## queue.h: bool ns3::Queue::DoEnqueue(ns3::Ptr p) [member function] + cls.add_method('DoEnqueue', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')], is_pure_virtual=True, visibility='private', is_virtual=True) + ## queue.h: ns3::Ptr ns3::Queue::DoDequeue() [member function] + cls.add_method('DoDequeue', 'ns3::Ptr< ns3::Packet >', [], is_pure_virtual=True, visibility='private', is_virtual=True) + ## queue.h: ns3::Ptr ns3::Queue::DoPeek() const [member function] + cls.add_method('DoPeek', 'ns3::Ptr< ns3::Packet >', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + return + +def register_Ns3Socket_methods(root_module, cls): + ## socket.h: ns3::Socket::Socket() [constructor] + cls.add_constructor([], visibility='public') + ## socket.h: static ns3::Ptr ns3::Socket::CreateSocket(ns3::Ptr node, ns3::TypeId tid) [member function] + cls.add_method('CreateSocket', 'ns3::Ptr< ns3::Socket >', [param('ns3::Ptr< ns3::Node >', 'node'), param('ns3::TypeId', 'tid')], is_static=True) + ## socket.h: ns3::Socket::SocketErrno ns3::Socket::GetErrno() const [member function] + cls.add_method('GetErrno', 'ns3::Socket::SocketErrno', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## socket.h: ns3::Ptr ns3::Socket::GetNode() const [member function] + cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## socket.h: void ns3::Socket::SetConnectCallback(ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionSucceeded, ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionFailed) [member function] + 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')]) + ## socket.h: void ns3::Socket::SetAcceptCallback(ns3::Callback, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionRequest, ns3::Callback, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty> newConnectionCreated) [member function] + 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')]) + ## socket.h: bool ns3::Socket::SetDataSentCallback(ns3::Callback, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty> dataSent) [member function] + 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) + ## socket.h: void ns3::Socket::SetSendCallback(ns3::Callback, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty> sendCb) [member function] + cls.add_method('SetSendCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'sendCb')]) + ## socket.h: void ns3::Socket::SetRecvCallback(ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> arg0) [member function] + cls.add_method('SetRecvCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'arg0')]) + ## socket.h: int ns3::Socket::Bind(ns3::Address const & address) [member function] + cls.add_method('Bind', 'int', [param('ns3::Address&', 'address', is_const=True)], is_pure_virtual=True, is_virtual=True) + ## socket.h: int ns3::Socket::Bind() [member function] + cls.add_method('Bind', 'int', [], is_pure_virtual=True, is_virtual=True) + ## socket.h: int ns3::Socket::Close() [member function] + cls.add_method('Close', 'int', [], is_pure_virtual=True, is_virtual=True) + ## socket.h: int ns3::Socket::ShutdownSend() [member function] + cls.add_method('ShutdownSend', 'int', [], is_pure_virtual=True, is_virtual=True) + ## socket.h: int ns3::Socket::ShutdownRecv() [member function] + cls.add_method('ShutdownRecv', 'int', [], is_pure_virtual=True, is_virtual=True) + ## socket.h: int ns3::Socket::Connect(ns3::Address const & address) [member function] + cls.add_method('Connect', 'int', [param('ns3::Address&', 'address', is_const=True)], is_pure_virtual=True, is_virtual=True) + ## socket.h: int ns3::Socket::Listen(uint32_t queueLimit) [member function] + cls.add_method('Listen', 'int', [param('uint32_t', 'queueLimit')], is_pure_virtual=True, is_virtual=True) + ## socket.h: uint32_t ns3::Socket::GetTxAvailable() const [member function] + cls.add_method('GetTxAvailable', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## socket.h: int ns3::Socket::Send(ns3::Ptr p, uint32_t flags) [member function] + cls.add_method('Send', 'int', [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags')], is_pure_virtual=True, is_virtual=True) + ## socket.h: int ns3::Socket::SendTo(ns3::Ptr p, uint32_t flags, ns3::Address const & toAddress) [member function] + 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) + ## socket.h: uint32_t ns3::Socket::GetRxAvailable() const [member function] + cls.add_method('GetRxAvailable', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## socket.h: ns3::Ptr ns3::Socket::Recv(uint32_t maxSize, uint32_t flags) [member function] + cls.add_method('Recv', 'ns3::Ptr< ns3::Packet >', [param('uint32_t', 'maxSize'), param('uint32_t', 'flags')], is_pure_virtual=True, is_virtual=True) + ## socket.h: ns3::Ptr ns3::Socket::RecvFrom(uint32_t maxSize, uint32_t flags, ns3::Address & fromAddress) [member function] + 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) + ## socket.h: int ns3::Socket::Send(ns3::Ptr p) [member function] + cls.add_method('Send', 'int', [param('ns3::Ptr< ns3::Packet >', 'p')]) + ## socket.h: int ns3::Socket::Send(uint8_t const * buf, uint32_t size, uint32_t flags) [member function] + cls.add_method('Send', 'int', [param('uint8_t *', 'buf', transfer_ownership=False, is_const=True), param('uint32_t', 'size'), param('uint32_t', 'flags')]) + ## socket.h: int ns3::Socket::SendTo(uint8_t const * buf, uint32_t size, uint32_t flags, ns3::Address const & address) [member function] + 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)]) + ## socket.h: ns3::Ptr ns3::Socket::Recv() [member function] + cls.add_method('Recv', 'ns3::Ptr< ns3::Packet >', []) + ## socket.h: int ns3::Socket::Recv(uint8_t * buf, uint32_t size, uint32_t flags) [member function] + cls.add_method('Recv', 'int', [param('uint8_t *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags')]) + ## socket.h: ns3::Ptr ns3::Socket::RecvFrom(ns3::Address & fromAddress) [member function] + cls.add_method('RecvFrom', 'ns3::Ptr< ns3::Packet >', [param('ns3::Address&', 'fromAddress')]) + ## socket.h: int ns3::Socket::RecvFrom(uint8_t * buf, uint32_t size, uint32_t flags, ns3::Address & fromAddress) [member function] + cls.add_method('RecvFrom', 'int', [param('uint8_t *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags'), param('ns3::Address&', 'fromAddress')]) + ## socket.h: void ns3::Socket::NotifyConnectionSucceeded() [member function] + cls.add_method('NotifyConnectionSucceeded', 'void', [], visibility='protected') + ## socket.h: void ns3::Socket::NotifyConnectionFailed() [member function] + cls.add_method('NotifyConnectionFailed', 'void', [], visibility='protected') + ## socket.h: bool ns3::Socket::NotifyConnectionRequest(ns3::Address const & from) [member function] + cls.add_method('NotifyConnectionRequest', 'bool', [param('ns3::Address&', 'from', is_const=True)], visibility='protected') + ## socket.h: void ns3::Socket::NotifyNewConnectionCreated(ns3::Ptr socket, ns3::Address const & from) [member function] + cls.add_method('NotifyNewConnectionCreated', 'void', [param('ns3::Ptr< ns3::Socket >', 'socket'), param('ns3::Address&', 'from', is_const=True)], visibility='protected') + ## socket.h: void ns3::Socket::NotifyDataSent(uint32_t size) [member function] + cls.add_method('NotifyDataSent', 'void', [param('uint32_t', 'size')], visibility='protected') + ## socket.h: void ns3::Socket::NotifySend(uint32_t spaceAvailable) [member function] + cls.add_method('NotifySend', 'void', [param('uint32_t', 'spaceAvailable')], visibility='protected') + ## socket.h: void ns3::Socket::NotifyDataRecv() [member function] + cls.add_method('NotifyDataRecv', 'void', [], visibility='protected') + return + +def register_Ns3Ipv4Header_methods(root_module, cls): + ## ipv4-header.h: ns3::Ipv4Header::Ipv4Header() [constructor] + cls.add_constructor([], visibility='public') + ## ipv4-header.h: void ns3::Ipv4Header::EnableChecksum() [member function] + cls.add_method('EnableChecksum', 'void', []) + ## ipv4-header.h: void ns3::Ipv4Header::SetPayloadSize(uint16_t size) [member function] + cls.add_method('SetPayloadSize', 'void', [param('uint16_t', 'size')]) + ## ipv4-header.h: void ns3::Ipv4Header::SetIdentification(uint16_t identification) [member function] + cls.add_method('SetIdentification', 'void', [param('uint16_t', 'identification')]) + ## ipv4-header.h: void ns3::Ipv4Header::SetTos(uint8_t tos) [member function] + cls.add_method('SetTos', 'void', [param('uint8_t', 'tos')]) + ## ipv4-header.h: void ns3::Ipv4Header::SetMoreFragments() [member function] + cls.add_method('SetMoreFragments', 'void', []) + ## ipv4-header.h: void ns3::Ipv4Header::SetLastFragment() [member function] + cls.add_method('SetLastFragment', 'void', []) + ## ipv4-header.h: void ns3::Ipv4Header::SetDontFragment() [member function] + cls.add_method('SetDontFragment', 'void', []) + ## ipv4-header.h: void ns3::Ipv4Header::SetMayFragment() [member function] + cls.add_method('SetMayFragment', 'void', []) + ## ipv4-header.h: void ns3::Ipv4Header::SetFragmentOffset(uint16_t offset) [member function] + cls.add_method('SetFragmentOffset', 'void', [param('uint16_t', 'offset')]) + ## ipv4-header.h: void ns3::Ipv4Header::SetTtl(uint8_t ttl) [member function] + cls.add_method('SetTtl', 'void', [param('uint8_t', 'ttl')]) + ## ipv4-header.h: void ns3::Ipv4Header::SetProtocol(uint8_t num) [member function] + cls.add_method('SetProtocol', 'void', [param('uint8_t', 'num')]) + ## ipv4-header.h: void ns3::Ipv4Header::SetSource(ns3::Ipv4Address source) [member function] + cls.add_method('SetSource', 'void', [param('ns3::Ipv4Address', 'source')]) + ## ipv4-header.h: void ns3::Ipv4Header::SetDestination(ns3::Ipv4Address destination) [member function] + cls.add_method('SetDestination', 'void', [param('ns3::Ipv4Address', 'destination')]) + ## ipv4-header.h: uint16_t ns3::Ipv4Header::GetPayloadSize() const [member function] + cls.add_method('GetPayloadSize', 'uint16_t', [], is_const=True) + ## ipv4-header.h: uint16_t ns3::Ipv4Header::GetIdentification() const [member function] + cls.add_method('GetIdentification', 'uint16_t', [], is_const=True) + ## ipv4-header.h: uint8_t ns3::Ipv4Header::GetTos() const [member function] + cls.add_method('GetTos', 'uint8_t', [], is_const=True) + ## ipv4-header.h: bool ns3::Ipv4Header::IsLastFragment() const [member function] + cls.add_method('IsLastFragment', 'bool', [], is_const=True) + ## ipv4-header.h: bool ns3::Ipv4Header::IsDontFragment() const [member function] + cls.add_method('IsDontFragment', 'bool', [], is_const=True) + ## ipv4-header.h: uint16_t ns3::Ipv4Header::GetFragmentOffset() const [member function] + cls.add_method('GetFragmentOffset', 'uint16_t', [], is_const=True) + ## ipv4-header.h: uint8_t ns3::Ipv4Header::GetTtl() const [member function] + cls.add_method('GetTtl', 'uint8_t', [], is_const=True) + ## ipv4-header.h: uint8_t ns3::Ipv4Header::GetProtocol() const [member function] + cls.add_method('GetProtocol', 'uint8_t', [], is_const=True) + ## ipv4-header.h: ns3::Ipv4Address ns3::Ipv4Header::GetSource() const [member function] + cls.add_method('GetSource', 'ns3::Ipv4Address', [], is_const=True) + ## ipv4-header.h: ns3::Ipv4Address ns3::Ipv4Header::GetDestination() const [member function] + cls.add_method('GetDestination', 'ns3::Ipv4Address', [], is_const=True) + ## ipv4-header.h: bool ns3::Ipv4Header::IsChecksumOk() const [member function] + cls.add_method('IsChecksumOk', 'bool', [], is_const=True) + ## ipv4-header.h: static ns3::TypeId ns3::Ipv4Header::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## ipv4-header.h: ns3::TypeId ns3::Ipv4Header::GetInstanceTypeId() const [member function] + cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True) + ## ipv4-header.h: void ns3::Ipv4Header::Print(std::ostream & os) const [member function] + cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True) + ## ipv4-header.h: uint32_t ns3::Ipv4Header::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True) + ## ipv4-header.h: void ns3::Ipv4Header::Serialize(ns3::Buffer::Iterator start) const [member function] + cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_const=True, is_virtual=True) + ## ipv4-header.h: uint32_t ns3::Ipv4Header::Deserialize(ns3::Buffer::Iterator start) [member function] + cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_virtual=True) + return + +def register_Ns3UdpSocket_methods(root_module, cls): + ## udp-socket.h: static ns3::TypeId ns3::UdpSocket::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## udp-socket.h: ns3::UdpSocket::UdpSocket() [constructor] + cls.add_constructor([], visibility='public') + ## udp-socket.h: ns3::Socket::SocketErrno ns3::UdpSocket::GetErrno() const [member function] + cls.add_method('GetErrno', 'ns3::Socket::SocketErrno', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## udp-socket.h: ns3::Ptr ns3::UdpSocket::GetNode() const [member function] + cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## udp-socket.h: int ns3::UdpSocket::Bind() [member function] + cls.add_method('Bind', 'int', [], is_pure_virtual=True, is_virtual=True) + ## udp-socket.h: int ns3::UdpSocket::Close() [member function] + cls.add_method('Close', 'int', [], is_pure_virtual=True, is_virtual=True) + ## udp-socket.h: int ns3::UdpSocket::ShutdownSend() [member function] + cls.add_method('ShutdownSend', 'int', [], is_pure_virtual=True, is_virtual=True) + ## udp-socket.h: int ns3::UdpSocket::ShutdownRecv() [member function] + cls.add_method('ShutdownRecv', 'int', [], is_pure_virtual=True, is_virtual=True) + ## udp-socket.h: int ns3::UdpSocket::Connect(ns3::Address const & address) [member function] + cls.add_method('Connect', 'int', [param('ns3::Address&', 'address', is_const=True)], is_pure_virtual=True, is_virtual=True) + ## udp-socket.h: uint32_t ns3::UdpSocket::GetTxAvailable() const [member function] + cls.add_method('GetTxAvailable', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## udp-socket.h: int ns3::UdpSocket::Send(ns3::Ptr p, uint32_t flags) [member function] + cls.add_method('Send', 'int', [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags')], is_pure_virtual=True, is_virtual=True) + ## udp-socket.h: int ns3::UdpSocket::SendTo(ns3::Ptr p, uint32_t flags, ns3::Address const & toAddress) [member function] + 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) + ## udp-socket.h: uint32_t ns3::UdpSocket::GetRxAvailable() const [member function] + cls.add_method('GetRxAvailable', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## udp-socket.h: ns3::Ptr ns3::UdpSocket::Recv(uint32_t maxSize, uint32_t flags) [member function] + cls.add_method('Recv', 'ns3::Ptr< ns3::Packet >', [param('uint32_t', 'maxSize'), param('uint32_t', 'flags')], is_pure_virtual=True, is_virtual=True) + ## udp-socket.h: ns3::Ptr ns3::UdpSocket::RecvFrom(uint32_t maxSize, uint32_t flags, ns3::Address & fromAddress) [member function] + 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) + ## udp-socket.h: void ns3::UdpSocket::SetRcvBufSize(uint32_t size) [member function] + cls.add_method('SetRcvBufSize', 'void', [param('uint32_t', 'size')], is_pure_virtual=True, visibility='private', is_virtual=True) + ## udp-socket.h: uint32_t ns3::UdpSocket::GetRcvBufSize() const [member function] + cls.add_method('GetRcvBufSize', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + ## udp-socket.h: void ns3::UdpSocket::SetIpTtl(uint32_t ipTtl) [member function] + cls.add_method('SetIpTtl', 'void', [param('uint32_t', 'ipTtl')], is_pure_virtual=True, visibility='private', is_virtual=True) + ## udp-socket.h: uint32_t ns3::UdpSocket::GetIpTtl() const [member function] + cls.add_method('GetIpTtl', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + ## udp-socket.h: void ns3::UdpSocket::SetIpMulticastTtl(uint32_t ipTtl) [member function] + cls.add_method('SetIpMulticastTtl', 'void', [param('uint32_t', 'ipTtl')], is_pure_virtual=True, visibility='private', is_virtual=True) + ## udp-socket.h: uint32_t ns3::UdpSocket::GetIpMulticastTtl() const [member function] + cls.add_method('GetIpMulticastTtl', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + return + +def register_Ns3NetDevice_methods(root_module, cls): + ## net-device.h: static ns3::TypeId ns3::NetDevice::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## net-device.h: void ns3::NetDevice::SetName(std::string const name) [member function] + cls.add_method('SetName', 'void', [param('std::string', 'name', is_const=True)], is_pure_virtual=True, is_virtual=True) + ## net-device.h: std::string ns3::NetDevice::GetName() const [member function] + cls.add_method('GetName', 'std::string', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## net-device.h: void ns3::NetDevice::SetIfIndex(uint32_t const index) [member function] + cls.add_method('SetIfIndex', 'void', [param('uint32_t', 'index', is_const=True)], is_pure_virtual=True, is_virtual=True) + ## net-device.h: uint32_t ns3::NetDevice::GetIfIndex() const [member function] + cls.add_method('GetIfIndex', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## net-device.h: ns3::Ptr ns3::NetDevice::GetChannel() const [member function] + cls.add_method('GetChannel', 'ns3::Ptr< ns3::Channel >', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## net-device.h: ns3::Address ns3::NetDevice::GetAddress() const [member function] + cls.add_method('GetAddress', 'ns3::Address', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## net-device.h: bool ns3::NetDevice::SetMtu(uint16_t const mtu) [member function] + cls.add_method('SetMtu', 'bool', [param('uint16_t', 'mtu', is_const=True)], is_pure_virtual=True, is_virtual=True) + ## net-device.h: uint16_t ns3::NetDevice::GetMtu() const [member function] + cls.add_method('GetMtu', 'uint16_t', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## net-device.h: bool ns3::NetDevice::IsLinkUp() const [member function] + cls.add_method('IsLinkUp', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## net-device.h: void ns3::NetDevice::SetLinkChangeCallback(ns3::Callback callback) [member function] + 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) + ## net-device.h: bool ns3::NetDevice::IsBroadcast() const [member function] + cls.add_method('IsBroadcast', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## net-device.h: ns3::Address ns3::NetDevice::GetBroadcast() const [member function] + cls.add_method('GetBroadcast', 'ns3::Address', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## net-device.h: bool ns3::NetDevice::IsMulticast() const [member function] + cls.add_method('IsMulticast', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## net-device.h: ns3::Address ns3::NetDevice::GetMulticast() const [member function] + cls.add_method('GetMulticast', 'ns3::Address', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## net-device.h: ns3::Address ns3::NetDevice::MakeMulticastAddress(ns3::Ipv4Address multicastGroup) const [member function] + cls.add_method('MakeMulticastAddress', 'ns3::Address', [param('ns3::Ipv4Address', 'multicastGroup')], is_pure_virtual=True, is_const=True, is_virtual=True) + ## net-device.h: bool ns3::NetDevice::IsPointToPoint() const [member function] + cls.add_method('IsPointToPoint', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## net-device.h: bool ns3::NetDevice::Send(ns3::Ptr packet, ns3::Address const & dest, uint16_t protocolNumber) [member function] + 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) + ## net-device.h: ns3::Ptr ns3::NetDevice::GetNode() const [member function] + cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## net-device.h: void ns3::NetDevice::SetNode(ns3::Ptr node) [member function] + cls.add_method('SetNode', 'void', [param('ns3::Ptr< ns3::Node >', 'node')], is_pure_virtual=True, is_virtual=True) + ## net-device.h: bool ns3::NetDevice::NeedsArp() const [member function] + cls.add_method('NeedsArp', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## net-device.h: void ns3::NetDevice::SetReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function] + 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) + cls.add_constructor([]) + return + +def register_Ns3Channel_methods(root_module, cls): + ## channel.h: static ns3::TypeId ns3::Channel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## channel.h: ns3::Channel::Channel() [constructor] + cls.add_constructor([], visibility='public') + ## channel.h: ns3::Channel::Channel(std::string name) [constructor] + cls.add_constructor([param('std::string', 'name')], visibility='public') + ## channel.h: void ns3::Channel::SetName(std::string arg0) [member function] + cls.add_method('SetName', 'void', [param('std::string', 'arg0')]) + ## channel.h: std::string ns3::Channel::GetName() [member function] + cls.add_method('GetName', 'std::string', []) + ## channel.h: uint32_t ns3::Channel::GetNDevices() const [member function] + cls.add_method('GetNDevices', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## channel.h: ns3::Ptr ns3::Channel::GetDevice(uint32_t i) const [member function] + cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', [param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True) + return + +def register_Ns3SimpleChannel_methods(root_module, cls): + ## simple-channel.h: static ns3::TypeId ns3::SimpleChannel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## simple-channel.h: ns3::SimpleChannel::SimpleChannel() [constructor] + cls.add_constructor([], visibility='public') + ## simple-channel.h: void ns3::SimpleChannel::Send(ns3::Ptr p, uint16_t protocol, ns3::Mac48Address to, ns3::Mac48Address from, ns3::Ptr sender) [member function] + 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')]) + ## simple-channel.h: void ns3::SimpleChannel::Add(ns3::Ptr device) [member function] + cls.add_method('Add', 'void', [param('ns3::Ptr< ns3::SimpleNetDevice >', 'device')]) + ## simple-channel.h: uint32_t ns3::SimpleChannel::GetNDevices() const [member function] + cls.add_method('GetNDevices', 'uint32_t', [], is_const=True, is_virtual=True) + ## simple-channel.h: ns3::Ptr ns3::SimpleChannel::GetDevice(uint32_t i) const [member function] + cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', [param('uint32_t', 'i')], is_const=True, is_virtual=True) + return + +def register_Ns3AddressValue_methods(root_module, cls): + ## address.h: ns3::AddressValue::AddressValue() [constructor] + cls.add_constructor([], visibility='public') + ## address.h: ns3::AddressValue::AddressValue(ns3::Address const & value) [constructor] + cls.add_constructor([param('ns3::Address&', 'value', is_const=True)], visibility='public') + ## address.h: void ns3::AddressValue::Set(ns3::Address const & value) [member function] + cls.add_method('Set', 'void', [param('ns3::Address&', 'value', is_const=True)]) + ## address.h: ns3::Address ns3::AddressValue::Get() const [member function] + cls.add_method('Get', 'ns3::Address', [], is_const=True) + ## address.h: ns3::Ptr ns3::AddressValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) + ## address.h: std::string ns3::AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True) + ## address.h: bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) + return + +def register_Ns3Node_methods(root_module, cls): + ## node.h: static ns3::TypeId ns3::Node::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## node.h: ns3::Node::Node() [constructor] + cls.add_constructor([], visibility='public') + ## node.h: ns3::Node::Node(uint32_t systemId) [constructor] + cls.add_constructor([param('uint32_t', 'systemId')], visibility='public') + ## node.h: uint32_t ns3::Node::GetId() const [member function] + cls.add_method('GetId', 'uint32_t', [], is_const=True) + ## node.h: uint32_t ns3::Node::GetSystemId() const [member function] + cls.add_method('GetSystemId', 'uint32_t', [], is_const=True) + ## node.h: uint32_t ns3::Node::AddDevice(ns3::Ptr device) [member function] + cls.add_method('AddDevice', 'uint32_t', [param('ns3::Ptr< ns3::NetDevice >', 'device')]) + ## node.h: ns3::Ptr ns3::Node::GetDevice(uint32_t index) const [member function] + cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', [param('uint32_t', 'index')], is_const=True) + ## node.h: uint32_t ns3::Node::GetNDevices() const [member function] + cls.add_method('GetNDevices', 'uint32_t', [], is_const=True) + ## node.h: uint32_t ns3::Node::AddApplication(ns3::Ptr application) [member function] + cls.add_method('AddApplication', 'uint32_t', [param('ns3::Ptr< ns3::Application >', 'application')]) + ## node.h: ns3::Ptr ns3::Node::GetApplication(uint32_t index) const [member function] + cls.add_method('GetApplication', 'ns3::Ptr< ns3::Application >', [param('uint32_t', 'index')], is_const=True) + ## node.h: ns3::Ptr ns3::Node::GetFirstApplication(ns3::TypeId tid) [member function] + cls.add_method('GetFirstApplication', 'ns3::Ptr< ns3::Application >', [param('ns3::TypeId', 'tid')]) + ## node.h: uint32_t ns3::Node::GetNApplications() const [member function] + cls.add_method('GetNApplications', 'uint32_t', [], is_const=True) + ## node.h: void ns3::Node::RegisterProtocolHandler(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> handler, uint16_t protocolType, ns3::Ptr device) [member function] + 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')]) + ## node.h: void ns3::Node::UnregisterProtocolHandler(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> handler) [member function] + 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')]) + ## node.h: void ns3::Node::DoDispose() [member function] + cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True) + ## node.h: void ns3::Node::NotifyDeviceAdded(ns3::Ptr device) [member function] + cls.add_method('NotifyDeviceAdded', 'void', [param('ns3::Ptr< ns3::NetDevice >', 'device')], visibility='private', is_virtual=True) + return + +def register_Ns3TcpSocket_methods(root_module, cls): + ## tcp-socket.h: static ns3::TypeId ns3::TcpSocket::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## tcp-socket.h: ns3::TcpSocket::TcpSocket() [constructor] + cls.add_constructor([], visibility='public') + ## tcp-socket.h: ns3::Socket::SocketErrno ns3::TcpSocket::GetErrno() const [member function] + cls.add_method('GetErrno', 'ns3::Socket::SocketErrno', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## tcp-socket.h: ns3::Ptr ns3::TcpSocket::GetNode() const [member function] + cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## tcp-socket.h: int ns3::TcpSocket::Bind() [member function] + cls.add_method('Bind', 'int', [], is_pure_virtual=True, is_virtual=True) + ## tcp-socket.h: int ns3::TcpSocket::Close() [member function] + cls.add_method('Close', 'int', [], is_pure_virtual=True, is_virtual=True) + ## tcp-socket.h: int ns3::TcpSocket::ShutdownSend() [member function] + cls.add_method('ShutdownSend', 'int', [], is_pure_virtual=True, is_virtual=True) + ## tcp-socket.h: int ns3::TcpSocket::ShutdownRecv() [member function] + cls.add_method('ShutdownRecv', 'int', [], is_pure_virtual=True, is_virtual=True) + ## tcp-socket.h: int ns3::TcpSocket::Connect(ns3::Address const & address) [member function] + cls.add_method('Connect', 'int', [param('ns3::Address&', 'address', is_const=True)], is_pure_virtual=True, is_virtual=True) + ## tcp-socket.h: uint32_t ns3::TcpSocket::GetTxAvailable() const [member function] + cls.add_method('GetTxAvailable', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## tcp-socket.h: int ns3::TcpSocket::Send(ns3::Ptr p, uint32_t flags) [member function] + cls.add_method('Send', 'int', [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags')], is_pure_virtual=True, is_virtual=True) + ## tcp-socket.h: int ns3::TcpSocket::SendTo(ns3::Ptr p, uint32_t flags, ns3::Address const & toAddress) [member function] + 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) + ## tcp-socket.h: uint32_t ns3::TcpSocket::GetRxAvailable() const [member function] + cls.add_method('GetRxAvailable', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## tcp-socket.h: ns3::Ptr ns3::TcpSocket::Recv(uint32_t maxSize, uint32_t flags) [member function] + cls.add_method('Recv', 'ns3::Ptr< ns3::Packet >', [param('uint32_t', 'maxSize'), param('uint32_t', 'flags')], is_pure_virtual=True, is_virtual=True) + ## tcp-socket.h: ns3::Ptr ns3::TcpSocket::RecvFrom(uint32_t maxSize, uint32_t flags, ns3::Address & fromAddress) [member function] + 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) + ## tcp-socket.h: void ns3::TcpSocket::SetSndBufSize(uint32_t size) [member function] + cls.add_method('SetSndBufSize', 'void', [param('uint32_t', 'size')], is_pure_virtual=True, visibility='private', is_virtual=True) + ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSndBufSize() const [member function] + cls.add_method('GetSndBufSize', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + ## tcp-socket.h: void ns3::TcpSocket::SetRcvBufSize(uint32_t size) [member function] + cls.add_method('SetRcvBufSize', 'void', [param('uint32_t', 'size')], is_pure_virtual=True, visibility='private', is_virtual=True) + ## tcp-socket.h: uint32_t ns3::TcpSocket::GetRcvBufSize() const [member function] + cls.add_method('GetRcvBufSize', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + ## tcp-socket.h: void ns3::TcpSocket::SetSegSize(uint32_t size) [member function] + cls.add_method('SetSegSize', 'void', [param('uint32_t', 'size')], is_pure_virtual=True, visibility='private', is_virtual=True) + ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSegSize() const [member function] + cls.add_method('GetSegSize', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + ## tcp-socket.h: void ns3::TcpSocket::SetAdvWin(uint32_t window) [member function] + cls.add_method('SetAdvWin', 'void', [param('uint32_t', 'window')], is_pure_virtual=True, visibility='private', is_virtual=True) + ## tcp-socket.h: uint32_t ns3::TcpSocket::GetAdvWin() const [member function] + cls.add_method('GetAdvWin', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + ## tcp-socket.h: void ns3::TcpSocket::SetSSThresh(uint32_t threshold) [member function] + cls.add_method('SetSSThresh', 'void', [param('uint32_t', 'threshold')], is_pure_virtual=True, visibility='private', is_virtual=True) + ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSSThresh() const [member function] + cls.add_method('GetSSThresh', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + ## tcp-socket.h: void ns3::TcpSocket::SetInitialCwnd(uint32_t count) [member function] + cls.add_method('SetInitialCwnd', 'void', [param('uint32_t', 'count')], is_pure_virtual=True, visibility='private', is_virtual=True) + ## tcp-socket.h: uint32_t ns3::TcpSocket::GetInitialCwnd() const [member function] + cls.add_method('GetInitialCwnd', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + ## tcp-socket.h: void ns3::TcpSocket::SetConnTimeout(ns3::Time timeout) [member function] + cls.add_method('SetConnTimeout', 'void', [param('ns3::Time', 'timeout')], is_pure_virtual=True, visibility='private', is_virtual=True) + ## tcp-socket.h: ns3::Time ns3::TcpSocket::GetConnTimeout() const [member function] + cls.add_method('GetConnTimeout', 'ns3::Time', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + ## tcp-socket.h: void ns3::TcpSocket::SetConnCount(uint32_t count) [member function] + cls.add_method('SetConnCount', 'void', [param('uint32_t', 'count')], is_pure_virtual=True, visibility='private', is_virtual=True) + ## tcp-socket.h: uint32_t ns3::TcpSocket::GetConnCount() const [member function] + cls.add_method('GetConnCount', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + ## tcp-socket.h: void ns3::TcpSocket::SetDelAckTimeout(ns3::Time timeout) [member function] + cls.add_method('SetDelAckTimeout', 'void', [param('ns3::Time', 'timeout')], is_pure_virtual=True, visibility='private', is_virtual=True) + ## tcp-socket.h: ns3::Time ns3::TcpSocket::GetDelAckTimeout() const [member function] + cls.add_method('GetDelAckTimeout', 'ns3::Time', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + ## tcp-socket.h: void ns3::TcpSocket::SetDelAckMaxCount(uint32_t count) [member function] + cls.add_method('SetDelAckMaxCount', 'void', [param('uint32_t', 'count')], is_pure_virtual=True, visibility='private', is_virtual=True) + ## tcp-socket.h: uint32_t ns3::TcpSocket::GetDelAckMaxCount() const [member function] + cls.add_method('GetDelAckMaxCount', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + return + +def register_Ns3EthernetHeader_methods(root_module, cls): + ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader(bool hasPreamble) [constructor] + cls.add_constructor([param('bool', 'hasPreamble')], visibility='public') + ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader() [constructor] + cls.add_constructor([], visibility='public') + ## ethernet-header.h: void ns3::EthernetHeader::SetLengthType(uint16_t size) [member function] + cls.add_method('SetLengthType', 'void', [param('uint16_t', 'size')]) + ## ethernet-header.h: void ns3::EthernetHeader::SetSource(ns3::Mac48Address source) [member function] + cls.add_method('SetSource', 'void', [param('ns3::Mac48Address', 'source')]) + ## ethernet-header.h: void ns3::EthernetHeader::SetDestination(ns3::Mac48Address destination) [member function] + cls.add_method('SetDestination', 'void', [param('ns3::Mac48Address', 'destination')]) + ## ethernet-header.h: void ns3::EthernetHeader::SetPreambleSfd(uint64_t preambleSfd) [member function] + cls.add_method('SetPreambleSfd', 'void', [param('uint64_t', 'preambleSfd')]) + ## ethernet-header.h: uint16_t ns3::EthernetHeader::GetLengthType() const [member function] + cls.add_method('GetLengthType', 'uint16_t', [], is_const=True) + ## ethernet-header.h: ns3::ethernet_header_t ns3::EthernetHeader::GetPacketType() const [member function] + cls.add_method('GetPacketType', 'ns3::ethernet_header_t', [], is_const=True) + ## ethernet-header.h: ns3::Mac48Address ns3::EthernetHeader::GetSource() const [member function] + cls.add_method('GetSource', 'ns3::Mac48Address', [], is_const=True) + ## ethernet-header.h: ns3::Mac48Address ns3::EthernetHeader::GetDestination() const [member function] + cls.add_method('GetDestination', 'ns3::Mac48Address', [], is_const=True) + ## ethernet-header.h: uint64_t ns3::EthernetHeader::GetPreambleSfd() const [member function] + cls.add_method('GetPreambleSfd', 'uint64_t', [], is_const=True) + ## ethernet-header.h: uint32_t ns3::EthernetHeader::GetHeaderSize() const [member function] + cls.add_method('GetHeaderSize', 'uint32_t', [], is_const=True) + ## ethernet-header.h: static ns3::TypeId ns3::EthernetHeader::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## ethernet-header.h: ns3::TypeId ns3::EthernetHeader::GetInstanceTypeId() const [member function] + cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True) + ## ethernet-header.h: void ns3::EthernetHeader::Print(std::ostream & os) const [member function] + cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True) + ## ethernet-header.h: uint32_t ns3::EthernetHeader::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True) + ## ethernet-header.h: void ns3::EthernetHeader::Serialize(ns3::Buffer::Iterator start) const [member function] + cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_const=True, is_virtual=True) + ## ethernet-header.h: uint32_t ns3::EthernetHeader::Deserialize(ns3::Buffer::Iterator start) [member function] + cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_virtual=True) + return + +def register_Ns3SocketIpTtlTag_methods(root_module, cls): + ## socket.h: ns3::SocketIpTtlTag::SocketIpTtlTag() [constructor] + cls.add_constructor([], visibility='public') + ## socket.h: void ns3::SocketIpTtlTag::SetTtl(uint8_t ttl) [member function] + cls.add_method('SetTtl', 'void', [param('uint8_t', 'ttl')]) + ## socket.h: uint8_t ns3::SocketIpTtlTag::GetTtl() const [member function] + cls.add_method('GetTtl', 'uint8_t', [], is_const=True) + ## socket.h: static ns3::TypeId ns3::SocketIpTtlTag::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## socket.h: ns3::TypeId ns3::SocketIpTtlTag::GetInstanceTypeId() const [member function] + cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True) + ## socket.h: uint32_t ns3::SocketIpTtlTag::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True) + ## socket.h: void ns3::SocketIpTtlTag::Serialize(ns3::TagBuffer i) const [member function] + cls.add_method('Serialize', 'void', [param('ns3::TagBuffer', 'i')], is_const=True, is_virtual=True) + ## socket.h: void ns3::SocketIpTtlTag::Deserialize(ns3::TagBuffer i) [member function] + cls.add_method('Deserialize', 'void', [param('ns3::TagBuffer', 'i')], is_virtual=True) + ## socket.h: void ns3::SocketIpTtlTag::Print(std::ostream & os) const [member function] + cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True) + return + +def register_Ns3Ipv4_methods(root_module, cls): + ## ipv4.h: static ns3::TypeId ns3::Ipv4::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## ipv4.h: ns3::Ipv4::Ipv4() [constructor] + cls.add_constructor([], visibility='public') + ## ipv4.h: void ns3::Ipv4::AddRoutingProtocol(ns3::Ptr routingProtocol, int16_t priority) [member function] + cls.add_method('AddRoutingProtocol', 'void', [param('ns3::Ptr< ns3::Ipv4RoutingProtocol >', 'routingProtocol'), param('int16_t', 'priority')], is_pure_virtual=True, is_virtual=True) + ## ipv4.h: void ns3::Ipv4::AddHostRouteTo(ns3::Ipv4Address dest, ns3::Ipv4Address nextHop, uint32_t interface) [member function] + cls.add_method('AddHostRouteTo', 'void', [param('ns3::Ipv4Address', 'dest'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_pure_virtual=True, is_virtual=True) + ## ipv4.h: void ns3::Ipv4::AddHostRouteTo(ns3::Ipv4Address dest, uint32_t interface) [member function] + cls.add_method('AddHostRouteTo', 'void', [param('ns3::Ipv4Address', 'dest'), param('uint32_t', 'interface')], is_pure_virtual=True, is_virtual=True) + ## ipv4.h: void ns3::Ipv4::AddNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, ns3::Ipv4Address nextHop, uint32_t interface) [member function] + 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) + ## ipv4.h: void ns3::Ipv4::AddNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, uint32_t interface) [member function] + cls.add_method('AddNetworkRouteTo', 'void', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('uint32_t', 'interface')], is_pure_virtual=True, is_virtual=True) + ## ipv4.h: void ns3::Ipv4::SetDefaultRoute(ns3::Ipv4Address nextHop, uint32_t interface) [member function] + cls.add_method('SetDefaultRoute', 'void', [param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_pure_virtual=True, is_virtual=True) + ## ipv4.h: uint32_t ns3::Ipv4::GetNRoutes() [member function] + cls.add_method('GetNRoutes', 'uint32_t', [], is_pure_virtual=True, is_virtual=True) + ## ipv4.h: ns3::Ipv4Route ns3::Ipv4::GetRoute(uint32_t i) [member function] + cls.add_method('GetRoute', 'ns3::Ipv4Route', [param('uint32_t', 'i')], is_pure_virtual=True, is_virtual=True) + ## ipv4.h: void ns3::Ipv4::RemoveRoute(uint32_t i) [member function] + cls.add_method('RemoveRoute', 'void', [param('uint32_t', 'i')], is_pure_virtual=True, is_virtual=True) + ## ipv4.h: void ns3::Ipv4::AddMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface, std::vector > outputInterfaces) [member function] + 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) + ## ipv4.h: void ns3::Ipv4::RemoveMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface) [member function] + cls.add_method('RemoveMulticastRoute', 'void', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface')], is_pure_virtual=True, is_virtual=True) + ## ipv4.h: void ns3::Ipv4::SetDefaultMulticastRoute(uint32_t outputInterface) [member function] + cls.add_method('SetDefaultMulticastRoute', 'void', [param('uint32_t', 'outputInterface')], is_pure_virtual=True, is_virtual=True) + ## ipv4.h: uint32_t ns3::Ipv4::GetNMulticastRoutes() const [member function] + cls.add_method('GetNMulticastRoutes', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## ipv4.h: ns3::Ipv4MulticastRoute ns3::Ipv4::GetMulticastRoute(uint32_t i) const [member function] + cls.add_method('GetMulticastRoute', 'ns3::Ipv4MulticastRoute', [param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True) + ## ipv4.h: void ns3::Ipv4::RemoveMulticastRoute(uint32_t i) [member function] + cls.add_method('RemoveMulticastRoute', 'void', [param('uint32_t', 'i')], is_pure_virtual=True, is_virtual=True) + ## ipv4.h: uint32_t ns3::Ipv4::AddInterface(ns3::Ptr device) [member function] + cls.add_method('AddInterface', 'uint32_t', [param('ns3::Ptr< ns3::NetDevice >', 'device')], is_pure_virtual=True, is_virtual=True) + ## ipv4.h: uint32_t ns3::Ipv4::GetNInterfaces() [member function] + cls.add_method('GetNInterfaces', 'uint32_t', [], is_pure_virtual=True, is_virtual=True) + ## ipv4.h: uint32_t ns3::Ipv4::FindInterfaceForAddr(ns3::Ipv4Address addr) const [member function] + cls.add_method('FindInterfaceForAddr', 'uint32_t', [param('ns3::Ipv4Address', 'addr')], is_pure_virtual=True, is_const=True, is_virtual=True) + ## ipv4.h: uint32_t ns3::Ipv4::FindInterfaceForAddr(ns3::Ipv4Address addr, ns3::Ipv4Mask mask) const [member function] + cls.add_method('FindInterfaceForAddr', 'uint32_t', [param('ns3::Ipv4Address', 'addr'), param('ns3::Ipv4Mask', 'mask')], is_pure_virtual=True, is_const=True, is_virtual=True) + ## ipv4.h: int32_t ns3::Ipv4::FindInterfaceForDevice(ns3::Ptr nd) const [member function] + cls.add_method('FindInterfaceForDevice', 'int32_t', [param('ns3::Ptr< ns3::NetDevice >', 'nd')], is_pure_virtual=True, is_const=True, is_virtual=True) + ## ipv4.h: ns3::Ptr ns3::Ipv4::GetNetDevice(uint32_t i) [member function] + cls.add_method('GetNetDevice', 'ns3::Ptr< ns3::NetDevice >', [param('uint32_t', 'i')], is_pure_virtual=True, is_virtual=True) + ## ipv4.h: void ns3::Ipv4::JoinMulticastGroup(ns3::Ipv4Address origin, ns3::Ipv4Address group) [member function] + cls.add_method('JoinMulticastGroup', 'void', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group')], is_pure_virtual=True, is_virtual=True) + ## ipv4.h: void ns3::Ipv4::LeaveMulticastGroup(ns3::Ipv4Address origin, ns3::Ipv4Address group) [member function] + cls.add_method('LeaveMulticastGroup', 'void', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group')], is_pure_virtual=True, is_virtual=True) + ## ipv4.h: void ns3::Ipv4::SetAddress(uint32_t i, ns3::Ipv4Address address) [member function] + cls.add_method('SetAddress', 'void', [param('uint32_t', 'i'), param('ns3::Ipv4Address', 'address')], is_pure_virtual=True, is_virtual=True) + ## ipv4.h: void ns3::Ipv4::SetNetworkMask(uint32_t i, ns3::Ipv4Mask mask) [member function] + cls.add_method('SetNetworkMask', 'void', [param('uint32_t', 'i'), param('ns3::Ipv4Mask', 'mask')], is_pure_virtual=True, is_virtual=True) + ## ipv4.h: ns3::Ipv4Mask ns3::Ipv4::GetNetworkMask(uint32_t i) const [member function] + cls.add_method('GetNetworkMask', 'ns3::Ipv4Mask', [param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True) + ## ipv4.h: void ns3::Ipv4::SetMetric(uint32_t i, uint16_t metric) [member function] + cls.add_method('SetMetric', 'void', [param('uint32_t', 'i'), param('uint16_t', 'metric')], is_pure_virtual=True, is_virtual=True) + ## ipv4.h: uint16_t ns3::Ipv4::GetMetric(uint32_t i) const [member function] + cls.add_method('GetMetric', 'uint16_t', [param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True) + ## ipv4.h: ns3::Ipv4Address ns3::Ipv4::GetAddress(uint32_t i) const [member function] + cls.add_method('GetAddress', 'ns3::Ipv4Address', [param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True) + ## ipv4.h: ns3::Ipv4Address ns3::Ipv4::GetSourceAddress(ns3::Ipv4Address destination) const [member function] + cls.add_method('GetSourceAddress', 'ns3::Ipv4Address', [param('ns3::Ipv4Address', 'destination')], is_pure_virtual=True, is_const=True, is_virtual=True) + ## ipv4.h: bool ns3::Ipv4::GetIfIndexForDestination(ns3::Ipv4Address dest, uint32_t & ifIndex) const [member function] + cls.add_method('GetIfIndexForDestination', 'bool', [param('ns3::Ipv4Address', 'dest'), param('uint32_t&', 'ifIndex')], is_pure_virtual=True, is_const=True, is_virtual=True) + ## ipv4.h: uint16_t ns3::Ipv4::GetMtu(uint32_t i) const [member function] + cls.add_method('GetMtu', 'uint16_t', [param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True) + ## ipv4.h: bool ns3::Ipv4::IsUp(uint32_t i) const [member function] + cls.add_method('IsUp', 'bool', [param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True) + ## ipv4.h: void ns3::Ipv4::SetUp(uint32_t i) [member function] + cls.add_method('SetUp', 'void', [param('uint32_t', 'i')], is_pure_virtual=True, is_virtual=True) + ## ipv4.h: void ns3::Ipv4::SetDown(uint32_t i) [member function] + cls.add_method('SetDown', 'void', [param('uint32_t', 'i')], is_pure_virtual=True, is_virtual=True) + ## ipv4.h: uint32_t ns3::Ipv4::GetIfIndexByAddress(ns3::Ipv4Address addr, ns3::Ipv4Mask mask=ns3::Ipv4Mask(((const char*)"255.255.255.255"))) [member function] + 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) + return + +def register_Ns3SocketFactory_methods(root_module, cls): + ## socket-factory.h: static ns3::TypeId ns3::SocketFactory::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## socket-factory.h: ns3::SocketFactory::SocketFactory() [constructor] + cls.add_constructor([], visibility='public') + ## socket-factory.h: ns3::Ptr ns3::SocketFactory::CreateSocket() [member function] + cls.add_method('CreateSocket', 'ns3::Ptr< ns3::Socket >', [], is_pure_virtual=True, is_virtual=True) + return + +def register_Ns3DropTailQueue_methods(root_module, cls): + ## drop-tail-queue.h: static ns3::TypeId ns3::DropTailQueue::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## drop-tail-queue.h: ns3::DropTailQueue::DropTailQueue() [constructor] + cls.add_constructor([], visibility='public') + ## drop-tail-queue.h: bool ns3::DropTailQueue::DoEnqueue(ns3::Ptr p) [member function] + cls.add_method('DoEnqueue', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')], visibility='private', is_virtual=True) + ## drop-tail-queue.h: ns3::Ptr ns3::DropTailQueue::DoDequeue() [member function] + cls.add_method('DoDequeue', 'ns3::Ptr< ns3::Packet >', [], visibility='private', is_virtual=True) + ## drop-tail-queue.h: ns3::Ptr ns3::DropTailQueue::DoPeek() const [member function] + cls.add_method('DoPeek', 'ns3::Ptr< ns3::Packet >', [], is_const=True, visibility='private', is_virtual=True) + return + +def register_Ns3EthernetTrailer_methods(root_module, cls): + ## ethernet-trailer.h: ns3::EthernetTrailer::EthernetTrailer() [constructor] + cls.add_constructor([], visibility='public') + ## ethernet-trailer.h: static void ns3::EthernetTrailer::EnableFcs(bool enable) [member function] + cls.add_method('EnableFcs', 'void', [param('bool', 'enable')], is_static=True) + ## ethernet-trailer.h: void ns3::EthernetTrailer::CalcFcs(ns3::Ptr p) [member function] + cls.add_method('CalcFcs', 'void', [param('ns3::Ptr< ns3::Packet >', 'p')]) + ## ethernet-trailer.h: void ns3::EthernetTrailer::SetFcs(uint32_t fcs) [member function] + cls.add_method('SetFcs', 'void', [param('uint32_t', 'fcs')]) + ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetFcs() [member function] + cls.add_method('GetFcs', 'uint32_t', []) + ## ethernet-trailer.h: bool ns3::EthernetTrailer::CheckFcs(ns3::Ptr p) const [member function] + cls.add_method('CheckFcs', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')], is_const=True) + ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetTrailerSize() const [member function] + cls.add_method('GetTrailerSize', 'uint32_t', [], is_const=True) + ## ethernet-trailer.h: static ns3::TypeId ns3::EthernetTrailer::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## ethernet-trailer.h: ns3::TypeId ns3::EthernetTrailer::GetInstanceTypeId() const [member function] + cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True) + ## ethernet-trailer.h: void ns3::EthernetTrailer::Print(std::ostream & os) const [member function] + cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True) + ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True) + ## ethernet-trailer.h: void ns3::EthernetTrailer::Serialize(ns3::Buffer::Iterator end) const [member function] + cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'end')], is_const=True, is_virtual=True) + ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::Deserialize(ns3::Buffer::Iterator end) [member function] + cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'end')], is_virtual=True) + return + +def register_Ns3LlcSnapHeader_methods(root_module, cls): + ## llc-snap-header.h: ns3::LlcSnapHeader::LlcSnapHeader() [constructor] + cls.add_constructor([], visibility='public') + ## llc-snap-header.h: void ns3::LlcSnapHeader::SetType(uint16_t type) [member function] + cls.add_method('SetType', 'void', [param('uint16_t', 'type')]) + ## llc-snap-header.h: uint16_t ns3::LlcSnapHeader::GetType() [member function] + cls.add_method('GetType', 'uint16_t', []) + ## llc-snap-header.h: static ns3::TypeId ns3::LlcSnapHeader::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## llc-snap-header.h: ns3::TypeId ns3::LlcSnapHeader::GetInstanceTypeId() const [member function] + cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True) + ## llc-snap-header.h: void ns3::LlcSnapHeader::Print(std::ostream & os) const [member function] + cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True) + ## llc-snap-header.h: uint32_t ns3::LlcSnapHeader::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True) + ## llc-snap-header.h: void ns3::LlcSnapHeader::Serialize(ns3::Buffer::Iterator start) const [member function] + cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_const=True, is_virtual=True) + ## llc-snap-header.h: uint32_t ns3::LlcSnapHeader::Deserialize(ns3::Buffer::Iterator start) [member function] + cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_virtual=True) + return + +def register_Ns3UdpSocketFactory_methods(root_module, cls): + ## udp-socket-factory.h: static ns3::TypeId ns3::UdpSocketFactory::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## udp-socket-factory.h: ns3::Ptr ns3::UdpSocketFactory::CreateSocket() [member function] + cls.add_method('CreateSocket', 'ns3::Ptr< ns3::Socket >', [], is_pure_virtual=True, is_virtual=True) + cls.add_constructor([]) + return + +def register_Ns3SimpleNetDevice_methods(root_module, cls): + ## simple-net-device.h: static ns3::TypeId ns3::SimpleNetDevice::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## simple-net-device.h: ns3::SimpleNetDevice::SimpleNetDevice() [constructor] + cls.add_constructor([], visibility='public') + ## simple-net-device.h: void ns3::SimpleNetDevice::Receive(ns3::Ptr packet, uint16_t protocol, ns3::Mac48Address to, ns3::Mac48Address from) [member function] + cls.add_method('Receive', 'void', [param('ns3::Ptr< ns3::Packet >', 'packet'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from')]) + ## simple-net-device.h: void ns3::SimpleNetDevice::SetChannel(ns3::Ptr channel) [member function] + cls.add_method('SetChannel', 'void', [param('ns3::Ptr< ns3::SimpleChannel >', 'channel')]) + ## simple-net-device.h: void ns3::SimpleNetDevice::SetAddress(ns3::Mac48Address address) [member function] + cls.add_method('SetAddress', 'void', [param('ns3::Mac48Address', 'address')]) + ## simple-net-device.h: void ns3::SimpleNetDevice::SetName(std::string const name) [member function] + cls.add_method('SetName', 'void', [param('std::string', 'name', is_const=True)], is_virtual=True) + ## simple-net-device.h: std::string ns3::SimpleNetDevice::GetName() const [member function] + cls.add_method('GetName', 'std::string', [], is_const=True, is_virtual=True) + ## simple-net-device.h: void ns3::SimpleNetDevice::SetIfIndex(uint32_t const index) [member function] + cls.add_method('SetIfIndex', 'void', [param('uint32_t', 'index', is_const=True)], is_virtual=True) + ## simple-net-device.h: uint32_t ns3::SimpleNetDevice::GetIfIndex() const [member function] + cls.add_method('GetIfIndex', 'uint32_t', [], is_const=True, is_virtual=True) + ## simple-net-device.h: ns3::Ptr ns3::SimpleNetDevice::GetChannel() const [member function] + cls.add_method('GetChannel', 'ns3::Ptr< ns3::Channel >', [], is_const=True, is_virtual=True) + ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::GetAddress() const [member function] + cls.add_method('GetAddress', 'ns3::Address', [], is_const=True, is_virtual=True) + ## simple-net-device.h: bool ns3::SimpleNetDevice::SetMtu(uint16_t const mtu) [member function] + cls.add_method('SetMtu', 'bool', [param('uint16_t', 'mtu', is_const=True)], is_virtual=True) + ## simple-net-device.h: uint16_t ns3::SimpleNetDevice::GetMtu() const [member function] + cls.add_method('GetMtu', 'uint16_t', [], is_const=True, is_virtual=True) + ## simple-net-device.h: bool ns3::SimpleNetDevice::IsLinkUp() const [member function] + cls.add_method('IsLinkUp', 'bool', [], is_const=True, is_virtual=True) + ## simple-net-device.h: void ns3::SimpleNetDevice::SetLinkChangeCallback(ns3::Callback callback) [member function] + 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) + ## simple-net-device.h: bool ns3::SimpleNetDevice::IsBroadcast() const [member function] + cls.add_method('IsBroadcast', 'bool', [], is_const=True, is_virtual=True) + ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::GetBroadcast() const [member function] + cls.add_method('GetBroadcast', 'ns3::Address', [], is_const=True, is_virtual=True) + ## simple-net-device.h: bool ns3::SimpleNetDevice::IsMulticast() const [member function] + cls.add_method('IsMulticast', 'bool', [], is_const=True, is_virtual=True) + ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::GetMulticast() const [member function] + cls.add_method('GetMulticast', 'ns3::Address', [], is_const=True, is_virtual=True) + ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::MakeMulticastAddress(ns3::Ipv4Address multicastGroup) const [member function] + cls.add_method('MakeMulticastAddress', 'ns3::Address', [param('ns3::Ipv4Address', 'multicastGroup')], is_const=True, is_virtual=True) + ## simple-net-device.h: bool ns3::SimpleNetDevice::IsPointToPoint() const [member function] + cls.add_method('IsPointToPoint', 'bool', [], is_const=True, is_virtual=True) + ## simple-net-device.h: bool ns3::SimpleNetDevice::Send(ns3::Ptr packet, ns3::Address const & dest, uint16_t protocolNumber) [member function] + 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) + ## simple-net-device.h: ns3::Ptr ns3::SimpleNetDevice::GetNode() const [member function] + cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [], is_const=True, is_virtual=True) + ## simple-net-device.h: void ns3::SimpleNetDevice::SetNode(ns3::Ptr node) [member function] + cls.add_method('SetNode', 'void', [param('ns3::Ptr< ns3::Node >', 'node')], is_virtual=True) + ## simple-net-device.h: bool ns3::SimpleNetDevice::NeedsArp() const [member function] + cls.add_method('NeedsArp', 'bool', [], is_const=True, is_virtual=True) + ## simple-net-device.h: void ns3::SimpleNetDevice::SetReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function] + 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) + ## simple-net-device.h: void ns3::SimpleNetDevice::DoDispose() [member function] + cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True) + return + +def register_Ns3TcpSocketFactory_methods(root_module, cls): + ## tcp-socket-factory.h: static ns3::TypeId ns3::TcpSocketFactory::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## tcp-socket-factory.h: ns3::Ptr ns3::TcpSocketFactory::CreateSocket() [member function] + cls.add_method('CreateSocket', 'ns3::Ptr< ns3::Socket >', [], is_pure_virtual=True, is_virtual=True) + cls.add_constructor([]) + return + +def register_Ns3PacketSocketFactory_methods(root_module, cls): + ## packet-socket-factory.h: static ns3::TypeId ns3::PacketSocketFactory::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## packet-socket-factory.h: ns3::PacketSocketFactory::PacketSocketFactory() [constructor] + cls.add_constructor([], visibility='public') + ## packet-socket-factory.h: ns3::Ptr ns3::PacketSocketFactory::CreateSocket() [member function] + cls.add_method('CreateSocket', 'ns3::Ptr< ns3::Socket >', [], is_virtual=True) + return + +def register_functions(root_module): + module = root_module + ## mac48-address.h: extern ns3::Ptr ns3::MakeMac48AddressChecker() [free function] + module.add_function('MakeMac48AddressChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) + ## ipv4-address.h: extern ns3::Ptr ns3::MakeIpv4AddressChecker() [free function] + module.add_function('MakeIpv4AddressChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) + ## address-utils.h: extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Mac48Address ad) [free function] + module.add_function('WriteTo', 'void', [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Mac48Address', 'ad')]) + ## address-utils.h: extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Address const & ad) [free function] + module.add_function('WriteTo', 'void', [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Address&', 'ad', is_const=True)]) + ## address-utils.h: extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Ipv4Address ad) [free function] + module.add_function('WriteTo', 'void', [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Ipv4Address', 'ad')]) + ## address.h: extern ns3::Ptr ns3::MakeAddressChecker() [free function] + module.add_function('MakeAddressChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) + ## ipv4-address.h: extern ns3::Ptr ns3::MakeIpv4MaskChecker() [free function] + module.add_function('MakeIpv4MaskChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) + ## address-utils.h: extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Mac48Address & ad) [free function] + module.add_function('ReadFrom', 'void', [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Mac48Address&', 'ad')]) + ## address-utils.h: extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Address & ad, uint32_t len) [free function] + module.add_function('ReadFrom', 'void', [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Address&', 'ad'), param('uint32_t', 'len')]) + ## address-utils.h: extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Ipv4Address & ad) [free function] + module.add_function('ReadFrom', 'void', [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Ipv4Address&', 'ad')]) + register_functions_ns3_internal(module.get_submodule('internal'), root_module) + register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module) + register_functions_ns3_Config(module.get_submodule('Config'), root_module) + register_functions_ns3_olsr(module.get_submodule('olsr'), root_module) + return + +def register_functions_ns3_internal(module, root_module): + return + +def register_functions_ns3_TimeStepPrecision(module, root_module): + return + +def register_functions_ns3_Config(module, root_module): + return + +def register_functions_ns3_olsr(module, root_module): + return + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/ns3_module_olsr.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/ns3_module_olsr.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,288 @@ +from pybindgen import Module, FileCodeSink, write_preamble, param, retval + +def register_types(module): + root_module = module.get_root() + + + ## Register a nested module for the namespace internal + + nested_module = module.add_cpp_namespace('internal') + register_types_ns3_internal(nested_module) + + + ## Register a nested module for the namespace TimeStepPrecision + + nested_module = module.add_cpp_namespace('TimeStepPrecision') + register_types_ns3_TimeStepPrecision(nested_module) + + + ## Register a nested module for the namespace Config + + nested_module = module.add_cpp_namespace('Config') + register_types_ns3_Config(nested_module) + + + ## Register a nested module for the namespace olsr + + nested_module = module.add_cpp_namespace('olsr') + register_types_ns3_olsr(nested_module) + + +def register_types_ns3_internal(module): + root_module = module.get_root() + + +def register_types_ns3_TimeStepPrecision(module): + root_module = module.get_root() + + +def register_types_ns3_Config(module): + root_module = module.get_root() + + +def register_types_ns3_olsr(module): + root_module = module.get_root() + + ## olsr-header.h: ns3::olsr::MessageHeader [class] + module.add_class('MessageHeader', allow_subclassing=True, parent=root_module['ns3::Header']) + ## olsr-header.h: ns3::olsr::MessageHeader::MessageType [enumeration] + module.add_enum('MessageType', ['HELLO_MESSAGE', 'TC_MESSAGE', 'MID_MESSAGE', 'HNA_MESSAGE'], outer_class=root_module['ns3::olsr::MessageHeader']) + ## olsr-header.h: ns3::olsr::MessageHeader::Mid [struct] + module.add_class('Mid', outer_class=root_module['ns3::olsr::MessageHeader']) + ## olsr-header.h: ns3::olsr::MessageHeader::Hello [struct] + module.add_class('Hello', outer_class=root_module['ns3::olsr::MessageHeader']) + ## olsr-header.h: ns3::olsr::MessageHeader::Hello::LinkMessage [struct] + module.add_class('LinkMessage', outer_class=root_module['ns3::olsr::MessageHeader::Hello']) + ## olsr-header.h: ns3::olsr::MessageHeader::Tc [struct] + module.add_class('Tc', outer_class=root_module['ns3::olsr::MessageHeader']) + ## olsr-header.h: ns3::olsr::MessageHeader::Hna [struct] + module.add_class('Hna', outer_class=root_module['ns3::olsr::MessageHeader']) + ## olsr-header.h: ns3::olsr::MessageHeader::Hna::Association [struct] + module.add_class('Association', outer_class=root_module['ns3::olsr::MessageHeader::Hna']) + ## olsr-agent.h: ns3::olsr::Agent [class] + module.add_class('Agent', allow_subclassing=True, parent=root_module['ns3::Object']) + ## olsr-header.h: ns3::olsr::PacketHeader [class] + module.add_class('PacketHeader', allow_subclassing=True, parent=root_module['ns3::Header']) + +def register_methods(root_module): + register_Ns3OlsrMessageHeader_methods(root_module, root_module['ns3::olsr::MessageHeader']) + register_Ns3OlsrMessageHeaderMid_methods(root_module, root_module['ns3::olsr::MessageHeader::Mid']) + register_Ns3OlsrMessageHeaderHello_methods(root_module, root_module['ns3::olsr::MessageHeader::Hello']) + register_Ns3OlsrMessageHeaderHelloLinkMessage_methods(root_module, root_module['ns3::olsr::MessageHeader::Hello::LinkMessage']) + register_Ns3OlsrMessageHeaderTc_methods(root_module, root_module['ns3::olsr::MessageHeader::Tc']) + register_Ns3OlsrMessageHeaderHna_methods(root_module, root_module['ns3::olsr::MessageHeader::Hna']) + register_Ns3OlsrMessageHeaderHnaAssociation_methods(root_module, root_module['ns3::olsr::MessageHeader::Hna::Association']) + register_Ns3OlsrAgent_methods(root_module, root_module['ns3::olsr::Agent']) + register_Ns3OlsrPacketHeader_methods(root_module, root_module['ns3::olsr::PacketHeader']) + return + +def register_Ns3OlsrMessageHeader_methods(root_module, cls): + ## olsr-header.h: ns3::olsr::MessageHeader::MessageHeader(ns3::olsr::MessageHeader const & arg0) [copy constructor] + cls.add_constructor([param('ns3::olsr::MessageHeader&', 'arg0', is_const=True)], visibility='public') + ## olsr-header.h: ns3::olsr::MessageHeader::MessageHeader() [constructor] + cls.add_constructor([], visibility='public') + ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Deserialize(ns3::Buffer::Iterator start) [member function] + cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_virtual=True) + ## olsr-header.h: ns3::olsr::MessageHeader::Hello & ns3::olsr::MessageHeader::GetHello() [member function] + cls.add_method('GetHello', 'ns3::olsr::MessageHeader::Hello&', []) + ## olsr-header.h: ns3::olsr::MessageHeader::Hello const & ns3::olsr::MessageHeader::GetHello() const [member function] + cls.add_method('GetHello', retval('ns3::olsr::MessageHeader::Hello&', is_const=True), [], is_const=True) + ## olsr-header.h: ns3::olsr::MessageHeader::Hna & ns3::olsr::MessageHeader::GetHna() [member function] + cls.add_method('GetHna', 'ns3::olsr::MessageHeader::Hna&', []) + ## olsr-header.h: ns3::olsr::MessageHeader::Hna const & ns3::olsr::MessageHeader::GetHna() const [member function] + cls.add_method('GetHna', retval('ns3::olsr::MessageHeader::Hna&', is_const=True), [], is_const=True) + ## olsr-header.h: uint8_t ns3::olsr::MessageHeader::GetHopCount() const [member function] + cls.add_method('GetHopCount', 'uint8_t', [], is_const=True) + ## olsr-header.h: ns3::TypeId ns3::olsr::MessageHeader::GetInstanceTypeId() const [member function] + cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True) + ## olsr-header.h: uint16_t ns3::olsr::MessageHeader::GetMessageSequenceNumber() const [member function] + cls.add_method('GetMessageSequenceNumber', 'uint16_t', [], is_const=True) + ## olsr-header.h: ns3::olsr::MessageHeader::MessageType ns3::olsr::MessageHeader::GetMessageType() const [member function] + cls.add_method('GetMessageType', 'ns3::olsr::MessageHeader::MessageType', [], is_const=True) + ## olsr-header.h: ns3::olsr::MessageHeader::Mid & ns3::olsr::MessageHeader::GetMid() [member function] + cls.add_method('GetMid', 'ns3::olsr::MessageHeader::Mid&', []) + ## olsr-header.h: ns3::olsr::MessageHeader::Mid const & ns3::olsr::MessageHeader::GetMid() const [member function] + cls.add_method('GetMid', retval('ns3::olsr::MessageHeader::Mid&', is_const=True), [], is_const=True) + ## olsr-header.h: ns3::Ipv4Address ns3::olsr::MessageHeader::GetOriginatorAddress() const [member function] + cls.add_method('GetOriginatorAddress', 'ns3::Ipv4Address', [], is_const=True) + ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True) + ## olsr-header.h: ns3::olsr::MessageHeader::Tc & ns3::olsr::MessageHeader::GetTc() [member function] + cls.add_method('GetTc', 'ns3::olsr::MessageHeader::Tc&', []) + ## olsr-header.h: ns3::olsr::MessageHeader::Tc const & ns3::olsr::MessageHeader::GetTc() const [member function] + cls.add_method('GetTc', retval('ns3::olsr::MessageHeader::Tc&', is_const=True), [], is_const=True) + ## olsr-header.h: uint8_t ns3::olsr::MessageHeader::GetTimeToLive() const [member function] + cls.add_method('GetTimeToLive', 'uint8_t', [], is_const=True) + ## olsr-header.h: static ns3::TypeId ns3::olsr::MessageHeader::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## olsr-header.h: ns3::Time ns3::olsr::MessageHeader::GetVTime() const [member function] + cls.add_method('GetVTime', 'ns3::Time', [], is_const=True) + ## olsr-header.h: void ns3::olsr::MessageHeader::Print(std::ostream & os) const [member function] + cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True) + ## olsr-header.h: void ns3::olsr::MessageHeader::Serialize(ns3::Buffer::Iterator start) const [member function] + cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_const=True, is_virtual=True) + ## olsr-header.h: void ns3::olsr::MessageHeader::SetHopCount(uint8_t hopCount) [member function] + cls.add_method('SetHopCount', 'void', [param('uint8_t', 'hopCount')]) + ## olsr-header.h: void ns3::olsr::MessageHeader::SetMessageSequenceNumber(uint16_t messageSequenceNumber) [member function] + cls.add_method('SetMessageSequenceNumber', 'void', [param('uint16_t', 'messageSequenceNumber')]) + ## olsr-header.h: void ns3::olsr::MessageHeader::SetMessageType(ns3::olsr::MessageHeader::MessageType messageType) [member function] + cls.add_method('SetMessageType', 'void', [param('ns3::olsr::MessageHeader::MessageType', 'messageType')]) + ## olsr-header.h: void ns3::olsr::MessageHeader::SetOriginatorAddress(ns3::Ipv4Address originatorAddress) [member function] + cls.add_method('SetOriginatorAddress', 'void', [param('ns3::Ipv4Address', 'originatorAddress')]) + ## olsr-header.h: void ns3::olsr::MessageHeader::SetTimeToLive(uint8_t timeToLive) [member function] + cls.add_method('SetTimeToLive', 'void', [param('uint8_t', 'timeToLive')]) + ## olsr-header.h: void ns3::olsr::MessageHeader::SetVTime(ns3::Time time) [member function] + cls.add_method('SetVTime', 'void', [param('ns3::Time', 'time')]) + cls.add_output_stream_operator() + return + +def register_Ns3OlsrMessageHeaderMid_methods(root_module, cls): + ## olsr-header.h: ns3::olsr::MessageHeader::Mid::Mid(ns3::olsr::MessageHeader::Mid const & arg0) [copy constructor] + cls.add_constructor([param('ns3::olsr::MessageHeader::Mid&', 'arg0', is_const=True)], visibility='public') + ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Mid::Deserialize(ns3::Buffer::Iterator start, uint32_t messageSize) [member function] + cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start'), param('uint32_t', 'messageSize')]) + ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Mid::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True) + ## olsr-header.h: void ns3::olsr::MessageHeader::Mid::Print(std::ostream & os) const [member function] + cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True) + ## olsr-header.h: void ns3::olsr::MessageHeader::Mid::Serialize(ns3::Buffer::Iterator start) const [member function] + cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_const=True) + ## olsr-header.h: ns3::olsr::MessageHeader::Mid::interfaceAddresses [variable] + cls.add_instance_attribute('interfaceAddresses', 'std::vector< ns3::Ipv4Address, std::allocator< ns3::Ipv4Address > >', is_const=False) + return + +def register_Ns3OlsrMessageHeaderHello_methods(root_module, cls): + ## olsr-header.h: ns3::olsr::MessageHeader::Hello::Hello(ns3::olsr::MessageHeader::Hello const & arg0) [copy constructor] + cls.add_constructor([param('ns3::olsr::MessageHeader::Hello&', 'arg0', is_const=True)], visibility='public') + ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Hello::Deserialize(ns3::Buffer::Iterator start, uint32_t messageSize) [member function] + cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start'), param('uint32_t', 'messageSize')]) + ## olsr-header.h: ns3::Time ns3::olsr::MessageHeader::Hello::GetHTime() const [member function] + cls.add_method('GetHTime', 'ns3::Time', [], is_const=True) + ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Hello::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True) + ## olsr-header.h: void ns3::olsr::MessageHeader::Hello::Print(std::ostream & os) const [member function] + cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True) + ## olsr-header.h: void ns3::olsr::MessageHeader::Hello::Serialize(ns3::Buffer::Iterator start) const [member function] + cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_const=True) + ## olsr-header.h: void ns3::olsr::MessageHeader::Hello::SetHTime(ns3::Time time) [member function] + cls.add_method('SetHTime', 'void', [param('ns3::Time', 'time')]) + ## olsr-header.h: ns3::olsr::MessageHeader::Hello::hTime [variable] + cls.add_instance_attribute('hTime', 'uint8_t', is_const=False) + ## olsr-header.h: ns3::olsr::MessageHeader::Hello::linkMessages [variable] + cls.add_instance_attribute('linkMessages', 'std::vector< ns3::olsr::MessageHeader::Hello::LinkMessage, std::allocator< ns3::olsr::MessageHeader::Hello::LinkMessage > >', is_const=False) + ## olsr-header.h: ns3::olsr::MessageHeader::Hello::willingness [variable] + cls.add_instance_attribute('willingness', 'uint8_t', is_const=False) + return + +def register_Ns3OlsrMessageHeaderHelloLinkMessage_methods(root_module, cls): + ## olsr-header.h: ns3::olsr::MessageHeader::Hello::LinkMessage::linkCode [variable] + cls.add_instance_attribute('linkCode', 'uint8_t', is_const=False) + ## olsr-header.h: ns3::olsr::MessageHeader::Hello::LinkMessage::neighborInterfaceAddresses [variable] + cls.add_instance_attribute('neighborInterfaceAddresses', 'std::vector< ns3::Ipv4Address, std::allocator< ns3::Ipv4Address > >', is_const=False) + cls.add_constructor([]) + return + +def register_Ns3OlsrMessageHeaderTc_methods(root_module, cls): + ## olsr-header.h: ns3::olsr::MessageHeader::Tc::Tc(ns3::olsr::MessageHeader::Tc const & arg0) [copy constructor] + cls.add_constructor([param('ns3::olsr::MessageHeader::Tc&', 'arg0', is_const=True)], visibility='public') + ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Tc::Deserialize(ns3::Buffer::Iterator start, uint32_t messageSize) [member function] + cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start'), param('uint32_t', 'messageSize')]) + ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Tc::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True) + ## olsr-header.h: void ns3::olsr::MessageHeader::Tc::Print(std::ostream & os) const [member function] + cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True) + ## olsr-header.h: void ns3::olsr::MessageHeader::Tc::Serialize(ns3::Buffer::Iterator start) const [member function] + cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_const=True) + ## olsr-header.h: ns3::olsr::MessageHeader::Tc::ansn [variable] + cls.add_instance_attribute('ansn', 'uint16_t', is_const=False) + ## olsr-header.h: ns3::olsr::MessageHeader::Tc::neighborAddresses [variable] + cls.add_instance_attribute('neighborAddresses', 'std::vector< ns3::Ipv4Address, std::allocator< ns3::Ipv4Address > >', is_const=False) + return + +def register_Ns3OlsrMessageHeaderHna_methods(root_module, cls): + ## olsr-header.h: ns3::olsr::MessageHeader::Hna::Hna(ns3::olsr::MessageHeader::Hna const & arg0) [copy constructor] + cls.add_constructor([param('ns3::olsr::MessageHeader::Hna&', 'arg0', is_const=True)], visibility='public') + ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Hna::Deserialize(ns3::Buffer::Iterator start, uint32_t messageSize) [member function] + cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start'), param('uint32_t', 'messageSize')]) + ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Hna::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True) + ## olsr-header.h: void ns3::olsr::MessageHeader::Hna::Print(std::ostream & os) const [member function] + cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True) + ## olsr-header.h: void ns3::olsr::MessageHeader::Hna::Serialize(ns3::Buffer::Iterator start) const [member function] + cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_const=True) + ## olsr-header.h: ns3::olsr::MessageHeader::Hna::associations [variable] + cls.add_instance_attribute('associations', 'std::vector< ns3::olsr::MessageHeader::Hna::Association, std::allocator< ns3::olsr::MessageHeader::Hna::Association > >', is_const=False) + return + +def register_Ns3OlsrMessageHeaderHnaAssociation_methods(root_module, cls): + ## olsr-header.h: ns3::olsr::MessageHeader::Hna::Association::address [variable] + cls.add_instance_attribute('address', 'ns3::Ipv4Address', is_const=False) + ## olsr-header.h: ns3::olsr::MessageHeader::Hna::Association::mask [variable] + cls.add_instance_attribute('mask', 'ns3::Ipv4Mask', is_const=False) + cls.add_constructor([]) + return + +def register_Ns3OlsrAgent_methods(root_module, cls): + ## olsr-agent.h: static ns3::TypeId ns3::olsr::Agent::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## olsr-agent.h: void ns3::olsr::Agent::SetNode(ns3::Ptr node) [member function] + cls.add_method('SetNode', 'void', [param('ns3::Ptr< ns3::Node >', 'node')], is_pure_virtual=True, is_virtual=True) + ## olsr-agent.h: void ns3::olsr::Agent::SetMainInterface(uint32_t interface) [member function] + cls.add_method('SetMainInterface', 'void', [param('uint32_t', 'interface')], is_pure_virtual=True, is_virtual=True) + ## olsr-agent.h: void ns3::olsr::Agent::Start() [member function] + cls.add_method('Start', 'void', [], is_pure_virtual=True, is_virtual=True) + cls.add_constructor([]) + return + +def register_Ns3OlsrPacketHeader_methods(root_module, cls): + ## olsr-header.h: ns3::olsr::PacketHeader::PacketHeader(ns3::olsr::PacketHeader const & arg0) [copy constructor] + cls.add_constructor([param('ns3::olsr::PacketHeader&', 'arg0', is_const=True)], visibility='public') + ## olsr-header.h: ns3::olsr::PacketHeader::PacketHeader() [constructor] + cls.add_constructor([], visibility='public') + ## olsr-header.h: uint32_t ns3::olsr::PacketHeader::Deserialize(ns3::Buffer::Iterator start) [member function] + cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_virtual=True) + ## olsr-header.h: ns3::TypeId ns3::olsr::PacketHeader::GetInstanceTypeId() const [member function] + cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True) + ## olsr-header.h: uint16_t ns3::olsr::PacketHeader::GetPacketLength() const [member function] + cls.add_method('GetPacketLength', 'uint16_t', [], is_const=True) + ## olsr-header.h: uint16_t ns3::olsr::PacketHeader::GetPacketSequenceNumber() const [member function] + cls.add_method('GetPacketSequenceNumber', 'uint16_t', [], is_const=True) + ## olsr-header.h: uint32_t ns3::olsr::PacketHeader::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True) + ## olsr-header.h: static ns3::TypeId ns3::olsr::PacketHeader::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## olsr-header.h: void ns3::olsr::PacketHeader::Print(std::ostream & os) const [member function] + cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True) + ## olsr-header.h: void ns3::olsr::PacketHeader::Serialize(ns3::Buffer::Iterator start) const [member function] + cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_const=True, is_virtual=True) + ## olsr-header.h: void ns3::olsr::PacketHeader::SetPacketLength(uint16_t length) [member function] + cls.add_method('SetPacketLength', 'void', [param('uint16_t', 'length')]) + ## olsr-header.h: void ns3::olsr::PacketHeader::SetPacketSequenceNumber(uint16_t seqnum) [member function] + cls.add_method('SetPacketSequenceNumber', 'void', [param('uint16_t', 'seqnum')]) + cls.add_output_stream_operator() + return + +def register_functions(root_module): + module = root_module + register_functions_ns3_internal(module.get_submodule('internal'), root_module) + register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module) + register_functions_ns3_Config(module.get_submodule('Config'), root_module) + register_functions_ns3_olsr(module.get_submodule('olsr'), root_module) + return + +def register_functions_ns3_internal(module, root_module): + return + +def register_functions_ns3_TimeStepPrecision(module, root_module): + return + +def register_functions_ns3_Config(module, root_module): + return + +def register_functions_ns3_olsr(module, root_module): + ## olsr-header.h: extern double ns3::olsr::EmfToSeconds(uint8_t emf) [free function] + module.add_function('EmfToSeconds', 'double', [param('uint8_t', 'emf')]) + ## olsr-header.h: extern uint8_t ns3::olsr::SecondsToEmf(double seconds) [free function] + module.add_function('SecondsToEmf', 'uint8_t', [param('double', 'seconds')]) + return + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/ns3_module_onoff.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/ns3_module_onoff.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,87 @@ +from pybindgen import Module, FileCodeSink, write_preamble, param, retval + +def register_types(module): + root_module = module.get_root() + + ## onoff-application.h: ns3::OnOffApplication [class] + module.add_class('OnOffApplication', allow_subclassing=True, parent=root_module['ns3::Application']) + + ## Register a nested module for the namespace internal + + nested_module = module.add_cpp_namespace('internal') + register_types_ns3_internal(nested_module) + + + ## Register a nested module for the namespace TimeStepPrecision + + nested_module = module.add_cpp_namespace('TimeStepPrecision') + register_types_ns3_TimeStepPrecision(nested_module) + + + ## Register a nested module for the namespace Config + + nested_module = module.add_cpp_namespace('Config') + register_types_ns3_Config(nested_module) + + + ## Register a nested module for the namespace olsr + + nested_module = module.add_cpp_namespace('olsr') + register_types_ns3_olsr(nested_module) + + +def register_types_ns3_internal(module): + root_module = module.get_root() + + +def register_types_ns3_TimeStepPrecision(module): + root_module = module.get_root() + + +def register_types_ns3_Config(module): + root_module = module.get_root() + + +def register_types_ns3_olsr(module): + root_module = module.get_root() + + +def register_methods(root_module): + register_Ns3OnOffApplication_methods(root_module, root_module['ns3::OnOffApplication']) + return + +def register_Ns3OnOffApplication_methods(root_module, cls): + ## onoff-application.h: static ns3::TypeId ns3::OnOffApplication::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## onoff-application.h: ns3::OnOffApplication::OnOffApplication() [constructor] + cls.add_constructor([], visibility='public') + ## onoff-application.h: void ns3::OnOffApplication::SetMaxBytes(uint32_t maxBytes) [member function] + cls.add_method('SetMaxBytes', 'void', [param('uint32_t', 'maxBytes')]) + ## onoff-application.h: void ns3::OnOffApplication::DoDispose() [member function] + cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True) + ## onoff-application.h: void ns3::OnOffApplication::StartApplication() [member function] + cls.add_method('StartApplication', 'void', [], visibility='private', is_virtual=True) + ## onoff-application.h: void ns3::OnOffApplication::StopApplication() [member function] + cls.add_method('StopApplication', 'void', [], visibility='private', is_virtual=True) + return + +def register_functions(root_module): + module = root_module + register_functions_ns3_internal(module.get_submodule('internal'), root_module) + register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module) + register_functions_ns3_Config(module.get_submodule('Config'), root_module) + register_functions_ns3_olsr(module.get_submodule('olsr'), root_module) + return + +def register_functions_ns3_internal(module, root_module): + return + +def register_functions_ns3_TimeStepPrecision(module, root_module): + return + +def register_functions_ns3_Config(module, root_module): + return + +def register_functions_ns3_olsr(module, root_module): + return + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/ns3_module_packet_sink.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/ns3_module_packet_sink.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,85 @@ +from pybindgen import Module, FileCodeSink, write_preamble, param, retval + +def register_types(module): + root_module = module.get_root() + + ## packet-sink.h: ns3::PacketSink [class] + module.add_class('PacketSink', allow_subclassing=True, parent=root_module['ns3::Application']) + + ## Register a nested module for the namespace internal + + nested_module = module.add_cpp_namespace('internal') + register_types_ns3_internal(nested_module) + + + ## Register a nested module for the namespace TimeStepPrecision + + nested_module = module.add_cpp_namespace('TimeStepPrecision') + register_types_ns3_TimeStepPrecision(nested_module) + + + ## Register a nested module for the namespace Config + + nested_module = module.add_cpp_namespace('Config') + register_types_ns3_Config(nested_module) + + + ## Register a nested module for the namespace olsr + + nested_module = module.add_cpp_namespace('olsr') + register_types_ns3_olsr(nested_module) + + +def register_types_ns3_internal(module): + root_module = module.get_root() + + +def register_types_ns3_TimeStepPrecision(module): + root_module = module.get_root() + + +def register_types_ns3_Config(module): + root_module = module.get_root() + + +def register_types_ns3_olsr(module): + root_module = module.get_root() + + +def register_methods(root_module): + register_Ns3PacketSink_methods(root_module, root_module['ns3::PacketSink']) + return + +def register_Ns3PacketSink_methods(root_module, cls): + ## packet-sink.h: static ns3::TypeId ns3::PacketSink::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## packet-sink.h: ns3::PacketSink::PacketSink() [constructor] + cls.add_constructor([], visibility='public') + ## packet-sink.h: void ns3::PacketSink::DoDispose() [member function] + cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True) + ## packet-sink.h: void ns3::PacketSink::StartApplication() [member function] + cls.add_method('StartApplication', 'void', [], visibility='private', is_virtual=True) + ## packet-sink.h: void ns3::PacketSink::StopApplication() [member function] + cls.add_method('StopApplication', 'void', [], visibility='private', is_virtual=True) + return + +def register_functions(root_module): + module = root_module + register_functions_ns3_internal(module.get_submodule('internal'), root_module) + register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module) + register_functions_ns3_Config(module.get_submodule('Config'), root_module) + register_functions_ns3_olsr(module.get_submodule('olsr'), root_module) + return + +def register_functions_ns3_internal(module, root_module): + return + +def register_functions_ns3_TimeStepPrecision(module, root_module): + return + +def register_functions_ns3_Config(module, root_module): + return + +def register_functions_ns3_olsr(module, root_module): + return + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/ns3_module_point_to_point.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/ns3_module_point_to_point.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,157 @@ +from pybindgen import Module, FileCodeSink, write_preamble, param, retval + +def register_types(module): + root_module = module.get_root() + + ## point-to-point-channel.h: ns3::PointToPointChannel [class] + module.add_class('PointToPointChannel', allow_subclassing=True, parent=root_module['ns3::Channel']) + ## point-to-point-net-device.h: ns3::PointToPointNetDevice [class] + module.add_class('PointToPointNetDevice', allow_subclassing=True, parent=root_module['ns3::NetDevice']) + + ## Register a nested module for the namespace internal + + nested_module = module.add_cpp_namespace('internal') + register_types_ns3_internal(nested_module) + + + ## Register a nested module for the namespace TimeStepPrecision + + nested_module = module.add_cpp_namespace('TimeStepPrecision') + register_types_ns3_TimeStepPrecision(nested_module) + + + ## Register a nested module for the namespace Config + + nested_module = module.add_cpp_namespace('Config') + register_types_ns3_Config(nested_module) + + + ## Register a nested module for the namespace olsr + + nested_module = module.add_cpp_namespace('olsr') + register_types_ns3_olsr(nested_module) + + +def register_types_ns3_internal(module): + root_module = module.get_root() + + +def register_types_ns3_TimeStepPrecision(module): + root_module = module.get_root() + + +def register_types_ns3_Config(module): + root_module = module.get_root() + + +def register_types_ns3_olsr(module): + root_module = module.get_root() + + +def register_methods(root_module): + register_Ns3PointToPointChannel_methods(root_module, root_module['ns3::PointToPointChannel']) + register_Ns3PointToPointNetDevice_methods(root_module, root_module['ns3::PointToPointNetDevice']) + return + +def register_Ns3PointToPointChannel_methods(root_module, cls): + ## point-to-point-channel.h: static ns3::TypeId ns3::PointToPointChannel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## point-to-point-channel.h: ns3::PointToPointChannel::PointToPointChannel() [constructor] + cls.add_constructor([], visibility='public') + ## point-to-point-channel.h: void ns3::PointToPointChannel::Attach(ns3::Ptr device) [member function] + cls.add_method('Attach', 'void', [param('ns3::Ptr< ns3::PointToPointNetDevice >', 'device')]) + ## point-to-point-channel.h: bool ns3::PointToPointChannel::TransmitStart(ns3::Ptr p, ns3::Ptr src, ns3::Time txTime) [member function] + cls.add_method('TransmitStart', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ptr< ns3::PointToPointNetDevice >', 'src'), param('ns3::Time', 'txTime')]) + ## point-to-point-channel.h: uint32_t ns3::PointToPointChannel::GetNDevices() const [member function] + cls.add_method('GetNDevices', 'uint32_t', [], is_const=True, is_virtual=True) + ## point-to-point-channel.h: ns3::Ptr ns3::PointToPointChannel::GetPointToPointDevice(uint32_t i) const [member function] + cls.add_method('GetPointToPointDevice', 'ns3::Ptr< ns3::PointToPointNetDevice >', [param('uint32_t', 'i')], is_const=True) + ## point-to-point-channel.h: ns3::Ptr ns3::PointToPointChannel::GetDevice(uint32_t i) const [member function] + cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', [param('uint32_t', 'i')], is_const=True, is_virtual=True) + return + +def register_Ns3PointToPointNetDevice_methods(root_module, cls): + ## point-to-point-net-device.h: static ns3::TypeId ns3::PointToPointNetDevice::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## point-to-point-net-device.h: ns3::PointToPointNetDevice::PointToPointNetDevice() [constructor] + cls.add_constructor([], visibility='public') + ## point-to-point-net-device.h: void ns3::PointToPointNetDevice::SetDataRate(ns3::DataRate bps) [member function] + cls.add_method('SetDataRate', 'void', [param('ns3::DataRate', 'bps')]) + ## point-to-point-net-device.h: void ns3::PointToPointNetDevice::SetInterframeGap(ns3::Time t) [member function] + cls.add_method('SetInterframeGap', 'void', [param('ns3::Time', 't')]) + ## point-to-point-net-device.h: bool ns3::PointToPointNetDevice::Attach(ns3::Ptr ch) [member function] + cls.add_method('Attach', 'bool', [param('ns3::Ptr< ns3::PointToPointChannel >', 'ch')]) + ## point-to-point-net-device.h: void ns3::PointToPointNetDevice::SetQueue(ns3::Ptr queue) [member function] + cls.add_method('SetQueue', 'void', [param('ns3::Ptr< ns3::Queue >', 'queue')]) + ## point-to-point-net-device.h: void ns3::PointToPointNetDevice::SetReceiveErrorModel(ns3::Ptr em) [member function] + cls.add_method('SetReceiveErrorModel', 'void', [param('ns3::Ptr< ns3::ErrorModel >', 'em')]) + ## point-to-point-net-device.h: void ns3::PointToPointNetDevice::Receive(ns3::Ptr p) [member function] + cls.add_method('Receive', 'void', [param('ns3::Ptr< ns3::Packet >', 'p')]) + ## point-to-point-net-device.h: void ns3::PointToPointNetDevice::SetAddress(ns3::Mac48Address addr) [member function] + cls.add_method('SetAddress', 'void', [param('ns3::Mac48Address', 'addr')]) + ## point-to-point-net-device.h: void ns3::PointToPointNetDevice::SetName(std::string const name) [member function] + cls.add_method('SetName', 'void', [param('std::string', 'name', is_const=True)], is_virtual=True) + ## point-to-point-net-device.h: std::string ns3::PointToPointNetDevice::GetName() const [member function] + cls.add_method('GetName', 'std::string', [], is_const=True, is_virtual=True) + ## point-to-point-net-device.h: void ns3::PointToPointNetDevice::SetIfIndex(uint32_t const index) [member function] + cls.add_method('SetIfIndex', 'void', [param('uint32_t', 'index', is_const=True)], is_virtual=True) + ## point-to-point-net-device.h: uint32_t ns3::PointToPointNetDevice::GetIfIndex() const [member function] + cls.add_method('GetIfIndex', 'uint32_t', [], is_const=True, is_virtual=True) + ## point-to-point-net-device.h: ns3::Ptr ns3::PointToPointNetDevice::GetChannel() const [member function] + cls.add_method('GetChannel', 'ns3::Ptr< ns3::Channel >', [], is_const=True, is_virtual=True) + ## point-to-point-net-device.h: ns3::Address ns3::PointToPointNetDevice::GetAddress() const [member function] + cls.add_method('GetAddress', 'ns3::Address', [], is_const=True, is_virtual=True) + ## point-to-point-net-device.h: bool ns3::PointToPointNetDevice::SetMtu(uint16_t const mtu) [member function] + cls.add_method('SetMtu', 'bool', [param('uint16_t', 'mtu', is_const=True)], is_virtual=True) + ## point-to-point-net-device.h: uint16_t ns3::PointToPointNetDevice::GetMtu() const [member function] + cls.add_method('GetMtu', 'uint16_t', [], is_const=True, is_virtual=True) + ## point-to-point-net-device.h: bool ns3::PointToPointNetDevice::IsLinkUp() const [member function] + cls.add_method('IsLinkUp', 'bool', [], is_const=True, is_virtual=True) + ## point-to-point-net-device.h: void ns3::PointToPointNetDevice::SetLinkChangeCallback(ns3::Callback callback) [member function] + 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) + ## point-to-point-net-device.h: bool ns3::PointToPointNetDevice::IsBroadcast() const [member function] + cls.add_method('IsBroadcast', 'bool', [], is_const=True, is_virtual=True) + ## point-to-point-net-device.h: ns3::Address ns3::PointToPointNetDevice::GetBroadcast() const [member function] + cls.add_method('GetBroadcast', 'ns3::Address', [], is_const=True, is_virtual=True) + ## point-to-point-net-device.h: bool ns3::PointToPointNetDevice::IsMulticast() const [member function] + cls.add_method('IsMulticast', 'bool', [], is_const=True, is_virtual=True) + ## point-to-point-net-device.h: ns3::Address ns3::PointToPointNetDevice::GetMulticast() const [member function] + cls.add_method('GetMulticast', 'ns3::Address', [], is_const=True, is_virtual=True) + ## point-to-point-net-device.h: ns3::Address ns3::PointToPointNetDevice::MakeMulticastAddress(ns3::Ipv4Address multicastGroup) const [member function] + cls.add_method('MakeMulticastAddress', 'ns3::Address', [param('ns3::Ipv4Address', 'multicastGroup')], is_const=True, is_virtual=True) + ## point-to-point-net-device.h: bool ns3::PointToPointNetDevice::IsPointToPoint() const [member function] + cls.add_method('IsPointToPoint', 'bool', [], is_const=True, is_virtual=True) + ## point-to-point-net-device.h: bool ns3::PointToPointNetDevice::Send(ns3::Ptr packet, ns3::Address const & dest, uint16_t protocolNumber) [member function] + 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) + ## point-to-point-net-device.h: ns3::Ptr ns3::PointToPointNetDevice::GetNode() const [member function] + cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [], is_const=True, is_virtual=True) + ## point-to-point-net-device.h: void ns3::PointToPointNetDevice::SetNode(ns3::Ptr node) [member function] + cls.add_method('SetNode', 'void', [param('ns3::Ptr< ns3::Node >', 'node')], is_virtual=True) + ## point-to-point-net-device.h: bool ns3::PointToPointNetDevice::NeedsArp() const [member function] + cls.add_method('NeedsArp', 'bool', [], is_const=True, is_virtual=True) + ## point-to-point-net-device.h: void ns3::PointToPointNetDevice::SetReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function] + 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) + ## point-to-point-net-device.h: void ns3::PointToPointNetDevice::DoDispose() [member function] + cls.add_method('DoDispose', 'void', [], visibility='private', is_virtual=True) + return + +def register_functions(root_module): + module = root_module + register_functions_ns3_internal(module.get_submodule('internal'), root_module) + register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module) + register_functions_ns3_Config(module.get_submodule('Config'), root_module) + register_functions_ns3_olsr(module.get_submodule('olsr'), root_module) + return + +def register_functions_ns3_internal(module, root_module): + return + +def register_functions_ns3_TimeStepPrecision(module, root_module): + return + +def register_functions_ns3_Config(module, root_module): + return + +def register_functions_ns3_olsr(module, root_module): + return + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/ns3_module_simulator.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/ns3_module_simulator.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,456 @@ +from pybindgen import Module, FileCodeSink, write_preamble, param, retval + +def register_types(module): + root_module = module.get_root() + + ## timer.h: ns3::Timer [class] + module.add_class('Timer') + ## timer.h: ns3::Timer::DestroyPolicy [enumeration] + module.add_enum('DestroyPolicy', ['CANCEL_ON_DESTROY', 'REMOVE_ON_DESTROY', 'CHECK_ON_DESTROY'], outer_class=root_module['ns3::Timer']) + ## timer.h: ns3::Timer::State [enumeration] + module.add_enum('State', ['RUNNING', 'EXPIRED', 'SUSPENDED'], outer_class=root_module['ns3::Timer']) + ## timer-impl.h: ns3::TimerImpl [class] + module.add_class('TimerImpl', allow_subclassing=True) + ## nstime.h: ns3::TimeUnit<1> [class] + module.add_class('Time') + ## nstime.h: ns3::TimeUnit<0> [class] + module.add_class('Scalar') + ## watchdog.h: ns3::Watchdog [class] + module.add_class('Watchdog') + ## simulator.h: ns3::Simulator [class] + module.add_class('Simulator', is_singleton=True) + ## event-id.h: ns3::EventId [class] + module.add_class('EventId') + ## event-impl.h: ns3::EventImpl [class] + module.add_class('EventImpl', allow_subclassing=True) + ## high-precision-128.h: ns3::HighPrecision [class] + module.add_class('HighPrecision') + ## nstime.h: ns3::TimeChecker [class] + module.add_class('TimeChecker', parent=root_module['ns3::AttributeChecker']) + ## scheduler.h: ns3::Scheduler [class] + module.add_class('Scheduler', allow_subclassing=True, parent=root_module['ns3::Object']) + ## scheduler.h: ns3::Scheduler::EventKey [struct] + module.add_class('EventKey', outer_class=root_module['ns3::Scheduler']) + ## nstime.h: ns3::TimeValue [class] + module.add_class('TimeValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue']) + ## heap-scheduler.h: ns3::HeapScheduler [class] + module.add_class('HeapScheduler', allow_subclassing=True, parent=root_module['ns3::Scheduler']) + ## list-scheduler.h: ns3::ListScheduler [class] + module.add_class('ListScheduler', allow_subclassing=True, parent=root_module['ns3::Scheduler']) + ## map-scheduler.h: ns3::MapScheduler [class] + module.add_class('MapScheduler', allow_subclassing=True, parent=root_module['ns3::Scheduler']) + + ## Register a nested module for the namespace internal + + nested_module = module.add_cpp_namespace('internal') + register_types_ns3_internal(nested_module) + + + ## Register a nested module for the namespace TimeStepPrecision + + nested_module = module.add_cpp_namespace('TimeStepPrecision') + register_types_ns3_TimeStepPrecision(nested_module) + + + ## Register a nested module for the namespace Config + + nested_module = module.add_cpp_namespace('Config') + register_types_ns3_Config(nested_module) + + + ## Register a nested module for the namespace olsr + + nested_module = module.add_cpp_namespace('olsr') + register_types_ns3_olsr(nested_module) + + +def register_types_ns3_internal(module): + root_module = module.get_root() + + +def register_types_ns3_TimeStepPrecision(module): + root_module = module.get_root() + + ## nstime.h: ns3::TimeStepPrecision::precision_t [enumeration] + module.add_enum('precision_t', ['S', 'MS', 'US', 'NS', 'PS', 'FS']) + +def register_types_ns3_Config(module): + root_module = module.get_root() + + +def register_types_ns3_olsr(module): + root_module = module.get_root() + + +def register_methods(root_module): + register_Ns3Timer_methods(root_module, root_module['ns3::Timer']) + register_Ns3TimerImpl_methods(root_module, root_module['ns3::TimerImpl']) + register_Ns3Time_methods(root_module, root_module['ns3::Time']) + register_Ns3Scalar_methods(root_module, root_module['ns3::Scalar']) + register_Ns3Watchdog_methods(root_module, root_module['ns3::Watchdog']) + register_Ns3Simulator_methods(root_module, root_module['ns3::Simulator']) + register_Ns3EventId_methods(root_module, root_module['ns3::EventId']) + register_Ns3EventImpl_methods(root_module, root_module['ns3::EventImpl']) + register_Ns3HighPrecision_methods(root_module, root_module['ns3::HighPrecision']) + register_Ns3TimeChecker_methods(root_module, root_module['ns3::TimeChecker']) + register_Ns3Scheduler_methods(root_module, root_module['ns3::Scheduler']) + register_Ns3SchedulerEventKey_methods(root_module, root_module['ns3::Scheduler::EventKey']) + register_Ns3TimeValue_methods(root_module, root_module['ns3::TimeValue']) + register_Ns3HeapScheduler_methods(root_module, root_module['ns3::HeapScheduler']) + register_Ns3ListScheduler_methods(root_module, root_module['ns3::ListScheduler']) + register_Ns3MapScheduler_methods(root_module, root_module['ns3::MapScheduler']) + return + +def register_Ns3Timer_methods(root_module, cls): + ## timer.h: ns3::Timer::Timer() [constructor] + cls.add_constructor([], visibility='public') + ## timer.h: ns3::Timer::Timer(ns3::Timer::DestroyPolicy destroyPolicy) [constructor] + cls.add_constructor([param('ns3::Timer::DestroyPolicy', 'destroyPolicy')], visibility='public') + ## timer.h: void ns3::Timer::SetDelay(ns3::Time const & delay) [member function] + cls.add_method('SetDelay', 'void', [param('ns3::Time&', 'delay', is_const=True)]) + ## timer.h: ns3::Time ns3::Timer::GetDelay() const [member function] + cls.add_method('GetDelay', 'ns3::Time', [], is_const=True) + ## timer.h: ns3::Time ns3::Timer::GetDelayLeft() const [member function] + cls.add_method('GetDelayLeft', 'ns3::Time', [], is_const=True) + ## timer.h: void ns3::Timer::Cancel() [member function] + cls.add_method('Cancel', 'void', []) + ## timer.h: void ns3::Timer::Remove() [member function] + cls.add_method('Remove', 'void', []) + ## timer.h: bool ns3::Timer::IsExpired() const [member function] + cls.add_method('IsExpired', 'bool', [], is_const=True) + ## timer.h: bool ns3::Timer::IsRunning() const [member function] + cls.add_method('IsRunning', 'bool', [], is_const=True) + ## timer.h: bool ns3::Timer::IsSuspended() const [member function] + cls.add_method('IsSuspended', 'bool', [], is_const=True) + ## timer.h: ns3::Timer::State ns3::Timer::GetState() const [member function] + cls.add_method('GetState', 'ns3::Timer::State', [], is_const=True) + ## timer.h: void ns3::Timer::Schedule() [member function] + cls.add_method('Schedule', 'void', []) + ## timer.h: void ns3::Timer::Schedule(ns3::Time delay) [member function] + cls.add_method('Schedule', 'void', [param('ns3::Time', 'delay')]) + ## timer.h: void ns3::Timer::Suspend() [member function] + cls.add_method('Suspend', 'void', []) + ## timer.h: void ns3::Timer::Resume() [member function] + cls.add_method('Resume', 'void', []) + return + +def register_Ns3TimerImpl_methods(root_module, cls): + ## timer-impl.h: ns3::EventId ns3::TimerImpl::Schedule(ns3::Time const & delay) [member function] + cls.add_method('Schedule', 'ns3::EventId', [param('ns3::Time&', 'delay', is_const=True)], is_pure_virtual=True, is_virtual=True) + ## timer-impl.h: void ns3::TimerImpl::Invoke() [member function] + cls.add_method('Invoke', 'void', [], is_pure_virtual=True, is_virtual=True) + cls.add_constructor([]) + return + +def register_Ns3Time_methods(root_module, cls): + ## nstime.h: ns3::TimeUnit<1>::TimeUnit(std::string const & s) [constructor] + cls.add_constructor([param('std::string&', 's', is_const=True)], visibility='public') + ## nstime.h: ns3::TimeUnit<1>::TimeUnit() [constructor] + cls.add_constructor([], visibility='public') + ## nstime.h: ns3::TimeUnit<1>::TimeUnit(ns3::TimeUnit<1> const & o) [copy constructor] + cls.add_constructor([param('ns3::Time&', 'o', is_const=True)], visibility='public') + ## nstime.h: ns3::TimeUnit<1>::TimeUnit(ns3::HighPrecision data) [constructor] + cls.add_constructor([param('ns3::HighPrecision', 'data')], visibility='public') + ## nstime.h: int64_t ns3::TimeUnit<1>::GetFemtoSeconds() const [member function] + cls.add_method('GetFemtoSeconds', 'int64_t', [], is_const=True) + ## nstime.h: ns3::HighPrecision const & ns3::TimeUnit<1>::GetHighPrecision() const [member function] + cls.add_method('GetHighPrecision', retval('ns3::HighPrecision&', is_const=True), [], is_const=True) + ## nstime.h: int64_t ns3::TimeUnit<1>::GetMicroSeconds() const [member function] + cls.add_method('GetMicroSeconds', 'int64_t', [], is_const=True) + ## nstime.h: int64_t ns3::TimeUnit<1>::GetMilliSeconds() const [member function] + cls.add_method('GetMilliSeconds', 'int64_t', [], is_const=True) + ## nstime.h: int64_t ns3::TimeUnit<1>::GetNanoSeconds() const [member function] + cls.add_method('GetNanoSeconds', 'int64_t', [], is_const=True) + ## nstime.h: int64_t ns3::TimeUnit<1>::GetPicoSeconds() const [member function] + cls.add_method('GetPicoSeconds', 'int64_t', [], is_const=True) + ## nstime.h: double ns3::TimeUnit<1>::GetSeconds() const [member function] + cls.add_method('GetSeconds', 'double', [], is_const=True) + ## nstime.h: int64_t ns3::TimeUnit<1>::GetTimeStep() const [member function] + cls.add_method('GetTimeStep', 'int64_t', [], is_const=True) + ## nstime.h: bool ns3::TimeUnit<1>::IsNegative() const [member function] + cls.add_method('IsNegative', 'bool', [], is_const=True) + ## nstime.h: bool ns3::TimeUnit<1>::IsPositive() const [member function] + cls.add_method('IsPositive', 'bool', [], is_const=True) + ## nstime.h: bool ns3::TimeUnit<1>::IsStrictlyNegative() const [member function] + cls.add_method('IsStrictlyNegative', 'bool', [], is_const=True) + ## nstime.h: bool ns3::TimeUnit<1>::IsStrictlyPositive() const [member function] + cls.add_method('IsStrictlyPositive', 'bool', [], is_const=True) + ## nstime.h: bool ns3::TimeUnit<1>::IsZero() const [member function] + cls.add_method('IsZero', 'bool', [], is_const=True) + ## nstime.h: ns3::HighPrecision * ns3::TimeUnit<1>::PeekHighPrecision() [member function] + cls.add_method('PeekHighPrecision', 'ns3::HighPrecision *', []) + ## nstime.h: static uint64_t ns3::TimeUnit<1>::UnitsToTimestep(uint64_t unitValue, uint64_t unitFactor) [member function] + cls.add_method('UnitsToTimestep', 'uint64_t', [param('uint64_t', 'unitValue'), param('uint64_t', 'unitFactor')], is_static=True) + cls.add_output_stream_operator() + return + +def register_Ns3Scalar_methods(root_module, cls): + ## nstime.h: ns3::TimeUnit<0>::TimeUnit(double scalar) [constructor] + cls.add_constructor([param('double', 'scalar')], visibility='public') + ## nstime.h: ns3::TimeUnit<0>::TimeUnit() [constructor] + cls.add_constructor([], visibility='public') + ## nstime.h: ns3::TimeUnit<0>::TimeUnit(ns3::TimeUnit<0> const & o) [copy constructor] + cls.add_constructor([param('ns3::Scalar&', 'o', is_const=True)], visibility='public') + ## nstime.h: ns3::TimeUnit<0>::TimeUnit(ns3::HighPrecision data) [constructor] + cls.add_constructor([param('ns3::HighPrecision', 'data')], visibility='public') + ## nstime.h: double ns3::TimeUnit<0>::GetDouble() const [member function] + cls.add_method('GetDouble', 'double', [], is_const=True) + ## nstime.h: ns3::HighPrecision const & ns3::TimeUnit<0>::GetHighPrecision() const [member function] + cls.add_method('GetHighPrecision', retval('ns3::HighPrecision&', is_const=True), [], is_const=True) + ## nstime.h: bool ns3::TimeUnit<0>::IsNegative() const [member function] + cls.add_method('IsNegative', 'bool', [], is_const=True) + ## nstime.h: bool ns3::TimeUnit<0>::IsPositive() const [member function] + cls.add_method('IsPositive', 'bool', [], is_const=True) + ## nstime.h: bool ns3::TimeUnit<0>::IsStrictlyNegative() const [member function] + cls.add_method('IsStrictlyNegative', 'bool', [], is_const=True) + ## nstime.h: bool ns3::TimeUnit<0>::IsStrictlyPositive() const [member function] + cls.add_method('IsStrictlyPositive', 'bool', [], is_const=True) + ## nstime.h: bool ns3::TimeUnit<0>::IsZero() const [member function] + cls.add_method('IsZero', 'bool', [], is_const=True) + ## nstime.h: ns3::HighPrecision * ns3::TimeUnit<0>::PeekHighPrecision() [member function] + cls.add_method('PeekHighPrecision', 'ns3::HighPrecision *', []) + return + +def register_Ns3Watchdog_methods(root_module, cls): + ## watchdog.h: ns3::Watchdog::Watchdog() [constructor] + cls.add_constructor([], visibility='public') + ## watchdog.h: void ns3::Watchdog::Ping(ns3::Time delay) [member function] + cls.add_method('Ping', 'void', [param('ns3::Time', 'delay')]) + return + +def register_Ns3Simulator_methods(root_module, cls): + ## simulator.h: static void ns3::Simulator::SetScheduler(ns3::Ptr scheduler) [member function] + cls.add_method('SetScheduler', 'void', [param('ns3::Ptr< ns3::Scheduler >', 'scheduler')], is_static=True) + ## simulator.h: static void ns3::Simulator::EnableLogTo(char const * filename) [member function] + cls.add_method('EnableLogTo', 'void', [param('char *', 'filename', transfer_ownership=False, is_const=True)], is_static=True) + ## simulator.h: static void ns3::Simulator::Destroy() [member function] + cls.add_method('Destroy', 'void', [], is_static=True) + ## simulator.h: static bool ns3::Simulator::IsFinished() [member function] + cls.add_method('IsFinished', 'bool', [], is_static=True) + ## simulator.h: static ns3::Time ns3::Simulator::Next() [member function] + cls.add_method('Next', 'ns3::Time', [], is_static=True) + ## simulator.h: static void ns3::Simulator::Run() [member function] + cls.add_method('Run', 'void', [], is_static=True) + ## simulator.h: static void ns3::Simulator::Stop() [member function] + cls.add_method('Stop', 'void', [], is_static=True) + ## simulator.h: static void ns3::Simulator::Stop(ns3::Time const & time) [member function] + cls.add_method('Stop', 'void', [param('ns3::Time&', 'time', is_const=True)], is_static=True) + ## simulator.h: static void ns3::Simulator::Remove(ns3::EventId const & id) [member function] + cls.add_method('Remove', 'void', [param('ns3::EventId&', 'id', is_const=True)], is_static=True) + ## simulator.h: static void ns3::Simulator::Cancel(ns3::EventId const & id) [member function] + cls.add_method('Cancel', 'void', [param('ns3::EventId&', 'id', is_const=True)], is_static=True) + ## simulator.h: static bool ns3::Simulator::IsExpired(ns3::EventId const & id) [member function] + cls.add_method('IsExpired', 'bool', [param('ns3::EventId&', 'id', is_const=True)], is_static=True) + ## simulator.h: static ns3::Time ns3::Simulator::Now() [member function] + cls.add_method('Now', 'ns3::Time', [], is_static=True) + ## simulator.h: static ns3::Time ns3::Simulator::GetDelayLeft(ns3::EventId const & id) [member function] + cls.add_method('GetDelayLeft', 'ns3::Time', [param('ns3::EventId&', 'id', is_const=True)], is_static=True) + ## simulator.h: static ns3::Time ns3::Simulator::GetMaximumSimulationTime() [member function] + cls.add_method('GetMaximumSimulationTime', 'ns3::Time', [], is_static=True) + return + +def register_Ns3EventId_methods(root_module, cls): + ## event-id.h: ns3::EventId::EventId(ns3::EventId const & arg0) [copy constructor] + cls.add_constructor([param('ns3::EventId&', 'arg0', is_const=True)], visibility='public') + ## event-id.h: ns3::EventId::EventId() [constructor] + cls.add_constructor([], visibility='public') + ## event-id.h: ns3::EventId::EventId(ns3::Ptr const & impl, uint64_t ts, uint32_t uid) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::EventImpl >&', 'impl', is_const=True), param('uint64_t', 'ts'), param('uint32_t', 'uid')], visibility='public') + ## event-id.h: void ns3::EventId::Cancel() [member function] + cls.add_method('Cancel', 'void', []) + ## event-id.h: bool ns3::EventId::IsExpired() const [member function] + cls.add_method('IsExpired', 'bool', [], is_const=True) + ## event-id.h: bool ns3::EventId::IsRunning() const [member function] + cls.add_method('IsRunning', 'bool', [], is_const=True) + ## event-id.h: ns3::EventImpl * ns3::EventId::PeekEventImpl() const [member function] + cls.add_method('PeekEventImpl', 'ns3::EventImpl *', [], is_const=True) + ## event-id.h: uint64_t ns3::EventId::GetTs() const [member function] + cls.add_method('GetTs', 'uint64_t', [], is_const=True) + ## event-id.h: uint32_t ns3::EventId::GetUid() const [member function] + cls.add_method('GetUid', 'uint32_t', [], is_const=True) + return + +def register_Ns3EventImpl_methods(root_module, cls): + ## event-impl.h: ns3::EventImpl::EventImpl() [constructor] + cls.add_constructor([], visibility='public') + ## event-impl.h: void ns3::EventImpl::Ref() const [member function] + cls.add_method('Ref', 'void', [], is_const=True) + ## event-impl.h: void ns3::EventImpl::Unref() const [member function] + cls.add_method('Unref', 'void', [], is_const=True) + ## event-impl.h: void ns3::EventImpl::Invoke() [member function] + cls.add_method('Invoke', 'void', []) + ## event-impl.h: void ns3::EventImpl::Cancel() [member function] + cls.add_method('Cancel', 'void', []) + ## event-impl.h: bool ns3::EventImpl::IsCancelled() [member function] + cls.add_method('IsCancelled', 'bool', []) + ## event-impl.h: void ns3::EventImpl::Notify() [member function] + cls.add_method('Notify', 'void', [], is_pure_virtual=True, visibility='protected', is_virtual=True) + return + +def register_Ns3HighPrecision_methods(root_module, cls): + ## high-precision-128.h: ns3::HighPrecision::HighPrecision(ns3::HighPrecision const & arg0) [copy constructor] + cls.add_constructor([param('ns3::HighPrecision&', 'arg0', is_const=True)], visibility='public') + ## high-precision-128.h: ns3::HighPrecision::HighPrecision() [constructor] + cls.add_constructor([], visibility='public') + ## high-precision-128.h: ns3::HighPrecision::HighPrecision(int64_t value, bool dummy) [constructor] + cls.add_constructor([param('int64_t', 'value'), param('bool', 'dummy')], visibility='public') + ## high-precision-128.h: ns3::HighPrecision::HighPrecision(double value) [constructor] + cls.add_constructor([param('double', 'value')], visibility='public') + ## high-precision-128.h: static void ns3::HighPrecision::PrintStats() [member function] + cls.add_method('PrintStats', 'void', [], is_static=True) + ## high-precision-128.h: int64_t ns3::HighPrecision::GetInteger() const [member function] + cls.add_method('GetInteger', 'int64_t', [], is_const=True) + ## high-precision-128.h: double ns3::HighPrecision::GetDouble() const [member function] + cls.add_method('GetDouble', 'double', [], is_const=True) + ## high-precision-128.h: bool ns3::HighPrecision::Add(ns3::HighPrecision const & o) [member function] + cls.add_method('Add', 'bool', [param('ns3::HighPrecision&', 'o', is_const=True)]) + ## high-precision-128.h: bool ns3::HighPrecision::Sub(ns3::HighPrecision const & o) [member function] + cls.add_method('Sub', 'bool', [param('ns3::HighPrecision&', 'o', is_const=True)]) + ## high-precision-128.h: bool ns3::HighPrecision::Mul(ns3::HighPrecision const & o) [member function] + cls.add_method('Mul', 'bool', [param('ns3::HighPrecision&', 'o', is_const=True)]) + ## high-precision-128.h: bool ns3::HighPrecision::Div(ns3::HighPrecision const & o) [member function] + cls.add_method('Div', 'bool', [param('ns3::HighPrecision&', 'o', is_const=True)]) + ## high-precision-128.h: int ns3::HighPrecision::Compare(ns3::HighPrecision const & o) const [member function] + cls.add_method('Compare', 'int', [param('ns3::HighPrecision&', 'o', is_const=True)], is_const=True) + ## high-precision-128.h: static ns3::HighPrecision ns3::HighPrecision::Zero() [member function] + cls.add_method('Zero', 'ns3::HighPrecision', [], is_static=True) + return + +def register_Ns3TimeChecker_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3Scheduler_methods(root_module, cls): + ## scheduler.h: static ns3::TypeId ns3::Scheduler::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## scheduler.h: void ns3::Scheduler::Insert(ns3::EventId const & id) [member function] + cls.add_method('Insert', 'void', [param('ns3::EventId&', 'id', is_const=True)], is_pure_virtual=True, is_virtual=True) + ## scheduler.h: bool ns3::Scheduler::IsEmpty() const [member function] + cls.add_method('IsEmpty', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## scheduler.h: ns3::EventId ns3::Scheduler::PeekNext() const [member function] + cls.add_method('PeekNext', 'ns3::EventId', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## scheduler.h: ns3::EventId ns3::Scheduler::RemoveNext() [member function] + cls.add_method('RemoveNext', 'ns3::EventId', [], is_pure_virtual=True, is_virtual=True) + ## scheduler.h: bool ns3::Scheduler::Remove(ns3::EventId const & id) [member function] + cls.add_method('Remove', 'bool', [param('ns3::EventId&', 'id', is_const=True)], is_pure_virtual=True, is_virtual=True) + cls.add_constructor([]) + return + +def register_Ns3SchedulerEventKey_methods(root_module, cls): + ## scheduler.h: ns3::Scheduler::EventKey::m_ts [variable] + cls.add_instance_attribute('m_ts', 'uint64_t', is_const=False) + ## scheduler.h: ns3::Scheduler::EventKey::m_uid [variable] + cls.add_instance_attribute('m_uid', 'uint32_t', is_const=False) + cls.add_constructor([]) + return + +def register_Ns3TimeValue_methods(root_module, cls): + ## nstime.h: ns3::TimeValue::TimeValue() [constructor] + cls.add_constructor([], visibility='public') + ## nstime.h: ns3::TimeValue::TimeValue(ns3::Time const & value) [constructor] + cls.add_constructor([param('ns3::Time&', 'value', is_const=True)], visibility='public') + ## nstime.h: void ns3::TimeValue::Set(ns3::Time const & value) [member function] + cls.add_method('Set', 'void', [param('ns3::Time&', 'value', is_const=True)]) + ## nstime.h: ns3::Time ns3::TimeValue::Get() const [member function] + cls.add_method('Get', 'ns3::Time', [], is_const=True) + ## nstime.h: ns3::Ptr ns3::TimeValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) + ## nstime.h: std::string ns3::TimeValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True) + ## nstime.h: bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) + return + +def register_Ns3HeapScheduler_methods(root_module, cls): + ## heap-scheduler.h: ns3::HeapScheduler::HeapScheduler() [constructor] + cls.add_constructor([], visibility='public') + ## heap-scheduler.h: void ns3::HeapScheduler::Insert(ns3::EventId const & id) [member function] + cls.add_method('Insert', 'void', [param('ns3::EventId&', 'id', is_const=True)], is_virtual=True) + ## heap-scheduler.h: bool ns3::HeapScheduler::IsEmpty() const [member function] + cls.add_method('IsEmpty', 'bool', [], is_const=True, is_virtual=True) + ## heap-scheduler.h: ns3::EventId ns3::HeapScheduler::PeekNext() const [member function] + cls.add_method('PeekNext', 'ns3::EventId', [], is_const=True, is_virtual=True) + ## heap-scheduler.h: ns3::EventId ns3::HeapScheduler::RemoveNext() [member function] + cls.add_method('RemoveNext', 'ns3::EventId', [], is_virtual=True) + ## heap-scheduler.h: bool ns3::HeapScheduler::Remove(ns3::EventId const & ev) [member function] + cls.add_method('Remove', 'bool', [param('ns3::EventId&', 'ev', is_const=True)], is_virtual=True) + return + +def register_Ns3ListScheduler_methods(root_module, cls): + ## list-scheduler.h: ns3::ListScheduler::ListScheduler() [constructor] + cls.add_constructor([], visibility='public') + ## list-scheduler.h: void ns3::ListScheduler::Insert(ns3::EventId const & id) [member function] + cls.add_method('Insert', 'void', [param('ns3::EventId&', 'id', is_const=True)], is_virtual=True) + ## list-scheduler.h: bool ns3::ListScheduler::IsEmpty() const [member function] + cls.add_method('IsEmpty', 'bool', [], is_const=True, is_virtual=True) + ## list-scheduler.h: ns3::EventId ns3::ListScheduler::PeekNext() const [member function] + cls.add_method('PeekNext', 'ns3::EventId', [], is_const=True, is_virtual=True) + ## list-scheduler.h: ns3::EventId ns3::ListScheduler::RemoveNext() [member function] + cls.add_method('RemoveNext', 'ns3::EventId', [], is_virtual=True) + ## list-scheduler.h: bool ns3::ListScheduler::Remove(ns3::EventId const & ev) [member function] + cls.add_method('Remove', 'bool', [param('ns3::EventId&', 'ev', is_const=True)], is_virtual=True) + return + +def register_Ns3MapScheduler_methods(root_module, cls): + ## map-scheduler.h: ns3::MapScheduler::MapScheduler() [constructor] + cls.add_constructor([], visibility='public') + ## map-scheduler.h: void ns3::MapScheduler::Insert(ns3::EventId const & id) [member function] + cls.add_method('Insert', 'void', [param('ns3::EventId&', 'id', is_const=True)], is_virtual=True) + ## map-scheduler.h: bool ns3::MapScheduler::IsEmpty() const [member function] + cls.add_method('IsEmpty', 'bool', [], is_const=True, is_virtual=True) + ## map-scheduler.h: ns3::EventId ns3::MapScheduler::PeekNext() const [member function] + cls.add_method('PeekNext', 'ns3::EventId', [], is_const=True, is_virtual=True) + ## map-scheduler.h: ns3::EventId ns3::MapScheduler::RemoveNext() [member function] + cls.add_method('RemoveNext', 'ns3::EventId', [], is_virtual=True) + ## map-scheduler.h: bool ns3::MapScheduler::Remove(ns3::EventId const & ev) [member function] + cls.add_method('Remove', 'bool', [param('ns3::EventId&', 'ev', is_const=True)], is_virtual=True) + return + +def register_functions(root_module): + module = root_module + ## high-precision.h: extern ns3::HighPrecision ns3::Max(ns3::HighPrecision const & a, ns3::HighPrecision const & b) [free function] + module.add_function('Max', 'ns3::HighPrecision', [param('ns3::HighPrecision&', 'a', is_const=True), param('ns3::HighPrecision&', 'b', is_const=True)]) + ## nstime.h: extern ns3::Time ns3::FemtoSeconds(uint64_t fs) [free function] + module.add_function('FemtoSeconds', 'ns3::Time', [param('uint64_t', 'fs')]) + ## nstime.h: extern ns3::Time ns3::MicroSeconds(uint64_t us) [free function] + module.add_function('MicroSeconds', 'ns3::Time', [param('uint64_t', 'us')]) + ## simulator.h: extern ns3::Time ns3::Now() [free function] + module.add_function('Now', 'ns3::Time', []) + ## nstime.h: extern ns3::Time ns3::MilliSeconds(uint64_t ms) [free function] + module.add_function('MilliSeconds', 'ns3::Time', [param('uint64_t', 'ms')]) + ## nstime.h: extern ns3::Time ns3::NanoSeconds(uint64_t ns) [free function] + module.add_function('NanoSeconds', 'ns3::Time', [param('uint64_t', 'ns')]) + ## high-precision.h: extern ns3::HighPrecision ns3::Abs(ns3::HighPrecision const & value) [free function] + module.add_function('Abs', 'ns3::HighPrecision', [param('ns3::HighPrecision&', 'value', is_const=True)]) + ## nstime.h: extern ns3::Ptr ns3::MakeTimeChecker() [free function] + module.add_function('MakeTimeChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) + ## nstime.h: extern ns3::Time ns3::Seconds(double seconds) [free function] + module.add_function('Seconds', 'ns3::Time', [param('double', 'seconds')]) + ## nstime.h: extern ns3::Time ns3::PicoSeconds(uint64_t ps) [free function] + module.add_function('PicoSeconds', 'ns3::Time', [param('uint64_t', 'ps')]) + ## high-precision.h: extern ns3::HighPrecision ns3::Min(ns3::HighPrecision const & a, ns3::HighPrecision const & b) [free function] + module.add_function('Min', 'ns3::HighPrecision', [param('ns3::HighPrecision&', 'a', is_const=True), param('ns3::HighPrecision&', 'b', is_const=True)]) + ## nstime.h: extern ns3::Time ns3::TimeStep(uint64_t ts) [free function] + module.add_function('TimeStep', 'ns3::Time', [param('uint64_t', 'ts')]) + register_functions_ns3_internal(module.get_submodule('internal'), root_module) + register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module) + register_functions_ns3_Config(module.get_submodule('Config'), root_module) + register_functions_ns3_olsr(module.get_submodule('olsr'), root_module) + return + +def register_functions_ns3_internal(module, root_module): + return + +def register_functions_ns3_TimeStepPrecision(module, root_module): + ## nstime.h: extern void ns3::TimeStepPrecision::Set(ns3::TimeStepPrecision::precision_t precision) [free function] + module.add_function('Set', 'void', [param('ns3::TimeStepPrecision::precision_t', 'precision')]) + ## nstime.h: extern ns3::TimeStepPrecision::precision_t ns3::TimeStepPrecision::Get() [free function] + module.add_function('Get', 'ns3::TimeStepPrecision::precision_t', []) + return + +def register_functions_ns3_Config(module, root_module): + return + +def register_functions_ns3_olsr(module, root_module): + return + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/ns3_module_udp_echo.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/ns3_module_udp_echo.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,103 @@ +from pybindgen import Module, FileCodeSink, write_preamble, param, retval + +def register_types(module): + root_module = module.get_root() + + ## udp-echo-client.h: ns3::UdpEchoClient [class] + module.add_class('UdpEchoClient', allow_subclassing=True, parent=root_module['ns3::Application']) + ## udp-echo-server.h: ns3::UdpEchoServer [class] + module.add_class('UdpEchoServer', allow_subclassing=True, parent=root_module['ns3::Application']) + + ## Register a nested module for the namespace internal + + nested_module = module.add_cpp_namespace('internal') + register_types_ns3_internal(nested_module) + + + ## Register a nested module for the namespace TimeStepPrecision + + nested_module = module.add_cpp_namespace('TimeStepPrecision') + register_types_ns3_TimeStepPrecision(nested_module) + + + ## Register a nested module for the namespace Config + + nested_module = module.add_cpp_namespace('Config') + register_types_ns3_Config(nested_module) + + + ## Register a nested module for the namespace olsr + + nested_module = module.add_cpp_namespace('olsr') + register_types_ns3_olsr(nested_module) + + +def register_types_ns3_internal(module): + root_module = module.get_root() + + +def register_types_ns3_TimeStepPrecision(module): + root_module = module.get_root() + + +def register_types_ns3_Config(module): + root_module = module.get_root() + + +def register_types_ns3_olsr(module): + root_module = module.get_root() + + +def register_methods(root_module): + register_Ns3UdpEchoClient_methods(root_module, root_module['ns3::UdpEchoClient']) + register_Ns3UdpEchoServer_methods(root_module, root_module['ns3::UdpEchoServer']) + return + +def register_Ns3UdpEchoClient_methods(root_module, cls): + ## udp-echo-client.h: static ns3::TypeId ns3::UdpEchoClient::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## udp-echo-client.h: ns3::UdpEchoClient::UdpEchoClient() [constructor] + cls.add_constructor([], visibility='public') + ## udp-echo-client.h: void ns3::UdpEchoClient::SetRemote(ns3::Ipv4Address ip, uint16_t port) [member function] + cls.add_method('SetRemote', 'void', [param('ns3::Ipv4Address', 'ip'), param('uint16_t', 'port')]) + ## udp-echo-client.h: void ns3::UdpEchoClient::DoDispose() [member function] + cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True) + ## udp-echo-client.h: void ns3::UdpEchoClient::StartApplication() [member function] + cls.add_method('StartApplication', 'void', [], visibility='private', is_virtual=True) + ## udp-echo-client.h: void ns3::UdpEchoClient::StopApplication() [member function] + cls.add_method('StopApplication', 'void', [], visibility='private', is_virtual=True) + return + +def register_Ns3UdpEchoServer_methods(root_module, cls): + ## udp-echo-server.h: static ns3::TypeId ns3::UdpEchoServer::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## udp-echo-server.h: ns3::UdpEchoServer::UdpEchoServer() [constructor] + cls.add_constructor([], visibility='public') + ## udp-echo-server.h: void ns3::UdpEchoServer::DoDispose() [member function] + cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True) + ## udp-echo-server.h: void ns3::UdpEchoServer::StartApplication() [member function] + cls.add_method('StartApplication', 'void', [], visibility='private', is_virtual=True) + ## udp-echo-server.h: void ns3::UdpEchoServer::StopApplication() [member function] + cls.add_method('StopApplication', 'void', [], visibility='private', is_virtual=True) + return + +def register_functions(root_module): + module = root_module + register_functions_ns3_internal(module.get_submodule('internal'), root_module) + register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module) + register_functions_ns3_Config(module.get_submodule('Config'), root_module) + register_functions_ns3_olsr(module.get_submodule('olsr'), root_module) + return + +def register_functions_ns3_internal(module, root_module): + return + +def register_functions_ns3_TimeStepPrecision(module, root_module): + return + +def register_functions_ns3_Config(module, root_module): + return + +def register_functions_ns3_olsr(module, root_module): + return + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/ns3_module_wifi.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/ns3_module_wifi.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,1225 @@ +from pybindgen import Module, FileCodeSink, write_preamble, param, retval + +def register_types(module): + root_module = module.get_root() + + ## wifi-preamble.h: ns3::WifiPreamble [enumeration] + module.add_enum('WifiPreamble', ['WIFI_PREAMBLE_LONG', 'WIFI_PREAMBLE_SHORT']) + ## wifi-phy-standard.h: ns3::WifiPhyStandard [enumeration] + module.add_enum('WifiPhyStandard', ['WIFI_PHY_STANDARD_80211a', 'WIFI_PHY_STANDARD_holland']) + ## wifi-remote-station-manager.h: ns3::WifiRemoteStation [class] + module.add_class('WifiRemoteStation', allow_subclassing=True) + ## wifi-phy.h: ns3::WifiPhyListener [class] + module.add_class('WifiPhyListener', allow_subclassing=True) + ## rraa-wifi-manager.h: ns3::ThresholdsItem [struct] + module.add_class('ThresholdsItem') + ## supported-rates.h: ns3::SupportedRates [class] + module.add_class('SupportedRates') + ## ideal-wifi-manager.h: ns3::IdealWifiRemoteStation [class] + module.add_class('IdealWifiRemoteStation', allow_subclassing=True, parent=root_module['ns3::WifiRemoteStation']) + ## wifi-mode.h: ns3::WifiModeChecker [class] + module.add_class('WifiModeChecker', parent=root_module['ns3::AttributeChecker']) + ## wifi-mode.h: ns3::WifiModeFactory [class] + module.add_class('WifiModeFactory') + ## onoe-wifi-manager.h: ns3::OnoeWifiRemoteStation [class] + module.add_class('OnoeWifiRemoteStation', allow_subclassing=True, parent=root_module['ns3::WifiRemoteStation']) + ## rraa-wifi-manager.h: ns3::RraaWifiRemoteStation [class] + module.add_class('RraaWifiRemoteStation', allow_subclassing=True, parent=root_module['ns3::WifiRemoteStation']) + ## ssid.h: ns3::Ssid [class] + module.add_class('Ssid') + ## wifi-mode.h: ns3::WifiMode [class] + module.add_class('WifiMode') + ## wifi-mode.h: ns3::WifiMode::ModulationType [enumeration] + module.add_enum('ModulationType', ['BPSK', 'QAM'], outer_class=root_module['ns3::WifiMode']) + ## ssid.h: ns3::SsidValue [class] + module.add_class('SsidValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue']) + ## ssid.h: ns3::SsidChecker [class] + module.add_class('SsidChecker', parent=root_module['ns3::AttributeChecker']) + ## constant-rate-wifi-manager.h: ns3::ConstantRateWifiRemoteStation [class] + module.add_class('ConstantRateWifiRemoteStation', allow_subclassing=True, parent=root_module['ns3::WifiRemoteStation']) + ## propagation-loss-model.h: ns3::PropagationLossModel [class] + module.add_class('PropagationLossModel', allow_subclassing=True, parent=root_module['ns3::Object']) + ## arf-wifi-manager.h: ns3::ArfWifiRemoteStation [class] + module.add_class('ArfWifiRemoteStation', allow_subclassing=True, parent=root_module['ns3::WifiRemoteStation']) + ## wifi-mac.h: ns3::WifiMac [class] + module.add_class('WifiMac', allow_subclassing=True, parent=root_module['ns3::Object']) + ## nqap-wifi-mac.h: ns3::NqapWifiMac [class] + module.add_class('NqapWifiMac', allow_subclassing=True, parent=root_module['ns3::WifiMac']) + ## amrr-wifi-manager.h: ns3::AmrrWifiRemoteStation [class] + module.add_class('AmrrWifiRemoteStation', allow_subclassing=True, parent=root_module['ns3::WifiRemoteStation']) + ## composite-propagation-loss-model.h: ns3::CompositePropagationLossModel [class] + module.add_class('CompositePropagationLossModel', allow_subclassing=True, parent=root_module['ns3::PropagationLossModel']) + ## propagation-loss-model.h: ns3::FriisPropagationLossModel [class] + module.add_class('FriisPropagationLossModel', allow_subclassing=True, parent=root_module['ns3::PropagationLossModel']) + ## wifi-remote-station-manager.h: ns3::WifiRemoteStationManager [class] + module.add_class('WifiRemoteStationManager', allow_subclassing=True, parent=root_module['ns3::Object']) + ## wifi-mode.h: ns3::WifiModeValue [class] + module.add_class('WifiModeValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue']) + ## onoe-wifi-manager.h: ns3::OnoeWifiManager [class] + module.add_class('OnoeWifiManager', allow_subclassing=True, parent=root_module['ns3::WifiRemoteStationManager']) + ## wifi-phy.h: ns3::WifiPhy [class] + module.add_class('WifiPhy', allow_subclassing=True, parent=root_module['ns3::Object']) + ## wifi-phy.h: ns3::WifiPhy::State [enumeration] + module.add_enum('State', ['SYNC', 'TX', 'CCA_BUSY', 'IDLE'], outer_class=root_module['ns3::WifiPhy']) + ## wifi-channel.h: ns3::WifiChannel [class] + module.add_class('WifiChannel', allow_subclassing=True, parent=root_module['ns3::Channel']) + ## propagation-loss-model.h: ns3::LogDistancePropagationLossModel [class] + module.add_class('LogDistancePropagationLossModel', allow_subclassing=True, parent=root_module['ns3::PropagationLossModel']) + ## constant-rate-wifi-manager.h: ns3::ConstantRateWifiManager [class] + module.add_class('ConstantRateWifiManager', allow_subclassing=True, parent=root_module['ns3::WifiRemoteStationManager']) + ## aarf-wifi-manager.h: ns3::AarfWifiRemoteStation [class] + module.add_class('AarfWifiRemoteStation', allow_subclassing=True, parent=root_module['ns3::ArfWifiRemoteStation']) + ## propagation-delay-model.h: ns3::PropagationDelayModel [class] + module.add_class('PropagationDelayModel', allow_subclassing=True, parent=root_module['ns3::Object']) + ## adhoc-wifi-mac.h: ns3::AdhocWifiMac [class] + module.add_class('AdhocWifiMac', allow_subclassing=True, parent=root_module['ns3::WifiMac']) + ## jakes-propagation-loss-model.h: ns3::JakesPropagationLossModel [class] + module.add_class('JakesPropagationLossModel', allow_subclassing=True, parent=root_module['ns3::PropagationLossModel']) + ## propagation-delay-model.h: ns3::ConstantSpeedPropagationDelayModel [class] + module.add_class('ConstantSpeedPropagationDelayModel', allow_subclassing=True, parent=root_module['ns3::PropagationDelayModel']) + ## wifi-net-device.h: ns3::WifiNetDevice [class] + module.add_class('WifiNetDevice', allow_subclassing=True, parent=root_module['ns3::NetDevice']) + ## nqsta-wifi-mac.h: ns3::NqstaWifiMac [class] + module.add_class('NqstaWifiMac', allow_subclassing=True, parent=root_module['ns3::WifiMac']) + ## propagation-loss-model.h: ns3::RandomPropagationLossModel [class] + module.add_class('RandomPropagationLossModel', allow_subclassing=True, parent=root_module['ns3::PropagationLossModel']) + ## propagation-delay-model.h: ns3::RandomPropagationDelayModel [class] + module.add_class('RandomPropagationDelayModel', allow_subclassing=True, parent=root_module['ns3::PropagationDelayModel']) + ## amrr-wifi-manager.h: ns3::AmrrWifiManager [class] + module.add_class('AmrrWifiManager', allow_subclassing=True, parent=root_module['ns3::WifiRemoteStationManager']) + ## rraa-wifi-manager.h: ns3::RraaWifiManager [class] + module.add_class('RraaWifiManager', allow_subclassing=True, parent=root_module['ns3::WifiRemoteStationManager']) + ## ideal-wifi-manager.h: ns3::IdealWifiManager [class] + module.add_class('IdealWifiManager', allow_subclassing=True, parent=root_module['ns3::WifiRemoteStationManager']) + ## arf-wifi-manager.h: ns3::ArfWifiManager [class] + module.add_class('ArfWifiManager', allow_subclassing=True, parent=root_module['ns3::WifiRemoteStationManager']) + ## aarf-wifi-manager.h: ns3::AarfWifiManager [class] + module.add_class('AarfWifiManager', allow_subclassing=True, parent=root_module['ns3::ArfWifiManager']) + + ## Register a nested module for the namespace internal + + nested_module = module.add_cpp_namespace('internal') + register_types_ns3_internal(nested_module) + + + ## Register a nested module for the namespace TimeStepPrecision + + nested_module = module.add_cpp_namespace('TimeStepPrecision') + register_types_ns3_TimeStepPrecision(nested_module) + + + ## Register a nested module for the namespace Config + + nested_module = module.add_cpp_namespace('Config') + register_types_ns3_Config(nested_module) + + + ## Register a nested module for the namespace olsr + + nested_module = module.add_cpp_namespace('olsr') + register_types_ns3_olsr(nested_module) + + +def register_types_ns3_internal(module): + root_module = module.get_root() + + +def register_types_ns3_TimeStepPrecision(module): + root_module = module.get_root() + + +def register_types_ns3_Config(module): + root_module = module.get_root() + + +def register_types_ns3_olsr(module): + root_module = module.get_root() + + +def register_methods(root_module): + register_Ns3WifiRemoteStation_methods(root_module, root_module['ns3::WifiRemoteStation']) + register_Ns3WifiPhyListener_methods(root_module, root_module['ns3::WifiPhyListener']) + register_Ns3ThresholdsItem_methods(root_module, root_module['ns3::ThresholdsItem']) + register_Ns3SupportedRates_methods(root_module, root_module['ns3::SupportedRates']) + register_Ns3IdealWifiRemoteStation_methods(root_module, root_module['ns3::IdealWifiRemoteStation']) + register_Ns3WifiModeChecker_methods(root_module, root_module['ns3::WifiModeChecker']) + register_Ns3WifiModeFactory_methods(root_module, root_module['ns3::WifiModeFactory']) + register_Ns3OnoeWifiRemoteStation_methods(root_module, root_module['ns3::OnoeWifiRemoteStation']) + register_Ns3RraaWifiRemoteStation_methods(root_module, root_module['ns3::RraaWifiRemoteStation']) + register_Ns3Ssid_methods(root_module, root_module['ns3::Ssid']) + register_Ns3WifiMode_methods(root_module, root_module['ns3::WifiMode']) + register_Ns3SsidValue_methods(root_module, root_module['ns3::SsidValue']) + register_Ns3SsidChecker_methods(root_module, root_module['ns3::SsidChecker']) + register_Ns3ConstantRateWifiRemoteStation_methods(root_module, root_module['ns3::ConstantRateWifiRemoteStation']) + register_Ns3PropagationLossModel_methods(root_module, root_module['ns3::PropagationLossModel']) + register_Ns3ArfWifiRemoteStation_methods(root_module, root_module['ns3::ArfWifiRemoteStation']) + register_Ns3WifiMac_methods(root_module, root_module['ns3::WifiMac']) + register_Ns3NqapWifiMac_methods(root_module, root_module['ns3::NqapWifiMac']) + register_Ns3AmrrWifiRemoteStation_methods(root_module, root_module['ns3::AmrrWifiRemoteStation']) + register_Ns3CompositePropagationLossModel_methods(root_module, root_module['ns3::CompositePropagationLossModel']) + register_Ns3FriisPropagationLossModel_methods(root_module, root_module['ns3::FriisPropagationLossModel']) + register_Ns3WifiRemoteStationManager_methods(root_module, root_module['ns3::WifiRemoteStationManager']) + register_Ns3WifiModeValue_methods(root_module, root_module['ns3::WifiModeValue']) + register_Ns3OnoeWifiManager_methods(root_module, root_module['ns3::OnoeWifiManager']) + register_Ns3WifiPhy_methods(root_module, root_module['ns3::WifiPhy']) + register_Ns3WifiChannel_methods(root_module, root_module['ns3::WifiChannel']) + register_Ns3LogDistancePropagationLossModel_methods(root_module, root_module['ns3::LogDistancePropagationLossModel']) + register_Ns3ConstantRateWifiManager_methods(root_module, root_module['ns3::ConstantRateWifiManager']) + register_Ns3AarfWifiRemoteStation_methods(root_module, root_module['ns3::AarfWifiRemoteStation']) + register_Ns3PropagationDelayModel_methods(root_module, root_module['ns3::PropagationDelayModel']) + register_Ns3AdhocWifiMac_methods(root_module, root_module['ns3::AdhocWifiMac']) + register_Ns3JakesPropagationLossModel_methods(root_module, root_module['ns3::JakesPropagationLossModel']) + register_Ns3ConstantSpeedPropagationDelayModel_methods(root_module, root_module['ns3::ConstantSpeedPropagationDelayModel']) + register_Ns3WifiNetDevice_methods(root_module, root_module['ns3::WifiNetDevice']) + register_Ns3NqstaWifiMac_methods(root_module, root_module['ns3::NqstaWifiMac']) + register_Ns3RandomPropagationLossModel_methods(root_module, root_module['ns3::RandomPropagationLossModel']) + register_Ns3RandomPropagationDelayModel_methods(root_module, root_module['ns3::RandomPropagationDelayModel']) + register_Ns3AmrrWifiManager_methods(root_module, root_module['ns3::AmrrWifiManager']) + register_Ns3RraaWifiManager_methods(root_module, root_module['ns3::RraaWifiManager']) + register_Ns3IdealWifiManager_methods(root_module, root_module['ns3::IdealWifiManager']) + register_Ns3ArfWifiManager_methods(root_module, root_module['ns3::ArfWifiManager']) + register_Ns3AarfWifiManager_methods(root_module, root_module['ns3::AarfWifiManager']) + return + +def register_Ns3WifiRemoteStation_methods(root_module, cls): + ## wifi-remote-station-manager.h: static ns3::TypeId ns3::WifiRemoteStation::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## wifi-remote-station-manager.h: ns3::WifiRemoteStation::WifiRemoteStation() [constructor] + cls.add_constructor([], visibility='public') + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::Reset() [member function] + cls.add_method('Reset', 'void', []) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::AddSupportedMode(ns3::WifiMode mode) [member function] + cls.add_method('AddSupportedMode', 'void', [param('ns3::WifiMode', 'mode')]) + ## wifi-remote-station-manager.h: bool ns3::WifiRemoteStation::IsBrandNew() const [member function] + cls.add_method('IsBrandNew', 'bool', [], is_const=True) + ## wifi-remote-station-manager.h: bool ns3::WifiRemoteStation::IsAssociated() const [member function] + cls.add_method('IsAssociated', 'bool', [], is_const=True) + ## wifi-remote-station-manager.h: bool ns3::WifiRemoteStation::IsWaitAssocTxOk() const [member function] + cls.add_method('IsWaitAssocTxOk', 'bool', [], is_const=True) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::RecordWaitAssocTxOk() [member function] + cls.add_method('RecordWaitAssocTxOk', 'void', []) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::RecordGotAssocTxOk() [member function] + cls.add_method('RecordGotAssocTxOk', 'void', []) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::RecordGotAssocTxFailed() [member function] + cls.add_method('RecordGotAssocTxFailed', 'void', []) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::RecordDisassociated() [member function] + cls.add_method('RecordDisassociated', 'void', []) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::PrepareForQueue(ns3::Ptr packet, uint32_t fullPacketSize) [member function] + cls.add_method('PrepareForQueue', 'void', [param('ns3::Ptr< const ns3::Packet >', 'packet'), param('uint32_t', 'fullPacketSize')]) + ## wifi-remote-station-manager.h: ns3::WifiMode ns3::WifiRemoteStation::GetDataMode(ns3::Ptr packet, uint32_t fullPacketSize) [member function] + cls.add_method('GetDataMode', 'ns3::WifiMode', [param('ns3::Ptr< const ns3::Packet >', 'packet'), param('uint32_t', 'fullPacketSize')]) + ## wifi-remote-station-manager.h: ns3::WifiMode ns3::WifiRemoteStation::GetRtsMode(ns3::Ptr packet) [member function] + cls.add_method('GetRtsMode', 'ns3::WifiMode', [param('ns3::Ptr< const ns3::Packet >', 'packet')]) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::ReportRtsFailed() [member function] + cls.add_method('ReportRtsFailed', 'void', []) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::ReportDataFailed() [member function] + cls.add_method('ReportDataFailed', 'void', []) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::ReportRtsOk(double ctsSnr, ns3::WifiMode ctsMode, double rtsSnr) [member function] + cls.add_method('ReportRtsOk', 'void', [param('double', 'ctsSnr'), param('ns3::WifiMode', 'ctsMode'), param('double', 'rtsSnr')]) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::ReportDataOk(double ackSnr, ns3::WifiMode ackMode, double dataSnr) [member function] + cls.add_method('ReportDataOk', 'void', [param('double', 'ackSnr'), param('ns3::WifiMode', 'ackMode'), param('double', 'dataSnr')]) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::ReportFinalRtsFailed() [member function] + cls.add_method('ReportFinalRtsFailed', 'void', []) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::ReportFinalDataFailed() [member function] + cls.add_method('ReportFinalDataFailed', 'void', []) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::ReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function] + cls.add_method('ReportRxOk', 'void', [param('double', 'rxSnr'), param('ns3::WifiMode', 'txMode')]) + ## wifi-remote-station-manager.h: bool ns3::WifiRemoteStation::NeedRts(ns3::Ptr packet) [member function] + cls.add_method('NeedRts', 'bool', [param('ns3::Ptr< const ns3::Packet >', 'packet')], is_virtual=True) + ## wifi-remote-station-manager.h: bool ns3::WifiRemoteStation::NeedRtsRetransmission(ns3::Ptr packet) [member function] + cls.add_method('NeedRtsRetransmission', 'bool', [param('ns3::Ptr< const ns3::Packet >', 'packet')], is_virtual=True) + ## wifi-remote-station-manager.h: bool ns3::WifiRemoteStation::NeedDataRetransmission(ns3::Ptr packet) [member function] + cls.add_method('NeedDataRetransmission', 'bool', [param('ns3::Ptr< const ns3::Packet >', 'packet')], is_virtual=True) + ## wifi-remote-station-manager.h: bool ns3::WifiRemoteStation::NeedFragmentation(ns3::Ptr packet) [member function] + cls.add_method('NeedFragmentation', 'bool', [param('ns3::Ptr< const ns3::Packet >', 'packet')], is_virtual=True) + ## wifi-remote-station-manager.h: uint32_t ns3::WifiRemoteStation::GetNFragments(ns3::Ptr packet) [member function] + cls.add_method('GetNFragments', 'uint32_t', [param('ns3::Ptr< const ns3::Packet >', 'packet')], is_virtual=True) + ## wifi-remote-station-manager.h: uint32_t ns3::WifiRemoteStation::GetFragmentSize(ns3::Ptr packet, uint32_t fragmentNumber) [member function] + cls.add_method('GetFragmentSize', 'uint32_t', [param('ns3::Ptr< const ns3::Packet >', 'packet'), param('uint32_t', 'fragmentNumber')], is_virtual=True) + ## wifi-remote-station-manager.h: bool ns3::WifiRemoteStation::IsLastFragment(ns3::Ptr packet, uint32_t fragmentNumber) [member function] + cls.add_method('IsLastFragment', 'bool', [param('ns3::Ptr< const ns3::Packet >', 'packet'), param('uint32_t', 'fragmentNumber')], is_virtual=True) + ## wifi-remote-station-manager.h: ns3::WifiMode ns3::WifiRemoteStation::GetCtsMode(ns3::WifiMode rtsMode) [member function] + cls.add_method('GetCtsMode', 'ns3::WifiMode', [param('ns3::WifiMode', 'rtsMode')]) + ## wifi-remote-station-manager.h: ns3::WifiMode ns3::WifiRemoteStation::GetAckMode(ns3::WifiMode dataMode) [member function] + cls.add_method('GetAckMode', 'ns3::WifiMode', [param('ns3::WifiMode', 'dataMode')]) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::DoReportRtsFailed() [member function] + cls.add_method('DoReportRtsFailed', 'void', [], is_pure_virtual=True, visibility='protected', is_virtual=True) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::DoReportDataFailed() [member function] + cls.add_method('DoReportDataFailed', 'void', [], is_pure_virtual=True, visibility='protected', is_virtual=True) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::DoReportRtsOk(double ctsSnr, ns3::WifiMode ctsMode, double rtsSnr) [member function] + cls.add_method('DoReportRtsOk', 'void', [param('double', 'ctsSnr'), param('ns3::WifiMode', 'ctsMode'), param('double', 'rtsSnr')], is_pure_virtual=True, visibility='protected', is_virtual=True) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::DoReportDataOk(double ackSnr, ns3::WifiMode ackMode, double dataSnr) [member function] + cls.add_method('DoReportDataOk', 'void', [param('double', 'ackSnr'), param('ns3::WifiMode', 'ackMode'), param('double', 'dataSnr')], is_pure_virtual=True, visibility='protected', is_virtual=True) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::DoReportFinalRtsFailed() [member function] + cls.add_method('DoReportFinalRtsFailed', 'void', [], is_pure_virtual=True, visibility='protected', is_virtual=True) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::DoReportFinalDataFailed() [member function] + cls.add_method('DoReportFinalDataFailed', 'void', [], is_pure_virtual=True, visibility='protected', is_virtual=True) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function] + cls.add_method('DoReportRxOk', 'void', [param('double', 'rxSnr'), param('ns3::WifiMode', 'txMode')], is_pure_virtual=True, visibility='protected', is_virtual=True) + ## wifi-remote-station-manager.h: uint32_t ns3::WifiRemoteStation::GetNSupportedModes() const [member function] + cls.add_method('GetNSupportedModes', 'uint32_t', [], is_const=True, visibility='protected') + ## wifi-remote-station-manager.h: ns3::WifiMode ns3::WifiRemoteStation::GetSupportedMode(uint32_t i) const [member function] + cls.add_method('GetSupportedMode', 'ns3::WifiMode', [param('uint32_t', 'i')], is_const=True, visibility='protected') + ## wifi-remote-station-manager.h: ns3::Ptr ns3::WifiRemoteStation::GetManager() const [member function] + cls.add_method('GetManager', 'ns3::Ptr< ns3::WifiRemoteStationManager >', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + ## wifi-remote-station-manager.h: ns3::WifiMode ns3::WifiRemoteStation::DoGetDataMode(uint32_t size) [member function] + cls.add_method('DoGetDataMode', 'ns3::WifiMode', [param('uint32_t', 'size')], is_pure_virtual=True, visibility='private', is_virtual=True) + ## wifi-remote-station-manager.h: ns3::WifiMode ns3::WifiRemoteStation::DoGetRtsMode() [member function] + cls.add_method('DoGetRtsMode', 'ns3::WifiMode', [], is_pure_virtual=True, visibility='private', is_virtual=True) + return + +def register_Ns3WifiPhyListener_methods(root_module, cls): + ## wifi-phy.h: void ns3::WifiPhyListener::NotifyRxStart(ns3::Time duration) [member function] + cls.add_method('NotifyRxStart', 'void', [param('ns3::Time', 'duration')], is_pure_virtual=True, is_virtual=True) + ## wifi-phy.h: void ns3::WifiPhyListener::NotifyRxEndOk() [member function] + cls.add_method('NotifyRxEndOk', 'void', [], is_pure_virtual=True, is_virtual=True) + ## wifi-phy.h: void ns3::WifiPhyListener::NotifyRxEndError() [member function] + cls.add_method('NotifyRxEndError', 'void', [], is_pure_virtual=True, is_virtual=True) + ## wifi-phy.h: void ns3::WifiPhyListener::NotifyTxStart(ns3::Time duration) [member function] + cls.add_method('NotifyTxStart', 'void', [param('ns3::Time', 'duration')], is_pure_virtual=True, is_virtual=True) + ## wifi-phy.h: void ns3::WifiPhyListener::NotifyCcaBusyStart(ns3::Time duration) [member function] + cls.add_method('NotifyCcaBusyStart', 'void', [param('ns3::Time', 'duration')], is_pure_virtual=True, is_virtual=True) + cls.add_constructor([]) + return + +def register_Ns3ThresholdsItem_methods(root_module, cls): + ## rraa-wifi-manager.h: ns3::ThresholdsItem::datarate [variable] + cls.add_instance_attribute('datarate', 'uint32_t', is_const=False) + ## rraa-wifi-manager.h: ns3::ThresholdsItem::pori [variable] + cls.add_instance_attribute('pori', 'double', is_const=False) + ## rraa-wifi-manager.h: ns3::ThresholdsItem::pmtl [variable] + cls.add_instance_attribute('pmtl', 'double', is_const=False) + ## rraa-wifi-manager.h: ns3::ThresholdsItem::ewnd [variable] + cls.add_instance_attribute('ewnd', 'uint32_t', is_const=False) + cls.add_constructor([]) + return + +def register_Ns3SupportedRates_methods(root_module, cls): + ## supported-rates.h: ns3::SupportedRates::SupportedRates(ns3::SupportedRates const & arg0) [copy constructor] + cls.add_constructor([param('ns3::SupportedRates&', 'arg0', is_const=True)], visibility='public') + ## supported-rates.h: ns3::SupportedRates::SupportedRates() [constructor] + cls.add_constructor([], visibility='public') + ## supported-rates.h: void ns3::SupportedRates::AddSupportedRate(uint32_t bs) [member function] + cls.add_method('AddSupportedRate', 'void', [param('uint32_t', 'bs')]) + ## supported-rates.h: ns3::Buffer::Iterator ns3::SupportedRates::Deserialize(ns3::Buffer::Iterator start) [member function] + cls.add_method('Deserialize', 'ns3::Buffer::Iterator', [param('ns3::Buffer::Iterator', 'start')]) + ## supported-rates.h: uint8_t ns3::SupportedRates::GetNRates() const [member function] + cls.add_method('GetNRates', 'uint8_t', [], is_const=True) + ## supported-rates.h: uint32_t ns3::SupportedRates::GetRate(uint8_t i) const [member function] + cls.add_method('GetRate', 'uint32_t', [param('uint8_t', 'i')], is_const=True) + ## supported-rates.h: uint32_t ns3::SupportedRates::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True) + ## supported-rates.h: bool ns3::SupportedRates::IsBasicRate(uint32_t bs) const [member function] + cls.add_method('IsBasicRate', 'bool', [param('uint32_t', 'bs')], is_const=True) + ## supported-rates.h: bool ns3::SupportedRates::IsSupportedRate(uint32_t bs) const [member function] + cls.add_method('IsSupportedRate', 'bool', [param('uint32_t', 'bs')], is_const=True) + ## supported-rates.h: ns3::Buffer::Iterator ns3::SupportedRates::Serialize(ns3::Buffer::Iterator start) const [member function] + cls.add_method('Serialize', 'ns3::Buffer::Iterator', [param('ns3::Buffer::Iterator', 'start')], is_const=True) + ## supported-rates.h: void ns3::SupportedRates::SetBasicRate(uint32_t bs) [member function] + cls.add_method('SetBasicRate', 'void', [param('uint32_t', 'bs')]) + cls.add_output_stream_operator() + return + +def register_Ns3IdealWifiRemoteStation_methods(root_module, cls): + ## ideal-wifi-manager.h: ns3::IdealWifiRemoteStation::IdealWifiRemoteStation(ns3::Ptr stations) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::IdealWifiManager >', 'stations')], visibility='public') + ## ideal-wifi-manager.h: void ns3::IdealWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function] + cls.add_method('DoReportRxOk', 'void', [param('double', 'rxSnr'), param('ns3::WifiMode', 'txMode')], visibility='protected', is_virtual=True) + ## ideal-wifi-manager.h: void ns3::IdealWifiRemoteStation::DoReportRtsFailed() [member function] + cls.add_method('DoReportRtsFailed', 'void', [], visibility='protected', is_virtual=True) + ## ideal-wifi-manager.h: void ns3::IdealWifiRemoteStation::DoReportDataFailed() [member function] + cls.add_method('DoReportDataFailed', 'void', [], visibility='protected', is_virtual=True) + ## ideal-wifi-manager.h: void ns3::IdealWifiRemoteStation::DoReportRtsOk(double ctsSnr, ns3::WifiMode ctsMode, double rtsSnr) [member function] + cls.add_method('DoReportRtsOk', 'void', [param('double', 'ctsSnr'), param('ns3::WifiMode', 'ctsMode'), param('double', 'rtsSnr')], visibility='protected', is_virtual=True) + ## ideal-wifi-manager.h: void ns3::IdealWifiRemoteStation::DoReportDataOk(double ackSnr, ns3::WifiMode ackMode, double dataSnr) [member function] + cls.add_method('DoReportDataOk', 'void', [param('double', 'ackSnr'), param('ns3::WifiMode', 'ackMode'), param('double', 'dataSnr')], visibility='protected', is_virtual=True) + ## ideal-wifi-manager.h: void ns3::IdealWifiRemoteStation::DoReportFinalRtsFailed() [member function] + cls.add_method('DoReportFinalRtsFailed', 'void', [], visibility='protected', is_virtual=True) + ## ideal-wifi-manager.h: void ns3::IdealWifiRemoteStation::DoReportFinalDataFailed() [member function] + cls.add_method('DoReportFinalDataFailed', 'void', [], visibility='protected', is_virtual=True) + ## ideal-wifi-manager.h: ns3::Ptr ns3::IdealWifiRemoteStation::GetManager() const [member function] + cls.add_method('GetManager', 'ns3::Ptr< ns3::WifiRemoteStationManager >', [], is_const=True, visibility='private', is_virtual=True) + ## ideal-wifi-manager.h: ns3::WifiMode ns3::IdealWifiRemoteStation::DoGetDataMode(uint32_t size) [member function] + cls.add_method('DoGetDataMode', 'ns3::WifiMode', [param('uint32_t', 'size')], visibility='private', is_virtual=True) + ## ideal-wifi-manager.h: ns3::WifiMode ns3::IdealWifiRemoteStation::DoGetRtsMode() [member function] + cls.add_method('DoGetRtsMode', 'ns3::WifiMode', [], visibility='private', is_virtual=True) + return + +def register_Ns3WifiModeChecker_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3WifiModeFactory_methods(root_module, cls): + ## wifi-mode.h: static ns3::WifiMode ns3::WifiModeFactory::CreateBpsk(std::string uniqueName, bool isMandatory, uint32_t bandwidth, uint32_t dataRate, uint32_t phyRate) [member function] + cls.add_method('CreateBpsk', 'ns3::WifiMode', [param('std::string', 'uniqueName'), param('bool', 'isMandatory'), param('uint32_t', 'bandwidth'), param('uint32_t', 'dataRate'), param('uint32_t', 'phyRate')], is_static=True) + ## wifi-mode.h: static ns3::WifiMode ns3::WifiModeFactory::CreateQam(std::string uniqueName, bool isMandatory, uint32_t bandwidth, uint32_t dataRate, uint32_t phyRate, uint8_t constellationSize) [member function] + cls.add_method('CreateQam', 'ns3::WifiMode', [param('std::string', 'uniqueName'), param('bool', 'isMandatory'), param('uint32_t', 'bandwidth'), param('uint32_t', 'dataRate'), param('uint32_t', 'phyRate'), param('uint8_t', 'constellationSize')], is_static=True) + return + +def register_Ns3OnoeWifiRemoteStation_methods(root_module, cls): + ## onoe-wifi-manager.h: ns3::OnoeWifiRemoteStation::OnoeWifiRemoteStation(ns3::Ptr stations) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::OnoeWifiManager >', 'stations')], visibility='public') + ## onoe-wifi-manager.h: void ns3::OnoeWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function] + cls.add_method('DoReportRxOk', 'void', [param('double', 'rxSnr'), param('ns3::WifiMode', 'txMode')], visibility='protected', is_virtual=True) + ## onoe-wifi-manager.h: void ns3::OnoeWifiRemoteStation::DoReportRtsFailed() [member function] + cls.add_method('DoReportRtsFailed', 'void', [], visibility='protected', is_virtual=True) + ## onoe-wifi-manager.h: void ns3::OnoeWifiRemoteStation::DoReportDataFailed() [member function] + cls.add_method('DoReportDataFailed', 'void', [], visibility='protected', is_virtual=True) + ## onoe-wifi-manager.h: void ns3::OnoeWifiRemoteStation::DoReportRtsOk(double ctsSnr, ns3::WifiMode ctsMode, double rtsSnr) [member function] + cls.add_method('DoReportRtsOk', 'void', [param('double', 'ctsSnr'), param('ns3::WifiMode', 'ctsMode'), param('double', 'rtsSnr')], visibility='protected', is_virtual=True) + ## onoe-wifi-manager.h: void ns3::OnoeWifiRemoteStation::DoReportDataOk(double ackSnr, ns3::WifiMode ackMode, double dataSnr) [member function] + cls.add_method('DoReportDataOk', 'void', [param('double', 'ackSnr'), param('ns3::WifiMode', 'ackMode'), param('double', 'dataSnr')], visibility='protected', is_virtual=True) + ## onoe-wifi-manager.h: void ns3::OnoeWifiRemoteStation::DoReportFinalRtsFailed() [member function] + cls.add_method('DoReportFinalRtsFailed', 'void', [], visibility='protected', is_virtual=True) + ## onoe-wifi-manager.h: void ns3::OnoeWifiRemoteStation::DoReportFinalDataFailed() [member function] + cls.add_method('DoReportFinalDataFailed', 'void', [], visibility='protected', is_virtual=True) + ## onoe-wifi-manager.h: ns3::Ptr ns3::OnoeWifiRemoteStation::GetManager() const [member function] + cls.add_method('GetManager', 'ns3::Ptr< ns3::WifiRemoteStationManager >', [], is_const=True, visibility='private', is_virtual=True) + ## onoe-wifi-manager.h: ns3::WifiMode ns3::OnoeWifiRemoteStation::DoGetDataMode(uint32_t size) [member function] + cls.add_method('DoGetDataMode', 'ns3::WifiMode', [param('uint32_t', 'size')], visibility='private', is_virtual=True) + ## onoe-wifi-manager.h: ns3::WifiMode ns3::OnoeWifiRemoteStation::DoGetRtsMode() [member function] + cls.add_method('DoGetRtsMode', 'ns3::WifiMode', [], visibility='private', is_virtual=True) + return + +def register_Ns3RraaWifiRemoteStation_methods(root_module, cls): + ## rraa-wifi-manager.h: ns3::RraaWifiRemoteStation::RraaWifiRemoteStation(ns3::Ptr stations) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::RraaWifiManager >', 'stations')], visibility='public') + ## rraa-wifi-manager.h: bool ns3::RraaWifiRemoteStation::NeedRts(ns3::Ptr packet) [member function] + cls.add_method('NeedRts', 'bool', [param('ns3::Ptr< const ns3::Packet >', 'packet')], is_virtual=True) + ## rraa-wifi-manager.h: void ns3::RraaWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function] + cls.add_method('DoReportRxOk', 'void', [param('double', 'rxSnr'), param('ns3::WifiMode', 'txMode')], visibility='protected', is_virtual=True) + ## rraa-wifi-manager.h: void ns3::RraaWifiRemoteStation::DoReportRtsFailed() [member function] + cls.add_method('DoReportRtsFailed', 'void', [], visibility='protected', is_virtual=True) + ## rraa-wifi-manager.h: void ns3::RraaWifiRemoteStation::DoReportDataFailed() [member function] + cls.add_method('DoReportDataFailed', 'void', [], visibility='protected', is_virtual=True) + ## rraa-wifi-manager.h: void ns3::RraaWifiRemoteStation::DoReportRtsOk(double ctsSnr, ns3::WifiMode ctsMode, double rtsSnr) [member function] + cls.add_method('DoReportRtsOk', 'void', [param('double', 'ctsSnr'), param('ns3::WifiMode', 'ctsMode'), param('double', 'rtsSnr')], visibility='protected', is_virtual=True) + ## rraa-wifi-manager.h: void ns3::RraaWifiRemoteStation::DoReportDataOk(double ackSnr, ns3::WifiMode ackMode, double dataSnr) [member function] + cls.add_method('DoReportDataOk', 'void', [param('double', 'ackSnr'), param('ns3::WifiMode', 'ackMode'), param('double', 'dataSnr')], visibility='protected', is_virtual=True) + ## rraa-wifi-manager.h: void ns3::RraaWifiRemoteStation::DoReportFinalRtsFailed() [member function] + cls.add_method('DoReportFinalRtsFailed', 'void', [], visibility='protected', is_virtual=True) + ## rraa-wifi-manager.h: void ns3::RraaWifiRemoteStation::DoReportFinalDataFailed() [member function] + cls.add_method('DoReportFinalDataFailed', 'void', [], visibility='protected', is_virtual=True) + ## rraa-wifi-manager.h: ns3::Ptr ns3::RraaWifiRemoteStation::GetManager() const [member function] + cls.add_method('GetManager', 'ns3::Ptr< ns3::WifiRemoteStationManager >', [], is_const=True, visibility='private', is_virtual=True) + ## rraa-wifi-manager.h: ns3::WifiMode ns3::RraaWifiRemoteStation::DoGetDataMode(uint32_t size) [member function] + cls.add_method('DoGetDataMode', 'ns3::WifiMode', [param('uint32_t', 'size')], visibility='private', is_virtual=True) + ## rraa-wifi-manager.h: ns3::WifiMode ns3::RraaWifiRemoteStation::DoGetRtsMode() [member function] + cls.add_method('DoGetRtsMode', 'ns3::WifiMode', [], visibility='private', is_virtual=True) + return + +def register_Ns3Ssid_methods(root_module, cls): + ## ssid.h: ns3::Ssid::Ssid(ns3::Ssid const & arg0) [copy constructor] + cls.add_constructor([param('ns3::Ssid&', 'arg0', is_const=True)], visibility='public') + ## ssid.h: ns3::Ssid::Ssid() [constructor] + cls.add_constructor([], visibility='public') + ## ssid.h: ns3::Ssid::Ssid(char const * ssid) [constructor] + cls.add_constructor([param('char *', 'ssid', transfer_ownership=False, is_const=True)], visibility='public') + ## ssid.h: ns3::Ssid::Ssid(char const * ssid, uint8_t length) [constructor] + cls.add_constructor([param('char *', 'ssid', transfer_ownership=False, is_const=True), param('uint8_t', 'length')], visibility='public') + ## ssid.h: ns3::Buffer::Iterator ns3::Ssid::Deserialize(ns3::Buffer::Iterator i) [member function] + cls.add_method('Deserialize', 'ns3::Buffer::Iterator', [param('ns3::Buffer::Iterator', 'i')]) + ## ssid.h: uint32_t ns3::Ssid::GetLength() const [member function] + cls.add_method('GetLength', 'uint32_t', [], is_const=True) + ## ssid.h: uint32_t ns3::Ssid::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True) + ## ssid.h: bool ns3::Ssid::IsBroadcast() const [member function] + cls.add_method('IsBroadcast', 'bool', [], is_const=True) + ## ssid.h: bool ns3::Ssid::IsEqual(ns3::Ssid const & o) const [member function] + cls.add_method('IsEqual', 'bool', [param('ns3::Ssid&', 'o', is_const=True)], is_const=True) + ## ssid.h: char * ns3::Ssid::PeekString() const [member function] + cls.add_method('PeekString', 'char *', [], is_const=True) + ## ssid.h: ns3::Buffer::Iterator ns3::Ssid::Serialize(ns3::Buffer::Iterator i) const [member function] + cls.add_method('Serialize', 'ns3::Buffer::Iterator', [param('ns3::Buffer::Iterator', 'i')], is_const=True) + cls.add_output_stream_operator() + return + +def register_Ns3WifiMode_methods(root_module, cls): + ## wifi-mode.h: ns3::WifiMode::WifiMode(ns3::WifiMode const & arg0) [copy constructor] + cls.add_constructor([param('ns3::WifiMode&', 'arg0', is_const=True)], visibility='public') + ## wifi-mode.h: ns3::WifiMode::WifiMode() [constructor] + cls.add_constructor([], visibility='public') + ## wifi-mode.h: uint32_t ns3::WifiMode::GetBandwidth() const [member function] + cls.add_method('GetBandwidth', 'uint32_t', [], is_const=True) + ## wifi-mode.h: uint8_t ns3::WifiMode::GetConstellationSize() const [member function] + cls.add_method('GetConstellationSize', 'uint8_t', [], is_const=True) + ## wifi-mode.h: uint32_t ns3::WifiMode::GetDataRate() const [member function] + cls.add_method('GetDataRate', 'uint32_t', [], is_const=True) + ## wifi-mode.h: ns3::WifiMode::ModulationType ns3::WifiMode::GetModulationType() const [member function] + cls.add_method('GetModulationType', 'ns3::WifiMode::ModulationType', [], is_const=True) + ## wifi-mode.h: uint32_t ns3::WifiMode::GetPhyRate() const [member function] + cls.add_method('GetPhyRate', 'uint32_t', [], is_const=True) + ## wifi-mode.h: uint32_t ns3::WifiMode::GetUid() const [member function] + cls.add_method('GetUid', 'uint32_t', [], is_const=True) + ## wifi-mode.h: std::string ns3::WifiMode::GetUniqueName() const [member function] + cls.add_method('GetUniqueName', 'std::string', [], is_const=True) + ## wifi-mode.h: bool ns3::WifiMode::IsMandatory() const [member function] + cls.add_method('IsMandatory', 'bool', [], is_const=True) + ## wifi-mode.h: bool ns3::WifiMode::IsModulationBpsk() const [member function] + cls.add_method('IsModulationBpsk', 'bool', [], is_const=True) + ## wifi-mode.h: bool ns3::WifiMode::IsModulationQam() const [member function] + cls.add_method('IsModulationQam', 'bool', [], is_const=True) + cls.add_output_stream_operator() + return + +def register_Ns3SsidValue_methods(root_module, cls): + ## ssid.h: ns3::SsidValue::SsidValue() [constructor] + cls.add_constructor([], visibility='public') + ## ssid.h: ns3::SsidValue::SsidValue(ns3::Ssid const & value) [constructor] + cls.add_constructor([param('ns3::Ssid&', 'value', is_const=True)], visibility='public') + ## ssid.h: void ns3::SsidValue::Set(ns3::Ssid const & value) [member function] + cls.add_method('Set', 'void', [param('ns3::Ssid&', 'value', is_const=True)]) + ## ssid.h: ns3::Ssid ns3::SsidValue::Get() const [member function] + cls.add_method('Get', 'ns3::Ssid', [], is_const=True) + ## ssid.h: ns3::Ptr ns3::SsidValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) + ## ssid.h: std::string ns3::SsidValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True) + ## ssid.h: bool ns3::SsidValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) + return + +def register_Ns3SsidChecker_methods(root_module, cls): + cls.add_constructor([]) + return + +def register_Ns3ConstantRateWifiRemoteStation_methods(root_module, cls): + ## constant-rate-wifi-manager.h: ns3::ConstantRateWifiRemoteStation::ConstantRateWifiRemoteStation(ns3::Ptr stations) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::ConstantRateWifiManager >', 'stations')], visibility='public') + ## constant-rate-wifi-manager.h: void ns3::ConstantRateWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function] + cls.add_method('DoReportRxOk', 'void', [param('double', 'rxSnr'), param('ns3::WifiMode', 'txMode')], visibility='protected', is_virtual=True) + ## constant-rate-wifi-manager.h: void ns3::ConstantRateWifiRemoteStation::DoReportRtsFailed() [member function] + cls.add_method('DoReportRtsFailed', 'void', [], visibility='protected', is_virtual=True) + ## constant-rate-wifi-manager.h: void ns3::ConstantRateWifiRemoteStation::DoReportDataFailed() [member function] + cls.add_method('DoReportDataFailed', 'void', [], visibility='protected', is_virtual=True) + ## constant-rate-wifi-manager.h: void ns3::ConstantRateWifiRemoteStation::DoReportRtsOk(double ctsSnr, ns3::WifiMode ctsMode, double rtsSnr) [member function] + cls.add_method('DoReportRtsOk', 'void', [param('double', 'ctsSnr'), param('ns3::WifiMode', 'ctsMode'), param('double', 'rtsSnr')], visibility='protected', is_virtual=True) + ## constant-rate-wifi-manager.h: void ns3::ConstantRateWifiRemoteStation::DoReportDataOk(double ackSnr, ns3::WifiMode ackMode, double dataSnr) [member function] + cls.add_method('DoReportDataOk', 'void', [param('double', 'ackSnr'), param('ns3::WifiMode', 'ackMode'), param('double', 'dataSnr')], visibility='protected', is_virtual=True) + ## constant-rate-wifi-manager.h: void ns3::ConstantRateWifiRemoteStation::DoReportFinalRtsFailed() [member function] + cls.add_method('DoReportFinalRtsFailed', 'void', [], visibility='protected', is_virtual=True) + ## constant-rate-wifi-manager.h: void ns3::ConstantRateWifiRemoteStation::DoReportFinalDataFailed() [member function] + cls.add_method('DoReportFinalDataFailed', 'void', [], visibility='protected', is_virtual=True) + ## constant-rate-wifi-manager.h: ns3::Ptr ns3::ConstantRateWifiRemoteStation::GetManager() const [member function] + cls.add_method('GetManager', 'ns3::Ptr< ns3::WifiRemoteStationManager >', [], is_const=True, visibility='private', is_virtual=True) + ## constant-rate-wifi-manager.h: ns3::WifiMode ns3::ConstantRateWifiRemoteStation::DoGetDataMode(uint32_t size) [member function] + cls.add_method('DoGetDataMode', 'ns3::WifiMode', [param('uint32_t', 'size')], visibility='private', is_virtual=True) + ## constant-rate-wifi-manager.h: ns3::WifiMode ns3::ConstantRateWifiRemoteStation::DoGetRtsMode() [member function] + cls.add_method('DoGetRtsMode', 'ns3::WifiMode', [], visibility='private', is_virtual=True) + return + +def register_Ns3PropagationLossModel_methods(root_module, cls): + ## propagation-loss-model.h: static ns3::TypeId ns3::PropagationLossModel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## propagation-loss-model.h: double ns3::PropagationLossModel::GetLoss(ns3::Ptr a, ns3::Ptr b) const [member function] + cls.add_method('GetLoss', 'double', [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], is_pure_virtual=True, is_const=True, is_virtual=True) + cls.add_constructor([]) + return + +def register_Ns3ArfWifiRemoteStation_methods(root_module, cls): + ## arf-wifi-manager.h: ns3::ArfWifiRemoteStation::ArfWifiRemoteStation(ns3::Ptr stations, int minTimerTimeout, int minSuccessThreshold) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::ArfWifiManager >', 'stations'), param('int', 'minTimerTimeout'), param('int', 'minSuccessThreshold')], visibility='public') + ## arf-wifi-manager.h: void ns3::ArfWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function] + cls.add_method('DoReportRxOk', 'void', [param('double', 'rxSnr'), param('ns3::WifiMode', 'txMode')], visibility='protected', is_virtual=True) + ## arf-wifi-manager.h: void ns3::ArfWifiRemoteStation::DoReportRtsFailed() [member function] + cls.add_method('DoReportRtsFailed', 'void', [], visibility='protected', is_virtual=True) + ## arf-wifi-manager.h: void ns3::ArfWifiRemoteStation::DoReportDataFailed() [member function] + cls.add_method('DoReportDataFailed', 'void', [], visibility='protected', is_virtual=True) + ## arf-wifi-manager.h: void ns3::ArfWifiRemoteStation::DoReportRtsOk(double ctsSnr, ns3::WifiMode ctsMode, double rtsSnr) [member function] + cls.add_method('DoReportRtsOk', 'void', [param('double', 'ctsSnr'), param('ns3::WifiMode', 'ctsMode'), param('double', 'rtsSnr')], visibility='protected', is_virtual=True) + ## arf-wifi-manager.h: void ns3::ArfWifiRemoteStation::DoReportDataOk(double ackSnr, ns3::WifiMode ackMode, double dataSnr) [member function] + cls.add_method('DoReportDataOk', 'void', [param('double', 'ackSnr'), param('ns3::WifiMode', 'ackMode'), param('double', 'dataSnr')], visibility='protected', is_virtual=True) + ## arf-wifi-manager.h: void ns3::ArfWifiRemoteStation::DoReportFinalRtsFailed() [member function] + cls.add_method('DoReportFinalRtsFailed', 'void', [], visibility='protected', is_virtual=True) + ## arf-wifi-manager.h: void ns3::ArfWifiRemoteStation::DoReportFinalDataFailed() [member function] + cls.add_method('DoReportFinalDataFailed', 'void', [], visibility='protected', is_virtual=True) + ## arf-wifi-manager.h: uint32_t ns3::ArfWifiRemoteStation::GetMinTimerTimeout() [member function] + cls.add_method('GetMinTimerTimeout', 'uint32_t', [], visibility='protected') + ## arf-wifi-manager.h: uint32_t ns3::ArfWifiRemoteStation::GetMinSuccessThreshold() [member function] + cls.add_method('GetMinSuccessThreshold', 'uint32_t', [], visibility='protected') + ## arf-wifi-manager.h: uint32_t ns3::ArfWifiRemoteStation::GetTimerTimeout() [member function] + cls.add_method('GetTimerTimeout', 'uint32_t', [], visibility='protected') + ## arf-wifi-manager.h: uint32_t ns3::ArfWifiRemoteStation::GetSuccessThreshold() [member function] + cls.add_method('GetSuccessThreshold', 'uint32_t', [], visibility='protected') + ## arf-wifi-manager.h: void ns3::ArfWifiRemoteStation::SetTimerTimeout(uint32_t timerTimeout) [member function] + cls.add_method('SetTimerTimeout', 'void', [param('uint32_t', 'timerTimeout')], visibility='protected') + ## arf-wifi-manager.h: void ns3::ArfWifiRemoteStation::SetSuccessThreshold(uint32_t successThreshold) [member function] + cls.add_method('SetSuccessThreshold', 'void', [param('uint32_t', 'successThreshold')], visibility='protected') + ## arf-wifi-manager.h: ns3::Ptr ns3::ArfWifiRemoteStation::GetManager() const [member function] + cls.add_method('GetManager', 'ns3::Ptr< ns3::WifiRemoteStationManager >', [], is_const=True, visibility='private', is_virtual=True) + ## arf-wifi-manager.h: ns3::WifiMode ns3::ArfWifiRemoteStation::DoGetDataMode(uint32_t size) [member function] + cls.add_method('DoGetDataMode', 'ns3::WifiMode', [param('uint32_t', 'size')], visibility='private', is_virtual=True) + ## arf-wifi-manager.h: ns3::WifiMode ns3::ArfWifiRemoteStation::DoGetRtsMode() [member function] + cls.add_method('DoGetRtsMode', 'ns3::WifiMode', [], visibility='private', is_virtual=True) + ## arf-wifi-manager.h: void ns3::ArfWifiRemoteStation::ReportRecoveryFailure() [member function] + cls.add_method('ReportRecoveryFailure', 'void', [], visibility='private', is_virtual=True) + ## arf-wifi-manager.h: void ns3::ArfWifiRemoteStation::ReportFailure() [member function] + cls.add_method('ReportFailure', 'void', [], visibility='private', is_virtual=True) + return + +def register_Ns3WifiMac_methods(root_module, cls): + ## wifi-mac.h: static ns3::TypeId ns3::WifiMac::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## wifi-mac.h: void ns3::WifiMac::SetSlot(ns3::Time slotTime) [member function] + cls.add_method('SetSlot', 'void', [param('ns3::Time', 'slotTime')], is_pure_virtual=True, is_virtual=True) + ## wifi-mac.h: void ns3::WifiMac::SetSifs(ns3::Time sifs) [member function] + cls.add_method('SetSifs', 'void', [param('ns3::Time', 'sifs')], is_pure_virtual=True, is_virtual=True) + ## wifi-mac.h: void ns3::WifiMac::SetEifsNoDifs(ns3::Time eifsNoDifs) [member function] + cls.add_method('SetEifsNoDifs', 'void', [param('ns3::Time', 'eifsNoDifs')], is_pure_virtual=True, is_virtual=True) + ## wifi-mac.h: void ns3::WifiMac::SetPifs(ns3::Time pifs) [member function] + cls.add_method('SetPifs', 'void', [param('ns3::Time', 'pifs')]) + ## wifi-mac.h: void ns3::WifiMac::SetCtsTimeout(ns3::Time ctsTimeout) [member function] + cls.add_method('SetCtsTimeout', 'void', [param('ns3::Time', 'ctsTimeout')]) + ## wifi-mac.h: void ns3::WifiMac::SetAckTimeout(ns3::Time ackTimeout) [member function] + cls.add_method('SetAckTimeout', 'void', [param('ns3::Time', 'ackTimeout')]) + ## wifi-mac.h: void ns3::WifiMac::SetMaxPropagationDelay(ns3::Time delay) [member function] + cls.add_method('SetMaxPropagationDelay', 'void', [param('ns3::Time', 'delay')]) + ## wifi-mac.h: ns3::Time ns3::WifiMac::GetPifs() const [member function] + cls.add_method('GetPifs', 'ns3::Time', [], is_const=True) + ## wifi-mac.h: ns3::Time ns3::WifiMac::GetSifs() const [member function] + cls.add_method('GetSifs', 'ns3::Time', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## wifi-mac.h: ns3::Time ns3::WifiMac::GetSlot() const [member function] + cls.add_method('GetSlot', 'ns3::Time', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## wifi-mac.h: ns3::Time ns3::WifiMac::GetEifsNoDifs() const [member function] + cls.add_method('GetEifsNoDifs', 'ns3::Time', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## wifi-mac.h: ns3::Time ns3::WifiMac::GetCtsTimeout() const [member function] + cls.add_method('GetCtsTimeout', 'ns3::Time', [], is_const=True) + ## wifi-mac.h: ns3::Time ns3::WifiMac::GetAckTimeout() const [member function] + cls.add_method('GetAckTimeout', 'ns3::Time', [], is_const=True) + ## wifi-mac.h: ns3::Time ns3::WifiMac::GetMsduLifetime() const [member function] + cls.add_method('GetMsduLifetime', 'ns3::Time', [], is_const=True) + ## wifi-mac.h: ns3::Time ns3::WifiMac::GetMaxPropagationDelay() const [member function] + cls.add_method('GetMaxPropagationDelay', 'ns3::Time', [], is_const=True) + ## wifi-mac.h: uint32_t ns3::WifiMac::GetMaxMsduSize() const [member function] + cls.add_method('GetMaxMsduSize', 'uint32_t', [], is_const=True) + ## wifi-mac.h: ns3::Mac48Address ns3::WifiMac::GetAddress() const [member function] + cls.add_method('GetAddress', 'ns3::Mac48Address', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## wifi-mac.h: ns3::Ssid ns3::WifiMac::GetSsid() const [member function] + cls.add_method('GetSsid', 'ns3::Ssid', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## wifi-mac.h: ns3::Mac48Address ns3::WifiMac::GetBssid() const [member function] + cls.add_method('GetBssid', 'ns3::Mac48Address', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## wifi-mac.h: void ns3::WifiMac::SetAddress(ns3::Mac48Address address) [member function] + cls.add_method('SetAddress', 'void', [param('ns3::Mac48Address', 'address')], is_pure_virtual=True, is_virtual=True) + ## wifi-mac.h: void ns3::WifiMac::SetSsid(ns3::Ssid ssid) [member function] + cls.add_method('SetSsid', 'void', [param('ns3::Ssid', 'ssid')], is_pure_virtual=True, is_virtual=True) + ## wifi-mac.h: void ns3::WifiMac::Enqueue(ns3::Ptr packet, ns3::Mac48Address to) [member function] + cls.add_method('Enqueue', 'void', [param('ns3::Ptr< const ns3::Packet >', 'packet'), param('ns3::Mac48Address', 'to')], is_pure_virtual=True, visibility='private', is_virtual=True) + ## wifi-mac.h: void ns3::WifiMac::SetWifiPhy(ns3::Ptr phy) [member function] + cls.add_method('SetWifiPhy', 'void', [param('ns3::Ptr< ns3::WifiPhy >', 'phy')], is_pure_virtual=True, visibility='private', is_virtual=True) + ## wifi-mac.h: void ns3::WifiMac::SetWifiRemoteStationManager(ns3::Ptr stationManager) [member function] + cls.add_method('SetWifiRemoteStationManager', 'void', [param('ns3::Ptr< ns3::WifiRemoteStationManager >', 'stationManager')], is_pure_virtual=True, visibility='private', is_virtual=True) + ## wifi-mac.h: void ns3::WifiMac::SetForwardUpCallback(ns3::Callback, ns3::Mac48Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty> upCallback) [member function] + cls.add_method('SetForwardUpCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::Mac48Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'upCallback')], is_pure_virtual=True, visibility='private', is_virtual=True) + ## wifi-mac.h: void ns3::WifiMac::SetLinkUpCallback(ns3::Callback linkUp) [member function] + cls.add_method('SetLinkUpCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'linkUp')], is_pure_virtual=True, visibility='private', is_virtual=True) + ## wifi-mac.h: void ns3::WifiMac::SetLinkDownCallback(ns3::Callback linkDown) [member function] + cls.add_method('SetLinkDownCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'linkDown')], is_pure_virtual=True, visibility='private', is_virtual=True) + cls.add_constructor([]) + return + +def register_Ns3NqapWifiMac_methods(root_module, cls): + ## nqap-wifi-mac.h: static ns3::TypeId ns3::NqapWifiMac::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## nqap-wifi-mac.h: ns3::NqapWifiMac::NqapWifiMac() [constructor] + cls.add_constructor([], visibility='public') + ## nqap-wifi-mac.h: void ns3::NqapWifiMac::SetSlot(ns3::Time slotTime) [member function] + cls.add_method('SetSlot', 'void', [param('ns3::Time', 'slotTime')], is_virtual=True) + ## nqap-wifi-mac.h: void ns3::NqapWifiMac::SetSifs(ns3::Time sifs) [member function] + cls.add_method('SetSifs', 'void', [param('ns3::Time', 'sifs')], is_virtual=True) + ## nqap-wifi-mac.h: void ns3::NqapWifiMac::SetEifsNoDifs(ns3::Time eifsNoDifs) [member function] + cls.add_method('SetEifsNoDifs', 'void', [param('ns3::Time', 'eifsNoDifs')], is_virtual=True) + ## nqap-wifi-mac.h: ns3::Time ns3::NqapWifiMac::GetSlot() const [member function] + cls.add_method('GetSlot', 'ns3::Time', [], is_const=True, is_virtual=True) + ## nqap-wifi-mac.h: ns3::Time ns3::NqapWifiMac::GetSifs() const [member function] + cls.add_method('GetSifs', 'ns3::Time', [], is_const=True, is_virtual=True) + ## nqap-wifi-mac.h: ns3::Time ns3::NqapWifiMac::GetEifsNoDifs() const [member function] + cls.add_method('GetEifsNoDifs', 'ns3::Time', [], is_const=True, is_virtual=True) + ## nqap-wifi-mac.h: void ns3::NqapWifiMac::SetWifiPhy(ns3::Ptr phy) [member function] + cls.add_method('SetWifiPhy', 'void', [param('ns3::Ptr< ns3::WifiPhy >', 'phy')], is_virtual=True) + ## nqap-wifi-mac.h: void ns3::NqapWifiMac::SetWifiRemoteStationManager(ns3::Ptr stationManager) [member function] + cls.add_method('SetWifiRemoteStationManager', 'void', [param('ns3::Ptr< ns3::WifiRemoteStationManager >', 'stationManager')], is_virtual=True) + ## nqap-wifi-mac.h: void ns3::NqapWifiMac::Enqueue(ns3::Ptr packet, ns3::Mac48Address to) [member function] + cls.add_method('Enqueue', 'void', [param('ns3::Ptr< const ns3::Packet >', 'packet'), param('ns3::Mac48Address', 'to')], is_virtual=True) + ## nqap-wifi-mac.h: void ns3::NqapWifiMac::SetForwardUpCallback(ns3::Callback, ns3::Mac48Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty> upCallback) [member function] + cls.add_method('SetForwardUpCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::Mac48Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'upCallback')], is_virtual=True) + ## nqap-wifi-mac.h: void ns3::NqapWifiMac::SetLinkUpCallback(ns3::Callback linkUp) [member function] + cls.add_method('SetLinkUpCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'linkUp')], is_virtual=True) + ## nqap-wifi-mac.h: void ns3::NqapWifiMac::SetLinkDownCallback(ns3::Callback linkDown) [member function] + cls.add_method('SetLinkDownCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'linkDown')], is_virtual=True) + ## nqap-wifi-mac.h: ns3::Mac48Address ns3::NqapWifiMac::GetAddress() const [member function] + cls.add_method('GetAddress', 'ns3::Mac48Address', [], is_const=True, is_virtual=True) + ## nqap-wifi-mac.h: ns3::Ssid ns3::NqapWifiMac::GetSsid() const [member function] + cls.add_method('GetSsid', 'ns3::Ssid', [], is_const=True, is_virtual=True) + ## nqap-wifi-mac.h: ns3::Mac48Address ns3::NqapWifiMac::GetBssid() const [member function] + cls.add_method('GetBssid', 'ns3::Mac48Address', [], is_const=True, is_virtual=True) + ## nqap-wifi-mac.h: void ns3::NqapWifiMac::SetAddress(ns3::Mac48Address address) [member function] + cls.add_method('SetAddress', 'void', [param('ns3::Mac48Address', 'address')], is_virtual=True) + ## nqap-wifi-mac.h: void ns3::NqapWifiMac::SetSsid(ns3::Ssid ssid) [member function] + cls.add_method('SetSsid', 'void', [param('ns3::Ssid', 'ssid')], is_virtual=True) + ## nqap-wifi-mac.h: void ns3::NqapWifiMac::SetBeaconInterval(ns3::Time interval) [member function] + cls.add_method('SetBeaconInterval', 'void', [param('ns3::Time', 'interval')]) + ## nqap-wifi-mac.h: void ns3::NqapWifiMac::StartBeaconing() [member function] + cls.add_method('StartBeaconing', 'void', []) + ## nqap-wifi-mac.h: void ns3::NqapWifiMac::DoDispose() [member function] + cls.add_method('DoDispose', 'void', [], visibility='private', is_virtual=True) + return + +def register_Ns3AmrrWifiRemoteStation_methods(root_module, cls): + ## amrr-wifi-manager.h: ns3::AmrrWifiRemoteStation::AmrrWifiRemoteStation(ns3::Ptr stations) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::AmrrWifiManager >', 'stations')], visibility='public') + ## amrr-wifi-manager.h: void ns3::AmrrWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function] + cls.add_method('DoReportRxOk', 'void', [param('double', 'rxSnr'), param('ns3::WifiMode', 'txMode')], visibility='protected', is_virtual=True) + ## amrr-wifi-manager.h: void ns3::AmrrWifiRemoteStation::DoReportRtsFailed() [member function] + cls.add_method('DoReportRtsFailed', 'void', [], visibility='protected', is_virtual=True) + ## amrr-wifi-manager.h: void ns3::AmrrWifiRemoteStation::DoReportDataFailed() [member function] + cls.add_method('DoReportDataFailed', 'void', [], visibility='protected', is_virtual=True) + ## amrr-wifi-manager.h: void ns3::AmrrWifiRemoteStation::DoReportRtsOk(double ctsSnr, ns3::WifiMode ctsMode, double rtsSnr) [member function] + cls.add_method('DoReportRtsOk', 'void', [param('double', 'ctsSnr'), param('ns3::WifiMode', 'ctsMode'), param('double', 'rtsSnr')], visibility='protected', is_virtual=True) + ## amrr-wifi-manager.h: void ns3::AmrrWifiRemoteStation::DoReportDataOk(double ackSnr, ns3::WifiMode ackMode, double dataSnr) [member function] + cls.add_method('DoReportDataOk', 'void', [param('double', 'ackSnr'), param('ns3::WifiMode', 'ackMode'), param('double', 'dataSnr')], visibility='protected', is_virtual=True) + ## amrr-wifi-manager.h: void ns3::AmrrWifiRemoteStation::DoReportFinalRtsFailed() [member function] + cls.add_method('DoReportFinalRtsFailed', 'void', [], visibility='protected', is_virtual=True) + ## amrr-wifi-manager.h: void ns3::AmrrWifiRemoteStation::DoReportFinalDataFailed() [member function] + cls.add_method('DoReportFinalDataFailed', 'void', [], visibility='protected', is_virtual=True) + ## amrr-wifi-manager.h: ns3::Ptr ns3::AmrrWifiRemoteStation::GetManager() const [member function] + cls.add_method('GetManager', 'ns3::Ptr< ns3::WifiRemoteStationManager >', [], is_const=True, visibility='private', is_virtual=True) + ## amrr-wifi-manager.h: ns3::WifiMode ns3::AmrrWifiRemoteStation::DoGetDataMode(uint32_t size) [member function] + cls.add_method('DoGetDataMode', 'ns3::WifiMode', [param('uint32_t', 'size')], visibility='private', is_virtual=True) + ## amrr-wifi-manager.h: ns3::WifiMode ns3::AmrrWifiRemoteStation::DoGetRtsMode() [member function] + cls.add_method('DoGetRtsMode', 'ns3::WifiMode', [], visibility='private', is_virtual=True) + return + +def register_Ns3CompositePropagationLossModel_methods(root_module, cls): + ## composite-propagation-loss-model.h: static ns3::TypeId ns3::CompositePropagationLossModel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## composite-propagation-loss-model.h: ns3::CompositePropagationLossModel::CompositePropagationLossModel() [constructor] + cls.add_constructor([], visibility='public') + ## composite-propagation-loss-model.h: double ns3::CompositePropagationLossModel::GetLoss(ns3::Ptr a, ns3::Ptr b) const [member function] + cls.add_method('GetLoss', 'double', [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], is_const=True, is_virtual=True) + ## composite-propagation-loss-model.h: void ns3::CompositePropagationLossModel::AddPropagationLossModel(ns3::Ptr pl) [member function] + cls.add_method('AddPropagationLossModel', 'void', [param('ns3::Ptr< ns3::PropagationLossModel >', 'pl')]) + ## composite-propagation-loss-model.h: void ns3::CompositePropagationLossModel::AddDefaults() [member function] + cls.add_method('AddDefaults', 'void', [], visibility='protected', is_virtual=True) + return + +def register_Ns3FriisPropagationLossModel_methods(root_module, cls): + ## propagation-loss-model.h: static ns3::TypeId ns3::FriisPropagationLossModel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## propagation-loss-model.h: ns3::FriisPropagationLossModel::FriisPropagationLossModel() [constructor] + cls.add_constructor([], visibility='public') + ## propagation-loss-model.h: void ns3::FriisPropagationLossModel::SetLambda(double frequency, double speed) [member function] + cls.add_method('SetLambda', 'void', [param('double', 'frequency'), param('double', 'speed')]) + ## propagation-loss-model.h: void ns3::FriisPropagationLossModel::SetLambda(double lambda) [member function] + cls.add_method('SetLambda', 'void', [param('double', 'lambda')]) + ## propagation-loss-model.h: void ns3::FriisPropagationLossModel::SetSystemLoss(double systemLoss) [member function] + cls.add_method('SetSystemLoss', 'void', [param('double', 'systemLoss')]) + ## propagation-loss-model.h: double ns3::FriisPropagationLossModel::GetLambda() const [member function] + cls.add_method('GetLambda', 'double', [], is_const=True) + ## propagation-loss-model.h: double ns3::FriisPropagationLossModel::GetSystemLoss() const [member function] + cls.add_method('GetSystemLoss', 'double', [], is_const=True) + ## propagation-loss-model.h: double ns3::FriisPropagationLossModel::GetLoss(ns3::Ptr a, ns3::Ptr b) const [member function] + cls.add_method('GetLoss', 'double', [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], is_const=True, is_virtual=True) + return + +def register_Ns3WifiRemoteStationManager_methods(root_module, cls): + ## wifi-remote-station-manager.h: static ns3::TypeId ns3::WifiRemoteStationManager::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## wifi-remote-station-manager.h: ns3::WifiRemoteStationManager::WifiRemoteStationManager() [constructor] + cls.add_constructor([], visibility='public') + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStationManager::SetupPhy(ns3::Ptr phy) [member function] + cls.add_method('SetupPhy', 'void', [param('ns3::Ptr< ns3::WifiPhy >', 'phy')], is_virtual=True) + ## wifi-remote-station-manager.h: uint32_t ns3::WifiRemoteStationManager::GetMaxSsrc() const [member function] + cls.add_method('GetMaxSsrc', 'uint32_t', [], is_const=True) + ## wifi-remote-station-manager.h: uint32_t ns3::WifiRemoteStationManager::GetMaxSlrc() const [member function] + cls.add_method('GetMaxSlrc', 'uint32_t', [], is_const=True) + ## wifi-remote-station-manager.h: uint32_t ns3::WifiRemoteStationManager::GetRtsCtsThreshold() const [member function] + cls.add_method('GetRtsCtsThreshold', 'uint32_t', [], is_const=True) + ## wifi-remote-station-manager.h: uint32_t ns3::WifiRemoteStationManager::GetFragmentationThreshold() const [member function] + cls.add_method('GetFragmentationThreshold', 'uint32_t', [], is_const=True) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStationManager::SetMaxSsrc(uint32_t maxSsrc) [member function] + cls.add_method('SetMaxSsrc', 'void', [param('uint32_t', 'maxSsrc')]) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStationManager::SetMaxSlrc(uint32_t maxSlrc) [member function] + cls.add_method('SetMaxSlrc', 'void', [param('uint32_t', 'maxSlrc')]) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStationManager::SetRtsCtsThreshold(uint32_t threshold) [member function] + cls.add_method('SetRtsCtsThreshold', 'void', [param('uint32_t', 'threshold')]) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStationManager::SetFragmentationThreshold(uint32_t threshold) [member function] + cls.add_method('SetFragmentationThreshold', 'void', [param('uint32_t', 'threshold')]) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStationManager::Reset() [member function] + cls.add_method('Reset', 'void', []) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStationManager::AddBasicMode(ns3::WifiMode mode) [member function] + cls.add_method('AddBasicMode', 'void', [param('ns3::WifiMode', 'mode')]) + ## wifi-remote-station-manager.h: ns3::WifiMode ns3::WifiRemoteStationManager::GetDefaultMode() const [member function] + cls.add_method('GetDefaultMode', 'ns3::WifiMode', [], is_const=True) + ## wifi-remote-station-manager.h: uint32_t ns3::WifiRemoteStationManager::GetNBasicModes() const [member function] + cls.add_method('GetNBasicModes', 'uint32_t', [], is_const=True) + ## wifi-remote-station-manager.h: ns3::WifiMode ns3::WifiRemoteStationManager::GetBasicMode(uint32_t i) const [member function] + cls.add_method('GetBasicMode', 'ns3::WifiMode', [param('uint32_t', 'i')], is_const=True) + ## wifi-remote-station-manager.h: __gnu_cxx::__normal_iterator > > ns3::WifiRemoteStationManager::BeginBasicModes() const [member function] + cls.add_method('BeginBasicModes', '__gnu_cxx::__normal_iterator< const ns3::WifiMode*, std::vector< ns3::WifiMode, std::allocator< ns3::WifiMode > > >', [], is_const=True) + ## wifi-remote-station-manager.h: __gnu_cxx::__normal_iterator > > ns3::WifiRemoteStationManager::EndBasicModes() const [member function] + cls.add_method('EndBasicModes', '__gnu_cxx::__normal_iterator< const ns3::WifiMode*, std::vector< ns3::WifiMode, std::allocator< ns3::WifiMode > > >', [], is_const=True) + ## wifi-remote-station-manager.h: bool ns3::WifiRemoteStationManager::IsLowLatency() const [member function] + cls.add_method('IsLowLatency', 'bool', [], is_const=True) + ## wifi-remote-station-manager.h: ns3::WifiRemoteStation * ns3::WifiRemoteStationManager::Lookup(ns3::Mac48Address address) [member function] + cls.add_method('Lookup', 'ns3::WifiRemoteStation *', [param('ns3::Mac48Address', 'address')]) + ## wifi-remote-station-manager.h: ns3::WifiRemoteStation * ns3::WifiRemoteStationManager::LookupNonUnicast() [member function] + cls.add_method('LookupNonUnicast', 'ns3::WifiRemoteStation *', []) + ## wifi-remote-station-manager.h: void ns3::WifiRemoteStationManager::DoDispose() [member function] + cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True) + ## wifi-remote-station-manager.h: ns3::WifiRemoteStation * ns3::WifiRemoteStationManager::CreateStation() [member function] + cls.add_method('CreateStation', 'ns3::WifiRemoteStation *', [], is_pure_virtual=True, visibility='private', is_virtual=True) + return + +def register_Ns3WifiModeValue_methods(root_module, cls): + ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue() [constructor] + cls.add_constructor([], visibility='public') + ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue(ns3::WifiMode const & value) [constructor] + cls.add_constructor([param('ns3::WifiMode&', 'value', is_const=True)], visibility='public') + ## wifi-mode.h: void ns3::WifiModeValue::Set(ns3::WifiMode const & value) [member function] + cls.add_method('Set', 'void', [param('ns3::WifiMode&', 'value', is_const=True)]) + ## wifi-mode.h: ns3::WifiMode ns3::WifiModeValue::Get() const [member function] + cls.add_method('Get', 'ns3::WifiMode', [], is_const=True) + ## wifi-mode.h: ns3::Ptr ns3::WifiModeValue::Copy() const [member function] + cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) + ## wifi-mode.h: std::string ns3::WifiModeValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True) + ## wifi-mode.h: bool ns3::WifiModeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) + return + +def register_Ns3OnoeWifiManager_methods(root_module, cls): + ## onoe-wifi-manager.h: static ns3::TypeId ns3::OnoeWifiManager::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## onoe-wifi-manager.h: ns3::OnoeWifiManager::OnoeWifiManager() [constructor] + cls.add_constructor([], visibility='public') + ## onoe-wifi-manager.h: ns3::WifiRemoteStation * ns3::OnoeWifiManager::CreateStation() [member function] + cls.add_method('CreateStation', 'ns3::WifiRemoteStation *', [], visibility='private', is_virtual=True) + return + +def register_Ns3WifiPhy_methods(root_module, cls): + ## wifi-phy.h: static ns3::TypeId ns3::WifiPhy::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## wifi-phy.h: ns3::WifiPhy::WifiPhy() [constructor] + cls.add_constructor([], visibility='public') + ## wifi-phy.h: void ns3::WifiPhy::SetStandard(ns3::WifiPhyStandard standard) [member function] + cls.add_method('SetStandard', 'void', [param('ns3::WifiPhyStandard', 'standard')]) + ## wifi-phy.h: void ns3::WifiPhy::SetRxNoise(double ratio) [member function] + cls.add_method('SetRxNoise', 'void', [param('double', 'ratio')]) + ## wifi-phy.h: void ns3::WifiPhy::SetTxPowerStart(double start) [member function] + cls.add_method('SetTxPowerStart', 'void', [param('double', 'start')]) + ## wifi-phy.h: void ns3::WifiPhy::SetTxPowerEnd(double end) [member function] + cls.add_method('SetTxPowerEnd', 'void', [param('double', 'end')]) + ## wifi-phy.h: void ns3::WifiPhy::SetNTxPower(uint32_t n) [member function] + cls.add_method('SetNTxPower', 'void', [param('uint32_t', 'n')]) + ## wifi-phy.h: void ns3::WifiPhy::SetTxGain(double gain) [member function] + cls.add_method('SetTxGain', 'void', [param('double', 'gain')]) + ## wifi-phy.h: void ns3::WifiPhy::SetRxGain(double gain) [member function] + cls.add_method('SetRxGain', 'void', [param('double', 'gain')]) + ## wifi-phy.h: void ns3::WifiPhy::SetEdThreshold(double threshold) [member function] + cls.add_method('SetEdThreshold', 'void', [param('double', 'threshold')]) + ## wifi-phy.h: double ns3::WifiPhy::GetRxNoise() const [member function] + cls.add_method('GetRxNoise', 'double', [], is_const=True) + ## wifi-phy.h: double ns3::WifiPhy::GetTxPowerStart() const [member function] + cls.add_method('GetTxPowerStart', 'double', [], is_const=True) + ## wifi-phy.h: double ns3::WifiPhy::GetTxPowerEnd() const [member function] + cls.add_method('GetTxPowerEnd', 'double', [], is_const=True) + ## wifi-phy.h: uint32_t ns3::WifiPhy::GetNTxPower() const [member function] + cls.add_method('GetNTxPower', 'uint32_t', [], is_const=True) + ## wifi-phy.h: double ns3::WifiPhy::GetTxGain() const [member function] + cls.add_method('GetTxGain', 'double', [], is_const=True) + ## wifi-phy.h: double ns3::WifiPhy::GetRxGain() const [member function] + cls.add_method('GetRxGain', 'double', [], is_const=True) + ## wifi-phy.h: double ns3::WifiPhy::GetEdThreshold() const [member function] + cls.add_method('GetEdThreshold', 'double', [], is_const=True) + ## wifi-phy.h: void ns3::WifiPhy::SetChannel(ns3::Ptr channel) [member function] + cls.add_method('SetChannel', 'void', [param('ns3::Ptr< ns3::WifiChannel >', 'channel')]) + ## wifi-phy.h: void ns3::WifiPhy::SetReceiveOkCallback(ns3::Callback, double, ns3::WifiMode, ns3::WifiPreamble, ns3::empty, ns3::empty> callback) [member function] + cls.add_method('SetReceiveOkCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::WifiMode, ns3::WifiPreamble, ns3::empty, ns3::empty >', 'callback')]) + ## wifi-phy.h: void ns3::WifiPhy::SetReceiveErrorCallback(ns3::Callback, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function] + cls.add_method('SetReceiveErrorCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) + ## wifi-phy.h: void ns3::WifiPhy::SendPacket(ns3::Ptr packet, ns3::WifiMode mode, ns3::WifiPreamble preamble, uint8_t txPowerLevel) [member function] + cls.add_method('SendPacket', 'void', [param('ns3::Ptr< const ns3::Packet >', 'packet'), param('ns3::WifiMode', 'mode'), param('ns3::WifiPreamble', 'preamble'), param('uint8_t', 'txPowerLevel')]) + ## wifi-phy.h: void ns3::WifiPhy::RegisterListener(ns3::WifiPhyListener * listener) [member function] + cls.add_method('RegisterListener', 'void', [param('ns3::WifiPhyListener *', 'listener')]) + ## wifi-phy.h: bool ns3::WifiPhy::IsStateCcaBusy() [member function] + cls.add_method('IsStateCcaBusy', 'bool', []) + ## wifi-phy.h: bool ns3::WifiPhy::IsStateIdle() [member function] + cls.add_method('IsStateIdle', 'bool', []) + ## wifi-phy.h: bool ns3::WifiPhy::IsStateBusy() [member function] + cls.add_method('IsStateBusy', 'bool', []) + ## wifi-phy.h: bool ns3::WifiPhy::IsStateSync() [member function] + cls.add_method('IsStateSync', 'bool', []) + ## wifi-phy.h: bool ns3::WifiPhy::IsStateTx() [member function] + cls.add_method('IsStateTx', 'bool', []) + ## wifi-phy.h: ns3::Time ns3::WifiPhy::GetStateDuration() [member function] + cls.add_method('GetStateDuration', 'ns3::Time', []) + ## wifi-phy.h: ns3::Time ns3::WifiPhy::GetDelayUntilIdle() [member function] + cls.add_method('GetDelayUntilIdle', 'ns3::Time', []) + ## wifi-phy.h: ns3::Time ns3::WifiPhy::GetLastRxStartTime() const [member function] + cls.add_method('GetLastRxStartTime', 'ns3::Time', [], is_const=True) + ## wifi-phy.h: ns3::Time ns3::WifiPhy::CalculateTxDuration(uint32_t size, ns3::WifiMode payloadMode, ns3::WifiPreamble preamble) const [member function] + cls.add_method('CalculateTxDuration', 'ns3::Time', [param('uint32_t', 'size'), param('ns3::WifiMode', 'payloadMode'), param('ns3::WifiPreamble', 'preamble')], is_const=True) + ## wifi-phy.h: uint32_t ns3::WifiPhy::GetNModes() const [member function] + cls.add_method('GetNModes', 'uint32_t', [], is_const=True) + ## wifi-phy.h: ns3::WifiMode ns3::WifiPhy::GetMode(uint32_t mode) const [member function] + cls.add_method('GetMode', 'ns3::WifiMode', [param('uint32_t', 'mode')], is_const=True) + ## wifi-phy.h: double ns3::WifiPhy::CalculateSnr(ns3::WifiMode txMode, double ber) const [member function] + cls.add_method('CalculateSnr', 'double', [param('ns3::WifiMode', 'txMode'), param('double', 'ber')], is_const=True) + ## wifi-phy.h: void ns3::WifiPhy::StartReceivePacket(ns3::Ptr packet, double rxPowerDbm, ns3::WifiMode mode, ns3::WifiPreamble preamble) [member function] + cls.add_method('StartReceivePacket', 'void', [param('ns3::Ptr< ns3::Packet >', 'packet'), param('double', 'rxPowerDbm'), param('ns3::WifiMode', 'mode'), param('ns3::WifiPreamble', 'preamble')]) + ## wifi-phy.h: ns3::Ptr ns3::WifiPhy::GetChannel() const [member function] + cls.add_method('GetChannel', 'ns3::Ptr< ns3::WifiChannel >', [], is_const=True) + ## wifi-phy.h: void ns3::WifiPhy::DoDispose() [member function] + cls.add_method('DoDispose', 'void', [], visibility='private', is_virtual=True) + return + +def register_Ns3WifiChannel_methods(root_module, cls): + ## wifi-channel.h: static ns3::TypeId ns3::WifiChannel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## wifi-channel.h: ns3::WifiChannel::WifiChannel() [constructor] + cls.add_constructor([], visibility='public') + ## wifi-channel.h: uint32_t ns3::WifiChannel::GetNDevices() const [member function] + cls.add_method('GetNDevices', 'uint32_t', [], is_const=True, is_virtual=True) + ## wifi-channel.h: ns3::Ptr ns3::WifiChannel::GetDevice(uint32_t i) const [member function] + cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', [param('uint32_t', 'i')], is_const=True, is_virtual=True) + ## wifi-channel.h: void ns3::WifiChannel::SetPropagationLossModel(ns3::Ptr loss) [member function] + cls.add_method('SetPropagationLossModel', 'void', [param('ns3::Ptr< ns3::PropagationLossModel >', 'loss')]) + ## wifi-channel.h: void ns3::WifiChannel::SetPropagationDelayModel(ns3::Ptr delay) [member function] + cls.add_method('SetPropagationDelayModel', 'void', [param('ns3::Ptr< ns3::PropagationDelayModel >', 'delay')]) + ## wifi-channel.h: void ns3::WifiChannel::Add(ns3::Ptr device, ns3::Ptr phy) [member function] + cls.add_method('Add', 'void', [param('ns3::Ptr< ns3::NetDevice >', 'device'), param('ns3::Ptr< ns3::WifiPhy >', 'phy')]) + ## wifi-channel.h: void ns3::WifiChannel::Send(ns3::Ptr sender, ns3::Ptr packet, double txPowerDbm, ns3::WifiMode wifiMode, ns3::WifiPreamble preamble) const [member function] + cls.add_method('Send', 'void', [param('ns3::Ptr< ns3::WifiPhy >', 'sender'), param('ns3::Ptr< const ns3::Packet >', 'packet'), param('double', 'txPowerDbm'), param('ns3::WifiMode', 'wifiMode'), param('ns3::WifiPreamble', 'preamble')], is_const=True) + return + +def register_Ns3LogDistancePropagationLossModel_methods(root_module, cls): + ## propagation-loss-model.h: static ns3::TypeId ns3::LogDistancePropagationLossModel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## propagation-loss-model.h: ns3::LogDistancePropagationLossModel::LogDistancePropagationLossModel() [constructor] + cls.add_constructor([], visibility='public') + ## propagation-loss-model.h: void ns3::LogDistancePropagationLossModel::SetPathLossExponent(double n) [member function] + cls.add_method('SetPathLossExponent', 'void', [param('double', 'n')]) + ## propagation-loss-model.h: double ns3::LogDistancePropagationLossModel::GetPathLossExponent() const [member function] + cls.add_method('GetPathLossExponent', 'double', [], is_const=True) + ## propagation-loss-model.h: void ns3::LogDistancePropagationLossModel::SetReferenceModel(ns3::Ptr model) [member function] + cls.add_method('SetReferenceModel', 'void', [param('ns3::Ptr< ns3::PropagationLossModel >', 'model')]) + ## propagation-loss-model.h: void ns3::LogDistancePropagationLossModel::SetReferenceDistance(double referenceDistance) [member function] + cls.add_method('SetReferenceDistance', 'void', [param('double', 'referenceDistance')]) + ## propagation-loss-model.h: double ns3::LogDistancePropagationLossModel::GetLoss(ns3::Ptr a, ns3::Ptr b) const [member function] + cls.add_method('GetLoss', 'double', [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], is_const=True, is_virtual=True) + return + +def register_Ns3ConstantRateWifiManager_methods(root_module, cls): + ## constant-rate-wifi-manager.h: static ns3::TypeId ns3::ConstantRateWifiManager::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## constant-rate-wifi-manager.h: ns3::ConstantRateWifiManager::ConstantRateWifiManager() [constructor] + cls.add_constructor([], visibility='public') + ## constant-rate-wifi-manager.h: ns3::WifiMode ns3::ConstantRateWifiManager::GetDataMode() const [member function] + cls.add_method('GetDataMode', 'ns3::WifiMode', [], is_const=True) + ## constant-rate-wifi-manager.h: ns3::WifiMode ns3::ConstantRateWifiManager::GetCtlMode() const [member function] + cls.add_method('GetCtlMode', 'ns3::WifiMode', [], is_const=True) + ## constant-rate-wifi-manager.h: ns3::WifiRemoteStation * ns3::ConstantRateWifiManager::CreateStation() [member function] + cls.add_method('CreateStation', 'ns3::WifiRemoteStation *', [], visibility='private', is_virtual=True) + return + +def register_Ns3AarfWifiRemoteStation_methods(root_module, cls): + ## aarf-wifi-manager.h: ns3::AarfWifiRemoteStation::AarfWifiRemoteStation(ns3::Ptr stations, uint32_t minTimerThreshold, uint32_t minSuccessThreshold, double successK, uint32_t maxSuccessThreshold, double timerK) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::AarfWifiManager >', 'stations'), param('uint32_t', 'minTimerThreshold'), param('uint32_t', 'minSuccessThreshold'), param('double', 'successK'), param('uint32_t', 'maxSuccessThreshold'), param('double', 'timerK')], visibility='public') + ## aarf-wifi-manager.h: void ns3::AarfWifiRemoteStation::ReportRecoveryFailure() [member function] + cls.add_method('ReportRecoveryFailure', 'void', [], visibility='private', is_virtual=True) + ## aarf-wifi-manager.h: void ns3::AarfWifiRemoteStation::ReportFailure() [member function] + cls.add_method('ReportFailure', 'void', [], visibility='private', is_virtual=True) + return + +def register_Ns3PropagationDelayModel_methods(root_module, cls): + ## propagation-delay-model.h: static ns3::TypeId ns3::PropagationDelayModel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## propagation-delay-model.h: ns3::Time ns3::PropagationDelayModel::GetDelay(ns3::Ptr a, ns3::Ptr b) const [member function] + cls.add_method('GetDelay', 'ns3::Time', [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], is_pure_virtual=True, is_const=True, is_virtual=True) + cls.add_constructor([]) + return + +def register_Ns3AdhocWifiMac_methods(root_module, cls): + ## adhoc-wifi-mac.h: static ns3::TypeId ns3::AdhocWifiMac::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## adhoc-wifi-mac.h: ns3::AdhocWifiMac::AdhocWifiMac() [constructor] + cls.add_constructor([], visibility='public') + ## adhoc-wifi-mac.h: void ns3::AdhocWifiMac::SetSlot(ns3::Time slotTime) [member function] + cls.add_method('SetSlot', 'void', [param('ns3::Time', 'slotTime')], is_virtual=True) + ## adhoc-wifi-mac.h: void ns3::AdhocWifiMac::SetSifs(ns3::Time sifs) [member function] + cls.add_method('SetSifs', 'void', [param('ns3::Time', 'sifs')], is_virtual=True) + ## adhoc-wifi-mac.h: void ns3::AdhocWifiMac::SetEifsNoDifs(ns3::Time eifsNoDifs) [member function] + cls.add_method('SetEifsNoDifs', 'void', [param('ns3::Time', 'eifsNoDifs')], is_virtual=True) + ## adhoc-wifi-mac.h: ns3::Time ns3::AdhocWifiMac::GetSlot() const [member function] + cls.add_method('GetSlot', 'ns3::Time', [], is_const=True, is_virtual=True) + ## adhoc-wifi-mac.h: ns3::Time ns3::AdhocWifiMac::GetSifs() const [member function] + cls.add_method('GetSifs', 'ns3::Time', [], is_const=True, is_virtual=True) + ## adhoc-wifi-mac.h: ns3::Time ns3::AdhocWifiMac::GetEifsNoDifs() const [member function] + cls.add_method('GetEifsNoDifs', 'ns3::Time', [], is_const=True, is_virtual=True) + ## adhoc-wifi-mac.h: void ns3::AdhocWifiMac::SetWifiPhy(ns3::Ptr phy) [member function] + cls.add_method('SetWifiPhy', 'void', [param('ns3::Ptr< ns3::WifiPhy >', 'phy')], is_virtual=True) + ## adhoc-wifi-mac.h: void ns3::AdhocWifiMac::SetWifiRemoteStationManager(ns3::Ptr stationManager) [member function] + cls.add_method('SetWifiRemoteStationManager', 'void', [param('ns3::Ptr< ns3::WifiRemoteStationManager >', 'stationManager')], is_virtual=True) + ## adhoc-wifi-mac.h: void ns3::AdhocWifiMac::Enqueue(ns3::Ptr packet, ns3::Mac48Address to) [member function] + cls.add_method('Enqueue', 'void', [param('ns3::Ptr< const ns3::Packet >', 'packet'), param('ns3::Mac48Address', 'to')], is_virtual=True) + ## adhoc-wifi-mac.h: void ns3::AdhocWifiMac::SetForwardUpCallback(ns3::Callback, ns3::Mac48Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty> upCallback) [member function] + cls.add_method('SetForwardUpCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::Mac48Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'upCallback')], is_virtual=True) + ## adhoc-wifi-mac.h: void ns3::AdhocWifiMac::SetLinkUpCallback(ns3::Callback linkUp) [member function] + cls.add_method('SetLinkUpCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'linkUp')], is_virtual=True) + ## adhoc-wifi-mac.h: void ns3::AdhocWifiMac::SetLinkDownCallback(ns3::Callback linkDown) [member function] + cls.add_method('SetLinkDownCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'linkDown')], is_virtual=True) + ## adhoc-wifi-mac.h: ns3::Mac48Address ns3::AdhocWifiMac::GetAddress() const [member function] + cls.add_method('GetAddress', 'ns3::Mac48Address', [], is_const=True, is_virtual=True) + ## adhoc-wifi-mac.h: ns3::Ssid ns3::AdhocWifiMac::GetSsid() const [member function] + cls.add_method('GetSsid', 'ns3::Ssid', [], is_const=True, is_virtual=True) + ## adhoc-wifi-mac.h: ns3::Mac48Address ns3::AdhocWifiMac::GetBssid() const [member function] + cls.add_method('GetBssid', 'ns3::Mac48Address', [], is_const=True, is_virtual=True) + ## adhoc-wifi-mac.h: void ns3::AdhocWifiMac::SetAddress(ns3::Mac48Address address) [member function] + cls.add_method('SetAddress', 'void', [param('ns3::Mac48Address', 'address')], is_virtual=True) + ## adhoc-wifi-mac.h: void ns3::AdhocWifiMac::SetSsid(ns3::Ssid ssid) [member function] + cls.add_method('SetSsid', 'void', [param('ns3::Ssid', 'ssid')], is_virtual=True) + ## adhoc-wifi-mac.h: void ns3::AdhocWifiMac::DoDispose() [member function] + cls.add_method('DoDispose', 'void', [], visibility='private', is_virtual=True) + return + +def register_Ns3JakesPropagationLossModel_methods(root_module, cls): + ## jakes-propagation-loss-model.h: static ns3::TypeId ns3::JakesPropagationLossModel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## jakes-propagation-loss-model.h: ns3::JakesPropagationLossModel::JakesPropagationLossModel() [constructor] + cls.add_constructor([], visibility='public') + ## jakes-propagation-loss-model.h: double ns3::JakesPropagationLossModel::GetLoss(ns3::Ptr a, ns3::Ptr b) const [member function] + cls.add_method('GetLoss', 'double', [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], is_const=True, is_virtual=True) + ## jakes-propagation-loss-model.h: void ns3::JakesPropagationLossModel::SetNRays(uint8_t nRays) [member function] + cls.add_method('SetNRays', 'void', [param('uint8_t', 'nRays')]) + ## jakes-propagation-loss-model.h: void ns3::JakesPropagationLossModel::SetNOscillators(uint8_t nOscillators) [member function] + cls.add_method('SetNOscillators', 'void', [param('uint8_t', 'nOscillators')]) + return + +def register_Ns3ConstantSpeedPropagationDelayModel_methods(root_module, cls): + ## propagation-delay-model.h: static ns3::TypeId ns3::ConstantSpeedPropagationDelayModel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## propagation-delay-model.h: ns3::ConstantSpeedPropagationDelayModel::ConstantSpeedPropagationDelayModel() [constructor] + cls.add_constructor([], visibility='public') + ## propagation-delay-model.h: ns3::Time ns3::ConstantSpeedPropagationDelayModel::GetDelay(ns3::Ptr a, ns3::Ptr b) const [member function] + cls.add_method('GetDelay', 'ns3::Time', [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], is_const=True, is_virtual=True) + ## propagation-delay-model.h: void ns3::ConstantSpeedPropagationDelayModel::SetSpeed(double speed) [member function] + cls.add_method('SetSpeed', 'void', [param('double', 'speed')]) + ## propagation-delay-model.h: double ns3::ConstantSpeedPropagationDelayModel::GetSpeed() const [member function] + cls.add_method('GetSpeed', 'double', [], is_const=True) + return + +def register_Ns3WifiNetDevice_methods(root_module, cls): + ## wifi-net-device.h: static ns3::TypeId ns3::WifiNetDevice::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## wifi-net-device.h: ns3::WifiNetDevice::WifiNetDevice() [constructor] + cls.add_constructor([], visibility='public') + ## wifi-net-device.h: void ns3::WifiNetDevice::SetMac(ns3::Ptr mac) [member function] + cls.add_method('SetMac', 'void', [param('ns3::Ptr< ns3::WifiMac >', 'mac')]) + ## wifi-net-device.h: void ns3::WifiNetDevice::SetPhy(ns3::Ptr phy) [member function] + cls.add_method('SetPhy', 'void', [param('ns3::Ptr< ns3::WifiPhy >', 'phy')]) + ## wifi-net-device.h: void ns3::WifiNetDevice::SetRemoteStationManager(ns3::Ptr manager) [member function] + cls.add_method('SetRemoteStationManager', 'void', [param('ns3::Ptr< ns3::WifiRemoteStationManager >', 'manager')]) + ## wifi-net-device.h: void ns3::WifiNetDevice::SetChannel(ns3::Ptr channel) [member function] + cls.add_method('SetChannel', 'void', [param('ns3::Ptr< ns3::WifiChannel >', 'channel')]) + ## wifi-net-device.h: ns3::Ptr ns3::WifiNetDevice::GetMac() const [member function] + cls.add_method('GetMac', 'ns3::Ptr< ns3::WifiMac >', [], is_const=True) + ## wifi-net-device.h: ns3::Ptr ns3::WifiNetDevice::GetPhy() const [member function] + cls.add_method('GetPhy', 'ns3::Ptr< ns3::WifiPhy >', [], is_const=True) + ## wifi-net-device.h: ns3::Ptr ns3::WifiNetDevice::GetRemoteStationManager() const [member function] + cls.add_method('GetRemoteStationManager', 'ns3::Ptr< ns3::WifiRemoteStationManager >', [], is_const=True) + ## wifi-net-device.h: void ns3::WifiNetDevice::SetName(std::string const name) [member function] + cls.add_method('SetName', 'void', [param('std::string', 'name', is_const=True)], is_virtual=True) + ## wifi-net-device.h: std::string ns3::WifiNetDevice::GetName() const [member function] + cls.add_method('GetName', 'std::string', [], is_const=True, is_virtual=True) + ## wifi-net-device.h: void ns3::WifiNetDevice::SetIfIndex(uint32_t const index) [member function] + cls.add_method('SetIfIndex', 'void', [param('uint32_t', 'index', is_const=True)], is_virtual=True) + ## wifi-net-device.h: uint32_t ns3::WifiNetDevice::GetIfIndex() const [member function] + cls.add_method('GetIfIndex', 'uint32_t', [], is_const=True, is_virtual=True) + ## wifi-net-device.h: ns3::Ptr ns3::WifiNetDevice::GetChannel() const [member function] + cls.add_method('GetChannel', 'ns3::Ptr< ns3::Channel >', [], is_const=True, is_virtual=True) + ## wifi-net-device.h: ns3::Address ns3::WifiNetDevice::GetAddress() const [member function] + cls.add_method('GetAddress', 'ns3::Address', [], is_const=True, is_virtual=True) + ## wifi-net-device.h: bool ns3::WifiNetDevice::SetMtu(uint16_t const mtu) [member function] + cls.add_method('SetMtu', 'bool', [param('uint16_t', 'mtu', is_const=True)], is_virtual=True) + ## wifi-net-device.h: uint16_t ns3::WifiNetDevice::GetMtu() const [member function] + cls.add_method('GetMtu', 'uint16_t', [], is_const=True, is_virtual=True) + ## wifi-net-device.h: bool ns3::WifiNetDevice::IsLinkUp() const [member function] + cls.add_method('IsLinkUp', 'bool', [], is_const=True, is_virtual=True) + ## wifi-net-device.h: void ns3::WifiNetDevice::SetLinkChangeCallback(ns3::Callback callback) [member function] + 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) + ## wifi-net-device.h: bool ns3::WifiNetDevice::IsBroadcast() const [member function] + cls.add_method('IsBroadcast', 'bool', [], is_const=True, is_virtual=True) + ## wifi-net-device.h: ns3::Address ns3::WifiNetDevice::GetBroadcast() const [member function] + cls.add_method('GetBroadcast', 'ns3::Address', [], is_const=True, is_virtual=True) + ## wifi-net-device.h: bool ns3::WifiNetDevice::IsMulticast() const [member function] + cls.add_method('IsMulticast', 'bool', [], is_const=True, is_virtual=True) + ## wifi-net-device.h: ns3::Address ns3::WifiNetDevice::GetMulticast() const [member function] + cls.add_method('GetMulticast', 'ns3::Address', [], is_const=True, is_virtual=True) + ## wifi-net-device.h: ns3::Address ns3::WifiNetDevice::MakeMulticastAddress(ns3::Ipv4Address multicastGroup) const [member function] + cls.add_method('MakeMulticastAddress', 'ns3::Address', [param('ns3::Ipv4Address', 'multicastGroup')], is_const=True, is_virtual=True) + ## wifi-net-device.h: bool ns3::WifiNetDevice::IsPointToPoint() const [member function] + cls.add_method('IsPointToPoint', 'bool', [], is_const=True, is_virtual=True) + ## wifi-net-device.h: bool ns3::WifiNetDevice::Send(ns3::Ptr packet, ns3::Address const & dest, uint16_t protocolNumber) [member function] + 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) + ## wifi-net-device.h: ns3::Ptr ns3::WifiNetDevice::GetNode() const [member function] + cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [], is_const=True, is_virtual=True) + ## wifi-net-device.h: void ns3::WifiNetDevice::SetNode(ns3::Ptr node) [member function] + cls.add_method('SetNode', 'void', [param('ns3::Ptr< ns3::Node >', 'node')], is_virtual=True) + ## wifi-net-device.h: bool ns3::WifiNetDevice::NeedsArp() const [member function] + cls.add_method('NeedsArp', 'bool', [], is_const=True, is_virtual=True) + ## wifi-net-device.h: void ns3::WifiNetDevice::SetReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function] + 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) + ## wifi-net-device.h: void ns3::WifiNetDevice::DoDispose() [member function] + cls.add_method('DoDispose', 'void', [], visibility='private', is_virtual=True) + return + +def register_Ns3NqstaWifiMac_methods(root_module, cls): + ## nqsta-wifi-mac.h: static ns3::TypeId ns3::NqstaWifiMac::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## nqsta-wifi-mac.h: ns3::NqstaWifiMac::NqstaWifiMac() [constructor] + cls.add_constructor([], visibility='public') + ## nqsta-wifi-mac.h: void ns3::NqstaWifiMac::SetSlot(ns3::Time slotTime) [member function] + cls.add_method('SetSlot', 'void', [param('ns3::Time', 'slotTime')], is_virtual=True) + ## nqsta-wifi-mac.h: void ns3::NqstaWifiMac::SetSifs(ns3::Time sifs) [member function] + cls.add_method('SetSifs', 'void', [param('ns3::Time', 'sifs')], is_virtual=True) + ## nqsta-wifi-mac.h: void ns3::NqstaWifiMac::SetEifsNoDifs(ns3::Time eifsNoDifs) [member function] + cls.add_method('SetEifsNoDifs', 'void', [param('ns3::Time', 'eifsNoDifs')], is_virtual=True) + ## nqsta-wifi-mac.h: ns3::Time ns3::NqstaWifiMac::GetSlot() const [member function] + cls.add_method('GetSlot', 'ns3::Time', [], is_const=True, is_virtual=True) + ## nqsta-wifi-mac.h: ns3::Time ns3::NqstaWifiMac::GetSifs() const [member function] + cls.add_method('GetSifs', 'ns3::Time', [], is_const=True, is_virtual=True) + ## nqsta-wifi-mac.h: ns3::Time ns3::NqstaWifiMac::GetEifsNoDifs() const [member function] + cls.add_method('GetEifsNoDifs', 'ns3::Time', [], is_const=True, is_virtual=True) + ## nqsta-wifi-mac.h: void ns3::NqstaWifiMac::SetWifiPhy(ns3::Ptr phy) [member function] + cls.add_method('SetWifiPhy', 'void', [param('ns3::Ptr< ns3::WifiPhy >', 'phy')], is_virtual=True) + ## nqsta-wifi-mac.h: void ns3::NqstaWifiMac::SetWifiRemoteStationManager(ns3::Ptr stationManager) [member function] + cls.add_method('SetWifiRemoteStationManager', 'void', [param('ns3::Ptr< ns3::WifiRemoteStationManager >', 'stationManager')], is_virtual=True) + ## nqsta-wifi-mac.h: void ns3::NqstaWifiMac::Enqueue(ns3::Ptr packet, ns3::Mac48Address to) [member function] + cls.add_method('Enqueue', 'void', [param('ns3::Ptr< const ns3::Packet >', 'packet'), param('ns3::Mac48Address', 'to')], is_virtual=True) + ## nqsta-wifi-mac.h: void ns3::NqstaWifiMac::SetForwardUpCallback(ns3::Callback, ns3::Mac48Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty> upCallback) [member function] + cls.add_method('SetForwardUpCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::Mac48Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'upCallback')], is_virtual=True) + ## nqsta-wifi-mac.h: void ns3::NqstaWifiMac::SetLinkUpCallback(ns3::Callback linkUp) [member function] + cls.add_method('SetLinkUpCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'linkUp')], is_virtual=True) + ## nqsta-wifi-mac.h: void ns3::NqstaWifiMac::SetLinkDownCallback(ns3::Callback linkDown) [member function] + cls.add_method('SetLinkDownCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'linkDown')], is_virtual=True) + ## nqsta-wifi-mac.h: ns3::Mac48Address ns3::NqstaWifiMac::GetAddress() const [member function] + cls.add_method('GetAddress', 'ns3::Mac48Address', [], is_const=True, is_virtual=True) + ## nqsta-wifi-mac.h: ns3::Ssid ns3::NqstaWifiMac::GetSsid() const [member function] + cls.add_method('GetSsid', 'ns3::Ssid', [], is_const=True, is_virtual=True) + ## nqsta-wifi-mac.h: ns3::Mac48Address ns3::NqstaWifiMac::GetBssid() const [member function] + cls.add_method('GetBssid', 'ns3::Mac48Address', [], is_const=True, is_virtual=True) + ## nqsta-wifi-mac.h: void ns3::NqstaWifiMac::SetAddress(ns3::Mac48Address address) [member function] + cls.add_method('SetAddress', 'void', [param('ns3::Mac48Address', 'address')], is_virtual=True) + ## nqsta-wifi-mac.h: void ns3::NqstaWifiMac::SetSsid(ns3::Ssid ssid) [member function] + cls.add_method('SetSsid', 'void', [param('ns3::Ssid', 'ssid')], is_virtual=True) + ## nqsta-wifi-mac.h: void ns3::NqstaWifiMac::SetMaxMissedBeacons(uint32_t missed) [member function] + cls.add_method('SetMaxMissedBeacons', 'void', [param('uint32_t', 'missed')]) + ## nqsta-wifi-mac.h: void ns3::NqstaWifiMac::SetProbeRequestTimeout(ns3::Time timeout) [member function] + cls.add_method('SetProbeRequestTimeout', 'void', [param('ns3::Time', 'timeout')]) + ## nqsta-wifi-mac.h: void ns3::NqstaWifiMac::SetAssocRequestTimeout(ns3::Time timeout) [member function] + cls.add_method('SetAssocRequestTimeout', 'void', [param('ns3::Time', 'timeout')]) + ## nqsta-wifi-mac.h: void ns3::NqstaWifiMac::StartActiveAssociation() [member function] + cls.add_method('StartActiveAssociation', 'void', []) + ## nqsta-wifi-mac.h: void ns3::NqstaWifiMac::DoDispose() [member function] + cls.add_method('DoDispose', 'void', [], visibility='private', is_virtual=True) + return + +def register_Ns3RandomPropagationLossModel_methods(root_module, cls): + ## propagation-loss-model.h: static ns3::TypeId ns3::RandomPropagationLossModel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## propagation-loss-model.h: ns3::RandomPropagationLossModel::RandomPropagationLossModel() [constructor] + cls.add_constructor([], visibility='public') + ## propagation-loss-model.h: double ns3::RandomPropagationLossModel::GetLoss(ns3::Ptr a, ns3::Ptr b) const [member function] + cls.add_method('GetLoss', 'double', [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], is_const=True, is_virtual=True) + return + +def register_Ns3RandomPropagationDelayModel_methods(root_module, cls): + ## propagation-delay-model.h: static ns3::TypeId ns3::RandomPropagationDelayModel::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## propagation-delay-model.h: ns3::RandomPropagationDelayModel::RandomPropagationDelayModel() [constructor] + cls.add_constructor([], visibility='public') + ## propagation-delay-model.h: ns3::Time ns3::RandomPropagationDelayModel::GetDelay(ns3::Ptr a, ns3::Ptr b) const [member function] + cls.add_method('GetDelay', 'ns3::Time', [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], is_const=True, is_virtual=True) + return + +def register_Ns3AmrrWifiManager_methods(root_module, cls): + ## amrr-wifi-manager.h: static ns3::TypeId ns3::AmrrWifiManager::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## amrr-wifi-manager.h: ns3::AmrrWifiManager::AmrrWifiManager() [constructor] + cls.add_constructor([], visibility='public') + ## amrr-wifi-manager.h: ns3::WifiRemoteStation * ns3::AmrrWifiManager::CreateStation() [member function] + cls.add_method('CreateStation', 'ns3::WifiRemoteStation *', [], visibility='private', is_virtual=True) + return + +def register_Ns3RraaWifiManager_methods(root_module, cls): + ## rraa-wifi-manager.h: static ns3::TypeId ns3::RraaWifiManager::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## rraa-wifi-manager.h: ns3::RraaWifiManager::RraaWifiManager() [constructor] + cls.add_constructor([], visibility='public') + ## rraa-wifi-manager.h: bool ns3::RraaWifiManager::OnlyBasic() [member function] + cls.add_method('OnlyBasic', 'bool', []) + ## rraa-wifi-manager.h: ns3::Time ns3::RraaWifiManager::GetTimeout() const [member function] + cls.add_method('GetTimeout', 'ns3::Time', [], is_const=True) + ## rraa-wifi-manager.h: ns3::ThresholdsItem ns3::RraaWifiManager::GetThresholds(ns3::WifiMode mode) const [member function] + cls.add_method('GetThresholds', 'ns3::ThresholdsItem', [param('ns3::WifiMode', 'mode')], is_const=True) + ## rraa-wifi-manager.h: ns3::WifiRemoteStation * ns3::RraaWifiManager::CreateStation() [member function] + cls.add_method('CreateStation', 'ns3::WifiRemoteStation *', [], visibility='private', is_virtual=True) + return + +def register_Ns3IdealWifiManager_methods(root_module, cls): + ## ideal-wifi-manager.h: static ns3::TypeId ns3::IdealWifiManager::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## ideal-wifi-manager.h: ns3::IdealWifiManager::IdealWifiManager() [constructor] + cls.add_constructor([], visibility='public') + ## ideal-wifi-manager.h: void ns3::IdealWifiManager::SetupPhy(ns3::Ptr phy) [member function] + cls.add_method('SetupPhy', 'void', [param('ns3::Ptr< ns3::WifiPhy >', 'phy')], is_virtual=True) + ## ideal-wifi-manager.h: double ns3::IdealWifiManager::GetSnrThreshold(ns3::WifiMode mode) const [member function] + cls.add_method('GetSnrThreshold', 'double', [param('ns3::WifiMode', 'mode')], is_const=True) + ## ideal-wifi-manager.h: void ns3::IdealWifiManager::AddModeSnrThreshold(ns3::WifiMode mode, double ber) [member function] + cls.add_method('AddModeSnrThreshold', 'void', [param('ns3::WifiMode', 'mode'), param('double', 'ber')]) + ## ideal-wifi-manager.h: ns3::WifiRemoteStation * ns3::IdealWifiManager::CreateStation() [member function] + cls.add_method('CreateStation', 'ns3::WifiRemoteStation *', [], visibility='private', is_virtual=True) + return + +def register_Ns3ArfWifiManager_methods(root_module, cls): + ## arf-wifi-manager.h: static ns3::TypeId ns3::ArfWifiManager::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## arf-wifi-manager.h: ns3::ArfWifiManager::ArfWifiManager() [constructor] + cls.add_constructor([], visibility='public') + ## arf-wifi-manager.h: ns3::WifiRemoteStation * ns3::ArfWifiManager::CreateStation() [member function] + cls.add_method('CreateStation', 'ns3::WifiRemoteStation *', [], visibility='private', is_virtual=True) + return + +def register_Ns3AarfWifiManager_methods(root_module, cls): + ## aarf-wifi-manager.h: static ns3::TypeId ns3::AarfWifiManager::GetTypeId() [member function] + cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) + ## aarf-wifi-manager.h: ns3::AarfWifiManager::AarfWifiManager() [constructor] + cls.add_constructor([], visibility='public') + ## aarf-wifi-manager.h: ns3::WifiRemoteStation * ns3::AarfWifiManager::CreateStation() [member function] + cls.add_method('CreateStation', 'ns3::WifiRemoteStation *', [], visibility='private', is_virtual=True) + return + +def register_functions(root_module): + module = root_module + ## wifi-mode.h: extern ns3::Ptr ns3::MakeWifiModeChecker() [free function] + module.add_function('MakeWifiModeChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) + ## ssid.h: extern ns3::Ptr ns3::MakeSsidChecker() [free function] + module.add_function('MakeSsidChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) + register_functions_ns3_internal(module.get_submodule('internal'), root_module) + register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module) + register_functions_ns3_Config(module.get_submodule('Config'), root_module) + register_functions_ns3_olsr(module.get_submodule('olsr'), root_module) + return + +def register_functions_ns3_internal(module, root_module): + return + +def register_functions_ns3_TimeStepPrecision(module, root_module): + return + +def register_functions_ns3_Config(module, root_module): + return + +def register_functions_ns3_olsr(module, root_module): + return + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/ns3module_helpers.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/ns3module_helpers.cc Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,178 @@ +#include "ns3module.h" + + +namespace ns3{ + +void PythonCompleteConstruct (Ptr object, TypeId typeId, const AttributeList &attributes) +{ + object->SetTypeId (typeId); + object->Object::Construct (attributes); +} + +} + + + +class PythonEventImpl : public ns3::EventImpl +{ +private: + PyObject *m_callback; + PyObject *m_args; +public: + PythonEventImpl (PyObject *callback, PyObject *args) + { + m_callback = callback; + Py_INCREF(m_callback); + m_args = args; + Py_INCREF(m_args); + } + virtual ~PythonEventImpl () + { + Py_DECREF(m_callback); + Py_DECREF(m_args); + } + virtual void Notify () + { + PyObject *retval = PyObject_CallObject(m_callback, m_args); + if (retval) { + if (retval != Py_None) { + PyErr_SetString(PyExc_TypeError, "event callback should return None"); + PyErr_Print(); + } + Py_DECREF(retval); + } else { + PyErr_Print(); + } + } +}; + + +PyObject * +_wrap_Simulator_Schedule(PyNs3Simulator *PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs, + PyObject **return_exception) +{ + PyObject *exc_type, *traceback; + PyObject *py_time; + PyObject *py_callback; + PyObject *user_args; + ns3::Ptr py_event_impl; + PyNs3EventId *py_EventId; + + if (kwargs && PyObject_Length(kwargs) > 0) { + PyErr_SetString(PyExc_TypeError, "keyword arguments not supported"); + goto error; + } + + if (PyTuple_GET_SIZE(args) < 2) { + PyErr_SetString(PyExc_TypeError, "ns3.Simulator.Schedule needs at least 2 arguments"); + goto error; + } + py_time = PyTuple_GET_ITEM(args, 0); + py_callback = PyTuple_GET_ITEM(args, 1); + + if (!PyObject_IsInstance(py_time, (PyObject*) &PyNs3Time_Type)) { + PyErr_SetString(PyExc_TypeError, "Parameter 1 should be a ns3.Time instance"); + goto error; + } + if (!PyCallable_Check(py_callback)) { + PyErr_SetString(PyExc_TypeError, "Parameter 2 should be callable"); + goto error; + } + user_args = PyTuple_GetSlice(args, 2, PyTuple_GET_SIZE(args)); + py_event_impl = ns3::Create(py_callback, user_args); + Py_DECREF(user_args); + + py_EventId = PyObject_New(PyNs3EventId, &PyNs3EventId_Type); + py_EventId->obj = new ns3::EventId( + ns3::Simulator::Schedule(*((PyNs3Time *) py_time)->obj, py_event_impl)); + return (PyObject *) py_EventId; + +error: + PyErr_Fetch(&exc_type, return_exception, &traceback); + Py_XDECREF(exc_type); + Py_XDECREF(traceback); + return NULL; +} + + +PyObject * +_wrap_Simulator_ScheduleNow(PyNs3Simulator *PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs, + PyObject **return_exception) +{ + PyObject *exc_type, *traceback; + PyObject *py_callback; + PyObject *user_args; + ns3::Ptr py_event_impl; + PyNs3EventId *py_EventId; + + if (kwargs && PyObject_Length(kwargs) > 0) { + PyErr_SetString(PyExc_TypeError, "keyword arguments not supported"); + goto error; + } + + if (PyTuple_GET_SIZE(args) < 1) { + PyErr_SetString(PyExc_TypeError, "ns3.Simulator.Schedule needs at least 1 argument"); + goto error; + } + py_callback = PyTuple_GET_ITEM(args, 0); + + if (!PyCallable_Check(py_callback)) { + PyErr_SetString(PyExc_TypeError, "Parameter 2 should be callable"); + goto error; + } + user_args = PyTuple_GetSlice(args, 1, PyTuple_GET_SIZE(args)); + py_event_impl = ns3::Create(py_callback, user_args); + Py_DECREF(user_args); + + py_EventId = PyObject_New(PyNs3EventId, &PyNs3EventId_Type); + py_EventId->obj = new ns3::EventId(ns3::Simulator::ScheduleNow(py_event_impl)); + return (PyObject *) py_EventId; + +error: + PyErr_Fetch(&exc_type, return_exception, &traceback); + Py_XDECREF(exc_type); + Py_XDECREF(traceback); + return NULL; +} + + +PyObject * +_wrap_Simulator_ScheduleDestroy(PyNs3Simulator *PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs, + PyObject **return_exception) +{ + PyObject *exc_type, *traceback; + PyObject *py_callback; + PyObject *user_args; + ns3::Ptr py_event_impl; + PyNs3EventId *py_EventId; + + if (kwargs && PyObject_Length(kwargs) > 0) { + PyErr_SetString(PyExc_TypeError, "keyword arguments not supported"); + goto error; + } + + if (PyTuple_GET_SIZE(args) < 1) { + PyErr_SetString(PyExc_TypeError, "ns3.Simulator.Schedule needs at least 1 argument"); + goto error; + } + py_callback = PyTuple_GET_ITEM(args, 0); + + if (!PyCallable_Check(py_callback)) { + PyErr_SetString(PyExc_TypeError, "Parameter 2 should be callable"); + goto error; + } + user_args = PyTuple_GetSlice(args, 1, PyTuple_GET_SIZE(args)); + py_event_impl = ns3::Create(py_callback, user_args); + Py_DECREF(user_args); + + py_EventId = PyObject_New(PyNs3EventId, &PyNs3EventId_Type); + py_EventId->obj = new ns3::EventId(ns3::Simulator::ScheduleDestroy(py_event_impl)); + return (PyObject *) py_EventId; + +error: + PyErr_Fetch(&exc_type, return_exception, &traceback); + Py_XDECREF(exc_type); + Py_XDECREF(traceback); + return NULL; +} + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/ns3modulegen.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/ns3modulegen.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,116 @@ + +LOCAL_MODULES = [ + #'my_extra_api_definitions', + ] + + + +import sys +import os + +from pybindgen import FileCodeSink, write_preamble +from pybindgen.module import MultiSectionFactory +import pybindgen.settings + +from ns3modulegen_generated import (module_init, register_types, register_methods, register_functions) +import ns3modulegen_core_customizations +import callbacks_list + +this_script_dir = os.path.dirname(os.path.abspath(sys.argv[0])) + +class ErrorHandler(pybindgen.settings.ErrorHandler): + def handle_error(self, wrapper, exception, traceback_): + try: + stack = wrapper.stack_where_defined + except AttributeError: + print >> sys.stderr, "??:??: %s / %r" % (wrapper, exception) + else: + stack = list(stack) + stack.reverse() + for (filename, line_number, function_name, text) in stack: + file_dir = os.path.dirname(os.path.abspath(filename)) + if file_dir == this_script_dir: + print >> sys.stderr, "%s:%i: %r" % (os.path.join("..", "bindings", "python", os.path.basename(filename)), + line_number, exception) + break + return True +pybindgen.settings.error_handler = ErrorHandler() + + +class MyMultiSectionFactory(MultiSectionFactory): + + def __init__(self, main_file_name, modules): + super(MyMultiSectionFactory, self).__init__() + self.main_file_name = main_file_name + self.main_sink = FileCodeSink(open(main_file_name, "wt")) + self.header_name = "ns3module.h" + header_file_name = os.path.join(os.path.dirname(self.main_file_name), self.header_name) + self.header_sink = FileCodeSink(open(header_file_name, "wt")) + self.section_sinks = {} + + for module in modules: + section_name = 'ns3_module_%s' % module.replace('-', '_') + file_name = os.path.join(os.path.dirname(self.main_file_name), "%s.cc" % section_name) + sink = FileCodeSink(open(file_name, "wt")) + self.section_sinks[section_name] = sink + + def get_section_code_sink(self, section_name): + return self.section_sinks[section_name] + + def get_main_code_sink(self): + return self.main_sink + + def get_common_header_code_sink(self): + return self.header_sink + + def get_common_header_include(self): + return '"%s"' % self.header_name + + def close(self): + self.header_sink.file.close() + self.main_sink.file.close() + for sink in self.section_sinks.itervalues(): + sink.file.close() + + + +def main(): + out = MyMultiSectionFactory(sys.argv[1], sys.argv[2:]) + root_module = module_init() + root_module.add_include('"ns3/everything.h"') + + register_types(root_module) + + ns3modulegen_core_customizations.Simulator_customizations(root_module) + ns3modulegen_core_customizations.CommandLine_customizations(root_module) + + + for local_module in LOCAL_MODULES: + mod = __import__(local_module) + mod.register_types(root_module) + + ns3modulegen_core_customizations.generate_callback_classes(root_module.after_forward_declarations, + callbacks_list.callback_classes) + + + register_methods(root_module) + + for local_module in LOCAL_MODULES: + mod = __import__(local_module) + mod.register_methods(root_module) + + ns3modulegen_core_customizations.Object_customizations(root_module) + + register_functions(root_module) + + for local_module in LOCAL_MODULES: + mod = __import__(local_module) + mod.register_functions(root_module) + + root_module.generate(out, '_ns3') + + out.close() + +if __name__ == '__main__': + main() + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/ns3modulegen_core_customizations.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/ns3modulegen_core_customizations.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,495 @@ +import re + +from pybindgen.typehandlers import base as typehandlers +from pybindgen import (ReturnValue, Parameter) +from pybindgen.cppmethod import CustomCppMethodWrapper, CustomCppConstructorWrapper +from pybindgen.typehandlers.codesink import MemoryCodeSink +from pybindgen.typehandlers import ctypeparser +import warnings + +from pybindgen.typehandlers.base import CodeGenerationError + +import sys + +class SmartPointerTransformation(typehandlers.TypeTransformation): + """ + This class provides a "type transformation" that tends to support + NS-3 smart pointers. Parameters such as "Ptr foo" are + transformed into something like Parameter.new("Foo*", "foo", + transfer_ownership=False). Return values such as Ptr are + transformed into ReturnValue.new("Foo*", + caller_owns_return=False). Since the underlying objects have + reference counting, PyBindGen does the right thing. + """ + def __init__(self): + super(SmartPointerTransformation, self).__init__() + self.rx = re.compile(r'(ns3::|::ns3::|)Ptr<([^>]+)>') + + def _get_untransformed_type_traits(self, name): + m = self.rx.match(name) + is_const = False + if m is None: + return None, False + else: + name1 = m.group(2).strip() + if name1.startswith('const '): + name1 = name1[len('const '):] + is_const = True + if name1.endswith(' const'): + name1 = name1[:-len(' const')] + is_const = True + new_name = name1+' *' + + if new_name.startswith('::'): + new_name = new_name[2:] + return new_name, is_const + + def get_untransformed_name(self, name): + new_name, dummy_is_const = self._get_untransformed_type_traits(name) + return new_name + + def create_type_handler(self, type_handler, *args, **kwargs): + if issubclass(type_handler, Parameter): + kwargs['transfer_ownership'] = False + elif issubclass(type_handler, ReturnValue): + kwargs['caller_owns_return'] = False + else: + raise AssertionError + + ## fix the ctype, add ns3:: namespace + orig_ctype, is_const = self._get_untransformed_type_traits(args[0]) + if is_const: + kwargs['is_const'] = True + correct_ctype = 'ns3::Ptr< %s const >' % orig_ctype[:-2] + else: + correct_ctype = 'ns3::Ptr< %s >' % orig_ctype[:-2] + args = tuple([correct_ctype] + list(args[1:])) + + handler = type_handler(*args, **kwargs) + handler.set_tranformation(self, orig_ctype) + return handler + + def untransform(self, type_handler, declarations, code_block, expression): + return 'ns3::PeekPointer (%s)' % (expression,) + + def transform(self, type_handler, declarations, code_block, expression): + assert type_handler.untransformed_ctype[-1] == '*' + return 'ns3::Ptr< %s > (%s)' % (type_handler.untransformed_ctype[:-1], expression) + +## register the type transformation +transf = SmartPointerTransformation() +typehandlers.return_type_matcher.register_transformation(transf) +typehandlers.param_type_matcher.register_transformation(transf) +del transf + + +class ArgvParam(Parameter): + """ + Converts a python list-of-strings argument to a pair of 'int argc, + char *argv[]' arguments to pass into C. + + One Python argument becomes two C function arguments -> it's a miracle! + + Note: this parameter type handler is not registered by any name; + must be used explicitly. + """ + + DIRECTIONS = [Parameter.DIRECTION_IN] + CTYPES = [] + + def convert_c_to_python(self, wrapper): + raise NotImplementedError + + def convert_python_to_c(self, wrapper): + py_name = wrapper.declarations.declare_variable('PyObject*', 'py_' + self.name) + argc_var = wrapper.declarations.declare_variable('int', 'argc') + name = wrapper.declarations.declare_variable('char**', self.name) + idx = wrapper.declarations.declare_variable('Py_ssize_t', 'idx') + wrapper.parse_params.add_parameter('O!', ['&PyList_Type', '&'+py_name], self.name) + + #wrapper.before_call.write_error_check('!PyList_Check(%s)' % py_name) # XXX + + wrapper.before_call.write_code("%s = (char **) malloc(sizeof(char*)*PyList_Size(%s));" + % (name, py_name)) + wrapper.before_call.add_cleanup_code('free(%s);' % name) + wrapper.before_call.write_code(''' +for (%(idx)s = 0; %(idx)s < PyList_Size(%(py_name)s); %(idx)s++) +{ +''' % vars()) + wrapper.before_call.sink.indent() + wrapper.before_call.write_code(''' +PyObject *item = PyList_GET_ITEM(%(py_name)s, %(idx)s); +''' % vars()) + #wrapper.before_call.write_error_check('item == NULL') + wrapper.before_call.write_error_check( + '!PyString_Check(item)', + failure_cleanup=('PyErr_SetString(PyExc_TypeError, ' + '"argument %s must be a list of strings");') % self.name) + wrapper.before_call.write_code( + '%s[%s] = PyString_AsString(item);' % (name, idx)) + wrapper.before_call.sink.unindent() + wrapper.before_call.write_code('}') + wrapper.before_call.write_code('%s = PyList_Size(%s);' % (argc_var, py_name)) + + wrapper.call_params.append(argc_var) + wrapper.call_params.append(name) + + +class CallbackImplProxyMethod(typehandlers.ReverseWrapperBase): + """ + Class that generates a proxy virtual method that calls a similarly named python method. + """ + + def __init__(self, return_value, parameters): + super(CallbackImplProxyMethod, self).__init__(return_value, parameters) + + def generate_python_call(self): + """code to call the python method""" + build_params = self.build_params.get_parameters() + if build_params[0][0] == '"': + build_params[0] = '(char *) ' + build_params[0] + args = self.before_call.declare_variable('PyObject*', 'args') + self.before_call.write_code('%s = Py_BuildValue(%s);' + % (args, ', '.join(build_params))) + self.before_call.add_cleanup_code('Py_DECREF(%s);' % args) + self.before_call.write_code('py_retval = PyObject_CallObject(m_callback, %s);' % args) + self.before_call.write_error_check('py_retval == NULL') + self.before_call.add_cleanup_code('Py_DECREF(py_retval);') + + + + +def generate_callback_classes(out, callbacks): + for callback_impl_num, template_parameters in enumerate(callbacks): + sink = MemoryCodeSink() + cls_name = "ns3::Callback< %s >" % ', '.join(template_parameters) + #print >> sys.stderr, "***** trying to register callback: %r" % cls_name + class_name = "PythonCallbackImpl%i" % callback_impl_num + sink.writeln(''' +class %s : public ns3::CallbackImpl<%s> +{ +public: + PyObject *m_callback; + %s(PyObject *callback) + { + Py_INCREF(callback); + m_callback = callback; + } + virtual ~%s() + { + Py_DECREF(m_callback); + m_callback = NULL; + } + + virtual bool IsEqual(ns3::Ptr other_base) const + { + const %s *other = dynamic_cast (ns3::PeekPointer (other_base)); + if (other != NULL) + return (other->m_callback == m_callback); + else + return false; + } + +''' % (class_name, ', '.join(template_parameters), class_name, class_name, class_name, class_name)) + sink.indent() + callback_return = template_parameters[0] + return_ctype = ctypeparser.parse_type(callback_return) + if ('const' in return_ctype.remove_modifiers()): + kwargs = {'is_const': True} + else: + kwargs = {} + try: + return_type = ReturnValue.new(str(return_ctype), **kwargs) + except (typehandlers.TypeLookupError, typehandlers.TypeConfigurationError), ex: + warnings.warn("***** Unable to register callback; Return value '%s' error (used in %s): %r" + % (callback_return, cls_name, ex), + Warning) + continue + + arguments = [] + ok = True + callback_parameters = [arg for arg in template_parameters[1:] if arg != 'ns3::empty'] + for arg_num, arg_type in enumerate(callback_parameters): + arg_name = 'arg%i' % (arg_num+1) + + param_ctype = ctypeparser.parse_type(arg_type) + if ('const' in param_ctype.remove_modifiers()): + kwargs = {'is_const': True} + else: + kwargs = {} + try: + arguments.append(Parameter.new(str(param_ctype), arg_name, **kwargs)) + except (typehandlers.TypeLookupError, typehandlers.TypeConfigurationError), ex: + warnings.warn("***** Unable to register callback; parameter '%s %s' error (used in %s): %r" + % (arg_type, arg_name, cls_name, ex), + Warning) + ok = False + if not ok: + continue + + wrapper = CallbackImplProxyMethod(return_type, arguments) + wrapper.generate(sink, 'operator()', decl_modifiers=[]) + + sink.unindent() + sink.writeln('};\n') + sink.flush_to(out) + + class PythonCallbackParameter(Parameter): + "Class handlers" + CTYPES = [cls_name] + #print >> sys.stderr, "***** registering callback handler: %r" % ctypeparser.normalize_type_string(cls_name) + DIRECTIONS = [Parameter.DIRECTION_IN] + PYTHON_CALLBACK_IMPL_NAME = class_name + TEMPLATE_ARGS = template_parameters + + def convert_python_to_c(self, wrapper): + "parses python args to get C++ value" + assert isinstance(wrapper, typehandlers.ForwardWrapperBase) + + py_callback = wrapper.declarations.declare_variable('PyObject*', self.name) + wrapper.parse_params.add_parameter('O', ['&'+py_callback], self.name) + wrapper.before_call.write_error_check( + '!PyCallable_Check(%s)' % py_callback, + 'PyErr_SetString(PyExc_TypeError, "parameter \'%s\' must be callbale");' % self.name) + callback_impl = wrapper.declarations.declare_variable( + 'ns3::Ptr<%s>' % self.PYTHON_CALLBACK_IMPL_NAME, + '%s_cb_impl' % self.name) + wrapper.before_call.write_code("%s = ns3::Create<%s> (%s);" + % (callback_impl, self.PYTHON_CALLBACK_IMPL_NAME, py_callback)) + wrapper.call_params.append( + 'ns3::Callback<%s> (%s)' % (', '.join(self.TEMPLATE_ARGS), callback_impl)) + + def convert_c_to_python(self, wrapper): + raise typehandlers.NotSupportedError("Reverse wrappers for ns3::Callback<...> types " + "(python using callbacks defined in C++) not implemented.") + + +# def write_preamble(out): +# pybindgen.write_preamble(out) +# out.writeln("#include \"ns3/everything.h\"") + + + +def Simulator_customizations(module): + Simulator = module['ns3::Simulator'] + + ## Simulator::Schedule(delay, callback, ...user..args...) + Simulator.add_custom_method_wrapper("Schedule", "_wrap_Simulator_Schedule", + flags=["METH_VARARGS", "METH_KEYWORDS", "METH_STATIC"]) + + + ## Simulator::ScheduleNow(callback, ...user..args...) + Simulator.add_custom_method_wrapper("ScheduleNow", "_wrap_Simulator_ScheduleNow", + flags=["METH_VARARGS", "METH_KEYWORDS", "METH_STATIC"]) + + + ## Simulator::ScheduleDestroy(callback, ...user..args...) + Simulator.add_custom_method_wrapper("ScheduleDestroy", "_wrap_Simulator_ScheduleDestroy", + flags=["METH_VARARGS", "METH_KEYWORDS", "METH_STATIC"]) + + +def CommandLine_customizations(module): + CommandLine = module['ns3::CommandLine'] + CommandLine.add_method('Parse', None, [ArgvParam(None, 'argv')], + is_static=False) + + +def Object_customizations(module): + ## --------------------------------------------------------------------- + ## Here we generate custom constructor code for all classes that + ## derive from ns3::Object. The custom constructors are needed in + ## order to support kwargs only and to translate kwargs into ns3 + ## attributes, etc. + ## --------------------------------------------------------------------- + Object = module['ns3::Object'] + + + ## add a GetTypeId method to all generatd helper classes + def helper_class_hook(helper_class): + decl = """ +static ns3::TypeId GetTypeId (void) +{ + static ns3::TypeId tid = ns3::TypeId ("%s") + .SetParent< %s > () + ; + return tid; +}""" % (helper_class.name, helper_class.class_.full_name) + + helper_class.add_custom_method(decl) + helper_class.add_post_generation_code( + "NS_OBJECT_ENSURE_REGISTERED (%s);" % helper_class.name) + Object.add_helper_class_hook(helper_class_hook) + + ## Replace all class constructors with a generic constructor based on CreateObject (AttributeList) + module.header.writeln(''' +namespace ns3 { + +void PythonCompleteConstruct (Ptr object, TypeId typeId, const AttributeList &attributes); + +template +Ptr CreateObjectPython (PyObject *pyobj, const AttributeList &attributes) +{ + Ptr p = Ptr (new T (), false); + p->set_pyobj (pyobj); + PythonCompleteConstruct (p, T::GetTypeId (), attributes); + return p; +} + +} // namespace ns3 + +''') + + for cls in module.classes: + if not cls.is_subclass(Object): + continue + cls.constructors = [] # clear the list of constructors + + ## add our own custom constructor, if possible + try: + construct_name = cls.get_construct_name() + except CodeGenerationError: + construct_name = None + + if construct_name and not cls.helper_class: + construct_code = ''' + ns3::Ptr< %(CONSTRUCT_NAME)s > obj = ns3::CreateObject< %(CONSTRUCT_NAME)s > (attrList); + obj->Ref (); + self->obj = ns3::PeekPointer (obj); +''' % dict (CONSTRUCT_NAME=construct_name) + + elif not construct_name and not cls.helper_class: + continue + + elif not construct_name and cls.helper_class: + construct_code = ''' + if (self->ob_type != &%(PYTYPESTRUCT)s) + { + ns3::Ptr< %(HELPER_CLASS_NAME)s > obj = ns3::CreateObjectPython< %(HELPER_CLASS_NAME)s > ((PyObject *)self, attrList); + obj->Ref (); + self->obj = ns3::PeekPointer (obj); + } else { + PyErr_SetString(PyExc_TypeError, "Class cannot be constructed (unless subclassed)"); + { + PyObject *exc_type, *traceback; + PyErr_Fetch(&exc_type, return_exception, &traceback); + Py_XDECREF(exc_type); + Py_XDECREF(traceback); + } + return -1; + } +''' % dict (CONSTRUCT_NAME=construct_name, HELPER_CLASS_NAME=cls.helper_class.name, + PYTYPESTRUCT=cls.pytypestruct) + + elif construct_name and cls.helper_class: + construct_code = ''' + if (self->ob_type != &%(PYTYPESTRUCT)s) + { + ns3::Ptr< %(HELPER_CLASS_NAME)s > obj = ns3::CreateObjectPython< %(HELPER_CLASS_NAME)s > ((PyObject *)self, attrList); + obj->Ref (); + self->obj = ns3::PeekPointer (obj); + } else { + ns3::Ptr< %(CONSTRUCT_NAME)s > obj = ns3::CreateObject< %(CONSTRUCT_NAME)s > (attrList); + obj->Ref (); + self->obj = ns3::PeekPointer (obj); + } +''' % dict (CONSTRUCT_NAME=construct_name, HELPER_CLASS_NAME=cls.helper_class.name, + PYTYPESTRUCT=cls.pytypestruct) + else: + raise AssertionError + + wrapper_name = "_wrap_create_object_%s" % (cls.full_name.replace(':', '_'),) + constructor = ''' +static int %(WRAPPER_NAME)s (%(PYSTRUCT)s *self, PyObject *args, PyObject *kwargs, PyObject **return_exception) +{ + if (PyTuple_Size(args)) { + PyErr_SetString(PyExc_TypeError, "positional arguments not supported " + "for ns3.Object constructors, only keyword arguments" + " should be used (AttributeName=Value)"); + { + PyObject *exc_type, *traceback; + PyErr_Fetch(&exc_type, return_exception, &traceback); + Py_XDECREF(exc_type); + Py_XDECREF(traceback); + } + return -1; + } + ns3::AttributeList attrList; + if (kwargs && KwargsToAttributeList(kwargs, %(CLASS_NAME)s::GetTypeId(), attrList)) { + { + PyObject *exc_type, *traceback; + PyErr_Fetch(&exc_type, return_exception, &traceback); + Py_XDECREF(exc_type); + Py_XDECREF(traceback); + } + return -1; + } + %(CONSTRUCT_CODE)s + return 0; +} +''' % dict(WRAPPER_NAME=wrapper_name, PYSTRUCT=cls.pystruct, CLASS_NAME=cls.full_name, + CONSTRUCT_CODE=construct_code, PURE_VIRTUALS=cls.have_pure_virtual_methods) + cls.add_constructor(CustomCppConstructorWrapper(wrapper_name, constructor)) + + + # Generate conversion function from PyObject* to AttributeValue +# sink = module.body +# sink.writeln(''' +# Ptr AttributeValueFromPyObject (PyObject *obj) +# { +# // note: needs to check for bool first, because bool is a subclass of int +# if (PyBool_Check(obj)) { +# return Create(PyObject_IsTrue(obj)); +# } else if (PyInt_Check(obj)) { +# return Create(PyInt_AsLong(obj)); +# } else if (PyLong_Check(obj)) { +# return Create(PyLong_AsLongLong(obj)); +# } else if (PyFloat_Check(obj)) { +# return Create(PyFloat_AsDouble(obj)); +# } + +# ''') + + + + ## --------------------------------------------------------------------- + ## -------------- write the KwargsToAttributeList function ------------- + ## --------------------------------------------------------------------- + Attribute = module['ns3::AttributeValue'] + module.after_forward_declarations.writeln( + 'int KwargsToAttributeList(PyObject *kwargs, ns3::TypeId tid, ns3::AttributeList &oAttrList);') + + module.body.writeln( +''' +int KwargsToAttributeList(PyObject *kwargs, ns3::TypeId tid, ns3::AttributeList &oAttrList) +{ + PyObject *key, *value; + Py_ssize_t pos = 0; + + while (PyDict_Next(kwargs, &pos, &key, &value)) { + if (!PyString_Check(key)) { + PyErr_SetString(PyExc_TypeError, "kwargs keys must be strings"); + return -1; + } + if (PyObject_IsInstance(value, (PyObject*) &%s)) { + oAttrList.SetWithTid(tid, PyString_AsString(key), *((%s *) value)->obj);''' \ + % (Attribute.pytypestruct, Attribute.pystruct)) + + for conversion_source in Attribute.get_all_implicit_conversions(): + module.body.writeln(''' + } else if (PyObject_IsInstance(value, (PyObject*) &%s)) { + oAttrList.SetWithTid(tid, PyString_AsString(key), *((%s *) value)->obj);''' \ + % (conversion_source.pytypestruct, conversion_source.pystruct)) + + possible_type_names = ", ".join([cls.name for cls in [Attribute] + Attribute.get_all_implicit_conversions()]) + module.body.writeln(''' + } else { + PyErr_Format(PyExc_TypeError, \"parameter must an instance of one of the types (%s), not %%s\", value->ob_type->tp_name); + return -1; + }''' % (possible_type_names)) + + module.body.writeln( +''' + } + return 0; +} +''') diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/ns3modulegen_generated.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/ns3modulegen_generated.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,642 @@ +from pybindgen import Module, FileCodeSink, write_preamble, param, retval + + +import pybindgen.settings +import warnings + +class ErrorHandler(pybindgen.settings.ErrorHandler): + def handle_error(self, wrapper, exception, traceback_): + warnings.warn("exception %r in wrapper %s" % (exception, wrapper)) + return True +pybindgen.settings.error_handler = ErrorHandler() + + +import sys +import ns3_module_core +import ns3_module_simulator +import ns3_module_mobility +import ns3_module_common +import ns3_module_contrib +import ns3_module_node +import ns3_module_point_to_point +import ns3_module_internet_stack +import ns3_module_wifi +import ns3_module_csma +import ns3_module_packet_sink +import ns3_module_global_routing +import ns3_module_onoff +import ns3_module_olsr +import ns3_module_udp_echo +import ns3_module_helper + +def module_init(): + root_module = Module('ns3', cpp_namespace='::ns3') + return root_module + +def register_types(module): + root_module = module.get_root() + + root_module.begin_section('ns3_module_core') + ns3_module_core.register_types(module) + + try: + import ns3_module_core__local + except ImportError: + pass + else: + ns3_module_core__local.register_types(module) + + root_module.end_section('ns3_module_core') + root_module.begin_section('ns3_module_simulator') + ns3_module_simulator.register_types(module) + + try: + import ns3_module_simulator__local + except ImportError: + pass + else: + ns3_module_simulator__local.register_types(module) + + root_module.end_section('ns3_module_simulator') + root_module.begin_section('ns3_module_mobility') + ns3_module_mobility.register_types(module) + + try: + import ns3_module_mobility__local + except ImportError: + pass + else: + ns3_module_mobility__local.register_types(module) + + root_module.end_section('ns3_module_mobility') + root_module.begin_section('ns3_module_common') + ns3_module_common.register_types(module) + + try: + import ns3_module_common__local + except ImportError: + pass + else: + ns3_module_common__local.register_types(module) + + root_module.end_section('ns3_module_common') + root_module.begin_section('ns3_module_contrib') + ns3_module_contrib.register_types(module) + + try: + import ns3_module_contrib__local + except ImportError: + pass + else: + ns3_module_contrib__local.register_types(module) + + root_module.end_section('ns3_module_contrib') + root_module.begin_section('ns3_module_node') + ns3_module_node.register_types(module) + + try: + import ns3_module_node__local + except ImportError: + pass + else: + ns3_module_node__local.register_types(module) + + root_module.end_section('ns3_module_node') + root_module.begin_section('ns3_module_point_to_point') + ns3_module_point_to_point.register_types(module) + + try: + import ns3_module_point_to_point__local + except ImportError: + pass + else: + ns3_module_point_to_point__local.register_types(module) + + root_module.end_section('ns3_module_point_to_point') + root_module.begin_section('ns3_module_internet_stack') + ns3_module_internet_stack.register_types(module) + + try: + import ns3_module_internet_stack__local + except ImportError: + pass + else: + ns3_module_internet_stack__local.register_types(module) + + root_module.end_section('ns3_module_internet_stack') + root_module.begin_section('ns3_module_wifi') + ns3_module_wifi.register_types(module) + + try: + import ns3_module_wifi__local + except ImportError: + pass + else: + ns3_module_wifi__local.register_types(module) + + root_module.end_section('ns3_module_wifi') + root_module.begin_section('ns3_module_csma') + ns3_module_csma.register_types(module) + + try: + import ns3_module_csma__local + except ImportError: + pass + else: + ns3_module_csma__local.register_types(module) + + root_module.end_section('ns3_module_csma') + root_module.begin_section('ns3_module_packet_sink') + ns3_module_packet_sink.register_types(module) + + try: + import ns3_module_packet_sink__local + except ImportError: + pass + else: + ns3_module_packet_sink__local.register_types(module) + + root_module.end_section('ns3_module_packet_sink') + root_module.begin_section('ns3_module_global_routing') + ns3_module_global_routing.register_types(module) + + try: + import ns3_module_global_routing__local + except ImportError: + pass + else: + ns3_module_global_routing__local.register_types(module) + + root_module.end_section('ns3_module_global_routing') + root_module.begin_section('ns3_module_onoff') + ns3_module_onoff.register_types(module) + + try: + import ns3_module_onoff__local + except ImportError: + pass + else: + ns3_module_onoff__local.register_types(module) + + root_module.end_section('ns3_module_onoff') + root_module.begin_section('ns3_module_olsr') + ns3_module_olsr.register_types(module) + + try: + import ns3_module_olsr__local + except ImportError: + pass + else: + ns3_module_olsr__local.register_types(module) + + root_module.end_section('ns3_module_olsr') + root_module.begin_section('ns3_module_udp_echo') + ns3_module_udp_echo.register_types(module) + + try: + import ns3_module_udp_echo__local + except ImportError: + pass + else: + ns3_module_udp_echo__local.register_types(module) + + root_module.end_section('ns3_module_udp_echo') + root_module.begin_section('ns3_module_helper') + ns3_module_helper.register_types(module) + + try: + import ns3_module_helper__local + except ImportError: + pass + else: + ns3_module_helper__local.register_types(module) + + root_module.end_section('ns3_module_helper') + + ## Register a nested module for the namespace internal + + nested_module = module.add_cpp_namespace('internal') + register_types_ns3_internal(nested_module) + + + ## Register a nested module for the namespace TimeStepPrecision + + nested_module = module.add_cpp_namespace('TimeStepPrecision') + register_types_ns3_TimeStepPrecision(nested_module) + + + ## Register a nested module for the namespace Config + + nested_module = module.add_cpp_namespace('Config') + register_types_ns3_Config(nested_module) + + + ## Register a nested module for the namespace olsr + + nested_module = module.add_cpp_namespace('olsr') + register_types_ns3_olsr(nested_module) + + +def register_types_ns3_internal(module): + root_module = module.get_root() + + +def register_types_ns3_TimeStepPrecision(module): + root_module = module.get_root() + + +def register_types_ns3_Config(module): + root_module = module.get_root() + + +def register_types_ns3_olsr(module): + root_module = module.get_root() + + +def register_methods(root_module): + root_module.begin_section('ns3_module_core') + ns3_module_core.register_methods(root_module) + + try: + import ns3_module_core__local + except ImportError: + pass + else: + ns3_module_core__local.register_methods(root_module) + + root_module.end_section('ns3_module_core') + root_module.begin_section('ns3_module_simulator') + ns3_module_simulator.register_methods(root_module) + + try: + import ns3_module_simulator__local + except ImportError: + pass + else: + ns3_module_simulator__local.register_methods(root_module) + + root_module.end_section('ns3_module_simulator') + root_module.begin_section('ns3_module_mobility') + ns3_module_mobility.register_methods(root_module) + + try: + import ns3_module_mobility__local + except ImportError: + pass + else: + ns3_module_mobility__local.register_methods(root_module) + + root_module.end_section('ns3_module_mobility') + root_module.begin_section('ns3_module_common') + ns3_module_common.register_methods(root_module) + + try: + import ns3_module_common__local + except ImportError: + pass + else: + ns3_module_common__local.register_methods(root_module) + + root_module.end_section('ns3_module_common') + root_module.begin_section('ns3_module_contrib') + ns3_module_contrib.register_methods(root_module) + + try: + import ns3_module_contrib__local + except ImportError: + pass + else: + ns3_module_contrib__local.register_methods(root_module) + + root_module.end_section('ns3_module_contrib') + root_module.begin_section('ns3_module_node') + ns3_module_node.register_methods(root_module) + + try: + import ns3_module_node__local + except ImportError: + pass + else: + ns3_module_node__local.register_methods(root_module) + + root_module.end_section('ns3_module_node') + root_module.begin_section('ns3_module_point_to_point') + ns3_module_point_to_point.register_methods(root_module) + + try: + import ns3_module_point_to_point__local + except ImportError: + pass + else: + ns3_module_point_to_point__local.register_methods(root_module) + + root_module.end_section('ns3_module_point_to_point') + root_module.begin_section('ns3_module_internet_stack') + ns3_module_internet_stack.register_methods(root_module) + + try: + import ns3_module_internet_stack__local + except ImportError: + pass + else: + ns3_module_internet_stack__local.register_methods(root_module) + + root_module.end_section('ns3_module_internet_stack') + root_module.begin_section('ns3_module_wifi') + ns3_module_wifi.register_methods(root_module) + + try: + import ns3_module_wifi__local + except ImportError: + pass + else: + ns3_module_wifi__local.register_methods(root_module) + + root_module.end_section('ns3_module_wifi') + root_module.begin_section('ns3_module_csma') + ns3_module_csma.register_methods(root_module) + + try: + import ns3_module_csma__local + except ImportError: + pass + else: + ns3_module_csma__local.register_methods(root_module) + + root_module.end_section('ns3_module_csma') + root_module.begin_section('ns3_module_packet_sink') + ns3_module_packet_sink.register_methods(root_module) + + try: + import ns3_module_packet_sink__local + except ImportError: + pass + else: + ns3_module_packet_sink__local.register_methods(root_module) + + root_module.end_section('ns3_module_packet_sink') + root_module.begin_section('ns3_module_global_routing') + ns3_module_global_routing.register_methods(root_module) + + try: + import ns3_module_global_routing__local + except ImportError: + pass + else: + ns3_module_global_routing__local.register_methods(root_module) + + root_module.end_section('ns3_module_global_routing') + root_module.begin_section('ns3_module_onoff') + ns3_module_onoff.register_methods(root_module) + + try: + import ns3_module_onoff__local + except ImportError: + pass + else: + ns3_module_onoff__local.register_methods(root_module) + + root_module.end_section('ns3_module_onoff') + root_module.begin_section('ns3_module_olsr') + ns3_module_olsr.register_methods(root_module) + + try: + import ns3_module_olsr__local + except ImportError: + pass + else: + ns3_module_olsr__local.register_methods(root_module) + + root_module.end_section('ns3_module_olsr') + root_module.begin_section('ns3_module_udp_echo') + ns3_module_udp_echo.register_methods(root_module) + + try: + import ns3_module_udp_echo__local + except ImportError: + pass + else: + ns3_module_udp_echo__local.register_methods(root_module) + + root_module.end_section('ns3_module_udp_echo') + root_module.begin_section('ns3_module_helper') + ns3_module_helper.register_methods(root_module) + + try: + import ns3_module_helper__local + except ImportError: + pass + else: + ns3_module_helper__local.register_methods(root_module) + + root_module.end_section('ns3_module_helper') + return + +def register_functions(root_module): + module = root_module + root_module.begin_section('ns3_module_core') + ns3_module_core.register_functions(root_module) + + try: + import ns3_module_core__local + except ImportError: + pass + else: + ns3_module_core__local.register_functions(root_module) + + root_module.end_section('ns3_module_core') + root_module.begin_section('ns3_module_simulator') + ns3_module_simulator.register_functions(root_module) + + try: + import ns3_module_simulator__local + except ImportError: + pass + else: + ns3_module_simulator__local.register_functions(root_module) + + root_module.end_section('ns3_module_simulator') + root_module.begin_section('ns3_module_mobility') + ns3_module_mobility.register_functions(root_module) + + try: + import ns3_module_mobility__local + except ImportError: + pass + else: + ns3_module_mobility__local.register_functions(root_module) + + root_module.end_section('ns3_module_mobility') + root_module.begin_section('ns3_module_common') + ns3_module_common.register_functions(root_module) + + try: + import ns3_module_common__local + except ImportError: + pass + else: + ns3_module_common__local.register_functions(root_module) + + root_module.end_section('ns3_module_common') + root_module.begin_section('ns3_module_contrib') + ns3_module_contrib.register_functions(root_module) + + try: + import ns3_module_contrib__local + except ImportError: + pass + else: + ns3_module_contrib__local.register_functions(root_module) + + root_module.end_section('ns3_module_contrib') + root_module.begin_section('ns3_module_node') + ns3_module_node.register_functions(root_module) + + try: + import ns3_module_node__local + except ImportError: + pass + else: + ns3_module_node__local.register_functions(root_module) + + root_module.end_section('ns3_module_node') + root_module.begin_section('ns3_module_point_to_point') + ns3_module_point_to_point.register_functions(root_module) + + try: + import ns3_module_point_to_point__local + except ImportError: + pass + else: + ns3_module_point_to_point__local.register_functions(root_module) + + root_module.end_section('ns3_module_point_to_point') + root_module.begin_section('ns3_module_internet_stack') + ns3_module_internet_stack.register_functions(root_module) + + try: + import ns3_module_internet_stack__local + except ImportError: + pass + else: + ns3_module_internet_stack__local.register_functions(root_module) + + root_module.end_section('ns3_module_internet_stack') + root_module.begin_section('ns3_module_wifi') + ns3_module_wifi.register_functions(root_module) + + try: + import ns3_module_wifi__local + except ImportError: + pass + else: + ns3_module_wifi__local.register_functions(root_module) + + root_module.end_section('ns3_module_wifi') + root_module.begin_section('ns3_module_csma') + ns3_module_csma.register_functions(root_module) + + try: + import ns3_module_csma__local + except ImportError: + pass + else: + ns3_module_csma__local.register_functions(root_module) + + root_module.end_section('ns3_module_csma') + root_module.begin_section('ns3_module_packet_sink') + ns3_module_packet_sink.register_functions(root_module) + + try: + import ns3_module_packet_sink__local + except ImportError: + pass + else: + ns3_module_packet_sink__local.register_functions(root_module) + + root_module.end_section('ns3_module_packet_sink') + root_module.begin_section('ns3_module_global_routing') + ns3_module_global_routing.register_functions(root_module) + + try: + import ns3_module_global_routing__local + except ImportError: + pass + else: + ns3_module_global_routing__local.register_functions(root_module) + + root_module.end_section('ns3_module_global_routing') + root_module.begin_section('ns3_module_onoff') + ns3_module_onoff.register_functions(root_module) + + try: + import ns3_module_onoff__local + except ImportError: + pass + else: + ns3_module_onoff__local.register_functions(root_module) + + root_module.end_section('ns3_module_onoff') + root_module.begin_section('ns3_module_olsr') + ns3_module_olsr.register_functions(root_module) + + try: + import ns3_module_olsr__local + except ImportError: + pass + else: + ns3_module_olsr__local.register_functions(root_module) + + root_module.end_section('ns3_module_olsr') + root_module.begin_section('ns3_module_udp_echo') + ns3_module_udp_echo.register_functions(root_module) + + try: + import ns3_module_udp_echo__local + except ImportError: + pass + else: + ns3_module_udp_echo__local.register_functions(root_module) + + root_module.end_section('ns3_module_udp_echo') + root_module.begin_section('ns3_module_helper') + ns3_module_helper.register_functions(root_module) + + try: + import ns3_module_helper__local + except ImportError: + pass + else: + ns3_module_helper__local.register_functions(root_module) + + root_module.end_section('ns3_module_helper') + register_functions_ns3_internal(module.get_submodule('internal'), root_module) + register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module) + register_functions_ns3_Config(module.get_submodule('Config'), root_module) + register_functions_ns3_olsr(module.get_submodule('olsr'), root_module) + return + +def register_functions_ns3_internal(module, root_module): + return + +def register_functions_ns3_TimeStepPrecision(module, root_module): + return + +def register_functions_ns3_Config(module, root_module): + return + +def register_functions_ns3_olsr(module, root_module): + return + +def main(): + out = FileCodeSink(sys.stdout) + root_module = module_init() + register_types(root_module) + register_methods(root_module) + register_functions(root_module) + write_preamble(out) + root_module.generate(out) + +if __name__ == '__main__': + main() + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/ns3modulescan.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/ns3modulescan.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,281 @@ +#! /usr/bin/env python + +import sys +import os.path + +import pybindgen.settings +from pybindgen.gccxmlparser import ModuleParser, PygenClassifier, PygenSection, WrapperWarning +from pybindgen.typehandlers.codesink import FileCodeSink +from pygccxml.declarations import templates +from pygccxml.declarations.class_declaration import class_t +from pygccxml.declarations.calldef import free_function_t, member_function_t, constructor_t + + +## we need the smart pointer type transformation to be active even +## during gccxml scanning. +import ns3modulegen_core_customizations + + +## silence gccxmlparser errors; we only want error handling in the +## generated python script, not while scanning. +class ErrorHandler(pybindgen.settings.ErrorHandler): + def handle_error(self, dummy_wrapper, dummy_exception, dummy_traceback_): + return True +pybindgen.settings.error_handler = ErrorHandler() +import warnings +warnings.filterwarnings(category=WrapperWarning, action='ignore') + +type_annotations = { + '::ns3::RefCountBase': { + 'incref_method': 'Ref', + 'decref_method': 'Unref', + 'peekref_method': 'GetReferenceCount', + 'automatic_type_narrowing': 'true', + }, + '::ns3::Object': { + 'incref_method': 'Ref', + 'decref_method': 'Unref', + 'peekref_method': 'GetReferenceCount', + 'automatic_type_narrowing': 'true', + }, + '::ns3::Packet': { + 'incref_method': 'Ref', + 'decref_method': 'Unref', + 'peekref_method': 'GetReferenceCount', + }, + '::ns3::CallbackImplBase': { + 'incref_method': 'Ref', + 'decref_method': 'Unref', + 'peekref_method': 'GetReferenceCount', + }, + '::ns3::PacketMetadata': { + 'ignore': None, + }, + '::ns3::AttributeChecker': { + 'incref_method': 'Ref', + 'decref_method': 'Unref', + 'automatic_type_narrowing': 'true', + 'allow_subclassing': 'false', + }, + '::ns3::AttributeValue': { + 'incref_method': 'Ref', + 'decref_method': 'Unref', + 'automatic_type_narrowing': 'true', + 'allow_subclassing': 'false', + }, + 'ns3::RandomVariable::RandomVariable(ns3::RandomVariableBase const & variable) [constructor]': { + 'ignore': None, + }, + 'ns3::RandomVariableBase * ns3::RandomVariable::Peek() const [member function]': { + 'ignore': None, + }, + 'void ns3::RandomVariable::GetSeed(uint32_t * seed) const [member function]': { + 'params': {'seed':{'direction':'out', + 'array_length':'6'}} + }, + 'bool ns3::TypeId::LookupAttributeByName(std::string name, ns3::TypeId::AttributeInfo * info) const [member function]': { + 'params': {'info':{'transfer_ownership': 'false'}} + }, + 'static bool ns3::TypeId::LookupByNameFailSafe(std::string name, ns3::TypeId * tid) [member function]': { + 'params': {'tid': {'transfer_ownership': 'false'}} + }, + 'bool ns3::TraceSourceAccessor::ConnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function]': { + 'params': {'obj': {'transfer_ownership':'false'}} + }, + 'bool ns3::TraceSourceAccessor::Connect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function]': { + 'params': {'obj': {'transfer_ownership':'false'}} + }, + 'bool ns3::TraceSourceAccessor::DisconnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function]': { + 'params': {'obj': {'transfer_ownership':'false'}} + }, + 'bool ns3::TraceSourceAccessor::Disconnect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function]': { + 'params': {'obj': {'transfer_ownership':'false'}} + }, + 'bool ns3::AttributeAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function]': { + 'params': {'object': {'transfer_ownership':'false'}} + }, + 'ns3::EmpiricalVariable::EmpiricalVariable(ns3::RandomVariableBase const & variable) [constructor]': { + 'ignore': None + }, + 'static ns3::AttributeList * ns3::AttributeList::GetGlobal() [member function]': { + 'caller_owns_return': 'false' + }, + 'void ns3::CommandLine::Parse(int argc, char * * argv) const [member function]': { + 'ignore': None # manually wrapped + }, + 'extern void ns3::PythonCompleteConstruct(ns3::Ptr object, ns3::TypeId typeId, ns3::AttributeList const & attributes) [free function]': { + 'ignore': None # used transparently by, should not be wrapped + }, + } + +def get_ns3_relative_path(path): + l = [] + head = path + while head: + head, tail = os.path.split(head) + if tail == 'ns3': + return os.path.join(*l) + l.insert(0, tail) + raise AssertionError("is the path %r inside ns3?!" % path) + + +def pre_scan_hook(dummy_module_parser, + pygccxml_definition, + global_annotations, + parameter_annotations): + ns3_header = get_ns3_relative_path(pygccxml_definition.location.file_name) + + ## Note: we don't include line numbers in the comments because + ## those numbers are very likely to change frequently, which would + ## cause needless changes, since the generated python files are + ## kept under version control. + + #global_annotations['pygen_comment'] = "%s:%i: %s" % \ + # (ns3_header, pygccxml_definition.location.line, pygccxml_definition) + global_annotations['pygen_comment'] = "%s: %s" % \ + (ns3_header, pygccxml_definition) + + + ## handle ns3::Object::GetObject (left to its own devices, + ## pybindgen will generate a mangled name containing the template + ## argument type name). + if isinstance(pygccxml_definition, member_function_t) \ + and pygccxml_definition.parent.name == 'Object' \ + and pygccxml_definition.name == 'GetObject': + template_args = templates.args(pygccxml_definition.demangled_name) + if template_args == ['ns3::Object']: + global_annotations['template_instance_names'] = 'ns3::Object=>GetObject' + + ## Don't wrap Simulator::Schedule* (manually wrapped) + if isinstance(pygccxml_definition, member_function_t) \ + and pygccxml_definition.parent.name == 'Simulator' \ + and pygccxml_definition.name.startswith('Schedule'): + global_annotations['ignore'] = None + + ## classes + if isinstance(pygccxml_definition, class_t): + # no need for helper classes to allow subclassing in Python, I think... + if pygccxml_definition.name.endswith('Helper'): + global_annotations['allow_subclassing'] = 'false' + + if pygccxml_definition.decl_string.startswith('::ns3::Callback<'): + # manually handled in ns3modulegen_core_customizations.py + global_annotations['ignore'] = None + return + + if pygccxml_definition.decl_string.startswith('::ns3::Ptr<'): + # handled by pybindgen "type transformation" + global_annotations['ignore'] = None + return + + # table driven class customization + try: + annotations = type_annotations[pygccxml_definition.decl_string] + except KeyError: + pass + else: + global_annotations.update(annotations) + + ## free functions + if isinstance(pygccxml_definition, free_function_t): + if pygccxml_definition.name == 'PeekPointer': + global_annotations['ignore'] = None + return + + ## table driven methods/constructors/functions customization + if isinstance(pygccxml_definition, (free_function_t, member_function_t, constructor_t)): + try: + annotations = type_annotations[str(pygccxml_definition)] + except KeyError: + pass + else: + for key,value in annotations.items(): + if key == 'params': + parameter_annotations.update (value) + del annotations['params'] + global_annotations.update(annotations) + + +# def post_scan_hook(dummy_module_parser, dummy_pygccxml_definition, pybindgen_wrapper): +# ## classes +# if isinstance(pybindgen_wrapper, CppClass): +# if pybindgen_wrapper.name.endswith('Checker'): +# print >> sys.stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!", pybindgen_wrapper +# #pybindgen_wrapper.set_instance_creation_function(AttributeChecker_instance_creation_function) + + +def scan_callback_classes(module_parser, callback_classes_file): + callback_classes_file.write("callback_classes = [\n") + for cls in module_parser.module_namespace.classes(function=module_parser.location_filter, + recursive=False): + if not cls.name.startswith("Callback<"): + continue + assert templates.is_instantiation(cls.decl_string), "%s is not a template instantiation" % cls + dummy_cls_name, template_parameters = templates.split(cls.decl_string) + callback_classes_file.write(" %r,\n" % template_parameters) + callback_classes_file.write("]\n") + + +class MyPygenClassifier(PygenClassifier): + def __init__(self, headers_map): + self.headers_map = headers_map + + def classify(self, pygccxml_definition): + name = os.path.basename(pygccxml_definition.location.file_name) + try: + return self.headers_map[name] + except KeyError: + return '__main__' + + +def ns3_module_scan(top_builddir, pygen_file_name): + + ns3_modules = eval(sys.stdin.read()) + + ## do a topological sort on the modules graph + from topsort import topsort + graph = [] + for ns3_module_name, (ns3_module_deps, dummy) in ns3_modules.iteritems(): + for dep in ns3_module_deps: + graph.append((dep, ns3_module_name)) + sorted_ns3_modules = topsort(graph) + print >> sys.stderr, "******* topological sort: ", sorted_ns3_modules + + sections = [PygenSection('__main__', FileCodeSink(open(pygen_file_name, "wt")))] + headers_map = {} # header_name -> section_name + for ns3_module in sorted_ns3_modules: + section_name = "ns3_module_%s" % ns3_module.replace('-', '_') + file_name = os.path.join(os.path.dirname(pygen_file_name), "%s.py" % section_name) + sections.append(PygenSection(section_name, FileCodeSink(open(file_name, "wt")), + section_name + "__local")) + for header in ns3_modules[ns3_module][1]: + headers_map[header] = section_name + + module_parser = ModuleParser('ns3', 'ns3') + + module_parser.add_pre_scan_hook(pre_scan_hook) + #module_parser.add_post_scan_hook(post_scan_hook) + module_parser.parse_init([os.path.join(top_builddir, 'ns3', 'everything.h')], + include_paths=[top_builddir], whitelist_paths=[top_builddir], + #includes=['"ns3/everything.h"'], + pygen_sink=sections, + pygen_classifier=MyPygenClassifier(headers_map)) + module_parser.scan_types() + + callback_classes_file = open(os.path.join(os.path.dirname(pygen_file_name), "callbacks_list.py"), "wt") + scan_callback_classes(module_parser, callback_classes_file) + callback_classes_file.close() + + + module_parser.scan_methods() + module_parser.scan_functions() + module_parser.parse_finalize() + + for section in sections: + section.code_sink.file.close() + + + +if __name__ == '__main__': + ns3_module_scan(sys.argv[1], sys.argv[2]) + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/rad_util.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/rad_util.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,909 @@ +# Copyright (c) 2007 RADLogic +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +"""Provide various handy Python functions. + +Running this script directly will execute the doctests. + +Functions: +int2bin(i, n) -- Convert integer to binary string. +bin2int(bin_string) -- Convert binary string to integer. +reverse(input_string) -- Reverse a string. +transpose(matrix) -- Transpose a list of lists. +polygon_area(points_list) -- Calculate the area of an arbitrary polygon. +timestamp() -- Return string containing current time stamp. +pt2str(point) -- Return prettier string version of point tuple. +gcf(a, b) -- Return the greatest common factor of two numbers. +lcm(a, b) -- Return the least common multiple of two numbers. +permutations(input_list) -- Generate all permutations of a list of items. +reduce_fraction(fraction) -- Reduce fraction (num, denom) to simplest form. +quantile(l, p) -- Return p quantile of list l. E.g. p=0.25 for q1. +trim(l) -- Discard values in list more than 1.5*IQR outside IQR. +nice_units(value) -- Return value converted to human readable units. +uniquify(seq) -- Return sequence with duplicate items in sequence seq removed. +reverse_dict(d) -- Return the dictionary with the items as keys and vice-versa. +lsb(x, n) -- Return the n least significant bits of x. +gray_encode(i) -- Gray encode the given integer. +random_vec(bits, max_value=None) -- Return a random binary vector. +binary_range(bits) -- Return list of all possible binary numbers width=bits. +float_range([start], stop, [step]) -- Return range of floats. +find_common_fixes(s1, s2) -- Find common (prefix, suffix) of two strings. +is_rotated(seq1, seq2) -- Return true if the list is a rotation of other list. +getmodule(obj) -- Return the module that contains the object definition of obj. + (use inspect.getmodule instead, though) +get_args(argv) -- Store command-line args in a dictionary. + +This module requires Python >= 2.2 + +""" +__author__ = 'Tim Wegener ' +__date__ = '$Date: 2007/03/27 03:15:06 $' +__version__ = '$Revision: 0.45 $' +__credits__ = """ + David Chandler, for polygon area algorithm. + (http://www.davidchandler.com/AreaOfAGeneralPolygon.pdf) + """ + +import re +import sys +import time +import random + +try: + True, False +except NameError: + True, False = (1==1, 0==1) + + +def int2bin(i, n): + """Convert decimal integer i to n-bit binary number (string). + + >>> int2bin(0, 8) + '00000000' + + >>> int2bin(123, 8) + '01111011' + + >>> int2bin(123L, 8) + '01111011' + + >>> int2bin(15, 2) + Traceback (most recent call last): + ValueError: Value too large for given number of bits. + + """ + hex2bin = {'0': '0000', '1': '0001', '2': '0010', '3': '0011', + '4': '0100', '5': '0101', '6': '0110', '7': '0111', + '8': '1000', '9': '1001', 'a': '1010', 'b': '1011', + 'c': '1100', 'd': '1101', 'e': '1110', 'f': '1111'} + # Convert to hex then map each hex digit to binary equivalent. + result = ''.join([hex2bin[x] for x in hex(i).lower().replace('l','')[2:]]) + + # Shrink result to appropriate length. + # Raise an error if the value is changed by the truncation. + if '1' in result[:-n]: + raise ValueError("Value too large for given number of bits.") + result = result[-n:] + # Zero-pad if length longer than mapped result. + result = '0'*(n-len(result)) + result + return result + + +def bin2int(bin_string): + """Convert binary number string to decimal integer. + + Note: Python > v2 has int(bin_string, 2) + + >>> bin2int('1111') + 15 + + >>> bin2int('0101') + 5 + + """ +## result = 0 +## bin_list = list(bin_string) +## if len(filter(lambda x: x in ('1','0'), bin_list)) < len(bin_list): +## raise Exception ("bin2int: Error - not a binary number: %s" +## % bin_string) +## bit_list = map(int, bin_list) +## bit_list.reverse() # Make most significant bit have highest index. +## for bit_place in range(len(bit_list)): +## result = result + ((2**bit_place) * bit_list[bit_place]) +## return result + return int(bin_string, 2) + + +def reverse(input_string): + """Reverse a string. Useful for strings of binary numbers. + + >>> reverse('abc') + 'cba' + + """ + str_list = list(input_string) + str_list.reverse() + return ''.join(str_list) + + +def transpose(matrix): + """Transpose a list of lists. + + >>> transpose([['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]) + [['a', 'd', 'g'], ['b', 'e', 'h'], ['c', 'f', 'i']] + + >>> transpose([['a', 'b', 'c'], ['d', 'e', 'f']]) + [['a', 'd'], ['b', 'e'], ['c', 'f']] + + >>> transpose([['a', 'b'], ['d', 'e'], ['g', 'h']]) + [['a', 'd', 'g'], ['b', 'e', 'h']] + + """ + result = zip(*matrix) + # Convert list of tuples to list of lists. + # map is faster than a list comprehension since it is being used with + # a built-in function as an argument. + result = map(list, result) + return result + + +def polygon_area(points_list, precision=100): + """Calculate area of an arbitrary polygon using an algorithm from the web. + + Return the area of the polygon as a positive float. + + Arguments: + points_list -- list of point tuples [(x0, y0), (x1, y1), (x2, y2), ...] + (Unclosed polygons will be closed automatically. + precision -- Internal arithmetic precision (integer arithmetic). + + >>> polygon_area([(0, 0), (0, 1), (1, 1), (1, 2), (2, 2), (2, 0), (0, 0)]) + 3.0 + + Credits: + Area of a General Polygon by David Chandler + http://www.davidchandler.com/AreaOfAGeneralPolygon.pdf + + """ + # Scale up co-ordinates and convert them to integers. + for i in range(len(points_list)): + points_list[i] = (int(points_list[i][0] * precision), + int(points_list[i][1] * precision)) + # Close polygon if not closed. + if points_list[-1] != points_list[0]: + points_list.append(points_list[0]) + # Calculate area. + area = 0 + for i in range(len(points_list)-1): + (x_i, y_i) = points_list[i] + (x_i_plus_1, y_i_plus_1) = points_list[i+1] + area = area + (x_i_plus_1 * y_i) - (y_i_plus_1 * x_i) + area = abs(area / 2) + # Unscale area. + area = float(area)/(precision**2) + return area + + +def timestamp(): + """Return string containing current time stamp. + + Note: In Python 2 onwards can use time.asctime() with no arguments. + + """ + + return time.asctime() + + +def pt2str(point): + """Return prettier string version of point tuple. + + >>> pt2str((1.8, 1.9)) + '(1.8, 1.9)' + + """ + return "(%s, %s)" % (str(point[0]), str(point[1])) + + +def gcf(a, b, epsilon=1e-16): + """Return the greatest common factor of a and b, using Euclidean algorithm. + + Arguments: + a, b -- two numbers + If both numbers are integers return an integer result, + otherwise return a float result. + epsilon -- floats less than this magnitude are considered to be zero + (default: 1e-16) + + Examples: + + >>> gcf(12, 34) + 2 + + >>> gcf(13.5, 4) + 0.5 + + >>> gcf(-2, 4) + 2 + + >>> gcf(5, 0) + 5 + + By (a convenient) definition: + >>> gcf(0, 0) + 0 + + """ + result = max(a, b) + remainder = min(a, b) + while remainder and abs(remainder) > epsilon: + new_remainder = result % remainder + result = remainder + remainder = new_remainder + return abs(result) + +def lcm(a, b, precision=None): + """Return the least common multiple of a and b, using the gcf function. + + Arguments: + a, b -- two numbers. If both are integers return an integer result, + otherwise a return a float result. + precision -- scaling factor if a and/or b are floats. + + >>> lcm(21, 6) + 42 + + >>> lcm(2.5, 3.5) + 17.5 + + >>> str(lcm(1.5e-8, 2.5e-8, precision=1e9)) + '7.5e-08' + + By (an arbitary) definition: + >>> lcm(0, 0) + 0 + + """ + # Note: Dummy precision argument is for backwards compatibility. + # Do the division first. + # (See http://en.wikipedia.org/wiki/Least_common_multiple ) + denom = gcf(a, b) + if denom == 0: + result = 0 + else: + result = a * (b / denom) + return result + + +def permutations(input_list): + """Return a list containing all permutations of the input list. + + Note: This is a recursive function. + + >>> perms = permutations(['a', 'b', 'c']) + >>> perms.sort() + >>> for perm in perms: + ... print perm + ['a', 'b', 'c'] + ['a', 'c', 'b'] + ['b', 'a', 'c'] + ['b', 'c', 'a'] + ['c', 'a', 'b'] + ['c', 'b', 'a'] + + """ + out_lists = [] + if len(input_list) > 1: + # Extract first item in list. + item = input_list[0] + # Find all permutations of remainder of list. (Recursive call.) + sub_lists = permutations(input_list[1:]) + # For every permutation of the sub list... + for sub_list in sub_lists: + # Insert the extracted first item at every position of the list. + for i in range(len(input_list)): + new_list = sub_list[:] + new_list.insert(i, item) + out_lists.append(new_list) + else: + # Termination condition: only one item in input list. + out_lists = [input_list] + return out_lists + + +def reduce_fraction(fraction): + """Reduce fraction tuple to simplest form. fraction=(num, denom) + + >>> reduce_fraction((14, 7)) + (2, 1) + + >>> reduce_fraction((-2, 4)) + (-1, 2) + + >>> reduce_fraction((0, 4)) + (0, 1) + + >>> reduce_fraction((4, 0)) + (1, 0) + + """ + (numerator, denominator) = fraction + common_factor = abs(gcf(numerator, denominator)) + result = (numerator/common_factor, denominator/common_factor) + return result + + +def quantile(l, p): + """Return p quantile of list l. E.g. p=0.25 for q1. + + See: + http://rweb.stat.umn.edu/R/library/base/html/quantile.html + + """ + l_sort = l[:] + l_sort.sort() + n = len(l) + r = 1 + ((n - 1) * p) + i = int(r) + f = r - i + if i < n: + result = (1-f)*l_sort[i-1] + f*l_sort[i] + else: + result = l_sort[i-1] + return result + + +def trim(l): + """Discard values in list more than 1.5*IQR outside IQR. + + (IQR is inter-quartile-range) + + This function uses rad_util.quantile + + 1.5*IQR -- mild outlier + 3*IQR -- extreme outlier + + See: + http://wind.cc.whecn.edu/~pwildman/statnew/section_7_-_exploratory_data_analysis.htm + + """ + l_sort = l[:] + l_sort.sort() + # Calculate medianscore (based on stats.py lmedianscore by Gary Strangman) + if len(l_sort) % 2 == 0: + # If even number of scores, average middle 2. + index = int(len(l_sort) / 2) # Integer division correct + median = float(l_sort[index] + l_sort[index-1]) / 2 + else: + # int divsion gives mid value when count from 0 + index = int(len(l_sort) / 2) + median = l_sort[index] + # Calculate IQR. + q1 = quantile(l_sort, 0.25) + q3 = quantile(l_sort, 0.75) + iqr = q3 - q1 + iqr_extra = iqr * 1.5 + def in_interval(x, i=iqr_extra, q1=q1, q3=q3): + return (x >= q1-i and x <= q3+i) + l_trimmed = [x for x in l_sort if in_interval(x)] + return l_trimmed + + +def nice_units(value, dp=0, sigfigs=None, suffix='', space=' ', + use_extra_prefixes=False, use_full_name=False, mode='si'): + """Return value converted to human readable units eg milli, micro, etc. + + Arguments: + value -- number in base units + dp -- number of decimal places to display (rounded) + sigfigs -- number of significant figures to display (rounded) + This overrides dp if set. + suffix -- optional unit suffix to append to unit multiplier + space -- seperator between value and unit multiplier (default: ' ') + use_extra_prefixes -- use hecto, deka, deci and centi as well if set. + (default: False) + use_full_name -- use full name for multiplier symbol, + e.g. milli instead of m + (default: False) + mode -- 'si' for SI prefixes, 'bin' for binary multipliers (1024, etc.) + (Default: 'si') + + SI prefixes from: + http://physics.nist.gov/cuu/Units/prefixes.html + (Greek mu changed to u.) + Binary prefixes based on: + http://physics.nist.gov/cuu/Units/binary.html + + >>> nice_units(2e-11) + '20 p' + + >>> nice_units(2e-11, space='') + '20p' + + """ + si_prefixes = {1e24: ('Y', 'yotta'), + 1e21: ('Z', 'zetta'), + 1e18: ('E', 'exa'), + 1e15: ('P', 'peta'), + 1e12: ('T', 'tera'), + 1e9: ('G', 'giga'), + 1e6: ('M', 'mega'), + 1e3: ('k', 'kilo'), + 1e-3: ('m', 'milli'), + 1e-6: ('u', 'micro'), + 1e-9: ('n', 'nano'), + 1e-12: ('p', 'pico'), + 1e-15: ('f', 'femto'), + 1e-18: ('a', 'atto'), + 1e-21: ('z', 'zepto'), + 1e-24: ('y', 'yocto') + } + if use_extra_prefixes: + si_prefixes.update({1e2: ('h', 'hecto'), + 1e1: ('da', 'deka'), + 1e-1: ('d', 'deci'), + 1e-2: ('c', 'centi') + }) + bin_prefixes = {2**10: ('K', 'kilo'), + 2**20: ('M', 'mega'), + 2**30: ('G', 'mega'), + 2**40: ('T', 'tera'), + 2**50: ('P', 'peta'), + 2**60: ('E', 'exa') + } + if mode == 'bin': + prefixes = bin_prefixes + else: + prefixes = si_prefixes + prefixes[1] = ('', '') # Unity. + # Determine appropriate multiplier. + multipliers = prefixes.keys() + multipliers.sort() + mult = None + for i in range(len(multipliers) - 1): + lower_mult = multipliers[i] + upper_mult = multipliers[i+1] + if lower_mult <= value < upper_mult: + mult_i = i + break + if mult is None: + if value < multipliers[0]: + mult_i = 0 + elif value >= multipliers[-1]: + mult_i = len(multipliers) - 1 + mult = multipliers[mult_i] + # Convert value for this multiplier. + new_value = value / mult + # Deal with special case due to rounding. + if sigfigs is None: + if mult_i < (len(multipliers) - 1) and \ + round(new_value, dp) == \ + round((multipliers[mult_i+1] / mult), dp): + mult = multipliers[mult_i + 1] + new_value = value / mult + # Concatenate multiplier symbol. + if use_full_name: + label_type = 1 + else: + label_type = 0 + # Round and truncate to appropriate precision. + if sigfigs is None: + str_value = eval('"%.'+str(dp)+'f" % new_value', locals(), {}) + else: + str_value = eval('"%.'+str(sigfigs)+'g" % new_value', locals(), {}) + return str_value + space + prefixes[mult][label_type] + suffix + + +def uniquify(seq, preserve_order=False): + """Return sequence with duplicate items in sequence seq removed. + + The code is based on usenet post by Tim Peters. + + This code is O(N) if the sequence items are hashable, O(N**2) if not. + + Peter Bengtsson has a blog post with an empirical comparison of other + approaches: + http://www.peterbe.com/plog/uniqifiers-benchmark + + If order is not important and the sequence items are hashable then + list(set(seq)) is readable and efficient. + + If order is important and the sequence items are hashable generator + expressions can be used (in py >= 2.4) (useful for large sequences): + seen = set() + do_something(x for x in seq if x not in seen or seen.add(x)) + + Arguments: + seq -- sequence + preserve_order -- if not set the order will be arbitrary + Using this option will incur a speed penalty. + (default: False) + + Example showing order preservation: + + >>> uniquify(['a', 'aa', 'b', 'b', 'ccc', 'ccc', 'd'], preserve_order=True) + ['a', 'aa', 'b', 'ccc', 'd'] + + Example using a sequence of un-hashable items: + + >>> uniquify([['z'], ['x'], ['y'], ['z']], preserve_order=True) + [['z'], ['x'], ['y']] + + The sorted output or the non-order-preserving approach should equal + that of the sorted order-preserving approach output: + + >>> unordered = uniquify([3, 3, 1, 2], preserve_order=False) + >>> unordered.sort() + >>> ordered = uniquify([3, 3, 1, 2], preserve_order=True) + >>> ordered.sort() + >>> ordered + [1, 2, 3] + >>> int(ordered == unordered) + 1 + + """ + try: + # Attempt fast algorithm. + d = {} + if preserve_order: + # This is based on Dave Kirby's method (f8) noted in the post: + # http://www.peterbe.com/plog/uniqifiers-benchmark + return [x for x in seq if (x not in d) and not d.__setitem__(x, 0)] + else: + for x in seq: + d[x] = 0 + return d.keys() + except TypeError: + # Have an unhashable object, so use slow algorithm. + result = [] + app = result.append + for x in seq: + if x not in result: + app(x) + return result + +# Alias to noun form for backward compatibility. +unique = uniquify + + +def reverse_dict(d): + """Reverse a dictionary so the items become the keys and vice-versa. + + Note: The results will be arbitrary if the items are not unique. + + >>> d = reverse_dict({'a': 1, 'b': 2}) + >>> d_items = d.items() + >>> d_items.sort() + >>> d_items + [(1, 'a'), (2, 'b')] + + """ + result = {} + for key, value in d.items(): + result[value] = key + return result + + +def lsb(x, n): + """Return the n least significant bits of x. + + >>> lsb(13, 3) + 5 + + """ + return x & ((2 ** n) - 1) + + +def gray_encode(i): + """Gray encode the given integer.""" + + return i ^ (i >> 1) + + +def random_vec(bits, max_value=None): + """Generate a random binary vector of length bits and given max value.""" + + vector = "" + for _ in range(int(bits / 10) + 1): + i = int((2**10) * random.random()) + vector += int2bin(i, 10) + + if max_value and (max_value < 2 ** bits - 1): + vector = int2bin((int(vector, 2) / (2 ** bits - 1)) * max_value, bits) + + return vector[0:bits] + + +def binary_range(bits): + """Return a list of all possible binary numbers in order with width=bits. + + It would be nice to extend it to match the + functionality of python's range() built-in function. + + """ + l = [] + v = ['0'] * bits + + toggle = [1] + [0] * bits + + while toggle[bits] != 1: + v_copy = v[:] + v_copy.reverse() + l.append(''.join(v_copy)) + + toggle = [1] + [0]*bits + i = 0 + while i < bits and toggle[i] == 1: + if toggle[i]: + if v[i] == '0': + v[i] = '1' + toggle[i+1] = 0 + else: + v[i] = '0' + toggle[i+1] = 1 + i += 1 + return l + + +def float_range(start, stop=None, step=None): + """Return a list containing an arithmetic progression of floats. + + Return a list of floats between 0.0 (or start) and stop with an + increment of step. + + This is in functionality to python's range() built-in function + but can accept float increments. + + As with range(), stop is omitted from the list. + + """ + if stop is None: + stop = float(start) + start = 0.0 + + if step is None: + step = 1.0 + + cur = float(start) + l = [] + while cur < stop: + l.append(cur) + cur += step + + return l + + +def find_common_fixes(s1, s2): + """Find common (prefix, suffix) of two strings. + + >>> find_common_fixes('abc', 'def') + ('', '') + + >>> find_common_fixes('abcelephantdef', 'abccowdef') + ('abc', 'def') + + >>> find_common_fixes('abcelephantdef', 'abccow') + ('abc', '') + + >>> find_common_fixes('elephantdef', 'abccowdef') + ('', 'def') + + """ + prefix = [] + suffix = [] + + i = 0 + common_len = min(len(s1), len(s2)) + while i < common_len: + if s1[i] != s2[i]: + break + + prefix.append(s1[i]) + i += 1 + + i = 1 + while i < (common_len + 1): + if s1[-i] != s2[-i]: + break + + suffix.append(s1[-i]) + i += 1 + + suffix.reverse() + + prefix = ''.join(prefix) + suffix = ''.join(suffix) + + return (prefix, suffix) + + +def is_rotated(seq1, seq2): + """Return true if the first sequence is a rotation of the second sequence. + + >>> seq1 = ['A', 'B', 'C', 'D'] + >>> seq2 = ['C', 'D', 'A', 'B'] + >>> int(is_rotated(seq1, seq2)) + 1 + + >>> seq2 = ['C', 'D', 'B', 'A'] + >>> int(is_rotated(seq1, seq2)) + 0 + + >>> seq1 = ['A', 'B', 'C', 'A'] + >>> seq2 = ['A', 'A', 'B', 'C'] + >>> int(is_rotated(seq1, seq2)) + 1 + + >>> seq2 = ['A', 'B', 'C', 'A'] + >>> int(is_rotated(seq1, seq2)) + 1 + + >>> seq2 = ['A', 'A', 'C', 'B'] + >>> int(is_rotated(seq1, seq2)) + 0 + + """ + # Do a sanity check. + if len(seq1) != len(seq2): + return False + # Look for occurrences of second sequence head item in first sequence. + start_indexes = [] + head_item = seq2[0] + for index1 in range(len(seq1)): + if seq1[index1] == head_item: + start_indexes.append(index1) + # Check that wrapped sequence matches. + double_seq1 = seq1 + seq1 + for index1 in start_indexes: + if double_seq1[index1:index1+len(seq1)] == seq2: + return True + return False + +def getmodule(obj): + """Return the module that contains the object definition of obj. + + Note: Use inspect.getmodule instead. + + Arguments: + obj -- python obj, generally a class or a function + + Examples: + + A function: + >>> module = getmodule(random.choice) + >>> module.__name__ + 'random' + >>> module is random + 1 + + A class: + >>> module = getmodule(random.Random) + >>> module.__name__ + 'random' + >>> module is random + 1 + + A class inheriting from a class in another module: + (note: The inheriting class must define at least one function.) + >>> class MyRandom(random.Random): + ... def play(self): + ... pass + >>> module = getmodule(MyRandom) + >>> if __name__ == '__main__': + ... name = 'rad_util' + ... else: + ... name = module.__name__ + >>> name + 'rad_util' + >>> module is sys.modules[__name__] + 1 + + Discussion: + This approach is slightly hackish, and won't work in various situations. + However, this was the approach recommended by GvR, so it's as good as + you'll get. + + See GvR's post in this thread: + http://groups.google.com.au/group/comp.lang.python/browse_thread/thread/966a7bdee07e3b34/c3cab3f41ea84236?lnk=st&q=python+determine+class+module&rnum=4&hl=en#c3cab3f41ea84236 + + """ + if hasattr(obj, 'func_globals'): + func = obj + else: + # Handle classes. + func = None + for item in obj.__dict__.values(): + if hasattr(item, 'func_globals'): + func = item + break + if func is None: + raise ValueError("No functions attached to object: %r" % obj) + module_name = func.func_globals['__name__'] + # Get module. + module = sys.modules[module_name] + return module + + +def round_grid(value, grid, mode=0): + """Round off the given value to the given grid size. + + Arguments: + value -- value to be roudne + grid -- result must be a multiple of this + mode -- 0 nearest, 1 up, -1 down + + Examples: + + >>> round_grid(7.5, 5) + 10 + + >>> round_grid(7.5, 5, mode=-1) + 5 + + >>> round_grid(7.3, 5, mode=1) + 10 + + >>> round_grid(7.3, 5.0, mode=1) + 10.0 + + """ + off_grid = value % grid + if mode == 0: + add_one = int(off_grid >= (grid / 2.0)) + elif mode == 1 and off_grid: + add_one = 1 + elif mode == -1 and off_grid: + add_one = 0 + result = ((int(value / grid) + add_one) * grid) + return result + + +def get_args(argv): + """Store command-line args in a dictionary. + + -, -- prefixes are removed + Items not prefixed with - or -- are stored as a list, indexed by 'args' + + For options that take a value use --option=value + + Consider using optparse or getopt (in Python standard library) instead. + + """ + d = {} + args = [] + + for arg in argv: + + if arg.startswith('-'): + parts = re.sub(r'^-+', '', arg).split('=') + if len(parts) == 2: + d[parts[0]] = parts[1] + else: + d[parts[0]] = None + else: + args.append(arg) + + d['args'] = args + + return d + + +if __name__ == '__main__': + import doctest + doctest.testmod(sys.modules['__main__']) + diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/topsort.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/topsort.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,392 @@ +# topsort - dependency (topological) sorting and cycle finding functions +# Copyright (C) 2007 RADLogic +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# See http://www.fsf.org/licensing/licenses/lgpl.txt for full license text. +"""Provide toplogical sorting (i.e. dependency sorting) functions. + +The topsort function is based on code posted on Usenet by Tim Peters. + +Modifications: +- added doctests +- changed some bits to use current Python idioms + (listcomp instead of filter, +=/-=, inherit from Exception) +- added a topsort_levels version that ports items in each dependency level + into a sub-list +- added find_cycles to aid in cycle debugging + +Run this module directly to run the doctests (unittests). +Make sure they all pass before checking in any modifications. + +Requires Python >= 2.2 +(For Python 2.2 also requires separate sets.py module) + +This requires the rad_util.py module. + +""" + +# Provide support for Python 2.2* +from __future__ import generators + +__version__ = '$Revision: 0.9 $' +__date__ = '$Date: 2007/03/27 04:15:26 $' +__credits__ = '''Tim Peters -- original topsort code +Tim Wegener -- doctesting, updating to current idioms, topsort_levels, + find_cycles +''' + +# Make Python 2.3 sets look like Python 2.4 sets. +try: + set +except NameError: + from sets import Set as set + +from rad_util import is_rotated + + +class CycleError(Exception): + """Cycle Error""" + pass + + +def topsort(pairlist): + """Topologically sort a list of (parent, child) pairs. + + Return a list of the elements in dependency order (parent to child order). + + >>> print topsort( [(1,2), (3,4), (5,6), (1,3), (1,5), (1,6), (2,5)] ) + [1, 2, 3, 5, 4, 6] + + >>> print topsort( [(1,2), (1,3), (2,4), (3,4), (5,6), (4,5)] ) + [1, 2, 3, 4, 5, 6] + + >>> print topsort( [(1,2), (2,3), (3,2)] ) + Traceback (most recent call last): + CycleError: ([1], {2: 1, 3: 1}, {2: [3], 3: [2]}) + + """ + num_parents = {} # element -> # of predecessors + children = {} # element -> list of successors + for parent, child in pairlist: + # Make sure every element is a key in num_parents. + if not num_parents.has_key( parent ): + num_parents[parent] = 0 + if not num_parents.has_key( child ): + num_parents[child] = 0 + + # Since child has a parent, increment child's num_parents count. + num_parents[child] += 1 + + # ... and parent gains a child. + children.setdefault(parent, []).append(child) + + # Suck up everything without a parent. + answer = [x for x in num_parents.keys() if num_parents[x] == 0] + + # For everything in answer, knock down the parent count on its children. + # Note that answer grows *in* the loop. + for parent in answer: + del num_parents[parent] + if children.has_key( parent ): + for child in children[parent]: + num_parents[child] -= 1 + if num_parents[child] == 0: + answer.append( child ) + # Following "del" isn't needed; just makes + # CycleError details easier to grasp. + del children[parent] + + if num_parents: + # Everything in num_parents has at least one child -> + # there's a cycle. + raise CycleError(answer, num_parents, children) + return answer + +def topsort_levels(pairlist): + """Topologically sort a list of (parent, child) pairs into depth levels. + + This returns a generator. + Turn this into a an iterator using the iter built-in function. + (if you iterate over the iterator, each element gets generated when + it is asked for, rather than generating the whole list up-front.) + + Each generated element is a list of items at that dependency level. + + >>> dependency_pairs = [(1,2), (3,4), (5,6), (1,3), (1,5), (1,6), (2,5)] + >>> for level in iter(topsort_levels( dependency_pairs )): + ... print level + [1] + [2, 3] + [4, 5] + [6] + + >>> dependency_pairs = [(1,2), (1,3), (2,4), (3,4), (5,6), (4,5)] + >>> for level in iter(topsort_levels( dependency_pairs )): + ... print level + [1] + [2, 3] + [4] + [5] + [6] + + >>> dependency_pairs = [(1,2), (2,3), (3,4), (4, 3)] + >>> try: + ... for level in iter(topsort_levels( dependency_pairs )): + ... print level + ... except CycleError, exc: + ... print 'CycleError:', exc + [1] + [2] + CycleError: ({3: 1, 4: 1}, {3: [4], 4: [3]}) + + + The cycle error should look like. + CycleError: ({3: 1, 4: 1}, {3: [4], 4: [3]}) + # todo: Make the doctest more robust (i.e. handle arbitrary dict order). + + """ + num_parents = {} # element -> # of predecessors + children = {} # element -> list of successors + for parent, child in pairlist: + # Make sure every element is a key in num_parents. + if not num_parents.has_key( parent ): + num_parents[parent] = 0 + if not num_parents.has_key( child ): + num_parents[child] = 0 + + # Since child has a parent, increment child's num_parents count. + num_parents[child] += 1 + + # ... and parent gains a child. + children.setdefault(parent, []).append(child) + + return topsort_levels_core(num_parents, children) + +def topsort_levels_core(num_parents, children): + """Topologically sort a bunch of interdependent items based on dependency. + + This returns a generator. + Turn this into a an iterator using the iter built-in function. + (if you iterate over the iterator, each element gets generated when + it is asked for, rather than generating the whole list up-front.) + + Each generated element is a list of items at that dependency level. + + >>> list(topsort_levels_core( + ... {1: 0, 2: 1, 3: 1, 4: 1, 5: 2, 6: 2}, + ... {1: [2, 3, 5, 6], 2: [5], 3: [4], 4: [], 5: [6]})) + [[1], [2, 3], [4, 5], [6]] + + >>> list(topsort_levels_core( + ... {1: 0, 2: 2, 3: 1}, + ... {1: [2], 2: [3], 3: [2]})) + Traceback (most recent call last): + CycleError: ({2: 1, 3: 1}, {2: [3], 3: [2]}) + + This function has a more complicated interface than topsort_levels, + but is useful if the data is easier to generate in this form. + + Arguments: + num_parents -- key: item, value: number of parents (predecessors) + children -- key: item, value: list of children (successors) + + """ + while 1: + # Suck up everything without a predecessor. + level_parents = [x for x in num_parents.keys() if num_parents[x] == 0] + + if not level_parents: + break + + # Offer the next generated item, + # which is a list of the items at this dependency level. + yield level_parents + + # For everything item in this level, + # decrement the parent count, + # since we have accounted for its parent. + for level_parent in level_parents: + + del num_parents[level_parent] + + if children.has_key(level_parent): + for level_parent_child in children[level_parent]: + num_parents[level_parent_child] -= 1 + del children[level_parent] + + if num_parents: + # Everything in num_parents has at least one child -> + # there's a cycle. + raise CycleError(num_parents, children) + else: + # This is the end of the generator. + raise StopIteration + + +def find_cycles(parent_children): + """Yield cycles. Each result is a list of items comprising a cycle. + + Use a 'stack' based approach to find all the cycles. + This is a generator, so yields each cycle as it finds it. + + It is implicit that the last item in each cycle list is a parent of the + first item (thereby forming a cycle). + + Arguments: + parent_children -- parent -> collection of children + + Simplest cycle: + >>> cycles = list(find_cycles({'A': ['B'], 'B': ['A']})) + >>> len(cycles) + 1 + >>> cycle = cycles[0] + >>> cycle.sort() + >>> print cycle + ['A', 'B'] + + Simplest cycle with extra baggage at the start and the end: + >>> cycles = list(find_cycles(parent_children={'A': ['B'], + ... 'B': ['C'], + ... 'C': ['B', 'D'], + ... 'D': [], + ... })) + >>> len(cycles) + 1 + >>> cycle = cycles[0] + >>> cycle.sort() + >>> print cycle + ['B', 'C'] + + Double cycle: + >>> cycles = list(find_cycles(parent_children={'A': ['B'], + ... 'B': ['C1', 'C2'], + ... 'C1': ['D1'], + ... 'D1': ['E1'], + ... 'E1': ['D1'], + ... 'C2': ['D2'], + ... 'D2': ['E2'], + ... 'E2': ['D2'], + ... })) + >>> len(cycles) + 2 + >>> for cycle in cycles: + ... cycle.sort() + >>> cycles.sort() + >>> cycle1 = cycles[0] + >>> cycle1.sort() + >>> print cycle1 + ['D1', 'E1'] + >>> cycle2 = cycles[1] + >>> cycle2.sort() + >>> print cycle2 + ['D2', 'E2'] + + Simple cycle with children not specified for one item: + # todo: Should this barf instead? + >>> cycles = list(find_cycles(parent_children={'A': ['B'], + ... 'B': ['A'], + ... 'C': ['D']})) + >>> len(cycles) + 1 + >>> cycle = cycles[0] + >>> cycle.sort() + >>> print cycle + ['A', 'B'] + + Diamond cycle + >>> cycles = list(find_cycles(parent_children={'A': ['B1', 'B2'], + ... 'B1': ['C'], + ... 'B2': ['C'], + ... 'C': ['A', 'B1']})) + >>> len(cycles) + 3 + >>> sorted_cycles = [] + >>> for cycle in cycles: + ... cycle = list(cycle) + ... cycle.sort() + ... sorted_cycles.append(cycle) + >>> sorted_cycles.sort() + >>> for cycle in sorted_cycles: + ... print cycle + ['A', 'B1', 'C'] + ['A', 'B2', 'C'] + ['B1', 'C'] + + Hairy case (order can matter if something is wrong): + (Note order of B and C in the list.) + >>> cycles = list(find_cycles(parent_children={ + ... 'TD': ['DD'], + ... 'TC': ['DC'], + ... 'DC': ['DQ'], + ... 'C': ['DQ'], + ... 'DQ': ['IA', 'TO'], + ... 'IA': ['A'], + ... 'A': ['B', 'C'], + ... })) + >>> len(cycles) + 1 + >>> cycle = cycles[0] + >>> cycle.sort() + >>> print cycle + ['A', 'C', 'DQ', 'IA'] + + """ + cycles = [] + visited_nodes = set() + + for parent in parent_children: + if parent in visited_nodes: + # This node is part of a path that has already been traversed. + continue + + paths = [[parent]] + while paths: + path = paths.pop() + + parent = path[-1] + + try: + children = parent_children[parent] + except KeyError: + continue + + for child in children: + # Keeping a set of the path nodes, for O(1) lookups at the + # expense of more memory and complexity, actually makes speed + # worse. (Due to construction of sets.) + # This is O(N). + if child in path: + # This is a cycle. + cycle = path[path.index(child):] + # Check that this is not a dup cycle. + is_dup = False + for other_cycle in cycles: + if is_rotated(other_cycle, cycle): + is_dup = True + break + if not is_dup: + cycles.append(cycle) + yield cycle + else: + # Push this new path onto the 'stack'. + # This is probably the most expensive part of the algorithm + # (a list copy). + paths.append(path + [child]) + # Mark the node as visited. + visited_nodes.add(child) + + +if __name__ == '__main__': + # Run the doctest tests. + import sys + import doctest + doctest.testmod(sys.modules['__main__']) diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/waf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/waf Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,1 @@ +exec "`dirname "$0"`"/../../waf "$@" \ No newline at end of file diff -r 0d83aa14b65d -r 2cc40b3e4fa5 bindings/python/wscript --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bindings/python/wscript Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,367 @@ +## -*- Mode: python; py-indent-offset: 4; indent-tabs-mode: nil; coding: utf-8; -*- + +import re +import Params +import Configure +import Object +import Action +import os +import Task +import pproc as subprocess +from Params import fatal, warning +import shutil + +## Adjust python path to look for our local copy of pybindgen +LOCAL_PYBINDGEN_PATH = os.path.join(os.getcwd(), "bindings", "python", "pybindgen") +#PYBINDGEN_BRANCH = 'lp:pybindgen' +PYBINDGEN_BRANCH = 'https://launchpad.net/pybindgen' +if os.environ.get('PYTHONPATH', ''): + os.environ['PYTHONPATH'] = LOCAL_PYBINDGEN_PATH + os.pathsep + os.environ.get('PYTHONPATH') +else: + os.environ['PYTHONPATH'] = LOCAL_PYBINDGEN_PATH + +## https://launchpad.net/pybindgen/ +REQUIRED_PYBINDGEN_VERSION = (0, 8, 0, 475) +REQUIRED_PYGCCXML_VERSION = (0, 9, 5) + + +def set_options(opt): + opt.tool_options('python') + opt.add_option('--python-disable', + help=("Don't build Python bindings."), + action="store_true", default=False, + dest='python_disable') + opt.add_option('--python-scan', + help=("Rescan Python bindings. Needs working GCCXML / pygccxml environment."), + action="store_true", default=False, + dest='python_scan') + opt.add_option('--pybindgen-checkout', + help=("During configure, force checkout of pybingen inside ns-3, " + "instead of using the system installed version."), + action="store_true", default=False, + dest='pybindgen_checkout') + +def fetch_pybindgen(conf): + """ + Fetches pybindgen from launchpad as bindings/python/pybindgen. + Returns True if successful, False it not. + """ + bzr = conf.find_program("bzr") + if not bzr: + warning("the program 'bzr' is needed in order to fetch pybindgen") + return False + if len(REQUIRED_PYBINDGEN_VERSION) == 4: + rev = "-rrevno:%i" % REQUIRED_PYBINDGEN_VERSION[3] + else: + rev = "-rtag:%s" % '.'.join([str(x) for x in REQUIRED_PYBINDGEN_VERSION]) + if os.path.exists(LOCAL_PYBINDGEN_PATH): + print "Trying to update pybindgen; this will fail if no network connection is available." + + cmd = [bzr, "pull", rev, PYBINDGEN_BRANCH] + print " => ", ' '.join(cmd) + if subprocess.Popen(cmd, cwd=LOCAL_PYBINDGEN_PATH).wait(): + return False + print "Update was successful." + else: + print "Trying to fetch pybindgen; this will fail if no network connection is available." + cmd = [bzr, "checkout", rev, PYBINDGEN_BRANCH, LOCAL_PYBINDGEN_PATH] + print " => ", ' '.join(cmd) + if subprocess.Popen(cmd).wait(): + return False + print "Fetch was successful." + + ## generate a fake version.py file in pybindgen it's safer this + ## way, since the normal version generation process requires + ## bazaar python bindings, which may not be available. + vfile = open(os.path.join(LOCAL_PYBINDGEN_PATH, "pybindgen", "version.py"), "wt") + vfile.write(""" +# (fake version generated by ns-3) +__version__ = %r +""" % list(REQUIRED_PYBINDGEN_VERSION)) + vfile.close() + + return True + + +def configure(conf): + conf.env['ENABLE_PYTHON_BINDINGS'] = False + if Params.g_options.python_disable: + return + + conf.check_tool('misc') + + ## Check for Python + try: + conf.check_tool('python') + conf.check_python_version((2,4,2)) + conf.check_python_headers() + except Configure.ConfigurationError: + return + + ## Check for pybindgen + if Params.g_options.pybindgen_checkout: + fetch_pybindgen(conf) + + try: + conf.check_python_module('pybindgen') + except Configure.ConfigurationError: + warning("pybindgen missing") + if not fetch_pybindgen(conf): + return + else: + out = subprocess.Popen([conf.env['PYTHON'], "-c", + "import pybindgen.version; " + "print '.'.join([str(x) for x in pybindgen.version.__version__])"], + stdout=subprocess.PIPE).communicate()[0] + pybindgen_version_str = out.strip() + pybindgen_version = tuple([int(x) for x in pybindgen_version_str.split('.')]) + conf.check_message('pybindgen', 'version', + (pybindgen_version >= REQUIRED_PYBINDGEN_VERSION), + pybindgen_version_str) + if not (pybindgen_version >= REQUIRED_PYBINDGEN_VERSION): + warning("pybindgen (found %s) is too old (need %s)" % + (pybindgen_version_str, + '.'.join([str(x) for x in REQUIRED_PYBINDGEN_VERSION]))) + if not fetch_pybindgen(conf): + return + + ## If all has gone well, we finally enable the Python bindings + conf.env['ENABLE_PYTHON_BINDINGS'] = True + + ## Check for pygccxml + try: + conf.check_python_module('pygccxml') + except Configure.ConfigurationError: + return + + out = subprocess.Popen([conf.env['PYTHON'], "-c", + "import pygccxml; print pygccxml.__version__"], + stdout=subprocess.PIPE).communicate()[0] + pygccxml_version_str = out.strip() + pygccxml_version = tuple([int(x) for x in pygccxml_version_str.split('.')]) + conf.check_message('pygccxml', 'version', + (pygccxml_version >= REQUIRED_PYGCCXML_VERSION), + pygccxml_version_str) + if not (pygccxml_version >= REQUIRED_PYGCCXML_VERSION): + warning("pygccxml (found %s) is too old (need %s) => " + "automatic scanning of API definitions will not be possible" % + (pygccxml_version_str, + '.'.join([str(x) for x in REQUIRED_PYGCCXML_VERSION]))) + return + + + ## Check gccxml version + gccxml = conf.find_program('gccxml', var='GCCXML') + if not gccxml: + warning("gccxml missing; automatic scanning of API definitions will not be possible") + return + + gccxml_version_line = os.popen(gccxml + " --version").readline().strip() + m = re.match( "^GCC-XML version (\d\.\d(\.\d)?)$", gccxml_version_line) + gccxml_version = m.group(1) + gccxml_version_ok = ([int(s) for s in gccxml_version.split('.')] >= [0, 9]) + conf.check_message('gccxml', 'version', True, gccxml_version) + if not gccxml_version_ok: + warning("gccxml too old, need version >= 0.9; automatic scanning of API definitions will not be possible") + return + + ## If we reached + conf.env['ENABLE_PYTHON_SCANNING'] = True + + +prio_headers = { + -2: ( + "string.h", # work around http://www.gccxml.org/Bug/view.php?id=6682 + ), + -1: ( + "propagation-delay-model.h", + "propagation-loss-model.h", + "net-device.h", + ) + } + +def get_header_prio(header): + for prio, headers in prio_headers.iteritems(): + if header in headers: + return prio + return 1 + +def gen_ns3_metaheader(task): + assert len(task.m_outputs) == 1 + header_files = [os.path.basename(node.abspath(task.m_env)) for node in task.m_inputs] + outfile = file(task.m_outputs[0].bldpath(task.m_env), "w") + + def sort_func(h1, h2): + return cmp((get_header_prio(h1), h1), (get_header_prio(h1), h2)) + + header_files.sort(sort_func) + + for header in header_files: + print >> outfile, "#include \"ns3/%s\"" % (header,) + + print >> outfile, """ +namespace ns3 { +static inline Ptr +__dummy_function_to_force_template_instantiation (Ptr obj, TypeId typeId) +{ + return obj->GetObject (typeId); +} + +} +""" + outfile.close() + return 0 + + +class all_ns3_headers_taskgen(Object.task_gen): + """Generates a 'everything.h' header file that includes some/all public ns3 headers. + This single header file is to be parsed only once by gccxml, for greater efficiency. + """ + def __init__(self, *features): + Object.task_gen.__init__(self, *features) + self.inst_var = 'INCLUDEDIR' + self.inst_dir = 'ns3' + + def apply(self): + ## get all of the ns3 headers + ns3_dir_node = Params.g_build.m_srcnode.find_dir("ns3") + all_headers_inputs = [] + + for filename in self.to_list(self.source): + src_node = ns3_dir_node.find_build(filename) + if src_node is None: + Params.fatal("source ns3 header file %s not found" % (filename,)) + all_headers_inputs.append(src_node) + + ## if self.source was empty, include all ns3 headers in enabled modules + if not all_headers_inputs: + for ns3headers in Object.g_allobjs: + if type(ns3headers).__name__ == 'ns3header_taskgen': # XXX: find less hackish way to compare + ## skip headers not part of enabled modules + if self.env['NS3_ENABLED_MODULES']: + if ("ns3-%s" % ns3headers.module) not in self.env['NS3_ENABLED_MODULES']: + continue + + for source in ns3headers.to_list(ns3headers.source): + source = os.path.basename(source) + node = ns3_dir_node.find_build(os.path.basename(source)) + if node is None: + fatal("missing header file %s" % (source,)) + all_headers_inputs.append(node) + assert all_headers_inputs + all_headers_outputs = [ns3_dir_node.find_build("everything.h")] + task = self.create_task('gen-ns3-metaheader', self.env, 4) + task.set_inputs(all_headers_inputs) + task.set_outputs(all_headers_outputs) + + def install(self): + pass + + +def get_modules_and_headers(): + """ + Gets a dict of + module_name => ([module_dep1, module_dep2, ...], [module_header1, module_header2, ...]) + tuples, one for each module. + """ + + retval = {} + for module in Object.g_allobjs: + if not module.name.startswith('ns3-'): + continue + module_name = module.name[4:] # strip the ns3- prefix + ## find the headers object for this module + headers = [] + for ns3headers in Object.g_allobjs: + if type(ns3headers).__name__ != 'ns3header_taskgen': # XXX: find less hackish way to compare + continue + if ns3headers.module != module_name: + continue + for source in ns3headers.to_list(ns3headers.source): + headers.append(source) + retval[module_name] = (list(module.module_deps), headers) + return retval + + +def build(bld): + if Params.g_options.python_disable: + return + + env = bld.env_of_name('default') + #Object.register('all-ns3-headers', AllNs3Headers) + Action.Action('gen-ns3-metaheader', func=gen_ns3_metaheader, color='BLUE') + + obj = bld.create_obj('all_ns3_headers') + + if Params.g_options.python_scan: + if not env['ENABLE_PYTHON_SCANNING']: + Params.fatal("Cannot re-scan python bindings: (py)gccxml not available") + print "Rescanning the python bindings..." + curdir = bld.m_curdirnode.abspath() + argv = [ + env['PYTHON'], + os.path.join(curdir, 'ns3modulescan.py'), # scanning script + bld.m_curdirnode.find_dir('../..').abspath(env), # include path (where the ns3 include dir is) + os.path.join(curdir, 'ns3modulegen_generated.py'), # output file + ] + scan = subprocess.Popen(argv, stdin=subprocess.PIPE) + scan.stdin.write(repr(get_modules_and_headers())) + scan.stdin.close() + if scan.wait(): + raise SystemExit(1) + print "Rescanning the python bindings done." + raise SystemExit + + if env['ENABLE_PYTHON_BINDINGS']: + bindgen = bld.create_obj('command-output') + bindgen.name = 'pybindgen' + + bindgen.command = env['PYTHON'] + bindgen.command_is_external = True + bindgen.argv = [ + bindgen.input_file("ns3modulegen.py"), + bindgen.output_file("ns3module.cc"), + ] + bindgen.argv.extend(get_modules_and_headers().iterkeys()) + bindgen.hidden_inputs = ['../../ns3/everything.h', + 'ns3modulegen_generated.py', + 'ns3modulegen_core_customizations.py'] + for module in get_modules_and_headers().iterkeys(): + bindgen.hidden_inputs.append("ns3_module_%s.py" % module.replace('-', '_')) + bindgen.hidden_outputs = ['ns3module.h'] + for module in get_modules_and_headers().iterkeys(): + bindgen.hidden_outputs.append("ns3_module_%s.cc" % module.replace('-', '_')) + bindgen.prio = 50 + + + ## we build python bindings if either we have the tools to + ## generate them or if the pregenerated source file is already + ## present in the source dir. + if env['ENABLE_PYTHON_BINDINGS'] \ + or os.path.exists(os.path.join(bld.m_curdirnode.abspath(), 'ns3module.cc')): + pymod = bld.create_obj('cpp', 'shlib', 'pyext') + pymod.source = ['ns3module.cc', 'ns3module_helpers.cc'] + pymod.includes = '.' + for module in get_modules_and_headers().iterkeys(): + pymod.source.append("ns3_module_%s.cc" % module.replace('-', '_')) + pymod.target = 'ns3/_ns3' + pymod.name = 'ns3module' + pymod.uselib_local = "ns3" + + # copy the __init__.py file to the build dir waf can't handle + # this, it's against waf's principles to have build dir files + # with the same name as source dir files, apparently. + dirnode = bld.m_curdirnode.find_dir('ns3') + src = os.path.join(dirnode.abspath(), '__init__.py') + dst = os.path.join(dirnode.abspath(env), '__init__.py') + try: + need_copy = os.stat(src).st_mtime > os.stat(dst).st_mtime + except OSError: + need_copy = True + if need_copy: + try: + os.mkdir(os.path.dirname(dst)) + except OSError: + pass + print "%r -> %r" % (src, dst) + shutil.copy2(src, dst) diff -r 0d83aa14b65d -r 2cc40b3e4fa5 samples/sample-simulator.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/samples/sample-simulator.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,28 @@ +# -*- Mode:Python; -*- + +import ns3 as ns + + +class MyModel(object): + + def Start(self): + ns.Simulator.Schedule(ns.Seconds(10.0), self.DealWithEvent, ns.Simulator.Now().GetSeconds()) + + def DealWithEvent(self, value): + print "Member method received event at ", ns.Simulator.Now().GetSeconds(), \ + "s started at ", value, "s" + +def random_function(model): + print "random function received event at ", ns.Simulator.Now().GetSeconds(), "s" + model.Start() + + +def main(dummy_argv): + model = MyModel() + ns.Simulator.Schedule(ns.Seconds(10.0), random_function, model) + ns.Simulator.Run() + ns.Simulator.Destroy() + +if __name__ == '__main__': + import sys + main(sys.argv) diff -r 0d83aa14b65d -r 2cc40b3e4fa5 utils/python-unit-tests.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/utils/python-unit-tests.py Tue Jul 08 10:43:58 2008 -0700 @@ -0,0 +1,86 @@ +import unittest +import ns3 + +class TestSimulator(unittest.TestCase): + + def testScheduleNow(self): + def callback(args): + self._args_received = args + self._cb_time = ns3.Simulator.Now() + ns3.Simulator.Destroy() + self._args_received = None + self._cb_time = None + ns3.Simulator.ScheduleNow(callback, "args") + ns3.Simulator.Run() + self.assertEqual(self._args_received, "args") + self.assertEqual(self._cb_time.GetSeconds(), 0.0) + + def testSchedule(self): + def callback(args): + self._args_received = args + self._cb_time = ns3.Simulator.Now() + ns3.Simulator.Destroy() + self._args_received = None + self._cb_time = None + ns3.Simulator.Schedule(ns3.Seconds(123), callback, "args") + ns3.Simulator.Run() + self.assertEqual(self._args_received, "args") + self.assertEqual(self._cb_time.GetSeconds(), 123.0) + + def testScheduleDestroy(self): + def callback(args): + self._args_received = args + self._cb_time = ns3.Simulator.Now() + ns3.Simulator.Destroy() + self._args_received = None + self._cb_time = None + def null(): pass + ns3.Simulator.Schedule(ns3.Seconds(123), null) + ns3.Simulator.ScheduleDestroy(callback, "args") + ns3.Simulator.Run() + ns3.Simulator.Destroy() + self.assertEqual(self._args_received, "args") + self.assertEqual(self._cb_time.GetSeconds(), 123.0) + + if 0: # these tests are known to fail for now (pybindgen limitation) + def testTime_EQ(self): + self.assert_(ns3.Seconds(123) == ns3.Seconds(123)) + def testTime_GE(self): + self.assert_(ns3.Seconds(123) >= ns3.Seconds(123)) + def testTime_LE(self): + self.assert_(ns3.Seconds(123) <= ns3.Seconds(123)) + def testTime_GT(self): + self.assert_(ns3.Seconds(124) > ns3.Seconds(123)) + def testTime_LT(self): + self.assert_(ns3.Seconds(123) < ns3.Seconds(124)) + + def testConfig(self): + ns3.Config.Set("ns3::OnOffApplication::PacketSize", ns3.UintegerValue(123)) + ns3.Config.SetDefault("ns3::OnOffApplication::PacketSize", ns3.UintegerValue(123)) + # hm.. no Config.Get? + + if 0: + # not yet: https://bugs.launchpad.net/pybindgen/+bug/246069 + def testSocket(self): + node = ns3.Node() + ns3.AddInternetStack(node) + self._received_packet = None + + def rx_callback(socket): + assert self._received_packet is None + self._received_packet = socket.Recv() + + sink = ns3.Socket.CreateSocket(node, ns3.TypeId.LookupByName("ns3::UdpSocketFactory")) + sink.Bind(ns3.InetSocketAddress(ns3.Ipv4Address.GetAny(), 80)) + sink.SetRecvCallback(rx_callback) + + source = ns3.Socket.CreateSocket(node, ns3.TypeId.LookupByName("ns3::UdpSocketFactory")) + source.SendTo(ns3.InetSocketAddress(ns3.Ipv4Address.GetAny(), 80), ns3.Packet(19)) + + ns3.Simulator.Run() + self.assert_(self._received_packet is not None) + self.assertEqual(self._received_packet.GetSize(), 19) + + +if __name__ == '__main__': + unittest.main() diff -r 0d83aa14b65d -r 2cc40b3e4fa5 wscript --- a/wscript Tue Jul 08 10:19:34 2008 -0700 +++ b/wscript Tue Jul 08 10:43:58 2008 -0700 @@ -61,6 +61,9 @@ shutil.rmtree("doc/html", True) shutil.rmtree("doc/latex", True) + if not os.path.exists("bindings/python/pybindgen"): + Params.fatal("Missing pybindgen checkout; run './waf configure --pybindgen-checkout' first.") + ## build the name of the traces subdirectory. Will be something like ## ns-3-dev-ref-traces traces_name = APPNAME + '-' + VERSION + REGRESSION_SUFFIX @@ -76,7 +79,6 @@ ## Now remove it; we do not ship the traces with the main tarball... shutil.rmtree(traces_dir, True) - def set_options(opt): def debug_option_callback(option, opt, value, parser): @@ -161,6 +163,7 @@ # options provided in a script in a subdirectory named "src" opt.sub_options('src') + opt.sub_options('bindings/python') def configure(conf): @@ -222,6 +225,7 @@ conf.sub_config('src') conf.sub_config('utils') + conf.sub_config('bindings/python') if Params.g_options.enable_modules: conf.env['NS3_ENABLED_MODULES'] = ['ns3-'+mod for mod in @@ -351,11 +355,13 @@ lib.target = 'ns3' if env['NS3_ENABLED_MODULES']: lib.add_objects = list(modules) + env['NS3_ENABLED_MODULES'] = list(modules) lib.uselib_local = list(modules) else: lib.add_objects = list(env['NS3_MODULES']) lib.uselib_local = list(env['NS3_MODULES']) + bld.add_subdirs('bindings/python') def get_command_template(): if Params.g_options.valgrind: @@ -413,8 +419,13 @@ raise SystemExit(1) out.close() + print "-- Running NS-3 C++ core unit tests..." run_program('run-tests', get_command_template()) + print "-- Running NS-3 Python bindings unit tests..." + _run_argv([env['PYTHON'], os.path.join("utils", "python-unit-tests.py")], proc_env) + + def _find_program(program_name, env): launch_dir = os.path.abspath(Params.g_cwd_launch) found_programs = [] @@ -457,10 +468,18 @@ proc_env[pathvar] = os.pathsep.join(list(env['NS3_MODULE_PATH']) + [proc_env[pathvar]]) else: proc_env[pathvar] = os.pathsep.join(list(env['NS3_MODULE_PATH'])) + + pymoddir = Params.g_build.m_curdirnode.find_dir('bindings/python').abspath(env) + if 'PYTHONPATH' in proc_env: + proc_env['PYTHONPATH'] = os.pathsep.join([pymoddir] + [proc_env['PYTHONPATH']]) + else: + proc_env['PYTHONPATH'] = pymoddir + return proc_env def _run_argv(argv, os_env=None): proc_env = _get_proc_env(os_env) + env = Params.g_build.env_of_name('default') retval = subprocess.Popen(argv, env=proc_env).wait() if retval: Params.fatal("Command %s exited with code %i" % (argv, retval))