from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandlers

def register_types(module):

    root_module = module.get_root()

    ## data-output-interface.h: ns3::DataOutputCallback [class]

    module.add_class('DataOutputCallback', allow_subclassing=True)

    ## data-calculator.h: ns3::StatisticalSummary [class]

    module.add_class('StatisticalSummary', allow_subclassing=True)

    ## data-calculator.h: ns3::DataCalculator [class]

    module.add_class('DataCalculator', parent=root_module['ns3::Object'])

    ## data-collector.h: ns3::DataCollector [class]

    module.add_class('DataCollector', parent=root_module['ns3::Object'])

    ## data-output-interface.h: ns3::DataOutputInterface [class]

    module.add_class('DataOutputInterface', parent=root_module['ns3::Object'])

    ## basic-data-calculators.h: ns3::MinMaxAvgTotalCalculator<unsigned int> [class]

    module.add_class('MinMaxAvgTotalCalculator', template_parameters=['unsigned int'], parent=[root_module['ns3::DataCalculator'], root_module['ns3::StatisticalSummary']])

    ## omnet-data-output.h: ns3::OmnetDataOutput [class]

    module.add_class('OmnetDataOutput', parent=root_module['ns3::DataOutputInterface'])

    ## packet-data-calculators.h: ns3::PacketSizeMinMaxAvgTotalCalculator [class]

    module.add_class('PacketSizeMinMaxAvgTotalCalculator', parent=root_module['ns3::MinMaxAvgTotalCalculator< unsigned int >'])

    ## time-data-calculators.h: ns3::TimeMinMaxAvgTotalCalculator [class]

    module.add_class('TimeMinMaxAvgTotalCalculator', parent=root_module['ns3::DataCalculator'])

    ## basic-data-calculators.h: ns3::CounterCalculator<unsigned int> [class]

    module.add_class('CounterCalculator', template_parameters=['unsigned int'], parent=root_module['ns3::DataCalculator'])

    ## packet-data-calculators.h: ns3::PacketCounterCalculator [class]

    module.add_class('PacketCounterCalculator', parent=root_module['ns3::CounterCalculator< unsigned int >'])

    typehandlers.add_type_alias('std::list< ns3::Ptr< ns3::DataCalculator >, std::allocator< ns3::Ptr< ns3::DataCalculator > > >', 'ns3::DataCalculatorList')

    typehandlers.add_type_alias('std::list< ns3::Ptr< ns3::DataCalculator >, std::allocator< ns3::Ptr< ns3::DataCalculator > > >*', 'ns3::DataCalculatorList*')

    typehandlers.add_type_alias('std::list< ns3::Ptr< ns3::DataCalculator >, std::allocator< ns3::Ptr< ns3::DataCalculator > > >&', 'ns3::DataCalculatorList&')

    ## Register a nested module for the namespace Config

    nested_module = module.add_cpp_namespace('Config')

    register_types_ns3_Config(nested_module)

    ## Register a nested module for the namespace FatalImpl

    nested_module = module.add_cpp_namespace('FatalImpl')

    register_types_ns3_FatalImpl(nested_module)

    ## Register a nested module for the namespace addressUtils

    nested_module = module.add_cpp_namespace('addressUtils')

    register_types_ns3_addressUtils(nested_module)

    ## Register a nested module for the namespace aodv

    nested_module = module.add_cpp_namespace('aodv')

    register_types_ns3_aodv(nested_module)

    ## Register a nested module for the namespace dot11s

    nested_module = module.add_cpp_namespace('dot11s')

    register_types_ns3_dot11s(nested_module)

    ## Register a nested module for the namespace flame

    nested_module = module.add_cpp_namespace('flame')

    register_types_ns3_flame(nested_module)

    ## Register a nested module for the namespace internal

    nested_module = module.add_cpp_namespace('internal')

    register_types_ns3_internal(nested_module)

    ## Register a nested module for the namespace olsr

    nested_module = module.add_cpp_namespace('olsr')

    register_types_ns3_olsr(nested_module)

def register_types_ns3_Config(module):

    root_module = module.get_root()

def register_types_ns3_FatalImpl(module):

    root_module = module.get_root()

def register_types_ns3_addressUtils(module):

    root_module = module.get_root()

def register_types_ns3_aodv(module):

    root_module = module.get_root()

