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

def register_types(module):

    root_module = module.get_root()

    ## event-id.h: ns3::EventId [class]

    module.add_class('EventId')

    ## event-impl.h: ns3::EventImpl [class]

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

    ## event-impl.h: ns3::EventLock [class]

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

    ## high-precision-128.h: ns3::HighPrecision [class]

    module.add_class('HighPrecision')

    ## realtime-simulator-impl.h: ns3::RealtimeEventLock [class]

    module.add_class('RealtimeEventLock', parent=root_module['ns3::EventLock'])

    ## simulator.h: ns3::Simulator [class]

    module.add_class('Simulator', is_singleton=True)

    ## nstime.h: ns3::TimeUnit<-1> [class]

    module.add_class('TimeInvert')

    ## nstime.h: ns3::TimeUnit<0> [class]

    module.add_class('Scalar')

    ## nstime.h: ns3::TimeUnit<1> [class]

    module.add_class('Time')

    ## nstime.h: ns3::TimeUnit<2> [class]

    module.add_class('TimeSquare')

    ## timer.h: ns3::Timer [class]

    module.add_class('Timer')

    ## timer.h: ns3::Timer::DestroyPolicy [enumeration]

    module.add_enum('DestroyPolicy', ['CANCEL_ON_DESTROY', 'REMOVE_ON_DESTROY', 'CHECK_ON_DESTROY'], outer_class=root_module['ns3::Timer'])

    ## timer.h: ns3::Timer::State [enumeration]

    module.add_enum('State', ['RUNNING', 'EXPIRED', 'SUSPENDED'], outer_class=root_module['ns3::Timer'])

    ## timer-impl.h: ns3::TimerImpl [class]

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

    ## watchdog.h: ns3::Watchdog [class]

    module.add_class('Watchdog')

    ## scheduler.h: ns3::Scheduler [class]

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

    ## scheduler.h: ns3::Scheduler::EventKey [struct]

    module.add_class('EventKey', outer_class=root_module['ns3::Scheduler'])

    ## simulator-impl.h: ns3::SimulatorImpl [class]

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

    ## synchronizer.h: ns3::Synchronizer [class]

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

    ## nstime.h: ns3::TimeChecker [class]

    module.add_class('TimeChecker', parent=root_module['ns3::AttributeChecker'])

    ## nstime.h: ns3::TimeValue [class]

    module.add_class('TimeValue', parent=root_module['ns3::AttributeValue'])

    ## wall-clock-synchronizer.h: ns3::WallClockSynchronizer [class]

    module.add_class('WallClockSynchronizer', parent=root_module['ns3::Synchronizer'])

    ## default-simulator-impl.h: ns3::DefaultSimulatorImpl [class]

    module.add_class('DefaultSimulatorImpl', parent=root_module['ns3::SimulatorImpl'])

    ## heap-scheduler.h: ns3::HeapScheduler [class]

    module.add_class('HeapScheduler', parent=root_module['ns3::Scheduler'])

    ## list-scheduler.h: ns3::ListScheduler [class]

    module.add_class('ListScheduler', parent=root_module['ns3::Scheduler'])

    ## map-scheduler.h: ns3::MapScheduler [class]

    module.add_class('MapScheduler', parent=root_module['ns3::Scheduler'])

    ## realtime-simulator-impl.h: ns3::RealtimeSimulatorImpl [class]

    module.add_class('RealtimeSimulatorImpl', parent=root_module['ns3::SimulatorImpl'])

    ## realtime-simulator-impl.h: ns3::RealtimeSimulatorImpl::SynchronizationMode [enumeration]

    module.add_enum('SynchronizationMode', ['SYNC_BEST_EFFORT', 'SYNC_HARD_LIMIT'], outer_class=root_module['ns3::RealtimeSimulatorImpl'])

    ## Register a nested module for the namespace internal

    nested_module = module.add_cpp_namespace('internal')

    register_types_ns3_internal(nested_module)

    ## Register a nested module for the namespace TimeStepPrecision

    nested_module = module.add_cpp_namespace('TimeStepPrecision')

    register_types_ns3_TimeStepPrecision(nested_module)

    ## Register a nested module for the namespace Config

    nested_module = module.add_cpp_namespace('Config')

    register_types_ns3_Config(nested_module)

    ## Register a nested module for the namespace olsr

    nested_module = module.add_cpp_namespace('olsr')

    register_types_ns3_olsr(nested_module)

