bindings/python/ns3_module_stats.py
author Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
Sat, 04 Jul 2009 08:15:48 +0200
changeset 4654 2eaebe77d66b
parent 4474 19e2b7ff3482
permissions -rw-r--r--
Added tag ns-3.5 for changeset c975274c9707
     1 from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandlers
     2 
     3 def register_types(module):
     4     root_module = module.get_root()
     5     
     6     ## data-output-interface.h: ns3::DataOutputCallback [class]
     7     module.add_class('DataOutputCallback', allow_subclassing=True)
     8     ## data-calculator.h: ns3::DataCalculator [class]
     9     module.add_class('DataCalculator', parent=root_module['ns3::Object'])
    10     ## data-collector.h: ns3::DataCollector [class]
    11     module.add_class('DataCollector', parent=root_module['ns3::Object'])
    12     ## data-output-interface.h: ns3::DataOutputInterface [class]
    13     module.add_class('DataOutputInterface', parent=root_module['ns3::Object'])
    14     ## basic-data-calculators.h: ns3::MinMaxAvgTotalCalculator<unsigned int> [class]
    15     module.add_class('MinMaxAvgTotalCalculator', template_parameters=['unsigned int'], parent=root_module['ns3::DataCalculator'])
    16     ## omnet-data-output.h: ns3::OmnetDataOutput [class]
    17     module.add_class('OmnetDataOutput', parent=root_module['ns3::DataOutputInterface'])
    18     ## packet-data-calculators.h: ns3::PacketSizeMinMaxAvgTotalCalculator [class]
    19     module.add_class('PacketSizeMinMaxAvgTotalCalculator', parent=root_module['ns3::MinMaxAvgTotalCalculator< unsigned int >'])
    20     ## sqlite-data-output.h: ns3::SqliteDataOutput [class]
    21     module.add_class('SqliteDataOutput', parent=root_module['ns3::DataOutputInterface'])
    22     ## time-data-calculators.h: ns3::TimeMinMaxAvgTotalCalculator [class]
    23     module.add_class('TimeMinMaxAvgTotalCalculator', parent=root_module['ns3::DataCalculator'])
    24     ## basic-data-calculators.h: ns3::CounterCalculator<unsigned int> [class]
    25     module.add_class('CounterCalculator', template_parameters=['unsigned int'], parent=root_module['ns3::DataCalculator'])
    26     ## packet-data-calculators.h: ns3::PacketCounterCalculator [class]
    27     module.add_class('PacketCounterCalculator', parent=root_module['ns3::CounterCalculator< unsigned int >'])
    28     typehandlers.add_type_alias('std::list< ns3::Ptr< ns3::DataCalculator >, std::allocator< ns3::Ptr< ns3::DataCalculator > > >', 'ns3::DataCalculatorList')
    29     typehandlers.add_type_alias('std::list< std::pair< std::string, std::string >, std::allocator< std::pair< std::string, std::string > > >', 'ns3::MetadataList')
    30     
    31     ## Register a nested module for the namespace Config
    32     
    33     nested_module = module.add_cpp_namespace('Config')
    34     register_types_ns3_Config(nested_module)
    35     
    36     
    37     ## Register a nested module for the namespace TimeStepPrecision
    38     
    39     nested_module = module.add_cpp_namespace('TimeStepPrecision')
    40     register_types_ns3_TimeStepPrecision(nested_module)
    41     
    42     
    43     ## Register a nested module for the namespace addressUtils
    44     
    45     nested_module = module.add_cpp_namespace('addressUtils')
    46     register_types_ns3_addressUtils(nested_module)
    47     
    48     
    49     ## Register a nested module for the namespace internal
    50     
    51     nested_module = module.add_cpp_namespace('internal')
    52     register_types_ns3_internal(nested_module)
    53     
    54     
    55     ## Register a nested module for the namespace olsr
    56     
    57     nested_module = module.add_cpp_namespace('olsr')
    58     register_types_ns3_olsr(nested_module)
    59     
    60 
    61 def register_types_ns3_Config(module):
    62     root_module = module.get_root()
    63     
    64 
    65 def register_types_ns3_TimeStepPrecision(module):
    66     root_module = module.get_root()
    67     
    68 
    69 def register_types_ns3_addressUtils(module):
    70     root_module = module.get_root()
    71     
    72 
    73 def register_types_ns3_internal(module):
    74     root_module = module.get_root()
    75     
    76 
    77 def register_types_ns3_olsr(module):
    78     root_module = module.get_root()
    79     
    80 
    81 def register_methods(root_module):
    82     register_Ns3DataOutputCallback_methods(root_module, root_module['ns3::DataOutputCallback'])
    83     register_Ns3DataCalculator_methods(root_module, root_module['ns3::DataCalculator'])
    84     register_Ns3DataCollector_methods(root_module, root_module['ns3::DataCollector'])
    85     register_Ns3DataOutputInterface_methods(root_module, root_module['ns3::DataOutputInterface'])
    86     register_Ns3MinMaxAvgTotalCalculator__Unsigned_int_methods(root_module, root_module['ns3::MinMaxAvgTotalCalculator< unsigned int >'])
    87     register_Ns3OmnetDataOutput_methods(root_module, root_module['ns3::OmnetDataOutput'])
    88     register_Ns3PacketSizeMinMaxAvgTotalCalculator_methods(root_module, root_module['ns3::PacketSizeMinMaxAvgTotalCalculator'])
    89     register_Ns3SqliteDataOutput_methods(root_module, root_module['ns3::SqliteDataOutput'])
    90     register_Ns3TimeMinMaxAvgTotalCalculator_methods(root_module, root_module['ns3::TimeMinMaxAvgTotalCalculator'])
    91     register_Ns3CounterCalculator__Unsigned_int_methods(root_module, root_module['ns3::CounterCalculator< unsigned int >'])
    92     register_Ns3PacketCounterCalculator_methods(root_module, root_module['ns3::PacketCounterCalculator'])
    93     return
    94 
    95 def register_Ns3DataOutputCallback_methods(root_module, cls):
    96     ## data-output-interface.h: ns3::DataOutputCallback::DataOutputCallback(ns3::DataOutputCallback const & arg0) [copy constructor]
    97     cls.add_constructor([param('ns3::DataOutputCallback const &', 'arg0')])
    98     ## data-output-interface.h: ns3::DataOutputCallback::DataOutputCallback() [constructor]
    99     cls.add_constructor([])
   100     ## data-output-interface.h: void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, int val) [member function]
   101     cls.add_method('OutputSingleton', 
   102                    'void', 
   103                    [param('std::string', 'key'), param('std::string', 'variable'), param('int', 'val')], 
   104                    is_pure_virtual=True, is_virtual=True)
   105     ## data-output-interface.h: void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, uint32_t val) [member function]
   106     cls.add_method('OutputSingleton', 
   107                    'void', 
   108                    [param('std::string', 'key'), param('std::string', 'variable'), param('uint32_t', 'val')], 
   109                    is_pure_virtual=True, is_virtual=True)
   110     ## data-output-interface.h: void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, double val) [member function]
   111     cls.add_method('OutputSingleton', 
   112                    'void', 
   113                    [param('std::string', 'key'), param('std::string', 'variable'), param('double', 'val')], 
   114                    is_pure_virtual=True, is_virtual=True)
   115     ## data-output-interface.h: void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, std::string val) [member function]
   116     cls.add_method('OutputSingleton', 
   117                    'void', 
   118                    [param('std::string', 'key'), param('std::string', 'variable'), param('std::string', 'val')], 
   119                    is_pure_virtual=True, is_virtual=True)
   120     ## data-output-interface.h: void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, ns3::Time val) [member function]
   121     cls.add_method('OutputSingleton', 
   122                    'void', 
   123                    [param('std::string', 'key'), param('std::string', 'variable'), param('ns3::Time', 'val')], 
   124                    is_pure_virtual=True, is_virtual=True)
   125     return
   126 
   127 def register_Ns3DataCalculator_methods(root_module, cls):
   128     ## data-calculator.h: ns3::DataCalculator::DataCalculator(ns3::DataCalculator const & arg0) [copy constructor]
   129     cls.add_constructor([param('ns3::DataCalculator const &', 'arg0')])
   130     ## data-calculator.h: ns3::DataCalculator::DataCalculator() [constructor]
   131     cls.add_constructor([])
   132     ## data-calculator.h: bool ns3::DataCalculator::GetEnabled() const [member function]
   133     cls.add_method('GetEnabled', 
   134                    'bool', 
   135                    [], 
   136                    is_const=True)
   137     ## data-calculator.h: void ns3::DataCalculator::Enable() [member function]
   138     cls.add_method('Enable', 
   139                    'void', 
   140                    [])
   141     ## data-calculator.h: void ns3::DataCalculator::Disable() [member function]
   142     cls.add_method('Disable', 
   143                    'void', 
   144                    [])
   145     ## data-calculator.h: void ns3::DataCalculator::SetKey(std::string const key) [member function]
   146     cls.add_method('SetKey', 
   147                    'void', 
   148                    [param('std::string const', 'key')])
   149     ## data-calculator.h: std::string ns3::DataCalculator::GetKey() const [member function]
   150     cls.add_method('GetKey', 
   151                    'std::string', 
   152                    [], 
   153                    is_const=True)
   154     ## data-calculator.h: void ns3::DataCalculator::Start(ns3::Time const & startTime) [member function]
   155     cls.add_method('Start', 
   156                    'void', 
   157                    [param('ns3::Time const &', 'startTime')], 
   158                    is_virtual=True)
   159     ## data-calculator.h: void ns3::DataCalculator::Stop(ns3::Time const & stopTime) [member function]
   160     cls.add_method('Stop', 
   161                    'void', 
   162                    [param('ns3::Time const &', 'stopTime')], 
   163                    is_virtual=True)
   164     ## data-calculator.h: void ns3::DataCalculator::Output(ns3::DataOutputCallback & callback) const [member function]
   165     cls.add_method('Output', 
   166                    'void', 
   167                    [param('ns3::DataOutputCallback &', 'callback')], 
   168                    is_pure_virtual=True, is_const=True, is_virtual=True)
   169     ## data-calculator.h: void ns3::DataCalculator::DoDispose() [member function]
   170     cls.add_method('DoDispose', 
   171                    'void', 
   172                    [], 
   173                    visibility='protected', is_virtual=True)
   174     return
   175 
   176 def register_Ns3DataCollector_methods(root_module, cls):
   177     ## data-collector.h: ns3::DataCollector::DataCollector(ns3::DataCollector const & arg0) [copy constructor]
   178     cls.add_constructor([param('ns3::DataCollector const &', 'arg0')])
   179     ## data-collector.h: ns3::DataCollector::DataCollector() [constructor]
   180     cls.add_constructor([])
   181     ## data-collector.h: void ns3::DataCollector::DescribeRun(std::string experiment, std::string strategy, std::string input, std::string runID, std::string description="") [member function]
   182     cls.add_method('DescribeRun', 
   183                    'void', 
   184                    [param('std::string', 'experiment'), param('std::string', 'strategy'), param('std::string', 'input'), param('std::string', 'runID'), param('std::string', 'description', default_value='""')])
   185     ## data-collector.h: std::string ns3::DataCollector::GetExperimentLabel() const [member function]
   186     cls.add_method('GetExperimentLabel', 
   187                    'std::string', 
   188                    [], 
   189                    is_const=True)
   190     ## data-collector.h: std::string ns3::DataCollector::GetStrategyLabel() const [member function]
   191     cls.add_method('GetStrategyLabel', 
   192                    'std::string', 
   193                    [], 
   194                    is_const=True)
   195     ## data-collector.h: std::string ns3::DataCollector::GetInputLabel() const [member function]
   196     cls.add_method('GetInputLabel', 
   197                    'std::string', 
   198                    [], 
   199                    is_const=True)
   200     ## data-collector.h: std::string ns3::DataCollector::GetRunLabel() const [member function]
   201     cls.add_method('GetRunLabel', 
   202                    'std::string', 
   203                    [], 
   204                    is_const=True)
   205     ## data-collector.h: std::string ns3::DataCollector::GetDescription() const [member function]
   206     cls.add_method('GetDescription', 
   207                    'std::string', 
   208                    [], 
   209                    is_const=True)
   210     ## data-collector.h: void ns3::DataCollector::AddMetadata(std::string key, std::string value) [member function]
   211     cls.add_method('AddMetadata', 
   212                    'void', 
   213                    [param('std::string', 'key'), param('std::string', 'value')])
   214     ## data-collector.h: void ns3::DataCollector::AddMetadata(std::string key, double value) [member function]
   215     cls.add_method('AddMetadata', 
   216                    'void', 
   217                    [param('std::string', 'key'), param('double', 'value')])
   218     ## data-collector.h: void ns3::DataCollector::AddMetadata(std::string key, uint32_t value) [member function]
   219     cls.add_method('AddMetadata', 
   220                    'void', 
   221                    [param('std::string', 'key'), param('uint32_t', 'value')])
   222     ## data-collector.h: std::_List_iterator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > ns3::DataCollector::MetadataBegin() [member function]
   223     cls.add_method('MetadataBegin', 
   224                    'std::_List_iterator< std::pair< std::basic_string< char, std::char_traits< char >, std::allocator< char > >, std::basic_string< char, std::char_traits< char >, std::allocator< char > > > >', 
   225                    [])
   226     ## data-collector.h: std::_List_iterator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > ns3::DataCollector::MetadataEnd() [member function]
   227     cls.add_method('MetadataEnd', 
   228                    'std::_List_iterator< std::pair< std::basic_string< char, std::char_traits< char >, std::allocator< char > >, std::basic_string< char, std::char_traits< char >, std::allocator< char > > > >', 
   229                    [])
   230     ## data-collector.h: void ns3::DataCollector::AddDataCalculator(ns3::Ptr<ns3::DataCalculator> datac) [member function]
   231     cls.add_method('AddDataCalculator', 
   232                    'void', 
   233                    [param('ns3::Ptr< ns3::DataCalculator >', 'datac')])
   234     ## data-collector.h: std::_List_iterator<ns3::Ptr<ns3::DataCalculator> > ns3::DataCollector::DataCalculatorBegin() [member function]
   235     cls.add_method('DataCalculatorBegin', 
   236                    'std::_List_iterator< ns3::Ptr< ns3::DataCalculator > >', 
   237                    [])
   238     ## data-collector.h: std::_List_iterator<ns3::Ptr<ns3::DataCalculator> > ns3::DataCollector::DataCalculatorEnd() [member function]
   239     cls.add_method('DataCalculatorEnd', 
   240                    'std::_List_iterator< ns3::Ptr< ns3::DataCalculator > >', 
   241                    [])
   242     ## data-collector.h: void ns3::DataCollector::DoDispose() [member function]
   243     cls.add_method('DoDispose', 
   244                    'void', 
   245                    [], 
   246                    visibility='protected', is_virtual=True)
   247     return
   248 
   249 def register_Ns3DataOutputInterface_methods(root_module, cls):
   250     ## data-output-interface.h: ns3::DataOutputInterface::DataOutputInterface(ns3::DataOutputInterface const & arg0) [copy constructor]
   251     cls.add_constructor([param('ns3::DataOutputInterface const &', 'arg0')])
   252     ## data-output-interface.h: ns3::DataOutputInterface::DataOutputInterface() [constructor]
   253     cls.add_constructor([])
   254     ## data-output-interface.h: void ns3::DataOutputInterface::Output(ns3::DataCollector & dc) [member function]
   255     cls.add_method('Output', 
   256                    'void', 
   257                    [param('ns3::DataCollector &', 'dc')], 
   258                    is_pure_virtual=True, is_virtual=True)
   259     ## data-output-interface.h: void ns3::DataOutputInterface::SetFilePrefix(std::string const prefix) [member function]
   260     cls.add_method('SetFilePrefix', 
   261                    'void', 
   262                    [param('std::string const', 'prefix')])
   263     ## data-output-interface.h: std::string ns3::DataOutputInterface::GetFilePrefix() const [member function]
   264     cls.add_method('GetFilePrefix', 
   265                    'std::string', 
   266                    [], 
   267                    is_const=True)
   268     ## data-output-interface.h: void ns3::DataOutputInterface::DoDispose() [member function]
   269     cls.add_method('DoDispose', 
   270                    'void', 
   271                    [], 
   272                    visibility='protected', is_virtual=True)
   273     return
   274 
   275 def register_Ns3MinMaxAvgTotalCalculator__Unsigned_int_methods(root_module, cls):
   276     ## basic-data-calculators.h: ns3::MinMaxAvgTotalCalculator<unsigned int>::MinMaxAvgTotalCalculator(ns3::MinMaxAvgTotalCalculator<unsigned int> const & arg0) [copy constructor]
   277     cls.add_constructor([param('ns3::MinMaxAvgTotalCalculator< unsigned int > const &', 'arg0')])
   278     ## basic-data-calculators.h: ns3::MinMaxAvgTotalCalculator<unsigned int>::MinMaxAvgTotalCalculator() [constructor]
   279     cls.add_constructor([])
   280     ## basic-data-calculators.h: void ns3::MinMaxAvgTotalCalculator<unsigned int>::Update(unsigned int const i) [member function]
   281     cls.add_method('Update', 
   282                    'void', 
   283                    [param('unsigned int const', 'i')])
   284     ## basic-data-calculators.h: void ns3::MinMaxAvgTotalCalculator<unsigned int>::Output(ns3::DataOutputCallback & callback) const [member function]
   285     cls.add_method('Output', 
   286                    'void', 
   287                    [param('ns3::DataOutputCallback &', 'callback')], 
   288                    is_const=True, is_virtual=True)
   289     ## basic-data-calculators.h: void ns3::MinMaxAvgTotalCalculator<unsigned int>::DoDispose() [member function]
   290     cls.add_method('DoDispose', 
   291                    'void', 
   292                    [], 
   293                    visibility='protected', is_virtual=True)
   294     return
   295 
   296 def register_Ns3OmnetDataOutput_methods(root_module, cls):
   297     ## omnet-data-output.h: ns3::OmnetDataOutput::OmnetDataOutput(ns3::OmnetDataOutput const & arg0) [copy constructor]
   298     cls.add_constructor([param('ns3::OmnetDataOutput const &', 'arg0')])
   299     ## omnet-data-output.h: ns3::OmnetDataOutput::OmnetDataOutput() [constructor]
   300     cls.add_constructor([])
   301     ## omnet-data-output.h: void ns3::OmnetDataOutput::Output(ns3::DataCollector & dc) [member function]
   302     cls.add_method('Output', 
   303                    'void', 
   304                    [param('ns3::DataCollector &', 'dc')], 
   305                    is_virtual=True)
   306     ## omnet-data-output.h: void ns3::OmnetDataOutput::DoDispose() [member function]
   307     cls.add_method('DoDispose', 
   308                    'void', 
   309                    [], 
   310                    visibility='protected', is_virtual=True)
   311     return
   312 
   313 def register_Ns3PacketSizeMinMaxAvgTotalCalculator_methods(root_module, cls):
   314     ## packet-data-calculators.h: ns3::PacketSizeMinMaxAvgTotalCalculator::PacketSizeMinMaxAvgTotalCalculator(ns3::PacketSizeMinMaxAvgTotalCalculator const & arg0) [copy constructor]
   315     cls.add_constructor([param('ns3::PacketSizeMinMaxAvgTotalCalculator const &', 'arg0')])
   316     ## packet-data-calculators.h: ns3::PacketSizeMinMaxAvgTotalCalculator::PacketSizeMinMaxAvgTotalCalculator() [constructor]
   317     cls.add_constructor([])
   318     ## packet-data-calculators.h: void ns3::PacketSizeMinMaxAvgTotalCalculator::PacketUpdate(std::string path, ns3::Ptr<ns3::Packet const> packet) [member function]
   319     cls.add_method('PacketUpdate', 
   320                    'void', 
   321                    [param('std::string', 'path'), param('ns3::Ptr< ns3::Packet const >', 'packet')])
   322     ## packet-data-calculators.h: void ns3::PacketSizeMinMaxAvgTotalCalculator::FrameUpdate(std::string path, ns3::Ptr<ns3::Packet const> packet, ns3::Mac48Address realto) [member function]
   323     cls.add_method('FrameUpdate', 
   324                    'void', 
   325                    [param('std::string', 'path'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Mac48Address', 'realto')])
   326     ## packet-data-calculators.h: void ns3::PacketSizeMinMaxAvgTotalCalculator::DoDispose() [member function]
   327     cls.add_method('DoDispose', 
   328                    'void', 
   329                    [], 
   330                    visibility='protected', is_virtual=True)
   331     return
   332 
   333 def register_Ns3SqliteDataOutput_methods(root_module, cls):
   334     ## sqlite-data-output.h: ns3::SqliteDataOutput::SqliteDataOutput(ns3::SqliteDataOutput const & arg0) [copy constructor]
   335     cls.add_constructor([param('ns3::SqliteDataOutput const &', 'arg0')])
   336     ## sqlite-data-output.h: ns3::SqliteDataOutput::SqliteDataOutput() [constructor]
   337     cls.add_constructor([])
   338     ## sqlite-data-output.h: void ns3::SqliteDataOutput::Output(ns3::DataCollector & dc) [member function]
   339     cls.add_method('Output', 
   340                    'void', 
   341                    [param('ns3::DataCollector &', 'dc')], 
   342                    is_virtual=True)
   343     ## sqlite-data-output.h: void ns3::SqliteDataOutput::DoDispose() [member function]
   344     cls.add_method('DoDispose', 
   345                    'void', 
   346                    [], 
   347                    visibility='protected', is_virtual=True)
   348     return
   349 
   350 def register_Ns3TimeMinMaxAvgTotalCalculator_methods(root_module, cls):
   351     ## time-data-calculators.h: ns3::TimeMinMaxAvgTotalCalculator::TimeMinMaxAvgTotalCalculator(ns3::TimeMinMaxAvgTotalCalculator const & arg0) [copy constructor]
   352     cls.add_constructor([param('ns3::TimeMinMaxAvgTotalCalculator const &', 'arg0')])
   353     ## time-data-calculators.h: ns3::TimeMinMaxAvgTotalCalculator::TimeMinMaxAvgTotalCalculator() [constructor]
   354     cls.add_constructor([])
   355     ## time-data-calculators.h: void ns3::TimeMinMaxAvgTotalCalculator::Update(ns3::Time const i) [member function]
   356     cls.add_method('Update', 
   357                    'void', 
   358                    [param('ns3::Time const', 'i')])
   359     ## time-data-calculators.h: void ns3::TimeMinMaxAvgTotalCalculator::Output(ns3::DataOutputCallback & callback) const [member function]
   360     cls.add_method('Output', 
   361                    'void', 
   362                    [param('ns3::DataOutputCallback &', 'callback')], 
   363                    is_const=True, is_virtual=True)
   364     ## time-data-calculators.h: void ns3::TimeMinMaxAvgTotalCalculator::DoDispose() [member function]
   365     cls.add_method('DoDispose', 
   366                    'void', 
   367                    [], 
   368                    visibility='protected', is_virtual=True)
   369     return
   370 
   371 def register_Ns3CounterCalculator__Unsigned_int_methods(root_module, cls):
   372     ## basic-data-calculators.h: ns3::CounterCalculator<unsigned int>::CounterCalculator(ns3::CounterCalculator<unsigned int> const & arg0) [copy constructor]
   373     cls.add_constructor([param('ns3::CounterCalculator< unsigned int > const &', 'arg0')])
   374     ## basic-data-calculators.h: ns3::CounterCalculator<unsigned int>::CounterCalculator() [constructor]
   375     cls.add_constructor([])
   376     ## basic-data-calculators.h: void ns3::CounterCalculator<unsigned int>::Update() [member function]
   377     cls.add_method('Update', 
   378                    'void', 
   379                    [])
   380     ## basic-data-calculators.h: void ns3::CounterCalculator<unsigned int>::Update(unsigned int const i) [member function]
   381     cls.add_method('Update', 
   382                    'void', 
   383                    [param('unsigned int const', 'i')])
   384     ## basic-data-calculators.h: unsigned int ns3::CounterCalculator<unsigned int>::GetCount() const [member function]
   385     cls.add_method('GetCount', 
   386                    'unsigned int', 
   387                    [], 
   388                    is_const=True)
   389     ## basic-data-calculators.h: void ns3::CounterCalculator<unsigned int>::Output(ns3::DataOutputCallback & callback) const [member function]
   390     cls.add_method('Output', 
   391                    'void', 
   392                    [param('ns3::DataOutputCallback &', 'callback')], 
   393                    is_const=True, is_virtual=True)
   394     ## basic-data-calculators.h: void ns3::CounterCalculator<unsigned int>::DoDispose() [member function]
   395     cls.add_method('DoDispose', 
   396                    'void', 
   397                    [], 
   398                    visibility='protected', is_virtual=True)
   399     return
   400 
   401 def register_Ns3PacketCounterCalculator_methods(root_module, cls):
   402     ## packet-data-calculators.h: ns3::PacketCounterCalculator::PacketCounterCalculator(ns3::PacketCounterCalculator const & arg0) [copy constructor]
   403     cls.add_constructor([param('ns3::PacketCounterCalculator const &', 'arg0')])
   404     ## packet-data-calculators.h: ns3::PacketCounterCalculator::PacketCounterCalculator() [constructor]
   405     cls.add_constructor([])
   406     ## packet-data-calculators.h: void ns3::PacketCounterCalculator::PacketUpdate(std::string path, ns3::Ptr<ns3::Packet const> packet) [member function]
   407     cls.add_method('PacketUpdate', 
   408                    'void', 
   409                    [param('std::string', 'path'), param('ns3::Ptr< ns3::Packet const >', 'packet')])
   410     ## packet-data-calculators.h: void ns3::PacketCounterCalculator::FrameUpdate(std::string path, ns3::Ptr<ns3::Packet const> packet, ns3::Mac48Address realto) [member function]
   411     cls.add_method('FrameUpdate', 
   412                    'void', 
   413                    [param('std::string', 'path'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Mac48Address', 'realto')])
   414     ## packet-data-calculators.h: void ns3::PacketCounterCalculator::DoDispose() [member function]
   415     cls.add_method('DoDispose', 
   416                    'void', 
   417                    [], 
   418                    visibility='protected', is_virtual=True)
   419     return
   420 
   421 def register_functions(root_module):
   422     module = root_module
   423     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
   424     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
   425     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
   426     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
   427     register_functions_ns3_olsr(module.get_submodule('olsr'), root_module)
   428     return
   429 
   430 def register_functions_ns3_Config(module, root_module):
   431     return
   432 
   433 def register_functions_ns3_TimeStepPrecision(module, root_module):
   434     return
   435 
   436 def register_functions_ns3_addressUtils(module, root_module):
   437     return
   438 
   439 def register_functions_ns3_internal(module, root_module):
   440     return
   441 
   442 def register_functions_ns3_olsr(module, root_module):
   443     return
   444