def register_types_ns3_dot11s(module):

    root_module = module.get_root()

def register_types_ns3_flame(module):

    root_module = module.get_root()

def register_types_ns3_internal(module):

    root_module = module.get_root()

def register_types_ns3_olsr(module):

    root_module = module.get_root()

def register_methods(root_module):

    register_Ns3DataOutputCallback_methods(root_module, root_module['ns3::DataOutputCallback'])

    register_Ns3StatisticalSummary_methods(root_module, root_module['ns3::StatisticalSummary'])

    register_Ns3DataCalculator_methods(root_module, root_module['ns3::DataCalculator'])

    register_Ns3DataCollector_methods(root_module, root_module['ns3::DataCollector'])

    register_Ns3DataOutputInterface_methods(root_module, root_module['ns3::DataOutputInterface'])

    register_Ns3MinMaxAvgTotalCalculator__Unsigned_int_methods(root_module, root_module['ns3::MinMaxAvgTotalCalculator< unsigned int >'])

    register_Ns3OmnetDataOutput_methods(root_module, root_module['ns3::OmnetDataOutput'])

    register_Ns3PacketSizeMinMaxAvgTotalCalculator_methods(root_module, root_module['ns3::PacketSizeMinMaxAvgTotalCalculator'])

    register_Ns3TimeMinMaxAvgTotalCalculator_methods(root_module, root_module['ns3::TimeMinMaxAvgTotalCalculator'])

    register_Ns3CounterCalculator__Unsigned_int_methods(root_module, root_module['ns3::CounterCalculator< unsigned int >'])

    register_Ns3PacketCounterCalculator_methods(root_module, root_module['ns3::PacketCounterCalculator'])

    return

def register_Ns3DataOutputCallback_methods(root_module, cls):

    ## data-output-interface.h: ns3::DataOutputCallback::DataOutputCallback() [constructor]

    cls.add_constructor([])

    ## data-output-interface.h: ns3::DataOutputCallback::DataOutputCallback(ns3::DataOutputCallback const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::DataOutputCallback const &', 'arg0')])

    ## data-output-interface.h: void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, int val) [member function]

    cls.add_method('OutputSingleton', 

                   'void', 

                   [param('std::string', 'key'), param('std::string', 'variable'), param('int', 'val')], 

                   is_pure_virtual=True, is_virtual=True)

    ## data-output-interface.h: void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, uint32_t val) [member function]

    cls.add_method('OutputSingleton', 

                   'void', 

                   [param('std::string', 'key'), param('std::string', 'variable'), param('uint32_t', 'val')], 

                   is_pure_virtual=True, is_virtual=True)

    ## data-output-interface.h: void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, double val) [member function]

    cls.add_method('OutputSingleton', 

                   'void', 

                   [param('std::string', 'key'), param('std::string', 'variable'), param('double', 'val')], 

                   is_pure_virtual=True, is_virtual=True)

    ## data-output-interface.h: void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, std::string val) [member function]

    cls.add_method('OutputSingleton', 

                   'void', 

                   [param('std::string', 'key'), param('std::string', 'variable'), param('std::string', 'val')], 

                   is_pure_virtual=True, is_virtual=True)

    ## data-output-interface.h: void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, ns3::Time val) [member function]

    cls.add_method('OutputSingleton', 

                   'void', 

                   [param('std::string', 'key'), param('std::string', 'variable'), param('ns3::Time', 'val')], 

                   is_pure_virtual=True, is_virtual=True)

    ## data-output-interface.h: void ns3::DataOutputCallback::OutputStatistic(std::string key, std::string variable, ns3::StatisticalSummary const * statSum) [member function]

    cls.add_method('OutputStatistic', 

                   'void', 

                   [param('std::string', 'key'), param('std::string', 'variable'), param('ns3::StatisticalSummary const *', 'statSum')], 

                   is_pure_virtual=True, is_virtual=True)

    return