def register_types_ns3_internal(module):

    root_module = module.get_root()

def register_types_ns3_TimeStepPrecision(module):

    root_module = module.get_root()

    ## nstime.h: ns3::TimeStepPrecision::precision_t [enumeration]

    module.add_enum('precision_t', ['S', 'MS', 'US', 'NS', 'PS', 'FS'])

def register_types_ns3_Config(module):

    root_module = module.get_root()

def register_types_ns3_olsr(module):

    root_module = module.get_root()

def register_methods(root_module):

    register_Ns3EventId_methods(root_module, root_module['ns3::EventId'])

    register_Ns3EventImpl_methods(root_module, root_module['ns3::EventImpl'])

    register_Ns3EventLock_methods(root_module, root_module['ns3::EventLock'])

    register_Ns3HighPrecision_methods(root_module, root_module['ns3::HighPrecision'])

    register_Ns3RealtimeEventLock_methods(root_module, root_module['ns3::RealtimeEventLock'])

    register_Ns3Simulator_methods(root_module, root_module['ns3::Simulator'])

    register_Ns3TimeInvert_methods(root_module, root_module['ns3::TimeInvert'])

    register_Ns3Scalar_methods(root_module, root_module['ns3::Scalar'])

    register_Ns3Time_methods(root_module, root_module['ns3::Time'])

    register_Ns3TimeSquare_methods(root_module, root_module['ns3::TimeSquare'])

    register_Ns3Timer_methods(root_module, root_module['ns3::Timer'])

    register_Ns3TimerImpl_methods(root_module, root_module['ns3::TimerImpl'])

    register_Ns3Watchdog_methods(root_module, root_module['ns3::Watchdog'])

    register_Ns3Scheduler_methods(root_module, root_module['ns3::Scheduler'])

    register_Ns3SchedulerEventKey_methods(root_module, root_module['ns3::Scheduler::EventKey'])

    register_Ns3SimulatorImpl_methods(root_module, root_module['ns3::SimulatorImpl'])

    register_Ns3Synchronizer_methods(root_module, root_module['ns3::Synchronizer'])

    register_Ns3TimeChecker_methods(root_module, root_module['ns3::TimeChecker'])

    register_Ns3TimeValue_methods(root_module, root_module['ns3::TimeValue'])

    register_Ns3WallClockSynchronizer_methods(root_module, root_module['ns3::WallClockSynchronizer'])

    register_Ns3DefaultSimulatorImpl_methods(root_module, root_module['ns3::DefaultSimulatorImpl'])

    register_Ns3HeapScheduler_methods(root_module, root_module['ns3::HeapScheduler'])

    register_Ns3ListScheduler_methods(root_module, root_module['ns3::ListScheduler'])

    register_Ns3MapScheduler_methods(root_module, root_module['ns3::MapScheduler'])

    register_Ns3RealtimeSimulatorImpl_methods(root_module, root_module['ns3::RealtimeSimulatorImpl'])

    return

def register_Ns3EventId_methods(root_module, cls):

    cls.add_binary_comparison_operator('!=')

    cls.add_binary_comparison_operator('==')

    ## event-id.h: ns3::EventId::EventId(ns3::EventId const & arg0) [copy constructor]

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

    ## event-id.h: ns3::EventId::EventId() [constructor]

    cls.add_constructor([])

    ## event-id.h: ns3::EventId::EventId(ns3::Ptr<ns3::EventImpl> const & impl, uint64_t ts, uint32_t uid) [constructor]

    cls.add_constructor([param('ns3::Ptr< ns3::EventImpl > const &', 'impl'), param('uint64_t', 'ts'), param('uint32_t', 'uid')])

    ## event-id.h: void ns3::EventId::Cancel() [member function]

    cls.add_method('Cancel', 

                   'void', 

                   [])

    ## event-id.h: uint64_t ns3::EventId::GetTs() const [member function]

    cls.add_method('GetTs', 

                   'uint64_t', 

                   [], 

                   is_const=True)

    ## event-id.h: uint32_t ns3::EventId::GetUid() const [member function]

    cls.add_method('GetUid', 

                   'uint32_t', 

                   [], 

                   is_const=True)

    ## event-id.h: bool ns3::EventId::IsExpired() const [member function]

    cls.add_method('IsExpired', 

                   'bool', 

                   [], 

                   is_const=True)

    ## event-id.h: bool ns3::EventId::IsRunning() const [member function]

    cls.add_method('IsRunning', 

                   'bool', 

                   [], 

                   is_const=True)

    ## event-id.h: ns3::EventImpl * ns3::EventId::PeekEventImpl() const [member function]

    cls.add_method('PeekEventImpl', 

                   'ns3::EventImpl *', 

                   [], 

                   is_const=True)

    return

