def register_Ns3WifiInformationElement_methods(root_module, cls):
    cls.add_binary_comparison_operator('<')
    cls.add_binary_comparison_operator('==')
    ## wifi-information-element-vector.h: ns3::WifiInformationElement::WifiInformationElement() [constructor]
    cls.add_constructor([])
    ## wifi-information-element-vector.h: ns3::WifiInformationElement::WifiInformationElement(ns3::WifiInformationElement const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::WifiInformationElement const &', 'arg0')])
    ## wifi-information-element-vector.h: uint8_t ns3::WifiInformationElement::DeserializeInformation(ns3::Buffer::Iterator start, uint8_t length) [member function]
    cls.add_method('DeserializeInformation', 
                   'uint8_t', 
                   [param('ns3::Buffer::Iterator', 'start'), param('uint8_t', 'length')], 
                   is_pure_virtual=True, is_virtual=True)
    ## wifi-information-element-vector.h: ns3::WifiElementId ns3::WifiInformationElement::ElementId() const [member function]
    cls.add_method('ElementId', 
                   'ns3::WifiElementId', 
                   [], 
                   is_pure_virtual=True, is_const=True, is_virtual=True)
    ## wifi-information-element-vector.h: uint8_t ns3::WifiInformationElement::GetInformationSize() const [member function]
    cls.add_method('GetInformationSize', 
                   'uint8_t', 
                   [], 
                   is_pure_virtual=True, is_const=True, is_virtual=True)
    ## wifi-information-element-vector.h: void ns3::WifiInformationElement::Print(std::ostream & os) const [member function]
    cls.add_method('Print', 
                   'void', 
                   [param('std::ostream &', 'os')], 
                   is_pure_virtual=True, is_const=True, is_virtual=True)
    ## wifi-information-element-vector.h: void ns3::WifiInformationElement::SerializeInformation(ns3::Buffer::Iterator start) const [member function]
    cls.add_method('SerializeInformation', 
                   'void', 
                   [param('ns3::Buffer::Iterator', 'start')], 
                   is_pure_virtual=True, is_const=True, is_virtual=True)
    return
def register_Ns3LogDistancePropagationLossModel_methods(root_module, cls):
    ## propagation-loss-model.h: static ns3::TypeId ns3::LogDistancePropagationLossModel::GetTypeId() [member function]
    cls.add_method('GetTypeId', 
                   'ns3::TypeId', 
                   [], 
                   is_static=True)
    ## propagation-loss-model.h: ns3::LogDistancePropagationLossModel::LogDistancePropagationLossModel() [constructor]
    cls.add_constructor([])
    ## propagation-loss-model.h: void ns3::LogDistancePropagationLossModel::SetPathLossExponent(double n) [member function]
    cls.add_method('SetPathLossExponent', 
                   'void', 
                   [param('double', 'n')])
    ## propagation-loss-model.h: double ns3::LogDistancePropagationLossModel::GetPathLossExponent() const [member function]
    cls.add_method('GetPathLossExponent', 
                   'double', 
                   [], 
                   is_const=True)
    ## propagation-loss-model.h: void ns3::LogDistancePropagationLossModel::SetReference(double referenceDistance, double referenceLoss) [member function]
    cls.add_method('SetReference', 
                   'void', 
                   [param('double', 'referenceDistance'), param('double', 'referenceLoss')])
    ## propagation-loss-model.h: double ns3::LogDistancePropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
    cls.add_method('DoCalcRxPower', 
                   'double', 
                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
                   is_const=True, visibility='private', is_virtual=True)
    return
def register_Ns3JakesPropagationLossModel_methods(root_module, cls):
    ## jakes-propagation-loss-model.h: ns3::JakesPropagationLossModel::JakesPropagationLossModel() [constructor]
    cls.add_constructor([])
    ## jakes-propagation-loss-model.h: uint8_t ns3::JakesPropagationLossModel::GetNOscillators() const [member function]
    cls.add_method('GetNOscillators', 
                   'uint8_t', 
                   [], 
                   is_const=True)
    ## jakes-propagation-loss-model.h: uint8_t ns3::JakesPropagationLossModel::GetNRays() const [member function]
    cls.add_method('GetNRays', 
                   'uint8_t', 
                   [], 
                   is_const=True)
    ## jakes-propagation-loss-model.h: static ns3::TypeId ns3::JakesPropagationLossModel::GetTypeId() [member function]
    cls.add_method('GetTypeId', 
                   'ns3::TypeId', 
                   [], 
                   is_static=True)
    ## jakes-propagation-loss-model.h: void ns3::JakesPropagationLossModel::SetNOscillators(uint8_t nOscillators) [member function]
    cls.add_method('SetNOscillators', 
                   'void', 
                   [param('uint8_t', 'nOscillators')])
    ## jakes-propagation-loss-model.h: void ns3::JakesPropagationLossModel::SetNRays(uint8_t nRays) [member function]
    cls.add_method('SetNRays', 
                   'void', 
                   [param('uint8_t', 'nRays')])
    ## jakes-propagation-loss-model.h: double ns3::JakesPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
    cls.add_method('DoCalcRxPower', 
                   'double', 
                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
                   is_const=True, visibility='private', is_virtual=True)
    return