def register_Ns3StatisticalSummary_methods(root_module, cls):

    ## data-calculator.h: ns3::StatisticalSummary::StatisticalSummary() [constructor]

    cls.add_constructor([])

    ## data-calculator.h: ns3::StatisticalSummary::StatisticalSummary(ns3::StatisticalSummary const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::StatisticalSummary const &', 'arg0')])

    ## data-calculator.h: long int ns3::StatisticalSummary::getCount() const [member function]

    cls.add_method('getCount', 

                   'long int', 

                   [], 

                   is_pure_virtual=True, is_const=True, is_virtual=True)

    ## data-calculator.h: double ns3::StatisticalSummary::getMax() const [member function]

    cls.add_method('getMax', 

                   'double', 

                   [], 

                   is_pure_virtual=True, is_const=True, is_virtual=True)

    ## data-calculator.h: double ns3::StatisticalSummary::getMean() const [member function]

    cls.add_method('getMean', 

                   'double', 

                   [], 

                   is_pure_virtual=True, is_const=True, is_virtual=True)

    ## data-calculator.h: double ns3::StatisticalSummary::getMin() const [member function]

    cls.add_method('getMin', 

                   'double', 

                   [], 

                   is_pure_virtual=True, is_const=True, is_virtual=True)

    ## data-calculator.h: double ns3::StatisticalSummary::getSqrSum() const [member function]

    cls.add_method('getSqrSum', 

                   'double', 

                   [], 

                   is_pure_virtual=True, is_const=True, is_virtual=True)

    ## data-calculator.h: double ns3::StatisticalSummary::getStddev() const [member function]

    cls.add_method('getStddev', 

                   'double', 

                   [], 

                   is_pure_virtual=True, is_const=True, is_virtual=True)

    ## data-calculator.h: double ns3::StatisticalSummary::getSum() const [member function]

    cls.add_method('getSum', 

                   'double', 

                   [], 

                   is_pure_virtual=True, is_const=True, is_virtual=True)

    ## data-calculator.h: double ns3::StatisticalSummary::getVariance() const [member function]

    cls.add_method('getVariance', 

                   'double', 

                   [], 

                   is_pure_virtual=True, is_const=True, is_virtual=True)

    return

def register_Ns3DataCalculator_methods(root_module, cls):

    ## data-calculator.h: ns3::DataCalculator::DataCalculator(ns3::DataCalculator const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::DataCalculator const &', 'arg0')])

    ## data-calculator.h: ns3::DataCalculator::DataCalculator() [constructor]

    cls.add_constructor([])

    ## data-calculator.h: void ns3::DataCalculator::Disable() [member function]

    cls.add_method('Disable', 

                   'void', 

                   [])

    ## data-calculator.h: void ns3::DataCalculator::Enable() [member function]

    cls.add_method('Enable', 

                   'void', 

                   [])

    ## data-calculator.h: std::string ns3::DataCalculator::GetContext() const [member function]

    cls.add_method('GetContext', 

                   'std::string', 

                   [], 

                   is_const=True)

    ## data-calculator.h: bool ns3::DataCalculator::GetEnabled() const [member function]

    cls.add_method('GetEnabled', 

                   'bool', 

                   [], 

                   is_const=True)

    ## data-calculator.h: std::string ns3::DataCalculator::GetKey() const [member function]

    cls.add_method('GetKey', 

                   'std::string', 

                   [], 

                   is_const=True)

    ## data-calculator.h: void ns3::DataCalculator::Output(ns3::DataOutputCallback & callback) const [member function]

    cls.add_method('Output', 

                   'void', 

                   [param('ns3::DataOutputCallback &', 'callback')], 

                   is_pure_virtual=True, is_const=True, is_virtual=True)

    ## data-calculator.h: void ns3::DataCalculator::SetContext(std::string const context) [member function]

    cls.add_method('SetContext', 

                   'void', 

                   [param('std::string const', 'context')])

    ## data-calculator.h: void ns3::DataCalculator::SetKey(std::string const key) [member function]

    cls.add_method('SetKey', 

                   'void', 

                   [param('std::string const', 'key')])

    ## data-calculator.h: void ns3::DataCalculator::Start(ns3::Time const & startTime) [member function]

    cls.add_method('Start', 

                   'void', 

                   [param('ns3::Time const &', 'startTime')], 

                   is_virtual=True)

    ## data-calculator.h: void ns3::DataCalculator::Stop(ns3::Time const & stopTime) [member function]

    cls.add_method('Stop', 

                   'void', 

                   [param('ns3::Time const &', 'stopTime')], 

                   is_virtual=True)

    ## data-calculator.h: void ns3::DataCalculator::DoDispose() [member function]

    cls.add_method('DoDispose', 

                   'void', 

                   [], 

                   visibility='protected', is_virtual=True)

    return

