~ubuntu-branches/ubuntu/quantal/ns3/quantal

« back to all changes in this revision

Viewing changes to ns-3.13/src/netanim/bindings/modulegen__gcc_ILP32.py

  • Committer: Package Import Robot
  • Author(s): YunQiang Su, Aron Xu, YunQiang Su, Upstream
  • Date: 2012-01-06 00:35:42 UTC
  • mfrom: (10.1.5 sid)
  • Revision ID: package-import@ubuntu.com-20120106003542-vcn5g03mhapm991h
Tags: 3.13+dfsg-1
[ Aron Xu ]:
        add tag binary and binary-indep, 
  for not build doc when --binary-arch (Closes: #654493).
[ YunQiang Su ]
        add waf 1.5/1.6 source to debian directory, 
  and build waf from there (Closes: #642217).
[ Upstream ]
  Successfully link with --as-needed option (Closes: #642225).

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandlers
 
2
 
 
3
 
 
4
import pybindgen.settings
 
5
import warnings
 
6
 
 
7
class ErrorHandler(pybindgen.settings.ErrorHandler):
 
8
    def handle_error(self, wrapper, exception, traceback_):
 
9
        warnings.warn("exception %r in wrapper %s" % (exception, wrapper))
 
10
        return True
 
11
pybindgen.settings.error_handler = ErrorHandler()
 
12
 
 
13
 
 
14
import sys
 
15
 
 
16
def module_init():
 
17
    root_module = Module('ns.netanim', cpp_namespace='::ns3')
 
18
    return root_module
 
19
 
 
20
def register_types(module):
 
21
    root_module = module.get_root()
 
22
    
 
23
    ## log.h (module 'core'): ns3::LogLevel [enumeration]
 
24
    module.add_enum('LogLevel', ['LOG_NONE', 'LOG_ERROR', 'LOG_LEVEL_ERROR', 'LOG_WARN', 'LOG_LEVEL_WARN', 'LOG_DEBUG', 'LOG_LEVEL_DEBUG', 'LOG_INFO', 'LOG_LEVEL_INFO', 'LOG_FUNCTION', 'LOG_LEVEL_FUNCTION', 'LOG_LOGIC', 'LOG_LEVEL_LOGIC', 'LOG_ALL', 'LOG_LEVEL_ALL', 'LOG_PREFIX_FUNC', 'LOG_PREFIX_TIME', 'LOG_PREFIX_NODE'], import_from_module='ns.core')
 
25
    ## address.h (module 'network'): ns3::Address [class]
 
26
    module.add_class('Address', import_from_module='ns.network')
 
27
    ## address.h (module 'network'): ns3::Address::MaxSize_e [enumeration]
 
28
    module.add_enum('MaxSize_e', ['MAX_SIZE'], outer_class=root_module['ns3::Address'], import_from_module='ns.network')
 
29
    ## animation-interface-helper.h (module 'netanim'): ns3::AnimPacketInfo [class]
 
30
    module.add_class('AnimPacketInfo')
 
31
    ## animation-interface-helper.h (module 'netanim'): ns3::AnimRxInfo [class]
 
32
    module.add_class('AnimRxInfo')
 
33
    ## animation-interface.h (module 'netanim'): ns3::AnimationInterface [class]
 
34
    module.add_class('AnimationInterface')
 
35
    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList [class]
 
36
    module.add_class('AttributeConstructionList', import_from_module='ns.core')
 
37
    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item [struct]
 
38
    module.add_class('Item', import_from_module='ns.core', outer_class=root_module['ns3::AttributeConstructionList'])
 
39
    ## buffer.h (module 'network'): ns3::Buffer [class]
 
40
    module.add_class('Buffer', import_from_module='ns.network')
 
41
    ## buffer.h (module 'network'): ns3::Buffer::Iterator [class]
 
42
    module.add_class('Iterator', import_from_module='ns.network', outer_class=root_module['ns3::Buffer'])
 
43
    ## packet.h (module 'network'): ns3::ByteTagIterator [class]
 
44
    module.add_class('ByteTagIterator', import_from_module='ns.network')
 
45
    ## packet.h (module 'network'): ns3::ByteTagIterator::Item [class]
 
46
    module.add_class('Item', import_from_module='ns.network', outer_class=root_module['ns3::ByteTagIterator'])
 
47
    ## byte-tag-list.h (module 'network'): ns3::ByteTagList [class]
 
48
    module.add_class('ByteTagList', import_from_module='ns.network')
 
49
    ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator [class]
 
50
    module.add_class('Iterator', import_from_module='ns.network', outer_class=root_module['ns3::ByteTagList'])
 
51
    ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item [struct]
 
52
    module.add_class('Item', import_from_module='ns.network', outer_class=root_module['ns3::ByteTagList::Iterator'])
 
53
    ## callback.h (module 'core'): ns3::CallbackBase [class]
 
54
    module.add_class('CallbackBase', import_from_module='ns.core')
 
55
    ## event-id.h (module 'core'): ns3::EventId [class]
 
56
    module.add_class('EventId', import_from_module='ns.core')
 
57
    ## ipv4-address.h (module 'network'): ns3::Ipv4Address [class]
 
58
    module.add_class('Ipv4Address', import_from_module='ns.network')
 
59
    ## ipv4-address.h (module 'network'): ns3::Ipv4Address [class]
 
60
    root_module['ns3::Ipv4Address'].implicitly_converts_to(root_module['ns3::Address'])
 
61
    ## ipv4-address.h (module 'network'): ns3::Ipv4Mask [class]
 
62
    module.add_class('Ipv4Mask', import_from_module='ns.network')
 
63
    ## ipv6-address.h (module 'network'): ns3::Ipv6Address [class]
 
64
    module.add_class('Ipv6Address', import_from_module='ns.network')
 
65
    ## ipv6-address.h (module 'network'): ns3::Ipv6Address [class]
 
66
    root_module['ns3::Ipv6Address'].implicitly_converts_to(root_module['ns3::Address'])
 
67
    ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix [class]
 
68
    module.add_class('Ipv6Prefix', import_from_module='ns.network')
 
69
    ## log.h (module 'core'): ns3::LogComponent [class]
 
70
    module.add_class('LogComponent', import_from_module='ns.core')
 
71
    ## mac48-address.h (module 'network'): ns3::Mac48Address [class]
 
72
    module.add_class('Mac48Address', import_from_module='ns.network')
 
73
    ## mac48-address.h (module 'network'): ns3::Mac48Address [class]
 
74
    root_module['ns3::Mac48Address'].implicitly_converts_to(root_module['ns3::Address'])
 
75
    ## node-list.h (module 'network'): ns3::NodeList [class]
 
76
    module.add_class('NodeList', import_from_module='ns.network')
 
77
    ## object-base.h (module 'core'): ns3::ObjectBase [class]
 
78
    module.add_class('ObjectBase', allow_subclassing=True, import_from_module='ns.core')
 
79
    ## object.h (module 'core'): ns3::ObjectDeleter [struct]
 
80
    module.add_class('ObjectDeleter', import_from_module='ns.core')
 
81
    ## object-factory.h (module 'core'): ns3::ObjectFactory [class]
 
82
    module.add_class('ObjectFactory', import_from_module='ns.core')
 
83
    ## packet-metadata.h (module 'network'): ns3::PacketMetadata [class]
 
84
    module.add_class('PacketMetadata', import_from_module='ns.network')
 
85
    ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item [struct]
 
86
    module.add_class('Item', import_from_module='ns.network', outer_class=root_module['ns3::PacketMetadata'])
 
87
    ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item [enumeration]
 
88
    module.add_enum('', ['PAYLOAD', 'HEADER', 'TRAILER'], outer_class=root_module['ns3::PacketMetadata::Item'], import_from_module='ns.network')
 
89
    ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator [class]
 
90
    module.add_class('ItemIterator', import_from_module='ns.network', outer_class=root_module['ns3::PacketMetadata'])
 
91
    ## packet.h (module 'network'): ns3::PacketTagIterator [class]
 
92
    module.add_class('PacketTagIterator', import_from_module='ns.network')
 
93
    ## packet.h (module 'network'): ns3::PacketTagIterator::Item [class]
 
94
    module.add_class('Item', import_from_module='ns.network', outer_class=root_module['ns3::PacketTagIterator'])
 
95
    ## packet-tag-list.h (module 'network'): ns3::PacketTagList [class]
 
96
    module.add_class('PacketTagList', import_from_module='ns.network')
 
97
    ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData [struct]
 
98
    module.add_class('TagData', import_from_module='ns.network', outer_class=root_module['ns3::PacketTagList'])
 
99
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter> [class]
 
100
    module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::Object', 'ns3::ObjectBase', 'ns3::ObjectDeleter'], parent=root_module['ns3::ObjectBase'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
 
101
    ## simulator.h (module 'core'): ns3::Simulator [class]
 
102
    module.add_class('Simulator', destructor_visibility='private', import_from_module='ns.core')
 
103
    ## tag.h (module 'network'): ns3::Tag [class]
 
104
    module.add_class('Tag', import_from_module='ns.network', parent=root_module['ns3::ObjectBase'])
 
105
    ## tag-buffer.h (module 'network'): ns3::TagBuffer [class]
 
106
    module.add_class('TagBuffer', import_from_module='ns.network')
 
107
    ## type-id.h (module 'core'): ns3::TypeId [class]
 
108
    module.add_class('TypeId', import_from_module='ns.core')
 
109
    ## type-id.h (module 'core'): ns3::TypeId::AttributeFlag [enumeration]
 
110
    module.add_enum('AttributeFlag', ['ATTR_GET', 'ATTR_SET', 'ATTR_CONSTRUCT', 'ATTR_SGC'], outer_class=root_module['ns3::TypeId'], import_from_module='ns.core')
 
111
    ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation [struct]
 
112
    module.add_class('AttributeInformation', import_from_module='ns.core', outer_class=root_module['ns3::TypeId'])
 
113
    ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation [struct]
 
114
    module.add_class('TraceSourceInformation', import_from_module='ns.core', outer_class=root_module['ns3::TypeId'])
 
115
    ## vector.h (module 'core'): ns3::Vector2D [class]
 
116
    module.add_class('Vector2D', import_from_module='ns.core')
 
117
    ## vector.h (module 'core'): ns3::Vector3D [class]
 
118
    module.add_class('Vector3D', import_from_module='ns.core')
 
119
    ## empty.h (module 'core'): ns3::empty [class]
 
120
    module.add_class('empty', import_from_module='ns.core')
 
121
    ## int64x64-double.h (module 'core'): ns3::int64x64_t [class]
 
122
    module.add_class('int64x64_t', import_from_module='ns.core')
 
123
    ## animation-interface.h (module 'netanim'): ns3::AnimByteTag [class]
 
124
    module.add_class('AnimByteTag', parent=root_module['ns3::Tag'])
 
125
    ## chunk.h (module 'network'): ns3::Chunk [class]
 
126
    module.add_class('Chunk', import_from_module='ns.network', parent=root_module['ns3::ObjectBase'])
 
127
    ## header.h (module 'network'): ns3::Header [class]
 
128
    module.add_class('Header', import_from_module='ns.network', parent=root_module['ns3::Chunk'])
 
129
    ## object.h (module 'core'): ns3::Object [class]
 
130
    module.add_class('Object', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter >'])
 
131
    ## object.h (module 'core'): ns3::Object::AggregateIterator [class]
 
132
    module.add_class('AggregateIterator', import_from_module='ns.core', outer_class=root_module['ns3::Object'])
 
133
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> > [class]
 
134
    module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::AttributeAccessor', 'ns3::empty', 'ns3::DefaultDeleter<ns3::AttributeAccessor>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
 
135
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> > [class]
 
136
    module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::AttributeChecker', 'ns3::empty', 'ns3::DefaultDeleter<ns3::AttributeChecker>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
 
137
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> > [class]
 
138
    module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::AttributeValue', 'ns3::empty', 'ns3::DefaultDeleter<ns3::AttributeValue>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
 
139
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> > [class]
 
140
    module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::CallbackImplBase', 'ns3::empty', 'ns3::DefaultDeleter<ns3::CallbackImplBase>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
 
141
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> > [class]
 
142
    module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::EventImpl', 'ns3::empty', 'ns3::DefaultDeleter<ns3::EventImpl>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
 
143
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::NixVector, ns3::empty, ns3::DefaultDeleter<ns3::NixVector> > [class]
 
144
    module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::NixVector', 'ns3::empty', 'ns3::DefaultDeleter<ns3::NixVector>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
 
145
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> > [class]
 
146
    module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::Packet', 'ns3::empty', 'ns3::DefaultDeleter<ns3::Packet>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
 
147
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> > [class]
 
148
    module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::TraceSourceAccessor', 'ns3::empty', 'ns3::DefaultDeleter<ns3::TraceSourceAccessor>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
 
149
    ## nstime.h (module 'core'): ns3::Time [class]
 
150
    module.add_class('Time', import_from_module='ns.core')
 
151
    ## nstime.h (module 'core'): ns3::Time::Unit [enumeration]
 
152
    module.add_enum('Unit', ['S', 'MS', 'US', 'NS', 'PS', 'FS', 'LAST'], outer_class=root_module['ns3::Time'], import_from_module='ns.core')
 
153
    ## nstime.h (module 'core'): ns3::Time [class]
 
154
    root_module['ns3::Time'].implicitly_converts_to(root_module['ns3::int64x64_t'])
 
155
    ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor [class]
 
156
    module.add_class('TraceSourceAccessor', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> >'])
 
157
    ## trailer.h (module 'network'): ns3::Trailer [class]
 
158
    module.add_class('Trailer', import_from_module='ns.network', parent=root_module['ns3::Chunk'])
 
159
    ## attribute.h (module 'core'): ns3::AttributeAccessor [class]
 
160
    module.add_class('AttributeAccessor', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >'])
 
161
    ## attribute.h (module 'core'): ns3::AttributeChecker [class]
 
162
    module.add_class('AttributeChecker', allow_subclassing=False, automatic_type_narrowing=True, import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >'])
 
163
    ## attribute.h (module 'core'): ns3::AttributeValue [class]
 
164
    module.add_class('AttributeValue', allow_subclassing=False, automatic_type_narrowing=True, import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >'])
 
165
    ## callback.h (module 'core'): ns3::CallbackChecker [class]
 
166
    module.add_class('CallbackChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])
 
167
    ## callback.h (module 'core'): ns3::CallbackImplBase [class]
 
168
    module.add_class('CallbackImplBase', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >'])
 
169
    ## callback.h (module 'core'): ns3::CallbackValue [class]
 
170
    module.add_class('CallbackValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
 
171
    ## attribute.h (module 'core'): ns3::EmptyAttributeValue [class]
 
172
    module.add_class('EmptyAttributeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
 
173
    ## event-impl.h (module 'core'): ns3::EventImpl [class]
 
174
    module.add_class('EventImpl', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> >'])
 
175
    ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker [class]
 
176
    module.add_class('Ipv4AddressChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])
 
177
    ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue [class]
 
178
    module.add_class('Ipv4AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])
 
179
    ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker [class]
 
180
    module.add_class('Ipv4MaskChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])
 
181
    ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue [class]
 
182
    module.add_class('Ipv4MaskValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])
 
183
    ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker [class]
 
184
    module.add_class('Ipv6AddressChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])
 
185
    ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue [class]
 
186
    module.add_class('Ipv6AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])
 
187
    ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker [class]
 
188
    module.add_class('Ipv6PrefixChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])
 
189
    ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue [class]
 
190
    module.add_class('Ipv6PrefixValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])
 
191
    ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker [class]
 
192
    module.add_class('Mac48AddressChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])
 
193
    ## mac48-address.h (module 'network'): ns3::Mac48AddressValue [class]
 
194
    module.add_class('Mac48AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])
 
195
    ## mobility-model.h (module 'mobility'): ns3::MobilityModel [class]
 
196
    module.add_class('MobilityModel', import_from_module='ns.mobility', parent=root_module['ns3::Object'])
 
197
    ## net-device.h (module 'network'): ns3::NetDevice [class]
 
198
    module.add_class('NetDevice', import_from_module='ns.network', parent=root_module['ns3::Object'])
 
199
    ## net-device.h (module 'network'): ns3::NetDevice::PacketType [enumeration]
 
200
    module.add_enum('PacketType', ['PACKET_HOST', 'NS3_PACKET_HOST', 'PACKET_BROADCAST', 'NS3_PACKET_BROADCAST', 'PACKET_MULTICAST', 'NS3_PACKET_MULTICAST', 'PACKET_OTHERHOST', 'NS3_PACKET_OTHERHOST'], outer_class=root_module['ns3::NetDevice'], import_from_module='ns.network')
 
201
    ## nix-vector.h (module 'network'): ns3::NixVector [class]
 
202
    module.add_class('NixVector', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::NixVector, ns3::empty, ns3::DefaultDeleter<ns3::NixVector> >'])
 
203
    ## node.h (module 'network'): ns3::Node [class]
 
204
    module.add_class('Node', import_from_module='ns.network', parent=root_module['ns3::Object'])
 
205
    ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker [class]
 
206
    module.add_class('ObjectFactoryChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])
 
207
    ## object-factory.h (module 'core'): ns3::ObjectFactoryValue [class]
 
208
    module.add_class('ObjectFactoryValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
 
209
    ## packet.h (module 'network'): ns3::Packet [class]
 
210
    module.add_class('Packet', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> >'])
 
211
    ## nstime.h (module 'core'): ns3::TimeChecker [class]
 
212
    module.add_class('TimeChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])
 
213
    ## nstime.h (module 'core'): ns3::TimeValue [class]
 
214
    module.add_class('TimeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
 
215
    ## type-id.h (module 'core'): ns3::TypeIdChecker [class]
 
216
    module.add_class('TypeIdChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])
 
217
    ## type-id.h (module 'core'): ns3::TypeIdValue [class]
 
218
    module.add_class('TypeIdValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
 
219
    ## vector.h (module 'core'): ns3::Vector2DChecker [class]
 
220
    module.add_class('Vector2DChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])
 
221
    ## vector.h (module 'core'): ns3::Vector2DValue [class]
 
222
    module.add_class('Vector2DValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
 
223
    ## vector.h (module 'core'): ns3::Vector3DChecker [class]
 
224
    module.add_class('Vector3DChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])
 
225
    ## vector.h (module 'core'): ns3::Vector3DValue [class]
 
226
    module.add_class('Vector3DValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
 
227
    ## address.h (module 'network'): ns3::AddressChecker [class]
 
228
    module.add_class('AddressChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])
 
229
    ## address.h (module 'network'): ns3::AddressValue [class]
 
230
    module.add_class('AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])
 
231
    module.add_container('std::map< unsigned int, ns3::AnimRxInfo >', ('unsigned int', 'ns3::AnimRxInfo'), container_type='map')
 
232
    typehandlers.add_type_alias('void ( * ) ( std::ostream & ) *', 'ns3::LogTimePrinter')
 
233
    typehandlers.add_type_alias('void ( * ) ( std::ostream & ) **', 'ns3::LogTimePrinter*')
 
234
    typehandlers.add_type_alias('void ( * ) ( std::ostream & ) *&', 'ns3::LogTimePrinter&')
 
235
    typehandlers.add_type_alias('ns3::Vector3DValue', 'ns3::VectorValue')
 
236
    typehandlers.add_type_alias('ns3::Vector3DValue*', 'ns3::VectorValue*')
 
237
    typehandlers.add_type_alias('ns3::Vector3DValue&', 'ns3::VectorValue&')
 
238
    module.add_typedef(root_module['ns3::Vector3DValue'], 'VectorValue')
 
239
    typehandlers.add_type_alias('void ( * ) ( std::ostream & ) *', 'ns3::LogNodePrinter')
 
240
    typehandlers.add_type_alias('void ( * ) ( std::ostream & ) **', 'ns3::LogNodePrinter*')
 
241
    typehandlers.add_type_alias('void ( * ) ( std::ostream & ) *&', 'ns3::LogNodePrinter&')
 
242
    typehandlers.add_type_alias('ns3::Vector3D', 'ns3::Vector')
 
243
    typehandlers.add_type_alias('ns3::Vector3D*', 'ns3::Vector*')
 
244
    typehandlers.add_type_alias('ns3::Vector3D&', 'ns3::Vector&')
 
245
    module.add_typedef(root_module['ns3::Vector3D'], 'Vector')
 
246
    typehandlers.add_type_alias('ns3::Vector3DChecker', 'ns3::VectorChecker')
 
247
    typehandlers.add_type_alias('ns3::Vector3DChecker*', 'ns3::VectorChecker*')
 
248
    typehandlers.add_type_alias('ns3::Vector3DChecker&', 'ns3::VectorChecker&')
 
249
    module.add_typedef(root_module['ns3::Vector3DChecker'], 'VectorChecker')
 
250
    
 
251
    ## Register a nested module for the namespace Config
 
252
    
 
253
    nested_module = module.add_cpp_namespace('Config')
 
254
    register_types_ns3_Config(nested_module)
 
255
    
 
256
    
 
257
    ## Register a nested module for the namespace FatalImpl
 
258
    
 
259
    nested_module = module.add_cpp_namespace('FatalImpl')
 
260
    register_types_ns3_FatalImpl(nested_module)
 
261
    
 
262
 
 
263
def register_types_ns3_Config(module):
 
264
    root_module = module.get_root()
 
265
    
 
266
    ## config.h (module 'core'): ns3::Config::MatchContainer [class]
 
267
    module.add_class('MatchContainer', import_from_module='ns.core')
 
268
    module.add_container('std::vector< ns3::Ptr< ns3::Object > >', 'ns3::Ptr< ns3::Object >', container_type='vector')
 
269
    module.add_container('std::vector< std::string >', 'std::string', container_type='vector')
 
270
 
 
271
def register_types_ns3_FatalImpl(module):
 
272
    root_module = module.get_root()
 
273
    
 
274
 
 
275
def register_methods(root_module):
 
276
    register_Ns3Address_methods(root_module, root_module['ns3::Address'])
 
277
    register_Ns3AnimPacketInfo_methods(root_module, root_module['ns3::AnimPacketInfo'])
 
278
    register_Ns3AnimRxInfo_methods(root_module, root_module['ns3::AnimRxInfo'])
 
279
    register_Ns3AnimationInterface_methods(root_module, root_module['ns3::AnimationInterface'])
 
280
    register_Ns3AttributeConstructionList_methods(root_module, root_module['ns3::AttributeConstructionList'])
 
281
    register_Ns3AttributeConstructionListItem_methods(root_module, root_module['ns3::AttributeConstructionList::Item'])
 
282
    register_Ns3Buffer_methods(root_module, root_module['ns3::Buffer'])
 
283
    register_Ns3BufferIterator_methods(root_module, root_module['ns3::Buffer::Iterator'])
 
284
    register_Ns3ByteTagIterator_methods(root_module, root_module['ns3::ByteTagIterator'])
 
285
    register_Ns3ByteTagIteratorItem_methods(root_module, root_module['ns3::ByteTagIterator::Item'])
 
286
    register_Ns3ByteTagList_methods(root_module, root_module['ns3::ByteTagList'])
 
287
    register_Ns3ByteTagListIterator_methods(root_module, root_module['ns3::ByteTagList::Iterator'])
 
288
    register_Ns3ByteTagListIteratorItem_methods(root_module, root_module['ns3::ByteTagList::Iterator::Item'])
 
289
    register_Ns3CallbackBase_methods(root_module, root_module['ns3::CallbackBase'])
 
290
    register_Ns3EventId_methods(root_module, root_module['ns3::EventId'])
 
291
    register_Ns3Ipv4Address_methods(root_module, root_module['ns3::Ipv4Address'])
 
292
    register_Ns3Ipv4Mask_methods(root_module, root_module['ns3::Ipv4Mask'])
 
293
    register_Ns3Ipv6Address_methods(root_module, root_module['ns3::Ipv6Address'])
 
294
    register_Ns3Ipv6Prefix_methods(root_module, root_module['ns3::Ipv6Prefix'])
 
295
    register_Ns3LogComponent_methods(root_module, root_module['ns3::LogComponent'])
 
296
    register_Ns3Mac48Address_methods(root_module, root_module['ns3::Mac48Address'])
 
297
    register_Ns3NodeList_methods(root_module, root_module['ns3::NodeList'])
 
298
    register_Ns3ObjectBase_methods(root_module, root_module['ns3::ObjectBase'])
 
299
    register_Ns3ObjectDeleter_methods(root_module, root_module['ns3::ObjectDeleter'])
 
300
    register_Ns3ObjectFactory_methods(root_module, root_module['ns3::ObjectFactory'])
 
301
    register_Ns3PacketMetadata_methods(root_module, root_module['ns3::PacketMetadata'])
 
302
    register_Ns3PacketMetadataItem_methods(root_module, root_module['ns3::PacketMetadata::Item'])
 
303
    register_Ns3PacketMetadataItemIterator_methods(root_module, root_module['ns3::PacketMetadata::ItemIterator'])
 
304
    register_Ns3PacketTagIterator_methods(root_module, root_module['ns3::PacketTagIterator'])
 
305
    register_Ns3PacketTagIteratorItem_methods(root_module, root_module['ns3::PacketTagIterator::Item'])
 
306
    register_Ns3PacketTagList_methods(root_module, root_module['ns3::PacketTagList'])
 
307
    register_Ns3PacketTagListTagData_methods(root_module, root_module['ns3::PacketTagList::TagData'])
 
308
    register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, root_module['ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter >'])
 
309
    register_Ns3Simulator_methods(root_module, root_module['ns3::Simulator'])
 
310
    register_Ns3Tag_methods(root_module, root_module['ns3::Tag'])
 
311
    register_Ns3TagBuffer_methods(root_module, root_module['ns3::TagBuffer'])
 
312
    register_Ns3TypeId_methods(root_module, root_module['ns3::TypeId'])
 
313
    register_Ns3TypeIdAttributeInformation_methods(root_module, root_module['ns3::TypeId::AttributeInformation'])
 
314
    register_Ns3TypeIdTraceSourceInformation_methods(root_module, root_module['ns3::TypeId::TraceSourceInformation'])
 
315
    register_Ns3Vector2D_methods(root_module, root_module['ns3::Vector2D'])
 
316
    register_Ns3Vector3D_methods(root_module, root_module['ns3::Vector3D'])
 
317
    register_Ns3Empty_methods(root_module, root_module['ns3::empty'])
 
318
    register_Ns3Int64x64_t_methods(root_module, root_module['ns3::int64x64_t'])
 
319
    register_Ns3AnimByteTag_methods(root_module, root_module['ns3::AnimByteTag'])
 
320
    register_Ns3Chunk_methods(root_module, root_module['ns3::Chunk'])
 
321
    register_Ns3Header_methods(root_module, root_module['ns3::Header'])
 
322
    register_Ns3Object_methods(root_module, root_module['ns3::Object'])
 
323
    register_Ns3ObjectAggregateIterator_methods(root_module, root_module['ns3::Object::AggregateIterator'])
 
324
    register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >'])
 
325
    register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >'])
 
326
    register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >'])
 
327
    register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3CallbackImplBase__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >'])
 
328
    register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3EventImpl__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> >'])
 
329
    register_Ns3SimpleRefCount__Ns3NixVector_Ns3Empty_Ns3DefaultDeleter__lt__ns3NixVector__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::NixVector, ns3::empty, ns3::DefaultDeleter<ns3::NixVector> >'])
 
330
    register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Packet__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> >'])
 
331
    register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3TraceSourceAccessor__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> >'])
 
332
    register_Ns3Time_methods(root_module, root_module['ns3::Time'])
 
333
    register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])
 
334
    register_Ns3Trailer_methods(root_module, root_module['ns3::Trailer'])
 
335
    register_Ns3AttributeAccessor_methods(root_module, root_module['ns3::AttributeAccessor'])
 
336
    register_Ns3AttributeChecker_methods(root_module, root_module['ns3::AttributeChecker'])
 
337
    register_Ns3AttributeValue_methods(root_module, root_module['ns3::AttributeValue'])
 
338
    register_Ns3CallbackChecker_methods(root_module, root_module['ns3::CallbackChecker'])
 
339
    register_Ns3CallbackImplBase_methods(root_module, root_module['ns3::CallbackImplBase'])
 
340
    register_Ns3CallbackValue_methods(root_module, root_module['ns3::CallbackValue'])
 
341
    register_Ns3EmptyAttributeValue_methods(root_module, root_module['ns3::EmptyAttributeValue'])
 
342
    register_Ns3EventImpl_methods(root_module, root_module['ns3::EventImpl'])
 
343
    register_Ns3Ipv4AddressChecker_methods(root_module, root_module['ns3::Ipv4AddressChecker'])
 
344
    register_Ns3Ipv4AddressValue_methods(root_module, root_module['ns3::Ipv4AddressValue'])
 
345
    register_Ns3Ipv4MaskChecker_methods(root_module, root_module['ns3::Ipv4MaskChecker'])
 
346
    register_Ns3Ipv4MaskValue_methods(root_module, root_module['ns3::Ipv4MaskValue'])
 
347
    register_Ns3Ipv6AddressChecker_methods(root_module, root_module['ns3::Ipv6AddressChecker'])
 
348
    register_Ns3Ipv6AddressValue_methods(root_module, root_module['ns3::Ipv6AddressValue'])
 
349
    register_Ns3Ipv6PrefixChecker_methods(root_module, root_module['ns3::Ipv6PrefixChecker'])
 
350
    register_Ns3Ipv6PrefixValue_methods(root_module, root_module['ns3::Ipv6PrefixValue'])
 
351
    register_Ns3Mac48AddressChecker_methods(root_module, root_module['ns3::Mac48AddressChecker'])
 
352
    register_Ns3Mac48AddressValue_methods(root_module, root_module['ns3::Mac48AddressValue'])
 
353
    register_Ns3MobilityModel_methods(root_module, root_module['ns3::MobilityModel'])
 
354
    register_Ns3NetDevice_methods(root_module, root_module['ns3::NetDevice'])
 
355
    register_Ns3NixVector_methods(root_module, root_module['ns3::NixVector'])
 
356
    register_Ns3Node_methods(root_module, root_module['ns3::Node'])
 
357
    register_Ns3ObjectFactoryChecker_methods(root_module, root_module['ns3::ObjectFactoryChecker'])
 
358
    register_Ns3ObjectFactoryValue_methods(root_module, root_module['ns3::ObjectFactoryValue'])
 
359
    register_Ns3Packet_methods(root_module, root_module['ns3::Packet'])
 
360
    register_Ns3TimeChecker_methods(root_module, root_module['ns3::TimeChecker'])
 
361
    register_Ns3TimeValue_methods(root_module, root_module['ns3::TimeValue'])
 
362
    register_Ns3TypeIdChecker_methods(root_module, root_module['ns3::TypeIdChecker'])
 
363
    register_Ns3TypeIdValue_methods(root_module, root_module['ns3::TypeIdValue'])
 
364
    register_Ns3Vector2DChecker_methods(root_module, root_module['ns3::Vector2DChecker'])
 
365
    register_Ns3Vector2DValue_methods(root_module, root_module['ns3::Vector2DValue'])
 
366
    register_Ns3Vector3DChecker_methods(root_module, root_module['ns3::Vector3DChecker'])
 
367
    register_Ns3Vector3DValue_methods(root_module, root_module['ns3::Vector3DValue'])
 
368
    register_Ns3AddressChecker_methods(root_module, root_module['ns3::AddressChecker'])
 
369
    register_Ns3AddressValue_methods(root_module, root_module['ns3::AddressValue'])
 
370
    register_Ns3ConfigMatchContainer_methods(root_module, root_module['ns3::Config::MatchContainer'])
 
371
    return
 
372
 
 
373
def register_Ns3Address_methods(root_module, cls):
 
374
    cls.add_binary_comparison_operator('<')
 
375
    cls.add_binary_comparison_operator('!=')
 
376
    cls.add_output_stream_operator()
 
377
    cls.add_binary_comparison_operator('==')
 
378
    ## address.h (module 'network'): ns3::Address::Address() [constructor]
 
379
    cls.add_constructor([])
 
380
    ## address.h (module 'network'): ns3::Address::Address(uint8_t type, uint8_t const * buffer, uint8_t len) [constructor]
 
381
    cls.add_constructor([param('uint8_t', 'type'), param('uint8_t const *', 'buffer'), param('uint8_t', 'len')])
 
382
    ## address.h (module 'network'): ns3::Address::Address(ns3::Address const & address) [copy constructor]
 
383
    cls.add_constructor([param('ns3::Address const &', 'address')])
 
384
    ## address.h (module 'network'): bool ns3::Address::CheckCompatible(uint8_t type, uint8_t len) const [member function]
 
385
    cls.add_method('CheckCompatible', 
 
386
                   'bool', 
 
387
                   [param('uint8_t', 'type'), param('uint8_t', 'len')], 
 
388
                   is_const=True)
 
389
    ## address.h (module 'network'): uint32_t ns3::Address::CopyAllFrom(uint8_t const * buffer, uint8_t len) [member function]
 
390
    cls.add_method('CopyAllFrom', 
 
391
                   'uint32_t', 
 
392
                   [param('uint8_t const *', 'buffer'), param('uint8_t', 'len')])
 
393
    ## address.h (module 'network'): uint32_t ns3::Address::CopyAllTo(uint8_t * buffer, uint8_t len) const [member function]
 
394
    cls.add_method('CopyAllTo', 
 
395
                   'uint32_t', 
 
396
                   [param('uint8_t *', 'buffer'), param('uint8_t', 'len')], 
 
397
                   is_const=True)
 
398
    ## address.h (module 'network'): uint32_t ns3::Address::CopyFrom(uint8_t const * buffer, uint8_t len) [member function]
 
399
    cls.add_method('CopyFrom', 
 
400
                   'uint32_t', 
 
401
                   [param('uint8_t const *', 'buffer'), param('uint8_t', 'len')])
 
402
    ## address.h (module 'network'): uint32_t ns3::Address::CopyTo(uint8_t * buffer) const [member function]
 
403
    cls.add_method('CopyTo', 
 
404
                   'uint32_t', 
 
405
                   [param('uint8_t *', 'buffer')], 
 
406
                   is_const=True)
 
407
    ## address.h (module 'network'): void ns3::Address::Deserialize(ns3::TagBuffer buffer) [member function]
 
408
    cls.add_method('Deserialize', 
 
409
                   'void', 
 
410
                   [param('ns3::TagBuffer', 'buffer')])
 
411
    ## address.h (module 'network'): uint8_t ns3::Address::GetLength() const [member function]
 
412
    cls.add_method('GetLength', 
 
413
                   'uint8_t', 
 
414
                   [], 
 
415
                   is_const=True)
 
416
    ## address.h (module 'network'): uint32_t ns3::Address::GetSerializedSize() const [member function]
 
417
    cls.add_method('GetSerializedSize', 
 
418
                   'uint32_t', 
 
419
                   [], 
 
420
                   is_const=True)
 
421
    ## address.h (module 'network'): bool ns3::Address::IsInvalid() const [member function]
 
422
    cls.add_method('IsInvalid', 
 
423
                   'bool', 
 
424
                   [], 
 
425
                   is_const=True)
 
426
    ## address.h (module 'network'): bool ns3::Address::IsMatchingType(uint8_t type) const [member function]
 
427
    cls.add_method('IsMatchingType', 
 
428
                   'bool', 
 
429
                   [param('uint8_t', 'type')], 
 
430
                   is_const=True)
 
431
    ## address.h (module 'network'): static uint8_t ns3::Address::Register() [member function]
 
432
    cls.add_method('Register', 
 
433
                   'uint8_t', 
 
434
                   [], 
 
435
                   is_static=True)
 
436
    ## address.h (module 'network'): void ns3::Address::Serialize(ns3::TagBuffer buffer) const [member function]
 
437
    cls.add_method('Serialize', 
 
438
                   'void', 
 
439
                   [param('ns3::TagBuffer', 'buffer')], 
 
440
                   is_const=True)
 
441
    return
 
442
 
 
443
def register_Ns3AnimPacketInfo_methods(root_module, cls):
 
444
    ## animation-interface-helper.h (module 'netanim'): ns3::AnimPacketInfo::AnimPacketInfo(ns3::AnimPacketInfo const & arg0) [copy constructor]
 
445
    cls.add_constructor([param('ns3::AnimPacketInfo const &', 'arg0')])
 
446
    ## animation-interface-helper.h (module 'netanim'): ns3::AnimPacketInfo::AnimPacketInfo() [constructor]
 
447
    cls.add_constructor([])
 
448
    ## animation-interface-helper.h (module 'netanim'): ns3::AnimPacketInfo::AnimPacketInfo(ns3::Ptr<ns3::NetDevice const> tx_nd, ns3::Time const & fbTx, ns3::Time const & lbTx, ns3::Vector txLoc) [constructor]
 
449
    cls.add_constructor([param('ns3::Ptr< ns3::NetDevice const >', 'tx_nd'), param('ns3::Time const &', 'fbTx'), param('ns3::Time const &', 'lbTx'), param('ns3::Vector', 'txLoc')])
 
450
    ## animation-interface-helper.h (module 'netanim'): ns3::AnimRxInfo ns3::AnimPacketInfo::GetRxInfo(ns3::Ptr<ns3::NetDevice const> nd) [member function]
 
451
    cls.add_method('GetRxInfo', 
 
452
                   'ns3::AnimRxInfo', 
 
453
                   [param('ns3::Ptr< ns3::NetDevice const >', 'nd')])
 
454
    ## animation-interface-helper.h (module 'netanim'): void ns3::AnimPacketInfo::ProcessRxBegin(ns3::Ptr<ns3::NetDevice const> nd, ns3::Time const & fbRx) [member function]
 
455
    cls.add_method('ProcessRxBegin', 
 
456
                   'void', 
 
457
                   [param('ns3::Ptr< ns3::NetDevice const >', 'nd'), param('ns3::Time const &', 'fbRx')])
 
458
    ## animation-interface-helper.h (module 'netanim'): void ns3::AnimPacketInfo::ProcessRxDrop(ns3::Ptr<ns3::NetDevice const> nd) [member function]
 
459
    cls.add_method('ProcessRxDrop', 
 
460
                   'void', 
 
461
                   [param('ns3::Ptr< ns3::NetDevice const >', 'nd')])
 
462
    ## animation-interface-helper.h (module 'netanim'): bool ns3::AnimPacketInfo::ProcessRxEnd(ns3::Ptr<ns3::NetDevice const> nd, ns3::Time const & fbRx, ns3::Vector rxLoc) [member function]
 
463
    cls.add_method('ProcessRxEnd', 
 
464
                   'bool', 
 
465
                   [param('ns3::Ptr< ns3::NetDevice const >', 'nd'), param('ns3::Time const &', 'fbRx'), param('ns3::Vector', 'rxLoc')])
 
466
    ## animation-interface-helper.h (module 'netanim'): void ns3::AnimPacketInfo::RemoveRxInfo(ns3::Ptr<ns3::NetDevice const> nd) [member function]
 
467
    cls.add_method('RemoveRxInfo', 
 
468
                   'void', 
 
469
                   [param('ns3::Ptr< ns3::NetDevice const >', 'nd')])
 
470
    ## animation-interface-helper.h (module 'netanim'): ns3::AnimPacketInfo::firstlastbitDelta [variable]
 
471
    cls.add_instance_attribute('firstlastbitDelta', 'double', is_const=False)
 
472
    ## animation-interface-helper.h (module 'netanim'): ns3::AnimPacketInfo::m_fbTx [variable]
 
473
    cls.add_instance_attribute('m_fbTx', 'double', is_const=False)
 
474
    ## animation-interface-helper.h (module 'netanim'): ns3::AnimPacketInfo::m_lbTx [variable]
 
475
    cls.add_instance_attribute('m_lbTx', 'double', is_const=False)
 
476
    ## animation-interface-helper.h (module 'netanim'): ns3::AnimPacketInfo::m_rx [variable]
 
477
    cls.add_instance_attribute('m_rx', 'std::map< unsigned int, ns3::AnimRxInfo >', is_const=False)
 
478
    ## animation-interface-helper.h (module 'netanim'): ns3::AnimPacketInfo::m_txLoc [variable]
 
479
    cls.add_instance_attribute('m_txLoc', 'ns3::Vector', is_const=False)
 
480
    ## animation-interface-helper.h (module 'netanim'): ns3::AnimPacketInfo::m_txnd [variable]
 
481
    cls.add_instance_attribute('m_txnd', 'ns3::Ptr< ns3::NetDevice const >', is_const=False)
 
482
    return
 
483
 
 
484
def register_Ns3AnimRxInfo_methods(root_module, cls):
 
485
    ## animation-interface-helper.h (module 'netanim'): ns3::AnimRxInfo::AnimRxInfo(ns3::AnimRxInfo const & arg0) [copy constructor]
 
486
    cls.add_constructor([param('ns3::AnimRxInfo const &', 'arg0')])
 
487
    ## animation-interface-helper.h (module 'netanim'): ns3::AnimRxInfo::AnimRxInfo() [constructor]
 
488
    cls.add_constructor([])
 
489
    ## animation-interface-helper.h (module 'netanim'): ns3::AnimRxInfo::AnimRxInfo(ns3::Time const & fbRx, ns3::Ptr<ns3::NetDevice const> nd, double rxRange) [constructor]
 
490
    cls.add_constructor([param('ns3::Time const &', 'fbRx'), param('ns3::Ptr< ns3::NetDevice const >', 'nd'), param('double', 'rxRange')])
 
491
    ## animation-interface-helper.h (module 'netanim'): bool ns3::AnimRxInfo::IsPhyRxComplete() [member function]
 
492
    cls.add_method('IsPhyRxComplete', 
 
493
                   'bool', 
 
494
                   [])
 
495
    ## animation-interface-helper.h (module 'netanim'): void ns3::AnimRxInfo::SetPhyRxComplete() [member function]
 
496
    cls.add_method('SetPhyRxComplete', 
 
497
                   'void', 
 
498
                   [])
 
499
    ## animation-interface-helper.h (module 'netanim'): ns3::AnimRxInfo::m_fbRx [variable]
 
500
    cls.add_instance_attribute('m_fbRx', 'double', is_const=False)
 
501
    ## animation-interface-helper.h (module 'netanim'): ns3::AnimRxInfo::m_lbRx [variable]
 
502
    cls.add_instance_attribute('m_lbRx', 'double', is_const=False)
 
503
    ## animation-interface-helper.h (module 'netanim'): ns3::AnimRxInfo::m_rxnd [variable]
 
504
    cls.add_instance_attribute('m_rxnd', 'ns3::Ptr< ns3::NetDevice const >', is_const=False)
 
505
    ## animation-interface-helper.h (module 'netanim'): ns3::AnimRxInfo::rxRange [variable]
 
506
    cls.add_instance_attribute('rxRange', 'double', is_const=False)
 
507
    return
 
508
 
 
509
def register_Ns3AnimationInterface_methods(root_module, cls):
 
510
    ## animation-interface.h (module 'netanim'): ns3::AnimationInterface::AnimationInterface(ns3::AnimationInterface const & arg0) [copy constructor]
 
511
    cls.add_constructor([param('ns3::AnimationInterface const &', 'arg0')])
 
512
    ## animation-interface.h (module 'netanim'): ns3::AnimationInterface::AnimationInterface() [constructor]
 
513
    cls.add_constructor([])
 
514
    ## animation-interface.h (module 'netanim'): ns3::AnimationInterface::AnimationInterface(std::string const filename, bool usingXML=true) [constructor]
 
515
    cls.add_constructor([param('std::string const', 'filename'), param('bool', 'usingXML', default_value='true')])
 
516
    ## animation-interface.h (module 'netanim'): ns3::AnimationInterface::AnimationInterface(uint16_t port, bool usingXML=true) [constructor]
 
517
    cls.add_constructor([param('uint16_t', 'port'), param('bool', 'usingXML', default_value='true')])
 
518
    ## animation-interface.h (module 'netanim'): static bool ns3::AnimationInterface::IsInitialized() [member function]
 
519
    cls.add_method('IsInitialized', 
 
520
                   'bool', 
 
521
                   [], 
 
522
                   is_static=True)
 
523
    ## animation-interface.h (module 'netanim'): bool ns3::AnimationInterface::IsStarted() [member function]
 
524
    cls.add_method('IsStarted', 
 
525
                   'bool', 
 
526
                   [])
 
527
    ## animation-interface.h (module 'netanim'): void ns3::AnimationInterface::ResetAnimWriteCallback() [member function]
 
528
    cls.add_method('ResetAnimWriteCallback', 
 
529
                   'void', 
 
530
                   [])
 
531
    ## animation-interface.h (module 'netanim'): void ns3::AnimationInterface::SetAnimWriteCallback(void (*)( char const * ) * cb) [member function]
 
532
    cls.add_method('SetAnimWriteCallback', 
 
533
                   'void', 
 
534
                   [param('void ( * ) ( char const * ) *', 'cb')])
 
535
    ## animation-interface.h (module 'netanim'): void ns3::AnimationInterface::SetConstantPosition(ns3::Ptr<ns3::Node> n, double x, double y, double z=0) [member function]
 
536
    cls.add_method('SetConstantPosition', 
 
537
                   'void', 
 
538
                   [param('ns3::Ptr< ns3::Node >', 'n'), param('double', 'x'), param('double', 'y'), param('double', 'z', default_value='0')])
 
539
    ## animation-interface.h (module 'netanim'): void ns3::AnimationInterface::SetMobilityPollInterval(ns3::Time t) [member function]
 
540
    cls.add_method('SetMobilityPollInterval', 
 
541
                   'void', 
 
542
                   [param('ns3::Time', 't')])
 
543
    ## animation-interface.h (module 'netanim'): bool ns3::AnimationInterface::SetOutputFile(std::string const & fn) [member function]
 
544
    cls.add_method('SetOutputFile', 
 
545
                   'bool', 
 
546
                   [param('std::string const &', 'fn')])
 
547
    ## animation-interface.h (module 'netanim'): void ns3::AnimationInterface::SetRandomPosition(bool setRandPos) [member function]
 
548
    cls.add_method('SetRandomPosition', 
 
549
                   'void', 
 
550
                   [param('bool', 'setRandPos')])
 
551
    ## animation-interface.h (module 'netanim'): bool ns3::AnimationInterface::SetServerPort(uint16_t port) [member function]
 
552
    cls.add_method('SetServerPort', 
 
553
                   'bool', 
 
554
                   [param('uint16_t', 'port')])
 
555
    ## animation-interface.h (module 'netanim'): void ns3::AnimationInterface::SetXMLOutput() [member function]
 
556
    cls.add_method('SetXMLOutput', 
 
557
                   'void', 
 
558
                   [])
 
559
    ## animation-interface.h (module 'netanim'): void ns3::AnimationInterface::StartAnimation() [member function]
 
560
    cls.add_method('StartAnimation', 
 
561
                   'void', 
 
562
                   [])
 
563
    ## animation-interface.h (module 'netanim'): void ns3::AnimationInterface::StopAnimation() [member function]
 
564
    cls.add_method('StopAnimation', 
 
565
                   'void', 
 
566
                   [])
 
567
    return
 
568
 
 
569
def register_Ns3AttributeConstructionList_methods(root_module, cls):
 
570
    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [copy constructor]
 
571
    cls.add_constructor([param('ns3::AttributeConstructionList const &', 'arg0')])
 
572
    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList() [constructor]
 
573
    cls.add_constructor([])
 
574
    ## attribute-construction-list.h (module 'core'): void ns3::AttributeConstructionList::Add(std::string name, ns3::Ptr<ns3::AttributeChecker const> checker, ns3::Ptr<ns3::AttributeValue> value) [member function]
 
575
    cls.add_method('Add', 
 
576
                   'void', 
 
577
                   [param('std::string', 'name'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::Ptr< ns3::AttributeValue >', 'value')])
 
578
    ## attribute-construction-list.h (module 'core'): std::_List_const_iterator<ns3::AttributeConstructionList::Item> ns3::AttributeConstructionList::Begin() const [member function]
 
579
    cls.add_method('Begin', 
 
580
                   'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', 
 
581
                   [], 
 
582
                   is_const=True)
 
583
    ## attribute-construction-list.h (module 'core'): std::_List_const_iterator<ns3::AttributeConstructionList::Item> ns3::AttributeConstructionList::End() const [member function]
 
584
    cls.add_method('End', 
 
585
                   'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', 
 
586
                   [], 
 
587
                   is_const=True)
 
588
    ## attribute-construction-list.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::AttributeConstructionList::Find(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
 
589
    cls.add_method('Find', 
 
590
                   'ns3::Ptr< ns3::AttributeValue >', 
 
591
                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
592
                   is_const=True)
 
593
    return
 
594
 
 
595
def register_Ns3AttributeConstructionListItem_methods(root_module, cls):
 
596
    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item() [constructor]
 
597
    cls.add_constructor([])
 
598
    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item(ns3::AttributeConstructionList::Item const & arg0) [copy constructor]
 
599
    cls.add_constructor([param('ns3::AttributeConstructionList::Item const &', 'arg0')])
 
600
    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::checker [variable]
 
601
    cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False)
 
602
    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::name [variable]
 
603
    cls.add_instance_attribute('name', 'std::string', is_const=False)
 
604
    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::value [variable]
 
605
    cls.add_instance_attribute('value', 'ns3::Ptr< ns3::AttributeValue >', is_const=False)
 
606
    return
 
607
 
 
608
def register_Ns3Buffer_methods(root_module, cls):
 
609
    ## buffer.h (module 'network'): ns3::Buffer::Buffer() [constructor]
 
610
    cls.add_constructor([])
 
611
    ## buffer.h (module 'network'): ns3::Buffer::Buffer(uint32_t dataSize) [constructor]
 
612
    cls.add_constructor([param('uint32_t', 'dataSize')])
 
613
    ## buffer.h (module 'network'): ns3::Buffer::Buffer(uint32_t dataSize, bool initialize) [constructor]
 
614
    cls.add_constructor([param('uint32_t', 'dataSize'), param('bool', 'initialize')])
 
615
    ## buffer.h (module 'network'): ns3::Buffer::Buffer(ns3::Buffer const & o) [copy constructor]
 
616
    cls.add_constructor([param('ns3::Buffer const &', 'o')])
 
617
    ## buffer.h (module 'network'): bool ns3::Buffer::AddAtEnd(uint32_t end) [member function]
 
618
    cls.add_method('AddAtEnd', 
 
619
                   'bool', 
 
620
                   [param('uint32_t', 'end')])
 
621
    ## buffer.h (module 'network'): void ns3::Buffer::AddAtEnd(ns3::Buffer const & o) [member function]
 
622
    cls.add_method('AddAtEnd', 
 
623
                   'void', 
 
624
                   [param('ns3::Buffer const &', 'o')])
 
625
    ## buffer.h (module 'network'): bool ns3::Buffer::AddAtStart(uint32_t start) [member function]
 
626
    cls.add_method('AddAtStart', 
 
627
                   'bool', 
 
628
                   [param('uint32_t', 'start')])
 
629
    ## buffer.h (module 'network'): ns3::Buffer::Iterator ns3::Buffer::Begin() const [member function]
 
630
    cls.add_method('Begin', 
 
631
                   'ns3::Buffer::Iterator', 
 
632
                   [], 
 
633
                   is_const=True)
 
634
    ## buffer.h (module 'network'): void ns3::Buffer::CopyData(std::ostream * os, uint32_t size) const [member function]
 
635
    cls.add_method('CopyData', 
 
636
                   'void', 
 
637
                   [param('std::ostream *', 'os'), param('uint32_t', 'size')], 
 
638
                   is_const=True)
 
639
    ## buffer.h (module 'network'): uint32_t ns3::Buffer::CopyData(uint8_t * buffer, uint32_t size) const [member function]
 
640
    cls.add_method('CopyData', 
 
641
                   'uint32_t', 
 
642
                   [param('uint8_t *', 'buffer'), param('uint32_t', 'size')], 
 
643
                   is_const=True)
 
644
    ## buffer.h (module 'network'): ns3::Buffer ns3::Buffer::CreateFragment(uint32_t start, uint32_t length) const [member function]
 
645
    cls.add_method('CreateFragment', 
 
646
                   'ns3::Buffer', 
 
647
                   [param('uint32_t', 'start'), param('uint32_t', 'length')], 
 
648
                   is_const=True)
 
649
    ## buffer.h (module 'network'): ns3::Buffer ns3::Buffer::CreateFullCopy() const [member function]
 
650
    cls.add_method('CreateFullCopy', 
 
651
                   'ns3::Buffer', 
 
652
                   [], 
 
653
                   is_const=True)
 
654
    ## buffer.h (module 'network'): uint32_t ns3::Buffer::Deserialize(uint8_t const * buffer, uint32_t size) [member function]
 
655
    cls.add_method('Deserialize', 
 
656
                   'uint32_t', 
 
657
                   [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')])
 
658
    ## buffer.h (module 'network'): ns3::Buffer::Iterator ns3::Buffer::End() const [member function]
 
659
    cls.add_method('End', 
 
660
                   'ns3::Buffer::Iterator', 
 
661
                   [], 
 
662
                   is_const=True)
 
663
    ## buffer.h (module 'network'): int32_t ns3::Buffer::GetCurrentEndOffset() const [member function]
 
664
    cls.add_method('GetCurrentEndOffset', 
 
665
                   'int32_t', 
 
666
                   [], 
 
667
                   is_const=True)
 
668
    ## buffer.h (module 'network'): int32_t ns3::Buffer::GetCurrentStartOffset() const [member function]
 
669
    cls.add_method('GetCurrentStartOffset', 
 
670
                   'int32_t', 
 
671
                   [], 
 
672
                   is_const=True)
 
673
    ## buffer.h (module 'network'): uint32_t ns3::Buffer::GetSerializedSize() const [member function]
 
674
    cls.add_method('GetSerializedSize', 
 
675
                   'uint32_t', 
 
676
                   [], 
 
677
                   is_const=True)
 
678
    ## buffer.h (module 'network'): uint32_t ns3::Buffer::GetSize() const [member function]
 
679
    cls.add_method('GetSize', 
 
680
                   'uint32_t', 
 
681
                   [], 
 
682
                   is_const=True)
 
683
    ## buffer.h (module 'network'): uint8_t const * ns3::Buffer::PeekData() const [member function]
 
684
    cls.add_method('PeekData', 
 
685
                   'uint8_t const *', 
 
686
                   [], 
 
687
                   is_const=True)
 
688
    ## buffer.h (module 'network'): void ns3::Buffer::RemoveAtEnd(uint32_t end) [member function]
 
689
    cls.add_method('RemoveAtEnd', 
 
690
                   'void', 
 
691
                   [param('uint32_t', 'end')])
 
692
    ## buffer.h (module 'network'): void ns3::Buffer::RemoveAtStart(uint32_t start) [member function]
 
693
    cls.add_method('RemoveAtStart', 
 
694
                   'void', 
 
695
                   [param('uint32_t', 'start')])
 
696
    ## buffer.h (module 'network'): uint32_t ns3::Buffer::Serialize(uint8_t * buffer, uint32_t maxSize) const [member function]
 
697
    cls.add_method('Serialize', 
 
698
                   'uint32_t', 
 
699
                   [param('uint8_t *', 'buffer'), param('uint32_t', 'maxSize')], 
 
700
                   is_const=True)
 
701
    return
 
702
 
 
703
def register_Ns3BufferIterator_methods(root_module, cls):
 
704
    ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator(ns3::Buffer::Iterator const & arg0) [copy constructor]
 
705
    cls.add_constructor([param('ns3::Buffer::Iterator const &', 'arg0')])
 
706
    ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator() [constructor]
 
707
    cls.add_constructor([])
 
708
    ## buffer.h (module 'network'): uint16_t ns3::Buffer::Iterator::CalculateIpChecksum(uint16_t size) [member function]
 
709
    cls.add_method('CalculateIpChecksum', 
 
710
                   'uint16_t', 
 
711
                   [param('uint16_t', 'size')])
 
712
    ## buffer.h (module 'network'): uint16_t ns3::Buffer::Iterator::CalculateIpChecksum(uint16_t size, uint32_t initialChecksum) [member function]
 
713
    cls.add_method('CalculateIpChecksum', 
 
714
                   'uint16_t', 
 
715
                   [param('uint16_t', 'size'), param('uint32_t', 'initialChecksum')])
 
716
    ## buffer.h (module 'network'): uint32_t ns3::Buffer::Iterator::GetDistanceFrom(ns3::Buffer::Iterator const & o) const [member function]
 
717
    cls.add_method('GetDistanceFrom', 
 
718
                   'uint32_t', 
 
719
                   [param('ns3::Buffer::Iterator const &', 'o')], 
 
720
                   is_const=True)
 
721
    ## buffer.h (module 'network'): uint32_t ns3::Buffer::Iterator::GetSize() const [member function]
 
722
    cls.add_method('GetSize', 
 
723
                   'uint32_t', 
 
724
                   [], 
 
725
                   is_const=True)
 
726
    ## buffer.h (module 'network'): bool ns3::Buffer::Iterator::IsEnd() const [member function]
 
727
    cls.add_method('IsEnd', 
 
728
                   'bool', 
 
729
                   [], 
 
730
                   is_const=True)
 
731
    ## buffer.h (module 'network'): bool ns3::Buffer::Iterator::IsStart() const [member function]
 
732
    cls.add_method('IsStart', 
 
733
                   'bool', 
 
734
                   [], 
 
735
                   is_const=True)
 
736
    ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Next() [member function]
 
737
    cls.add_method('Next', 
 
738
                   'void', 
 
739
                   [])
 
740
    ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Next(uint32_t delta) [member function]
 
741
    cls.add_method('Next', 
 
742
                   'void', 
 
743
                   [param('uint32_t', 'delta')])
 
744
    ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Prev() [member function]
 
745
    cls.add_method('Prev', 
 
746
                   'void', 
 
747
                   [])
 
748
    ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Prev(uint32_t delta) [member function]
 
749
    cls.add_method('Prev', 
 
750
                   'void', 
 
751
                   [param('uint32_t', 'delta')])
 
752
    ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Read(uint8_t * buffer, uint32_t size) [member function]
 
753
    cls.add_method('Read', 
 
754
                   'void', 
 
755
                   [param('uint8_t *', 'buffer'), param('uint32_t', 'size')])
 
756
    ## buffer.h (module 'network'): uint16_t ns3::Buffer::Iterator::ReadLsbtohU16() [member function]
 
757
    cls.add_method('ReadLsbtohU16', 
 
758
                   'uint16_t', 
 
759
                   [])
 
760
    ## buffer.h (module 'network'): uint32_t ns3::Buffer::Iterator::ReadLsbtohU32() [member function]
 
761
    cls.add_method('ReadLsbtohU32', 
 
762
                   'uint32_t', 
 
763
                   [])
 
764
    ## buffer.h (module 'network'): uint64_t ns3::Buffer::Iterator::ReadLsbtohU64() [member function]
 
765
    cls.add_method('ReadLsbtohU64', 
 
766
                   'uint64_t', 
 
767
                   [])
 
768
    ## buffer.h (module 'network'): uint16_t ns3::Buffer::Iterator::ReadNtohU16() [member function]
 
769
    cls.add_method('ReadNtohU16', 
 
770
                   'uint16_t', 
 
771
                   [])
 
772
    ## buffer.h (module 'network'): uint32_t ns3::Buffer::Iterator::ReadNtohU32() [member function]
 
773
    cls.add_method('ReadNtohU32', 
 
774
                   'uint32_t', 
 
775
                   [])
 
776
    ## buffer.h (module 'network'): uint64_t ns3::Buffer::Iterator::ReadNtohU64() [member function]
 
777
    cls.add_method('ReadNtohU64', 
 
778
                   'uint64_t', 
 
779
                   [])
 
780
    ## buffer.h (module 'network'): uint16_t ns3::Buffer::Iterator::ReadU16() [member function]
 
781
    cls.add_method('ReadU16', 
 
782
                   'uint16_t', 
 
783
                   [])
 
784
    ## buffer.h (module 'network'): uint32_t ns3::Buffer::Iterator::ReadU32() [member function]
 
785
    cls.add_method('ReadU32', 
 
786
                   'uint32_t', 
 
787
                   [])
 
788
    ## buffer.h (module 'network'): uint64_t ns3::Buffer::Iterator::ReadU64() [member function]
 
789
    cls.add_method('ReadU64', 
 
790
                   'uint64_t', 
 
791
                   [])
 
792
    ## buffer.h (module 'network'): uint8_t ns3::Buffer::Iterator::ReadU8() [member function]
 
793
    cls.add_method('ReadU8', 
 
794
                   'uint8_t', 
 
795
                   [])
 
796
    ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Write(uint8_t const * buffer, uint32_t size) [member function]
 
797
    cls.add_method('Write', 
 
798
                   'void', 
 
799
                   [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')])
 
800
    ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Write(ns3::Buffer::Iterator start, ns3::Buffer::Iterator end) [member function]
 
801
    cls.add_method('Write', 
 
802
                   'void', 
 
803
                   [param('ns3::Buffer::Iterator', 'start'), param('ns3::Buffer::Iterator', 'end')])
 
804
    ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtolsbU16(uint16_t data) [member function]
 
805
    cls.add_method('WriteHtolsbU16', 
 
806
                   'void', 
 
807
                   [param('uint16_t', 'data')])
 
808
    ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtolsbU32(uint32_t data) [member function]
 
809
    cls.add_method('WriteHtolsbU32', 
 
810
                   'void', 
 
811
                   [param('uint32_t', 'data')])
 
812
    ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtolsbU64(uint64_t data) [member function]
 
813
    cls.add_method('WriteHtolsbU64', 
 
814
                   'void', 
 
815
                   [param('uint64_t', 'data')])
 
816
    ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtonU16(uint16_t data) [member function]
 
817
    cls.add_method('WriteHtonU16', 
 
818
                   'void', 
 
819
                   [param('uint16_t', 'data')])
 
820
    ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtonU32(uint32_t data) [member function]
 
821
    cls.add_method('WriteHtonU32', 
 
822
                   'void', 
 
823
                   [param('uint32_t', 'data')])
 
824
    ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtonU64(uint64_t data) [member function]
 
825
    cls.add_method('WriteHtonU64', 
 
826
                   'void', 
 
827
                   [param('uint64_t', 'data')])
 
828
    ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU16(uint16_t data) [member function]
 
829
    cls.add_method('WriteU16', 
 
830
                   'void', 
 
831
                   [param('uint16_t', 'data')])
 
832
    ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU32(uint32_t data) [member function]
 
833
    cls.add_method('WriteU32', 
 
834
                   'void', 
 
835
                   [param('uint32_t', 'data')])
 
836
    ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU64(uint64_t data) [member function]
 
837
    cls.add_method('WriteU64', 
 
838
                   'void', 
 
839
                   [param('uint64_t', 'data')])
 
840
    ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU8(uint8_t data) [member function]
 
841
    cls.add_method('WriteU8', 
 
842
                   'void', 
 
843
                   [param('uint8_t', 'data')])
 
844
    ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU8(uint8_t data, uint32_t len) [member function]
 
845
    cls.add_method('WriteU8', 
 
846
                   'void', 
 
847
                   [param('uint8_t', 'data'), param('uint32_t', 'len')])
 
848
    return
 
849
 
 
850
def register_Ns3ByteTagIterator_methods(root_module, cls):
 
851
    ## packet.h (module 'network'): ns3::ByteTagIterator::ByteTagIterator(ns3::ByteTagIterator const & arg0) [copy constructor]
 
852
    cls.add_constructor([param('ns3::ByteTagIterator const &', 'arg0')])
 
853
    ## packet.h (module 'network'): bool ns3::ByteTagIterator::HasNext() const [member function]
 
854
    cls.add_method('HasNext', 
 
855
                   'bool', 
 
856
                   [], 
 
857
                   is_const=True)
 
858
    ## packet.h (module 'network'): ns3::ByteTagIterator::Item ns3::ByteTagIterator::Next() [member function]
 
859
    cls.add_method('Next', 
 
860
                   'ns3::ByteTagIterator::Item', 
 
861
                   [])
 
862
    return
 
863
 
 
864
def register_Ns3ByteTagIteratorItem_methods(root_module, cls):
 
865
    ## packet.h (module 'network'): ns3::ByteTagIterator::Item::Item(ns3::ByteTagIterator::Item const & arg0) [copy constructor]
 
866
    cls.add_constructor([param('ns3::ByteTagIterator::Item const &', 'arg0')])
 
867
    ## packet.h (module 'network'): uint32_t ns3::ByteTagIterator::Item::GetEnd() const [member function]
 
868
    cls.add_method('GetEnd', 
 
869
                   'uint32_t', 
 
870
                   [], 
 
871
                   is_const=True)
 
872
    ## packet.h (module 'network'): uint32_t ns3::ByteTagIterator::Item::GetStart() const [member function]
 
873
    cls.add_method('GetStart', 
 
874
                   'uint32_t', 
 
875
                   [], 
 
876
                   is_const=True)
 
877
    ## packet.h (module 'network'): void ns3::ByteTagIterator::Item::GetTag(ns3::Tag & tag) const [member function]
 
878
    cls.add_method('GetTag', 
 
879
                   'void', 
 
880
                   [param('ns3::Tag &', 'tag')], 
 
881
                   is_const=True)
 
882
    ## packet.h (module 'network'): ns3::TypeId ns3::ByteTagIterator::Item::GetTypeId() const [member function]
 
883
    cls.add_method('GetTypeId', 
 
884
                   'ns3::TypeId', 
 
885
                   [], 
 
886
                   is_const=True)
 
887
    return
 
888
 
 
889
def register_Ns3ByteTagList_methods(root_module, cls):
 
890
    ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList() [constructor]
 
891
    cls.add_constructor([])
 
892
    ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList(ns3::ByteTagList const & o) [copy constructor]
 
893
    cls.add_constructor([param('ns3::ByteTagList const &', 'o')])
 
894
    ## byte-tag-list.h (module 'network'): ns3::TagBuffer ns3::ByteTagList::Add(ns3::TypeId tid, uint32_t bufferSize, int32_t start, int32_t end) [member function]
 
895
    cls.add_method('Add', 
 
896
                   'ns3::TagBuffer', 
 
897
                   [param('ns3::TypeId', 'tid'), param('uint32_t', 'bufferSize'), param('int32_t', 'start'), param('int32_t', 'end')])
 
898
    ## byte-tag-list.h (module 'network'): void ns3::ByteTagList::Add(ns3::ByteTagList const & o) [member function]
 
899
    cls.add_method('Add', 
 
900
                   'void', 
 
901
                   [param('ns3::ByteTagList const &', 'o')])
 
902
    ## byte-tag-list.h (module 'network'): void ns3::ByteTagList::AddAtEnd(int32_t adjustment, int32_t appendOffset) [member function]
 
903
    cls.add_method('AddAtEnd', 
 
904
                   'void', 
 
905
                   [param('int32_t', 'adjustment'), param('int32_t', 'appendOffset')])
 
906
    ## byte-tag-list.h (module 'network'): void ns3::ByteTagList::AddAtStart(int32_t adjustment, int32_t prependOffset) [member function]
 
907
    cls.add_method('AddAtStart', 
 
908
                   'void', 
 
909
                   [param('int32_t', 'adjustment'), param('int32_t', 'prependOffset')])
 
910
    ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator ns3::ByteTagList::Begin(int32_t offsetStart, int32_t offsetEnd) const [member function]
 
911
    cls.add_method('Begin', 
 
912
                   'ns3::ByteTagList::Iterator', 
 
913
                   [param('int32_t', 'offsetStart'), param('int32_t', 'offsetEnd')], 
 
914
                   is_const=True)
 
915
    ## byte-tag-list.h (module 'network'): void ns3::ByteTagList::RemoveAll() [member function]
 
916
    cls.add_method('RemoveAll', 
 
917
                   'void', 
 
918
                   [])
 
919
    return
 
920
 
 
921
def register_Ns3ByteTagListIterator_methods(root_module, cls):
 
922
    ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Iterator(ns3::ByteTagList::Iterator const & arg0) [copy constructor]
 
923
    cls.add_constructor([param('ns3::ByteTagList::Iterator const &', 'arg0')])
 
924
    ## byte-tag-list.h (module 'network'): uint32_t ns3::ByteTagList::Iterator::GetOffsetStart() const [member function]
 
925
    cls.add_method('GetOffsetStart', 
 
926
                   'uint32_t', 
 
927
                   [], 
 
928
                   is_const=True)
 
929
    ## byte-tag-list.h (module 'network'): bool ns3::ByteTagList::Iterator::HasNext() const [member function]
 
930
    cls.add_method('HasNext', 
 
931
                   'bool', 
 
932
                   [], 
 
933
                   is_const=True)
 
934
    ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item ns3::ByteTagList::Iterator::Next() [member function]
 
935
    cls.add_method('Next', 
 
936
                   'ns3::ByteTagList::Iterator::Item', 
 
937
                   [])
 
938
    return
 
939
 
 
940
def register_Ns3ByteTagListIteratorItem_methods(root_module, cls):
 
941
    ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::ByteTagList::Iterator::Item const & arg0) [copy constructor]
 
942
    cls.add_constructor([param('ns3::ByteTagList::Iterator::Item const &', 'arg0')])
 
943
    ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::TagBuffer buf) [constructor]
 
944
    cls.add_constructor([param('ns3::TagBuffer', 'buf')])
 
945
    ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::buf [variable]
 
946
    cls.add_instance_attribute('buf', 'ns3::TagBuffer', is_const=False)
 
947
    ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::end [variable]
 
948
    cls.add_instance_attribute('end', 'int32_t', is_const=False)
 
949
    ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::size [variable]
 
950
    cls.add_instance_attribute('size', 'uint32_t', is_const=False)
 
951
    ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::start [variable]
 
952
    cls.add_instance_attribute('start', 'int32_t', is_const=False)
 
953
    ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::tid [variable]
 
954
    cls.add_instance_attribute('tid', 'ns3::TypeId', is_const=False)
 
955
    return
 
956
 
 
957
def register_Ns3CallbackBase_methods(root_module, cls):
 
958
    ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [copy constructor]
 
959
    cls.add_constructor([param('ns3::CallbackBase const &', 'arg0')])
 
960
    ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase() [constructor]
 
961
    cls.add_constructor([])
 
962
    ## callback.h (module 'core'): ns3::Ptr<ns3::CallbackImplBase> ns3::CallbackBase::GetImpl() const [member function]
 
963
    cls.add_method('GetImpl', 
 
964
                   'ns3::Ptr< ns3::CallbackImplBase >', 
 
965
                   [], 
 
966
                   is_const=True)
 
967
    ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::Ptr<ns3::CallbackImplBase> impl) [constructor]
 
968
    cls.add_constructor([param('ns3::Ptr< ns3::CallbackImplBase >', 'impl')], 
 
969
                        visibility='protected')
 
970
    ## callback.h (module 'core'): static std::string ns3::CallbackBase::Demangle(std::string const & mangled) [member function]
 
971
    cls.add_method('Demangle', 
 
972
                   'std::string', 
 
973
                   [param('std::string const &', 'mangled')], 
 
974
                   is_static=True, visibility='protected')
 
975
    return
 
976
 
 
977
def register_Ns3EventId_methods(root_module, cls):
 
978
    cls.add_binary_comparison_operator('!=')
 
979
    cls.add_binary_comparison_operator('==')
 
980
    ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::EventId const & arg0) [copy constructor]
 
981
    cls.add_constructor([param('ns3::EventId const &', 'arg0')])
 
982
    ## event-id.h (module 'core'): ns3::EventId::EventId() [constructor]
 
983
    cls.add_constructor([])
 
984
    ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::Ptr<ns3::EventImpl> const & impl, uint64_t ts, uint32_t context, uint32_t uid) [constructor]
 
985
    cls.add_constructor([param('ns3::Ptr< ns3::EventImpl > const &', 'impl'), param('uint64_t', 'ts'), param('uint32_t', 'context'), param('uint32_t', 'uid')])
 
986
    ## event-id.h (module 'core'): void ns3::EventId::Cancel() [member function]
 
987
    cls.add_method('Cancel', 
 
988
                   'void', 
 
989
                   [])
 
990
    ## event-id.h (module 'core'): uint32_t ns3::EventId::GetContext() const [member function]
 
991
    cls.add_method('GetContext', 
 
992
                   'uint32_t', 
 
993
                   [], 
 
994
                   is_const=True)
 
995
    ## event-id.h (module 'core'): uint64_t ns3::EventId::GetTs() const [member function]
 
996
    cls.add_method('GetTs', 
 
997
                   'uint64_t', 
 
998
                   [], 
 
999
                   is_const=True)
 
1000
    ## event-id.h (module 'core'): uint32_t ns3::EventId::GetUid() const [member function]
 
1001
    cls.add_method('GetUid', 
 
1002
                   'uint32_t', 
 
1003
                   [], 
 
1004
                   is_const=True)
 
1005
    ## event-id.h (module 'core'): bool ns3::EventId::IsExpired() const [member function]
 
1006
    cls.add_method('IsExpired', 
 
1007
                   'bool', 
 
1008
                   [], 
 
1009
                   is_const=True)
 
1010
    ## event-id.h (module 'core'): bool ns3::EventId::IsRunning() const [member function]
 
1011
    cls.add_method('IsRunning', 
 
1012
                   'bool', 
 
1013
                   [], 
 
1014
                   is_const=True)
 
1015
    ## event-id.h (module 'core'): ns3::EventImpl * ns3::EventId::PeekEventImpl() const [member function]
 
1016
    cls.add_method('PeekEventImpl', 
 
1017
                   'ns3::EventImpl *', 
 
1018
                   [], 
 
1019
                   is_const=True)
 
1020
    return
 
1021
 
 
1022
def register_Ns3Ipv4Address_methods(root_module, cls):
 
1023
    cls.add_binary_comparison_operator('<')
 
1024
    cls.add_binary_comparison_operator('!=')
 
1025
    cls.add_output_stream_operator()
 
1026
    cls.add_binary_comparison_operator('==')
 
1027
    ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor]
 
1028
    cls.add_constructor([param('ns3::Ipv4Address const &', 'arg0')])
 
1029
    ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address() [constructor]
 
1030
    cls.add_constructor([])
 
1031
    ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(uint32_t address) [constructor]
 
1032
    cls.add_constructor([param('uint32_t', 'address')])
 
1033
    ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(char const * address) [constructor]
 
1034
    cls.add_constructor([param('char const *', 'address')])
 
1035
    ## ipv4-address.h (module 'network'): ns3::Ipv4Address ns3::Ipv4Address::CombineMask(ns3::Ipv4Mask const & mask) const [member function]
 
1036
    cls.add_method('CombineMask', 
 
1037
                   'ns3::Ipv4Address', 
 
1038
                   [param('ns3::Ipv4Mask const &', 'mask')], 
 
1039
                   is_const=True)
 
1040
    ## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::ConvertFrom(ns3::Address const & address) [member function]
 
1041
    cls.add_method('ConvertFrom', 
 
1042
                   'ns3::Ipv4Address', 
 
1043
                   [param('ns3::Address const &', 'address')], 
 
1044
                   is_static=True)
 
1045
    ## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::Deserialize(uint8_t const * buf) [member function]
 
1046
    cls.add_method('Deserialize', 
 
1047
                   'ns3::Ipv4Address', 
 
1048
                   [param('uint8_t const *', 'buf')], 
 
1049
                   is_static=True)
 
1050
    ## ipv4-address.h (module 'network'): uint32_t ns3::Ipv4Address::Get() const [member function]
 
1051
    cls.add_method('Get', 
 
1052
                   'uint32_t', 
 
1053
                   [], 
 
1054
                   is_const=True)
 
1055
    ## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::GetAny() [member function]
 
1056
    cls.add_method('GetAny', 
 
1057
                   'ns3::Ipv4Address', 
 
1058
                   [], 
 
1059
                   is_static=True)
 
1060
    ## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::GetBroadcast() [member function]
 
1061
    cls.add_method('GetBroadcast', 
 
1062
                   'ns3::Ipv4Address', 
 
1063
                   [], 
 
1064
                   is_static=True)
 
1065
    ## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::GetLoopback() [member function]
 
1066
    cls.add_method('GetLoopback', 
 
1067
                   'ns3::Ipv4Address', 
 
1068
                   [], 
 
1069
                   is_static=True)
 
1070
    ## ipv4-address.h (module 'network'): ns3::Ipv4Address ns3::Ipv4Address::GetSubnetDirectedBroadcast(ns3::Ipv4Mask const & mask) const [member function]
 
1071
    cls.add_method('GetSubnetDirectedBroadcast', 
 
1072
                   'ns3::Ipv4Address', 
 
1073
                   [param('ns3::Ipv4Mask const &', 'mask')], 
 
1074
                   is_const=True)
 
1075
    ## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::GetZero() [member function]
 
1076
    cls.add_method('GetZero', 
 
1077
                   'ns3::Ipv4Address', 
 
1078
                   [], 
 
1079
                   is_static=True)
 
1080
    ## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsBroadcast() const [member function]
 
1081
    cls.add_method('IsBroadcast', 
 
1082
                   'bool', 
 
1083
                   [], 
 
1084
                   is_const=True)
 
1085
    ## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsEqual(ns3::Ipv4Address const & other) const [member function]
 
1086
    cls.add_method('IsEqual', 
 
1087
                   'bool', 
 
1088
                   [param('ns3::Ipv4Address const &', 'other')], 
 
1089
                   is_const=True)
 
1090
    ## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsLocalMulticast() const [member function]
 
1091
    cls.add_method('IsLocalMulticast', 
 
1092
                   'bool', 
 
1093
                   [], 
 
1094
                   is_const=True)
 
1095
    ## ipv4-address.h (module 'network'): static bool ns3::Ipv4Address::IsMatchingType(ns3::Address const & address) [member function]
 
1096
    cls.add_method('IsMatchingType', 
 
1097
                   'bool', 
 
1098
                   [param('ns3::Address const &', 'address')], 
 
1099
                   is_static=True)
 
1100
    ## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsMulticast() const [member function]
 
1101
    cls.add_method('IsMulticast', 
 
1102
                   'bool', 
 
1103
                   [], 
 
1104
                   is_const=True)
 
1105
    ## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsSubnetDirectedBroadcast(ns3::Ipv4Mask const & mask) const [member function]
 
1106
    cls.add_method('IsSubnetDirectedBroadcast', 
 
1107
                   'bool', 
 
1108
                   [param('ns3::Ipv4Mask const &', 'mask')], 
 
1109
                   is_const=True)
 
1110
    ## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Print(std::ostream & os) const [member function]
 
1111
    cls.add_method('Print', 
 
1112
                   'void', 
 
1113
                   [param('std::ostream &', 'os')], 
 
1114
                   is_const=True)
 
1115
    ## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Serialize(uint8_t * buf) const [member function]
 
1116
    cls.add_method('Serialize', 
 
1117
                   'void', 
 
1118
                   [param('uint8_t *', 'buf')], 
 
1119
                   is_const=True)
 
1120
    ## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Set(uint32_t address) [member function]
 
1121
    cls.add_method('Set', 
 
1122
                   'void', 
 
1123
                   [param('uint32_t', 'address')])
 
1124
    ## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Set(char const * address) [member function]
 
1125
    cls.add_method('Set', 
 
1126
                   'void', 
 
1127
                   [param('char const *', 'address')])
 
1128
    return
 
1129
 
 
1130
def register_Ns3Ipv4Mask_methods(root_module, cls):
 
1131
    cls.add_binary_comparison_operator('!=')
 
1132
    cls.add_output_stream_operator()
 
1133
    cls.add_binary_comparison_operator('==')
 
1134
    ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor]
 
1135
    cls.add_constructor([param('ns3::Ipv4Mask const &', 'arg0')])
 
1136
    ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask() [constructor]
 
1137
    cls.add_constructor([])
 
1138
    ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(uint32_t mask) [constructor]
 
1139
    cls.add_constructor([param('uint32_t', 'mask')])
 
1140
    ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(char const * mask) [constructor]
 
1141
    cls.add_constructor([param('char const *', 'mask')])
 
1142
    ## ipv4-address.h (module 'network'): uint32_t ns3::Ipv4Mask::Get() const [member function]
 
1143
    cls.add_method('Get', 
 
1144
                   'uint32_t', 
 
1145
                   [], 
 
1146
                   is_const=True)
 
1147
    ## ipv4-address.h (module 'network'): uint32_t ns3::Ipv4Mask::GetInverse() const [member function]
 
1148
    cls.add_method('GetInverse', 
 
1149
                   'uint32_t', 
 
1150
                   [], 
 
1151
                   is_const=True)
 
1152
    ## ipv4-address.h (module 'network'): static ns3::Ipv4Mask ns3::Ipv4Mask::GetLoopback() [member function]
 
1153
    cls.add_method('GetLoopback', 
 
1154
                   'ns3::Ipv4Mask', 
 
1155
                   [], 
 
1156
                   is_static=True)
 
1157
    ## ipv4-address.h (module 'network'): static ns3::Ipv4Mask ns3::Ipv4Mask::GetOnes() [member function]
 
1158
    cls.add_method('GetOnes', 
 
1159
                   'ns3::Ipv4Mask', 
 
1160
                   [], 
 
1161
                   is_static=True)
 
1162
    ## ipv4-address.h (module 'network'): uint16_t ns3::Ipv4Mask::GetPrefixLength() const [member function]
 
1163
    cls.add_method('GetPrefixLength', 
 
1164
                   'uint16_t', 
 
1165
                   [], 
 
1166
                   is_const=True)
 
1167
    ## ipv4-address.h (module 'network'): static ns3::Ipv4Mask ns3::Ipv4Mask::GetZero() [member function]
 
1168
    cls.add_method('GetZero', 
 
1169
                   'ns3::Ipv4Mask', 
 
1170
                   [], 
 
1171
                   is_static=True)
 
1172
    ## ipv4-address.h (module 'network'): bool ns3::Ipv4Mask::IsEqual(ns3::Ipv4Mask other) const [member function]
 
1173
    cls.add_method('IsEqual', 
 
1174
                   'bool', 
 
1175
                   [param('ns3::Ipv4Mask', 'other')], 
 
1176
                   is_const=True)
 
1177
    ## ipv4-address.h (module 'network'): bool ns3::Ipv4Mask::IsMatch(ns3::Ipv4Address a, ns3::Ipv4Address b) const [member function]
 
1178
    cls.add_method('IsMatch', 
 
1179
                   'bool', 
 
1180
                   [param('ns3::Ipv4Address', 'a'), param('ns3::Ipv4Address', 'b')], 
 
1181
                   is_const=True)
 
1182
    ## ipv4-address.h (module 'network'): void ns3::Ipv4Mask::Print(std::ostream & os) const [member function]
 
1183
    cls.add_method('Print', 
 
1184
                   'void', 
 
1185
                   [param('std::ostream &', 'os')], 
 
1186
                   is_const=True)
 
1187
    ## ipv4-address.h (module 'network'): void ns3::Ipv4Mask::Set(uint32_t mask) [member function]
 
1188
    cls.add_method('Set', 
 
1189
                   'void', 
 
1190
                   [param('uint32_t', 'mask')])
 
1191
    return
 
1192
 
 
1193
def register_Ns3Ipv6Address_methods(root_module, cls):
 
1194
    cls.add_binary_comparison_operator('<')
 
1195
    cls.add_binary_comparison_operator('!=')
 
1196
    cls.add_output_stream_operator()
 
1197
    cls.add_binary_comparison_operator('==')
 
1198
    ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address() [constructor]
 
1199
    cls.add_constructor([])
 
1200
    ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(char const * address) [constructor]
 
1201
    cls.add_constructor([param('char const *', 'address')])
 
1202
    ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(uint8_t * address) [constructor]
 
1203
    cls.add_constructor([param('uint8_t *', 'address')])
 
1204
    ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const & addr) [copy constructor]
 
1205
    cls.add_constructor([param('ns3::Ipv6Address const &', 'addr')])
 
1206
    ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const * addr) [constructor]
 
1207
    cls.add_constructor([param('ns3::Ipv6Address const *', 'addr')])
 
1208
    ## ipv6-address.h (module 'network'): ns3::Ipv6Address ns3::Ipv6Address::CombinePrefix(ns3::Ipv6Prefix const & prefix) [member function]
 
1209
    cls.add_method('CombinePrefix', 
 
1210
                   'ns3::Ipv6Address', 
 
1211
                   [param('ns3::Ipv6Prefix const &', 'prefix')])
 
1212
    ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::ConvertFrom(ns3::Address const & address) [member function]
 
1213
    cls.add_method('ConvertFrom', 
 
1214
                   'ns3::Ipv6Address', 
 
1215
                   [param('ns3::Address const &', 'address')], 
 
1216
                   is_static=True)
 
1217
    ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::Deserialize(uint8_t const * buf) [member function]
 
1218
    cls.add_method('Deserialize', 
 
1219
                   'ns3::Ipv6Address', 
 
1220
                   [param('uint8_t const *', 'buf')], 
 
1221
                   is_static=True)
 
1222
    ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetAllHostsMulticast() [member function]
 
1223
    cls.add_method('GetAllHostsMulticast', 
 
1224
                   'ns3::Ipv6Address', 
 
1225
                   [], 
 
1226
                   is_static=True)
 
1227
    ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetAllNodesMulticast() [member function]
 
1228
    cls.add_method('GetAllNodesMulticast', 
 
1229
                   'ns3::Ipv6Address', 
 
1230
                   [], 
 
1231
                   is_static=True)
 
1232
    ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetAllRoutersMulticast() [member function]
 
1233
    cls.add_method('GetAllRoutersMulticast', 
 
1234
                   'ns3::Ipv6Address', 
 
1235
                   [], 
 
1236
                   is_static=True)
 
1237
    ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetAny() [member function]
 
1238
    cls.add_method('GetAny', 
 
1239
                   'ns3::Ipv6Address', 
 
1240
                   [], 
 
1241
                   is_static=True)
 
1242
    ## ipv6-address.h (module 'network'): void ns3::Ipv6Address::GetBytes(uint8_t * buf) const [member function]
 
1243
    cls.add_method('GetBytes', 
 
1244
                   'void', 
 
1245
                   [param('uint8_t *', 'buf')], 
 
1246
                   is_const=True)
 
1247
    ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetLoopback() [member function]
 
1248
    cls.add_method('GetLoopback', 
 
1249
                   'ns3::Ipv6Address', 
 
1250
                   [], 
 
1251
                   is_static=True)
 
1252
    ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetOnes() [member function]
 
1253
    cls.add_method('GetOnes', 
 
1254
                   'ns3::Ipv6Address', 
 
1255
                   [], 
 
1256
                   is_static=True)
 
1257
    ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetZero() [member function]
 
1258
    cls.add_method('GetZero', 
 
1259
                   'ns3::Ipv6Address', 
 
1260
                   [], 
 
1261
                   is_static=True)
 
1262
    ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAllHostsMulticast() const [member function]
 
1263
    cls.add_method('IsAllHostsMulticast', 
 
1264
                   'bool', 
 
1265
                   [], 
 
1266
                   is_const=True)
 
1267
    ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAllNodesMulticast() const [member function]
 
1268
    cls.add_method('IsAllNodesMulticast', 
 
1269
                   'bool', 
 
1270
                   [], 
 
1271
                   is_const=True)
 
1272
    ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAllRoutersMulticast() const [member function]
 
1273
    cls.add_method('IsAllRoutersMulticast', 
 
1274
                   'bool', 
 
1275
                   [], 
 
1276
                   is_const=True)
 
1277
    ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAny() const [member function]
 
1278
    cls.add_method('IsAny', 
 
1279
                   'bool', 
 
1280
                   [], 
 
1281
                   is_const=True)
 
1282
    ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsEqual(ns3::Ipv6Address const & other) const [member function]
 
1283
    cls.add_method('IsEqual', 
 
1284
                   'bool', 
 
1285
                   [param('ns3::Ipv6Address const &', 'other')], 
 
1286
                   is_const=True)
 
1287
    ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsLinkLocal() const [member function]
 
1288
    cls.add_method('IsLinkLocal', 
 
1289
                   'bool', 
 
1290
                   [], 
 
1291
                   is_const=True)
 
1292
    ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsLocalhost() const [member function]
 
1293
    cls.add_method('IsLocalhost', 
 
1294
                   'bool', 
 
1295
                   [], 
 
1296
                   is_const=True)
 
1297
    ## ipv6-address.h (module 'network'): static bool ns3::Ipv6Address::IsMatchingType(ns3::Address const & address) [member function]
 
1298
    cls.add_method('IsMatchingType', 
 
1299
                   'bool', 
 
1300
                   [param('ns3::Address const &', 'address')], 
 
1301
                   is_static=True)
 
1302
    ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsMulticast() const [member function]
 
1303
    cls.add_method('IsMulticast', 
 
1304
                   'bool', 
 
1305
                   [], 
 
1306
                   is_const=True)
 
1307
    ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsSolicitedMulticast() const [member function]
 
1308
    cls.add_method('IsSolicitedMulticast', 
 
1309
                   'bool', 
 
1310
                   [], 
 
1311
                   is_const=True)
 
1312
    ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::MakeAutoconfiguredAddress(ns3::Mac48Address addr, ns3::Ipv6Address prefix) [member function]
 
1313
    cls.add_method('MakeAutoconfiguredAddress', 
 
1314
                   'ns3::Ipv6Address', 
 
1315
                   [param('ns3::Mac48Address', 'addr'), param('ns3::Ipv6Address', 'prefix')], 
 
1316
                   is_static=True)
 
1317
    ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::MakeAutoconfiguredLinkLocalAddress(ns3::Mac48Address mac) [member function]
 
1318
    cls.add_method('MakeAutoconfiguredLinkLocalAddress', 
 
1319
                   'ns3::Ipv6Address', 
 
1320
                   [param('ns3::Mac48Address', 'mac')], 
 
1321
                   is_static=True)
 
1322
    ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::MakeSolicitedAddress(ns3::Ipv6Address addr) [member function]
 
1323
    cls.add_method('MakeSolicitedAddress', 
 
1324
                   'ns3::Ipv6Address', 
 
1325
                   [param('ns3::Ipv6Address', 'addr')], 
 
1326
                   is_static=True)
 
1327
    ## ipv6-address.h (module 'network'): void ns3::Ipv6Address::Print(std::ostream & os) const [member function]
 
1328
    cls.add_method('Print', 
 
1329
                   'void', 
 
1330
                   [param('std::ostream &', 'os')], 
 
1331
                   is_const=True)
 
1332
    ## ipv6-address.h (module 'network'): void ns3::Ipv6Address::Serialize(uint8_t * buf) const [member function]
 
1333
    cls.add_method('Serialize', 
 
1334
                   'void', 
 
1335
                   [param('uint8_t *', 'buf')], 
 
1336
                   is_const=True)
 
1337
    ## ipv6-address.h (module 'network'): void ns3::Ipv6Address::Set(char const * address) [member function]
 
1338
    cls.add_method('Set', 
 
1339
                   'void', 
 
1340
                   [param('char const *', 'address')])
 
1341
    ## ipv6-address.h (module 'network'): void ns3::Ipv6Address::Set(uint8_t * address) [member function]
 
1342
    cls.add_method('Set', 
 
1343
                   'void', 
 
1344
                   [param('uint8_t *', 'address')])
 
1345
    return
 
1346
 
 
1347
def register_Ns3Ipv6Prefix_methods(root_module, cls):
 
1348
    cls.add_binary_comparison_operator('!=')
 
1349
    cls.add_output_stream_operator()
 
1350
    cls.add_binary_comparison_operator('==')
 
1351
    ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix() [constructor]
 
1352
    cls.add_constructor([])
 
1353
    ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(uint8_t * prefix) [constructor]
 
1354
    cls.add_constructor([param('uint8_t *', 'prefix')])
 
1355
    ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(char const * prefix) [constructor]
 
1356
    cls.add_constructor([param('char const *', 'prefix')])
 
1357
    ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(uint8_t prefix) [constructor]
 
1358
    cls.add_constructor([param('uint8_t', 'prefix')])
 
1359
    ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const & prefix) [copy constructor]
 
1360
    cls.add_constructor([param('ns3::Ipv6Prefix const &', 'prefix')])
 
1361
    ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const * prefix) [constructor]
 
1362
    cls.add_constructor([param('ns3::Ipv6Prefix const *', 'prefix')])
 
1363
    ## ipv6-address.h (module 'network'): void ns3::Ipv6Prefix::GetBytes(uint8_t * buf) const [member function]
 
1364
    cls.add_method('GetBytes', 
 
1365
                   'void', 
 
1366
                   [param('uint8_t *', 'buf')], 
 
1367
                   is_const=True)
 
1368
    ## ipv6-address.h (module 'network'): static ns3::Ipv6Prefix ns3::Ipv6Prefix::GetLoopback() [member function]
 
1369
    cls.add_method('GetLoopback', 
 
1370
                   'ns3::Ipv6Prefix', 
 
1371
                   [], 
 
1372
                   is_static=True)
 
1373
    ## ipv6-address.h (module 'network'): static ns3::Ipv6Prefix ns3::Ipv6Prefix::GetOnes() [member function]
 
1374
    cls.add_method('GetOnes', 
 
1375
                   'ns3::Ipv6Prefix', 
 
1376
                   [], 
 
1377
                   is_static=True)
 
1378
    ## ipv6-address.h (module 'network'): uint8_t ns3::Ipv6Prefix::GetPrefixLength() const [member function]
 
1379
    cls.add_method('GetPrefixLength', 
 
1380
                   'uint8_t', 
 
1381
                   [], 
 
1382
                   is_const=True)
 
1383
    ## ipv6-address.h (module 'network'): static ns3::Ipv6Prefix ns3::Ipv6Prefix::GetZero() [member function]
 
1384
    cls.add_method('GetZero', 
 
1385
                   'ns3::Ipv6Prefix', 
 
1386
                   [], 
 
1387
                   is_static=True)
 
1388
    ## ipv6-address.h (module 'network'): bool ns3::Ipv6Prefix::IsEqual(ns3::Ipv6Prefix const & other) const [member function]
 
1389
    cls.add_method('IsEqual', 
 
1390
                   'bool', 
 
1391
                   [param('ns3::Ipv6Prefix const &', 'other')], 
 
1392
                   is_const=True)
 
1393
    ## ipv6-address.h (module 'network'): bool ns3::Ipv6Prefix::IsMatch(ns3::Ipv6Address a, ns3::Ipv6Address b) const [member function]
 
1394
    cls.add_method('IsMatch', 
 
1395
                   'bool', 
 
1396
                   [param('ns3::Ipv6Address', 'a'), param('ns3::Ipv6Address', 'b')], 
 
1397
                   is_const=True)
 
1398
    ## ipv6-address.h (module 'network'): void ns3::Ipv6Prefix::Print(std::ostream & os) const [member function]
 
1399
    cls.add_method('Print', 
 
1400
                   'void', 
 
1401
                   [param('std::ostream &', 'os')], 
 
1402
                   is_const=True)
 
1403
    return
 
1404
 
 
1405
def register_Ns3LogComponent_methods(root_module, cls):
 
1406
    ## log.h (module 'core'): ns3::LogComponent::LogComponent(ns3::LogComponent const & arg0) [copy constructor]
 
1407
    cls.add_constructor([param('ns3::LogComponent const &', 'arg0')])
 
1408
    ## log.h (module 'core'): ns3::LogComponent::LogComponent(char const * name) [constructor]
 
1409
    cls.add_constructor([param('char const *', 'name')])
 
1410
    ## log.h (module 'core'): void ns3::LogComponent::Disable(ns3::LogLevel level) [member function]
 
1411
    cls.add_method('Disable', 
 
1412
                   'void', 
 
1413
                   [param('ns3::LogLevel', 'level')])
 
1414
    ## log.h (module 'core'): void ns3::LogComponent::Enable(ns3::LogLevel level) [member function]
 
1415
    cls.add_method('Enable', 
 
1416
                   'void', 
 
1417
                   [param('ns3::LogLevel', 'level')])
 
1418
    ## log.h (module 'core'): void ns3::LogComponent::EnvVarCheck(char const * name) [member function]
 
1419
    cls.add_method('EnvVarCheck', 
 
1420
                   'void', 
 
1421
                   [param('char const *', 'name')])
 
1422
    ## log.h (module 'core'): bool ns3::LogComponent::IsEnabled(ns3::LogLevel level) const [member function]
 
1423
    cls.add_method('IsEnabled', 
 
1424
                   'bool', 
 
1425
                   [param('ns3::LogLevel', 'level')], 
 
1426
                   is_const=True)
 
1427
    ## log.h (module 'core'): bool ns3::LogComponent::IsNoneEnabled() const [member function]
 
1428
    cls.add_method('IsNoneEnabled', 
 
1429
                   'bool', 
 
1430
                   [], 
 
1431
                   is_const=True)
 
1432
    ## log.h (module 'core'): char const * ns3::LogComponent::Name() const [member function]
 
1433
    cls.add_method('Name', 
 
1434
                   'char const *', 
 
1435
                   [], 
 
1436
                   is_const=True)
 
1437
    return
 
1438
 
 
1439
def register_Ns3Mac48Address_methods(root_module, cls):
 
1440
    cls.add_binary_comparison_operator('<')
 
1441
    cls.add_binary_comparison_operator('!=')
 
1442
    cls.add_output_stream_operator()
 
1443
    cls.add_binary_comparison_operator('==')
 
1444
    ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [copy constructor]
 
1445
    cls.add_constructor([param('ns3::Mac48Address const &', 'arg0')])
 
1446
    ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address() [constructor]
 
1447
    cls.add_constructor([])
 
1448
    ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address(char const * str) [constructor]
 
1449
    cls.add_constructor([param('char const *', 'str')])
 
1450
    ## mac48-address.h (module 'network'): static ns3::Mac48Address ns3::Mac48Address::Allocate() [member function]
 
1451
    cls.add_method('Allocate', 
 
1452
                   'ns3::Mac48Address', 
 
1453
                   [], 
 
1454
                   is_static=True)
 
1455
    ## mac48-address.h (module 'network'): static ns3::Mac48Address ns3::Mac48Address::ConvertFrom(ns3::Address const & address) [member function]
 
1456
    cls.add_method('ConvertFrom', 
 
1457
                   'ns3::Mac48Address', 
 
1458
                   [param('ns3::Address const &', 'address')], 
 
1459
                   is_static=True)
 
1460
    ## mac48-address.h (module 'network'): void ns3::Mac48Address::CopyFrom(uint8_t const * buffer) [member function]
 
1461
    cls.add_method('CopyFrom', 
 
1462
                   'void', 
 
1463
                   [param('uint8_t const *', 'buffer')])
 
1464
    ## mac48-address.h (module 'network'): void ns3::Mac48Address::CopyTo(uint8_t * buffer) const [member function]
 
1465
    cls.add_method('CopyTo', 
 
1466
                   'void', 
 
1467
                   [param('uint8_t *', 'buffer')], 
 
1468
                   is_const=True)
 
1469
    ## mac48-address.h (module 'network'): static ns3::Mac48Address ns3::Mac48Address::GetBroadcast() [member function]
 
1470
    cls.add_method('GetBroadcast', 
 
1471
                   'ns3::Mac48Address', 
 
1472
                   [], 
 
1473
                   is_static=True)
 
1474
    ## mac48-address.h (module 'network'): static ns3::Mac48Address ns3::Mac48Address::GetMulticast(ns3::Ipv4Address address) [member function]
 
1475
    cls.add_method('GetMulticast', 
 
1476
                   'ns3::Mac48Address', 
 
1477
                   [param('ns3::Ipv4Address', 'address')], 
 
1478
                   is_static=True)
 
1479
    ## mac48-address.h (module 'network'): static ns3::Mac48Address ns3::Mac48Address::GetMulticast(ns3::Ipv6Address address) [member function]
 
1480
    cls.add_method('GetMulticast', 
 
1481
                   'ns3::Mac48Address', 
 
1482
                   [param('ns3::Ipv6Address', 'address')], 
 
1483
                   is_static=True)
 
1484
    ## mac48-address.h (module 'network'): static ns3::Mac48Address ns3::Mac48Address::GetMulticast6Prefix() [member function]
 
1485
    cls.add_method('GetMulticast6Prefix', 
 
1486
                   'ns3::Mac48Address', 
 
1487
                   [], 
 
1488
                   is_static=True)
 
1489
    ## mac48-address.h (module 'network'): static ns3::Mac48Address ns3::Mac48Address::GetMulticastPrefix() [member function]
 
1490
    cls.add_method('GetMulticastPrefix', 
 
1491
                   'ns3::Mac48Address', 
 
1492
                   [], 
 
1493
                   is_static=True)
 
1494
    ## mac48-address.h (module 'network'): bool ns3::Mac48Address::IsBroadcast() const [member function]
 
1495
    cls.add_method('IsBroadcast', 
 
1496
                   'bool', 
 
1497
                   [], 
 
1498
                   is_const=True)
 
1499
    ## mac48-address.h (module 'network'): bool ns3::Mac48Address::IsGroup() const [member function]
 
1500
    cls.add_method('IsGroup', 
 
1501
                   'bool', 
 
1502
                   [], 
 
1503
                   is_const=True)
 
1504
    ## mac48-address.h (module 'network'): static bool ns3::Mac48Address::IsMatchingType(ns3::Address const & address) [member function]
 
1505
    cls.add_method('IsMatchingType', 
 
1506
                   'bool', 
 
1507
                   [param('ns3::Address const &', 'address')], 
 
1508
                   is_static=True)
 
1509
    return
 
1510
 
 
1511
def register_Ns3NodeList_methods(root_module, cls):
 
1512
    ## node-list.h (module 'network'): ns3::NodeList::NodeList() [constructor]
 
1513
    cls.add_constructor([])
 
1514
    ## node-list.h (module 'network'): ns3::NodeList::NodeList(ns3::NodeList const & arg0) [copy constructor]
 
1515
    cls.add_constructor([param('ns3::NodeList const &', 'arg0')])
 
1516
    ## node-list.h (module 'network'): static uint32_t ns3::NodeList::Add(ns3::Ptr<ns3::Node> node) [member function]
 
1517
    cls.add_method('Add', 
 
1518
                   'uint32_t', 
 
1519
                   [param('ns3::Ptr< ns3::Node >', 'node')], 
 
1520
                   is_static=True)
 
1521
    ## node-list.h (module 'network'): static __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Node>*,std::vector<ns3::Ptr<ns3::Node>, std::allocator<ns3::Ptr<ns3::Node> > > > ns3::NodeList::Begin() [member function]
 
1522
    cls.add_method('Begin', 
 
1523
                   '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', 
 
1524
                   [], 
 
1525
                   is_static=True)
 
1526
    ## node-list.h (module 'network'): static __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Node>*,std::vector<ns3::Ptr<ns3::Node>, std::allocator<ns3::Ptr<ns3::Node> > > > ns3::NodeList::End() [member function]
 
1527
    cls.add_method('End', 
 
1528
                   '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', 
 
1529
                   [], 
 
1530
                   is_static=True)
 
1531
    ## node-list.h (module 'network'): static uint32_t ns3::NodeList::GetNNodes() [member function]
 
1532
    cls.add_method('GetNNodes', 
 
1533
                   'uint32_t', 
 
1534
                   [], 
 
1535
                   is_static=True)
 
1536
    ## node-list.h (module 'network'): static ns3::Ptr<ns3::Node> ns3::NodeList::GetNode(uint32_t n) [member function]
 
1537
    cls.add_method('GetNode', 
 
1538
                   'ns3::Ptr< ns3::Node >', 
 
1539
                   [param('uint32_t', 'n')], 
 
1540
                   is_static=True)
 
1541
    return
 
1542
 
 
1543
def register_Ns3ObjectBase_methods(root_module, cls):
 
1544
    ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase() [constructor]
 
1545
    cls.add_constructor([])
 
1546
    ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor]
 
1547
    cls.add_constructor([param('ns3::ObjectBase const &', 'arg0')])
 
1548
    ## object-base.h (module 'core'): void ns3::ObjectBase::GetAttribute(std::string name, ns3::AttributeValue & value) const [member function]
 
1549
    cls.add_method('GetAttribute', 
 
1550
                   'void', 
 
1551
                   [param('std::string', 'name'), param('ns3::AttributeValue &', 'value')], 
 
1552
                   is_const=True)
 
1553
    ## object-base.h (module 'core'): bool ns3::ObjectBase::GetAttributeFailSafe(std::string name, ns3::AttributeValue & attribute) const [member function]
 
1554
    cls.add_method('GetAttributeFailSafe', 
 
1555
                   'bool', 
 
1556
                   [param('std::string', 'name'), param('ns3::AttributeValue &', 'attribute')], 
 
1557
                   is_const=True)
 
1558
    ## object-base.h (module 'core'): ns3::TypeId ns3::ObjectBase::GetInstanceTypeId() const [member function]
 
1559
    cls.add_method('GetInstanceTypeId', 
 
1560
                   'ns3::TypeId', 
 
1561
                   [], 
 
1562
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
1563
    ## object-base.h (module 'core'): static ns3::TypeId ns3::ObjectBase::GetTypeId() [member function]
 
1564
    cls.add_method('GetTypeId', 
 
1565
                   'ns3::TypeId', 
 
1566
                   [], 
 
1567
                   is_static=True)
 
1568
    ## object-base.h (module 'core'): void ns3::ObjectBase::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]
 
1569
    cls.add_method('SetAttribute', 
 
1570
                   'void', 
 
1571
                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
 
1572
    ## object-base.h (module 'core'): bool ns3::ObjectBase::SetAttributeFailSafe(std::string name, ns3::AttributeValue const & value) [member function]
 
1573
    cls.add_method('SetAttributeFailSafe', 
 
1574
                   'bool', 
 
1575
                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
 
1576
    ## object-base.h (module 'core'): bool ns3::ObjectBase::TraceConnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]
 
1577
    cls.add_method('TraceConnect', 
 
1578
                   'bool', 
 
1579
                   [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')])
 
1580
    ## object-base.h (module 'core'): bool ns3::ObjectBase::TraceConnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
 
1581
    cls.add_method('TraceConnectWithoutContext', 
 
1582
                   'bool', 
 
1583
                   [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
 
1584
    ## object-base.h (module 'core'): bool ns3::ObjectBase::TraceDisconnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]
 
1585
    cls.add_method('TraceDisconnect', 
 
1586
                   'bool', 
 
1587
                   [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')])
 
1588
    ## object-base.h (module 'core'): bool ns3::ObjectBase::TraceDisconnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
 
1589
    cls.add_method('TraceDisconnectWithoutContext', 
 
1590
                   'bool', 
 
1591
                   [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
 
1592
    ## object-base.h (module 'core'): void ns3::ObjectBase::ConstructSelf(ns3::AttributeConstructionList const & attributes) [member function]
 
1593
    cls.add_method('ConstructSelf', 
 
1594
                   'void', 
 
1595
                   [param('ns3::AttributeConstructionList const &', 'attributes')], 
 
1596
                   visibility='protected')
 
1597
    ## object-base.h (module 'core'): void ns3::ObjectBase::NotifyConstructionCompleted() [member function]
 
1598
    cls.add_method('NotifyConstructionCompleted', 
 
1599
                   'void', 
 
1600
                   [], 
 
1601
                   visibility='protected', is_virtual=True)
 
1602
    return
 
1603
 
 
1604
def register_Ns3ObjectDeleter_methods(root_module, cls):
 
1605
    ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter() [constructor]
 
1606
    cls.add_constructor([])
 
1607
    ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter(ns3::ObjectDeleter const & arg0) [copy constructor]
 
1608
    cls.add_constructor([param('ns3::ObjectDeleter const &', 'arg0')])
 
1609
    ## object.h (module 'core'): static void ns3::ObjectDeleter::Delete(ns3::Object * object) [member function]
 
1610
    cls.add_method('Delete', 
 
1611
                   'void', 
 
1612
                   [param('ns3::Object *', 'object')], 
 
1613
                   is_static=True)
 
1614
    return
 
1615
 
 
1616
def register_Ns3ObjectFactory_methods(root_module, cls):
 
1617
    cls.add_output_stream_operator()
 
1618
    ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [copy constructor]
 
1619
    cls.add_constructor([param('ns3::ObjectFactory const &', 'arg0')])
 
1620
    ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory() [constructor]
 
1621
    cls.add_constructor([])
 
1622
    ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(std::string typeId) [constructor]
 
1623
    cls.add_constructor([param('std::string', 'typeId')])
 
1624
    ## object-factory.h (module 'core'): ns3::Ptr<ns3::Object> ns3::ObjectFactory::Create() const [member function]
 
1625
    cls.add_method('Create', 
 
1626
                   'ns3::Ptr< ns3::Object >', 
 
1627
                   [], 
 
1628
                   is_const=True)
 
1629
    ## object-factory.h (module 'core'): ns3::TypeId ns3::ObjectFactory::GetTypeId() const [member function]
 
1630
    cls.add_method('GetTypeId', 
 
1631
                   'ns3::TypeId', 
 
1632
                   [], 
 
1633
                   is_const=True)
 
1634
    ## object-factory.h (module 'core'): void ns3::ObjectFactory::Set(std::string name, ns3::AttributeValue const & value) [member function]
 
1635
    cls.add_method('Set', 
 
1636
                   'void', 
 
1637
                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
 
1638
    ## object-factory.h (module 'core'): void ns3::ObjectFactory::SetTypeId(ns3::TypeId tid) [member function]
 
1639
    cls.add_method('SetTypeId', 
 
1640
                   'void', 
 
1641
                   [param('ns3::TypeId', 'tid')])
 
1642
    ## object-factory.h (module 'core'): void ns3::ObjectFactory::SetTypeId(char const * tid) [member function]
 
1643
    cls.add_method('SetTypeId', 
 
1644
                   'void', 
 
1645
                   [param('char const *', 'tid')])
 
1646
    ## object-factory.h (module 'core'): void ns3::ObjectFactory::SetTypeId(std::string tid) [member function]
 
1647
    cls.add_method('SetTypeId', 
 
1648
                   'void', 
 
1649
                   [param('std::string', 'tid')])
 
1650
    return
 
1651
 
 
1652
def register_Ns3PacketMetadata_methods(root_module, cls):
 
1653
    ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(uint64_t uid, uint32_t size) [constructor]
 
1654
    cls.add_constructor([param('uint64_t', 'uid'), param('uint32_t', 'size')])
 
1655
    ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(ns3::PacketMetadata const & o) [copy constructor]
 
1656
    cls.add_constructor([param('ns3::PacketMetadata const &', 'o')])
 
1657
    ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddAtEnd(ns3::PacketMetadata const & o) [member function]
 
1658
    cls.add_method('AddAtEnd', 
 
1659
                   'void', 
 
1660
                   [param('ns3::PacketMetadata const &', 'o')])
 
1661
    ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddHeader(ns3::Header const & header, uint32_t size) [member function]
 
1662
    cls.add_method('AddHeader', 
 
1663
                   'void', 
 
1664
                   [param('ns3::Header const &', 'header'), param('uint32_t', 'size')])
 
1665
    ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddPaddingAtEnd(uint32_t end) [member function]
 
1666
    cls.add_method('AddPaddingAtEnd', 
 
1667
                   'void', 
 
1668
                   [param('uint32_t', 'end')])
 
1669
    ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddTrailer(ns3::Trailer const & trailer, uint32_t size) [member function]
 
1670
    cls.add_method('AddTrailer', 
 
1671
                   'void', 
 
1672
                   [param('ns3::Trailer const &', 'trailer'), param('uint32_t', 'size')])
 
1673
    ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator ns3::PacketMetadata::BeginItem(ns3::Buffer buffer) const [member function]
 
1674
    cls.add_method('BeginItem', 
 
1675
                   'ns3::PacketMetadata::ItemIterator', 
 
1676
                   [param('ns3::Buffer', 'buffer')], 
 
1677
                   is_const=True)
 
1678
    ## packet-metadata.h (module 'network'): ns3::PacketMetadata ns3::PacketMetadata::CreateFragment(uint32_t start, uint32_t end) const [member function]
 
1679
    cls.add_method('CreateFragment', 
 
1680
                   'ns3::PacketMetadata', 
 
1681
                   [param('uint32_t', 'start'), param('uint32_t', 'end')], 
 
1682
                   is_const=True)
 
1683
    ## packet-metadata.h (module 'network'): uint32_t ns3::PacketMetadata::Deserialize(uint8_t const * buffer, uint32_t size) [member function]
 
1684
    cls.add_method('Deserialize', 
 
1685
                   'uint32_t', 
 
1686
                   [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')])
 
1687
    ## packet-metadata.h (module 'network'): static void ns3::PacketMetadata::Enable() [member function]
 
1688
    cls.add_method('Enable', 
 
1689
                   'void', 
 
1690
                   [], 
 
1691
                   is_static=True)
 
1692
    ## packet-metadata.h (module 'network'): static void ns3::PacketMetadata::EnableChecking() [member function]
 
1693
    cls.add_method('EnableChecking', 
 
1694
                   'void', 
 
1695
                   [], 
 
1696
                   is_static=True)
 
1697
    ## packet-metadata.h (module 'network'): uint32_t ns3::PacketMetadata::GetSerializedSize() const [member function]
 
1698
    cls.add_method('GetSerializedSize', 
 
1699
                   'uint32_t', 
 
1700
                   [], 
 
1701
                   is_const=True)
 
1702
    ## packet-metadata.h (module 'network'): uint64_t ns3::PacketMetadata::GetUid() const [member function]
 
1703
    cls.add_method('GetUid', 
 
1704
                   'uint64_t', 
 
1705
                   [], 
 
1706
                   is_const=True)
 
1707
    ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::RemoveAtEnd(uint32_t end) [member function]
 
1708
    cls.add_method('RemoveAtEnd', 
 
1709
                   'void', 
 
1710
                   [param('uint32_t', 'end')])
 
1711
    ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::RemoveAtStart(uint32_t start) [member function]
 
1712
    cls.add_method('RemoveAtStart', 
 
1713
                   'void', 
 
1714
                   [param('uint32_t', 'start')])
 
1715
    ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::RemoveHeader(ns3::Header const & header, uint32_t size) [member function]
 
1716
    cls.add_method('RemoveHeader', 
 
1717
                   'void', 
 
1718
                   [param('ns3::Header const &', 'header'), param('uint32_t', 'size')])
 
1719
    ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::RemoveTrailer(ns3::Trailer const & trailer, uint32_t size) [member function]
 
1720
    cls.add_method('RemoveTrailer', 
 
1721
                   'void', 
 
1722
                   [param('ns3::Trailer const &', 'trailer'), param('uint32_t', 'size')])
 
1723
    ## packet-metadata.h (module 'network'): uint32_t ns3::PacketMetadata::Serialize(uint8_t * buffer, uint32_t maxSize) const [member function]
 
1724
    cls.add_method('Serialize', 
 
1725
                   'uint32_t', 
 
1726
                   [param('uint8_t *', 'buffer'), param('uint32_t', 'maxSize')], 
 
1727
                   is_const=True)
 
1728
    return
 
1729
 
 
1730
def register_Ns3PacketMetadataItem_methods(root_module, cls):
 
1731
    ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item() [constructor]
 
1732
    cls.add_constructor([])
 
1733
    ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item(ns3::PacketMetadata::Item const & arg0) [copy constructor]
 
1734
    cls.add_constructor([param('ns3::PacketMetadata::Item const &', 'arg0')])
 
1735
    ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::current [variable]
 
1736
    cls.add_instance_attribute('current', 'ns3::Buffer::Iterator', is_const=False)
 
1737
    ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::currentSize [variable]
 
1738
    cls.add_instance_attribute('currentSize', 'uint32_t', is_const=False)
 
1739
    ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::currentTrimedFromEnd [variable]
 
1740
    cls.add_instance_attribute('currentTrimedFromEnd', 'uint32_t', is_const=False)
 
1741
    ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::currentTrimedFromStart [variable]
 
1742
    cls.add_instance_attribute('currentTrimedFromStart', 'uint32_t', is_const=False)
 
1743
    ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::isFragment [variable]
 
1744
    cls.add_instance_attribute('isFragment', 'bool', is_const=False)
 
1745
    ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::tid [variable]
 
1746
    cls.add_instance_attribute('tid', 'ns3::TypeId', is_const=False)
 
1747
    return
 
1748
 
 
1749
def register_Ns3PacketMetadataItemIterator_methods(root_module, cls):
 
1750
    ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata::ItemIterator const & arg0) [copy constructor]
 
1751
    cls.add_constructor([param('ns3::PacketMetadata::ItemIterator const &', 'arg0')])
 
1752
    ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata const * metadata, ns3::Buffer buffer) [constructor]
 
1753
    cls.add_constructor([param('ns3::PacketMetadata const *', 'metadata'), param('ns3::Buffer', 'buffer')])
 
1754
    ## packet-metadata.h (module 'network'): bool ns3::PacketMetadata::ItemIterator::HasNext() const [member function]
 
1755
    cls.add_method('HasNext', 
 
1756
                   'bool', 
 
1757
                   [], 
 
1758
                   is_const=True)
 
1759
    ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item ns3::PacketMetadata::ItemIterator::Next() [member function]
 
1760
    cls.add_method('Next', 
 
1761
                   'ns3::PacketMetadata::Item', 
 
1762
                   [])
 
1763
    return
 
1764
 
 
1765
def register_Ns3PacketTagIterator_methods(root_module, cls):
 
1766
    ## packet.h (module 'network'): ns3::PacketTagIterator::PacketTagIterator(ns3::PacketTagIterator const & arg0) [copy constructor]
 
1767
    cls.add_constructor([param('ns3::PacketTagIterator const &', 'arg0')])
 
1768
    ## packet.h (module 'network'): bool ns3::PacketTagIterator::HasNext() const [member function]
 
1769
    cls.add_method('HasNext', 
 
1770
                   'bool', 
 
1771
                   [], 
 
1772
                   is_const=True)
 
1773
    ## packet.h (module 'network'): ns3::PacketTagIterator::Item ns3::PacketTagIterator::Next() [member function]
 
1774
    cls.add_method('Next', 
 
1775
                   'ns3::PacketTagIterator::Item', 
 
1776
                   [])
 
1777
    return
 
1778
 
 
1779
def register_Ns3PacketTagIteratorItem_methods(root_module, cls):
 
1780
    ## packet.h (module 'network'): ns3::PacketTagIterator::Item::Item(ns3::PacketTagIterator::Item const & arg0) [copy constructor]
 
1781
    cls.add_constructor([param('ns3::PacketTagIterator::Item const &', 'arg0')])
 
1782
    ## packet.h (module 'network'): void ns3::PacketTagIterator::Item::GetTag(ns3::Tag & tag) const [member function]
 
1783
    cls.add_method('GetTag', 
 
1784
                   'void', 
 
1785
                   [param('ns3::Tag &', 'tag')], 
 
1786
                   is_const=True)
 
1787
    ## packet.h (module 'network'): ns3::TypeId ns3::PacketTagIterator::Item::GetTypeId() const [member function]
 
1788
    cls.add_method('GetTypeId', 
 
1789
                   'ns3::TypeId', 
 
1790
                   [], 
 
1791
                   is_const=True)
 
1792
    return
 
1793
 
 
1794
def register_Ns3PacketTagList_methods(root_module, cls):
 
1795
    ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList() [constructor]
 
1796
    cls.add_constructor([])
 
1797
    ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList(ns3::PacketTagList const & o) [copy constructor]
 
1798
    cls.add_constructor([param('ns3::PacketTagList const &', 'o')])
 
1799
    ## packet-tag-list.h (module 'network'): void ns3::PacketTagList::Add(ns3::Tag const & tag) const [member function]
 
1800
    cls.add_method('Add', 
 
1801
                   'void', 
 
1802
                   [param('ns3::Tag const &', 'tag')], 
 
1803
                   is_const=True)
 
1804
    ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData const * ns3::PacketTagList::Head() const [member function]
 
1805
    cls.add_method('Head', 
 
1806
                   'ns3::PacketTagList::TagData const *', 
 
1807
                   [], 
 
1808
                   is_const=True)
 
1809
    ## packet-tag-list.h (module 'network'): bool ns3::PacketTagList::Peek(ns3::Tag & tag) const [member function]
 
1810
    cls.add_method('Peek', 
 
1811
                   'bool', 
 
1812
                   [param('ns3::Tag &', 'tag')], 
 
1813
                   is_const=True)
 
1814
    ## packet-tag-list.h (module 'network'): bool ns3::PacketTagList::Remove(ns3::Tag & tag) [member function]
 
1815
    cls.add_method('Remove', 
 
1816
                   'bool', 
 
1817
                   [param('ns3::Tag &', 'tag')])
 
1818
    ## packet-tag-list.h (module 'network'): void ns3::PacketTagList::RemoveAll() [member function]
 
1819
    cls.add_method('RemoveAll', 
 
1820
                   'void', 
 
1821
                   [])
 
1822
    return
 
1823
 
 
1824
def register_Ns3PacketTagListTagData_methods(root_module, cls):
 
1825
    ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData() [constructor]
 
1826
    cls.add_constructor([])
 
1827
    ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData(ns3::PacketTagList::TagData const & arg0) [copy constructor]
 
1828
    cls.add_constructor([param('ns3::PacketTagList::TagData const &', 'arg0')])
 
1829
    ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::count [variable]
 
1830
    cls.add_instance_attribute('count', 'uint32_t', is_const=False)
 
1831
    ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::data [variable]
 
1832
    cls.add_instance_attribute('data', 'uint8_t [ 20 ]', is_const=False)
 
1833
    ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::next [variable]
 
1834
    cls.add_instance_attribute('next', 'ns3::PacketTagList::TagData *', is_const=False)
 
1835
    ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::tid [variable]
 
1836
    cls.add_instance_attribute('tid', 'ns3::TypeId', is_const=False)
 
1837
    return
 
1838
 
 
1839
def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, cls):
 
1840
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter>::SimpleRefCount() [constructor]
 
1841
    cls.add_constructor([])
 
1842
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter>::SimpleRefCount(ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter> const & o) [copy constructor]
 
1843
    cls.add_constructor([param('ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter > const &', 'o')])
 
1844
    ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter>::Cleanup() [member function]
 
1845
    cls.add_method('Cleanup', 
 
1846
                   'void', 
 
1847
                   [], 
 
1848
                   is_static=True)
 
1849
    return
 
1850
 
 
1851
def register_Ns3Simulator_methods(root_module, cls):
 
1852
    ## simulator.h (module 'core'): ns3::Simulator::Simulator(ns3::Simulator const & arg0) [copy constructor]
 
1853
    cls.add_constructor([param('ns3::Simulator const &', 'arg0')])
 
1854
    ## simulator.h (module 'core'): static void ns3::Simulator::Cancel(ns3::EventId const & id) [member function]
 
1855
    cls.add_method('Cancel', 
 
1856
                   'void', 
 
1857
                   [param('ns3::EventId const &', 'id')], 
 
1858
                   is_static=True)
 
1859
    ## simulator.h (module 'core'): static void ns3::Simulator::Destroy() [member function]
 
1860
    cls.add_method('Destroy', 
 
1861
                   'void', 
 
1862
                   [], 
 
1863
                   is_static=True)
 
1864
    ## simulator.h (module 'core'): static uint32_t ns3::Simulator::GetContext() [member function]
 
1865
    cls.add_method('GetContext', 
 
1866
                   'uint32_t', 
 
1867
                   [], 
 
1868
                   is_static=True)
 
1869
    ## simulator.h (module 'core'): static ns3::Time ns3::Simulator::GetDelayLeft(ns3::EventId const & id) [member function]
 
1870
    cls.add_method('GetDelayLeft', 
 
1871
                   'ns3::Time', 
 
1872
                   [param('ns3::EventId const &', 'id')], 
 
1873
                   is_static=True)
 
1874
    ## simulator.h (module 'core'): static ns3::Ptr<ns3::SimulatorImpl> ns3::Simulator::GetImplementation() [member function]
 
1875
    cls.add_method('GetImplementation', 
 
1876
                   'ns3::Ptr< ns3::SimulatorImpl >', 
 
1877
                   [], 
 
1878
                   is_static=True)
 
1879
    ## simulator.h (module 'core'): static ns3::Time ns3::Simulator::GetMaximumSimulationTime() [member function]
 
1880
    cls.add_method('GetMaximumSimulationTime', 
 
1881
                   'ns3::Time', 
 
1882
                   [], 
 
1883
                   is_static=True)
 
1884
    ## simulator.h (module 'core'): static uint32_t ns3::Simulator::GetSystemId() [member function]
 
1885
    cls.add_method('GetSystemId', 
 
1886
                   'uint32_t', 
 
1887
                   [], 
 
1888
                   is_static=True)
 
1889
    ## simulator.h (module 'core'): static bool ns3::Simulator::IsExpired(ns3::EventId const & id) [member function]
 
1890
    cls.add_method('IsExpired', 
 
1891
                   'bool', 
 
1892
                   [param('ns3::EventId const &', 'id')], 
 
1893
                   is_static=True)
 
1894
    ## simulator.h (module 'core'): static bool ns3::Simulator::IsFinished() [member function]
 
1895
    cls.add_method('IsFinished', 
 
1896
                   'bool', 
 
1897
                   [], 
 
1898
                   is_static=True)
 
1899
    ## simulator.h (module 'core'): static ns3::Time ns3::Simulator::Next() [member function]
 
1900
    cls.add_method('Next', 
 
1901
                   'ns3::Time', 
 
1902
                   [], 
 
1903
                   is_static=True, deprecated=True)
 
1904
    ## simulator.h (module 'core'): static ns3::Time ns3::Simulator::Now() [member function]
 
1905
    cls.add_method('Now', 
 
1906
                   'ns3::Time', 
 
1907
                   [], 
 
1908
                   is_static=True)
 
1909
    ## simulator.h (module 'core'): static void ns3::Simulator::Remove(ns3::EventId const & id) [member function]
 
1910
    cls.add_method('Remove', 
 
1911
                   'void', 
 
1912
                   [param('ns3::EventId const &', 'id')], 
 
1913
                   is_static=True)
 
1914
    ## simulator.h (module 'core'): static void ns3::Simulator::RunOneEvent() [member function]
 
1915
    cls.add_method('RunOneEvent', 
 
1916
                   'void', 
 
1917
                   [], 
 
1918
                   is_static=True, deprecated=True)
 
1919
    ## simulator.h (module 'core'): static void ns3::Simulator::SetImplementation(ns3::Ptr<ns3::SimulatorImpl> impl) [member function]
 
1920
    cls.add_method('SetImplementation', 
 
1921
                   'void', 
 
1922
                   [param('ns3::Ptr< ns3::SimulatorImpl >', 'impl')], 
 
1923
                   is_static=True)
 
1924
    ## simulator.h (module 'core'): static void ns3::Simulator::SetScheduler(ns3::ObjectFactory schedulerFactory) [member function]
 
1925
    cls.add_method('SetScheduler', 
 
1926
                   'void', 
 
1927
                   [param('ns3::ObjectFactory', 'schedulerFactory')], 
 
1928
                   is_static=True)
 
1929
    ## simulator.h (module 'core'): static void ns3::Simulator::Stop() [member function]
 
1930
    cls.add_method('Stop', 
 
1931
                   'void', 
 
1932
                   [], 
 
1933
                   is_static=True)
 
1934
    ## simulator.h (module 'core'): static void ns3::Simulator::Stop(ns3::Time const & time) [member function]
 
1935
    cls.add_method('Stop', 
 
1936
                   'void', 
 
1937
                   [param('ns3::Time const &', 'time')], 
 
1938
                   is_static=True)
 
1939
    return
 
1940
 
 
1941
def register_Ns3Tag_methods(root_module, cls):
 
1942
    ## tag.h (module 'network'): ns3::Tag::Tag() [constructor]
 
1943
    cls.add_constructor([])
 
1944
    ## tag.h (module 'network'): ns3::Tag::Tag(ns3::Tag const & arg0) [copy constructor]
 
1945
    cls.add_constructor([param('ns3::Tag const &', 'arg0')])
 
1946
    ## tag.h (module 'network'): void ns3::Tag::Deserialize(ns3::TagBuffer i) [member function]
 
1947
    cls.add_method('Deserialize', 
 
1948
                   'void', 
 
1949
                   [param('ns3::TagBuffer', 'i')], 
 
1950
                   is_pure_virtual=True, is_virtual=True)
 
1951
    ## tag.h (module 'network'): uint32_t ns3::Tag::GetSerializedSize() const [member function]
 
1952
    cls.add_method('GetSerializedSize', 
 
1953
                   'uint32_t', 
 
1954
                   [], 
 
1955
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
1956
    ## tag.h (module 'network'): static ns3::TypeId ns3::Tag::GetTypeId() [member function]
 
1957
    cls.add_method('GetTypeId', 
 
1958
                   'ns3::TypeId', 
 
1959
                   [], 
 
1960
                   is_static=True)
 
1961
    ## tag.h (module 'network'): void ns3::Tag::Print(std::ostream & os) const [member function]
 
1962
    cls.add_method('Print', 
 
1963
                   'void', 
 
1964
                   [param('std::ostream &', 'os')], 
 
1965
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
1966
    ## tag.h (module 'network'): void ns3::Tag::Serialize(ns3::TagBuffer i) const [member function]
 
1967
    cls.add_method('Serialize', 
 
1968
                   'void', 
 
1969
                   [param('ns3::TagBuffer', 'i')], 
 
1970
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
1971
    return
 
1972
 
 
1973
def register_Ns3TagBuffer_methods(root_module, cls):
 
1974
    ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(ns3::TagBuffer const & arg0) [copy constructor]
 
1975
    cls.add_constructor([param('ns3::TagBuffer const &', 'arg0')])
 
1976
    ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(uint8_t * start, uint8_t * end) [constructor]
 
1977
    cls.add_constructor([param('uint8_t *', 'start'), param('uint8_t *', 'end')])
 
1978
    ## tag-buffer.h (module 'network'): void ns3::TagBuffer::CopyFrom(ns3::TagBuffer o) [member function]
 
1979
    cls.add_method('CopyFrom', 
 
1980
                   'void', 
 
1981
                   [param('ns3::TagBuffer', 'o')])
 
1982
    ## tag-buffer.h (module 'network'): void ns3::TagBuffer::Read(uint8_t * buffer, uint32_t size) [member function]
 
1983
    cls.add_method('Read', 
 
1984
                   'void', 
 
1985
                   [param('uint8_t *', 'buffer'), param('uint32_t', 'size')])
 
1986
    ## tag-buffer.h (module 'network'): double ns3::TagBuffer::ReadDouble() [member function]
 
1987
    cls.add_method('ReadDouble', 
 
1988
                   'double', 
 
1989
                   [])
 
1990
    ## tag-buffer.h (module 'network'): uint16_t ns3::TagBuffer::ReadU16() [member function]
 
1991
    cls.add_method('ReadU16', 
 
1992
                   'uint16_t', 
 
1993
                   [])
 
1994
    ## tag-buffer.h (module 'network'): uint32_t ns3::TagBuffer::ReadU32() [member function]
 
1995
    cls.add_method('ReadU32', 
 
1996
                   'uint32_t', 
 
1997
                   [])
 
1998
    ## tag-buffer.h (module 'network'): uint64_t ns3::TagBuffer::ReadU64() [member function]
 
1999
    cls.add_method('ReadU64', 
 
2000
                   'uint64_t', 
 
2001
                   [])
 
2002
    ## tag-buffer.h (module 'network'): uint8_t ns3::TagBuffer::ReadU8() [member function]
 
2003
    cls.add_method('ReadU8', 
 
2004
                   'uint8_t', 
 
2005
                   [])
 
2006
    ## tag-buffer.h (module 'network'): void ns3::TagBuffer::TrimAtEnd(uint32_t trim) [member function]
 
2007
    cls.add_method('TrimAtEnd', 
 
2008
                   'void', 
 
2009
                   [param('uint32_t', 'trim')])
 
2010
    ## tag-buffer.h (module 'network'): void ns3::TagBuffer::Write(uint8_t const * buffer, uint32_t size) [member function]
 
2011
    cls.add_method('Write', 
 
2012
                   'void', 
 
2013
                   [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')])
 
2014
    ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteDouble(double v) [member function]
 
2015
    cls.add_method('WriteDouble', 
 
2016
                   'void', 
 
2017
                   [param('double', 'v')])
 
2018
    ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU16(uint16_t data) [member function]
 
2019
    cls.add_method('WriteU16', 
 
2020
                   'void', 
 
2021
                   [param('uint16_t', 'data')])
 
2022
    ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU32(uint32_t data) [member function]
 
2023
    cls.add_method('WriteU32', 
 
2024
                   'void', 
 
2025
                   [param('uint32_t', 'data')])
 
2026
    ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU64(uint64_t v) [member function]
 
2027
    cls.add_method('WriteU64', 
 
2028
                   'void', 
 
2029
                   [param('uint64_t', 'v')])
 
2030
    ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU8(uint8_t v) [member function]
 
2031
    cls.add_method('WriteU8', 
 
2032
                   'void', 
 
2033
                   [param('uint8_t', 'v')])
 
2034
    return
 
2035
 
 
2036
def register_Ns3TypeId_methods(root_module, cls):
 
2037
    cls.add_binary_comparison_operator('<')
 
2038
    cls.add_binary_comparison_operator('!=')
 
2039
    cls.add_output_stream_operator()
 
2040
    cls.add_binary_comparison_operator('==')
 
2041
    ## type-id.h (module 'core'): ns3::TypeId::TypeId(char const * name) [constructor]
 
2042
    cls.add_constructor([param('char const *', 'name')])
 
2043
    ## type-id.h (module 'core'): ns3::TypeId::TypeId() [constructor]
 
2044
    cls.add_constructor([])
 
2045
    ## type-id.h (module 'core'): ns3::TypeId::TypeId(ns3::TypeId const & o) [copy constructor]
 
2046
    cls.add_constructor([param('ns3::TypeId const &', 'o')])
 
2047
    ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr<ns3::AttributeAccessor const> accessor, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
 
2048
    cls.add_method('AddAttribute', 
 
2049
                   'ns3::TypeId', 
 
2050
                   [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')])
 
2051
    ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr<ns3::AttributeAccessor const> accessor, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
 
2052
    cls.add_method('AddAttribute', 
 
2053
                   'ns3::TypeId', 
 
2054
                   [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')])
 
2055
    ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr<ns3::TraceSourceAccessor const> accessor) [member function]
 
2056
    cls.add_method('AddTraceSource', 
 
2057
                   'ns3::TypeId', 
 
2058
                   [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')])
 
2059
    ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation ns3::TypeId::GetAttribute(uint32_t i) const [member function]
 
2060
    cls.add_method('GetAttribute', 
 
2061
                   'ns3::TypeId::AttributeInformation', 
 
2062
                   [param('uint32_t', 'i')], 
 
2063
                   is_const=True)
 
2064
    ## type-id.h (module 'core'): std::string ns3::TypeId::GetAttributeFullName(uint32_t i) const [member function]
 
2065
    cls.add_method('GetAttributeFullName', 
 
2066
                   'std::string', 
 
2067
                   [param('uint32_t', 'i')], 
 
2068
                   is_const=True)
 
2069
    ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetAttributeN() const [member function]
 
2070
    cls.add_method('GetAttributeN', 
 
2071
                   'uint32_t', 
 
2072
                   [], 
 
2073
                   is_const=True)
 
2074
    ## type-id.h (module 'core'): ns3::Callback<ns3::ObjectBase*,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ns3::TypeId::GetConstructor() const [member function]
 
2075
    cls.add_method('GetConstructor', 
 
2076
                   'ns3::Callback< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 
 
2077
                   [], 
 
2078
                   is_const=True)
 
2079
    ## type-id.h (module 'core'): std::string ns3::TypeId::GetGroupName() const [member function]
 
2080
    cls.add_method('GetGroupName', 
 
2081
                   'std::string', 
 
2082
                   [], 
 
2083
                   is_const=True)
 
2084
    ## type-id.h (module 'core'): std::string ns3::TypeId::GetName() const [member function]
 
2085
    cls.add_method('GetName', 
 
2086
                   'std::string', 
 
2087
                   [], 
 
2088
                   is_const=True)
 
2089
    ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::GetParent() const [member function]
 
2090
    cls.add_method('GetParent', 
 
2091
                   'ns3::TypeId', 
 
2092
                   [], 
 
2093
                   is_const=True)
 
2094
    ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::GetRegistered(uint32_t i) [member function]
 
2095
    cls.add_method('GetRegistered', 
 
2096
                   'ns3::TypeId', 
 
2097
                   [param('uint32_t', 'i')], 
 
2098
                   is_static=True)
 
2099
    ## type-id.h (module 'core'): static uint32_t ns3::TypeId::GetRegisteredN() [member function]
 
2100
    cls.add_method('GetRegisteredN', 
 
2101
                   'uint32_t', 
 
2102
                   [], 
 
2103
                   is_static=True)
 
2104
    ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation ns3::TypeId::GetTraceSource(uint32_t i) const [member function]
 
2105
    cls.add_method('GetTraceSource', 
 
2106
                   'ns3::TypeId::TraceSourceInformation', 
 
2107
                   [param('uint32_t', 'i')], 
 
2108
                   is_const=True)
 
2109
    ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetTraceSourceN() const [member function]
 
2110
    cls.add_method('GetTraceSourceN', 
 
2111
                   'uint32_t', 
 
2112
                   [], 
 
2113
                   is_const=True)
 
2114
    ## type-id.h (module 'core'): uint16_t ns3::TypeId::GetUid() const [member function]
 
2115
    cls.add_method('GetUid', 
 
2116
                   'uint16_t', 
 
2117
                   [], 
 
2118
                   is_const=True)
 
2119
    ## type-id.h (module 'core'): bool ns3::TypeId::HasConstructor() const [member function]
 
2120
    cls.add_method('HasConstructor', 
 
2121
                   'bool', 
 
2122
                   [], 
 
2123
                   is_const=True)
 
2124
    ## type-id.h (module 'core'): bool ns3::TypeId::HasParent() const [member function]
 
2125
    cls.add_method('HasParent', 
 
2126
                   'bool', 
 
2127
                   [], 
 
2128
                   is_const=True)
 
2129
    ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::HideFromDocumentation() [member function]
 
2130
    cls.add_method('HideFromDocumentation', 
 
2131
                   'ns3::TypeId', 
 
2132
                   [])
 
2133
    ## type-id.h (module 'core'): bool ns3::TypeId::IsChildOf(ns3::TypeId other) const [member function]
 
2134
    cls.add_method('IsChildOf', 
 
2135
                   'bool', 
 
2136
                   [param('ns3::TypeId', 'other')], 
 
2137
                   is_const=True)
 
2138
    ## type-id.h (module 'core'): bool ns3::TypeId::LookupAttributeByName(std::string name, ns3::TypeId::AttributeInformation * info) const [member function]
 
2139
    cls.add_method('LookupAttributeByName', 
 
2140
                   'bool', 
 
2141
                   [param('std::string', 'name'), param('ns3::TypeId::AttributeInformation *', 'info')], 
 
2142
                   is_const=True)
 
2143
    ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByName(std::string name) [member function]
 
2144
    cls.add_method('LookupByName', 
 
2145
                   'ns3::TypeId', 
 
2146
                   [param('std::string', 'name')], 
 
2147
                   is_static=True)
 
2148
    ## type-id.h (module 'core'): ns3::Ptr<ns3::TraceSourceAccessor const> ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function]
 
2149
    cls.add_method('LookupTraceSourceByName', 
 
2150
                   'ns3::Ptr< ns3::TraceSourceAccessor const >', 
 
2151
                   [param('std::string', 'name')], 
 
2152
                   is_const=True)
 
2153
    ## type-id.h (module 'core'): bool ns3::TypeId::MustHideFromDocumentation() const [member function]
 
2154
    cls.add_method('MustHideFromDocumentation', 
 
2155
                   'bool', 
 
2156
                   [], 
 
2157
                   is_const=True)
 
2158
    ## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr<ns3::AttributeValue const> initialValue) [member function]
 
2159
    cls.add_method('SetAttributeInitialValue', 
 
2160
                   'bool', 
 
2161
                   [param('uint32_t', 'i'), param('ns3::Ptr< ns3::AttributeValue const >', 'initialValue')])
 
2162
    ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::SetGroupName(std::string groupName) [member function]
 
2163
    cls.add_method('SetGroupName', 
 
2164
                   'ns3::TypeId', 
 
2165
                   [param('std::string', 'groupName')])
 
2166
    ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::SetParent(ns3::TypeId tid) [member function]
 
2167
    cls.add_method('SetParent', 
 
2168
                   'ns3::TypeId', 
 
2169
                   [param('ns3::TypeId', 'tid')])
 
2170
    ## type-id.h (module 'core'): void ns3::TypeId::SetUid(uint16_t tid) [member function]
 
2171
    cls.add_method('SetUid', 
 
2172
                   'void', 
 
2173
                   [param('uint16_t', 'tid')])
 
2174
    return
 
2175
 
 
2176
def register_Ns3TypeIdAttributeInformation_methods(root_module, cls):
 
2177
    ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation() [constructor]
 
2178
    cls.add_constructor([])
 
2179
    ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation(ns3::TypeId::AttributeInformation const & arg0) [copy constructor]
 
2180
    cls.add_constructor([param('ns3::TypeId::AttributeInformation const &', 'arg0')])
 
2181
    ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::accessor [variable]
 
2182
    cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::AttributeAccessor const >', is_const=False)
 
2183
    ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::checker [variable]
 
2184
    cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False)
 
2185
    ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::flags [variable]
 
2186
    cls.add_instance_attribute('flags', 'uint32_t', is_const=False)
 
2187
    ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::help [variable]
 
2188
    cls.add_instance_attribute('help', 'std::string', is_const=False)
 
2189
    ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::initialValue [variable]
 
2190
    cls.add_instance_attribute('initialValue', 'ns3::Ptr< ns3::AttributeValue const >', is_const=False)
 
2191
    ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::name [variable]
 
2192
    cls.add_instance_attribute('name', 'std::string', is_const=False)
 
2193
    ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::originalInitialValue [variable]
 
2194
    cls.add_instance_attribute('originalInitialValue', 'ns3::Ptr< ns3::AttributeValue const >', is_const=False)
 
2195
    return
 
2196
 
 
2197
def register_Ns3TypeIdTraceSourceInformation_methods(root_module, cls):
 
2198
    ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation() [constructor]
 
2199
    cls.add_constructor([])
 
2200
    ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation(ns3::TypeId::TraceSourceInformation const & arg0) [copy constructor]
 
2201
    cls.add_constructor([param('ns3::TypeId::TraceSourceInformation const &', 'arg0')])
 
2202
    ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::accessor [variable]
 
2203
    cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::TraceSourceAccessor const >', is_const=False)
 
2204
    ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::help [variable]
 
2205
    cls.add_instance_attribute('help', 'std::string', is_const=False)
 
2206
    ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::name [variable]
 
2207
    cls.add_instance_attribute('name', 'std::string', is_const=False)
 
2208
    return
 
2209
 
 
2210
def register_Ns3Vector2D_methods(root_module, cls):
 
2211
    cls.add_output_stream_operator()
 
2212
    ## vector.h (module 'core'): ns3::Vector2D::Vector2D(ns3::Vector2D const & arg0) [copy constructor]
 
2213
    cls.add_constructor([param('ns3::Vector2D const &', 'arg0')])
 
2214
    ## vector.h (module 'core'): ns3::Vector2D::Vector2D(double _x, double _y) [constructor]
 
2215
    cls.add_constructor([param('double', '_x'), param('double', '_y')])
 
2216
    ## vector.h (module 'core'): ns3::Vector2D::Vector2D() [constructor]
 
2217
    cls.add_constructor([])
 
2218
    ## vector.h (module 'core'): ns3::Vector2D::x [variable]
 
2219
    cls.add_instance_attribute('x', 'double', is_const=False)
 
2220
    ## vector.h (module 'core'): ns3::Vector2D::y [variable]
 
2221
    cls.add_instance_attribute('y', 'double', is_const=False)
 
2222
    return
 
2223
 
 
2224
def register_Ns3Vector3D_methods(root_module, cls):
 
2225
    cls.add_output_stream_operator()
 
2226
    ## vector.h (module 'core'): ns3::Vector3D::Vector3D(ns3::Vector3D const & arg0) [copy constructor]
 
2227
    cls.add_constructor([param('ns3::Vector3D const &', 'arg0')])
 
2228
    ## vector.h (module 'core'): ns3::Vector3D::Vector3D(double _x, double _y, double _z) [constructor]
 
2229
    cls.add_constructor([param('double', '_x'), param('double', '_y'), param('double', '_z')])
 
2230
    ## vector.h (module 'core'): ns3::Vector3D::Vector3D() [constructor]
 
2231
    cls.add_constructor([])
 
2232
    ## vector.h (module 'core'): ns3::Vector3D::x [variable]
 
2233
    cls.add_instance_attribute('x', 'double', is_const=False)
 
2234
    ## vector.h (module 'core'): ns3::Vector3D::y [variable]
 
2235
    cls.add_instance_attribute('y', 'double', is_const=False)
 
2236
    ## vector.h (module 'core'): ns3::Vector3D::z [variable]
 
2237
    cls.add_instance_attribute('z', 'double', is_const=False)
 
2238
    return
 
2239
 
 
2240
def register_Ns3Empty_methods(root_module, cls):
 
2241
    ## empty.h (module 'core'): ns3::empty::empty() [constructor]
 
2242
    cls.add_constructor([])
 
2243
    ## empty.h (module 'core'): ns3::empty::empty(ns3::empty const & arg0) [copy constructor]
 
2244
    cls.add_constructor([param('ns3::empty const &', 'arg0')])
 
2245
    return
 
2246
 
 
2247
def register_Ns3Int64x64_t_methods(root_module, cls):
 
2248
    cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long unsigned int const', 'right'))
 
2249
    cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long unsigned int const', 'right'))
 
2250
    cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned int const', 'right'))
 
2251
    cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short unsigned int const', 'right'))
 
2252
    cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned char const', 'right'))
 
2253
    cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long int const', 'right'))
 
2254
    cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long int const', 'right'))
 
2255
    cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('int const', 'right'))
 
2256
    cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short int const', 'right'))
 
2257
    cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('signed char const', 'right'))
 
2258
    cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('double const', 'right'))
 
2259
    cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', 'right'))
 
2260
    cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long unsigned int const', 'right'))
 
2261
    cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long unsigned int const', 'right'))
 
2262
    cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned int const', 'right'))
 
2263
    cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short unsigned int const', 'right'))
 
2264
    cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned char const', 'right'))
 
2265
    cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long int const', 'right'))
 
2266
    cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long int const', 'right'))
 
2267
    cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('int const', 'right'))
 
2268
    cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short int const', 'right'))
 
2269
    cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('signed char const', 'right'))
 
2270
    cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('double const', 'right'))
 
2271
    cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', 'right'))
 
2272
    cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long unsigned int const', 'right'))
 
2273
    cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long unsigned int const', 'right'))
 
2274
    cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned int const', 'right'))
 
2275
    cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short unsigned int const', 'right'))
 
2276
    cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned char const', 'right'))
 
2277
    cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long int const', 'right'))
 
2278
    cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long int const', 'right'))
 
2279
    cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('int const', 'right'))
 
2280
    cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short int const', 'right'))
 
2281
    cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('signed char const', 'right'))
 
2282
    cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('double const', 'right'))
 
2283
    cls.add_unary_numeric_operator('-')
 
2284
    cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', 'right'))
 
2285
    cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long unsigned int const', 'right'))
 
2286
    cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long unsigned int const', 'right'))
 
2287
    cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned int const', 'right'))
 
2288
    cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short unsigned int const', 'right'))
 
2289
    cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned char const', 'right'))
 
2290
    cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long int const', 'right'))
 
2291
    cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long int const', 'right'))
 
2292
    cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('int const', 'right'))
 
2293
    cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short int const', 'right'))
 
2294
    cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('signed char const', 'right'))
 
2295
    cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('double const', 'right'))
 
2296
    cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', 'right'))
 
2297
    cls.add_binary_comparison_operator('<')
 
2298
    cls.add_binary_comparison_operator('>')
 
2299
    cls.add_binary_comparison_operator('!=')
 
2300
    cls.add_inplace_numeric_operator('*=', param('ns3::int64x64_t const &', 'right'))
 
2301
    cls.add_inplace_numeric_operator('+=', param('ns3::int64x64_t const &', 'right'))
 
2302
    cls.add_inplace_numeric_operator('-=', param('ns3::int64x64_t const &', 'right'))
 
2303
    cls.add_inplace_numeric_operator('/=', param('ns3::int64x64_t const &', 'right'))
 
2304
    cls.add_output_stream_operator()
 
2305
    cls.add_binary_comparison_operator('<=')
 
2306
    cls.add_binary_comparison_operator('==')
 
2307
    cls.add_binary_comparison_operator('>=')
 
2308
    ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor]
 
2309
    cls.add_constructor([])
 
2310
    ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(double v) [constructor]
 
2311
    cls.add_constructor([param('double', 'v')])
 
2312
    ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(int v) [constructor]
 
2313
    cls.add_constructor([param('int', 'v')])
 
2314
    ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long int v) [constructor]
 
2315
    cls.add_constructor([param('long int', 'v')])
 
2316
    ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long long int v) [constructor]
 
2317
    cls.add_constructor([param('long long int', 'v')])
 
2318
    ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(unsigned int v) [constructor]
 
2319
    cls.add_constructor([param('unsigned int', 'v')])
 
2320
    ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long unsigned int v) [constructor]
 
2321
    cls.add_constructor([param('long unsigned int', 'v')])
 
2322
    ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long long unsigned int v) [constructor]
 
2323
    cls.add_constructor([param('long long unsigned int', 'v')])
 
2324
    ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(int64_t hi, uint64_t lo) [constructor]
 
2325
    cls.add_constructor([param('int64_t', 'hi'), param('uint64_t', 'lo')])
 
2326
    ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(ns3::int64x64_t const & o) [copy constructor]
 
2327
    cls.add_constructor([param('ns3::int64x64_t const &', 'o')])
 
2328
    ## int64x64-double.h (module 'core'): double ns3::int64x64_t::GetDouble() const [member function]
 
2329
    cls.add_method('GetDouble', 
 
2330
                   'double', 
 
2331
                   [], 
 
2332
                   is_const=True)
 
2333
    ## int64x64-double.h (module 'core'): int64_t ns3::int64x64_t::GetHigh() const [member function]
 
2334
    cls.add_method('GetHigh', 
 
2335
                   'int64_t', 
 
2336
                   [], 
 
2337
                   is_const=True)
 
2338
    ## int64x64-double.h (module 'core'): uint64_t ns3::int64x64_t::GetLow() const [member function]
 
2339
    cls.add_method('GetLow', 
 
2340
                   'uint64_t', 
 
2341
                   [], 
 
2342
                   is_const=True)
 
2343
    ## int64x64-double.h (module 'core'): static ns3::int64x64_t ns3::int64x64_t::Invert(uint64_t v) [member function]
 
2344
    cls.add_method('Invert', 
 
2345
                   'ns3::int64x64_t', 
 
2346
                   [param('uint64_t', 'v')], 
 
2347
                   is_static=True)
 
2348
    ## int64x64-double.h (module 'core'): void ns3::int64x64_t::MulByInvert(ns3::int64x64_t const & o) [member function]
 
2349
    cls.add_method('MulByInvert', 
 
2350
                   'void', 
 
2351
                   [param('ns3::int64x64_t const &', 'o')])
 
2352
    return
 
2353
 
 
2354
def register_Ns3AnimByteTag_methods(root_module, cls):
 
2355
    ## animation-interface.h (module 'netanim'): ns3::AnimByteTag::AnimByteTag() [constructor]
 
2356
    cls.add_constructor([])
 
2357
    ## animation-interface.h (module 'netanim'): ns3::AnimByteTag::AnimByteTag(ns3::AnimByteTag const & arg0) [copy constructor]
 
2358
    cls.add_constructor([param('ns3::AnimByteTag const &', 'arg0')])
 
2359
    ## animation-interface.h (module 'netanim'): void ns3::AnimByteTag::Deserialize(ns3::TagBuffer i) [member function]
 
2360
    cls.add_method('Deserialize', 
 
2361
                   'void', 
 
2362
                   [param('ns3::TagBuffer', 'i')], 
 
2363
                   is_virtual=True)
 
2364
    ## animation-interface.h (module 'netanim'): uint64_t ns3::AnimByteTag::Get() const [member function]
 
2365
    cls.add_method('Get', 
 
2366
                   'uint64_t', 
 
2367
                   [], 
 
2368
                   is_const=True)
 
2369
    ## animation-interface.h (module 'netanim'): ns3::TypeId ns3::AnimByteTag::GetInstanceTypeId() const [member function]
 
2370
    cls.add_method('GetInstanceTypeId', 
 
2371
                   'ns3::TypeId', 
 
2372
                   [], 
 
2373
                   is_const=True, is_virtual=True)
 
2374
    ## animation-interface.h (module 'netanim'): uint32_t ns3::AnimByteTag::GetSerializedSize() const [member function]
 
2375
    cls.add_method('GetSerializedSize', 
 
2376
                   'uint32_t', 
 
2377
                   [], 
 
2378
                   is_const=True, is_virtual=True)
 
2379
    ## animation-interface.h (module 'netanim'): static ns3::TypeId ns3::AnimByteTag::GetTypeId() [member function]
 
2380
    cls.add_method('GetTypeId', 
 
2381
                   'ns3::TypeId', 
 
2382
                   [], 
 
2383
                   is_static=True)
 
2384
    ## animation-interface.h (module 'netanim'): void ns3::AnimByteTag::Print(std::ostream & os) const [member function]
 
2385
    cls.add_method('Print', 
 
2386
                   'void', 
 
2387
                   [param('std::ostream &', 'os')], 
 
2388
                   is_const=True, is_virtual=True)
 
2389
    ## animation-interface.h (module 'netanim'): void ns3::AnimByteTag::Serialize(ns3::TagBuffer i) const [member function]
 
2390
    cls.add_method('Serialize', 
 
2391
                   'void', 
 
2392
                   [param('ns3::TagBuffer', 'i')], 
 
2393
                   is_const=True, is_virtual=True)
 
2394
    ## animation-interface.h (module 'netanim'): void ns3::AnimByteTag::Set(uint64_t AnimUid) [member function]
 
2395
    cls.add_method('Set', 
 
2396
                   'void', 
 
2397
                   [param('uint64_t', 'AnimUid')])
 
2398
    return
 
2399
 
 
2400
def register_Ns3Chunk_methods(root_module, cls):
 
2401
    ## chunk.h (module 'network'): ns3::Chunk::Chunk() [constructor]
 
2402
    cls.add_constructor([])
 
2403
    ## chunk.h (module 'network'): ns3::Chunk::Chunk(ns3::Chunk const & arg0) [copy constructor]
 
2404
    cls.add_constructor([param('ns3::Chunk const &', 'arg0')])
 
2405
    ## chunk.h (module 'network'): uint32_t ns3::Chunk::Deserialize(ns3::Buffer::Iterator start) [member function]
 
2406
    cls.add_method('Deserialize', 
 
2407
                   'uint32_t', 
 
2408
                   [param('ns3::Buffer::Iterator', 'start')], 
 
2409
                   is_pure_virtual=True, is_virtual=True)
 
2410
    ## chunk.h (module 'network'): static ns3::TypeId ns3::Chunk::GetTypeId() [member function]
 
2411
    cls.add_method('GetTypeId', 
 
2412
                   'ns3::TypeId', 
 
2413
                   [], 
 
2414
                   is_static=True)
 
2415
    ## chunk.h (module 'network'): void ns3::Chunk::Print(std::ostream & os) const [member function]
 
2416
    cls.add_method('Print', 
 
2417
                   'void', 
 
2418
                   [param('std::ostream &', 'os')], 
 
2419
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2420
    return
 
2421
 
 
2422
def register_Ns3Header_methods(root_module, cls):
 
2423
    cls.add_output_stream_operator()
 
2424
    ## header.h (module 'network'): ns3::Header::Header() [constructor]
 
2425
    cls.add_constructor([])
 
2426
    ## header.h (module 'network'): ns3::Header::Header(ns3::Header const & arg0) [copy constructor]
 
2427
    cls.add_constructor([param('ns3::Header const &', 'arg0')])
 
2428
    ## header.h (module 'network'): uint32_t ns3::Header::Deserialize(ns3::Buffer::Iterator start) [member function]
 
2429
    cls.add_method('Deserialize', 
 
2430
                   'uint32_t', 
 
2431
                   [param('ns3::Buffer::Iterator', 'start')], 
 
2432
                   is_pure_virtual=True, is_virtual=True)
 
2433
    ## header.h (module 'network'): uint32_t ns3::Header::GetSerializedSize() const [member function]
 
2434
    cls.add_method('GetSerializedSize', 
 
2435
                   'uint32_t', 
 
2436
                   [], 
 
2437
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2438
    ## header.h (module 'network'): static ns3::TypeId ns3::Header::GetTypeId() [member function]
 
2439
    cls.add_method('GetTypeId', 
 
2440
                   'ns3::TypeId', 
 
2441
                   [], 
 
2442
                   is_static=True)
 
2443
    ## header.h (module 'network'): void ns3::Header::Print(std::ostream & os) const [member function]
 
2444
    cls.add_method('Print', 
 
2445
                   'void', 
 
2446
                   [param('std::ostream &', 'os')], 
 
2447
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2448
    ## header.h (module 'network'): void ns3::Header::Serialize(ns3::Buffer::Iterator start) const [member function]
 
2449
    cls.add_method('Serialize', 
 
2450
                   'void', 
 
2451
                   [param('ns3::Buffer::Iterator', 'start')], 
 
2452
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2453
    return
 
2454
 
 
2455
def register_Ns3Object_methods(root_module, cls):
 
2456
    ## object.h (module 'core'): ns3::Object::Object() [constructor]
 
2457
    cls.add_constructor([])
 
2458
    ## object.h (module 'core'): void ns3::Object::AggregateObject(ns3::Ptr<ns3::Object> other) [member function]
 
2459
    cls.add_method('AggregateObject', 
 
2460
                   'void', 
 
2461
                   [param('ns3::Ptr< ns3::Object >', 'other')])
 
2462
    ## object.h (module 'core'): void ns3::Object::Dispose() [member function]
 
2463
    cls.add_method('Dispose', 
 
2464
                   'void', 
 
2465
                   [])
 
2466
    ## object.h (module 'core'): ns3::Object::AggregateIterator ns3::Object::GetAggregateIterator() const [member function]
 
2467
    cls.add_method('GetAggregateIterator', 
 
2468
                   'ns3::Object::AggregateIterator', 
 
2469
                   [], 
 
2470
                   is_const=True)
 
2471
    ## object.h (module 'core'): ns3::TypeId ns3::Object::GetInstanceTypeId() const [member function]
 
2472
    cls.add_method('GetInstanceTypeId', 
 
2473
                   'ns3::TypeId', 
 
2474
                   [], 
 
2475
                   is_const=True, is_virtual=True)
 
2476
    ## object.h (module 'core'): static ns3::TypeId ns3::Object::GetTypeId() [member function]
 
2477
    cls.add_method('GetTypeId', 
 
2478
                   'ns3::TypeId', 
 
2479
                   [], 
 
2480
                   is_static=True)
 
2481
    ## object.h (module 'core'): void ns3::Object::Start() [member function]
 
2482
    cls.add_method('Start', 
 
2483
                   'void', 
 
2484
                   [])
 
2485
    ## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
 
2486
    cls.add_constructor([param('ns3::Object const &', 'o')], 
 
2487
                        visibility='protected')
 
2488
    ## object.h (module 'core'): void ns3::Object::DoDispose() [member function]
 
2489
    cls.add_method('DoDispose', 
 
2490
                   'void', 
 
2491
                   [], 
 
2492
                   visibility='protected', is_virtual=True)
 
2493
    ## object.h (module 'core'): void ns3::Object::DoStart() [member function]
 
2494
    cls.add_method('DoStart', 
 
2495
                   'void', 
 
2496
                   [], 
 
2497
                   visibility='protected', is_virtual=True)
 
2498
    ## object.h (module 'core'): void ns3::Object::NotifyNewAggregate() [member function]
 
2499
    cls.add_method('NotifyNewAggregate', 
 
2500
                   'void', 
 
2501
                   [], 
 
2502
                   visibility='protected', is_virtual=True)
 
2503
    return
 
2504
 
 
2505
def register_Ns3ObjectAggregateIterator_methods(root_module, cls):
 
2506
    ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [copy constructor]
 
2507
    cls.add_constructor([param('ns3::Object::AggregateIterator const &', 'arg0')])
 
2508
    ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator() [constructor]
 
2509
    cls.add_constructor([])
 
2510
    ## object.h (module 'core'): bool ns3::Object::AggregateIterator::HasNext() const [member function]
 
2511
    cls.add_method('HasNext', 
 
2512
                   'bool', 
 
2513
                   [], 
 
2514
                   is_const=True)
 
2515
    ## object.h (module 'core'): ns3::Ptr<ns3::Object const> ns3::Object::AggregateIterator::Next() [member function]
 
2516
    cls.add_method('Next', 
 
2517
                   'ns3::Ptr< ns3::Object const >', 
 
2518
                   [])
 
2519
    return
 
2520
 
 
2521
def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, cls):
 
2522
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >::SimpleRefCount() [constructor]
 
2523
    cls.add_constructor([])
 
2524
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >::SimpleRefCount(ns3::SimpleRefCount<ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> > const & o) [copy constructor]
 
2525
    cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter< ns3::AttributeAccessor > > const &', 'o')])
 
2526
    ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount<ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >::Cleanup() [member function]
 
2527
    cls.add_method('Cleanup', 
 
2528
                   'void', 
 
2529
                   [], 
 
2530
                   is_static=True)
 
2531
    return
 
2532
 
 
2533
def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, cls):
 
2534
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >::SimpleRefCount() [constructor]
 
2535
    cls.add_constructor([])
 
2536
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >::SimpleRefCount(ns3::SimpleRefCount<ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> > const & o) [copy constructor]
 
2537
    cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter< ns3::AttributeChecker > > const &', 'o')])
 
2538
    ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount<ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >::Cleanup() [member function]
 
2539
    cls.add_method('Cleanup', 
 
2540
                   'void', 
 
2541
                   [], 
 
2542
                   is_static=True)
 
2543
    return
 
2544
 
 
2545
def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, cls):
 
2546
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >::SimpleRefCount() [constructor]
 
2547
    cls.add_constructor([])
 
2548
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >::SimpleRefCount(ns3::SimpleRefCount<ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> > const & o) [copy constructor]
 
2549
    cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter< ns3::AttributeValue > > const &', 'o')])
 
2550
    ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount<ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >::Cleanup() [member function]
 
2551
    cls.add_method('Cleanup', 
 
2552
                   'void', 
 
2553
                   [], 
 
2554
                   is_static=True)
 
2555
    return
 
2556
 
 
2557
def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3CallbackImplBase__gt___methods(root_module, cls):
 
2558
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >::SimpleRefCount() [constructor]
 
2559
    cls.add_constructor([])
 
2560
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >::SimpleRefCount(ns3::SimpleRefCount<ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> > const & o) [copy constructor]
 
2561
    cls.add_constructor([param('ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter< ns3::CallbackImplBase > > const &', 'o')])
 
2562
    ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount<ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >::Cleanup() [member function]
 
2563
    cls.add_method('Cleanup', 
 
2564
                   'void', 
 
2565
                   [], 
 
2566
                   is_static=True)
 
2567
    return
 
2568
 
 
2569
def register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3EventImpl__gt___methods(root_module, cls):
 
2570
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> >::SimpleRefCount() [constructor]
 
2571
    cls.add_constructor([])
 
2572
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> >::SimpleRefCount(ns3::SimpleRefCount<ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> > const & o) [copy constructor]
 
2573
    cls.add_constructor([param('ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter< ns3::EventImpl > > const &', 'o')])
 
2574
    ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount<ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> >::Cleanup() [member function]
 
2575
    cls.add_method('Cleanup', 
 
2576
                   'void', 
 
2577
                   [], 
 
2578
                   is_static=True)
 
2579
    return
 
2580
 
 
2581
def register_Ns3SimpleRefCount__Ns3NixVector_Ns3Empty_Ns3DefaultDeleter__lt__ns3NixVector__gt___methods(root_module, cls):
 
2582
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::NixVector, ns3::empty, ns3::DefaultDeleter<ns3::NixVector> >::SimpleRefCount() [constructor]
 
2583
    cls.add_constructor([])
 
2584
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::NixVector, ns3::empty, ns3::DefaultDeleter<ns3::NixVector> >::SimpleRefCount(ns3::SimpleRefCount<ns3::NixVector, ns3::empty, ns3::DefaultDeleter<ns3::NixVector> > const & o) [copy constructor]
 
2585
    cls.add_constructor([param('ns3::SimpleRefCount< ns3::NixVector, ns3::empty, ns3::DefaultDeleter< ns3::NixVector > > const &', 'o')])
 
2586
    ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount<ns3::NixVector, ns3::empty, ns3::DefaultDeleter<ns3::NixVector> >::Cleanup() [member function]
 
2587
    cls.add_method('Cleanup', 
 
2588
                   'void', 
 
2589
                   [], 
 
2590
                   is_static=True)
 
2591
    return
 
2592
 
 
2593
def register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Packet__gt___methods(root_module, cls):
 
2594
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> >::SimpleRefCount() [constructor]
 
2595
    cls.add_constructor([])
 
2596
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> >::SimpleRefCount(ns3::SimpleRefCount<ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> > const & o) [copy constructor]
 
2597
    cls.add_constructor([param('ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter< ns3::Packet > > const &', 'o')])
 
2598
    ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount<ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> >::Cleanup() [member function]
 
2599
    cls.add_method('Cleanup', 
 
2600
                   'void', 
 
2601
                   [], 
 
2602
                   is_static=True)
 
2603
    return
 
2604
 
 
2605
def register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3TraceSourceAccessor__gt___methods(root_module, cls):
 
2606
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> >::SimpleRefCount() [constructor]
 
2607
    cls.add_constructor([])
 
2608
    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> >::SimpleRefCount(ns3::SimpleRefCount<ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> > const & o) [copy constructor]
 
2609
    cls.add_constructor([param('ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter< ns3::TraceSourceAccessor > > const &', 'o')])
 
2610
    ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount<ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> >::Cleanup() [member function]
 
2611
    cls.add_method('Cleanup', 
 
2612
                   'void', 
 
2613
                   [], 
 
2614
                   is_static=True)
 
2615
    return
 
2616
 
 
2617
def register_Ns3Time_methods(root_module, cls):
 
2618
    cls.add_binary_numeric_operator('+', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', 'right'))
 
2619
    cls.add_binary_numeric_operator('-', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', 'right'))
 
2620
    cls.add_binary_comparison_operator('<')
 
2621
    cls.add_binary_comparison_operator('>')
 
2622
    cls.add_binary_comparison_operator('!=')
 
2623
    cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', 'right'))
 
2624
    cls.add_inplace_numeric_operator('-=', param('ns3::Time const &', 'right'))
 
2625
    cls.add_output_stream_operator()
 
2626
    cls.add_binary_comparison_operator('<=')
 
2627
    cls.add_binary_comparison_operator('==')
 
2628
    cls.add_binary_comparison_operator('>=')
 
2629
    ## nstime.h (module 'core'): ns3::Time::Time() [constructor]
 
2630
    cls.add_constructor([])
 
2631
    ## nstime.h (module 'core'): ns3::Time::Time(ns3::Time const & o) [copy constructor]
 
2632
    cls.add_constructor([param('ns3::Time const &', 'o')])
 
2633
    ## nstime.h (module 'core'): ns3::Time::Time(double v) [constructor]
 
2634
    cls.add_constructor([param('double', 'v')])
 
2635
    ## nstime.h (module 'core'): ns3::Time::Time(int v) [constructor]
 
2636
    cls.add_constructor([param('int', 'v')])
 
2637
    ## nstime.h (module 'core'): ns3::Time::Time(long int v) [constructor]
 
2638
    cls.add_constructor([param('long int', 'v')])
 
2639
    ## nstime.h (module 'core'): ns3::Time::Time(long long int v) [constructor]
 
2640
    cls.add_constructor([param('long long int', 'v')])
 
2641
    ## nstime.h (module 'core'): ns3::Time::Time(unsigned int v) [constructor]
 
2642
    cls.add_constructor([param('unsigned int', 'v')])
 
2643
    ## nstime.h (module 'core'): ns3::Time::Time(long unsigned int v) [constructor]
 
2644
    cls.add_constructor([param('long unsigned int', 'v')])
 
2645
    ## nstime.h (module 'core'): ns3::Time::Time(long long unsigned int v) [constructor]
 
2646
    cls.add_constructor([param('long long unsigned int', 'v')])
 
2647
    ## nstime.h (module 'core'): ns3::Time::Time(std::string const & s) [constructor]
 
2648
    cls.add_constructor([param('std::string const &', 's')])
 
2649
    ## nstime.h (module 'core'): ns3::Time::Time(ns3::int64x64_t const & value) [constructor]
 
2650
    cls.add_constructor([param('ns3::int64x64_t const &', 'value')])
 
2651
    ## nstime.h (module 'core'): int ns3::Time::Compare(ns3::Time const & o) const [member function]
 
2652
    cls.add_method('Compare', 
 
2653
                   'int', 
 
2654
                   [param('ns3::Time const &', 'o')], 
 
2655
                   is_const=True)
 
2656
    ## nstime.h (module 'core'): static ns3::Time ns3::Time::From(ns3::int64x64_t const & from, ns3::Time::Unit timeUnit) [member function]
 
2657
    cls.add_method('From', 
 
2658
                   'ns3::Time', 
 
2659
                   [param('ns3::int64x64_t const &', 'from'), param('ns3::Time::Unit', 'timeUnit')], 
 
2660
                   is_static=True)
 
2661
    ## nstime.h (module 'core'): static ns3::Time ns3::Time::From(ns3::int64x64_t const & value) [member function]
 
2662
    cls.add_method('From', 
 
2663
                   'ns3::Time', 
 
2664
                   [param('ns3::int64x64_t const &', 'value')], 
 
2665
                   is_static=True)
 
2666
    ## nstime.h (module 'core'): static ns3::Time ns3::Time::FromDouble(double value, ns3::Time::Unit timeUnit) [member function]
 
2667
    cls.add_method('FromDouble', 
 
2668
                   'ns3::Time', 
 
2669
                   [param('double', 'value'), param('ns3::Time::Unit', 'timeUnit')], 
 
2670
                   is_static=True)
 
2671
    ## nstime.h (module 'core'): static ns3::Time ns3::Time::FromInteger(uint64_t value, ns3::Time::Unit timeUnit) [member function]
 
2672
    cls.add_method('FromInteger', 
 
2673
                   'ns3::Time', 
 
2674
                   [param('uint64_t', 'value'), param('ns3::Time::Unit', 'timeUnit')], 
 
2675
                   is_static=True)
 
2676
    ## nstime.h (module 'core'): double ns3::Time::GetDouble() const [member function]
 
2677
    cls.add_method('GetDouble', 
 
2678
                   'double', 
 
2679
                   [], 
 
2680
                   is_const=True)
 
2681
    ## nstime.h (module 'core'): int64_t ns3::Time::GetFemtoSeconds() const [member function]
 
2682
    cls.add_method('GetFemtoSeconds', 
 
2683
                   'int64_t', 
 
2684
                   [], 
 
2685
                   is_const=True)
 
2686
    ## nstime.h (module 'core'): int64_t ns3::Time::GetInteger() const [member function]
 
2687
    cls.add_method('GetInteger', 
 
2688
                   'int64_t', 
 
2689
                   [], 
 
2690
                   is_const=True)
 
2691
    ## nstime.h (module 'core'): int64_t ns3::Time::GetMicroSeconds() const [member function]
 
2692
    cls.add_method('GetMicroSeconds', 
 
2693
                   'int64_t', 
 
2694
                   [], 
 
2695
                   is_const=True)
 
2696
    ## nstime.h (module 'core'): int64_t ns3::Time::GetMilliSeconds() const [member function]
 
2697
    cls.add_method('GetMilliSeconds', 
 
2698
                   'int64_t', 
 
2699
                   [], 
 
2700
                   is_const=True)
 
2701
    ## nstime.h (module 'core'): int64_t ns3::Time::GetNanoSeconds() const [member function]
 
2702
    cls.add_method('GetNanoSeconds', 
 
2703
                   'int64_t', 
 
2704
                   [], 
 
2705
                   is_const=True)
 
2706
    ## nstime.h (module 'core'): int64_t ns3::Time::GetPicoSeconds() const [member function]
 
2707
    cls.add_method('GetPicoSeconds', 
 
2708
                   'int64_t', 
 
2709
                   [], 
 
2710
                   is_const=True)
 
2711
    ## nstime.h (module 'core'): static ns3::Time::Unit ns3::Time::GetResolution() [member function]
 
2712
    cls.add_method('GetResolution', 
 
2713
                   'ns3::Time::Unit', 
 
2714
                   [], 
 
2715
                   is_static=True)
 
2716
    ## nstime.h (module 'core'): double ns3::Time::GetSeconds() const [member function]
 
2717
    cls.add_method('GetSeconds', 
 
2718
                   'double', 
 
2719
                   [], 
 
2720
                   is_const=True)
 
2721
    ## nstime.h (module 'core'): int64_t ns3::Time::GetTimeStep() const [member function]
 
2722
    cls.add_method('GetTimeStep', 
 
2723
                   'int64_t', 
 
2724
                   [], 
 
2725
                   is_const=True)
 
2726
    ## nstime.h (module 'core'): bool ns3::Time::IsNegative() const [member function]
 
2727
    cls.add_method('IsNegative', 
 
2728
                   'bool', 
 
2729
                   [], 
 
2730
                   is_const=True)
 
2731
    ## nstime.h (module 'core'): bool ns3::Time::IsPositive() const [member function]
 
2732
    cls.add_method('IsPositive', 
 
2733
                   'bool', 
 
2734
                   [], 
 
2735
                   is_const=True)
 
2736
    ## nstime.h (module 'core'): bool ns3::Time::IsStrictlyNegative() const [member function]
 
2737
    cls.add_method('IsStrictlyNegative', 
 
2738
                   'bool', 
 
2739
                   [], 
 
2740
                   is_const=True)
 
2741
    ## nstime.h (module 'core'): bool ns3::Time::IsStrictlyPositive() const [member function]
 
2742
    cls.add_method('IsStrictlyPositive', 
 
2743
                   'bool', 
 
2744
                   [], 
 
2745
                   is_const=True)
 
2746
    ## nstime.h (module 'core'): bool ns3::Time::IsZero() const [member function]
 
2747
    cls.add_method('IsZero', 
 
2748
                   'bool', 
 
2749
                   [], 
 
2750
                   is_const=True)
 
2751
    ## nstime.h (module 'core'): static void ns3::Time::SetResolution(ns3::Time::Unit resolution) [member function]
 
2752
    cls.add_method('SetResolution', 
 
2753
                   'void', 
 
2754
                   [param('ns3::Time::Unit', 'resolution')], 
 
2755
                   is_static=True)
 
2756
    ## nstime.h (module 'core'): ns3::int64x64_t ns3::Time::To(ns3::Time::Unit timeUnit) const [member function]
 
2757
    cls.add_method('To', 
 
2758
                   'ns3::int64x64_t', 
 
2759
                   [param('ns3::Time::Unit', 'timeUnit')], 
 
2760
                   is_const=True)
 
2761
    ## nstime.h (module 'core'): double ns3::Time::ToDouble(ns3::Time::Unit timeUnit) const [member function]
 
2762
    cls.add_method('ToDouble', 
 
2763
                   'double', 
 
2764
                   [param('ns3::Time::Unit', 'timeUnit')], 
 
2765
                   is_const=True)
 
2766
    ## nstime.h (module 'core'): int64_t ns3::Time::ToInteger(ns3::Time::Unit timeUnit) const [member function]
 
2767
    cls.add_method('ToInteger', 
 
2768
                   'int64_t', 
 
2769
                   [param('ns3::Time::Unit', 'timeUnit')], 
 
2770
                   is_const=True)
 
2771
    return
 
2772
 
 
2773
def register_Ns3TraceSourceAccessor_methods(root_module, cls):
 
2774
    ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [copy constructor]
 
2775
    cls.add_constructor([param('ns3::TraceSourceAccessor const &', 'arg0')])
 
2776
    ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor]
 
2777
    cls.add_constructor([])
 
2778
    ## trace-source-accessor.h (module 'core'): bool ns3::TraceSourceAccessor::Connect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function]
 
2779
    cls.add_method('Connect', 
 
2780
                   'bool', 
 
2781
                   [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')], 
 
2782
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2783
    ## trace-source-accessor.h (module 'core'): bool ns3::TraceSourceAccessor::ConnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function]
 
2784
    cls.add_method('ConnectWithoutContext', 
 
2785
                   'bool', 
 
2786
                   [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase const &', 'cb')], 
 
2787
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2788
    ## trace-source-accessor.h (module 'core'): bool ns3::TraceSourceAccessor::Disconnect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function]
 
2789
    cls.add_method('Disconnect', 
 
2790
                   'bool', 
 
2791
                   [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')], 
 
2792
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2793
    ## trace-source-accessor.h (module 'core'): bool ns3::TraceSourceAccessor::DisconnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function]
 
2794
    cls.add_method('DisconnectWithoutContext', 
 
2795
                   'bool', 
 
2796
                   [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase const &', 'cb')], 
 
2797
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2798
    return
 
2799
 
 
2800
def register_Ns3Trailer_methods(root_module, cls):
 
2801
    cls.add_output_stream_operator()
 
2802
    ## trailer.h (module 'network'): ns3::Trailer::Trailer() [constructor]
 
2803
    cls.add_constructor([])
 
2804
    ## trailer.h (module 'network'): ns3::Trailer::Trailer(ns3::Trailer const & arg0) [copy constructor]
 
2805
    cls.add_constructor([param('ns3::Trailer const &', 'arg0')])
 
2806
    ## trailer.h (module 'network'): uint32_t ns3::Trailer::Deserialize(ns3::Buffer::Iterator end) [member function]
 
2807
    cls.add_method('Deserialize', 
 
2808
                   'uint32_t', 
 
2809
                   [param('ns3::Buffer::Iterator', 'end')], 
 
2810
                   is_pure_virtual=True, is_virtual=True)
 
2811
    ## trailer.h (module 'network'): uint32_t ns3::Trailer::GetSerializedSize() const [member function]
 
2812
    cls.add_method('GetSerializedSize', 
 
2813
                   'uint32_t', 
 
2814
                   [], 
 
2815
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2816
    ## trailer.h (module 'network'): static ns3::TypeId ns3::Trailer::GetTypeId() [member function]
 
2817
    cls.add_method('GetTypeId', 
 
2818
                   'ns3::TypeId', 
 
2819
                   [], 
 
2820
                   is_static=True)
 
2821
    ## trailer.h (module 'network'): void ns3::Trailer::Print(std::ostream & os) const [member function]
 
2822
    cls.add_method('Print', 
 
2823
                   'void', 
 
2824
                   [param('std::ostream &', 'os')], 
 
2825
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2826
    ## trailer.h (module 'network'): void ns3::Trailer::Serialize(ns3::Buffer::Iterator start) const [member function]
 
2827
    cls.add_method('Serialize', 
 
2828
                   'void', 
 
2829
                   [param('ns3::Buffer::Iterator', 'start')], 
 
2830
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2831
    return
 
2832
 
 
2833
def register_Ns3AttributeAccessor_methods(root_module, cls):
 
2834
    ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [copy constructor]
 
2835
    cls.add_constructor([param('ns3::AttributeAccessor const &', 'arg0')])
 
2836
    ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor() [constructor]
 
2837
    cls.add_constructor([])
 
2838
    ## attribute.h (module 'core'): bool ns3::AttributeAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & attribute) const [member function]
 
2839
    cls.add_method('Get', 
 
2840
                   'bool', 
 
2841
                   [param('ns3::ObjectBase const *', 'object'), param('ns3::AttributeValue &', 'attribute')], 
 
2842
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2843
    ## attribute.h (module 'core'): bool ns3::AttributeAccessor::HasGetter() const [member function]
 
2844
    cls.add_method('HasGetter', 
 
2845
                   'bool', 
 
2846
                   [], 
 
2847
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2848
    ## attribute.h (module 'core'): bool ns3::AttributeAccessor::HasSetter() const [member function]
 
2849
    cls.add_method('HasSetter', 
 
2850
                   'bool', 
 
2851
                   [], 
 
2852
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2853
    ## attribute.h (module 'core'): bool ns3::AttributeAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function]
 
2854
    cls.add_method('Set', 
 
2855
                   'bool', 
 
2856
                   [param('ns3::ObjectBase *', 'object', transfer_ownership=False), param('ns3::AttributeValue const &', 'value')], 
 
2857
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2858
    return
 
2859
 
 
2860
def register_Ns3AttributeChecker_methods(root_module, cls):
 
2861
    ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [copy constructor]
 
2862
    cls.add_constructor([param('ns3::AttributeChecker const &', 'arg0')])
 
2863
    ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker() [constructor]
 
2864
    cls.add_constructor([])
 
2865
    ## attribute.h (module 'core'): bool ns3::AttributeChecker::Check(ns3::AttributeValue const & value) const [member function]
 
2866
    cls.add_method('Check', 
 
2867
                   'bool', 
 
2868
                   [param('ns3::AttributeValue const &', 'value')], 
 
2869
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2870
    ## attribute.h (module 'core'): bool ns3::AttributeChecker::Copy(ns3::AttributeValue const & source, ns3::AttributeValue & destination) const [member function]
 
2871
    cls.add_method('Copy', 
 
2872
                   'bool', 
 
2873
                   [param('ns3::AttributeValue const &', 'source'), param('ns3::AttributeValue &', 'destination')], 
 
2874
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2875
    ## attribute.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::AttributeChecker::Create() const [member function]
 
2876
    cls.add_method('Create', 
 
2877
                   'ns3::Ptr< ns3::AttributeValue >', 
 
2878
                   [], 
 
2879
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2880
    ## attribute.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::AttributeChecker::CreateValidValue(ns3::AttributeValue const & value) const [member function]
 
2881
    cls.add_method('CreateValidValue', 
 
2882
                   'ns3::Ptr< ns3::AttributeValue >', 
 
2883
                   [param('ns3::AttributeValue const &', 'value')], 
 
2884
                   is_const=True)
 
2885
    ## attribute.h (module 'core'): std::string ns3::AttributeChecker::GetUnderlyingTypeInformation() const [member function]
 
2886
    cls.add_method('GetUnderlyingTypeInformation', 
 
2887
                   'std::string', 
 
2888
                   [], 
 
2889
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2890
    ## attribute.h (module 'core'): std::string ns3::AttributeChecker::GetValueTypeName() const [member function]
 
2891
    cls.add_method('GetValueTypeName', 
 
2892
                   'std::string', 
 
2893
                   [], 
 
2894
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2895
    ## attribute.h (module 'core'): bool ns3::AttributeChecker::HasUnderlyingTypeInformation() const [member function]
 
2896
    cls.add_method('HasUnderlyingTypeInformation', 
 
2897
                   'bool', 
 
2898
                   [], 
 
2899
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2900
    return
 
2901
 
 
2902
def register_Ns3AttributeValue_methods(root_module, cls):
 
2903
    ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [copy constructor]
 
2904
    cls.add_constructor([param('ns3::AttributeValue const &', 'arg0')])
 
2905
    ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue() [constructor]
 
2906
    cls.add_constructor([])
 
2907
    ## attribute.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::AttributeValue::Copy() const [member function]
 
2908
    cls.add_method('Copy', 
 
2909
                   'ns3::Ptr< ns3::AttributeValue >', 
 
2910
                   [], 
 
2911
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2912
    ## attribute.h (module 'core'): bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
 
2913
    cls.add_method('DeserializeFromString', 
 
2914
                   'bool', 
 
2915
                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
2916
                   is_pure_virtual=True, is_virtual=True)
 
2917
    ## attribute.h (module 'core'): std::string ns3::AttributeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
 
2918
    cls.add_method('SerializeToString', 
 
2919
                   'std::string', 
 
2920
                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
2921
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2922
    return
 
2923
 
 
2924
def register_Ns3CallbackChecker_methods(root_module, cls):
 
2925
    ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker() [constructor]
 
2926
    cls.add_constructor([])
 
2927
    ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [copy constructor]
 
2928
    cls.add_constructor([param('ns3::CallbackChecker const &', 'arg0')])
 
2929
    return
 
2930
 
 
2931
def register_Ns3CallbackImplBase_methods(root_module, cls):
 
2932
    ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase() [constructor]
 
2933
    cls.add_constructor([])
 
2934
    ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [copy constructor]
 
2935
    cls.add_constructor([param('ns3::CallbackImplBase const &', 'arg0')])
 
2936
    ## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr<ns3::CallbackImplBase const> other) const [member function]
 
2937
    cls.add_method('IsEqual', 
 
2938
                   'bool', 
 
2939
                   [param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')], 
 
2940
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
2941
    return
 
2942
 
 
2943
def register_Ns3CallbackValue_methods(root_module, cls):
 
2944
    ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [copy constructor]
 
2945
    cls.add_constructor([param('ns3::CallbackValue const &', 'arg0')])
 
2946
    ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue() [constructor]
 
2947
    cls.add_constructor([])
 
2948
    ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackBase const & base) [constructor]
 
2949
    cls.add_constructor([param('ns3::CallbackBase const &', 'base')])
 
2950
    ## callback.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::CallbackValue::Copy() const [member function]
 
2951
    cls.add_method('Copy', 
 
2952
                   'ns3::Ptr< ns3::AttributeValue >', 
 
2953
                   [], 
 
2954
                   is_const=True, is_virtual=True)
 
2955
    ## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
 
2956
    cls.add_method('DeserializeFromString', 
 
2957
                   'bool', 
 
2958
                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
2959
                   is_virtual=True)
 
2960
    ## callback.h (module 'core'): std::string ns3::CallbackValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
 
2961
    cls.add_method('SerializeToString', 
 
2962
                   'std::string', 
 
2963
                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
2964
                   is_const=True, is_virtual=True)
 
2965
    ## callback.h (module 'core'): void ns3::CallbackValue::Set(ns3::CallbackBase base) [member function]
 
2966
    cls.add_method('Set', 
 
2967
                   'void', 
 
2968
                   [param('ns3::CallbackBase', 'base')])
 
2969
    return
 
2970
 
 
2971
def register_Ns3EmptyAttributeValue_methods(root_module, cls):
 
2972
    ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [copy constructor]
 
2973
    cls.add_constructor([param('ns3::EmptyAttributeValue const &', 'arg0')])
 
2974
    ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor]
 
2975
    cls.add_constructor([])
 
2976
    ## attribute.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::EmptyAttributeValue::Copy() const [member function]
 
2977
    cls.add_method('Copy', 
 
2978
                   'ns3::Ptr< ns3::AttributeValue >', 
 
2979
                   [], 
 
2980
                   is_const=True, visibility='private', is_virtual=True)
 
2981
    ## attribute.h (module 'core'): bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
 
2982
    cls.add_method('DeserializeFromString', 
 
2983
                   'bool', 
 
2984
                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
2985
                   visibility='private', is_virtual=True)
 
2986
    ## attribute.h (module 'core'): std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
 
2987
    cls.add_method('SerializeToString', 
 
2988
                   'std::string', 
 
2989
                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
2990
                   is_const=True, visibility='private', is_virtual=True)
 
2991
    return
 
2992
 
 
2993
def register_Ns3EventImpl_methods(root_module, cls):
 
2994
    ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [copy constructor]
 
2995
    cls.add_constructor([param('ns3::EventImpl const &', 'arg0')])
 
2996
    ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl() [constructor]
 
2997
    cls.add_constructor([])
 
2998
    ## event-impl.h (module 'core'): void ns3::EventImpl::Cancel() [member function]
 
2999
    cls.add_method('Cancel', 
 
3000
                   'void', 
 
3001
                   [])
 
3002
    ## event-impl.h (module 'core'): void ns3::EventImpl::Invoke() [member function]
 
3003
    cls.add_method('Invoke', 
 
3004
                   'void', 
 
3005
                   [])
 
3006
    ## event-impl.h (module 'core'): bool ns3::EventImpl::IsCancelled() [member function]
 
3007
    cls.add_method('IsCancelled', 
 
3008
                   'bool', 
 
3009
                   [])
 
3010
    ## event-impl.h (module 'core'): void ns3::EventImpl::Notify() [member function]
 
3011
    cls.add_method('Notify', 
 
3012
                   'void', 
 
3013
                   [], 
 
3014
                   is_pure_virtual=True, visibility='protected', is_virtual=True)
 
3015
    return
 
3016
 
 
3017
def register_Ns3Ipv4AddressChecker_methods(root_module, cls):
 
3018
    ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker() [constructor]
 
3019
    cls.add_constructor([])
 
3020
    ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker(ns3::Ipv4AddressChecker const & arg0) [copy constructor]
 
3021
    cls.add_constructor([param('ns3::Ipv4AddressChecker const &', 'arg0')])
 
3022
    return
 
3023
 
 
3024
def register_Ns3Ipv4AddressValue_methods(root_module, cls):
 
3025
    ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue() [constructor]
 
3026
    cls.add_constructor([])
 
3027
    ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4AddressValue const & arg0) [copy constructor]
 
3028
    cls.add_constructor([param('ns3::Ipv4AddressValue const &', 'arg0')])
 
3029
    ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4Address const & value) [constructor]
 
3030
    cls.add_constructor([param('ns3::Ipv4Address const &', 'value')])
 
3031
    ## ipv4-address.h (module 'network'): ns3::Ptr<ns3::AttributeValue> ns3::Ipv4AddressValue::Copy() const [member function]
 
3032
    cls.add_method('Copy', 
 
3033
                   'ns3::Ptr< ns3::AttributeValue >', 
 
3034
                   [], 
 
3035
                   is_const=True, is_virtual=True)
 
3036
    ## ipv4-address.h (module 'network'): bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
 
3037
    cls.add_method('DeserializeFromString', 
 
3038
                   'bool', 
 
3039
                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
3040
                   is_virtual=True)
 
3041
    ## ipv4-address.h (module 'network'): ns3::Ipv4Address ns3::Ipv4AddressValue::Get() const [member function]
 
3042
    cls.add_method('Get', 
 
3043
                   'ns3::Ipv4Address', 
 
3044
                   [], 
 
3045
                   is_const=True)
 
3046
    ## ipv4-address.h (module 'network'): std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
 
3047
    cls.add_method('SerializeToString', 
 
3048
                   'std::string', 
 
3049
                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
3050
                   is_const=True, is_virtual=True)
 
3051
    ## ipv4-address.h (module 'network'): void ns3::Ipv4AddressValue::Set(ns3::Ipv4Address const & value) [member function]
 
3052
    cls.add_method('Set', 
 
3053
                   'void', 
 
3054
                   [param('ns3::Ipv4Address const &', 'value')])
 
3055
    return
 
3056
 
 
3057
def register_Ns3Ipv4MaskChecker_methods(root_module, cls):
 
3058
    ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker() [constructor]
 
3059
    cls.add_constructor([])
 
3060
    ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker(ns3::Ipv4MaskChecker const & arg0) [copy constructor]
 
3061
    cls.add_constructor([param('ns3::Ipv4MaskChecker const &', 'arg0')])
 
3062
    return
 
3063
 
 
3064
def register_Ns3Ipv4MaskValue_methods(root_module, cls):
 
3065
    ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue() [constructor]
 
3066
    cls.add_constructor([])
 
3067
    ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4MaskValue const & arg0) [copy constructor]
 
3068
    cls.add_constructor([param('ns3::Ipv4MaskValue const &', 'arg0')])
 
3069
    ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4Mask const & value) [constructor]
 
3070
    cls.add_constructor([param('ns3::Ipv4Mask const &', 'value')])
 
3071
    ## ipv4-address.h (module 'network'): ns3::Ptr<ns3::AttributeValue> ns3::Ipv4MaskValue::Copy() const [member function]
 
3072
    cls.add_method('Copy', 
 
3073
                   'ns3::Ptr< ns3::AttributeValue >', 
 
3074
                   [], 
 
3075
                   is_const=True, is_virtual=True)
 
3076
    ## ipv4-address.h (module 'network'): bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
 
3077
    cls.add_method('DeserializeFromString', 
 
3078
                   'bool', 
 
3079
                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
3080
                   is_virtual=True)
 
3081
    ## ipv4-address.h (module 'network'): ns3::Ipv4Mask ns3::Ipv4MaskValue::Get() const [member function]
 
3082
    cls.add_method('Get', 
 
3083
                   'ns3::Ipv4Mask', 
 
3084
                   [], 
 
3085
                   is_const=True)
 
3086
    ## ipv4-address.h (module 'network'): std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
 
3087
    cls.add_method('SerializeToString', 
 
3088
                   'std::string', 
 
3089
                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
3090
                   is_const=True, is_virtual=True)
 
3091
    ## ipv4-address.h (module 'network'): void ns3::Ipv4MaskValue::Set(ns3::Ipv4Mask const & value) [member function]
 
3092
    cls.add_method('Set', 
 
3093
                   'void', 
 
3094
                   [param('ns3::Ipv4Mask const &', 'value')])
 
3095
    return
 
3096
 
 
3097
def register_Ns3Ipv6AddressChecker_methods(root_module, cls):
 
3098
    ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker() [constructor]
 
3099
    cls.add_constructor([])
 
3100
    ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker(ns3::Ipv6AddressChecker const & arg0) [copy constructor]
 
3101
    cls.add_constructor([param('ns3::Ipv6AddressChecker const &', 'arg0')])
 
3102
    return
 
3103
 
 
3104
def register_Ns3Ipv6AddressValue_methods(root_module, cls):
 
3105
    ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue() [constructor]
 
3106
    cls.add_constructor([])
 
3107
    ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6AddressValue const & arg0) [copy constructor]
 
3108
    cls.add_constructor([param('ns3::Ipv6AddressValue const &', 'arg0')])
 
3109
    ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6Address const & value) [constructor]
 
3110
    cls.add_constructor([param('ns3::Ipv6Address const &', 'value')])
 
3111
    ## ipv6-address.h (module 'network'): ns3::Ptr<ns3::AttributeValue> ns3::Ipv6AddressValue::Copy() const [member function]
 
3112
    cls.add_method('Copy', 
 
3113
                   'ns3::Ptr< ns3::AttributeValue >', 
 
3114
                   [], 
 
3115
                   is_const=True, is_virtual=True)
 
3116
    ## ipv6-address.h (module 'network'): bool ns3::Ipv6AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
 
3117
    cls.add_method('DeserializeFromString', 
 
3118
                   'bool', 
 
3119
                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
3120
                   is_virtual=True)
 
3121
    ## ipv6-address.h (module 'network'): ns3::Ipv6Address ns3::Ipv6AddressValue::Get() const [member function]
 
3122
    cls.add_method('Get', 
 
3123
                   'ns3::Ipv6Address', 
 
3124
                   [], 
 
3125
                   is_const=True)
 
3126
    ## ipv6-address.h (module 'network'): std::string ns3::Ipv6AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
 
3127
    cls.add_method('SerializeToString', 
 
3128
                   'std::string', 
 
3129
                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
3130
                   is_const=True, is_virtual=True)
 
3131
    ## ipv6-address.h (module 'network'): void ns3::Ipv6AddressValue::Set(ns3::Ipv6Address const & value) [member function]
 
3132
    cls.add_method('Set', 
 
3133
                   'void', 
 
3134
                   [param('ns3::Ipv6Address const &', 'value')])
 
3135
    return
 
3136
 
 
3137
def register_Ns3Ipv6PrefixChecker_methods(root_module, cls):
 
3138
    ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker() [constructor]
 
3139
    cls.add_constructor([])
 
3140
    ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker(ns3::Ipv6PrefixChecker const & arg0) [copy constructor]
 
3141
    cls.add_constructor([param('ns3::Ipv6PrefixChecker const &', 'arg0')])
 
3142
    return
 
3143
 
 
3144
def register_Ns3Ipv6PrefixValue_methods(root_module, cls):
 
3145
    ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue() [constructor]
 
3146
    cls.add_constructor([])
 
3147
    ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6PrefixValue const & arg0) [copy constructor]
 
3148
    cls.add_constructor([param('ns3::Ipv6PrefixValue const &', 'arg0')])
 
3149
    ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6Prefix const & value) [constructor]
 
3150
    cls.add_constructor([param('ns3::Ipv6Prefix const &', 'value')])
 
3151
    ## ipv6-address.h (module 'network'): ns3::Ptr<ns3::AttributeValue> ns3::Ipv6PrefixValue::Copy() const [member function]
 
3152
    cls.add_method('Copy', 
 
3153
                   'ns3::Ptr< ns3::AttributeValue >', 
 
3154
                   [], 
 
3155
                   is_const=True, is_virtual=True)
 
3156
    ## ipv6-address.h (module 'network'): bool ns3::Ipv6PrefixValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
 
3157
    cls.add_method('DeserializeFromString', 
 
3158
                   'bool', 
 
3159
                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
3160
                   is_virtual=True)
 
3161
    ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix ns3::Ipv6PrefixValue::Get() const [member function]
 
3162
    cls.add_method('Get', 
 
3163
                   'ns3::Ipv6Prefix', 
 
3164
                   [], 
 
3165
                   is_const=True)
 
3166
    ## ipv6-address.h (module 'network'): std::string ns3::Ipv6PrefixValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
 
3167
    cls.add_method('SerializeToString', 
 
3168
                   'std::string', 
 
3169
                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
3170
                   is_const=True, is_virtual=True)
 
3171
    ## ipv6-address.h (module 'network'): void ns3::Ipv6PrefixValue::Set(ns3::Ipv6Prefix const & value) [member function]
 
3172
    cls.add_method('Set', 
 
3173
                   'void', 
 
3174
                   [param('ns3::Ipv6Prefix const &', 'value')])
 
3175
    return
 
3176
 
 
3177
def register_Ns3Mac48AddressChecker_methods(root_module, cls):
 
3178
    ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker() [constructor]
 
3179
    cls.add_constructor([])
 
3180
    ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker(ns3::Mac48AddressChecker const & arg0) [copy constructor]
 
3181
    cls.add_constructor([param('ns3::Mac48AddressChecker const &', 'arg0')])
 
3182
    return
 
3183
 
 
3184
def register_Ns3Mac48AddressValue_methods(root_module, cls):
 
3185
    ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue() [constructor]
 
3186
    cls.add_constructor([])
 
3187
    ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48AddressValue const & arg0) [copy constructor]
 
3188
    cls.add_constructor([param('ns3::Mac48AddressValue const &', 'arg0')])
 
3189
    ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48Address const & value) [constructor]
 
3190
    cls.add_constructor([param('ns3::Mac48Address const &', 'value')])
 
3191
    ## mac48-address.h (module 'network'): ns3::Ptr<ns3::AttributeValue> ns3::Mac48AddressValue::Copy() const [member function]
 
3192
    cls.add_method('Copy', 
 
3193
                   'ns3::Ptr< ns3::AttributeValue >', 
 
3194
                   [], 
 
3195
                   is_const=True, is_virtual=True)
 
3196
    ## mac48-address.h (module 'network'): bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
 
3197
    cls.add_method('DeserializeFromString', 
 
3198
                   'bool', 
 
3199
                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
3200
                   is_virtual=True)
 
3201
    ## mac48-address.h (module 'network'): ns3::Mac48Address ns3::Mac48AddressValue::Get() const [member function]
 
3202
    cls.add_method('Get', 
 
3203
                   'ns3::Mac48Address', 
 
3204
                   [], 
 
3205
                   is_const=True)
 
3206
    ## mac48-address.h (module 'network'): std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
 
3207
    cls.add_method('SerializeToString', 
 
3208
                   'std::string', 
 
3209
                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
3210
                   is_const=True, is_virtual=True)
 
3211
    ## mac48-address.h (module 'network'): void ns3::Mac48AddressValue::Set(ns3::Mac48Address const & value) [member function]
 
3212
    cls.add_method('Set', 
 
3213
                   'void', 
 
3214
                   [param('ns3::Mac48Address const &', 'value')])
 
3215
    return
 
3216
 
 
3217
def register_Ns3MobilityModel_methods(root_module, cls):
 
3218
    ## mobility-model.h (module 'mobility'): ns3::MobilityModel::MobilityModel(ns3::MobilityModel const & arg0) [copy constructor]
 
3219
    cls.add_constructor([param('ns3::MobilityModel const &', 'arg0')])
 
3220
    ## mobility-model.h (module 'mobility'): ns3::MobilityModel::MobilityModel() [constructor]
 
3221
    cls.add_constructor([])
 
3222
    ## mobility-model.h (module 'mobility'): double ns3::MobilityModel::GetDistanceFrom(ns3::Ptr<const ns3::MobilityModel> position) const [member function]
 
3223
    cls.add_method('GetDistanceFrom', 
 
3224
                   'double', 
 
3225
                   [param('ns3::Ptr< ns3::MobilityModel const >', 'position')], 
 
3226
                   is_const=True)
 
3227
    ## mobility-model.h (module 'mobility'): ns3::Vector ns3::MobilityModel::GetPosition() const [member function]
 
3228
    cls.add_method('GetPosition', 
 
3229
                   'ns3::Vector', 
 
3230
                   [], 
 
3231
                   is_const=True)
 
3232
    ## mobility-model.h (module 'mobility'): double ns3::MobilityModel::GetRelativeSpeed(ns3::Ptr<const ns3::MobilityModel> other) const [member function]
 
3233
    cls.add_method('GetRelativeSpeed', 
 
3234
                   'double', 
 
3235
                   [param('ns3::Ptr< ns3::MobilityModel const >', 'other')], 
 
3236
                   is_const=True)
 
3237
    ## mobility-model.h (module 'mobility'): static ns3::TypeId ns3::MobilityModel::GetTypeId() [member function]
 
3238
    cls.add_method('GetTypeId', 
 
3239
                   'ns3::TypeId', 
 
3240
                   [], 
 
3241
                   is_static=True)
 
3242
    ## mobility-model.h (module 'mobility'): ns3::Vector ns3::MobilityModel::GetVelocity() const [member function]
 
3243
    cls.add_method('GetVelocity', 
 
3244
                   'ns3::Vector', 
 
3245
                   [], 
 
3246
                   is_const=True)
 
3247
    ## mobility-model.h (module 'mobility'): void ns3::MobilityModel::SetPosition(ns3::Vector const & position) [member function]
 
3248
    cls.add_method('SetPosition', 
 
3249
                   'void', 
 
3250
                   [param('ns3::Vector const &', 'position')])
 
3251
    ## mobility-model.h (module 'mobility'): void ns3::MobilityModel::NotifyCourseChange() const [member function]
 
3252
    cls.add_method('NotifyCourseChange', 
 
3253
                   'void', 
 
3254
                   [], 
 
3255
                   is_const=True, visibility='protected')
 
3256
    ## mobility-model.h (module 'mobility'): ns3::Vector ns3::MobilityModel::DoGetPosition() const [member function]
 
3257
    cls.add_method('DoGetPosition', 
 
3258
                   'ns3::Vector', 
 
3259
                   [], 
 
3260
                   is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
 
3261
    ## mobility-model.h (module 'mobility'): ns3::Vector ns3::MobilityModel::DoGetVelocity() const [member function]
 
3262
    cls.add_method('DoGetVelocity', 
 
3263
                   'ns3::Vector', 
 
3264
                   [], 
 
3265
                   is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
 
3266
    ## mobility-model.h (module 'mobility'): void ns3::MobilityModel::DoSetPosition(ns3::Vector const & position) [member function]
 
3267
    cls.add_method('DoSetPosition', 
 
3268
                   'void', 
 
3269
                   [param('ns3::Vector const &', 'position')], 
 
3270
                   is_pure_virtual=True, visibility='private', is_virtual=True)
 
3271
    return
 
3272
 
 
3273
def register_Ns3NetDevice_methods(root_module, cls):
 
3274
    ## net-device.h (module 'network'): ns3::NetDevice::NetDevice() [constructor]
 
3275
    cls.add_constructor([])
 
3276
    ## net-device.h (module 'network'): ns3::NetDevice::NetDevice(ns3::NetDevice const & arg0) [copy constructor]
 
3277
    cls.add_constructor([param('ns3::NetDevice const &', 'arg0')])
 
3278
    ## net-device.h (module 'network'): void ns3::NetDevice::AddLinkChangeCallback(ns3::Callback<void,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> callback) [member function]
 
3279
    cls.add_method('AddLinkChangeCallback', 
 
3280
                   'void', 
 
3281
                   [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')], 
 
3282
                   is_pure_virtual=True, is_virtual=True)
 
3283
    ## net-device.h (module 'network'): ns3::Address ns3::NetDevice::GetAddress() const [member function]
 
3284
    cls.add_method('GetAddress', 
 
3285
                   'ns3::Address', 
 
3286
                   [], 
 
3287
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
3288
    ## net-device.h (module 'network'): ns3::Address ns3::NetDevice::GetBroadcast() const [member function]
 
3289
    cls.add_method('GetBroadcast', 
 
3290
                   'ns3::Address', 
 
3291
                   [], 
 
3292
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
3293
    ## net-device.h (module 'network'): ns3::Ptr<ns3::Channel> ns3::NetDevice::GetChannel() const [member function]
 
3294
    cls.add_method('GetChannel', 
 
3295
                   'ns3::Ptr< ns3::Channel >', 
 
3296
                   [], 
 
3297
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
3298
    ## net-device.h (module 'network'): uint32_t ns3::NetDevice::GetIfIndex() const [member function]
 
3299
    cls.add_method('GetIfIndex', 
 
3300
                   'uint32_t', 
 
3301
                   [], 
 
3302
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
3303
    ## net-device.h (module 'network'): uint16_t ns3::NetDevice::GetMtu() const [member function]
 
3304
    cls.add_method('GetMtu', 
 
3305
                   'uint16_t', 
 
3306
                   [], 
 
3307
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
3308
    ## net-device.h (module 'network'): ns3::Address ns3::NetDevice::GetMulticast(ns3::Ipv4Address multicastGroup) const [member function]
 
3309
    cls.add_method('GetMulticast', 
 
3310
                   'ns3::Address', 
 
3311
                   [param('ns3::Ipv4Address', 'multicastGroup')], 
 
3312
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
3313
    ## net-device.h (module 'network'): ns3::Address ns3::NetDevice::GetMulticast(ns3::Ipv6Address addr) const [member function]
 
3314
    cls.add_method('GetMulticast', 
 
3315
                   'ns3::Address', 
 
3316
                   [param('ns3::Ipv6Address', 'addr')], 
 
3317
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
3318
    ## net-device.h (module 'network'): ns3::Ptr<ns3::Node> ns3::NetDevice::GetNode() const [member function]
 
3319
    cls.add_method('GetNode', 
 
3320
                   'ns3::Ptr< ns3::Node >', 
 
3321
                   [], 
 
3322
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
3323
    ## net-device.h (module 'network'): static ns3::TypeId ns3::NetDevice::GetTypeId() [member function]
 
3324
    cls.add_method('GetTypeId', 
 
3325
                   'ns3::TypeId', 
 
3326
                   [], 
 
3327
                   is_static=True)
 
3328
    ## net-device.h (module 'network'): bool ns3::NetDevice::IsBridge() const [member function]
 
3329
    cls.add_method('IsBridge', 
 
3330
                   'bool', 
 
3331
                   [], 
 
3332
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
3333
    ## net-device.h (module 'network'): bool ns3::NetDevice::IsBroadcast() const [member function]
 
3334
    cls.add_method('IsBroadcast', 
 
3335
                   'bool', 
 
3336
                   [], 
 
3337
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
3338
    ## net-device.h (module 'network'): bool ns3::NetDevice::IsLinkUp() const [member function]
 
3339
    cls.add_method('IsLinkUp', 
 
3340
                   'bool', 
 
3341
                   [], 
 
3342
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
3343
    ## net-device.h (module 'network'): bool ns3::NetDevice::IsMulticast() const [member function]
 
3344
    cls.add_method('IsMulticast', 
 
3345
                   'bool', 
 
3346
                   [], 
 
3347
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
3348
    ## net-device.h (module 'network'): bool ns3::NetDevice::IsPointToPoint() const [member function]
 
3349
    cls.add_method('IsPointToPoint', 
 
3350
                   'bool', 
 
3351
                   [], 
 
3352
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
3353
    ## net-device.h (module 'network'): bool ns3::NetDevice::NeedsArp() const [member function]
 
3354
    cls.add_method('NeedsArp', 
 
3355
                   'bool', 
 
3356
                   [], 
 
3357
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
3358
    ## net-device.h (module 'network'): bool ns3::NetDevice::Send(ns3::Ptr<ns3::Packet> packet, ns3::Address const & dest, uint16_t protocolNumber) [member function]
 
3359
    cls.add_method('Send', 
 
3360
                   'bool', 
 
3361
                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], 
 
3362
                   is_pure_virtual=True, is_virtual=True)
 
3363
    ## net-device.h (module 'network'): bool ns3::NetDevice::SendFrom(ns3::Ptr<ns3::Packet> packet, ns3::Address const & source, ns3::Address const & dest, uint16_t protocolNumber) [member function]
 
3364
    cls.add_method('SendFrom', 
 
3365
                   'bool', 
 
3366
                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], 
 
3367
                   is_pure_virtual=True, is_virtual=True)
 
3368
    ## net-device.h (module 'network'): void ns3::NetDevice::SetAddress(ns3::Address address) [member function]
 
3369
    cls.add_method('SetAddress', 
 
3370
                   'void', 
 
3371
                   [param('ns3::Address', 'address')], 
 
3372
                   is_pure_virtual=True, is_virtual=True)
 
3373
    ## net-device.h (module 'network'): void ns3::NetDevice::SetIfIndex(uint32_t const index) [member function]
 
3374
    cls.add_method('SetIfIndex', 
 
3375
                   'void', 
 
3376
                   [param('uint32_t const', 'index')], 
 
3377
                   is_pure_virtual=True, is_virtual=True)
 
3378
    ## net-device.h (module 'network'): bool ns3::NetDevice::SetMtu(uint16_t const mtu) [member function]
 
3379
    cls.add_method('SetMtu', 
 
3380
                   'bool', 
 
3381
                   [param('uint16_t const', 'mtu')], 
 
3382
                   is_pure_virtual=True, is_virtual=True)
 
3383
    ## net-device.h (module 'network'): void ns3::NetDevice::SetNode(ns3::Ptr<ns3::Node> node) [member function]
 
3384
    cls.add_method('SetNode', 
 
3385
                   'void', 
 
3386
                   [param('ns3::Ptr< ns3::Node >', 'node')], 
 
3387
                   is_pure_virtual=True, is_virtual=True)
 
3388
    ## net-device.h (module 'network'): void ns3::NetDevice::SetPromiscReceiveCallback(ns3::Callback<bool,ns3::Ptr<ns3::NetDevice>,ns3::Ptr<const ns3::Packet>,short unsigned int,const ns3::Address&,const ns3::Address&,ns3::NetDevice::PacketType,ns3::empty,ns3::empty,ns3::empty> cb) [member function]
 
3389
    cls.add_method('SetPromiscReceiveCallback', 
 
3390
                   'void', 
 
3391
                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, short unsigned int, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')], 
 
3392
                   is_pure_virtual=True, is_virtual=True)
 
3393
    ## net-device.h (module 'network'): void ns3::NetDevice::SetReceiveCallback(ns3::Callback<bool,ns3::Ptr<ns3::NetDevice>,ns3::Ptr<const ns3::Packet>,short unsigned int,const ns3::Address&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> cb) [member function]
 
3394
    cls.add_method('SetReceiveCallback', 
 
3395
                   'void', 
 
3396
                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, short unsigned int, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], 
 
3397
                   is_pure_virtual=True, is_virtual=True)
 
3398
    ## net-device.h (module 'network'): bool ns3::NetDevice::SupportsSendFrom() const [member function]
 
3399
    cls.add_method('SupportsSendFrom', 
 
3400
                   'bool', 
 
3401
                   [], 
 
3402
                   is_pure_virtual=True, is_const=True, is_virtual=True)
 
3403
    return
 
3404
 
 
3405
def register_Ns3NixVector_methods(root_module, cls):
 
3406
    cls.add_output_stream_operator()
 
3407
    ## nix-vector.h (module 'network'): ns3::NixVector::NixVector() [constructor]
 
3408
    cls.add_constructor([])
 
3409
    ## nix-vector.h (module 'network'): ns3::NixVector::NixVector(ns3::NixVector const & o) [copy constructor]
 
3410
    cls.add_constructor([param('ns3::NixVector const &', 'o')])
 
3411
    ## nix-vector.h (module 'network'): void ns3::NixVector::AddNeighborIndex(uint32_t newBits, uint32_t numberOfBits) [member function]
 
3412
    cls.add_method('AddNeighborIndex', 
 
3413
                   'void', 
 
3414
                   [param('uint32_t', 'newBits'), param('uint32_t', 'numberOfBits')])
 
3415
    ## nix-vector.h (module 'network'): uint32_t ns3::NixVector::BitCount(uint32_t numberOfNeighbors) const [member function]
 
3416
    cls.add_method('BitCount', 
 
3417
                   'uint32_t', 
 
3418
                   [param('uint32_t', 'numberOfNeighbors')], 
 
3419
                   is_const=True)
 
3420
    ## nix-vector.h (module 'network'): ns3::Ptr<ns3::NixVector> ns3::NixVector::Copy() const [member function]
 
3421
    cls.add_method('Copy', 
 
3422
                   'ns3::Ptr< ns3::NixVector >', 
 
3423
                   [], 
 
3424
                   is_const=True)
 
3425
    ## nix-vector.h (module 'network'): uint32_t ns3::NixVector::Deserialize(uint32_t const * buffer, uint32_t size) [member function]
 
3426
    cls.add_method('Deserialize', 
 
3427
                   'uint32_t', 
 
3428
                   [param('uint32_t const *', 'buffer'), param('uint32_t', 'size')])
 
3429
    ## nix-vector.h (module 'network'): uint32_t ns3::NixVector::ExtractNeighborIndex(uint32_t numberOfBits) [member function]
 
3430
    cls.add_method('ExtractNeighborIndex', 
 
3431
                   'uint32_t', 
 
3432
                   [param('uint32_t', 'numberOfBits')])
 
3433
    ## nix-vector.h (module 'network'): uint32_t ns3::NixVector::GetRemainingBits() [member function]
 
3434
    cls.add_method('GetRemainingBits', 
 
3435
                   'uint32_t', 
 
3436
                   [])
 
3437
    ## nix-vector.h (module 'network'): uint32_t ns3::NixVector::GetSerializedSize() const [member function]
 
3438
    cls.add_method('GetSerializedSize', 
 
3439
                   'uint32_t', 
 
3440
                   [], 
 
3441
                   is_const=True)
 
3442
    ## nix-vector.h (module 'network'): uint32_t ns3::NixVector::Serialize(uint32_t * buffer, uint32_t maxSize) const [member function]
 
3443
    cls.add_method('Serialize', 
 
3444
                   'uint32_t', 
 
3445
                   [param('uint32_t *', 'buffer'), param('uint32_t', 'maxSize')], 
 
3446
                   is_const=True)
 
3447
    return
 
3448
 
 
3449
def register_Ns3Node_methods(root_module, cls):
 
3450
    ## node.h (module 'network'): ns3::Node::Node(ns3::Node const & arg0) [copy constructor]
 
3451
    cls.add_constructor([param('ns3::Node const &', 'arg0')])
 
3452
    ## node.h (module 'network'): ns3::Node::Node() [constructor]
 
3453
    cls.add_constructor([])
 
3454
    ## node.h (module 'network'): ns3::Node::Node(uint32_t systemId) [constructor]
 
3455
    cls.add_constructor([param('uint32_t', 'systemId')])
 
3456
    ## node.h (module 'network'): uint32_t ns3::Node::AddApplication(ns3::Ptr<ns3::Application> application) [member function]
 
3457
    cls.add_method('AddApplication', 
 
3458
                   'uint32_t', 
 
3459
                   [param('ns3::Ptr< ns3::Application >', 'application')])
 
3460
    ## node.h (module 'network'): uint32_t ns3::Node::AddDevice(ns3::Ptr<ns3::NetDevice> device) [member function]
 
3461
    cls.add_method('AddDevice', 
 
3462
                   'uint32_t', 
 
3463
                   [param('ns3::Ptr< ns3::NetDevice >', 'device')])
 
3464
    ## node.h (module 'network'): static bool ns3::Node::ChecksumEnabled() [member function]
 
3465
    cls.add_method('ChecksumEnabled', 
 
3466
                   'bool', 
 
3467
                   [], 
 
3468
                   is_static=True)
 
3469
    ## node.h (module 'network'): ns3::Ptr<ns3::Application> ns3::Node::GetApplication(uint32_t index) const [member function]
 
3470
    cls.add_method('GetApplication', 
 
3471
                   'ns3::Ptr< ns3::Application >', 
 
3472
                   [param('uint32_t', 'index')], 
 
3473
                   is_const=True)
 
3474
    ## node.h (module 'network'): ns3::Ptr<ns3::NetDevice> ns3::Node::GetDevice(uint32_t index) const [member function]
 
3475
    cls.add_method('GetDevice', 
 
3476
                   'ns3::Ptr< ns3::NetDevice >', 
 
3477
                   [param('uint32_t', 'index')], 
 
3478
                   is_const=True)
 
3479
    ## node.h (module 'network'): uint32_t ns3::Node::GetId() const [member function]
 
3480
    cls.add_method('GetId', 
 
3481
                   'uint32_t', 
 
3482
                   [], 
 
3483
                   is_const=True)
 
3484
    ## node.h (module 'network'): uint32_t ns3::Node::GetNApplications() const [member function]
 
3485
    cls.add_method('GetNApplications', 
 
3486
                   'uint32_t', 
 
3487
                   [], 
 
3488
                   is_const=True)
 
3489
    ## node.h (module 'network'): uint32_t ns3::Node::GetNDevices() const [member function]
 
3490
    cls.add_method('GetNDevices', 
 
3491
                   'uint32_t', 
 
3492
                   [], 
 
3493
                   is_const=True)
 
3494
    ## node.h (module 'network'): uint32_t ns3::Node::GetSystemId() const [member function]
 
3495
    cls.add_method('GetSystemId', 
 
3496
                   'uint32_t', 
 
3497
                   [], 
 
3498
                   is_const=True)
 
3499
    ## node.h (module 'network'): static ns3::TypeId ns3::Node::GetTypeId() [member function]
 
3500
    cls.add_method('GetTypeId', 
 
3501
                   'ns3::TypeId', 
 
3502
                   [], 
 
3503
                   is_static=True)
 
3504
    ## node.h (module 'network'): void ns3::Node::RegisterDeviceAdditionListener(ns3::Callback<void,ns3::Ptr<ns3::NetDevice>,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> listener) [member function]
 
3505
    cls.add_method('RegisterDeviceAdditionListener', 
 
3506
                   'void', 
 
3507
                   [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'listener')])
 
3508
    ## node.h (module 'network'): void ns3::Node::RegisterProtocolHandler(ns3::Callback<void, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> handler, uint16_t protocolType, ns3::Ptr<ns3::NetDevice> device, bool promiscuous=false) [member function]
 
3509
    cls.add_method('RegisterProtocolHandler', 
 
3510
                   'void', 
 
3511
                   [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'handler'), param('uint16_t', 'protocolType'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'promiscuous', default_value='false')])
 
3512
    ## node.h (module 'network'): void ns3::Node::UnregisterDeviceAdditionListener(ns3::Callback<void,ns3::Ptr<ns3::NetDevice>,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> listener) [member function]
 
3513
    cls.add_method('UnregisterDeviceAdditionListener', 
 
3514
                   'void', 
 
3515
                   [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'listener')])
 
3516
    ## node.h (module 'network'): void ns3::Node::UnregisterProtocolHandler(ns3::Callback<void, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> handler) [member function]
 
3517
    cls.add_method('UnregisterProtocolHandler', 
 
3518
                   'void', 
 
3519
                   [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'handler')])
 
3520
    ## node.h (module 'network'): void ns3::Node::DoDispose() [member function]
 
3521
    cls.add_method('DoDispose', 
 
3522
                   'void', 
 
3523
                   [], 
 
3524
                   visibility='protected', is_virtual=True)
 
3525
    ## node.h (module 'network'): void ns3::Node::DoStart() [member function]
 
3526
    cls.add_method('DoStart', 
 
3527
                   'void', 
 
3528
                   [], 
 
3529
                   visibility='protected', is_virtual=True)
 
3530
    return
 
3531
 
 
3532
def register_Ns3ObjectFactoryChecker_methods(root_module, cls):
 
3533
    ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker() [constructor]
 
3534
    cls.add_constructor([])
 
3535
    ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [copy constructor]
 
3536
    cls.add_constructor([param('ns3::ObjectFactoryChecker const &', 'arg0')])
 
3537
    return
 
3538
 
 
3539
def register_Ns3ObjectFactoryValue_methods(root_module, cls):
 
3540
    ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue() [constructor]
 
3541
    cls.add_constructor([])
 
3542
    ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [copy constructor]
 
3543
    cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')])
 
3544
    ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactory const & value) [constructor]
 
3545
    cls.add_constructor([param('ns3::ObjectFactory const &', 'value')])
 
3546
    ## object-factory.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::ObjectFactoryValue::Copy() const [member function]
 
3547
    cls.add_method('Copy', 
 
3548
                   'ns3::Ptr< ns3::AttributeValue >', 
 
3549
                   [], 
 
3550
                   is_const=True, is_virtual=True)
 
3551
    ## object-factory.h (module 'core'): bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
 
3552
    cls.add_method('DeserializeFromString', 
 
3553
                   'bool', 
 
3554
                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
3555
                   is_virtual=True)
 
3556
    ## object-factory.h (module 'core'): ns3::ObjectFactory ns3::ObjectFactoryValue::Get() const [member function]
 
3557
    cls.add_method('Get', 
 
3558
                   'ns3::ObjectFactory', 
 
3559
                   [], 
 
3560
                   is_const=True)
 
3561
    ## object-factory.h (module 'core'): std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
 
3562
    cls.add_method('SerializeToString', 
 
3563
                   'std::string', 
 
3564
                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
3565
                   is_const=True, is_virtual=True)
 
3566
    ## object-factory.h (module 'core'): void ns3::ObjectFactoryValue::Set(ns3::ObjectFactory const & value) [member function]
 
3567
    cls.add_method('Set', 
 
3568
                   'void', 
 
3569
                   [param('ns3::ObjectFactory const &', 'value')])
 
3570
    return
 
3571
 
 
3572
def register_Ns3Packet_methods(root_module, cls):
 
3573
    cls.add_output_stream_operator()
 
3574
    ## packet.h (module 'network'): ns3::Packet::Packet() [constructor]
 
3575
    cls.add_constructor([])
 
3576
    ## packet.h (module 'network'): ns3::Packet::Packet(ns3::Packet const & o) [copy constructor]
 
3577
    cls.add_constructor([param('ns3::Packet const &', 'o')])
 
3578
    ## packet.h (module 'network'): ns3::Packet::Packet(uint32_t size) [constructor]
 
3579
    cls.add_constructor([param('uint32_t', 'size')])
 
3580
    ## packet.h (module 'network'): ns3::Packet::Packet(uint8_t const * buffer, uint32_t size, bool magic) [constructor]
 
3581
    cls.add_constructor([param('uint8_t const *', 'buffer'), param('uint32_t', 'size'), param('bool', 'magic')])
 
3582
    ## packet.h (module 'network'): ns3::Packet::Packet(uint8_t const * buffer, uint32_t size) [constructor]
 
3583
    cls.add_constructor([param('uint8_t const *', 'buffer'), param('uint32_t', 'size')])
 
3584
    ## packet.h (module 'network'): void ns3::Packet::AddAtEnd(ns3::Ptr<const ns3::Packet> packet) [member function]
 
3585
    cls.add_method('AddAtEnd', 
 
3586
                   'void', 
 
3587
                   [param('ns3::Ptr< ns3::Packet const >', 'packet')])
 
3588
    ## packet.h (module 'network'): void ns3::Packet::AddByteTag(ns3::Tag const & tag) const [member function]
 
3589
    cls.add_method('AddByteTag', 
 
3590
                   'void', 
 
3591
                   [param('ns3::Tag const &', 'tag')], 
 
3592
                   is_const=True)
 
3593
    ## packet.h (module 'network'): void ns3::Packet::AddHeader(ns3::Header const & header) [member function]
 
3594
    cls.add_method('AddHeader', 
 
3595
                   'void', 
 
3596
                   [param('ns3::Header const &', 'header')])
 
3597
    ## packet.h (module 'network'): void ns3::Packet::AddPacketTag(ns3::Tag const & tag) const [member function]
 
3598
    cls.add_method('AddPacketTag', 
 
3599
                   'void', 
 
3600
                   [param('ns3::Tag const &', 'tag')], 
 
3601
                   is_const=True)
 
3602
    ## packet.h (module 'network'): void ns3::Packet::AddPaddingAtEnd(uint32_t size) [member function]
 
3603
    cls.add_method('AddPaddingAtEnd', 
 
3604
                   'void', 
 
3605
                   [param('uint32_t', 'size')])
 
3606
    ## packet.h (module 'network'): void ns3::Packet::AddTrailer(ns3::Trailer const & trailer) [member function]
 
3607
    cls.add_method('AddTrailer', 
 
3608
                   'void', 
 
3609
                   [param('ns3::Trailer const &', 'trailer')])
 
3610
    ## packet.h (module 'network'): ns3::PacketMetadata::ItemIterator ns3::Packet::BeginItem() const [member function]
 
3611
    cls.add_method('BeginItem', 
 
3612
                   'ns3::PacketMetadata::ItemIterator', 
 
3613
                   [], 
 
3614
                   is_const=True)
 
3615
    ## packet.h (module 'network'): ns3::Ptr<ns3::Packet> ns3::Packet::Copy() const [member function]
 
3616
    cls.add_method('Copy', 
 
3617
                   'ns3::Ptr< ns3::Packet >', 
 
3618
                   [], 
 
3619
                   is_const=True)
 
3620
    ## packet.h (module 'network'): uint32_t ns3::Packet::CopyData(uint8_t * buffer, uint32_t size) const [member function]
 
3621
    cls.add_method('CopyData', 
 
3622
                   'uint32_t', 
 
3623
                   [param('uint8_t *', 'buffer'), param('uint32_t', 'size')], 
 
3624
                   is_const=True)
 
3625
    ## packet.h (module 'network'): void ns3::Packet::CopyData(std::ostream * os, uint32_t size) const [member function]
 
3626
    cls.add_method('CopyData', 
 
3627
                   'void', 
 
3628
                   [param('std::ostream *', 'os'), param('uint32_t', 'size')], 
 
3629
                   is_const=True)
 
3630
    ## packet.h (module 'network'): ns3::Ptr<ns3::Packet> ns3::Packet::CreateFragment(uint32_t start, uint32_t length) const [member function]
 
3631
    cls.add_method('CreateFragment', 
 
3632
                   'ns3::Ptr< ns3::Packet >', 
 
3633
                   [param('uint32_t', 'start'), param('uint32_t', 'length')], 
 
3634
                   is_const=True)
 
3635
    ## packet.h (module 'network'): static void ns3::Packet::EnableChecking() [member function]
 
3636
    cls.add_method('EnableChecking', 
 
3637
                   'void', 
 
3638
                   [], 
 
3639
                   is_static=True)
 
3640
    ## packet.h (module 'network'): static void ns3::Packet::EnablePrinting() [member function]
 
3641
    cls.add_method('EnablePrinting', 
 
3642
                   'void', 
 
3643
                   [], 
 
3644
                   is_static=True)
 
3645
    ## packet.h (module 'network'): bool ns3::Packet::FindFirstMatchingByteTag(ns3::Tag & tag) const [member function]
 
3646
    cls.add_method('FindFirstMatchingByteTag', 
 
3647
                   'bool', 
 
3648
                   [param('ns3::Tag &', 'tag')], 
 
3649
                   is_const=True)
 
3650
    ## packet.h (module 'network'): ns3::ByteTagIterator ns3::Packet::GetByteTagIterator() const [member function]
 
3651
    cls.add_method('GetByteTagIterator', 
 
3652
                   'ns3::ByteTagIterator', 
 
3653
                   [], 
 
3654
                   is_const=True)
 
3655
    ## packet.h (module 'network'): ns3::Ptr<ns3::NixVector> ns3::Packet::GetNixVector() const [member function]
 
3656
    cls.add_method('GetNixVector', 
 
3657
                   'ns3::Ptr< ns3::NixVector >', 
 
3658
                   [], 
 
3659
                   is_const=True)
 
3660
    ## packet.h (module 'network'): ns3::PacketTagIterator ns3::Packet::GetPacketTagIterator() const [member function]
 
3661
    cls.add_method('GetPacketTagIterator', 
 
3662
                   'ns3::PacketTagIterator', 
 
3663
                   [], 
 
3664
                   is_const=True)
 
3665
    ## packet.h (module 'network'): uint32_t ns3::Packet::GetSerializedSize() const [member function]
 
3666
    cls.add_method('GetSerializedSize', 
 
3667
                   'uint32_t', 
 
3668
                   [], 
 
3669
                   is_const=True)
 
3670
    ## packet.h (module 'network'): uint32_t ns3::Packet::GetSize() const [member function]
 
3671
    cls.add_method('GetSize', 
 
3672
                   'uint32_t', 
 
3673
                   [], 
 
3674
                   is_const=True)
 
3675
    ## packet.h (module 'network'): uint64_t ns3::Packet::GetUid() const [member function]
 
3676
    cls.add_method('GetUid', 
 
3677
                   'uint64_t', 
 
3678
                   [], 
 
3679
                   is_const=True)
 
3680
    ## packet.h (module 'network'): uint8_t const * ns3::Packet::PeekData() const [member function]
 
3681
    cls.add_method('PeekData', 
 
3682
                   'uint8_t const *', 
 
3683
                   [], 
 
3684
                   deprecated=True, is_const=True)
 
3685
    ## packet.h (module 'network'): uint32_t ns3::Packet::PeekHeader(ns3::Header & header) const [member function]
 
3686
    cls.add_method('PeekHeader', 
 
3687
                   'uint32_t', 
 
3688
                   [param('ns3::Header &', 'header')], 
 
3689
                   is_const=True)
 
3690
    ## packet.h (module 'network'): bool ns3::Packet::PeekPacketTag(ns3::Tag & tag) const [member function]
 
3691
    cls.add_method('PeekPacketTag', 
 
3692
                   'bool', 
 
3693
                   [param('ns3::Tag &', 'tag')], 
 
3694
                   is_const=True)
 
3695
    ## packet.h (module 'network'): uint32_t ns3::Packet::PeekTrailer(ns3::Trailer & trailer) [member function]
 
3696
    cls.add_method('PeekTrailer', 
 
3697
                   'uint32_t', 
 
3698
                   [param('ns3::Trailer &', 'trailer')])
 
3699
    ## packet.h (module 'network'): void ns3::Packet::Print(std::ostream & os) const [member function]
 
3700
    cls.add_method('Print', 
 
3701
                   'void', 
 
3702
                   [param('std::ostream &', 'os')], 
 
3703
                   is_const=True)
 
3704
    ## packet.h (module 'network'): void ns3::Packet::PrintByteTags(std::ostream & os) const [member function]
 
3705
    cls.add_method('PrintByteTags', 
 
3706
                   'void', 
 
3707
                   [param('std::ostream &', 'os')], 
 
3708
                   is_const=True)
 
3709
    ## packet.h (module 'network'): void ns3::Packet::PrintPacketTags(std::ostream & os) const [member function]
 
3710
    cls.add_method('PrintPacketTags', 
 
3711
                   'void', 
 
3712
                   [param('std::ostream &', 'os')], 
 
3713
                   is_const=True)
 
3714
    ## packet.h (module 'network'): void ns3::Packet::RemoveAllByteTags() [member function]
 
3715
    cls.add_method('RemoveAllByteTags', 
 
3716
                   'void', 
 
3717
                   [])
 
3718
    ## packet.h (module 'network'): void ns3::Packet::RemoveAllPacketTags() [member function]
 
3719
    cls.add_method('RemoveAllPacketTags', 
 
3720
                   'void', 
 
3721
                   [])
 
3722
    ## packet.h (module 'network'): void ns3::Packet::RemoveAtEnd(uint32_t size) [member function]
 
3723
    cls.add_method('RemoveAtEnd', 
 
3724
                   'void', 
 
3725
                   [param('uint32_t', 'size')])
 
3726
    ## packet.h (module 'network'): void ns3::Packet::RemoveAtStart(uint32_t size) [member function]
 
3727
    cls.add_method('RemoveAtStart', 
 
3728
                   'void', 
 
3729
                   [param('uint32_t', 'size')])
 
3730
    ## packet.h (module 'network'): uint32_t ns3::Packet::RemoveHeader(ns3::Header & header) [member function]
 
3731
    cls.add_method('RemoveHeader', 
 
3732
                   'uint32_t', 
 
3733
                   [param('ns3::Header &', 'header')])
 
3734
    ## packet.h (module 'network'): bool ns3::Packet::RemovePacketTag(ns3::Tag & tag) [member function]
 
3735
    cls.add_method('RemovePacketTag', 
 
3736
                   'bool', 
 
3737
                   [param('ns3::Tag &', 'tag')])
 
3738
    ## packet.h (module 'network'): uint32_t ns3::Packet::RemoveTrailer(ns3::Trailer & trailer) [member function]
 
3739
    cls.add_method('RemoveTrailer', 
 
3740
                   'uint32_t', 
 
3741
                   [param('ns3::Trailer &', 'trailer')])
 
3742
    ## packet.h (module 'network'): uint32_t ns3::Packet::Serialize(uint8_t * buffer, uint32_t maxSize) const [member function]
 
3743
    cls.add_method('Serialize', 
 
3744
                   'uint32_t', 
 
3745
                   [param('uint8_t *', 'buffer'), param('uint32_t', 'maxSize')], 
 
3746
                   is_const=True)
 
3747
    ## packet.h (module 'network'): void ns3::Packet::SetNixVector(ns3::Ptr<ns3::NixVector> arg0) [member function]
 
3748
    cls.add_method('SetNixVector', 
 
3749
                   'void', 
 
3750
                   [param('ns3::Ptr< ns3::NixVector >', 'arg0')])
 
3751
    return
 
3752
 
 
3753
def register_Ns3TimeChecker_methods(root_module, cls):
 
3754
    ## nstime.h (module 'core'): ns3::TimeChecker::TimeChecker() [constructor]
 
3755
    cls.add_constructor([])
 
3756
    ## nstime.h (module 'core'): ns3::TimeChecker::TimeChecker(ns3::TimeChecker const & arg0) [copy constructor]
 
3757
    cls.add_constructor([param('ns3::TimeChecker const &', 'arg0')])
 
3758
    return
 
3759
 
 
3760
def register_Ns3TimeValue_methods(root_module, cls):
 
3761
    ## nstime.h (module 'core'): ns3::TimeValue::TimeValue() [constructor]
 
3762
    cls.add_constructor([])
 
3763
    ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [copy constructor]
 
3764
    cls.add_constructor([param('ns3::TimeValue const &', 'arg0')])
 
3765
    ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::Time const & value) [constructor]
 
3766
    cls.add_constructor([param('ns3::Time const &', 'value')])
 
3767
    ## nstime.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::TimeValue::Copy() const [member function]
 
3768
    cls.add_method('Copy', 
 
3769
                   'ns3::Ptr< ns3::AttributeValue >', 
 
3770
                   [], 
 
3771
                   is_const=True, is_virtual=True)
 
3772
    ## nstime.h (module 'core'): bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
 
3773
    cls.add_method('DeserializeFromString', 
 
3774
                   'bool', 
 
3775
                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
3776
                   is_virtual=True)
 
3777
    ## nstime.h (module 'core'): ns3::Time ns3::TimeValue::Get() const [member function]
 
3778
    cls.add_method('Get', 
 
3779
                   'ns3::Time', 
 
3780
                   [], 
 
3781
                   is_const=True)
 
3782
    ## nstime.h (module 'core'): std::string ns3::TimeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
 
3783
    cls.add_method('SerializeToString', 
 
3784
                   'std::string', 
 
3785
                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
3786
                   is_const=True, is_virtual=True)
 
3787
    ## nstime.h (module 'core'): void ns3::TimeValue::Set(ns3::Time const & value) [member function]
 
3788
    cls.add_method('Set', 
 
3789
                   'void', 
 
3790
                   [param('ns3::Time const &', 'value')])
 
3791
    return
 
3792
 
 
3793
def register_Ns3TypeIdChecker_methods(root_module, cls):
 
3794
    ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker() [constructor]
 
3795
    cls.add_constructor([])
 
3796
    ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [copy constructor]
 
3797
    cls.add_constructor([param('ns3::TypeIdChecker const &', 'arg0')])
 
3798
    return
 
3799
 
 
3800
def register_Ns3TypeIdValue_methods(root_module, cls):
 
3801
    ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue() [constructor]
 
3802
    cls.add_constructor([])
 
3803
    ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [copy constructor]
 
3804
    cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')])
 
3805
    ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeId const & value) [constructor]
 
3806
    cls.add_constructor([param('ns3::TypeId const &', 'value')])
 
3807
    ## type-id.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::TypeIdValue::Copy() const [member function]
 
3808
    cls.add_method('Copy', 
 
3809
                   'ns3::Ptr< ns3::AttributeValue >', 
 
3810
                   [], 
 
3811
                   is_const=True, is_virtual=True)
 
3812
    ## type-id.h (module 'core'): bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
 
3813
    cls.add_method('DeserializeFromString', 
 
3814
                   'bool', 
 
3815
                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
3816
                   is_virtual=True)
 
3817
    ## type-id.h (module 'core'): ns3::TypeId ns3::TypeIdValue::Get() const [member function]
 
3818
    cls.add_method('Get', 
 
3819
                   'ns3::TypeId', 
 
3820
                   [], 
 
3821
                   is_const=True)
 
3822
    ## type-id.h (module 'core'): std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
 
3823
    cls.add_method('SerializeToString', 
 
3824
                   'std::string', 
 
3825
                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
3826
                   is_const=True, is_virtual=True)
 
3827
    ## type-id.h (module 'core'): void ns3::TypeIdValue::Set(ns3::TypeId const & value) [member function]
 
3828
    cls.add_method('Set', 
 
3829
                   'void', 
 
3830
                   [param('ns3::TypeId const &', 'value')])
 
3831
    return
 
3832
 
 
3833
def register_Ns3Vector2DChecker_methods(root_module, cls):
 
3834
    ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker() [constructor]
 
3835
    cls.add_constructor([])
 
3836
    ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker(ns3::Vector2DChecker const & arg0) [copy constructor]
 
3837
    cls.add_constructor([param('ns3::Vector2DChecker const &', 'arg0')])
 
3838
    return
 
3839
 
 
3840
def register_Ns3Vector2DValue_methods(root_module, cls):
 
3841
    ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue() [constructor]
 
3842
    cls.add_constructor([])
 
3843
    ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2DValue const & arg0) [copy constructor]
 
3844
    cls.add_constructor([param('ns3::Vector2DValue const &', 'arg0')])
 
3845
    ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2D const & value) [constructor]
 
3846
    cls.add_constructor([param('ns3::Vector2D const &', 'value')])
 
3847
    ## vector.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::Vector2DValue::Copy() const [member function]
 
3848
    cls.add_method('Copy', 
 
3849
                   'ns3::Ptr< ns3::AttributeValue >', 
 
3850
                   [], 
 
3851
                   is_const=True, is_virtual=True)
 
3852
    ## vector.h (module 'core'): bool ns3::Vector2DValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
 
3853
    cls.add_method('DeserializeFromString', 
 
3854
                   'bool', 
 
3855
                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
3856
                   is_virtual=True)
 
3857
    ## vector.h (module 'core'): ns3::Vector2D ns3::Vector2DValue::Get() const [member function]
 
3858
    cls.add_method('Get', 
 
3859
                   'ns3::Vector2D', 
 
3860
                   [], 
 
3861
                   is_const=True)
 
3862
    ## vector.h (module 'core'): std::string ns3::Vector2DValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
 
3863
    cls.add_method('SerializeToString', 
 
3864
                   'std::string', 
 
3865
                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
3866
                   is_const=True, is_virtual=True)
 
3867
    ## vector.h (module 'core'): void ns3::Vector2DValue::Set(ns3::Vector2D const & value) [member function]
 
3868
    cls.add_method('Set', 
 
3869
                   'void', 
 
3870
                   [param('ns3::Vector2D const &', 'value')])
 
3871
    return
 
3872
 
 
3873
def register_Ns3Vector3DChecker_methods(root_module, cls):
 
3874
    ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker() [constructor]
 
3875
    cls.add_constructor([])
 
3876
    ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker(ns3::Vector3DChecker const & arg0) [copy constructor]
 
3877
    cls.add_constructor([param('ns3::Vector3DChecker const &', 'arg0')])
 
3878
    return
 
3879
 
 
3880
def register_Ns3Vector3DValue_methods(root_module, cls):
 
3881
    ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue() [constructor]
 
3882
    cls.add_constructor([])
 
3883
    ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3DValue const & arg0) [copy constructor]
 
3884
    cls.add_constructor([param('ns3::Vector3DValue const &', 'arg0')])
 
3885
    ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3D const & value) [constructor]
 
3886
    cls.add_constructor([param('ns3::Vector3D const &', 'value')])
 
3887
    ## vector.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::Vector3DValue::Copy() const [member function]
 
3888
    cls.add_method('Copy', 
 
3889
                   'ns3::Ptr< ns3::AttributeValue >', 
 
3890
                   [], 
 
3891
                   is_const=True, is_virtual=True)
 
3892
    ## vector.h (module 'core'): bool ns3::Vector3DValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
 
3893
    cls.add_method('DeserializeFromString', 
 
3894
                   'bool', 
 
3895
                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
3896
                   is_virtual=True)
 
3897
    ## vector.h (module 'core'): ns3::Vector3D ns3::Vector3DValue::Get() const [member function]
 
3898
    cls.add_method('Get', 
 
3899
                   'ns3::Vector3D', 
 
3900
                   [], 
 
3901
                   is_const=True)
 
3902
    ## vector.h (module 'core'): std::string ns3::Vector3DValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
 
3903
    cls.add_method('SerializeToString', 
 
3904
                   'std::string', 
 
3905
                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
3906
                   is_const=True, is_virtual=True)
 
3907
    ## vector.h (module 'core'): void ns3::Vector3DValue::Set(ns3::Vector3D const & value) [member function]
 
3908
    cls.add_method('Set', 
 
3909
                   'void', 
 
3910
                   [param('ns3::Vector3D const &', 'value')])
 
3911
    return
 
3912
 
 
3913
def register_Ns3AddressChecker_methods(root_module, cls):
 
3914
    ## address.h (module 'network'): ns3::AddressChecker::AddressChecker() [constructor]
 
3915
    cls.add_constructor([])
 
3916
    ## address.h (module 'network'): ns3::AddressChecker::AddressChecker(ns3::AddressChecker const & arg0) [copy constructor]
 
3917
    cls.add_constructor([param('ns3::AddressChecker const &', 'arg0')])
 
3918
    return
 
3919
 
 
3920
def register_Ns3AddressValue_methods(root_module, cls):
 
3921
    ## address.h (module 'network'): ns3::AddressValue::AddressValue() [constructor]
 
3922
    cls.add_constructor([])
 
3923
    ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::AddressValue const & arg0) [copy constructor]
 
3924
    cls.add_constructor([param('ns3::AddressValue const &', 'arg0')])
 
3925
    ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::Address const & value) [constructor]
 
3926
    cls.add_constructor([param('ns3::Address const &', 'value')])
 
3927
    ## address.h (module 'network'): ns3::Ptr<ns3::AttributeValue> ns3::AddressValue::Copy() const [member function]
 
3928
    cls.add_method('Copy', 
 
3929
                   'ns3::Ptr< ns3::AttributeValue >', 
 
3930
                   [], 
 
3931
                   is_const=True, is_virtual=True)
 
3932
    ## address.h (module 'network'): bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
 
3933
    cls.add_method('DeserializeFromString', 
 
3934
                   'bool', 
 
3935
                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
3936
                   is_virtual=True)
 
3937
    ## address.h (module 'network'): ns3::Address ns3::AddressValue::Get() const [member function]
 
3938
    cls.add_method('Get', 
 
3939
                   'ns3::Address', 
 
3940
                   [], 
 
3941
                   is_const=True)
 
3942
    ## address.h (module 'network'): std::string ns3::AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
 
3943
    cls.add_method('SerializeToString', 
 
3944
                   'std::string', 
 
3945
                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
 
3946
                   is_const=True, is_virtual=True)
 
3947
    ## address.h (module 'network'): void ns3::AddressValue::Set(ns3::Address const & value) [member function]
 
3948
    cls.add_method('Set', 
 
3949
                   'void', 
 
3950
                   [param('ns3::Address const &', 'value')])
 
3951
    return
 
3952
 
 
3953
def register_Ns3ConfigMatchContainer_methods(root_module, cls):
 
3954
    ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer(ns3::Config::MatchContainer const & arg0) [copy constructor]
 
3955
    cls.add_constructor([param('ns3::Config::MatchContainer const &', 'arg0')])
 
3956
    ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer() [constructor]
 
3957
    cls.add_constructor([])
 
3958
    ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer(std::vector<ns3::Ptr<ns3::Object>, std::allocator<ns3::Ptr<ns3::Object> > > const & objects, std::vector<std::string, std::allocator<std::string> > const & contexts, std::string path) [constructor]
 
3959
    cls.add_constructor([param('std::vector< ns3::Ptr< ns3::Object > > const &', 'objects'), param('std::vector< std::string > const &', 'contexts'), param('std::string', 'path')])
 
3960
    ## config.h (module 'core'): __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Object>*,std::vector<ns3::Ptr<ns3::Object>, std::allocator<ns3::Ptr<ns3::Object> > > > ns3::Config::MatchContainer::Begin() const [member function]
 
3961
    cls.add_method('Begin', 
 
3962
                   '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Object > const, std::vector< ns3::Ptr< ns3::Object > > >', 
 
3963
                   [], 
 
3964
                   is_const=True)
 
3965
    ## config.h (module 'core'): void ns3::Config::MatchContainer::Connect(std::string name, ns3::CallbackBase const & cb) [member function]
 
3966
    cls.add_method('Connect', 
 
3967
                   'void', 
 
3968
                   [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
 
3969
    ## config.h (module 'core'): void ns3::Config::MatchContainer::ConnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
 
3970
    cls.add_method('ConnectWithoutContext', 
 
3971
                   'void', 
 
3972
                   [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
 
3973
    ## config.h (module 'core'): void ns3::Config::MatchContainer::Disconnect(std::string name, ns3::CallbackBase const & cb) [member function]
 
3974
    cls.add_method('Disconnect', 
 
3975
                   'void', 
 
3976
                   [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
 
3977
    ## config.h (module 'core'): void ns3::Config::MatchContainer::DisconnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
 
3978
    cls.add_method('DisconnectWithoutContext', 
 
3979
                   'void', 
 
3980
                   [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
 
3981
    ## config.h (module 'core'): __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Object>*,std::vector<ns3::Ptr<ns3::Object>, std::allocator<ns3::Ptr<ns3::Object> > > > ns3::Config::MatchContainer::End() const [member function]
 
3982
    cls.add_method('End', 
 
3983
                   '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Object > const, std::vector< ns3::Ptr< ns3::Object > > >', 
 
3984
                   [], 
 
3985
                   is_const=True)
 
3986
    ## config.h (module 'core'): ns3::Ptr<ns3::Object> ns3::Config::MatchContainer::Get(uint32_t i) const [member function]
 
3987
    cls.add_method('Get', 
 
3988
                   'ns3::Ptr< ns3::Object >', 
 
3989
                   [param('uint32_t', 'i')], 
 
3990
                   is_const=True)
 
3991
    ## config.h (module 'core'): std::string ns3::Config::MatchContainer::GetMatchedPath(uint32_t i) const [member function]
 
3992
    cls.add_method('GetMatchedPath', 
 
3993
                   'std::string', 
 
3994
                   [param('uint32_t', 'i')], 
 
3995
                   is_const=True)
 
3996
    ## config.h (module 'core'): uint32_t ns3::Config::MatchContainer::GetN() const [member function]
 
3997
    cls.add_method('GetN', 
 
3998
                   'uint32_t', 
 
3999
                   [], 
 
4000
                   is_const=True)
 
4001
    ## config.h (module 'core'): std::string ns3::Config::MatchContainer::GetPath() const [member function]
 
4002
    cls.add_method('GetPath', 
 
4003
                   'std::string', 
 
4004
                   [], 
 
4005
                   is_const=True)
 
4006
    ## config.h (module 'core'): void ns3::Config::MatchContainer::Set(std::string name, ns3::AttributeValue const & value) [member function]
 
4007
    cls.add_method('Set', 
 
4008
                   'void', 
 
4009
                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
 
4010
    return
 
4011
 
 
4012
def register_functions(root_module):
 
4013
    module = root_module
 
4014
    register_functions_ns3_Config(module.get_submodule('Config'), root_module)
 
4015
    register_functions_ns3_FatalImpl(module.get_submodule('FatalImpl'), root_module)
 
4016
    return
 
4017
 
 
4018
def register_functions_ns3_Config(module, root_module):
 
4019
    return
 
4020
 
 
4021
def register_functions_ns3_FatalImpl(module, root_module):
 
4022
    return
 
4023
 
 
4024
def main():
 
4025
    out = FileCodeSink(sys.stdout)
 
4026
    root_module = module_init()
 
4027
    register_types(root_module)
 
4028
    register_methods(root_module)
 
4029
    register_functions(root_module)
 
4030
    root_module.generate(out)
 
4031
 
 
4032
if __name__ == '__main__':
 
4033
    main()
 
4034