private ShapeWaitSet CreateSquareReader() { DataReaderQos qos = GetDataReaderQos(); ITopicDescription topic = null; if (_config.ReaderFilterConfig.Enabled) { string filter = _config.ReaderFilterConfig.FilterKind == FilterKind.Inside ? FILTER_INSIDE : FILTER_OUTSIDE; topic = _participant.CreateContentFilteredTopic("CFSquare" + (++_cfSquareCount), _squareTopic, filter, _config.ReaderFilterConfig.X0.ToString(), _config.ReaderFilterConfig.X1.ToString(), _config.ReaderFilterConfig.Y0.ToString(), _config.ReaderFilterConfig.Y1.ToString()); } else { topic = _squareTopic; } DataReader reader = _subscriber.CreateDataReader(topic, qos); if (reader == null) { throw new Exception("Could not create square data reader"); } ShapeTypeDataReader squareDataReader = new ShapeTypeDataReader(reader); return(new ShapeWaitSet(squareDataReader, SquareTopicDataAvailable)); }
public void TestGetPublicationMatchedStatus() { // Initialize entities DataWriterQos qos = new DataWriterQos(); qos.Reliability.Kind = ReliabilityQosPolicyKind.BestEffortReliabilityQos; DataWriter writer = _publisher.CreateDataWriter(_topic, qos); Assert.IsNotNull(writer); // If not datareaders are created should return the default status PublicationMatchedStatus status = default; ReturnCode result = writer.GetPublicationMatchedStatus(ref status); Assert.AreEqual(ReturnCode.Ok, result); Assert.AreEqual(0, status.CurrentCount); Assert.AreEqual(0, status.CurrentCountChange); Assert.AreEqual(0, status.TotalCount); Assert.AreEqual(0, status.TotalCountChange); Assert.AreEqual(InstanceHandle.HandleNil, status.LastSubscriptionHandle); // Create a not compatible reader Subscriber subscriber = _participant.CreateSubscriber(); Assert.IsNotNull(subscriber); DataReaderQos drQos = new DataReaderQos(); drQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos; DataReader reader = subscriber.CreateDataReader(_topic, drQos); Assert.IsNotNull(reader); // Wait for discovery and check the status System.Threading.Thread.Sleep(100); result = writer.GetPublicationMatchedStatus(ref status); Assert.AreEqual(ReturnCode.Ok, result); Assert.AreEqual(0, status.CurrentCount); Assert.AreEqual(0, status.CurrentCountChange); Assert.AreEqual(0, status.TotalCount); Assert.AreEqual(0, status.TotalCountChange); Assert.AreEqual(InstanceHandle.HandleNil, status.LastSubscriptionHandle); // Create a compatible reader DataReader otherReader = subscriber.CreateDataReader(_topic); Assert.IsNotNull(otherReader); // Wait for discovery and check the status System.Threading.Thread.Sleep(100); result = writer.GetPublicationMatchedStatus(ref status); Assert.AreEqual(ReturnCode.Ok, result); Assert.AreEqual(1, status.CurrentCount); Assert.AreEqual(1, status.CurrentCountChange); Assert.AreEqual(1, status.TotalCount); Assert.AreEqual(1, status.TotalCountChange); Assert.AreEqual(otherReader.InstanceHandle, status.LastSubscriptionHandle); }
public void TestGetMatchedSubscriptions() { // Initialize entities DataWriterQos qos = new DataWriterQos(); qos.Reliability.Kind = ReliabilityQosPolicyKind.BestEffortReliabilityQos; DataWriter writer = _publisher.CreateDataWriter(_topic, qos); Assert.IsNotNull(writer); // Test matched subscriptions without any match List <InstanceHandle> list = new List <InstanceHandle> { InstanceHandle.HandleNil, }; ReturnCode result = writer.GetMatchedSubscriptions(list); Assert.AreEqual(ReturnCode.Ok, result); Assert.AreEqual(0, list.Count); // Create a not compatible reader Subscriber subscriber = _participant.CreateSubscriber(); Assert.IsNotNull(subscriber); DataReaderQos drQos = new DataReaderQos(); drQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos; DataReader reader = subscriber.CreateDataReader(_topic, drQos); Assert.IsNotNull(reader); // Wait for discovery and check the matched subscriptions System.Threading.Thread.Sleep(100); result = writer.GetMatchedSubscriptions(list); Assert.AreEqual(ReturnCode.Ok, result); Assert.AreEqual(0, list.Count); // Create a compatible reader DataReader otherReader = subscriber.CreateDataReader(_topic); Assert.IsNotNull(otherReader); // Wait for discovery and check the matched subscriptions System.Threading.Thread.Sleep(100); result = writer.GetMatchedSubscriptions(list); Assert.AreEqual(ReturnCode.Ok, result); Assert.AreEqual(1, list.Count); Assert.AreEqual(otherReader.InstanceHandle, list.First()); // Test with null parameter result = writer.GetMatchedSubscriptions(null); Assert.AreEqual(ReturnCode.BadParameter, result); }
public void TestDeleteContainedEntities() { // Initialize entities TestStructTypeSupport support = new TestStructTypeSupport(); string typeName = support.GetTypeName(); ReturnCode result = support.RegisterType(_participant, typeName); Assert.AreEqual(ReturnCode.Ok, result); Topic topic = _participant.CreateTopic(nameof(TestDeleteContainedEntities), typeName); Assert.IsNotNull(topic); Assert.IsNull(topic.GetListener()); Assert.AreEqual(nameof(TestDeleteContainedEntities), topic.Name); Assert.AreEqual(typeName, topic.TypeName); Subscriber subscriber = _participant.CreateSubscriber(); Assert.IsNotNull(subscriber); // Call DeleteContainedEntities in an empty subscriber result = subscriber.DeleteContainedEntities(); Assert.AreEqual(ReturnCode.Ok, result); // Create a DataReader in the subscriber DataReader dataReader = subscriber.CreateDataReader(topic); Assert.IsNotNull(subscriber); // Try to delete the publisher without delete the datareader result = _participant.DeleteSubscriber(subscriber); Assert.AreEqual(ReturnCode.PreconditionNotMet, result); // Call DeleteContainedEntities and remove the subscriber again result = subscriber.DeleteContainedEntities(); Assert.AreEqual(ReturnCode.Ok, result); result = _participant.DeleteSubscriber(subscriber); Assert.AreEqual(ReturnCode.Ok, result); // Create a DataReader with null parameter DataReader nullDataReader = subscriber.CreateDataReader(null); Assert.IsNull(nullDataReader); // Create DataReader with incorrect qos DataReaderQos drQos = new DataReaderQos(); drQos.ResourceLimits.MaxSamples = 1; drQos.ResourceLimits.MaxSamplesPerInstance = 2; nullDataReader = subscriber.CreateDataReader(topic, drQos); Assert.IsNull(nullDataReader); }
public void TestLookupDataReader() { // Initialize entities TestStructTypeSupport support = new TestStructTypeSupport(); string typeName = support.GetTypeName(); ReturnCode result = support.RegisterType(_participant, typeName); Assert.AreEqual(ReturnCode.Ok, result); Topic topic = _participant.CreateTopic(nameof(TestLookupDataReader), typeName); Assert.IsNotNull(topic); Assert.IsNull(topic.GetListener()); Assert.AreEqual(nameof(TestLookupDataReader), topic.Name); Assert.AreEqual(typeName, topic.TypeName); Subscriber subscriber = _participant.CreateSubscriber(); Assert.IsNotNull(subscriber); Subscriber otherSubscriber = _participant.CreateSubscriber(); Assert.IsNotNull(otherSubscriber); // Create a DataReader and lookup in the subscribers DataReader datareader = subscriber.CreateDataReader(topic); Assert.IsNotNull(datareader); Assert.AreEqual(subscriber, datareader.Subscriber); Assert.IsNull(datareader.GetListener()); DataReader received = subscriber.LookupDataReader(nameof(TestLookupDataReader)); Assert.IsNotNull(received); Assert.AreEqual(datareader, received); received = otherSubscriber.LookupDataReader(nameof(TestLookupDataReader)); Assert.IsNull(received); // Create other DataReader in the same topic and lookup again DataReader otherDatareader = subscriber.CreateDataReader(topic); Assert.IsNotNull(otherDatareader); Assert.AreEqual(subscriber, otherDatareader.Subscriber); Assert.IsNull(otherDatareader.GetListener()); received = subscriber.LookupDataReader(nameof(TestLookupDataReader)); Assert.IsNotNull(received); Assert.IsTrue(datareader == received || otherDatareader == received); received = otherSubscriber.LookupDataReader(nameof(TestLookupDataReader)); Assert.IsNull(received); }
public void TestInitialize() { _participant = AssemblyInitializer.Factory.CreateParticipant(AssemblyInitializer.RTPS_DOMAIN); Assert.IsNotNull(_participant); _participant.BindRtpsUdpTransportConfig(); TestStructTypeSupport support = new TestStructTypeSupport(); string typeName = support.GetTypeName(); ReturnCode result = support.RegisterType(_participant, typeName); Assert.AreEqual(ReturnCode.Ok, result); _topic = _participant.CreateTopic(TestContext.TestName, typeName); Assert.IsNotNull(_topic); Assert.IsNull(_topic.Listener); Assert.AreEqual(TestContext.TestName, _topic.Name); Assert.AreEqual(typeName, _topic.TypeName); _subscriber = _participant.CreateSubscriber(); Assert.IsNotNull(_subscriber); _publisher = _participant.CreatePublisher(); Assert.IsNotNull(_publisher); _writer = _publisher.CreateDataWriter(_topic); Assert.IsNotNull(_writer); _dataWriter = new TestStructDataWriter(_writer); DataReaderQos qos = new DataReaderQos(); qos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos; _reader = _subscriber.CreateDataReader(_topic, qos); Assert.IsNotNull(_reader); }
public void TestWaitForAcknowledgments() { // Initialize entities DataWriter writer = _publisher.CreateDataWriter(_topic); Assert.IsNotNull(writer); TestStructDataWriter dataWriter = new TestStructDataWriter(writer); Subscriber subscriber = _participant.CreateSubscriber(); Assert.IsNotNull(subscriber); DataReaderQos drQos = new DataReaderQos(); drQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos; DataReader reader = subscriber.CreateDataReader(_topic); Assert.IsNotNull(reader); // Write some instances and wait for acknowledgments for (int i = 0; i < 10; i++) { ReturnCode result = dataWriter.Write(new TestStruct { Id = i, }); Assert.AreEqual(ReturnCode.Ok, result); result = dataWriter.WaitForAcknowledgments(new Duration { Seconds = 5 }); Assert.AreEqual(ReturnCode.Ok, result); } }
/// <summary> /// Creates a DomainParticipant, Topic, Subscriber and DataReader<HelloWorld>. /// </summary> public HelloWorldSubscriber(int domainId) { // Enable network capture. // This must be called before any other network capture function, and // before creating any participant for which we want to capture traffic. NetworkCapture.Enable(); // Start communicating in a domain, usually one participant per application // Load QoS profile from USER_QOS_PROFILES.xml file participant = DomainParticipantFactory.Instance.CreateParticipant(domainId); // A Topic has a name and a datatype. Topic <HelloWorld> topic = participant.CreateTopic <HelloWorld>( "Network capture shared memory example"); // Create a subscriber Subscriber subscriber = participant.CreateSubscriber(); // Create a DataReader, loading QoS profile from USER_QOS_PROFILES.xml. reader = subscriber.CreateDataReader(topic); // Obtain the DataReader's Status Condition StatusCondition statusCondition = reader.StatusCondition; // Enable the 'data available' status. statusCondition.EnabledStatuses = StatusMask.DataAvailable; // Associate an event handler with the status condition. // This will run when the condition is triggered, in the context of // the dispatch call (see below) statusCondition.Triggered += ProcessData; // Create a WaitSet and attach the StatusCondition waitset.AttachCondition(statusCondition); }
public override void RunExample(string[] args) { base.RunExample(args); DomainParticipantFactory factory = DomainParticipantFactory.GetInstance(Bootstrap.CreateInstance()); DomainParticipant dp = factory.CreateParticipant(); // Implicitly create TypeSupport and register type: Topic <Greeting> tp = dp.CreateTopic <Greeting>("Greetings Topic"); // Create the publisher Publisher pub = dp.CreatePublisher(); /* DataWriter<Greeting> dw = pub.CreateDataWriter(tp); * */ DataWriter <Greeting> dw = pub.CreateDataWriter <Greeting>(tp, pub.GetDefaultDataWriterQos(), null, null); // Create the subscriber Subscriber sub = dp.CreateSubscriber(); DataReaderListener <Greeting> ls = new MyListener(); /*DataReader<Greeting> dr = sub.CreateDataReader(tp);*/ DataReader <Greeting> dr = sub.CreateDataReader <Greeting>(tp, sub.GetDefaultDataReaderQos(), ls, null); /* * // Now Publish some piece of data * Greeting data = new Greeting("Hello, World with DDS."); * Console.WriteLine("Sending data:\"{0}\"", data.Value); * dw.Write(data); * //and check that the reader has this data * dr.WaitForHistoricalData(10, TimeUnit.SECONDS); * */ int i = 0; // Now Publish some piece of data //Greeting data = new Greeting("Hola Mundo"+ i.ToString()); for (i = 0; i < 1; i++) { Greeting data = new Greeting("Hola Mundo" + i.ToString()); Console.WriteLine("Sending data:\"{0}\"", data.Value); dw.Write(data); dr.WaitForHistoricalData(1500, TimeUnit.MILLISECONDS); } //and check that the reader has this data //dr.WaitForHistoricalData(10000, TimeUnit.SECONDS); dp.Close(); }
public IMessagingReader CreateReader(string topicName, IMessagingCallback callback) { DataReader <T> reader = null; if (parameters.CftSet && topicName == THROUGHPUT_TOPIC_NAME.Value) { reader = subscriber.CreateDataReader <T>( CreateCft( topicName, participant.CreateTopic <T>(topicName)), GetReaderQos(topicName)); } else { // Rti.Config.Logger.Instance.SetVerbosity(Rti.Config.Verbosity.Warning); reader = subscriber.CreateDataReader <T>( participant.CreateTopic <T>(topicName), GetReaderQos(topicName)); } if (callback != null) { reader.DataAvailable += _ => { // This is the equivalent of the On_data_available function. using var samples = reader.Take(); foreach (var sample in samples) { if (sample.Info.ValidData) { callback.ProcessMessage(dataTypeHelper.SampleToMessage(sample.Data)); } } }; reader.StatusCondition.EnabledStatuses = StatusMask.DataAvailable; } else { reader.StatusCondition.EnabledStatuses = StatusMask.None; } return(new RTIReader <T>( reader, dataTypeHelper.Clone(), parameters)); }
public void TestInitialize() { _participant = AssemblyInitializer.Factory.CreateParticipant(AssemblyInitializer.RTPS_DOMAIN); Assert.IsNotNull(_participant); _participant.BindRtpsUdpTransportConfig(); AthleteTypeSupport athleteSupport = new AthleteTypeSupport(); string athleteTypeName = athleteSupport.GetTypeName(); ReturnCode result = athleteSupport.RegisterType(_participant, athleteTypeName); Assert.AreEqual(ReturnCode.Ok, result); _athleteTopic = _participant.CreateTopic("AthleteTopic", athleteTypeName); Assert.IsNotNull(_athleteTopic); Assert.IsNull(_athleteTopic.Listener); Assert.AreEqual("AthleteTopic", _athleteTopic.Name); Assert.AreEqual(athleteTypeName, _athleteTopic.TypeName); ResultTypeSupport resultSupport = new ResultTypeSupport(); string resultTypeName = resultSupport.GetTypeName(); result = resultSupport.RegisterType(_participant, resultTypeName); Assert.AreEqual(ReturnCode.Ok, result); _resultTopic = _participant.CreateTopic("ResultTopic", resultTypeName); Assert.IsNotNull(_resultTopic); Assert.IsNull(_resultTopic.Listener); Assert.AreEqual("ResultTopic", _resultTopic.Name); Assert.AreEqual(resultTypeName, _resultTopic.TypeName); _subscriber = _participant.CreateSubscriber(); Assert.IsNotNull(_subscriber); _publisher = _participant.CreatePublisher(); Assert.IsNotNull(_publisher); _athleteWriter = _publisher.CreateDataWriter(_athleteTopic); Assert.IsNotNull(_athleteWriter); _athleteDataWriter = new AthleteDataWriter(_athleteWriter); Assert.IsNotNull(_athleteDataWriter); _resultWriter = _publisher.CreateDataWriter(_resultTopic); Assert.IsNotNull(_resultWriter); _resultDataWriter = new ResultDataWriter(_resultWriter); Assert.IsNotNull(_resultDataWriter); DataReaderQos qos = new DataReaderQos(); qos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos; _reader = _subscriber.CreateDataReader(_athleteTopic, qos); Assert.IsNotNull(_reader); }
public void TestGetOfferedDeadlineMissedStatus() { // Initialize entities DataWriterQos qos = new DataWriterQos(); qos.Deadline.Period = new Duration { Seconds = 1, }; DataWriter writer = _publisher.CreateDataWriter(_topic, qos); Assert.IsNotNull(writer); TestStructDataWriter dataWriter = new TestStructDataWriter(writer); Subscriber subscriber = _participant.CreateSubscriber(); Assert.IsNotNull(subscriber); DataReader reader = subscriber.CreateDataReader(_topic); Assert.IsNotNull(reader); // Wait for discovery and write an instance bool found = writer.WaitForSubscriptions(1, 1000); Assert.IsTrue(found); dataWriter.Write(new TestStruct { Id = 1, }); // After half second deadline should not be lost yet System.Threading.Thread.Sleep(500); OfferedDeadlineMissedStatus status = default; ReturnCode result = writer.GetOfferedDeadlineMissedStatus(ref status); Assert.AreEqual(ReturnCode.Ok, result); Assert.AreEqual(0, status.TotalCount); Assert.AreEqual(0, status.TotalCountChange); Assert.AreEqual(InstanceHandle.HandleNil, status.LastInstanceHandle); // After one second and a half one deadline should be lost System.Threading.Thread.Sleep(1000); result = writer.GetOfferedDeadlineMissedStatus(ref status); Assert.AreEqual(ReturnCode.Ok, result); Assert.AreEqual(1, status.TotalCount); Assert.AreEqual(1, status.TotalCountChange); Assert.AreNotEqual(InstanceHandle.HandleNil, status.LastInstanceHandle); }
public void TestDeleteDataReader() { // Initialize entities TestStructTypeSupport support = new TestStructTypeSupport(); string typeName = support.GetTypeName(); ReturnCode result = support.RegisterType(_participant, typeName); Assert.AreEqual(ReturnCode.Ok, result); Topic topic = _participant.CreateTopic(nameof(TestDeleteDataReader), typeName); Assert.IsNotNull(topic); Assert.IsNull(topic.GetListener()); Assert.AreEqual(nameof(TestDeleteDataReader), topic.Name); Assert.AreEqual(typeName, topic.TypeName); Subscriber subscriber = _participant.CreateSubscriber(); Assert.IsNotNull(subscriber); Subscriber otherSubscriber = _participant.CreateSubscriber(); Assert.IsNotNull(otherSubscriber); // Create a DataReader and try to delete it with another subscriber DataReader datareader = subscriber.CreateDataReader(topic); Assert.IsNotNull(datareader); Assert.AreEqual(subscriber, datareader.Subscriber); Assert.IsNull(datareader.GetListener()); DataReaderQos qos = new DataReaderQos(); result = datareader.GetQos(qos); Assert.AreEqual(ReturnCode.Ok, result); TestHelper.TestDefaultDataReaderQos(qos); result = otherSubscriber.DeleteDataReader(datareader); Assert.AreEqual(ReturnCode.PreconditionNotMet, result); // Delete the datareader with the correct subscriber result = subscriber.DeleteDataReader(datareader); Assert.AreEqual(ReturnCode.Ok, result); // Try to remove it again result = subscriber.DeleteDataReader(datareader); Assert.AreEqual(ReturnCode.Error, result); // Test with null parameter result = subscriber.DeleteDataReader(null); Assert.AreEqual(ReturnCode.Ok, result); }
/// <summary> /// Creates a DomainParticipant, Topic, Subscriber and DataReader<ShapeType>. /// </summary> public ShapeTypeSubscriber(int domainId, string typeSource = "build") { participant = DomainParticipantFactory.Instance.CreateParticipant(domainId); // Get the ShapeType definition using one of the available options DynamicType type = ShapeTypeHelper.GetShapeType(typeSource); Topic <DynamicData> topic = participant.CreateTopic("Square", type); Subscriber subscriber = participant.CreateSubscriber(); reader = subscriber.CreateDataReader(topic); }
private void RunExample(int domainId, int sampleCount) { // A DomainParticipant allows an application to begin communicating in // a DDS domain. Typically there is one DomainParticipant per application. // DomainParticipant QoS is configured in USER_QOS_PROFILES.xml DomainParticipant participant = DomainParticipantFactory.Instance .CreateParticipant(domainId); // A Topic has a name and a datatype. Create a Topic named // "ChocolateTemperature" with type Temperature // In this example we use a DynamicType defined in XML, which creates // a DynamicData topic. var provider = new QosProvider("../chocolate_factory.xml"); Topic <DynamicData> topic = participant.CreateTopic( "ChocolateTemperature", provider.GetType("Temperature")); // A Subscriber allows an application to create one or more DataReaders // Subscriber QoS is configured in USER_QOS_PROFILES.xml Subscriber subscriber = participant.CreateSubscriber(); // This DataReader reads data of type Temperature on Topic // "ChocolateTemperature". DataReader QoS is configured in // USER_QOS_PROFILES.xml DataReader <DynamicData> reader = subscriber.CreateDataReader(topic); // Obtain the DataReader's Status Condition StatusCondition statusCondition = reader.StatusCondition; // Enable the 'data available' status. statusCondition.EnabledStatuses = StatusMask.DataAvailable; // Associate an event handler with the status condition. // This will run when the condition is triggered, in the context of // the dispatch call (see below) int samplesRead = 0; statusCondition.Triggered += _ => samplesRead += ProcessData(reader); // Create a WaitSet and attach the StatusCondition var waitset = new WaitSet(); waitset.AttachCondition(statusCondition); while (samplesRead < sampleCount && !shutdownRequested) { // Dispatch will call the handlers associated to the WaitSet // conditions when they activate Console.WriteLine("ChocolateTemperature subscriber sleeping for 4 sec..."); waitset.Dispatch(Duration.FromSeconds(4)); } }
public void TestInitialize() { _participant = AssemblyInitializer.Factory.CreateParticipant(AssemblyInitializer.RTPS_DOMAIN); Assert.IsNotNull(_participant); _participant.BindRtpsUdpTransportConfig(); TestStructTypeSupport support = new TestStructTypeSupport(); string typeName = support.GetTypeName(); ReturnCode result = support.RegisterType(_participant, typeName); Assert.AreEqual(ReturnCode.Ok, result); _topic = _participant.CreateTopic(TestContext.TestName, typeName); Assert.IsNotNull(_topic); Assert.IsNull(_topic.GetListener()); Assert.AreEqual(TestContext.TestName, _topic.Name); Assert.AreEqual(typeName, _topic.TypeName); SubscriberQos sQos = new SubscriberQos(); sQos.EntityFactory.AutoenableCreatedEntities = false; sQos.Presentation.OrderedAccess = true; sQos.Presentation.CoherentAccess = true; sQos.Presentation.AccessScope = PresentationQosPolicyAccessScopeKind.InstancePresentationQos; _subscriber = _participant.CreateSubscriber(sQos); Assert.IsNotNull(_subscriber); PublisherQos pQos = new PublisherQos(); pQos.EntityFactory.AutoenableCreatedEntities = false; pQos.Presentation.OrderedAccess = true; pQos.Presentation.CoherentAccess = true; pQos.Presentation.AccessScope = PresentationQosPolicyAccessScopeKind.InstancePresentationQos; _publisher = _participant.CreatePublisher(pQos); Assert.IsNotNull(_publisher); _listener = new MyDataWriterListener(); _writer = _publisher.CreateDataWriter(_topic, _listener); Assert.IsNotNull(_writer); _dataWriter = new TestStructDataWriter(_writer); DataReaderQos qos = new DataReaderQos(); qos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos; _reader = _subscriber.CreateDataReader(_topic, qos); Assert.IsNotNull(_reader); }
public void TestGetOfferedIncompatibleQosStatus() { // Initialize entities DataWriterQos qos = new DataWriterQos(); qos.Reliability.Kind = ReliabilityQosPolicyKind.BestEffortReliabilityQos; DataWriter writer = _publisher.CreateDataWriter(_topic, qos); Assert.IsNotNull(writer); // If not matched readers should retur the default status OfferedIncompatibleQosStatus status = default; ReturnCode result = writer.GetOfferedIncompatibleQosStatus(ref status); Assert.AreEqual(ReturnCode.Ok, result); Assert.AreEqual(0, status.TotalCount); Assert.AreEqual(0, status.TotalCountChange); Assert.IsNotNull(status.Policies); Assert.AreEqual(0, status.Policies.Count); Assert.AreEqual(0, status.LastPolicyId); // Create a not compatible reader Subscriber subscriber = _participant.CreateSubscriber(); Assert.IsNotNull(subscriber); DataReaderQos drQos = new DataReaderQos(); drQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos; DataReader reader = subscriber.CreateDataReader(_topic, drQos); Assert.IsNotNull(reader); // Wait for discovery and check the status System.Threading.Thread.Sleep(100); status = default; result = writer.GetOfferedIncompatibleQosStatus(ref status); Assert.AreEqual(ReturnCode.Ok, result); Assert.AreEqual(1, status.TotalCount); Assert.AreEqual(1, status.TotalCountChange); Assert.AreEqual(11, status.LastPolicyId); Assert.IsNotNull(status.Policies); Assert.AreEqual(1, status.Policies.Count); Assert.AreEqual(1, status.Policies.First().Count); Assert.AreEqual(11, status.Policies.First().PolicyId); }
private static void TestOnInconsistentTopic() { DomainParticipantFactory dpf = ParticipantService.Instance.GetDomainParticipantFactory(); DomainParticipant participant = dpf.CreateParticipant(RTPS_DOMAIN); if (participant == null) { throw new ApplicationException("Failed to create the participant."); } BindRtpsUdpTransportConfig(participant); Subscriber subscriber = participant.CreateSubscriber(); if (subscriber == null) { throw new ApplicationException("Failed to create the subscriber."); } AthleteTypeSupport support = new AthleteTypeSupport(); string typeName = support.GetTypeName(); ReturnCode result = support.RegisterType(participant, typeName); if (result != ReturnCode.Ok) { throw new ApplicationException("Failed to register the type." + result.ToString()); } Topic topic = participant.CreateTopic(nameof(TestOnInconsistentTopic), typeName); if (topic == null) { throw new ApplicationException("Failed to create the topic."); } DataReader reader = subscriber.CreateDataReader(topic); if (reader == null) { throw new ApplicationException("Failed to create the reader."); } while (true) { System.Threading.Thread.Sleep(100); } }
private static void TestOnPublicationLostDisconnected() { DomainParticipantFactory dpf = ParticipantService.Instance.GetDomainParticipantFactory(); DomainParticipant participant = dpf.CreateParticipant(INFOREPO_DOMAIN); if (participant == null) { throw new InvalidOperationException("Failed to create the participant."); } BindTcpTransportConfig(participant); Subscriber subscriber = participant.CreateSubscriber(); if (subscriber == null) { throw new InvalidOperationException("Failed to create the subscriber."); } TestStructTypeSupport support = new TestStructTypeSupport(); string typeName = support.GetTypeName(); ReturnCode result = support.RegisterType(participant, typeName); if (result != ReturnCode.Ok) { throw new InvalidOperationException("Failed to register the type." + result.ToString()); } Topic topic = participant.CreateTopic("TestOnPublicationLostDisconnected", typeName); if (topic == null) { throw new InvalidOperationException("Failed to create the topic."); } DataReader reader = subscriber.CreateDataReader(topic); if (reader == null) { throw new InvalidOperationException("Failed to create the reader."); } while (true) { System.Threading.Thread.Sleep(100); } }
/// <summary> /// Runs the subscriber example. /// </summary> public static async Task RunSubscriber( int domainId, int sampleCount, CancellationToken cancellationToken) { // Start communicating in a domain, usually one participant per application // Load default QoS profile from USER_QOS_PROFILES.xml file using DomainParticipant participant = DomainParticipantFactory.Instance.CreateParticipant(domainId); // A Topic has a name and a datatype. Topic <HelloWorld> topic = participant.CreateTopic <HelloWorld>("Example cfc"); // Create a subscriber Subscriber subscriber = participant.CreateSubscriber(); // Create a DataReader with the default QoS profile defined in // USER_QOS_PROFILES.xml DataReader <HelloWorld> reader = subscriber.CreateDataReader(topic); var beginTime = DateTime.Now; // TakeAsync provides an IAsyncEnumerable that returns new data // samples when they are available, awaiting as necessary. The // cancellation token allows stopping the loop. int samplesRead = 0; await foreach (var sample in reader .TakeAsync() .WithCancellation(cancellationToken)) { if (sample.Info.ValidData) { samplesRead++; var elapsedTime = (DateTime.Now - beginTime).TotalSeconds; Console.WriteLine($"At t={elapsedTime}s, got x={sample.Data.x}"); if (samplesRead == sampleCount) { break; } } } }
/// <summary> /// Creates a DomainParticipant, Topic, Subscriber and DataReader<HelloWorld>. /// </summary> public HelloWorldSubscriber(int domainId, string password, string topicName) { // Configure the DomainParticipantQos add the UserData policy to it. // We're simply converting the input string into bytes, assuming // that only ASCII characters are used to keep the example simple. // We also set the maximum user data length. DomainParticipantQos participantQos = DomainParticipantFactory.Instance.DefaultParticipantQos .WithUserData(new UserData(password.Select(c => (byte)c))) .WithResourceLimits(policy => policy.ParticipantUserDataMaxLength = 1024); // Create the participant with the QoS participant = DomainParticipantFactory.Instance .CreateParticipant(domainId, participantQos); Topic <HelloWorld> topic = participant.CreateTopic <HelloWorld>(topicName); // Create a subscriber and a DataReader Subscriber subscriber = participant.CreateSubscriber(); reader = subscriber.CreateDataReader(topic); }
private void InitializeDDS() { //string id = usuario.Id; string id = "0"; int.TryParse(id, out domainId); // Create the DomainFactory factory = DomainParticipantFactory.GetInstance(Bootstrap.CreateInstance()); // Create the DomainParticipant with reference to the configuration file with the domain ID dp = factory.CreateParticipant(domainId); // Console.WriteLine("Domain ID = {0} has been created", domainId); // Implicitly create TypeSupport and register type: tp = dp.CreateTopic <ChatMessage>("Greetings Topic"); // Create the subscriber sub = dp.CreateSubscriber(); // Create a Listener for the publishing data ls = new MyListener(backgroundWorker1, backgroundWorker2, backgroundWorker3, backgroundWorker4, backgroundWorker5, backgroundWorker6); ls2 = new MyListener2(); // Create the DataReader using the topic, politics of QoS for DataReader and implemented listener dr = sub.CreateDataReader <ChatMessage>(tp, sub.GetDefaultDataReaderQos(), ls, null); // Create the publisher pub = dp.CreatePublisher(); // Create the DataWriter using the topic specified //dw = pub.CreateDataWriter(tp); dw = pub.CreateDataWriter <ChatMessage>(tp, pub.GetDefaultDataWriterQos(), ls2, null); }
/// <summary> /// Runs the subscriber example. /// </summary> public static void RunSubscriber( int domainId = 0, int sampleCount = int.MaxValue) { // A DomainParticipant allows an application to begin communicating in // a DDS domain. Typically there is one DomainParticipant per application. // DomainParticipant QoS is configured in USER_QOS_PROFILES.xml // // A participant needs to be Disposed to release middleware resources. // The 'using' keyword indicates that it will be Disposed when this // scope ends. using DomainParticipant participant = DomainParticipantFactory.Instance.CreateParticipant(domainId); // A Topic has a name and a datatype. Topic <StockPrice> topic = participant.CreateTopic <StockPrice>("Example market_data"); // A Subscriber allows an application to create one or more DataReaders // Subscriber QoS is configured in USER_QOS_PROFILES.xml Subscriber subscriber = participant.CreateSubscriber(); // Create a ContentFiltered Topic and specify the STRINGMATCH filter name // to use a built-in filter for matching multiple strings. // More information can be found in the example var symbolFilter = new Filter( expression: "Symbol MATCH 'A'", parameters: Array.Empty <string>(), name: Filter.StringMatchFilterName); ContentFilteredTopic <StockPrice> filteredTopic = participant.CreateContentFilteredTopic( name: "Filtered Example market_data", relatedTopic: topic, filter: symbolFilter); // Create a reader for the content-filtered topic, and set a // handler for the DataAvailable event that simply prints the data. DataReader <StockPrice> reader = subscriber.CreateDataReader( filteredTopic, preEnableAction: reader => { reader.DataAvailable += _ => PrintData(reader); }); int t = 0; while (receivedSamples < sampleCount) { if (t == 3) { // On t = 3 we add the symbol 'D' to the filter parameter // to match 'A' and 'D'. filteredTopic.AppendToExpressionParameter(0, "D"); Console.WriteLine("Changed filter to Symbol MATCH 'A,D'"); } else if (t == 6) { // On t = 6 we remove the symbol 'A' to the filter parameter // to match only 'D'. filteredTopic.RemoveFromExpressionParameter(0, "A"); Console.WriteLine("Changed filter to Symbol MATCH 'D'"); } Thread.Sleep(4000); t++; } }
private void RunExample(int domainId, string stationKind) { if (!Enum.TryParse <StationKind>(stationKind, out var currentStation)) { throw new ArgumentException("Invalid station"); } // A DomainParticipant allows an application to begin communicating in // a DDS domain. Typically there is one DomainParticipant per application. // Uses TemperingApplication QoS profile to set participant name. var qosProvider = new QosProvider("./qos_profiles.xml"); // By specifying a default library, we can later refer to the // profiles without the library name qosProvider.DefaultLibrary = "ChocolateFactoryLibrary"; DomainParticipant participant = DomainParticipantFactory.Instance .CreateParticipant( domainId, qosProvider.GetDomainParticipantQos("IngredientApplication")); Topic <Temperature> temperatureTopic = participant.CreateTopic <Temperature>("ChocolateTemperature"); Topic <ChocolateLotState> lotStateTopic = participant.CreateTopic <ChocolateLotState>("ChocolateLotState"); ContentFilteredTopic <ChocolateLotState> filteredLotStateTopic = participant.CreateContentFilteredTopic( name: "FilteredLot", relatedTopic: lotStateTopic, filter: new Filter( expression: "next_station = %0", parameters: new string[] { $"'{stationKind}'" })); Publisher publisher = participant.CreatePublisher(); // Create DataWriter of Topic "ChocolateLotState" // using ChocolateLotStateProfile QoS profile for State Data DataWriter <ChocolateLotState> lotStateWriter = publisher.CreateDataWriter( lotStateTopic, qosProvider.GetDataWriterQos("ChocolateLotStateProfile")); Subscriber subscriber = participant.CreateSubscriber(); // Create DataReader of Topic "ChocolateLotState", filtered by // next_station, and using ChocolateLotStateProfile QoS profile for // State Data. DataReader <ChocolateLotState> lotStateReader = subscriber.CreateDataReader( filteredLotStateTopic, qosProvider.GetDataReaderQos("ChocolateLotStateProfile")); // Monitor the DataAvailable status StatusCondition statusCondition = lotStateReader.StatusCondition; statusCondition.EnabledStatuses = StatusMask.DataAvailable; statusCondition.Triggered += _ => ProcessLot(currentStation, lotStateReader, lotStateWriter); var waitset = new WaitSet(); waitset.AttachCondition(statusCondition); while (!shutdownRequested) { // Wait for ChocolateLotState Console.WriteLine("Waiting for lot"); waitset.Dispatch(Duration.FromSeconds(10)); } }
/// <summary> /// Creates a DomainParticipant, Topic, Subscriber and DataReader<Temperature>. /// </summary> public SubscriberApplication(int domainId, bool useXmlQos = true) { // Start communicating in a domain, usually one participant per application // Load QoS profile from USER_QOS_PROFILES.xml file participant = DomainParticipantFactory.Instance.CreateParticipant(domainId); // Create the topics var alarmTopic = participant.CreateTopic <Alarm>("Alarm"); var heartRateTopic = participant.CreateTopic <HeartRate>("HeartRate"); var temperatureTopic = participant.CreateTopic <Temperature>("Temperature"); // Create a subscriber SubscriberQos subscriberQos = null; if (useXmlQos) { // Retrieve the Subscriber QoS, from USER_QOS_PROFILES.xml subscriberQos = QosProvider.Default.GetSubscriberQos(); } else { // Set the Subscriber QoS programatically, to the same effect subscriberQos = participant.DefaultSubscriberQos .WithPresentation(policy => { policy.AccessScope = PresentationAccessScopeKind.Group; policy.CoherentAccess = true; policy.OrderedAccess = true; // Uncomment this line to keep and deliver incomplete // coherent sets to the application // policy.DropIncompleteCoherentSet = false; }); } subscriber = participant.CreateSubscriber(subscriberQos); // Create a DataReader for each topic DataReaderQos readerQos = null; if (useXmlQos) { // Retrieve the DataReader QoS, from USER_QOS_PROFILES.xml readerQos = QosProvider.Default.GetDataReaderQos(); } else { // Set the DataReader QoS programatically, to the same effect readerQos = subscriber.DefaultDataReaderQos .WithReliability(policy => policy.Kind = ReliabilityKind.Reliable) .WithHistory(policy => policy.Kind = HistoryKind.KeepAll); } alarmReader = subscriber.CreateDataReader(alarmTopic, readerQos); heartRateReader = subscriber.CreateDataReader(heartRateTopic, readerQos); temperatureReader = subscriber.CreateDataReader(temperatureTopic, readerQos); // We are monitoring the sample lost status in case an // incomplete coherent set is received and dropped (assuming the // Presentation.DropIncompleteCoherentSet is true (the default)) alarmReader.SampleLost += OnSampleLost; heartRateReader.SampleLost += OnSampleLost; temperatureReader.SampleLost += OnSampleLost; }
public void TestSetDefaultDataReaderQos() { // Initialize entities TestStructTypeSupport support = new TestStructTypeSupport(); string typeName = support.GetTypeName(); ReturnCode result = support.RegisterType(_participant, typeName); Assert.AreEqual(ReturnCode.Ok, result); Topic topic = _participant.CreateTopic(nameof(TestSetDefaultDataReaderQos), typeName); Assert.IsNotNull(topic); Assert.IsNull(topic.GetListener()); Assert.AreEqual(nameof(TestSetDefaultDataReaderQos), topic.Name); Assert.AreEqual(typeName, topic.TypeName); Subscriber subscriber = _participant.CreateSubscriber(); Assert.IsNotNull(subscriber); // Creates a non-default QoS, set it an check it DataReaderQos qos = TestHelper.CreateNonDefaultDataReaderQos(); result = subscriber.SetDefaultDataReaderQos(qos); Assert.AreEqual(ReturnCode.Ok, result); qos = new DataReaderQos(); result = subscriber.GetDefaultDataReaderQos(qos); Assert.AreEqual(ReturnCode.Ok, result); TestHelper.TestNonDefaultDataReaderQos(qos); DataReader reader = subscriber.CreateDataReader(topic); Assert.IsNotNull(reader); qos = new DataReaderQos(); result = reader.GetQos(qos); Assert.AreEqual(ReturnCode.Ok, result); TestHelper.TestNonDefaultDataReaderQos(qos); // Put back the default QoS and check it qos = new DataReaderQos(); result = subscriber.SetDefaultDataReaderQos(qos); Assert.AreEqual(ReturnCode.Ok, result); qos = TestHelper.CreateNonDefaultDataReaderQos(); result = subscriber.GetDefaultDataReaderQos(qos); Assert.AreEqual(ReturnCode.Ok, result); TestHelper.TestDefaultDataReaderQos(qos); DataReader otherReader = subscriber.CreateDataReader(topic); Assert.IsNotNull(otherReader); qos = TestHelper.CreateNonDefaultDataReaderQos(); result = otherReader.GetQos(qos); Assert.AreEqual(ReturnCode.Ok, result); TestHelper.TestDefaultDataReaderQos(qos); // Create an inconsistent QoS and try to set it qos = TestHelper.CreateNonDefaultDataReaderQos(); qos.TimeBasedFilter.MinimumSeparation = new Duration { Seconds = 5, NanoSeconds = 5 }; result = subscriber.SetDefaultDataReaderQos(qos); Assert.AreEqual(ReturnCode.InconsistentPolicy, result); // Test SetDefaultDataReaderQos with null parametr result = subscriber.SetDefaultDataReaderQos(null); Assert.AreEqual(ReturnCode.BadParameter, result); }
public void TestCreateDataReaderr() { // Initialize entities TestStructTypeSupport support = new TestStructTypeSupport(); string typeName = support.GetTypeName(); ReturnCode result = support.RegisterType(_participant, typeName); Assert.AreEqual(ReturnCode.Ok, result); Topic topic = _participant.CreateTopic(nameof(TestCreateDataReaderr), typeName); Assert.IsNotNull(topic); Assert.IsNull(topic.GetListener()); Assert.AreEqual(nameof(TestCreateDataReaderr), topic.Name); Assert.AreEqual(typeName, topic.TypeName); Subscriber subscriber = _participant.CreateSubscriber(); Assert.IsNotNull(subscriber); // Test simplest overload DataReader datareader1 = subscriber.CreateDataReader(topic); Assert.IsNotNull(datareader1); Assert.AreEqual(subscriber, datareader1.Subscriber); Assert.IsNull(datareader1.GetListener()); DataReaderQos qos = new DataReaderQos(); result = datareader1.GetQos(qos); Assert.AreEqual(ReturnCode.Ok, result); TestHelper.TestDefaultDataReaderQos(qos); // Test overload with QoS parameter qos = TestHelper.CreateNonDefaultDataReaderQos(); DataReader datareader2 = subscriber.CreateDataReader(topic, qos); Assert.IsNotNull(datareader2); Assert.AreEqual(subscriber, datareader2.Subscriber); Assert.IsNull(datareader2.GetListener()); qos = new DataReaderQos(); result = datareader2.GetQos(qos); Assert.AreEqual(ReturnCode.Ok, result); TestHelper.TestNonDefaultDataReaderQos(qos); // Test overload with listener parameter MyDataReaderListener listener = new MyDataReaderListener(); DataReader datareader3 = subscriber.CreateDataReader(topic, listener); Assert.IsNotNull(datareader3); Assert.AreEqual(subscriber, datareader3.Subscriber); MyDataReaderListener received = (MyDataReaderListener)datareader3.GetListener(); Assert.IsNotNull(received); Assert.AreEqual(listener, received); qos = new DataReaderQos(); result = datareader3.GetQos(qos); Assert.AreEqual(ReturnCode.Ok, result); TestHelper.TestDefaultDataReaderQos(qos); // Test overload with listener and StatusMask parameters listener = new MyDataReaderListener(); DataReader datareader4 = subscriber.CreateDataReader(topic, listener, StatusMask.AllStatusMask); Assert.IsNotNull(datareader4); Assert.AreEqual(subscriber, datareader4.Subscriber); received = (MyDataReaderListener)datareader4.GetListener(); Assert.IsNotNull(received); Assert.AreEqual(listener, received); qos = new DataReaderQos(); result = datareader4.GetQos(qos); Assert.AreEqual(ReturnCode.Ok, result); TestHelper.TestDefaultDataReaderQos(qos); // Test overload with QoS and listener parameters qos = TestHelper.CreateNonDefaultDataReaderQos(); listener = new MyDataReaderListener(); DataReader datareader5 = subscriber.CreateDataReader(topic, qos, listener); Assert.IsNotNull(datareader5); Assert.AreEqual(subscriber, datareader5.Subscriber); received = (MyDataReaderListener)datareader5.GetListener(); Assert.IsNotNull(received); Assert.AreEqual(listener, received); qos = new DataReaderQos(); result = datareader5.GetQos(qos); Assert.AreEqual(ReturnCode.Ok, result); TestHelper.TestNonDefaultDataReaderQos(qos); // Test full call overload qos = TestHelper.CreateNonDefaultDataReaderQos(); listener = new MyDataReaderListener(); DataReader datareader6 = subscriber.CreateDataReader(topic, qos, listener, StatusMask.AllStatusMask); Assert.IsNotNull(datareader6); Assert.AreEqual(subscriber, datareader6.Subscriber); received = (MyDataReaderListener)datareader6.GetListener(); Assert.IsNotNull(received); Assert.AreEqual(listener, received); qos = new DataReaderQos(); result = datareader6.GetQos(qos); Assert.AreEqual(ReturnCode.Ok, result); TestHelper.TestNonDefaultDataReaderQos(qos); }
public void TestBeginEndAccess() { // OpenDDS Issue: Coherent sets for PRESENTATION QoS not Currently implemented on RTPS. // Just prepare the unit test for the moment. // Initialize entities TestStructTypeSupport support = new TestStructTypeSupport(); string typeName = support.GetTypeName(); ReturnCode result = support.RegisterType(_participant, typeName); Assert.AreEqual(ReturnCode.Ok, result); Topic topic = _participant.CreateTopic(nameof(TestNotifyDataReaders), typeName); Assert.IsNotNull(topic); Assert.IsNull(topic.GetListener()); Assert.AreEqual(nameof(TestNotifyDataReaders), topic.Name); Assert.AreEqual(typeName, topic.TypeName); Topic otherTopic = _participant.CreateTopic("Other" + nameof(TestNotifyDataReaders), typeName); Assert.IsNotNull(otherTopic); Assert.IsNull(otherTopic.GetListener()); Assert.AreEqual("Other" + nameof(TestNotifyDataReaders), otherTopic.Name); Assert.AreEqual(typeName, otherTopic.TypeName); PublisherQos pubQos = new PublisherQos(); pubQos.Presentation.AccessScope = PresentationQosPolicyAccessScopeKind.GroupPresentationQos; pubQos.Presentation.CoherentAccess = true; pubQos.Presentation.OrderedAccess = true; Publisher publisher = _participant.CreatePublisher(pubQos); Assert.IsNotNull(publisher); DataWriter writer = publisher.CreateDataWriter(topic); Assert.IsNotNull(writer); TestStructDataWriter dataWriter = new TestStructDataWriter(writer); DataWriter otherWriter = publisher.CreateDataWriter(otherTopic); Assert.IsNotNull(otherWriter); TestStructDataWriter otherDataWriter = new TestStructDataWriter(otherWriter); SubscriberQos subQos = new SubscriberQos(); subQos.Presentation.AccessScope = PresentationQosPolicyAccessScopeKind.GroupPresentationQos; subQos.Presentation.CoherentAccess = true; subQos.Presentation.OrderedAccess = true; MySubscriberListener listener = new MySubscriberListener(); listener.DataOnReaders += (sub) => { result = sub.BeginAccess(); Assert.AreEqual(ReturnCode.Ok, result); List <DataReader> list = new List <DataReader>(); result = sub.GetDataReaders(list); // Here we should check that we received two DataReader // read the data of each one and confirm tha the group coherent access // is working as expected. result = sub.EndAccess(); Assert.AreEqual(ReturnCode.Ok, result); }; Subscriber subscriber = _participant.CreateSubscriber(subQos, listener); Assert.IsNotNull(subscriber); DataReader reader = subscriber.CreateDataReader(topic); Assert.IsNotNull(reader); TestStructDataReader dataReader = new TestStructDataReader(reader); DataReader otherReader = subscriber.CreateDataReader(otherTopic); Assert.IsNotNull(otherReader); TestStructDataReader otherDataReader = new TestStructDataReader(otherReader); // Call EndAccess without calling first BeginAccess result = subscriber.EndAccess(); Assert.AreEqual(ReturnCode.PreconditionNotMet, result); // Publish a samples in both topics result = publisher.BeginCoherentChanges(); Assert.AreEqual(ReturnCode.Ok, result); result = dataWriter.Write(new TestStruct { Id = 1 }); Assert.AreEqual(ReturnCode.Ok, result); result = otherDataWriter.Write(new TestStruct { Id = 1 }); Assert.AreEqual(ReturnCode.Ok, result); result = publisher.EndCoherentChanges(); Assert.AreEqual(ReturnCode.Ok, result); // Give some time to the subscriber to process the messages System.Threading.Thread.Sleep(500); }
public void TestGetDataReaders() { // Initialize entities TestStructTypeSupport support = new TestStructTypeSupport(); string typeName = support.GetTypeName(); ReturnCode result = support.RegisterType(_participant, typeName); Assert.AreEqual(ReturnCode.Ok, result); Topic topic = _participant.CreateTopic(nameof(TestNotifyDataReaders), typeName); Assert.IsNotNull(topic); Assert.IsNull(topic.GetListener()); Assert.AreEqual(nameof(TestNotifyDataReaders), topic.Name); Assert.AreEqual(typeName, topic.TypeName); Topic otherTopic = _participant.CreateTopic("Other" + nameof(TestNotifyDataReaders), typeName); Assert.IsNotNull(otherTopic); Assert.IsNull(otherTopic.GetListener()); Assert.AreEqual("Other" + nameof(TestNotifyDataReaders), otherTopic.Name); Assert.AreEqual(typeName, otherTopic.TypeName); Publisher publisher = _participant.CreatePublisher(); Assert.IsNotNull(publisher); DataWriter writer = publisher.CreateDataWriter(topic); Assert.IsNotNull(writer); TestStructDataWriter dataWriter = new TestStructDataWriter(writer); DataWriter otherWriter = publisher.CreateDataWriter(otherTopic); Assert.IsNotNull(otherWriter); TestStructDataWriter otherDataWriter = new TestStructDataWriter(otherWriter); Subscriber subscriber = _participant.CreateSubscriber(); Assert.IsNotNull(subscriber); DataReader reader = subscriber.CreateDataReader(topic); Assert.IsNotNull(reader); TestStructDataReader dataReader = new TestStructDataReader(reader); DataReader otherReader = subscriber.CreateDataReader(otherTopic); Assert.IsNotNull(otherReader); TestStructDataReader otherDataReader = new TestStructDataReader(otherReader); // Check that the GetDataReaders without sending any sample List <DataReader> list = new List <DataReader>(); result = subscriber.GetDataReaders(list); Assert.AreEqual(ReturnCode.Ok, result); Assert.AreEqual(0, list.Count); // Publish in the topic and check again result = dataWriter.Write(new TestStruct { Id = 1 }); Assert.AreEqual(ReturnCode.Ok, result); System.Threading.Thread.Sleep(100); result = subscriber.GetDataReaders(list); Assert.AreEqual(ReturnCode.Ok, result); Assert.AreEqual(1, list.Count); // Publish in the otherTopic and check again result = otherDataWriter.Write(new TestStruct { Id = 1 }); Assert.AreEqual(ReturnCode.Ok, result); System.Threading.Thread.Sleep(100); result = subscriber.GetDataReaders(list, SampleStateKind.NotReadSampleState | SampleStateKind.ReadSampleState, ViewStateMask.AnyViewState, InstanceStateMask.AnyInstanceState); Assert.AreEqual(ReturnCode.Ok, result); Assert.AreEqual(2, list.Count); // Take from both DataReaders and check again List <TestStruct> received = new List <TestStruct>(); List <SampleInfo> sampleInfos = new List <SampleInfo>(); result = dataReader.Take(received, sampleInfos); Assert.AreEqual(ReturnCode.Ok, result); result = otherDataReader.Take(received, sampleInfos); Assert.AreEqual(ReturnCode.Ok, result); result = subscriber.GetDataReaders(list); Assert.AreEqual(ReturnCode.Ok, result); Assert.AreEqual(0, list.Count); // Test GetDataReaders with null parameter result = subscriber.GetDataReaders(null); Assert.AreEqual(ReturnCode.BadParameter, result); }
public void TestNotifyDataReaders() { // Initialize entities TestStructTypeSupport support = new TestStructTypeSupport(); string typeName = support.GetTypeName(); ReturnCode result = support.RegisterType(_participant, typeName); Assert.AreEqual(ReturnCode.Ok, result); Topic topic = _participant.CreateTopic(nameof(TestNotifyDataReaders), typeName); Assert.IsNotNull(topic); Assert.IsNull(topic.GetListener()); Assert.AreEqual(nameof(TestNotifyDataReaders), topic.Name); Assert.AreEqual(typeName, topic.TypeName); Publisher publisher = _participant.CreatePublisher(); Assert.IsNotNull(publisher); DataWriter writer = publisher.CreateDataWriter(topic); Assert.IsNotNull(writer); TestStructDataWriter dataWriter = new TestStructDataWriter(writer); int subscriberReceived = 0; int readerReceived = 0; // Create the Subscriber and the DataReader with the corresponding listeners MySubscriberListener subListener = new MySubscriberListener(); subListener.DataOnReaders += (sub) => { subscriberReceived++; if (subscriberReceived % 2 == 0) { sub.NotifyDataReaders(); } }; Subscriber subscriber = _participant.CreateSubscriber(subListener); Assert.IsNotNull(subscriber); MyDataReaderListener readListener = new MyDataReaderListener(); readListener.DataAvailable += (read) => { readerReceived++; }; DataReader reader = subscriber.CreateDataReader(topic, readListener); Assert.IsNotNull(reader); System.Threading.Thread.Sleep(100); // Publish instances for (int i = 0; i < 10; i++) { dataWriter.Write(new TestStruct { Id = i, ShortType = (short)i }); System.Threading.Thread.Sleep(100); } System.Threading.Thread.Sleep(100); // Check the received instances Assert.AreEqual(10, subscriberReceived); Assert.AreEqual(5, readerReceived); }