def register_Ns3DataCollector_methods(root_module, cls):

    ## data-collector.h: ns3::DataCollector::DataCollector(ns3::DataCollector const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::DataCollector const &', 'arg0')])

    ## data-collector.h: ns3::DataCollector::DataCollector() [constructor]

    cls.add_constructor([])

    ## data-collector.h: void ns3::DataCollector::AddDataCalculator(ns3::Ptr<ns3::DataCalculator> datac) [member function]

    cls.add_method('AddDataCalculator', 

                   'void', 

                   [param('ns3::Ptr< ns3::DataCalculator >', 'datac')])

    ## data-collector.h: void ns3::DataCollector::AddMetadata(std::string key, std::string value) [member function]

    cls.add_method('AddMetadata', 

                   'void', 

                   [param('std::string', 'key'), param('std::string', 'value')])

    ## data-collector.h: void ns3::DataCollector::AddMetadata(std::string key, double value) [member function]

    cls.add_method('AddMetadata', 

                   'void', 

                   [param('std::string', 'key'), param('double', 'value')])

    ## data-collector.h: void ns3::DataCollector::AddMetadata(std::string key, uint32_t value) [member function]

    cls.add_method('AddMetadata', 

                   'void', 

                   [param('std::string', 'key'), param('uint32_t', 'value')])

    ## data-collector.h: std::_List_iterator<ns3::Ptr<ns3::DataCalculator> > ns3::DataCollector::DataCalculatorBegin() [member function]

    cls.add_method('DataCalculatorBegin', 

                   'std::_List_iterator< ns3::Ptr< ns3::DataCalculator > >', 

                   [])

    ## data-collector.h: std::_List_iterator<ns3::Ptr<ns3::DataCalculator> > ns3::DataCollector::DataCalculatorEnd() [member function]

    cls.add_method('DataCalculatorEnd', 

                   'std::_List_iterator< ns3::Ptr< ns3::DataCalculator > >', 

                   [])

    ## data-collector.h: void ns3::DataCollector::DescribeRun(std::string experiment, std::string strategy, std::string input, std::string runID, std::string description="") [member function]

    cls.add_method('DescribeRun', 

                   'void', 

                   [param('std::string', 'experiment'), param('std::string', 'strategy'), param('std::string', 'input'), param('std::string', 'runID'), param('std::string', 'description', default_value='""')])

    ## data-collector.h: std::string ns3::DataCollector::GetDescription() const [member function]

    cls.add_method('GetDescription', 

                   'std::string', 

                   [], 

                   is_const=True)

    ## data-collector.h: std::string ns3::DataCollector::GetExperimentLabel() const [member function]

    cls.add_method('GetExperimentLabel', 

                   'std::string', 

                   [], 

                   is_const=True)

    ## data-collector.h: std::string ns3::DataCollector::GetInputLabel() const [member function]

    cls.add_method('GetInputLabel', 

                   'std::string', 

                   [], 

                   is_const=True)

    ## data-collector.h: std::string ns3::DataCollector::GetRunLabel() const [member function]

    cls.add_method('GetRunLabel', 

                   'std::string', 

                   [], 

                   is_const=True)

    ## data-collector.h: std::string ns3::DataCollector::GetStrategyLabel() const [member function]

    cls.add_method('GetStrategyLabel', 

                   'std::string', 

                   [], 

                   is_const=True)

    ## 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]

    cls.add_method('MetadataBegin', 

                   '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 > > > >', 

                   [])

    ## 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]

    cls.add_method('MetadataEnd', 

                   '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 > > > >', 

                   [])

    ## data-collector.h: void ns3::DataCollector::DoDispose() [member function]

    cls.add_method('DoDispose', 

                   'void', 

                   [], 

                   visibility='protected', is_virtual=True)

    return