def register_Ns3EventImpl_methods(root_module, cls):

    ## event-impl.h: ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [copy constructor]

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

    ## event-impl.h: ns3::EventImpl::EventImpl() [constructor]

    cls.add_constructor([])

    ## event-impl.h: void ns3::EventImpl::Ref() const [member function]

    cls.add_method('Ref', 

                   'void', 

                   [], 

                   is_const=True)

    ## event-impl.h: void ns3::EventImpl::Unref() const [member function]

    cls.add_method('Unref', 

                   'void', 

                   [], 

                   is_const=True)

    ## event-impl.h: void ns3::EventImpl::Invoke() [member function]

    cls.add_method('Invoke', 

                   'void', 

                   [])

    ## event-impl.h: void ns3::EventImpl::Cancel() [member function]

    cls.add_method('Cancel', 

                   'void', 

                   [])

    ## event-impl.h: bool ns3::EventImpl::IsCancelled() [member function]

    cls.add_method('IsCancelled', 

                   'bool', 

                   [])

    ## event-impl.h: static void ns3::EventImpl::SetEventLock(ns3::EventLock * eventLock) [member function]

    cls.add_method('SetEventLock', 

                   'void', 

                   [param('ns3::EventLock *', 'eventLock')], 

                   is_static=True)

    ## event-impl.h: static void ns3::EventImpl::SetNoEventLock() [member function]

    cls.add_method('SetNoEventLock', 

                   'void', 

                   [], 

                   is_static=True)

    ## event-impl.h: void ns3::EventImpl::Notify() [member function]

    cls.add_method('Notify', 

                   'void', 

                   [], 

                   is_pure_virtual=True, visibility='protected', is_virtual=True)

    return

def register_Ns3EventLock_methods(root_module, cls):

    ## event-impl.h: ns3::EventLock::EventLock(ns3::EventLock const & arg0) [copy constructor]

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

    ## event-impl.h: ns3::EventLock::EventLock() [constructor]

    cls.add_constructor([])

    ## event-impl.h: void ns3::EventLock::Lock() [member function]

    cls.add_method('Lock', 

                   'void', 

                   [], 

                   is_pure_virtual=True, is_virtual=True)

    ## event-impl.h: void ns3::EventLock::Unlock() [member function]

    cls.add_method('Unlock', 

                   'void', 

                   [], 

                   is_pure_virtual=True, is_virtual=True)

    return