def register_Ns3ConstantSpeedPropagationDelayModel_methods(root_module, cls):
    ## propagation-delay-model.h: ns3::ConstantSpeedPropagationDelayModel::ConstantSpeedPropagationDelayModel(ns3::ConstantSpeedPropagationDelayModel const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::ConstantSpeedPropagationDelayModel const &', 'arg0')])
    ## propagation-delay-model.h: ns3::ConstantSpeedPropagationDelayModel::ConstantSpeedPropagationDelayModel() [constructor]
    cls.add_constructor([])
    ## propagation-delay-model.h: ns3::Time ns3::ConstantSpeedPropagationDelayModel::GetDelay(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
    cls.add_method('GetDelay', 
                   'ns3::Time', 
                   [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
                   is_const=True, is_virtual=True)
    ## propagation-delay-model.h: double ns3::ConstantSpeedPropagationDelayModel::GetSpeed() const [member function]
    cls.add_method('GetSpeed', 
                   'double', 
                   [], 
                   is_const=True)
    ## propagation-delay-model.h: static ns3::TypeId ns3::ConstantSpeedPropagationDelayModel::GetTypeId() [member function]
    cls.add_method('GetTypeId', 
                   'ns3::TypeId', 
                   [], 
                   is_static=True)
    ## propagation-delay-model.h: void ns3::ConstantSpeedPropagationDelayModel::SetSpeed(double speed) [member function]
    cls.add_method('SetSpeed', 
                   'void', 
                   [param('double', 'speed')])
    return
Ejemplo n.º 5
0
def register_Ns3Dot11sDot11sMeshCapability_methods(root_module, cls):
    cls.add_binary_comparison_operator("==")
    ## ie-dot11s-configuration.h: ns3::dot11s::Dot11sMeshCapability::Dot11sMeshCapability(ns3::dot11s::Dot11sMeshCapability const & arg0) [copy constructor]
    cls.add_constructor([param("ns3::dot11s::Dot11sMeshCapability const &", "arg0")])
    ## ie-dot11s-configuration.h: ns3::dot11s::Dot11sMeshCapability::Dot11sMeshCapability() [constructor]
    cls.add_constructor([])
    ## ie-dot11s-configuration.h: ns3::Buffer::Iterator ns3::dot11s::Dot11sMeshCapability::Deserialize(ns3::Buffer::Iterator i) [member function]
    cls.add_method("Deserialize", "ns3::Buffer::Iterator", [param("ns3::Buffer::Iterator", "i")])
    ## ie-dot11s-configuration.h: uint8_t ns3::dot11s::Dot11sMeshCapability::GetSerializedSize() const [member function]
    cls.add_method("GetSerializedSize", "uint8_t", [], is_const=True)
    ## ie-dot11s-configuration.h: uint16_t ns3::dot11s::Dot11sMeshCapability::GetUint16() const [member function]
    cls.add_method("GetUint16", "uint16_t", [], is_const=True)
    ## ie-dot11s-configuration.h: bool ns3::dot11s::Dot11sMeshCapability::Is(uint16_t cap, uint8_t n) const [member function]
    cls.add_method("Is", "bool", [param("uint16_t", "cap"), param("uint8_t", "n")], is_const=True)
    ## ie-dot11s-configuration.h: ns3::Buffer::Iterator ns3::dot11s::Dot11sMeshCapability::Serialize(ns3::Buffer::Iterator i) const [member function]
    cls.add_method("Serialize", "ns3::Buffer::Iterator", [param("ns3::Buffer::Iterator", "i")], is_const=True)
    ## ie-dot11s-configuration.h: ns3::dot11s::Dot11sMeshCapability::MCCAEnabled [variable]
    cls.add_instance_attribute("MCCAEnabled", "bool", is_const=False)
    ## ie-dot11s-configuration.h: ns3::dot11s::Dot11sMeshCapability::MCCASupported [variable]
    cls.add_instance_attribute("MCCASupported", "bool", is_const=False)
    ## ie-dot11s-configuration.h: ns3::dot11s::Dot11sMeshCapability::TBTTAdjustment [variable]
    cls.add_instance_attribute("TBTTAdjustment", "bool", is_const=False)
    ## ie-dot11s-configuration.h: ns3::dot11s::Dot11sMeshCapability::acceptPeerLinks [variable]
    cls.add_instance_attribute("acceptPeerLinks", "bool", is_const=False)
    ## ie-dot11s-configuration.h: ns3::dot11s::Dot11sMeshCapability::beaconTimingReport [variable]
    cls.add_instance_attribute("beaconTimingReport", "bool", is_const=False)
    ## ie-dot11s-configuration.h: ns3::dot11s::Dot11sMeshCapability::forwarding [variable]
    cls.add_instance_attribute("forwarding", "bool", is_const=False)
    ## ie-dot11s-configuration.h: ns3::dot11s::Dot11sMeshCapability::powerSaveLevel [variable]
    cls.add_instance_attribute("powerSaveLevel", "bool", is_const=False)
    return
Ejemplo n.º 6
0
def register_Ns3ConstantVelocityMobilityModel_methods(root_module, cls):
    ## constant-velocity-mobility-model.h: ns3::ConstantVelocityMobilityModel::ConstantVelocityMobilityModel(ns3::ConstantVelocityMobilityModel const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::ConstantVelocityMobilityModel const &', 'arg0')])
    ## constant-velocity-mobility-model.h: ns3::ConstantVelocityMobilityModel::ConstantVelocityMobilityModel() [constructor]
    cls.add_constructor([])
    ## constant-velocity-mobility-model.h: static ns3::TypeId ns3::ConstantVelocityMobilityModel::GetTypeId() [member function]
    cls.add_method('GetTypeId', 
                   'ns3::TypeId', 
                   [], 
                   is_static=True)
    ## constant-velocity-mobility-model.h: void ns3::ConstantVelocityMobilityModel::SetVelocity(ns3::Vector const & speed) [member function]
    cls.add_method('SetVelocity', 
                   'void', 
                   [param('ns3::Vector const &', 'speed')])
    ## constant-velocity-mobility-model.h: ns3::Vector ns3::ConstantVelocityMobilityModel::DoGetPosition() const [member function]
    cls.add_method('DoGetPosition', 
                   'ns3::Vector', 
                   [], 
                   is_const=True, visibility='private', is_virtual=True)
    ## constant-velocity-mobility-model.h: ns3::Vector ns3::ConstantVelocityMobilityModel::DoGetVelocity() const [member function]
    cls.add_method('DoGetVelocity', 
                   'ns3::Vector', 
                   [], 
                   is_const=True, visibility='private', is_virtual=True)
    ## constant-velocity-mobility-model.h: void ns3::ConstantVelocityMobilityModel::DoSetPosition(ns3::Vector const & position) [member function]
    cls.add_method('DoSetPosition', 
                   'void', 
                   [param('ns3::Vector const &', 'position')], 
                   visibility='private', is_virtual=True)
    return
def register_Ns3UdpClient_methods(root_module, cls):
    ## udp-client.h: ns3::UdpClient::UdpClient(ns3::UdpClient const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::UdpClient const &', 'arg0')])
    ## udp-client.h: ns3::UdpClient::UdpClient() [constructor]
    cls.add_constructor([])
    ## udp-client.h: static ns3::TypeId ns3::UdpClient::GetTypeId() [member function]
    cls.add_method('GetTypeId', 
                   'ns3::TypeId', 
                   [], 
                   is_static=True)
    ## udp-client.h: void ns3::UdpClient::SetRemote(ns3::Ipv4Address ip, uint16_t port) [member function]
    cls.add_method('SetRemote', 
                   'void', 
                   [param('ns3::Ipv4Address', 'ip'), param('uint16_t', 'port')])
    ## udp-client.h: void ns3::UdpClient::DoDispose() [member function]
    cls.add_method('DoDispose', 
                   'void', 
                   [], 
                   visibility='protected', is_virtual=True)
    ## udp-client.h: void ns3::UdpClient::StartApplication() [member function]
    cls.add_method('StartApplication', 
                   'void', 
                   [], 
                   visibility='private', is_virtual=True)
    ## udp-client.h: void ns3::UdpClient::StopApplication() [member function]
    cls.add_method('StopApplication', 
                   'void', 
                   [], 
                   visibility='private', is_virtual=True)
    return
Ejemplo n.º 8
0
def register_Ns3Dot11sIeBeaconTimingUnit_methods(root_module, cls):
    cls.add_binary_comparison_operator('==')
    ## ie-dot11s-beacon-timing.h: ns3::dot11s::IeBeaconTimingUnit::IeBeaconTimingUnit(ns3::dot11s::IeBeaconTimingUnit const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::dot11s::IeBeaconTimingUnit const &', 'arg0')])
    ## ie-dot11s-beacon-timing.h: ns3::dot11s::IeBeaconTimingUnit::IeBeaconTimingUnit() [constructor]
    cls.add_constructor([])
    ## ie-dot11s-beacon-timing.h: uint8_t ns3::dot11s::IeBeaconTimingUnit::GetAid() const [member function]
    cls.add_method('GetAid', 
                   'uint8_t', 
                   [], 
                   is_const=True)
    ## ie-dot11s-beacon-timing.h: uint16_t ns3::dot11s::IeBeaconTimingUnit::GetBeaconInterval() const [member function]
    cls.add_method('GetBeaconInterval', 
                   'uint16_t', 
                   [], 
                   is_const=True)
    ## ie-dot11s-beacon-timing.h: uint16_t ns3::dot11s::IeBeaconTimingUnit::GetLastBeacon() const [member function]
    cls.add_method('GetLastBeacon', 
                   'uint16_t', 
                   [], 
                   is_const=True)
    ## ie-dot11s-beacon-timing.h: void ns3::dot11s::IeBeaconTimingUnit::SetAid(uint8_t aid) [member function]
    cls.add_method('SetAid', 
                   'void', 
                   [param('uint8_t', 'aid')])
    ## ie-dot11s-beacon-timing.h: void ns3::dot11s::IeBeaconTimingUnit::SetBeaconInterval(uint16_t beaconInterval) [member function]
    cls.add_method('SetBeaconInterval', 
                   'void', 
                   [param('uint16_t', 'beaconInterval')])
    ## ie-dot11s-beacon-timing.h: void ns3::dot11s::IeBeaconTimingUnit::SetLastBeacon(uint16_t lastBeacon) [member function]
    cls.add_method('SetLastBeacon', 
                   'void', 
                   [param('uint16_t', 'lastBeacon')])
    return
Ejemplo n.º 9
0
def register_Ns3WaypointMobilityModel_methods(root_module, cls):
    ## waypoint-mobility-model.h: ns3::WaypointMobilityModel::WaypointMobilityModel(ns3::WaypointMobilityModel const & arg0) [copy constructor]
    cls.add_constructor([param("ns3::WaypointMobilityModel const &", "arg0")])
    ## waypoint-mobility-model.h: ns3::WaypointMobilityModel::WaypointMobilityModel() [constructor]
    cls.add_constructor([])
    ## waypoint-mobility-model.h: void ns3::WaypointMobilityModel::AddWaypoint(ns3::Waypoint const & waypoint) [member function]
    cls.add_method("AddWaypoint", "void", [param("ns3::Waypoint const &", "waypoint")])
    ## waypoint-mobility-model.h: void ns3::WaypointMobilityModel::EndMobility() [member function]
    cls.add_method("EndMobility", "void", [])
    ## waypoint-mobility-model.h: ns3::Waypoint ns3::WaypointMobilityModel::GetNextWaypoint() const [member function]
    cls.add_method("GetNextWaypoint", "ns3::Waypoint", [], is_const=True)
    ## waypoint-mobility-model.h: static ns3::TypeId ns3::WaypointMobilityModel::GetTypeId() [member function]
    cls.add_method("GetTypeId", "ns3::TypeId", [], is_static=True)
    ## waypoint-mobility-model.h: uint32_t ns3::WaypointMobilityModel::WaypointsLeft() const [member function]
    cls.add_method("WaypointsLeft", "uint32_t", [], is_const=True)
    ## waypoint-mobility-model.h: void ns3::WaypointMobilityModel::DoDispose() [member function]
    cls.add_method("DoDispose", "void", [], visibility="private", is_virtual=True)
    ## waypoint-mobility-model.h: ns3::Vector ns3::WaypointMobilityModel::DoGetPosition() const [member function]
    cls.add_method("DoGetPosition", "ns3::Vector", [], is_const=True, visibility="private", is_virtual=True)
    ## waypoint-mobility-model.h: ns3::Vector ns3::WaypointMobilityModel::DoGetVelocity() const [member function]
    cls.add_method("DoGetVelocity", "ns3::Vector", [], is_const=True, visibility="private", is_virtual=True)
    ## waypoint-mobility-model.h: void ns3::WaypointMobilityModel::DoSetPosition(ns3::Vector const & position) [member function]
    cls.add_method(
        "DoSetPosition", "void", [param("ns3::Vector const &", "position")], visibility="private", is_virtual=True
    )
    return
Ejemplo n.º 10
0
def register_Ns3AttributeAccessor_methods(root_module, cls):
    ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::AttributeAccessor const &', 'arg0')])
    ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor() [constructor]
    cls.add_constructor([])
    ## attribute.h (module 'core'): bool ns3::AttributeAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & attribute) const [member function]
    cls.add_method('Get', 
                   'bool', 
                   [param('ns3::ObjectBase const *', 'object'), param('ns3::AttributeValue &', 'attribute')], 
                   is_pure_virtual=True, is_const=True, is_virtual=True)
    ## attribute.h (module 'core'): bool ns3::AttributeAccessor::HasGetter() const [member function]
    cls.add_method('HasGetter', 
                   'bool', 
                   [], 
                   is_pure_virtual=True, is_const=True, is_virtual=True)
    ## attribute.h (module 'core'): bool ns3::AttributeAccessor::HasSetter() const [member function]
    cls.add_method('HasSetter', 
                   'bool', 
                   [], 
                   is_pure_virtual=True, is_const=True, is_virtual=True)
    ## attribute.h (module 'core'): bool ns3::AttributeAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function]
    cls.add_method('Set', 
                   'bool', 
                   [param('ns3::ObjectBase *', 'object', transfer_ownership=False), param('ns3::AttributeValue const &', 'value')], 
                   is_pure_virtual=True, is_const=True, is_virtual=True)
    return
def register_Ns3FlowProbe_methods(root_module, cls):
    ## flow-probe.h: void ns3::FlowProbe::AddPacketDropStats(ns3::FlowId flowId, uint32_t packetSize, uint32_t reasonCode) [member function]
    cls.add_method(
        "AddPacketDropStats",
        "void",
        [param("ns3::FlowId", "flowId"), param("uint32_t", "packetSize"), param("uint32_t", "reasonCode")],
    )
    ## flow-probe.h: void ns3::FlowProbe::AddPacketStats(ns3::FlowId flowId, uint32_t packetSize, ns3::Time delayFromFirstProbe) [member function]
    cls.add_method(
        "AddPacketStats",
        "void",
        [param("ns3::FlowId", "flowId"), param("uint32_t", "packetSize"), param("ns3::Time", "delayFromFirstProbe")],
    )
    ## flow-probe.h: std::map<unsigned int, ns3::FlowProbe::FlowStats, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, ns3::FlowProbe::FlowStats> > > ns3::FlowProbe::GetStats() const [member function]
    cls.add_method("GetStats", "std::map< unsigned int, ns3::FlowProbe::FlowStats >", [], is_const=True)
    ## flow-probe.h: void ns3::FlowProbe::SerializeToXmlStream(std::ostream & os, int indent, uint32_t index) const [member function]
    cls.add_method(
        "SerializeToXmlStream",
        "void",
        [param("std::ostream &", "os"), param("int", "indent"), param("uint32_t", "index")],
        is_const=True,
    )
    ## flow-probe.h: ns3::FlowProbe::FlowProbe(ns3::Ptr<ns3::FlowMonitor> flowMonitor) [constructor]
    cls.add_constructor([param("ns3::Ptr< ns3::FlowMonitor >", "flowMonitor")], visibility="protected")
    return
def register_Ns3FlowMonitorHelper_methods(root_module, cls):
    ## flow-monitor-helper.h: ns3::FlowMonitorHelper::FlowMonitorHelper(ns3::FlowMonitorHelper const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::FlowMonitorHelper const &', 'arg0')])
    ## flow-monitor-helper.h: ns3::FlowMonitorHelper::FlowMonitorHelper() [constructor]
    cls.add_constructor([])
    ## flow-monitor-helper.h: ns3::Ptr<ns3::FlowClassifier> ns3::FlowMonitorHelper::GetClassifier() [member function]
    cls.add_method('GetClassifier', 
                   'ns3::Ptr< ns3::FlowClassifier >', 
                   [])
    ## flow-monitor-helper.h: ns3::Ptr<ns3::FlowMonitor> ns3::FlowMonitorHelper::GetMonitor() [member function]
    cls.add_method('GetMonitor', 
                   'ns3::Ptr< ns3::FlowMonitor >', 
                   [])
    ## flow-monitor-helper.h: ns3::Ptr<ns3::FlowMonitor> ns3::FlowMonitorHelper::Install(ns3::NodeContainer nodes) [member function]
    cls.add_method('Install', 
                   'ns3::Ptr< ns3::FlowMonitor >', 
                   [param('ns3::NodeContainer', 'nodes')])
    ## flow-monitor-helper.h: ns3::Ptr<ns3::FlowMonitor> ns3::FlowMonitorHelper::Install(ns3::Ptr<ns3::Node> node) [member function]
    cls.add_method('Install', 
                   'ns3::Ptr< ns3::FlowMonitor >', 
                   [param('ns3::Ptr< ns3::Node >', 'node')])
    ## flow-monitor-helper.h: ns3::Ptr<ns3::FlowMonitor> ns3::FlowMonitorHelper::InstallAll() [member function]
    cls.add_method('InstallAll', 
                   'ns3::Ptr< ns3::FlowMonitor >', 
                   [])
    ## flow-monitor-helper.h: void ns3::FlowMonitorHelper::SetMonitorAttribute(std::string n1, ns3::AttributeValue const & v1) [member function]
    cls.add_method('SetMonitorAttribute', 
                   'void', 
                   [param('std::string', 'n1'), param('ns3::AttributeValue const &', 'v1')])
    return
Ejemplo n.º 13
0
def register_Ns3DsdvPacketQueue_methods(root_module, cls):
    ## dsdv-packet-queue.h: ns3::dsdv::PacketQueue::PacketQueue(ns3::dsdv::PacketQueue const & arg0) [copy constructor]
    cls.add_constructor([param("ns3::dsdv::PacketQueue const &", "arg0")])
    ## dsdv-packet-queue.h: ns3::dsdv::PacketQueue::PacketQueue() [constructor]
    cls.add_constructor([])
    ## dsdv-packet-queue.h: bool ns3::dsdv::PacketQueue::Dequeue(ns3::Ipv4Address dst, ns3::dsdv::QueueEntry & entry) [member function]
    cls.add_method("Dequeue", "bool", [param("ns3::Ipv4Address", "dst"), param("ns3::dsdv::QueueEntry &", "entry")])
    ## dsdv-packet-queue.h: void ns3::dsdv::PacketQueue::DropPacketWithDst(ns3::Ipv4Address dst) [member function]
    cls.add_method("DropPacketWithDst", "void", [param("ns3::Ipv4Address", "dst")])
    ## dsdv-packet-queue.h: bool ns3::dsdv::PacketQueue::Enqueue(ns3::dsdv::QueueEntry & entry) [member function]
    cls.add_method("Enqueue", "bool", [param("ns3::dsdv::QueueEntry &", "entry")])
    ## dsdv-packet-queue.h: bool ns3::dsdv::PacketQueue::Find(ns3::Ipv4Address dst) [member function]
    cls.add_method("Find", "bool", [param("ns3::Ipv4Address", "dst")])
    ## dsdv-packet-queue.h: uint32_t ns3::dsdv::PacketQueue::GetCountForPacketsWithDst(ns3::Ipv4Address dst) [member function]
    cls.add_method("GetCountForPacketsWithDst", "uint32_t", [param("ns3::Ipv4Address", "dst")])
    ## dsdv-packet-queue.h: uint32_t ns3::dsdv::PacketQueue::GetMaxPacketsPerDst() const [member function]
    cls.add_method("GetMaxPacketsPerDst", "uint32_t", [], is_const=True)
    ## dsdv-packet-queue.h: uint32_t ns3::dsdv::PacketQueue::GetMaxQueueLen() const [member function]
    cls.add_method("GetMaxQueueLen", "uint32_t", [], is_const=True)
    ## dsdv-packet-queue.h: ns3::Time ns3::dsdv::PacketQueue::GetQueueTimeout() const [member function]
    cls.add_method("GetQueueTimeout", "ns3::Time", [], is_const=True)
    ## dsdv-packet-queue.h: uint32_t ns3::dsdv::PacketQueue::GetSize() [member function]
    cls.add_method("GetSize", "uint32_t", [])
    ## dsdv-packet-queue.h: void ns3::dsdv::PacketQueue::SetMaxPacketsPerDst(uint32_t len) [member function]
    cls.add_method("SetMaxPacketsPerDst", "void", [param("uint32_t", "len")])
    ## dsdv-packet-queue.h: void ns3::dsdv::PacketQueue::SetMaxQueueLen(uint32_t len) [member function]
    cls.add_method("SetMaxQueueLen", "void", [param("uint32_t", "len")])
    ## dsdv-packet-queue.h: void ns3::dsdv::PacketQueue::SetQueueTimeout(ns3::Time t) [member function]
    cls.add_method("SetQueueTimeout", "void", [param("ns3::Time", "t")])
    return
Ejemplo n.º 14
0
def inject_ParameterFunctional(module, exceptions, interfaces, CONFIG_H):
    assert(isinstance(module, pybindgen.module.Module))
    assert(isinstance(exceptions, list))
    assert(isinstance(interfaces, dict))
    for element in interfaces:
        assert(isinstance(element, str))
        assert(len(element) > 0)
        assert(isinstance(CONFIG_H, dict))
    namespace = module.add_cpp_namespace('Dune').add_cpp_namespace('Pymor')
    ParameterFunctional = namespace.add_class('ParameterFunctional', parent=[interfaces['Dune::Pymor::Parametric']])
    ParameterFunctional.add_copy_constructor()
    ParameterFunctional.add_constructor([param('const Dune::Pymor::ParameterType&', 'tt'),
                                         param('const std::string', 'exp')],
                                         throw=exceptions)
    ParameterFunctional.add_method('expression', retval('const std::string'), [], is_const=True)
    ParameterFunctional.add_method('report', retval('std::string'), [], is_const=True)
    ParameterFunctional.add_method('report',
                                   retval('std::string'),
                                   [param('const std::string', 'name')],
                                   is_const=True)
    ParameterFunctional.add_method('evaluate',
                                   'double',
                                   [param('const Parameter&', 'mu')],
                                   throw=exceptions,
                                   is_const=True)
    ParameterFunctional.allow_subclassing = True
    return module, ParameterFunctional
Ejemplo n.º 15
0
def register_Ns3DelayJitterEstimation_methods(root_module, cls):
    ## delay-jitter-estimation.h: ns3::DelayJitterEstimation::DelayJitterEstimation(ns3::DelayJitterEstimation const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::DelayJitterEstimation const &', 'arg0')])
    ## delay-jitter-estimation.h: ns3::DelayJitterEstimation::DelayJitterEstimation() [constructor]
    cls.add_constructor([])
    ## delay-jitter-estimation.h: static void ns3::DelayJitterEstimation::PrepareTx(ns3::Ptr<ns3::Packet const> packet) [member function]
    cls.add_method('PrepareTx', 
                   'void', 
                   [param('ns3::Ptr< ns3::Packet const >', 'packet')], 
                   is_static=True)
    ## delay-jitter-estimation.h: void ns3::DelayJitterEstimation::RecordRx(ns3::Ptr<ns3::Packet const> packet) [member function]
    cls.add_method('RecordRx', 
                   'void', 
                   [param('ns3::Ptr< ns3::Packet const >', 'packet')])
    ## delay-jitter-estimation.h: ns3::Time ns3::DelayJitterEstimation::GetLastDelay() const [member function]
    cls.add_method('GetLastDelay', 
                   'ns3::Time', 
                   [], 
                   is_const=True)
    ## delay-jitter-estimation.h: ns3::Time ns3::DelayJitterEstimation::GetLastJitter() const [member function]
    cls.add_method('GetLastJitter', 
                   'ns3::Time', 
                   [], 
                   is_const=True)
    return
Ejemplo n.º 16
0
def register_Ns3NoneFileConfig_methods(root_module, cls):
    ## file-config.h: ns3::NoneFileConfig::NoneFileConfig(ns3::NoneFileConfig const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::NoneFileConfig const &', 'arg0')])
    ## file-config.h: ns3::NoneFileConfig::NoneFileConfig() [constructor]
    cls.add_constructor([])
    ## file-config.h: void ns3::NoneFileConfig::SetFilename(std::string filename) [member function]
    cls.add_method('SetFilename', 
                   'void', 
                   [param('std::string', 'filename')], 
                   is_virtual=True)
    ## file-config.h: void ns3::NoneFileConfig::Default() [member function]
    cls.add_method('Default', 
                   'void', 
                   [], 
                   is_virtual=True)
    ## file-config.h: void ns3::NoneFileConfig::Global() [member function]
    cls.add_method('Global', 
                   'void', 
                   [], 
                   is_virtual=True)
    ## file-config.h: void ns3::NoneFileConfig::Attributes() [member function]
    cls.add_method('Attributes', 
                   'void', 
                   [], 
                   is_virtual=True)
    return
Ejemplo n.º 17
0
def register_Ns3UniformDiscPositionAllocator_methods(root_module, cls):
    ## position-allocator.h: ns3::UniformDiscPositionAllocator::UniformDiscPositionAllocator(ns3::UniformDiscPositionAllocator const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::UniformDiscPositionAllocator const &', 'arg0')])
    ## position-allocator.h: ns3::UniformDiscPositionAllocator::UniformDiscPositionAllocator() [constructor]
    cls.add_constructor([])
    ## position-allocator.h: ns3::Vector ns3::UniformDiscPositionAllocator::GetNext() const [member function]
    cls.add_method('GetNext', 
                   'ns3::Vector', 
                   [], 
                   is_const=True, is_virtual=True)
    ## position-allocator.h: static ns3::TypeId ns3::UniformDiscPositionAllocator::GetTypeId() [member function]
    cls.add_method('GetTypeId', 
                   'ns3::TypeId', 
                   [], 
                   is_static=True)
    ## position-allocator.h: void ns3::UniformDiscPositionAllocator::SetRho(double rho) [member function]
    cls.add_method('SetRho', 
                   'void', 
                   [param('double', 'rho')])
    ## position-allocator.h: void ns3::UniformDiscPositionAllocator::SetX(double x) [member function]
    cls.add_method('SetX', 
                   'void', 
                   [param('double', 'x')])
    ## position-allocator.h: void ns3::UniformDiscPositionAllocator::SetY(double y) [member function]
    cls.add_method('SetY', 
                   'void', 
                   [param('double', 'y')])
    return
def register_Ns3BridgeChannel_methods(root_module, cls):
    ## bridge-channel.h: ns3::BridgeChannel::BridgeChannel(ns3::BridgeChannel const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::BridgeChannel const &', 'arg0')])
    ## bridge-channel.h: ns3::BridgeChannel::BridgeChannel() [constructor]
    cls.add_constructor([])
    ## bridge-channel.h: void ns3::BridgeChannel::AddChannel(ns3::Ptr<ns3::Channel> bridgedChannel) [member function]
    cls.add_method('AddChannel', 
                   'void', 
                   [param('ns3::Ptr< ns3::Channel >', 'bridgedChannel')])
    ## bridge-channel.h: ns3::Ptr<ns3::NetDevice> ns3::BridgeChannel::GetDevice(uint32_t i) const [member function]
    cls.add_method('GetDevice', 
                   'ns3::Ptr< ns3::NetDevice >', 
                   [param('uint32_t', 'i')], 
                   is_const=True, is_virtual=True)
    ## bridge-channel.h: uint32_t ns3::BridgeChannel::GetNDevices() const [member function]
    cls.add_method('GetNDevices', 
                   'uint32_t', 
                   [], 
                   is_const=True, is_virtual=True)
    ## bridge-channel.h: static ns3::TypeId ns3::BridgeChannel::GetTypeId() [member function]
    cls.add_method('GetTypeId', 
                   'ns3::TypeId', 
                   [], 
                   is_static=True)
    return
def register_Ns3Average__Double_methods(root_module, cls):
    ## average.h: ns3::Average<double>::Average(ns3::Average<double> const & arg0) [copy constructor]
    cls.add_constructor([param("ns3::Average< double > const &", "arg0")])
    ## average.h: ns3::Average<double>::Average() [constructor]
    cls.add_constructor([])
    ## average.h: double ns3::Average<double>::Avg() const [member function]
    cls.add_method("Avg", "double", [], is_const=True)
    ## average.h: uint32_t ns3::Average<double>::Count() const [member function]
    cls.add_method("Count", "uint32_t", [], is_const=True)
    ## average.h: double ns3::Average<double>::Error90() const [member function]
    cls.add_method("Error90", "double", [], is_const=True)
    ## average.h: double ns3::Average<double>::Error95() const [member function]
    cls.add_method("Error95", "double", [], is_const=True)
    ## average.h: double ns3::Average<double>::Error99() const [member function]
    cls.add_method("Error99", "double", [], is_const=True)
    ## average.h: double ns3::Average<double>::Max() const [member function]
    cls.add_method("Max", "double", [], is_const=True)
    ## average.h: double ns3::Average<double>::Mean() const [member function]
    cls.add_method("Mean", "double", [], is_const=True)
    ## average.h: double ns3::Average<double>::Min() const [member function]
    cls.add_method("Min", "double", [], is_const=True)
    ## average.h: void ns3::Average<double>::Reset() [member function]
    cls.add_method("Reset", "void", [])
    ## average.h: double ns3::Average<double>::Stddev() const [member function]
    cls.add_method("Stddev", "double", [], is_const=True)
    ## average.h: void ns3::Average<double>::Update(double const & x) [member function]
    cls.add_method("Update", "void", [param("double const &", "x")])
    ## average.h: double ns3::Average<double>::Var() const [member function]
    cls.add_method("Var", "double", [], is_const=True)
    return
Ejemplo n.º 20
0
def register_Ns3OnOffApplication_methods(root_module, cls):
    ## onoff-application.h: ns3::OnOffApplication::OnOffApplication(ns3::OnOffApplication const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::OnOffApplication const &', 'arg0')])
    ## onoff-application.h: ns3::OnOffApplication::OnOffApplication() [constructor]
    cls.add_constructor([])
    ## onoff-application.h: ns3::Ptr<ns3::Socket> ns3::OnOffApplication::GetSocket() const [member function]
    cls.add_method('GetSocket', 
                   'ns3::Ptr< ns3::Socket >', 
                   [], 
                   is_const=True)
    ## onoff-application.h: static ns3::TypeId ns3::OnOffApplication::GetTypeId() [member function]
    cls.add_method('GetTypeId', 
                   'ns3::TypeId', 
                   [], 
                   is_static=True)
    ## onoff-application.h: void ns3::OnOffApplication::SetMaxBytes(uint32_t maxBytes) [member function]
    cls.add_method('SetMaxBytes', 
                   'void', 
                   [param('uint32_t', 'maxBytes')])
    ## onoff-application.h: void ns3::OnOffApplication::DoDispose() [member function]
    cls.add_method('DoDispose', 
                   'void', 
                   [], 
                   visibility='protected', is_virtual=True)
    ## onoff-application.h: void ns3::OnOffApplication::StartApplication() [member function]
    cls.add_method('StartApplication', 
                   'void', 
                   [], 
                   visibility='private', is_virtual=True)
    ## onoff-application.h: void ns3::OnOffApplication::StopApplication() [member function]
    cls.add_method('StopApplication', 
                   'void', 
                   [], 
                   visibility='private', is_virtual=True)
    return
Ejemplo n.º 21
0
def register_Ns3Backoff_methods(root_module, cls):
    ## backoff.h: ns3::Backoff::Backoff(ns3::Backoff const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::Backoff const &', 'arg0')])
    ## backoff.h: ns3::Backoff::Backoff() [constructor]
    cls.add_constructor([])
    ## backoff.h: ns3::Backoff::Backoff(ns3::Time slotTime, uint32_t minSlots, uint32_t maxSlots, uint32_t ceiling, uint32_t maxRetries) [constructor]
    cls.add_constructor([param('ns3::Time', 'slotTime'), param('uint32_t', 'minSlots'), param('uint32_t', 'maxSlots'), param('uint32_t', 'ceiling'), param('uint32_t', 'maxRetries')])
    ## backoff.h: ns3::Time ns3::Backoff::GetBackoffTime() [member function]
    cls.add_method('GetBackoffTime', 
                   'ns3::Time', 
                   [])
    ## backoff.h: void ns3::Backoff::IncrNumRetries() [member function]
    cls.add_method('IncrNumRetries', 
                   'void', 
                   [])
    ## backoff.h: bool ns3::Backoff::MaxRetriesReached() [member function]
    cls.add_method('MaxRetriesReached', 
                   'bool', 
                   [])
    ## backoff.h: void ns3::Backoff::ResetBackoffTime() [member function]
    cls.add_method('ResetBackoffTime', 
                   'void', 
                   [])
    ## backoff.h: ns3::Backoff::m_ceiling [variable]
    cls.add_instance_attribute('m_ceiling', 'uint32_t', is_const=False)
    ## backoff.h: ns3::Backoff::m_maxRetries [variable]
    cls.add_instance_attribute('m_maxRetries', 'uint32_t', is_const=False)
    ## backoff.h: ns3::Backoff::m_maxSlots [variable]
    cls.add_instance_attribute('m_maxSlots', 'uint32_t', is_const=False)
    ## backoff.h: ns3::Backoff::m_minSlots [variable]
    cls.add_instance_attribute('m_minSlots', 'uint32_t', is_const=False)
    ## backoff.h: ns3::Backoff::m_slotTime [variable]
    cls.add_instance_attribute('m_slotTime', 'ns3::Time', is_const=False)
    return
Ejemplo n.º 22
0
def register_Ns3Radvd_methods(root_module, cls):
    ## radvd.h: ns3::Radvd::Radvd(ns3::Radvd const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::Radvd const &', 'arg0')])
    ## radvd.h: ns3::Radvd::Radvd() [constructor]
    cls.add_constructor([])
    ## radvd.h: void ns3::Radvd::AddConfiguration(ns3::Ptr<ns3::RadvdInterface> routerInterface) [member function]
    cls.add_method('AddConfiguration', 
                   'void', 
                   [param('ns3::Ptr< ns3::RadvdInterface >', 'routerInterface')])
    ## radvd.h: static ns3::TypeId ns3::Radvd::GetTypeId() [member function]
    cls.add_method('GetTypeId', 
                   'ns3::TypeId', 
                   [], 
                   is_static=True)
    ## radvd.h: ns3::Radvd::MAX_RA_DELAY_TIME [variable]
    cls.add_static_attribute('MAX_RA_DELAY_TIME', 'uint32_t const', is_const=True)
    ## radvd.h: void ns3::Radvd::DoDispose() [member function]
    cls.add_method('DoDispose', 
                   'void', 
                   [], 
                   visibility='protected', is_virtual=True)
    ## radvd.h: void ns3::Radvd::StartApplication() [member function]
    cls.add_method('StartApplication', 
                   'void', 
                   [], 
                   visibility='private', is_virtual=True)
    ## radvd.h: void ns3::Radvd::StopApplication() [member function]
    cls.add_method('StopApplication', 
                   'void', 
                   [], 
                   visibility='private', is_virtual=True)
    return
Ejemplo n.º 23
0
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
Ejemplo n.º 24
0
def add_scalar_operators(root_module):
    # Scalar implicitly converts to Time, but pybindgen gccxml parser
    # cannot pick up operators supported through implicit conversions,
    # so we add them manually here.
    cls = root_module['ns3::Scalar']

    cls.add_binary_numeric_operator('*', root_module['ns3::Scalar'], root_module['ns3::Scalar'], param('ns3::Scalar const &', 'right'))
    cls.add_binary_numeric_operator('+', root_module['ns3::Scalar'], root_module['ns3::Scalar'], param('ns3::Scalar const &', 'right'))
    cls.add_binary_numeric_operator('-', root_module['ns3::Scalar'], root_module['ns3::Scalar'], param('ns3::Scalar const &', 'right'))
    cls.add_binary_numeric_operator('/', root_module['ns3::Scalar'], root_module['ns3::Scalar'], param('ns3::Scalar const &', 'right'))

    cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Scalar'], param('ns3::Time const &', 'right'))
    cls.add_binary_numeric_operator('-', root_module['ns3::Time'], root_module['ns3::Scalar'], param('ns3::Time const &', 'right'))

    root_module['ns3::Time'].add_binary_numeric_operator(
        '*', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Scalar const &', 'right'))

    root_module['ns3::Time'].add_binary_numeric_operator(
        '-', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Scalar const &', 'right'))

    cls.add_binary_comparison_operator('<')
    cls.add_binary_comparison_operator('>')
    cls.add_binary_comparison_operator('!=')
    cls.add_output_stream_operator()
    cls.add_binary_comparison_operator('<=')
    cls.add_binary_comparison_operator('==')
    cls.add_binary_comparison_operator('>=')
Ejemplo n.º 25
0
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
Ejemplo n.º 26
0
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([])
    ## basic-data-calculators.h: unsigned int ns3::CounterCalculator<unsigned int>::GetCount() const [member function]
    cls.add_method('GetCount', 
                   'unsigned int', 
                   [], 
                   is_const=True)
    ## basic-data-calculators.h: void ns3::CounterCalculator<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::CounterCalculator<unsigned int>::Update() [member function]
    cls.add_method('Update', 
                   'void', 
                   [])
    ## basic-data-calculators.h: void ns3::CounterCalculator<unsigned int>::Update(unsigned int const i) [member function]
    cls.add_method('Update', 
                   'void', 
                   [param('unsigned int const', 'i')])
    ## basic-data-calculators.h: void ns3::CounterCalculator<unsigned int>::DoDispose() [member function]
    cls.add_method('DoDispose', 
                   'void', 
                   [], 
                   visibility='protected', is_virtual=True)
    return
def register_Ns3EventGarbageCollector_methods(root_module, cls):
    ## event-garbage-collector.h: ns3::EventGarbageCollector::EventGarbageCollector(ns3::EventGarbageCollector const & arg0) [copy constructor]
    cls.add_constructor([param("ns3::EventGarbageCollector const &", "arg0")])
    ## event-garbage-collector.h: ns3::EventGarbageCollector::EventGarbageCollector() [constructor]
    cls.add_constructor([])
    ## event-garbage-collector.h: void ns3::EventGarbageCollector::Track(ns3::EventId event) [member function]
    cls.add_method("Track", "void", [param("ns3::EventId", "event")])
    return
Ejemplo n.º 28
0
        def reg_NextHop(cls):
            cls.add_constructor([param('const ns3::ndn::Face&', 'face'), param('uint64_t', 'endpointId')])

            cls.add_function_as_method('getFaceFromFibNextHop', 'std::shared_ptr<ns3::ndn::Face>',
                                       [param('const ns3::ndn::nfd::fib::NextHop&', 'obj')],
                                       custom_name='getFace')
            cls.add_method('setCost', 'void', [param('uint64_t', 'cost')])
            cls.add_method('getCost', 'uint64_t', [], is_const=True)
Ejemplo n.º 29
0
def register_Ns3ProcStatus_methods(root_module, cls):
    ## dce-manager-helper.h: ns3::ProcStatus::ProcStatus(ns3::ProcStatus const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::ProcStatus const &', 'arg0')])
    ## dce-manager-helper.h: ns3::ProcStatus::ProcStatus() [constructor]
    cls.add_constructor([])
    ## dce-manager-helper.h: ns3::ProcStatus::ProcStatus(int n, int e, int p, int64_t ns, int64_t ne, long int rs, long int re, double nd, long int rd, std::string cmd) [constructor]
    cls.add_constructor([param('int', 'n'), param('int', 'e'), param('int', 'p'), param('int64_t', 'ns'), param('int64_t', 'ne'), param('long int', 'rs'), param('long int', 're'), param('double', 'nd'), param('long int', 'rd'), param('std::string', 'cmd')])
    ## dce-manager-helper.h: std::string ns3::ProcStatus::GetCmdLine() const [member function]
    cls.add_method('GetCmdLine', 
                   'std::string', 
                   [], 
                   is_const=True)
    ## dce-manager-helper.h: int ns3::ProcStatus::GetExitCode() const [member function]
    cls.add_method('GetExitCode', 
                   'int', 
                   [], 
                   is_const=True)
    ## dce-manager-helper.h: int ns3::ProcStatus::GetNode() const [member function]
    cls.add_method('GetNode', 
                   'int', 
                   [], 
                   is_const=True)
    ## dce-manager-helper.h: int ns3::ProcStatus::GetPid() const [member function]
    cls.add_method('GetPid', 
                   'int', 
                   [], 
                   is_const=True)
    ## dce-manager-helper.h: long int ns3::ProcStatus::GetRealDuration() const [member function]
    cls.add_method('GetRealDuration', 
                   'long int', 
                   [], 
                   is_const=True)
    ## dce-manager-helper.h: long int ns3::ProcStatus::GetRealEndTime() const [member function]
    cls.add_method('GetRealEndTime', 
                   'long int', 
                   [], 
                   is_const=True)
    ## dce-manager-helper.h: long int ns3::ProcStatus::GetRealStartTime() const [member function]
    cls.add_method('GetRealStartTime', 
                   'long int', 
                   [], 
                   is_const=True)
    ## dce-manager-helper.h: double ns3::ProcStatus::GetSimulatedDuration() const [member function]
    cls.add_method('GetSimulatedDuration', 
                   'double', 
                   [], 
                   is_const=True)
    ## dce-manager-helper.h: int64_t ns3::ProcStatus::GetSimulatedEndTime() const [member function]
    cls.add_method('GetSimulatedEndTime', 
                   'int64_t', 
                   [], 
                   is_const=True)
    ## dce-manager-helper.h: int64_t ns3::ProcStatus::GetSimulatedStartTime() const [member function]
    cls.add_method('GetSimulatedStartTime', 
                   'int64_t', 
                   [], 
                   is_const=True)
    return
Ejemplo n.º 30
0
def inject_VectorBasedImplementation(module, exceptions, interfaces, CONFIG_H, Traits, template_parameters=None):
    assert isinstance(module, pybindgen.module.Module)
    assert isinstance(exceptions, list)
    assert isinstance(interfaces, dict)
    for element in interfaces:
        assert isinstance(element, str)
        assert len(element) > 0
    assert isinstance(CONFIG_H, dict)
    assert isinstance(Traits, dict)
    for key in Traits.keys():
        assert isinstance(Traits[key], str)
        assert len(Traits[key].strip()) > 0
    assert "SourceType" in Traits
    SourceType = Traits["SourceType"]
    assert "ScalarType" in Traits
    ScalarType = Traits["ScalarType"]
    assert "ContainerType" in Traits
    ContainerType = Traits["ContainerType"]
    if template_parameters is not None:
        if isinstance(template_parameters, str):
            assert len(template_parameters.strip()) > 0
            template_parameters = [template_parameters]
        elif isinstance(template_parameters, list):
            for element in template_parameters:
                assert isinstance(element, str)
                assert len(element.strip()) > 0
    module = module.add_cpp_namespace("Dune").add_cpp_namespace("Pymor").add_cpp_namespace("Functionals")
    Class = module.add_class(
        "VectorBased",
        parent=[interfaces["Dune::Pymor::Tags::FunctionalInterface"], interfaces["Dune::Pymor::Parametric"]],
        template_parameters=template_parameters,
    )
    Class.add_method("type_this", retval("std::string"), [], is_const=True, is_static=True, throw=exceptions)
    Class.add_method("type_source", retval("std::string"), [], is_const=True, is_static=True, throw=exceptions)
    Class.add_method("type_scalar", retval("std::string"), [], is_const=True, is_static=True, throw=exceptions)
    Class.add_method("type_frozen", retval("std::string"), [], is_const=True, is_static=True, throw=exceptions)
    Class.add_method("linear", retval("bool"), [], is_const=True)
    Class.add_method("dim_source", retval(CONFIG_H["DUNE_STUFF_SSIZE_T"]), [], is_const=True)
    Class.add_method(
        "apply", retval(ScalarType), [param("const " + SourceType + " &", "source")], is_const=True, throw=exceptions
    )
    Class.add_method(
        "apply",
        retval(ScalarType),
        [param("const " + SourceType + " &", "source"), param("const Dune::Pymor::Parameter", "mu")],
        is_const=True,
        throw=exceptions,
    )
    Class.add_method(
        "as_vector_and_return_ptr",
        retval(ContainerType + " *", caller_owns_return=True),
        [],
        is_const=True,
        throw=exceptions,
        custom_name="as_vector",
    )
    return Class
Ejemplo n.º 31
0
def register_Tr_benc_real_methods(root_module, cls):
    root_module.header.writeln("tr_benc *_wrap_tr_bencNewReal(double value);")
    root_module.body.writeln("""
tr_benc *_wrap_tr_bencNewReal(double value)
{
    tr_benc *benc = tr_new0(tr_benc, 1);
    tr_bencInitReal(benc, value);
    return benc;
}
""")

    cls.add_function_as_constructor("_wrap_tr_bencNewReal",
                                    ReturnValue.new("tr_benc*", caller_owns_return=True),
                                    [param('double', 'value')])
    return
Ejemplo n.º 32
0
def register_EudaqPyPacket_methods(root_module, cls):
    cls.add_constructor([param('eudaq::PyPacket const &', 'arg0')])
    cls.add_constructor([param('std::string const &', 'type'), param('std::string const &', 'subType')])
    cls.add_method('addMetaData', 
                   'void', 
                   [param('bool', 'tlu'), param('int', 'type'), param('uint64_t', 'data')])
    cls.add_method('getNextToSend', 
                   'eudaq::PyPacket *', 
                   [], 
                   is_static=True)
    cls.add_method('nextToSend', 
                   'void', 
                   [])
    cls.add_method('setData', 
                   'void', 
                   [param('uint64_t *', 'data'), param('uint64_t', 'size')])
    cls.add_method('setDataSize', 
                   'void', 
                   [param('uint64_t', 'size')])
    cls.add_method('setTags', 
                   'void', 
                   [param('std::string const &', 'jsonString')])
    cls.add_instance_attribute('packet', 'eudaq::AidaPacket *', is_const=False)
    return
Ejemplo n.º 33
0
    def reg_Name(root_module, cls):
        cls.implicitly_converts_to(root_module['ns3::ndn::Interest'])
        cls.add_output_stream_operator()
        for op in ['==', '!=', '<', '<=', '>', '>=']:
            cls.add_binary_comparison_operator(op)
        cls.add_container_traits(retval('const ns3::ndn::name::Component&'),
                                 begin_method='begin',
                                 end_method='end',
                                 iterator_type='const_iterator')

        cls.add_constructor([])
        cls.add_constructor([param('const ns3::ndn::Name&', 'other')])
        cls.add_constructor([param('const std::string&', 'url')])
        cls.add_method('append', 'ns3::ndn::Name &',
                       [param('const ns3::ndn::name::Component&', 'comp')])
        cls.add_method('get',
                       'const ns3::ndn::name::Component&',
                       [param('int', 'index')],
                       is_const=True)
        cls.add_method('getPrefix',
                       'ns3::ndn::Name', [param('size_t', 'len')],
                       is_const=True)
        cls.add_method('size', 'size_t', [], is_const=True)
        cls.add_method('toUri', retval('std::string'), [], is_const=True)
def register_Ns3TopologyReaderLink_methods(root_module, cls):
    ## topology-reader.h: ns3::TopologyReader::Link::Link(ns3::TopologyReader::Link const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::TopologyReader::Link const &', 'arg0')])
    ## topology-reader.h: ns3::TopologyReader::Link::Link(ns3::Ptr<ns3::Node> fromPtr, std::string fromName, ns3::Ptr<ns3::Node> toPtr, std::string toName) [constructor]
    cls.add_constructor([param('ns3::Ptr< ns3::Node >', 'fromPtr'), param('std::string', 'fromName'), param('ns3::Ptr< ns3::Node >', 'toPtr'), param('std::string', 'toName')])
    ## topology-reader.h: std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > ns3::TopologyReader::Link::AttributesBegin() [member function]
    cls.add_method('AttributesBegin', 
                   'std::_Rb_tree_const_iterator< std::pair< std::basic_string< char, std::char_traits< char >, std::allocator< char > > const, std::basic_string< char, std::char_traits< char >, std::allocator< char > > > >', 
                   [])
    ## topology-reader.h: std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > ns3::TopologyReader::Link::AttributesEnd() [member function]
    cls.add_method('AttributesEnd', 
                   'std::_Rb_tree_const_iterator< std::pair< std::basic_string< char, std::char_traits< char >, std::allocator< char > > const, std::basic_string< char, std::char_traits< char >, std::allocator< char > > > >', 
                   [])
    ## topology-reader.h: std::string ns3::TopologyReader::Link::GetAttribute(std::string name) [member function]
    cls.add_method('GetAttribute', 
                   'std::string', 
                   [param('std::string', 'name')])
    ## topology-reader.h: bool ns3::TopologyReader::Link::GetAttributeFailSafe(std::string name, std::string & value) [member function]
    cls.add_method('GetAttributeFailSafe', 
                   'bool', 
                   [param('std::string', 'name'), param('std::string &', 'value')])
    ## topology-reader.h: ns3::Ptr<ns3::Node> ns3::TopologyReader::Link::GetFromNode() const [member function]
    cls.add_method('GetFromNode', 
                   'ns3::Ptr< ns3::Node >', 
                   [], 
                   is_const=True)
    ## topology-reader.h: std::string ns3::TopologyReader::Link::GetFromNodeName() const [member function]
    cls.add_method('GetFromNodeName', 
                   'std::string', 
                   [], 
                   is_const=True)
    ## topology-reader.h: ns3::Ptr<ns3::Node> ns3::TopologyReader::Link::GetToNode() const [member function]
    cls.add_method('GetToNode', 
                   'ns3::Ptr< ns3::Node >', 
                   [], 
                   is_const=True)
    ## topology-reader.h: std::string ns3::TopologyReader::Link::GetToNodeName() const [member function]
    cls.add_method('GetToNodeName', 
                   'std::string', 
                   [], 
                   is_const=True)
    ## topology-reader.h: void ns3::TopologyReader::Link::SetAttribute(std::string name, std::string & value) [member function]
    cls.add_method('SetAttribute', 
                   'void', 
                   [param('std::string', 'name'), param('std::string &', 'value')])
    return
def register_Ns3PacketLossCounter_methods(root_module, cls):
    ## packet-loss-counter.h: ns3::PacketLossCounter::PacketLossCounter(ns3::PacketLossCounter const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::PacketLossCounter const &', 'arg0')])
    ## packet-loss-counter.h: ns3::PacketLossCounter::PacketLossCounter(uint8_t bitmapSize) [constructor]
    cls.add_constructor([param('uint8_t', 'bitmapSize')])
    ## packet-loss-counter.h: uint16_t ns3::PacketLossCounter::GetBitMapSize() const [member function]
    cls.add_method('GetBitMapSize', 
                   'uint16_t', 
                   [], 
                   is_const=True)
    ## packet-loss-counter.h: uint32_t ns3::PacketLossCounter::GetLost() const [member function]
    cls.add_method('GetLost', 
                   'uint32_t', 
                   [], 
                   is_const=True)
    ## packet-loss-counter.h: void ns3::PacketLossCounter::NotifyReceived(uint32_t seq) [member function]
    cls.add_method('NotifyReceived', 
                   'void', 
                   [param('uint32_t', 'seq')])
    ## packet-loss-counter.h: void ns3::PacketLossCounter::SetBitMapSize(uint16_t size) [member function]
    cls.add_method('SetBitMapSize', 
                   'void', 
                   [param('uint16_t', 'size')])
    return
Ejemplo n.º 36
0
def register_Ns3DsdvPacketQueue_methods(root_module, cls):
    ## dsdv-packet-queue.h: ns3::dsdv::PacketQueue::PacketQueue(ns3::dsdv::PacketQueue const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::dsdv::PacketQueue const &', 'arg0')])
    ## dsdv-packet-queue.h: ns3::dsdv::PacketQueue::PacketQueue() [constructor]
    cls.add_constructor([])
    ## dsdv-packet-queue.h: bool ns3::dsdv::PacketQueue::Dequeue(ns3::Ipv4Address dst, ns3::dsdv::QueueEntry & entry) [member function]
    cls.add_method('Dequeue', 'bool', [
        param('ns3::Ipv4Address', 'dst'),
        param('ns3::dsdv::QueueEntry &', 'entry')
    ])
    ## dsdv-packet-queue.h: void ns3::dsdv::PacketQueue::DropPacketWithDst(ns3::Ipv4Address dst) [member function]
    cls.add_method('DropPacketWithDst', 'void',
                   [param('ns3::Ipv4Address', 'dst')])
    ## dsdv-packet-queue.h: bool ns3::dsdv::PacketQueue::Enqueue(ns3::dsdv::QueueEntry & entry) [member function]
    cls.add_method('Enqueue', 'bool',
                   [param('ns3::dsdv::QueueEntry &', 'entry')])
    ## dsdv-packet-queue.h: bool ns3::dsdv::PacketQueue::Find(ns3::Ipv4Address dst) [member function]
    cls.add_method('Find', 'bool', [param('ns3::Ipv4Address', 'dst')])
    ## dsdv-packet-queue.h: uint32_t ns3::dsdv::PacketQueue::GetCountForPacketsWithDst(ns3::Ipv4Address dst) [member function]
    cls.add_method('GetCountForPacketsWithDst', 'uint32_t',
                   [param('ns3::Ipv4Address', 'dst')])
    ## dsdv-packet-queue.h: uint32_t ns3::dsdv::PacketQueue::GetMaxPacketsPerDst() const [member function]
    cls.add_method('GetMaxPacketsPerDst', 'uint32_t', [], is_const=True)
    ## dsdv-packet-queue.h: uint32_t ns3::dsdv::PacketQueue::GetMaxQueueLen() const [member function]
    cls.add_method('GetMaxQueueLen', 'uint32_t', [], is_const=True)
    ## dsdv-packet-queue.h: ns3::Time ns3::dsdv::PacketQueue::GetQueueTimeout() const [member function]
    cls.add_method('GetQueueTimeout', 'ns3::Time', [], is_const=True)
    ## dsdv-packet-queue.h: uint32_t ns3::dsdv::PacketQueue::GetSize() [member function]
    cls.add_method('GetSize', 'uint32_t', [])
    ## dsdv-packet-queue.h: void ns3::dsdv::PacketQueue::SetMaxPacketsPerDst(uint32_t len) [member function]
    cls.add_method('SetMaxPacketsPerDst', 'void', [param('uint32_t', 'len')])
    ## dsdv-packet-queue.h: void ns3::dsdv::PacketQueue::SetMaxQueueLen(uint32_t len) [member function]
    cls.add_method('SetMaxQueueLen', 'void', [param('uint32_t', 'len')])
    ## dsdv-packet-queue.h: void ns3::dsdv::PacketQueue::SetQueueTimeout(ns3::Time t) [member function]
    cls.add_method('SetQueueTimeout', 'void', [param('ns3::Time', 't')])
    return
Ejemplo n.º 37
0
def register_Ns3ConfigStore_methods(root_module, cls):
    ## config-store.h: ns3::ConfigStore::ConfigStore(ns3::ConfigStore const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::ConfigStore const &', 'arg0')])
    ## config-store.h: ns3::ConfigStore::ConfigStore() [constructor]
    cls.add_constructor([])
    ## config-store.h: void ns3::ConfigStore::ConfigureAttributes() [member function]
    cls.add_method('ConfigureAttributes', 
                   'void', 
                   [])
    ## config-store.h: void ns3::ConfigStore::ConfigureDefaults() [member function]
    cls.add_method('ConfigureDefaults', 
                   'void', 
                   [])
    ## config-store.h: ns3::TypeId ns3::ConfigStore::GetInstanceTypeId() const [member function]
    cls.add_method('GetInstanceTypeId', 
                   'ns3::TypeId', 
                   [], 
                   is_const=True, is_virtual=True)
    ## config-store.h: static ns3::TypeId ns3::ConfigStore::GetTypeId() [member function]
    cls.add_method('GetTypeId', 
                   'ns3::TypeId', 
                   [], 
                   is_static=True)
    ## config-store.h: void ns3::ConfigStore::SetFileFormat(ns3::ConfigStore::FileFormat format) [member function]
    cls.add_method('SetFileFormat', 
                   'void', 
                   [param('ns3::ConfigStore::FileFormat', 'format')])
    ## config-store.h: void ns3::ConfigStore::SetFilename(std::string filename) [member function]
    cls.add_method('SetFilename', 
                   'void', 
                   [param('std::string', 'filename')])
    ## config-store.h: void ns3::ConfigStore::SetMode(ns3::ConfigStore::Mode mode) [member function]
    cls.add_method('SetMode', 
                   'void', 
                   [param('ns3::ConfigStore::Mode', 'mode')])
    return
def register_Ns3PppHeader_methods(root_module, cls):
    ## ppp-header.h: ns3::PppHeader::PppHeader(ns3::PppHeader const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::PppHeader const &', 'arg0')])
    ## ppp-header.h: ns3::PppHeader::PppHeader() [constructor]
    cls.add_constructor([])
    ## ppp-header.h: static ns3::TypeId ns3::PppHeader::GetTypeId() [member function]
    cls.add_method('GetTypeId', 
                   'ns3::TypeId', 
                   [], 
                   is_static=True)
    ## ppp-header.h: ns3::TypeId ns3::PppHeader::GetInstanceTypeId() const [member function]
    cls.add_method('GetInstanceTypeId', 
                   'ns3::TypeId', 
                   [], 
                   is_const=True, is_virtual=True)
    ## ppp-header.h: void ns3::PppHeader::Print(std::ostream & os) const [member function]
    cls.add_method('Print', 
                   'void', 
                   [param('std::ostream &', 'os')], 
                   is_const=True, is_virtual=True)
    ## ppp-header.h: void ns3::PppHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
    cls.add_method('Serialize', 
                   'void', 
                   [param('ns3::Buffer::Iterator', 'start')], 
                   is_const=True, is_virtual=True)
    ## ppp-header.h: uint32_t ns3::PppHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
    cls.add_method('Deserialize', 
                   'uint32_t', 
                   [param('ns3::Buffer::Iterator', 'start')], 
                   is_virtual=True)
    ## ppp-header.h: uint32_t ns3::PppHeader::GetSerializedSize() const [member function]
    cls.add_method('GetSerializedSize', 
                   'uint32_t', 
                   [], 
                   is_const=True, is_virtual=True)
    return
Ejemplo n.º 39
0
def register_functions(root_module):
    module = root_module
    ## data-calculator.h: bool ns3::isNaN(double x) [free function]
    module.add_function('isNaN', 
                        'bool', 
                        [param('double', 'x')])
    register_functions_ns3_Config(module.get_submodule('Config'), root_module)
    register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
    register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
    register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
    register_functions_ns3_flame(module.get_submodule('flame'), root_module)
    register_functions_ns3_internal(module.get_submodule('internal'), root_module)
    register_functions_ns3_olsr(module.get_submodule('olsr'), root_module)
    return
Ejemplo n.º 40
0
def register_Ns3RandomWalk2dMobilityModel_methods(root_module, cls):
    ## random-walk-2d-mobility-model.h: ns3::RandomWalk2dMobilityModel::RandomWalk2dMobilityModel() [constructor]
    cls.add_constructor([])
    ## random-walk-2d-mobility-model.h: ns3::RandomWalk2dMobilityModel::RandomWalk2dMobilityModel(ns3::RandomWalk2dMobilityModel const & arg0) [copy constructor]
    cls.add_constructor(
        [param('ns3::RandomWalk2dMobilityModel const &', 'arg0')])
    ## random-walk-2d-mobility-model.h: static ns3::TypeId ns3::RandomWalk2dMobilityModel::GetTypeId() [member function]
    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
    ## random-walk-2d-mobility-model.h: void ns3::RandomWalk2dMobilityModel::DoDispose() [member function]
    cls.add_method('DoDispose',
                   'void', [],
                   visibility='private',
                   is_virtual=True)
    ## random-walk-2d-mobility-model.h: ns3::Vector ns3::RandomWalk2dMobilityModel::DoGetPosition() const [member function]
    cls.add_method('DoGetPosition',
                   'ns3::Vector', [],
                   is_const=True,
                   visibility='private',
                   is_virtual=True)
    ## random-walk-2d-mobility-model.h: ns3::Vector ns3::RandomWalk2dMobilityModel::DoGetVelocity() const [member function]
    cls.add_method('DoGetVelocity',
                   'ns3::Vector', [],
                   is_const=True,
                   visibility='private',
                   is_virtual=True)
    ## random-walk-2d-mobility-model.h: void ns3::RandomWalk2dMobilityModel::DoSetPosition(ns3::Vector const & position) [member function]
    cls.add_method('DoSetPosition',
                   'void', [param('ns3::Vector const &', 'position')],
                   visibility='private',
                   is_virtual=True)
    ## random-walk-2d-mobility-model.h: void ns3::RandomWalk2dMobilityModel::DoStart() [member function]
    cls.add_method('DoStart',
                   'void', [],
                   visibility='private',
                   is_virtual=True)
    return
def register_Ns3Dot11sIeMeshId_methods(root_module, cls):
    cls.add_output_stream_operator()
    cls.add_binary_comparison_operator('==')
    ## ie-dot11s-id.h: ns3::dot11s::IeMeshId::IeMeshId(ns3::dot11s::IeMeshId const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::dot11s::IeMeshId const &', 'arg0')])
    ## ie-dot11s-id.h: ns3::dot11s::IeMeshId::IeMeshId() [constructor]
    cls.add_constructor([])
    ## ie-dot11s-id.h: ns3::dot11s::IeMeshId::IeMeshId(std::string s) [constructor]
    cls.add_constructor([param('std::string', 's')])
    ## ie-dot11s-id.h: uint8_t ns3::dot11s::IeMeshId::DeserializeInformationField(ns3::Buffer::Iterator start, uint8_t length) [member function]
    cls.add_method('DeserializeInformationField', 
                   'uint8_t', 
                   [param('ns3::Buffer::Iterator', 'start'), param('uint8_t', 'length')], 
                   is_virtual=True)
    ## ie-dot11s-id.h: ns3::WifiInformationElementId ns3::dot11s::IeMeshId::ElementId() const [member function]
    cls.add_method('ElementId', 
                   'ns3::WifiInformationElementId', 
                   [], 
                   is_const=True, is_virtual=True)
    ## ie-dot11s-id.h: uint8_t ns3::dot11s::IeMeshId::GetInformationFieldSize() const [member function]
    cls.add_method('GetInformationFieldSize', 
                   'uint8_t', 
                   [], 
                   is_const=True, is_virtual=True)
    ## ie-dot11s-id.h: bool ns3::dot11s::IeMeshId::IsBroadcast() const [member function]
    cls.add_method('IsBroadcast', 
                   'bool', 
                   [], 
                   is_const=True)
    ## ie-dot11s-id.h: bool ns3::dot11s::IeMeshId::IsEqual(ns3::dot11s::IeMeshId const & o) const [member function]
    cls.add_method('IsEqual', 
                   'bool', 
                   [param('ns3::dot11s::IeMeshId const &', 'o')], 
                   is_const=True)
    ## ie-dot11s-id.h: char * ns3::dot11s::IeMeshId::PeekString() const [member function]
    cls.add_method('PeekString', 
                   'char *', 
                   [], 
                   is_const=True)
    ## ie-dot11s-id.h: void ns3::dot11s::IeMeshId::Print(std::ostream & os) const [member function]
    cls.add_method('Print', 
                   'void', 
                   [param('std::ostream &', 'os')], 
                   is_const=True, is_virtual=True)
    ## ie-dot11s-id.h: void ns3::dot11s::IeMeshId::SerializeInformationField(ns3::Buffer::Iterator i) const [member function]
    cls.add_method('SerializeInformationField', 
                   'void', 
                   [param('ns3::Buffer::Iterator', 'i')], 
                   is_const=True, is_virtual=True)
    return
def register_Ns3FlowProbeFlowStats_methods(root_module, cls):
    ## flow-probe.h: ns3::FlowProbe::FlowStats::FlowStats(ns3::FlowProbe::FlowStats const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::FlowProbe::FlowStats const &', 'arg0')])
    ## flow-probe.h: ns3::FlowProbe::FlowStats::FlowStats() [constructor]
    cls.add_constructor([])
    ## flow-probe.h: ns3::FlowProbe::FlowStats::bytes [variable]
    cls.add_instance_attribute('bytes', 'uint64_t', is_const=False)
    ## flow-probe.h: ns3::FlowProbe::FlowStats::bytesDropped [variable]
    cls.add_instance_attribute('bytesDropped', 'std::vector< unsigned long long >', is_const=False)
    ## flow-probe.h: ns3::FlowProbe::FlowStats::delayFromFirstProbeSum [variable]
    cls.add_instance_attribute('delayFromFirstProbeSum', 'ns3::Time', is_const=False)
    ## flow-probe.h: ns3::FlowProbe::FlowStats::packets [variable]
    cls.add_instance_attribute('packets', 'uint32_t', is_const=False)
    ## flow-probe.h: ns3::FlowProbe::FlowStats::packetsDropped [variable]
    cls.add_instance_attribute('packetsDropped', 'std::vector< unsigned int >', is_const=False)
    return
Ejemplo n.º 43
0
def register_Ns3PyVizPacketSample_methods(root_module, cls):
    ## pyviz.h: ns3::PyViz::PacketSample::PacketSample() [constructor]
    cls.add_constructor([])
    ## pyviz.h: ns3::PyViz::PacketSample::PacketSample(ns3::PyViz::PacketSample const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::PyViz::PacketSample const &', 'arg0')])
    ## pyviz.h: ns3::PyViz::PacketSample::device [variable]
    cls.add_instance_attribute('device',
                               'ns3::Ptr< ns3::NetDevice >',
                               is_const=False)
    ## pyviz.h: ns3::PyViz::PacketSample::packet [variable]
    cls.add_instance_attribute('packet',
                               'ns3::Ptr< ns3::Packet >',
                               is_const=False)
    ## pyviz.h: ns3::PyViz::PacketSample::time [variable]
    cls.add_instance_attribute('time', 'ns3::Time', is_const=False)
    return
 def reg_apphelper(cls):
     cls.add_constructor([param('const std::string&', 'prefix')])
     cls.add_method('SetPrefix', 'void',
                    [param('const std::string&', 'prefix')])
     cls.add_method('SetAttribute', 'void', [
         param('std::string', 'name'),
         param('const ns3::AttributeValue&', 'value')
     ])
     cls.add_method('Install', 'ns3::ApplicationContainer',
                    [param('ns3::NodeContainer', 'c')])
     cls.add_method('Install', 'ns3::ApplicationContainer',
                    [param('ns3::Ptr<ns3::Node>', 'node')])
     cls.add_method('Install', 'ns3::ApplicationContainer',
                    [param('std::string', 'nodeName')])
def register_Ns3UdpTraceClient_methods(root_module, cls):
    ## udp-trace-client.h: ns3::UdpTraceClient::UdpTraceClient(ns3::UdpTraceClient const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::UdpTraceClient const &', 'arg0')])
    ## udp-trace-client.h: ns3::UdpTraceClient::UdpTraceClient() [constructor]
    cls.add_constructor([])
    ## udp-trace-client.h: ns3::UdpTraceClient::UdpTraceClient(ns3::Ipv4Address ip, uint16_t port, char * traceFile) [constructor]
    cls.add_constructor([param('ns3::Ipv4Address', 'ip'), param('uint16_t', 'port'), param('char *', 'traceFile')])
    ## udp-trace-client.h: uint16_t ns3::UdpTraceClient::GetMaxPacketSize() [member function]
    cls.add_method('GetMaxPacketSize', 
                   'uint16_t', 
                   [])
    ## udp-trace-client.h: static ns3::TypeId ns3::UdpTraceClient::GetTypeId() [member function]
    cls.add_method('GetTypeId', 
                   'ns3::TypeId', 
                   [], 
                   is_static=True)
    ## udp-trace-client.h: void ns3::UdpTraceClient::SetMaxPacketSize(uint16_t maxPacketSize) [member function]
    cls.add_method('SetMaxPacketSize', 
                   'void', 
                   [param('uint16_t', 'maxPacketSize')])
    ## udp-trace-client.h: void ns3::UdpTraceClient::SetRemote(ns3::Ipv4Address ip, uint16_t port) [member function]
    cls.add_method('SetRemote', 
                   'void', 
                   [param('ns3::Ipv4Address', 'ip'), param('uint16_t', 'port')])
    ## udp-trace-client.h: void ns3::UdpTraceClient::SetTraceFile(std::string filename) [member function]
    cls.add_method('SetTraceFile', 
                   'void', 
                   [param('std::string', 'filename')])
    ## udp-trace-client.h: void ns3::UdpTraceClient::DoDispose() [member function]
    cls.add_method('DoDispose', 
                   'void', 
                   [], 
                   visibility='protected', is_virtual=True)
    ## udp-trace-client.h: void ns3::UdpTraceClient::StartApplication() [member function]
    cls.add_method('StartApplication', 
                   'void', 
                   [], 
                   visibility='private', is_virtual=True)
    ## udp-trace-client.h: void ns3::UdpTraceClient::StopApplication() [member function]
    cls.add_method('StopApplication', 
                   'void', 
                   [], 
                   visibility='private', is_virtual=True)
    return
Ejemplo n.º 46
0
def register_Ns3PyVizPacketCaptureOptions_methods(root_module, cls):
    ## pyviz.h: ns3::PyViz::PacketCaptureOptions::PacketCaptureOptions() [constructor]
    cls.add_constructor([])
    ## pyviz.h: ns3::PyViz::PacketCaptureOptions::PacketCaptureOptions(ns3::PyViz::PacketCaptureOptions const & arg0) [copy constructor]
    cls.add_constructor(
        [param('ns3::PyViz::PacketCaptureOptions const &', 'arg0')])
    ## pyviz.h: ns3::PyViz::PacketCaptureOptions::headers [variable]
    cls.add_instance_attribute('headers',
                               'std::set< ns3::TypeId >',
                               is_const=False)
    ## pyviz.h: ns3::PyViz::PacketCaptureOptions::mode [variable]
    cls.add_instance_attribute('mode',
                               'ns3::PyViz::PacketCaptureMode',
                               is_const=False)
    ## pyviz.h: ns3::PyViz::PacketCaptureOptions::numLastPackets [variable]
    cls.add_instance_attribute('numLastPackets', 'uint32_t', is_const=False)
    return
Ejemplo n.º 47
0
 def reg_NodeContainer(root_module,cls):
     ## node-container.h (module 'network'): ns3::Ptr<ns3::Node> ns3::NodeContainer::Get(uint32_t i) const [member function]
     cls.add_method('Get', 
                'ns3::Ptr< ns3::Node >', 
                [param('uint32_t', 'i')], 
                is_const=True)
     ## node-container.h (module 'network'): uint32_t ns3::NodeContainer::size() const [member function]
     # ZhangYu 2018-1-28, size() donot working, so add GetN
     cls.add_method('size', 
                'uint32_t', 
                [], 
                is_const=True)
     ## node-container.h (module 'network'): uint32_t ns3::NodeContainer::GetN() const [member function]
     cls.add_method('GetN', 
                'uint32_t', 
                [], 
                is_const=True)
Ejemplo n.º 48
0
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
Ejemplo n.º 49
0
def register_Ns3PyVizNetDeviceStatistics_methods(root_module, cls):
    ## pyviz.h: ns3::PyViz::NetDeviceStatistics::NetDeviceStatistics(ns3::PyViz::NetDeviceStatistics const & arg0) [copy constructor]
    cls.add_constructor(
        [param('ns3::PyViz::NetDeviceStatistics const &', 'arg0')])
    ## pyviz.h: ns3::PyViz::NetDeviceStatistics::NetDeviceStatistics() [constructor]
    cls.add_constructor([])
    ## pyviz.h: ns3::PyViz::NetDeviceStatistics::receivedBytes [variable]
    cls.add_instance_attribute('receivedBytes', 'uint64_t', is_const=False)
    ## pyviz.h: ns3::PyViz::NetDeviceStatistics::receivedPackets [variable]
    cls.add_instance_attribute('receivedPackets', 'uint32_t', is_const=False)
    ## pyviz.h: ns3::PyViz::NetDeviceStatistics::transmittedBytes [variable]
    cls.add_instance_attribute('transmittedBytes', 'uint64_t', is_const=False)
    ## pyviz.h: ns3::PyViz::NetDeviceStatistics::transmittedPackets [variable]
    cls.add_instance_attribute('transmittedPackets',
                               'uint32_t',
                               is_const=False)
    return
Ejemplo n.º 50
0
def register_Ns3Rectangle_methods(root_module, cls):
    cls.add_output_stream_operator()
    ## rectangle.h: ns3::Rectangle::Rectangle(ns3::Rectangle const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::Rectangle const &', 'arg0')])
    ## rectangle.h: ns3::Rectangle::Rectangle(double _xMin, double _xMax, double _yMin, double _yMax) [constructor]
    cls.add_constructor([
        param('double', '_xMin'),
        param('double', '_xMax'),
        param('double', '_yMin'),
        param('double', '_yMax')
    ])
    ## rectangle.h: ns3::Rectangle::Rectangle() [constructor]
    cls.add_constructor([])
    ## rectangle.h: ns3::Vector ns3::Rectangle::CalculateIntersection(ns3::Vector const & current, ns3::Vector const & speed) const [member function]
    cls.add_method('CalculateIntersection',
                   'ns3::Vector', [
                       param('ns3::Vector const &', 'current'),
                       param('ns3::Vector const &', 'speed')
                   ],
                   is_const=True)
    ## rectangle.h: ns3::Rectangle::Side ns3::Rectangle::GetClosestSide(ns3::Vector const & position) const [member function]
    cls.add_method('GetClosestSide',
                   'ns3::Rectangle::Side',
                   [param('ns3::Vector const &', 'position')],
                   is_const=True)
    ## rectangle.h: bool ns3::Rectangle::IsInside(ns3::Vector const & position) const [member function]
    cls.add_method('IsInside',
                   'bool', [param('ns3::Vector const &', 'position')],
                   is_const=True)
    ## rectangle.h: ns3::Rectangle::xMax [variable]
    cls.add_instance_attribute('xMax', 'double', is_const=False)
    ## rectangle.h: ns3::Rectangle::xMin [variable]
    cls.add_instance_attribute('xMin', 'double', is_const=False)
    ## rectangle.h: ns3::Rectangle::yMax [variable]
    cls.add_instance_attribute('yMax', 'double', is_const=False)
    ## rectangle.h: ns3::Rectangle::yMin [variable]
    cls.add_instance_attribute('yMin', 'double', is_const=False)
    return
Ejemplo n.º 51
0
 def register_Ns3L2RateTracer_methods(root_module, cls):
     ## l2-rate-tracer.h (module 'ndnSIM'): ns3::L2RateTracer::L2RateTracer(ns3::L2RateTracer const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::L2RateTracer const &', 'arg0')])
     ## l2-rate-tracer.h (module 'ndnSIM'): ns3::L2RateTracer::L2RateTracer(boost::shared_ptr<std::ostream> os, ns3::Ptr<ns3::Node> node) [constructor]
     cls.add_constructor([
         param('boost::shared_ptr< std::ostream >', 'os'),
         param('ns3::Ptr< ns3::Node >', 'node')
     ])
     ## l2-rate-tracer.h (module 'ndnSIM'): static void ns3::L2RateTracer::Destroy() [member function]
     cls.add_method('Destroy', 'void', [], is_static=True)
     ## l2-rate-tracer.h (module 'ndnSIM'): void ns3::L2RateTracer::Drop(ns3::Ptr<ns3::Packet const> arg0) [member function]
     cls.add_method('Drop',
                    'void',
                    [param('ns3::Ptr< ns3::Packet const >', 'arg0')],
                    is_virtual=True)
     ## l2-rate-tracer.h (module 'ndnSIM'): static void ns3::L2RateTracer::InstallAll(std::string const & file, ns3::Time averagingPeriod=ns3::Seconds( )) [member function]
     cls.add_method('InstallAll',
                    'void', [
                        param('std::string const &', 'file'),
                        param('ns3::Time',
                              'averagingPeriod',
                              default_value='ns3::Seconds(0)')
                    ],
                    is_static=True)
     ## l2-rate-tracer.h (module 'ndnSIM'): void ns3::L2RateTracer::Print(std::ostream & os) const [member function]
     cls.add_method('Print',
                    'void', [param('std::ostream &', 'os')],
                    is_const=True,
                    is_virtual=True)
     ## l2-rate-tracer.h (module 'ndnSIM'): void ns3::L2RateTracer::PrintHeader(std::ostream & os) const [member function]
     cls.add_method('PrintHeader',
                    'void', [param('std::ostream &', 'os')],
                    is_const=True,
                    is_virtual=True)
     ## l2-rate-tracer.h (module 'ndnSIM'): void ns3::L2RateTracer::SetAveragingPeriod(ns3::Time const & period) [member function]
     cls.add_method('SetAveragingPeriod', 'void',
                    [param('ns3::Time const &', 'period')])
     return
Ejemplo n.º 52
0
    def add_chuck_vm(self):
        # Depends on:
        self.add_chuck_carrier()
        ChuckObject = self.add_chuck_object()

        ChuckVM = self.add_struct('Chuck_VM', parent=ChuckObject, custom_name='ChuckVM')
        ChuckVM.add_constructor([])
        ChuckVM.add_method(
            'initialize',
            retval('t_CKBOOL'),
            [
                param('t_CKUINT', 'srate'),
                param('t_CKUINT', 'doc_chan'),
                param('t_CKUINT', 'adc_chan'),
                param('t_CKUINT', 'adaptive'),
                param('t_CKBOOL', 'halt'),
            ]
        )
        ChuckVM.add_method(
            'initialize_synthesis',
            retval('t_CKBOOL'),
            []
        )
        ChuckVM.add_method(
            'setCarrier',
            retval('t_CKBOOL'),
            [
                param('Chuck_Carrier *', 'c', transfer_ownership=False),
            ],
            custom_name='set_carrier'
        )
        ChuckVM.add_method(
            'shutdown',
            retval('t_CKBOOL'),
            []
        )
        ChuckVM.add_method(
            'has_init',
            retval('t_CKBOOL'),
            []
        )
        ChuckVM.add_method(
            'start',
            retval('t_CKBOOL'),
            []
        )
        ChuckVM.add_method(
            'stop',
            retval('t_CKBOOL'),
            []
        )
        return ChuckVM
Ejemplo n.º 53
0
def register_Ns3FlowIdTag_methods(root_module, cls):
    ## flow-id-tag.h: ns3::FlowIdTag::FlowIdTag(ns3::FlowIdTag const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::FlowIdTag const &', 'arg0')])
    ## flow-id-tag.h: ns3::FlowIdTag::FlowIdTag() [constructor]
    cls.add_constructor([])
    ## flow-id-tag.h: ns3::FlowIdTag::FlowIdTag(uint32_t flowId) [constructor]
    cls.add_constructor([param('uint32_t', 'flowId')])
    ## flow-id-tag.h: static uint32_t ns3::FlowIdTag::AllocateFlowId() [member function]
    cls.add_method('AllocateFlowId', 
                   'uint32_t', 
                   [], 
                   is_static=True)
    ## flow-id-tag.h: void ns3::FlowIdTag::Deserialize(ns3::TagBuffer buf) [member function]
    cls.add_method('Deserialize', 
                   'void', 
                   [param('ns3::TagBuffer', 'buf')], 
                   is_virtual=True)
    ## flow-id-tag.h: uint32_t ns3::FlowIdTag::GetFlowId() const [member function]
    cls.add_method('GetFlowId', 
                   'uint32_t', 
                   [], 
                   is_const=True)
    ## flow-id-tag.h: ns3::TypeId ns3::FlowIdTag::GetInstanceTypeId() const [member function]
    cls.add_method('GetInstanceTypeId', 
                   'ns3::TypeId', 
                   [], 
                   is_const=True, is_virtual=True)
    ## flow-id-tag.h: uint32_t ns3::FlowIdTag::GetSerializedSize() const [member function]
    cls.add_method('GetSerializedSize', 
                   'uint32_t', 
                   [], 
                   is_const=True, is_virtual=True)
    ## flow-id-tag.h: static ns3::TypeId ns3::FlowIdTag::GetTypeId() [member function]
    cls.add_method('GetTypeId', 
                   'ns3::TypeId', 
                   [], 
                   is_static=True)
    ## flow-id-tag.h: void ns3::FlowIdTag::Print(std::ostream & os) const [member function]
    cls.add_method('Print', 
                   'void', 
                   [param('std::ostream &', 'os')], 
                   is_const=True, is_virtual=True)
    ## flow-id-tag.h: void ns3::FlowIdTag::Serialize(ns3::TagBuffer buf) const [member function]
    cls.add_method('Serialize', 
                   'void', 
                   [param('ns3::TagBuffer', 'buf')], 
                   is_const=True, is_virtual=True)
    ## flow-id-tag.h: void ns3::FlowIdTag::SetFlowId(uint32_t flowId) [member function]
    cls.add_method('SetFlowId', 
                   'void', 
                   [param('uint32_t', 'flowId')])
    return
def register_Ns3Ipv4FlowClassifierFiveTuple_methods(root_module, cls):
    cls.add_binary_comparison_operator('<')
    cls.add_binary_comparison_operator('==')
    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::FiveTuple() [constructor]
    cls.add_constructor([])
    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::FiveTuple(ns3::Ipv4FlowClassifier::FiveTuple const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::Ipv4FlowClassifier::FiveTuple const &', 'arg0')])
    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::destinationAddress [variable]
    cls.add_instance_attribute('destinationAddress', 'ns3::Ipv4Address', is_const=False)
    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::destinationPort [variable]
    cls.add_instance_attribute('destinationPort', 'uint16_t', is_const=False)
    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::protocol [variable]
    cls.add_instance_attribute('protocol', 'uint8_t', is_const=False)
    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::sourceAddress [variable]
    cls.add_instance_attribute('sourceAddress', 'ns3::Ipv4Address', is_const=False)
    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::sourcePort [variable]
    cls.add_instance_attribute('sourcePort', 'uint16_t', is_const=False)
    return
Ejemplo n.º 55
0
def register_Ns3MeshWifiInterfaceMacPlugin_methods(root_module, cls):
    ## mesh-wifi-interface-mac-plugin.h: ns3::MeshWifiInterfaceMacPlugin::MeshWifiInterfaceMacPlugin() [constructor]
    cls.add_constructor([])
    ## mesh-wifi-interface-mac-plugin.h: ns3::MeshWifiInterfaceMacPlugin::MeshWifiInterfaceMacPlugin(ns3::MeshWifiInterfaceMacPlugin const & arg0) [copy constructor]
    cls.add_constructor(
        [param('ns3::MeshWifiInterfaceMacPlugin const &', 'arg0')])
    ## mesh-wifi-interface-mac-plugin.h: bool ns3::MeshWifiInterfaceMacPlugin::Receive(ns3::Ptr<ns3::Packet> packet, ns3::WifiMacHeader const & header) [member function]
    cls.add_method('Receive',
                   'bool', [
                       param('ns3::Ptr< ns3::Packet >', 'packet'),
                       param('ns3::WifiMacHeader const &', 'header')
                   ],
                   is_pure_virtual=True,
                   is_virtual=True)
    ## mesh-wifi-interface-mac-plugin.h: void ns3::MeshWifiInterfaceMacPlugin::SetParent(ns3::Ptr<ns3::MeshWifiInterfaceMac> parent) [member function]
    cls.add_method('SetParent',
                   'void',
                   [param('ns3::Ptr< ns3::MeshWifiInterfaceMac >', 'parent')],
                   is_pure_virtual=True,
                   is_virtual=True)
    ## mesh-wifi-interface-mac-plugin.h: void ns3::MeshWifiInterfaceMacPlugin::UpdateBeacon(ns3::MeshWifiBeacon & beacon) const [member function]
    cls.add_method('UpdateBeacon',
                   'void', [param('ns3::MeshWifiBeacon &', 'beacon')],
                   is_pure_virtual=True,
                   is_const=True,
                   is_virtual=True)
    ## mesh-wifi-interface-mac-plugin.h: bool ns3::MeshWifiInterfaceMacPlugin::UpdateOutcomingFrame(ns3::Ptr<ns3::Packet> packet, ns3::WifiMacHeader & header, ns3::Mac48Address from, ns3::Mac48Address to) [member function]
    cls.add_method('UpdateOutcomingFrame',
                   'bool', [
                       param('ns3::Ptr< ns3::Packet >', 'packet'),
                       param('ns3::WifiMacHeader &', 'header'),
                       param('ns3::Mac48Address', 'from'),
                       param('ns3::Mac48Address', 'to')
                   ],
                   is_pure_virtual=True,
                   is_virtual=True)
    return
def register_Ns3FlowMonitorFlowStats_methods(root_module, cls):
    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::FlowStats() [constructor]
    cls.add_constructor([])
    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::FlowStats(ns3::FlowMonitor::FlowStats const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::FlowMonitor::FlowStats const &', 'arg0')])
    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::bytesDropped [variable]
    cls.add_instance_attribute('bytesDropped', 'std::vector< unsigned long long >', is_const=False)
    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::delayHistogram [variable]
    cls.add_instance_attribute('delayHistogram', 'ns3::Histogram', is_const=False)
    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::delaySum [variable]
    cls.add_instance_attribute('delaySum', 'ns3::Time', is_const=False)
    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::flowInterruptionsHistogram [variable]
    cls.add_instance_attribute('flowInterruptionsHistogram', 'ns3::Histogram', is_const=False)
    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::jitterHistogram [variable]
    cls.add_instance_attribute('jitterHistogram', 'ns3::Histogram', is_const=False)
    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::jitterSum [variable]
    cls.add_instance_attribute('jitterSum', 'ns3::Time', is_const=False)
    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::lastDelay [variable]
    cls.add_instance_attribute('lastDelay', 'ns3::Time', is_const=False)
    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::lostPackets [variable]
    cls.add_instance_attribute('lostPackets', 'uint32_t', is_const=False)
    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::packetSizeHistogram [variable]
    cls.add_instance_attribute('packetSizeHistogram', 'ns3::Histogram', is_const=False)
    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::packetsDropped [variable]
    cls.add_instance_attribute('packetsDropped', 'std::vector< unsigned int >', is_const=False)
    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::rxBytes [variable]
    cls.add_instance_attribute('rxBytes', 'uint64_t', is_const=False)
    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::rxPackets [variable]
    cls.add_instance_attribute('rxPackets', 'uint32_t', is_const=False)
    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::timeFirstRxPacket [variable]
    cls.add_instance_attribute('timeFirstRxPacket', 'ns3::Time', is_const=False)
    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::timeFirstTxPacket [variable]
    cls.add_instance_attribute('timeFirstTxPacket', 'ns3::Time', is_const=False)
    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::timeLastRxPacket [variable]
    cls.add_instance_attribute('timeLastRxPacket', 'ns3::Time', is_const=False)
    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::timeLastTxPacket [variable]
    cls.add_instance_attribute('timeLastTxPacket', 'ns3::Time', is_const=False)
    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::timesForwarded [variable]
    cls.add_instance_attribute('timesForwarded', 'uint32_t', is_const=False)
    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::txBytes [variable]
    cls.add_instance_attribute('txBytes', 'uint64_t', is_const=False)
    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::txPackets [variable]
    cls.add_instance_attribute('txPackets', 'uint32_t', is_const=False)
    return
Ejemplo n.º 57
0
def define_interface(root, cls, selfname):

    cls.add_method('Wait', 'bool', [
        param('double',
              'timeout',
              default_value="std::numeric_limits<double>::infinity()")
    ])
    cls.add_method('is_fulfilled', 'bool', [])
    cls.add_method('has_failed', 'bool', [])
    cls.add_method('is_connection_closed', 'bool', [])

    for name in ["uint", "int"]:
        for bits in [8, 16, 32, 64]:
            base = name + str(bits)
            tname = base + "_t"
            cname = base.capitalize()
            cls.add_method('As< %s >' % tname,
                           tname, [],
                           custom_name="As" + cname)
Ejemplo n.º 58
0
def register_Ns3PyVizLastPacketsSample_methods(root_module, cls):
    ## pyviz.h: ns3::PyViz::LastPacketsSample::LastPacketsSample() [constructor]
    cls.add_constructor([])
    ## pyviz.h: ns3::PyViz::LastPacketsSample::LastPacketsSample(ns3::PyViz::LastPacketsSample const & arg0) [copy constructor]
    cls.add_constructor(
        [param('ns3::PyViz::LastPacketsSample const &', 'arg0')])
    ## pyviz.h: ns3::PyViz::LastPacketsSample::lastDroppedPackets [variable]
    cls.add_instance_attribute('lastDroppedPackets',
                               'std::vector< ns3::PyViz::PacketSample >',
                               is_const=False)
    ## pyviz.h: ns3::PyViz::LastPacketsSample::lastReceivedPackets [variable]
    cls.add_instance_attribute('lastReceivedPackets',
                               'std::vector< ns3::PyViz::RxPacketSample >',
                               is_const=False)
    ## pyviz.h: ns3::PyViz::LastPacketsSample::lastTransmittedPackets [variable]
    cls.add_instance_attribute('lastTransmittedPackets',
                               'std::vector< ns3::PyViz::TxPacketSample >',
                               is_const=False)
    return
Ejemplo n.º 59
0
def register_Ns3CsmaStarHelper_methods(root_module, cls):
    ## csma-star-helper.h: ns3::CsmaStarHelper::CsmaStarHelper(ns3::CsmaStarHelper const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::CsmaStarHelper const &', 'arg0')])
    ## csma-star-helper.h: ns3::CsmaStarHelper::CsmaStarHelper(uint32_t numSpokes, ns3::CsmaHelper csmaHelper) [constructor]
    cls.add_constructor([
        param('uint32_t', 'numSpokes'),
        param('ns3::CsmaHelper', 'csmaHelper')
    ])
    ## csma-star-helper.h: void ns3::CsmaStarHelper::AssignIpv4Addresses(ns3::Ipv4AddressHelper address) [member function]
    cls.add_method('AssignIpv4Addresses', 'void',
                   [param('ns3::Ipv4AddressHelper', 'address')])
    ## csma-star-helper.h: ns3::Ptr<ns3::Node> ns3::CsmaStarHelper::GetHub() const [member function]
    cls.add_method('GetHub', 'ns3::Ptr< ns3::Node >', [], is_const=True)
    ## csma-star-helper.h: ns3::NetDeviceContainer ns3::CsmaStarHelper::GetHubDevices() const [member function]
    cls.add_method('GetHubDevices',
                   'ns3::NetDeviceContainer', [],
                   is_const=True)
    ## csma-star-helper.h: ns3::Ipv4Address ns3::CsmaStarHelper::GetHubIpv4Address(uint32_t i) const [member function]
    cls.add_method('GetHubIpv4Address',
                   'ns3::Ipv4Address', [param('uint32_t', 'i')],
                   is_const=True)
    ## csma-star-helper.h: ns3::NetDeviceContainer ns3::CsmaStarHelper::GetSpokeDevices() const [member function]
    cls.add_method('GetSpokeDevices',
                   'ns3::NetDeviceContainer', [],
                   is_const=True)
    ## csma-star-helper.h: ns3::Ipv4Address ns3::CsmaStarHelper::GetSpokeIpv4Address(uint32_t i) const [member function]
    cls.add_method('GetSpokeIpv4Address',
                   'ns3::Ipv4Address', [param('uint32_t', 'i')],
                   is_const=True)
    ## csma-star-helper.h: ns3::Ptr<ns3::Node> ns3::CsmaStarHelper::GetSpokeNode(uint32_t i) const [member function]
    cls.add_method('GetSpokeNode',
                   'ns3::Ptr< ns3::Node >', [param('uint32_t', 'i')],
                   is_const=True)
    ## csma-star-helper.h: void ns3::CsmaStarHelper::InstallStack(ns3::InternetStackHelper stack) [member function]
    cls.add_method('InstallStack', 'void',
                   [param('ns3::InternetStackHelper', 'stack')])
    ## csma-star-helper.h: uint32_t ns3::CsmaStarHelper::SpokeCount() const [member function]
    cls.add_method('SpokeCount', 'uint32_t', [], is_const=True)
    return
 def reg_GlobalRoutingHelper(cls):
     cls.add_constructor([])
     cls.add_method('Install', 'void',
                    [param('ns3::Ptr<ns3::Node>', 'node')])
     cls.add_method('Install', 'void',
                    [param('const ns3::NodeContainer&', 'nodes')])
     cls.add_method('InstallAll', 'void', [])
     cls.add_method('AddOrigin', 'void', [
         param('const std::string&', 'prefix'),
         param('ns3::Ptr<ns3::Node>', 'node')
     ])
     cls.add_method('AddOrigin', 'void', [
         param('const std::string&', 'prefix'),
         param('const std::string&', 'nodeName')
     ])
     cls.add_method('AddOrigins', 'void', [
         param('const std::string&', 'prefix'),
         param('const ns3::NodeContainer&', 'nodes')
     ])
     cls.add_method('AddOriginsForAll', 'void', [])
     cls.add_method('CalculateRoutes', 'void', [])
     cls.add_method('CalculateAllPossibleRoutes', 'void', [])