def register_Ns3DataOutputInterface_methods(root_module, cls):

    ## data-output-interface.h: ns3::DataOutputInterface::DataOutputInterface(ns3::DataOutputInterface const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::DataOutputInterface const &', 'arg0')])

    ## data-output-interface.h: ns3::DataOutputInterface::DataOutputInterface() [constructor]

    cls.add_constructor([])

    ## data-output-interface.h: std::string ns3::DataOutputInterface::GetFilePrefix() const [member function]

    cls.add_method('GetFilePrefix', 

                   'std::string', 

                   [], 

                   is_const=True)

    ## data-output-interface.h: void ns3::DataOutputInterface::Output(ns3::DataCollector & dc) [member function]

    cls.add_method('Output', 

                   'void', 

                   [param('ns3::DataCollector &', 'dc')], 

                   is_pure_virtual=True, is_virtual=True)

    ## data-output-interface.h: void ns3::DataOutputInterface::SetFilePrefix(std::string const prefix) [member function]

    cls.add_method('SetFilePrefix', 

                   'void', 

                   [param('std::string const', 'prefix')])

    ## data-output-interface.h: void ns3::DataOutputInterface::DoDispose() [member function]

    cls.add_method('DoDispose', 

                   'void', 

                   [], 

                   visibility='protected', is_virtual=True)

    return

def register_Ns3MinMaxAvgTotalCalculator__Unsigned_int_methods(root_module, cls):

    ## basic-data-calculators.h: ns3::MinMaxAvgTotalCalculator<unsigned int>::MinMaxAvgTotalCalculator(ns3::MinMaxAvgTotalCalculator<unsigned int> const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::MinMaxAvgTotalCalculator< unsigned int > const &', 'arg0')])

    ## basic-data-calculators.h: ns3::MinMaxAvgTotalCalculator<unsigned int>::MinMaxAvgTotalCalculator() [constructor]

    cls.add_constructor([])

    ## basic-data-calculators.h: void ns3::MinMaxAvgTotalCalculator<unsigned int>::Output(ns3::DataOutputCallback & callback) const [member function]

    cls.add_method('Output', 

                   'void', 

                   [param('ns3::DataOutputCallback &', 'callback')], 

                   is_const=True, is_virtual=True)

    ## basic-data-calculators.h: void ns3::MinMaxAvgTotalCalculator<unsigned int>::Update(unsigned int const i) [member function]

    cls.add_method('Update', 

                   'void', 

                   [param('unsigned int const', 'i')])

    ## basic-data-calculators.h: long int ns3::MinMaxAvgTotalCalculator<unsigned int>::getCount() const [member function]

    cls.add_method('getCount', 

                   'long int', 

                   [], 

                   is_const=True, is_virtual=True)

    ## basic-data-calculators.h: double ns3::MinMaxAvgTotalCalculator<unsigned int>::getMax() const [member function]

    cls.add_method('getMax', 

                   'double', 

                   [], 

                   is_const=True, is_virtual=True)

    ## basic-data-calculators.h: double ns3::MinMaxAvgTotalCalculator<unsigned int>::getMean() const [member function]

    cls.add_method('getMean', 

                   'double', 

                   [], 

                   is_const=True, is_virtual=True)

    ## basic-data-calculators.h: double ns3::MinMaxAvgTotalCalculator<unsigned int>::getMin() const [member function]

    cls.add_method('getMin', 

                   'double', 

                   [], 

                   is_const=True, is_virtual=True)

    ## basic-data-calculators.h: double ns3::MinMaxAvgTotalCalculator<unsigned int>::getSqrSum() const [member function]

    cls.add_method('getSqrSum', 

                   'double', 

                   [], 

                   is_const=True, is_virtual=True)

    ## basic-data-calculators.h: double ns3::MinMaxAvgTotalCalculator<unsigned int>::getStddev() const [member function]

    cls.add_method('getStddev', 

                   'double', 

                   [], 

                   is_const=True, is_virtual=True)

    ## basic-data-calculators.h: double ns3::MinMaxAvgTotalCalculator<unsigned int>::getSum() const [member function]

    cls.add_method('getSum', 

                   'double', 

                   [], 

                   is_const=True, is_virtual=True)

    ## basic-data-calculators.h: double ns3::MinMaxAvgTotalCalculator<unsigned int>::getVariance() const [member function]

    cls.add_method('getVariance', 

                   'double', 

                   [], 

                   is_const=True, is_virtual=True)

    ## basic-data-calculators.h: void ns3::MinMaxAvgTotalCalculator<unsigned int>::DoDispose() [member function]

    cls.add_method('DoDispose', 

                   'void', 

                   [], 

                   visibility='protected', is_virtual=True)

    return