def register_Ns3HighPrecision_methods(root_module, cls):

    ## high-precision-128.h: ns3::HighPrecision::HighPrecision(ns3::HighPrecision const & arg0) [copy constructor]

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

    ## high-precision-128.h: ns3::HighPrecision::HighPrecision() [constructor]

    cls.add_constructor([])

    ## high-precision-128.h: ns3::HighPrecision::HighPrecision(int64_t value, bool dummy) [constructor]

    cls.add_constructor([param('int64_t', 'value'), param('bool', 'dummy')])

    ## high-precision-128.h: ns3::HighPrecision::HighPrecision(double value) [constructor]

    cls.add_constructor([param('double', 'value')])

    ## high-precision-128.h: static void ns3::HighPrecision::PrintStats() [member function]

    cls.add_method('PrintStats', 

                   'void', 

                   [], 

                   is_static=True)

    ## high-precision-128.h: int64_t ns3::HighPrecision::GetInteger() const [member function]

    cls.add_method('GetInteger', 

                   'int64_t', 

                   [], 

                   is_const=True)

    ## high-precision-128.h: double ns3::HighPrecision::GetDouble() const [member function]

    cls.add_method('GetDouble', 

                   'double', 

                   [], 

                   is_const=True)

    ## high-precision-128.h: bool ns3::HighPrecision::Add(ns3::HighPrecision const & o) [member function]

    cls.add_method('Add', 

                   'bool', 

                   [param('ns3::HighPrecision const &', 'o')])

    ## high-precision-128.h: bool ns3::HighPrecision::Sub(ns3::HighPrecision const & o) [member function]

    cls.add_method('Sub', 

                   'bool', 

                   [param('ns3::HighPrecision const &', 'o')])

    ## high-precision-128.h: bool ns3::HighPrecision::Mul(ns3::HighPrecision const & o) [member function]

    cls.add_method('Mul', 

                   'bool', 

                   [param('ns3::HighPrecision const &', 'o')])

    ## high-precision-128.h: bool ns3::HighPrecision::Div(ns3::HighPrecision const & o) [member function]

    cls.add_method('Div', 

                   'bool', 

                   [param('ns3::HighPrecision const &', 'o')])

    ## high-precision-128.h: int ns3::HighPrecision::Compare(ns3::HighPrecision const & o) const [member function]

    cls.add_method('Compare', 

                   'int', 

                   [param('ns3::HighPrecision const &', 'o')], 

                   is_const=True)

    ## high-precision-128.h: static ns3::HighPrecision ns3::HighPrecision::Zero() [member function]

    cls.add_method('Zero', 

                   'ns3::HighPrecision', 

                   [], 

                   is_static=True)

    return

def register_Ns3RealtimeEventLock_methods(root_module, cls):

    ## realtime-simulator-impl.h: ns3::RealtimeEventLock::RealtimeEventLock(ns3::RealtimeEventLock const & arg0) [copy constructor]

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

    ## realtime-simulator-impl.h: ns3::RealtimeEventLock::RealtimeEventLock() [constructor]

    cls.add_constructor([])

    ## realtime-simulator-impl.h: void ns3::RealtimeEventLock::Lock() [member function]

    cls.add_method('Lock', 

                   'void', 

                   [], 

                   is_virtual=True)

    ## realtime-simulator-impl.h: void ns3::RealtimeEventLock::Unlock() [member function]

    cls.add_method('Unlock', 

                   'void', 

                   [], 

                   is_virtual=True)

    return