def register_Ns3OmnetDataOutput_methods(root_module, cls):

    ## omnet-data-output.h: ns3::OmnetDataOutput::OmnetDataOutput(ns3::OmnetDataOutput const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::OmnetDataOutput const &', 'arg0')])

    ## omnet-data-output.h: ns3::OmnetDataOutput::OmnetDataOutput() [constructor]

    cls.add_constructor([])

    ## omnet-data-output.h: void ns3::OmnetDataOutput::Output(ns3::DataCollector & dc) [member function]

    cls.add_method('Output', 

                   'void', 

                   [param('ns3::DataCollector &', 'dc')], 

                   is_virtual=True)

    ## omnet-data-output.h: void ns3::OmnetDataOutput::DoDispose() [member function]

    cls.add_method('DoDispose', 

                   'void', 

                   [], 

                   visibility='protected', is_virtual=True)

    return

def register_Ns3PacketSizeMinMaxAvgTotalCalculator_methods(root_module, cls):

    ## packet-data-calculators.h: ns3::PacketSizeMinMaxAvgTotalCalculator::PacketSizeMinMaxAvgTotalCalculator(ns3::PacketSizeMinMaxAvgTotalCalculator const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::PacketSizeMinMaxAvgTotalCalculator const &', 'arg0')])

    ## packet-data-calculators.h: ns3::PacketSizeMinMaxAvgTotalCalculator::PacketSizeMinMaxAvgTotalCalculator() [constructor]

    cls.add_constructor([])

    ## packet-data-calculators.h: void ns3::PacketSizeMinMaxAvgTotalCalculator::FrameUpdate(std::string path, ns3::Ptr<ns3::Packet const> packet, ns3::Mac48Address realto) [member function]

    cls.add_method('FrameUpdate', 

                   'void', 

                   [param('std::string', 'path'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Mac48Address', 'realto')])

    ## packet-data-calculators.h: void ns3::PacketSizeMinMaxAvgTotalCalculator::PacketUpdate(std::string path, ns3::Ptr<ns3::Packet const> packet) [member function]

    cls.add_method('PacketUpdate', 

                   'void', 

                   [param('std::string', 'path'), param('ns3::Ptr< ns3::Packet const >', 'packet')])

    ## packet-data-calculators.h: void ns3::PacketSizeMinMaxAvgTotalCalculator::DoDispose() [member function]

    cls.add_method('DoDispose', 

                   'void', 

                   [], 

                   visibility='protected', is_virtual=True)

    return

def register_Ns3TimeMinMaxAvgTotalCalculator_methods(root_module, cls):

    ## time-data-calculators.h: ns3::TimeMinMaxAvgTotalCalculator::TimeMinMaxAvgTotalCalculator(ns3::TimeMinMaxAvgTotalCalculator const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::TimeMinMaxAvgTotalCalculator const &', 'arg0')])

    ## time-data-calculators.h: ns3::TimeMinMaxAvgTotalCalculator::TimeMinMaxAvgTotalCalculator() [constructor]

    cls.add_constructor([])

    ## time-data-calculators.h: void ns3::TimeMinMaxAvgTotalCalculator::Output(ns3::DataOutputCallback & callback) const [member function]

    cls.add_method('Output', 

                   'void', 

                   [param('ns3::DataOutputCallback &', 'callback')], 

                   is_const=True, is_virtual=True)

    ## time-data-calculators.h: void ns3::TimeMinMaxAvgTotalCalculator::Update(ns3::Time const i) [member function]

    cls.add_method('Update', 

                   'void', 

                   [param('ns3::Time const', 'i')])

    ## time-data-calculators.h: void ns3::TimeMinMaxAvgTotalCalculator::DoDispose() [member function]

    cls.add_method('DoDispose', 

                   'void', 

                   [], 

                   visibility='protected', is_virtual=True)

    return

def register_Ns3CounterCalculator__Unsigned_int_methods(root_module, cls):

    ## basic-data-calculators.h: ns3::CounterCalculator<unsigned int>::CounterCalculator(ns3::CounterCalculator<unsigned int> const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::CounterCalculator< unsigned int > const &', 'arg0')])

    ## basic-data-calculators.h: ns3::CounterCalculator<unsigned int>::CounterCalculator() [constructor]

    cls.add_constructor([])