def register_Ns3Simulator_methods(root_module, cls):

    ## simulator.h: ns3::Simulator::Simulator(ns3::Simulator const & arg0) [copy constructor]

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

    ## simulator.h: static void ns3::Simulator::SetImplementation(ns3::Ptr<ns3::SimulatorImpl> impl) [member function]

    cls.add_method('SetImplementation', 

                   'void', 

                   [param('ns3::Ptr< ns3::SimulatorImpl >', 'impl')], 

                   is_static=True)

    ## simulator.h: static void ns3::Simulator::SetScheduler(ns3::Ptr<ns3::Scheduler> scheduler) [member function]

    cls.add_method('SetScheduler', 

                   'void', 

                   [param('ns3::Ptr< ns3::Scheduler >', 'scheduler')], 

                   is_static=True)

    ## simulator.h: static void ns3::Simulator::EnableLogTo(char const * filename) [member function]

    cls.add_method('EnableLogTo', 

                   'void', 

                   [param('char const *', 'filename')], 

                   is_static=True, deprecated=True)

    ## simulator.h: static void ns3::Simulator::Destroy() [member function]

    cls.add_method('Destroy', 

                   'void', 

                   [], 

                   is_static=True)

    ## simulator.h: static bool ns3::Simulator::IsFinished() [member function]

    cls.add_method('IsFinished', 

                   'bool', 

                   [], 

                   is_static=True)

    ## simulator.h: static ns3::Time ns3::Simulator::Next() [member function]

    cls.add_method('Next', 

                   'ns3::Time', 

                   [], 

                   is_static=True)

    ## simulator.h: static void ns3::Simulator::Run() [member function]

    cls.add_method('Run', 

                   'void', 

                   [], 

                   is_static=True, unblock_threads=True)

    ## simulator.h: static void ns3::Simulator::RunOneEvent() [member function]

    cls.add_method('RunOneEvent', 

                   'void', 

                   [], 

                   is_static=True)

    ## simulator.h: static void ns3::Simulator::Stop() [member function]

    cls.add_method('Stop', 

                   'void', 

                   [], 

                   is_static=True)

    ## simulator.h: static void ns3::Simulator::Stop(ns3::Time const & time) [member function]

    cls.add_method('Stop', 

                   'void', 

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

                   is_static=True)

    ## simulator.h: static void ns3::Simulator::Remove(ns3::EventId const & id) [member function]

    cls.add_method('Remove', 

                   'void', 

                   [param('ns3::EventId const &', 'id')], 

                   is_static=True)

    ## simulator.h: static void ns3::Simulator::Cancel(ns3::EventId const & id) [member function]

    cls.add_method('Cancel', 

                   'void', 

                   [param('ns3::EventId const &', 'id')], 

                   is_static=True)

    ## simulator.h: static bool ns3::Simulator::IsExpired(ns3::EventId const & id) [member function]

    cls.add_method('IsExpired', 

                   'bool', 

                   [param('ns3::EventId const &', 'id')], 

                   is_static=True)

    ## simulator.h: static ns3::Time ns3::Simulator::Now() [member function]

    cls.add_method('Now', 

                   'ns3::Time', 

                   [], 

                   is_static=True)

    ## simulator.h: static ns3::Time ns3::Simulator::GetDelayLeft(ns3::EventId const & id) [member function]

    cls.add_method('GetDelayLeft', 

                   'ns3::Time', 

                   [param('ns3::EventId const &', 'id')], 

                   is_static=True)

    ## simulator.h: static ns3::Time ns3::Simulator::GetMaximumSimulationTime() [member function]

    cls.add_method('GetMaximumSimulationTime', 

                   'ns3::Time', 

                   [], 

                   is_static=True)

    return

def register_Ns3TimeInvert_methods(root_module, cls):

    ## nstime.h: ns3::TimeUnit<-1>::TimeUnit() [constructor]

    cls.add_constructor([])

    ## nstime.h: ns3::TimeUnit<-1>::TimeUnit(ns3::TimeUnit<-1> const & o) [copy constructor]

    cls.add_constructor([param('ns3::TimeUnit< - 1 > const &', 'o')])

    ## nstime.h: ns3::TimeUnit<-1>::TimeUnit(ns3::HighPrecision data) [constructor]

    cls.add_constructor([param('ns3::HighPrecision', 'data')])

    ## nstime.h: ns3::HighPrecision const & ns3::TimeUnit<-1>::GetHighPrecision() const [member function]

    cls.add_method('GetHighPrecision', 

                   'ns3::HighPrecision const &', 

                   [], 

                   is_const=True)

    ## nstime.h: bool ns3::TimeUnit<-1>::IsNegative() const [member function]

    cls.add_method('IsNegative', 

                   'bool', 

                   [], 

                   is_const=True)

    ## nstime.h: bool ns3::TimeUnit<-1>::IsPositive() const [member function]

    cls.add_method('IsPositive', 

                   'bool', 

                   [], 

                   is_const=True)

    ## nstime.h: bool ns3::TimeUnit<-1>::IsStrictlyNegative() const [member function]

    cls.add_method('IsStrictlyNegative', 

                   'bool', 

                   [], 

                   is_const=True)

    ## nstime.h: bool ns3::TimeUnit<-1>::IsStrictlyPositive() const [member function]

    cls.add_method('IsStrictlyPositive', 

                   'bool', 

                   [], 

                   is_const=True)

    ## nstime.h: bool ns3::TimeUnit<-1>::IsZero() const [member function]

    cls.add_method('IsZero', 

                   'bool', 

                   [], 

                   is_const=True)

    ## nstime.h: ns3::HighPrecision * ns3::TimeUnit<-1>::PeekHighPrecision() [member function]

    cls.add_method('PeekHighPrecision', 

                   'ns3::HighPrecision *', 

                   [])

    return

def register_Ns3Scalar_methods(root_module, cls):

    cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Scalar'], root_module['ns3::Time'])

    cls.add_binary_numeric_operator('/', root_module['ns3::Time'], root_module['ns3::Time'], root_module['ns3::Scalar'])

    cls.add_binary_numeric_operator('/', root_module['ns3::TimeInvert'], root_module['ns3::Scalar'], root_module['ns3::Time'])

    ## nstime.h: ns3::TimeUnit<0>::TimeUnit(double scalar) [constructor]

    cls.add_constructor([param('double', 'scalar')])

    ## nstime.h: ns3::TimeUnit<0>::TimeUnit() [constructor]

    cls.add_constructor([])

    ## nstime.h: ns3::TimeUnit<0>::TimeUnit(ns3::TimeUnit<0> const & o) [copy constructor]

    cls.add_constructor([param('ns3::TimeUnit< 0 > const &', 'o')])

    ## nstime.h: ns3::TimeUnit<0>::TimeUnit(ns3::HighPrecision data) [constructor]

    cls.add_constructor([param('ns3::HighPrecision', 'data')])

    ## nstime.h: double ns3::TimeUnit<0>::GetDouble() const [member function]

    cls.add_method('GetDouble', 

                   'double', 

                   [], 

                   is_const=True)

    ## nstime.h: ns3::HighPrecision const & ns3::TimeUnit<0>::GetHighPrecision() const [member function]

    cls.add_method('GetHighPrecision', 

                   'ns3::HighPrecision const &', 

                   [], 

                   is_const=True)

    ## nstime.h: bool ns3::TimeUnit<0>::IsNegative() const [member function]

    cls.add_method('IsNegative', 

                   'bool', 

                   [], 

                   is_const=True)

    ## nstime.h: bool ns3::TimeUnit<0>::IsPositive() const [member function]

    cls.add_method('IsPositive', 

                   'bool', 

                   [], 

                   is_const=True)

    ## nstime.h: bool ns3::TimeUnit<0>::IsStrictlyNegative() const [member function]

    cls.add_method('IsStrictlyNegative', 

                   'bool', 

                   [], 

                   is_const=True)

    ## nstime.h: bool ns3::TimeUnit<0>::IsStrictlyPositive() const [member function]

    cls.add_method('IsStrictlyPositive', 

                   'bool', 

                   [], 

                   is_const=True)

    ## nstime.h: bool ns3::TimeUnit<0>::IsZero() const [member function]

    cls.add_method('IsZero', 

                   'bool', 

                   [], 

                   is_const=True)

    ## nstime.h: ns3::HighPrecision * ns3::TimeUnit<0>::PeekHighPrecision() [member function]

    cls.add_method('PeekHighPrecision', 

                   'ns3::HighPrecision *', 

                   [])

    return

def register_Ns3Time_methods(root_module, cls):

    cls.add_binary_comparison_operator('!=')

    cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Scalar'], root_module['ns3::Time'])

    cls.add_binary_numeric_operator('*', root_module['ns3::TimeSquare'], root_module['ns3::Time'], root_module['ns3::Time'])

    cls.add_binary_numeric_operator('+', root_module['ns3::Time'], root_module['ns3::Time'], root_module['ns3::Time'])

    cls.add_binary_numeric_operator('-', root_module['ns3::Time'], root_module['ns3::Time'], root_module['ns3::Time'])

    cls.add_binary_numeric_operator('/', root_module['ns3::Time'], root_module['ns3::Time'], root_module['ns3::Scalar'])

    cls.add_binary_numeric_operator('/', root_module['ns3::TimeInvert'], root_module['ns3::Scalar'], root_module['ns3::Time'])

    cls.add_binary_numeric_operator('/', root_module['ns3::Scalar'], root_module['ns3::Time'], root_module['ns3::Time'])

    cls.add_binary_numeric_operator('/', root_module['ns3::Time'], root_module['ns3::TimeSquare'], root_module['ns3::Time'])

    cls.add_binary_comparison_operator('<')