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 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);
}
}
public DomainParticipantTransportSource(IDomainParticipant participant, string senderTopic, string receiverTopic)
{
_participant = participant;
var bdt = new ByteDataTypeSupport();
var result = bdt.RegisterType(participant, bdt.TypeName);
if (result != ReturnCode.Ok)
{
throw new Exception("Unable to register type: " + result);
}
_publisher = _participant.CreatePublisher();
_subscriber = _participant.CreateSubscriber();
var senderTopicQos = new TopicQos();
participant.GetDefaultTopicQos(ref senderTopicQos);
var receiverTopicQos = new TopicQos();
participant.GetDefaultTopicQos(ref receiverTopicQos);
_senderTopic = participant.CreateTopic(senderTopic, bdt.TypeName, senderTopicQos);
_receiverTopic = participant.CreateTopic(receiverTopic, bdt.TypeName, receiverTopicQos);
_dataWriter = (ByteDataWriter)_publisher.CreateDataWriter(_senderTopic);
_dataToSendHandle = _dataWriter.RegisterInstance(_dataToSend);
var dataReaderQos = new DataReaderQos();
_subscriber.GetDefaultDataReaderQos(ref dataReaderQos);
_dataReader = (ByteDataReader)_subscriber.CreateDataReader(_receiverTopic, dataReaderQos, this, StatusKind.Any);
}
public ReturnCode SetQos(DataReaderQos qos)
{
ReturnCode result = DDS.ReturnCode.AlreadyDeleted;
ReportStack.Start();
if (this.rlReq_isAlive)
{
result = QosManager.checkQos(qos);
if (result == DDS.ReturnCode.Ok)
{
using (OpenSplice.CustomMarshalers.DataReaderQosMarshaler marshaler =
new OpenSplice.CustomMarshalers.DataReaderQosMarshaler())
{
result = marshaler.CopyIn(qos);
if (result == ReturnCode.Ok)
{
result = uResultToReturnCode(
User.DataReader.SetQos(rlReq_UserPeer, marshaler.UserPtr));
if (result != ReturnCode.Ok)
{
ReportStack.Report(result, "Could not apply DataReaderQos.");
}
}
else
{
ReportStack.Report(result, "Could not copy DataReaderQos.");
}
}
}
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public DomainParticipantTransportSource(IDomainParticipant participant, string senderTopic, string receiverTopic)
{
_participant = participant;
var bdt = new ByteDataTypeSupport();
var result = bdt.RegisterType(participant, bdt.TypeName);
if (result != ReturnCode.Ok)
throw new Exception("Unable to register type: " + result);
_publisher = _participant.CreatePublisher();
_subscriber = _participant.CreateSubscriber();
var senderTopicQos = new TopicQos();
participant.GetDefaultTopicQos(ref senderTopicQos);
var receiverTopicQos = new TopicQos();
participant.GetDefaultTopicQos(ref receiverTopicQos);
_senderTopic = participant.CreateTopic(senderTopic, bdt.TypeName, senderTopicQos);
_receiverTopic = participant.CreateTopic(receiverTopic, bdt.TypeName, receiverTopicQos);
_dataWriter = (ByteDataWriter)_publisher.CreateDataWriter(_senderTopic);
_dataToSendHandle = _dataWriter.RegisterInstance(_dataToSend);
var dataReaderQos = new DataReaderQos();
_subscriber.GetDefaultDataReaderQos(ref dataReaderQos);
_dataReader = (ByteDataReader)_subscriber.CreateDataReader(_receiverTopic, dataReaderQos, this, StatusKind.Any);
}
public void TestGetDefaultDataReaderQos()
{
// 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(TestGetDefaultDataReaderQos), typeName);
Assert.IsNotNull(topic);
Assert.IsNull(topic.GetListener());
Assert.AreEqual(nameof(TestGetDefaultDataReaderQos), topic.Name);
Assert.AreEqual(typeName, topic.TypeName);
Subscriber subscriber = _participant.CreateSubscriber();
Assert.IsNotNull(subscriber);
// Create a non-default DataReader Qos, call GetDefaultDataReaderQos and check the default values
DataReaderQos qos = TestHelper.CreateNonDefaultDataReaderQos();
result = subscriber.GetDefaultDataReaderQos(qos);
Assert.AreEqual(ReturnCode.Ok, result);
TestHelper.TestDefaultDataReaderQos(qos);
// Test GetDefaultDataReaderQos with null parametr
result = subscriber.GetDefaultDataReaderQos(null);
Assert.AreEqual(ReturnCode.BadParameter, result);
}
public ReturnCode GetQos(ref DataReaderQos qos)
{
ReturnCode result = DDS.ReturnCode.AlreadyDeleted;
IntPtr userQos = IntPtr.Zero;
ReportStack.Start();
if (this.rlReq_isAlive)
{
result = uResultToReturnCode(
User.DataReader.GetQos(rlReq_UserPeer, ref userQos));
if (result == ReturnCode.Ok)
{
using (OpenSplice.CustomMarshalers.DataReaderQosMarshaler marshaler =
new OpenSplice.CustomMarshalers.DataReaderQosMarshaler(userQos, true))
{
marshaler.CopyOut(ref qos);
}
}
else
{
ReportStack.Report(result, "Could not copy DataReaderQos.");
}
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
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 DomainParticipantTransportSource(DomainParticipant participant, string senderTopic, string receiverTopic)
{
_participant = participant;
var senderTopicQos = new TopicQos();
participant.get_default_topic_qos(senderTopicQos);
var receiverTopicQos = new TopicQos();
participant.get_default_topic_qos(receiverTopicQos);
_sender = participant.create_topic(senderTopic, BytesTypeSupport.TYPENAME, senderTopicQos, null, StatusMask.STATUS_MASK_NONE);
_receiver = participant.create_topic(receiverTopic, BytesTypeSupport.TYPENAME, receiverTopicQos, null, StatusMask.STATUS_MASK_NONE);
var writerQos = new DataWriterQos();
//writerQos.publish_mode.kind = PublishModeQosPolicyKind.ASYNCHRONOUS_PUBLISH_MODE_QOS;
writerQos.publish_mode.flow_controller_name = FlowController.FIXED_RATE_FLOW_CONTROLLER_NAME;
participant.get_default_datawriter_qos(writerQos);
var readerQos = new DataReaderQos();
participant.get_default_datareader_qos(readerQos);
_writer = participant.create_datawriter(_sender, writerQos, null, StatusMask.STATUS_MASK_NONE);
_reader = participant.create_datareader(_receiver, readerQos, this, StatusMask.STATUS_MASK_ALL);
}
public DomainParticipantTransportSource(DomainParticipant participant, string senderTopic, string receiverTopic)
{
_participant = participant;
var senderTopicQos = new TopicQos();
participant.get_default_topic_qos(senderTopicQos);
var receiverTopicQos = new TopicQos();
participant.get_default_topic_qos(receiverTopicQos);
_sender = participant.create_topic(senderTopic, BytesTypeSupport.TYPENAME, senderTopicQos, null, StatusMask.STATUS_MASK_NONE);
_receiver = participant.create_topic(receiverTopic, BytesTypeSupport.TYPENAME, receiverTopicQos, null, StatusMask.STATUS_MASK_NONE);
var writerQos = new DataWriterQos();
//writerQos.publish_mode.kind = PublishModeQosPolicyKind.ASYNCHRONOUS_PUBLISH_MODE_QOS;
writerQos.publish_mode.flow_controller_name = FlowController.FIXED_RATE_FLOW_CONTROLLER_NAME;
participant.get_default_datawriter_qos(writerQos);
var readerQos = new DataReaderQos();
participant.get_default_datareader_qos(readerQos);
_writer = participant.create_datawriter(_sender, writerQos, null, StatusMask.STATUS_MASK_NONE);
_reader = participant.create_datareader(_receiver, readerQos, this, StatusMask.STATUS_MASK_ALL);
}
private ShapeWaitSet CreateTriangleReader()
{
DataReaderQos qos = GetDataReaderQos();
ITopicDescription topic = null;
if (_config.ReaderFilterConfig.Enabled)
{
string filter = _config.ReaderFilterConfig.FilterKind == FilterKind.Inside ? FILTER_INSIDE : FILTER_OUTSIDE;
topic = _participant.CreateContentFilteredTopic("CFTriangle" + (++_cfTriangleCount),
_triangleTopic, filter,
_config.ReaderFilterConfig.X0.ToString(),
_config.ReaderFilterConfig.X1.ToString(),
_config.ReaderFilterConfig.Y0.ToString(),
_config.ReaderFilterConfig.Y1.ToString());
}
else
{
topic = _triangleTopic;
}
DataReader reader = _subscriber.CreateDataReader(topic, qos);
if (reader == null)
{
throw new Exception("Could not create triangle data reader");
}
ShapeTypeDataReader triangleDataReader = new ShapeTypeDataReader(reader);
return(new ShapeWaitSet(triangleDataReader, TriangleTopicDataAvailable));
}
public ReturnCode SetDefaultDataReaderQos(DataReaderQos qos)
{
ReturnCode result = DDS.ReturnCode.AlreadyDeleted;
ReportStack.Start();
lock (this)
{
if (this.rlReq_isAlive)
{
result = QosManager.checkQos(qos);
if (result == DDS.ReturnCode.Ok)
{
using (OpenSplice.CustomMarshalers.DataReaderQosMarshaler marshaler =
new OpenSplice.CustomMarshalers.DataReaderQosMarshaler())
{
result = marshaler.CopyIn(qos);
if (result == ReturnCode.Ok)
{
marshaler.CopyOut(ref defaultDataReaderQos);
}
}
}
}
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public void TestReadInstance()
{
List <SubscriptionBuiltinTopicData> data = new List <SubscriptionBuiltinTopicData>();
List <SampleInfo> infos = new List <SampleInfo>();
ReturnCode ret = _dr.Read(data, infos);
Assert.AreEqual(ReturnCode.NoData, ret);
Assert.AreEqual(0, data.Count);
Assert.AreEqual(0, infos.Count);
DomainParticipant otherParticipant = AssemblyInitializer.Factory.CreateParticipant(AssemblyInitializer.RTPS_DOMAIN);
Assert.IsNotNull(otherParticipant);
otherParticipant.BindRtpsUdpTransportConfig();
TestStructTypeSupport support = new TestStructTypeSupport();
string typeName = support.GetTypeName();
ReturnCode result = support.RegisterType(otherParticipant, typeName);
Assert.AreEqual(ReturnCode.Ok, result);
var topic = otherParticipant.CreateTopic(TestContext.TestName, typeName);
Assert.IsNotNull(topic);
var subscriber = otherParticipant.CreateSubscriber();
Assert.IsNotNull(subscriber);
DataReaderQos drQos = TestHelper.CreateNonDefaultDataReaderQos();
DataReader dataReader = subscriber.CreateDataReader(topic, drQos);
Assert.IsNotNull(dataReader);
Thread.Sleep(500);
ret = _dr.ReadNextInstance(data, infos, InstanceHandle.HandleNil);
Assert.AreEqual(ReturnCode.Ok, ret);
Assert.AreEqual(1, data.Count);
Assert.AreEqual(1, infos.Count);
TestHelper.TestNonDefaultSubscriptionData(data.First());
var handle = infos.First().InstanceHandle;
data = new List <SubscriptionBuiltinTopicData>();
infos = new List <SampleInfo>();
ret = _dr.ReadInstance(data, infos, handle);
Assert.AreEqual(ReturnCode.Ok, ret);
Assert.AreEqual(1, data.Count);
Assert.AreEqual(1, infos.Count);
TestHelper.TestNonDefaultSubscriptionData(data.First());
ret = otherParticipant.DeleteContainedEntities();
Assert.AreEqual(ReturnCode.Ok, ret);
ret = AssemblyInitializer.Factory.DeleteParticipant(otherParticipant);
Assert.AreEqual(ReturnCode.Ok, ret);
}
public void TestOnOfferedIncompatibleQos()
{
DataWriter dw = null;
int totalCount = 0;
int totalCountChange = 0;
int lastPolicyId = 0;
ICollection <QosPolicyCount> policies = new List <QosPolicyCount>();
// Attach to the event
int count = 0;
_listener.OfferedIncompatibleQos += (w, s) =>
{
dw = w;
totalCount = s.TotalCount;
totalCountChange = s.TotalCountChange;
lastPolicyId = s.LastPolicyId;
policies = s.Policies;
count++;
};
// Prepare QoS for the test
DataWriterQos dwQos = new DataWriterQos();
dwQos.Reliability.Kind = ReliabilityQosPolicyKind.BestEffortReliabilityQos;
ReturnCode result = _writer.SetQos(dwQos);
Assert.AreEqual(ReturnCode.Ok, result);
DataReaderQos drQos = new DataReaderQos();
drQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos;
result = _reader.SetQos(drQos);
Assert.AreEqual(ReturnCode.Ok, result);
// Enable entities
result = _writer.Enable();
Assert.AreEqual(ReturnCode.Ok, result);
result = _reader.Enable();
Assert.AreEqual(ReturnCode.Ok, result);
// Wait for discovery
System.Threading.Thread.Sleep(100);
Assert.AreEqual(1, count);
Assert.AreEqual(_writer, dw);
Assert.AreEqual(1, totalCount);
Assert.AreEqual(1, totalCountChange);
Assert.AreEqual(11, lastPolicyId);
Assert.IsNotNull(policies);
Assert.AreEqual(1, policies.Count);
Assert.AreEqual(1, policies.First().Count);
Assert.AreEqual(11, policies.First().PolicyId);
// Remove the listener to avoid extra messages
result = _publisher.SetListener(null);
Assert.AreEqual(ReturnCode.Ok, result);
}
public void TestOnRequestedDeadlineMissed()
{
// Prepare qos for the test
DataWriterQos dwQos = new DataWriterQos();
dwQos.Deadline.Period = new Duration {
Seconds = 1
};
ReturnCode result = _writer.SetQos(dwQos);
Assert.AreEqual(ReturnCode.Ok, result);
DataReaderQos drQos = new DataReaderQos();
drQos.Deadline.Period = new Duration {
Seconds = 1
};
drQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos;
result = _reader.SetQos(drQos);
Assert.AreEqual(ReturnCode.Ok, result);
// Enable entities
result = _writer.Enable();
Assert.AreEqual(ReturnCode.Ok, result);
result = _reader.Enable();
Assert.AreEqual(ReturnCode.Ok, result);
// Wait for discovery
bool found = _writer.WaitForSubscriptions(1, 1000);
Assert.IsTrue(found);
// Attach to the event
int count = 0;
_listener.RequestedDeadlineMissed += (r, s) =>
{
Assert.AreEqual(_reader, r);
Assert.AreEqual(1, s.TotalCount);
Assert.AreEqual(1, s.TotalCountChange);
Assert.AreNotEqual(InstanceHandle.HandleNil, s.LastInstanceHandle);
count++;
};
// Write an instance
_dataWriter.Write(new TestStruct {
Id = 1
});
// After half second deadline should not be lost yet
System.Threading.Thread.Sleep(500);
Assert.AreEqual(0, count);
// After one second and a half one deadline should be lost
System.Threading.Thread.Sleep(1000);
Assert.AreEqual(1, count);
}
static void Main(string[] args)
{
_dpf = DomainParticipantFactory.Instance;
ErrorHandler.checkHandle(_dpf, "Domain Participant Factory");
_dp = _dpf.CreateParticipant(Domain);
//Initialize QOS
sQos = new SubscriberQos();
drQos = new DataReaderQos();
fdmDataType = new FDMTypeSupport();
string FDMDATATypeName = fdmDataType.TypeName;
ReturnCode status = fdmDataType.RegisterType(_dp, FDMDATATypeName);
ErrorHandler.checkStatus(status, "FDMDATA: Cannot Register Type");
//Create FDMDATA Topic
fdmDataTopic = _dp.FindTopic("FDMDATA", Duration.FromMilliseconds(1000));
if (fdmDataTopic == null)
{
fdmDataTopic = _dp.CreateTopic("FDMDATA", FDMDATATypeName);
}
ErrorHandler.checkHandle(fdmDataTopic, "Cannot Create Topic FDMDATA");
//Get Subscriber QOS and Set Partition Name
_dp.GetDefaultSubscriberQos(ref sQos);
sQos.Partition.Name = new String[1];
sQos.Partition.Name[0] = PartitionName;
//Create Subscriber for FDMDATA Topic
Subscriber = _dp.CreateSubscriber(sQos);
ErrorHandler.checkHandle(Subscriber, "Cannot Create FDMDATA Subscriber");
//Get Data Reader QOS and Set History Depth
Subscriber.GetDefaultDataReaderQos(ref drQos);
ErrorHandler.checkHandle(drQos, "Cannot get Data Reader Qos");
drQos.History.Depth = 5;
drQos.Reliability.Kind = ReliabilityQosPolicyKind.BestEffortReliabilityQos;
//Create DataReader for FDMDATA Topic
parentReader = Subscriber.CreateDataReader(fdmDataTopic, drQos);
ErrorHandler.checkHandle(parentReader, "Cannot Create FDMDATA Data Reader");
//Narrow abstract parentReader into its typed representative
fdmDataReader = parentReader as FDMDataReader;
ErrorHandler.checkHandle(fdmDataReader, "Cannot Narrow FDMDATA Data Reader");
// drQos.Durability.Kind = DurabilityQosPolicyKind.TransientLocalDurabilityQos;
fdmData = new FDM();
//Rececieve Loop
while (true)
{
StartReceive();
Console.WriteLine("abc: " + fdmData.aa.ToString());
}
}
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 static DataReaderQos CreateNonDefaultDataReaderQos()
{
DataReaderQos qos = new DataReaderQos();
qos.Deadline.Period = new Duration
{
Seconds = 5,
NanoSeconds = 0
};
qos.DestinationOrder.Kind = DestinationOrderQosPolicyKind.BySourceTimestampDestinationOrderQos;
qos.Durability.Kind = DurabilityQosPolicyKind.TransientLocalDurabilityQos;
qos.History.Depth = 5;
qos.History.Kind = HistoryQosPolicyKind.KeepAllHistoryQos;
qos.LatencyBudget.Duration = new Duration
{
Seconds = 5,
NanoSeconds = 5
};
qos.Liveliness.Kind = LivelinessQosPolicyKind.ManualByParticipantLivelinessQos;
qos.Liveliness.LeaseDuration = new Duration
{
Seconds = 5,
NanoSeconds = 5
};
qos.Ownership.Kind = OwnershipQosPolicyKind.ExclusiveOwnershipQos;
qos.ReaderDataLifecycle.AutopurgeDisposedSamplesDelay = new Duration
{
Seconds = 5,
NanoSeconds = 5
};
qos.ReaderDataLifecycle.AutopurgeNowriterSamplesDelay = new Duration
{
Seconds = 5,
NanoSeconds = 5
};
qos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos;
qos.Reliability.MaxBlockingTime = new Duration
{
Seconds = 5,
NanoSeconds = 5
};
qos.ResourceLimits.MaxInstances = 5;
qos.ResourceLimits.MaxSamples = 5;
qos.ResourceLimits.MaxSamplesPerInstance = 5;
qos.TimeBasedFilter.MinimumSeparation = new Duration
{
Seconds = 3,
NanoSeconds = 3
};
qos.UserData.Value = new List <byte> {
0x5
};
return(qos);
}
internal virtual ReturnCode init(Subscriber subscriber, DataReaderQos drQos, ITopicDescriptionImpl aTopic, string drName)
{
ReturnCode result = DDS.ReturnCode.Ok;
MyDomainId = subscriber.MyDomainId;
using (OpenSplice.CustomMarshalers.DataReaderQosMarshaler qosMarshaler =
new OpenSplice.CustomMarshalers.DataReaderQosMarshaler())
{
result = qosMarshaler.CopyIn(drQos);
if (result == ReturnCode.Ok)
{
using (SequenceStringToCValueArrMarshaler paramsMarshaler = new SequenceStringToCValueArrMarshaler())
{
string[] _params = aTopic.rlReq_TopicExpressionParameters;
result = paramsMarshaler.CopyIn(_params);
if (result == ReturnCode.Ok)
{
IntPtr uReader = User.DataReader.NewBySQL(
subscriber.rlReq_UserPeer,
drName,
aTopic.rlReq_TopicExpression,
paramsMarshaler.UserPtr,
_params == null ? 0 : Convert.ToUInt32(_params.Length),
qosMarshaler.UserPtr);
if (uReader != IntPtr.Zero)
{
result = base.init(uReader);
}
else
{
ReportStack.Report(result, "Could not allocate memory.");
result = DDS.ReturnCode.OutOfResources;
}
}
else
{
ReportStack.Report(result, "Could not create DataReader.");
}
}
}
else
{
ReportStack.Report(result, "Could not copy DataReaderQos.");
}
}
if (result == ReturnCode.Ok)
{
this.subscriber = subscriber;
this.topic = aTopic;
aTopic.wlReq_IncrNrUsers();
}
return(result);
}
public void TestGetKeyValue()
{
// Call GetKeyValue with HandleNil
SubscriptionBuiltinTopicData data = default;
SampleInfo info = new SampleInfo();
ReturnCode ret = _dr.GetKeyValue(ref data, InstanceHandle.HandleNil);
Assert.AreEqual(ReturnCode.BadParameter, ret);
DomainParticipant otherParticipant = AssemblyInitializer.Factory.CreateParticipant(AssemblyInitializer.RTPS_DOMAIN);
Assert.IsNotNull(otherParticipant);
otherParticipant.BindRtpsUdpTransportConfig();
TestStructTypeSupport support = new TestStructTypeSupport();
string typeName = support.GetTypeName();
ReturnCode result = support.RegisterType(otherParticipant, typeName);
Assert.AreEqual(ReturnCode.Ok, result);
var topic = otherParticipant.CreateTopic(TestContext.TestName, typeName);
Assert.IsNotNull(topic);
var subscriber = otherParticipant.CreateSubscriber();
Assert.IsNotNull(subscriber);
DataReaderQos drQos = TestHelper.CreateNonDefaultDataReaderQos();
DataReader dataReader = subscriber.CreateDataReader(topic, drQos);
Assert.IsNotNull(dataReader);
Thread.Sleep(500);
// Get the for an existing instance
ret = _dr.ReadNextSample(ref data, info);
Assert.AreEqual(ReturnCode.Ok, ret);
TestHelper.TestNonDefaultSubscriptionData(data);
SubscriptionBuiltinTopicData aux = default;
ret = _dr.GetKeyValue(ref aux, info.InstanceHandle);
Assert.AreEqual(ReturnCode.Ok, ret);
for (int i = 0; i < 3; i++)
{
Assert.AreEqual(data.Key.Value[i], aux.Key.Value[i]);
}
ret = otherParticipant.DeleteContainedEntities();
Assert.AreEqual(ReturnCode.Ok, ret);
ret = AssemblyInitializer.Factory.DeleteParticipant(otherParticipant);
Assert.AreEqual(ReturnCode.Ok, ret);
}
public void TestLookupInstance()
{
SubscriptionBuiltinTopicData data = default;
SampleInfo info = new SampleInfo();
DomainParticipant otherParticipant = AssemblyInitializer.Factory.CreateParticipant(AssemblyInitializer.RTPS_DOMAIN);
Assert.IsNotNull(otherParticipant);
otherParticipant.BindRtpsUdpTransportConfig();
TestStructTypeSupport support = new TestStructTypeSupport();
string typeName = support.GetTypeName();
ReturnCode result = support.RegisterType(otherParticipant, typeName);
Assert.AreEqual(ReturnCode.Ok, result);
var topic = otherParticipant.CreateTopic(TestContext.TestName, typeName);
Assert.IsNotNull(topic);
var subscriber = otherParticipant.CreateSubscriber();
Assert.IsNotNull(subscriber);
DataReaderQos drQos = TestHelper.CreateNonDefaultDataReaderQos();
DataReader dataReader = subscriber.CreateDataReader(topic, drQos);
Assert.IsNotNull(dataReader);
int count = 200;
ReturnCode ret = ReturnCode.NoData;
while (ret != ReturnCode.Ok && count > 0)
{
Thread.Sleep(100);
// Get the for an existing instance
ret = _dr.ReadNextSample(ref data, info);
count--;
}
Assert.AreEqual(ReturnCode.Ok, ret);
TestHelper.TestNonDefaultSubscriptionData(data);
// Lookup for an existing instance
var handle = _dr.LookupInstance(data);
Assert.AreNotEqual(InstanceHandle.HandleNil, handle);
ret = otherParticipant.DeleteContainedEntities();
Assert.AreEqual(ReturnCode.Ok, ret);
ret = AssemblyInitializer.Factory.DeleteParticipant(otherParticipant);
Assert.AreEqual(ReturnCode.Ok, ret);
}
GetDataReaderQos(
ref DataReaderQos datareaderQos,
string id)
{
NamedDataReaderQos drQos = new NamedDataReaderQos();
GCHandle qosHandle = GCHandle.Alloc(drQos, GCHandleType.Normal);
ReturnCode result = OpenSplice.Common.QosProvider.GetDataReaderQos(GapiPeer, id, GCHandle.ToIntPtr(qosHandle));
datareaderQos = drQos.DatareaderQos;
qosHandle.Free();
return(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 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 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);
}
public static void TestNonDefaultDataReaderQos(DataReaderQos qos)
{
Assert.IsNotNull(qos);
Assert.IsNotNull(qos.Deadline);
Assert.IsNotNull(qos.DestinationOrder);
Assert.IsNotNull(qos.Durability);
Assert.IsNotNull(qos.History);
Assert.IsNotNull(qos.LatencyBudget);
Assert.IsNotNull(qos.Liveliness);
Assert.IsNotNull(qos.Ownership);
Assert.IsNotNull(qos.ReaderDataLifecycle);
Assert.IsNotNull(qos.Reliability);
Assert.IsNotNull(qos.ResourceLimits);
Assert.IsNotNull(qos.TimeBasedFilter);
Assert.IsNotNull(qos.UserData);
Assert.IsNotNull(qos.Deadline.Period);
Assert.AreEqual(5, qos.Deadline.Period.Seconds);
Assert.AreEqual(Duration.ZeroNanoseconds, qos.Deadline.Period.NanoSeconds);
Assert.AreEqual(DestinationOrderQosPolicyKind.BySourceTimestampDestinationOrderQos, qos.DestinationOrder.Kind);
Assert.AreEqual(DurabilityQosPolicyKind.TransientLocalDurabilityQos, qos.Durability.Kind);
Assert.AreEqual(HistoryQosPolicyKind.KeepAllHistoryQos, qos.History.Kind);
Assert.AreEqual(5, qos.History.Depth);
Assert.IsNotNull(qos.LatencyBudget.Duration);
Assert.AreEqual(5, qos.LatencyBudget.Duration.Seconds);
Assert.AreEqual((uint)5, qos.LatencyBudget.Duration.NanoSeconds);
Assert.AreEqual(LivelinessQosPolicyKind.ManualByParticipantLivelinessQos, qos.Liveliness.Kind);
Assert.IsNotNull(qos.Liveliness.LeaseDuration);
Assert.AreEqual(5, qos.Liveliness.LeaseDuration.Seconds);
Assert.AreEqual((uint)5, qos.Liveliness.LeaseDuration.NanoSeconds);
Assert.AreEqual(OwnershipQosPolicyKind.ExclusiveOwnershipQos, qos.Ownership.Kind);
Assert.IsNotNull(qos.ReaderDataLifecycle.AutopurgeDisposedSamplesDelay);
Assert.AreEqual(5, qos.ReaderDataLifecycle.AutopurgeDisposedSamplesDelay.Seconds);
Assert.AreEqual((uint)5, qos.ReaderDataLifecycle.AutopurgeDisposedSamplesDelay.NanoSeconds);
Assert.IsNotNull(qos.ReaderDataLifecycle.AutopurgeNowriterSamplesDelay);
Assert.AreEqual(5, qos.ReaderDataLifecycle.AutopurgeNowriterSamplesDelay.Seconds);
Assert.AreEqual((uint)5, qos.ReaderDataLifecycle.AutopurgeNowriterSamplesDelay.NanoSeconds);
Assert.AreEqual(ReliabilityQosPolicyKind.ReliableReliabilityQos, qos.Reliability.Kind);
Assert.IsNotNull(qos.Reliability.MaxBlockingTime);
Assert.AreEqual(5, qos.Reliability.MaxBlockingTime.Seconds);
Assert.AreEqual((uint)5, qos.Reliability.MaxBlockingTime.NanoSeconds);
Assert.AreEqual(5, qos.ResourceLimits.MaxInstances);
Assert.AreEqual(5, qos.ResourceLimits.MaxSamples);
Assert.AreEqual(5, qos.ResourceLimits.MaxSamplesPerInstance);
Assert.AreEqual(1, qos.UserData.Value.Count());
Assert.IsNotNull(qos.TimeBasedFilter.MinimumSeparation);
Assert.AreEqual(3, qos.TimeBasedFilter.MinimumSeparation.Seconds);
Assert.AreEqual((uint)3, qos.TimeBasedFilter.MinimumSeparation.NanoSeconds);
Assert.AreEqual(0x5, qos.UserData.Value.First());
}
public static void TestDefaultDataReaderQos(DataReaderQos qos)
{
Assert.IsNotNull(qos);
Assert.IsNotNull(qos.Deadline);
Assert.IsNotNull(qos.DestinationOrder);
Assert.IsNotNull(qos.Durability);
Assert.IsNotNull(qos.History);
Assert.IsNotNull(qos.LatencyBudget);
Assert.IsNotNull(qos.Liveliness);
Assert.IsNotNull(qos.Ownership);
Assert.IsNotNull(qos.ReaderDataLifecycle);
Assert.IsNotNull(qos.Reliability);
Assert.IsNotNull(qos.ResourceLimits);
Assert.IsNotNull(qos.TimeBasedFilter);
Assert.IsNotNull(qos.UserData);
Assert.IsNotNull(qos.Deadline.Period);
Assert.AreEqual(Duration.InfiniteSeconds, qos.Deadline.Period.Seconds);
Assert.AreEqual(Duration.InfiniteNanoseconds, qos.Deadline.Period.NanoSeconds);
Assert.AreEqual(DestinationOrderQosPolicyKind.ByReceptionTimestampDestinationOrderQos, qos.DestinationOrder.Kind);
Assert.AreEqual(DurabilityQosPolicyKind.VolatileDurabilityQos, qos.Durability.Kind);
Assert.AreEqual(HistoryQosPolicyKind.KeepLastHistoryQos, qos.History.Kind);
Assert.AreEqual(1, qos.History.Depth);
Assert.IsNotNull(qos.LatencyBudget.Duration);
Assert.AreEqual(Duration.ZeroSeconds, qos.LatencyBudget.Duration.Seconds);
Assert.AreEqual(Duration.ZeroNanoseconds, qos.LatencyBudget.Duration.NanoSeconds);
Assert.AreEqual(LivelinessQosPolicyKind.AutomaticLivelinessQos, qos.Liveliness.Kind);
Assert.IsNotNull(qos.Liveliness.LeaseDuration);
Assert.AreEqual(Duration.InfiniteSeconds, qos.Liveliness.LeaseDuration.Seconds);
Assert.AreEqual(Duration.InfiniteNanoseconds, qos.Liveliness.LeaseDuration.NanoSeconds);
Assert.AreEqual(OwnershipQosPolicyKind.SharedOwnershipQos, qos.Ownership.Kind);
Assert.IsNotNull(qos.ReaderDataLifecycle.AutopurgeDisposedSamplesDelay);
Assert.AreEqual(Duration.InfiniteSeconds, qos.ReaderDataLifecycle.AutopurgeDisposedSamplesDelay.Seconds);
Assert.AreEqual(Duration.InfiniteNanoseconds, qos.ReaderDataLifecycle.AutopurgeDisposedSamplesDelay.NanoSeconds);
Assert.IsNotNull(qos.ReaderDataLifecycle.AutopurgeNowriterSamplesDelay);
Assert.AreEqual(Duration.InfiniteSeconds, qos.ReaderDataLifecycle.AutopurgeNowriterSamplesDelay.Seconds);
Assert.AreEqual(Duration.InfiniteNanoseconds, qos.ReaderDataLifecycle.AutopurgeNowriterSamplesDelay.NanoSeconds);
Assert.AreEqual(ReliabilityQosPolicyKind.BestEffortReliabilityQos, qos.Reliability.Kind);
Assert.IsNotNull(qos.Reliability.MaxBlockingTime);
Assert.AreEqual(Duration.InfiniteSeconds, qos.Reliability.MaxBlockingTime.Seconds);
Assert.AreEqual(Duration.InfiniteNanoseconds, qos.Reliability.MaxBlockingTime.NanoSeconds);
Assert.AreEqual(ResourceLimitsQosPolicy.LengthUnlimited, qos.ResourceLimits.MaxInstances);
Assert.AreEqual(ResourceLimitsQosPolicy.LengthUnlimited, qos.ResourceLimits.MaxSamples);
Assert.AreEqual(ResourceLimitsQosPolicy.LengthUnlimited, qos.ResourceLimits.MaxSamplesPerInstance);
Assert.IsNotNull(qos.TimeBasedFilter.MinimumSeparation);
Assert.AreEqual(0, qos.TimeBasedFilter.MinimumSeparation.Seconds);
Assert.AreEqual((uint)0, qos.TimeBasedFilter.MinimumSeparation.NanoSeconds);
Assert.IsNotNull(qos.UserData.Value);
Assert.AreEqual(0, qos.UserData.Value.Count());
}
public void TestOnOfferedIncompatibleQos()
{
// Attach to the event
int count = 0;
_listener.OfferedIncompatibleQos += (w, s) =>
{
Assert.AreEqual(_writer, w);
Assert.AreEqual(1, s.TotalCount);
Assert.AreEqual(1, s.TotalCountChange);
Assert.AreEqual(11, s.LastPolicyId);
Assert.IsNotNull(s.Policies);
Assert.AreEqual(1, s.Policies.Count());
Assert.AreEqual(1, s.Policies.First().Count);
Assert.AreEqual(11, s.Policies.First().PolicyId);
count++;
};
// Prepare QoS for the test
DataWriterQos dwQos = new DataWriterQos();
dwQos.Reliability.Kind = ReliabilityQosPolicyKind.BestEffortReliabilityQos;
ReturnCode result = _writer.SetQos(dwQos);
Assert.AreEqual(ReturnCode.Ok, result);
DataReaderQos drQos = new DataReaderQos();
drQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos;
result = _reader.SetQos(drQos);
Assert.AreEqual(ReturnCode.Ok, result);
// Enable entities
result = _writer.Enable();
Assert.AreEqual(ReturnCode.Ok, result);
result = _reader.Enable();
Assert.AreEqual(ReturnCode.Ok, result);
// Wait for discovery
System.Threading.Thread.Sleep(100);
Assert.AreEqual(1, count);
// Remove the listener to avoid extra messages
result = _participant.SetListener(null);
Assert.AreEqual(ReturnCode.Ok, result);
}
public ReturnCode GetQos(ref DataReaderQos qos)
{
ReturnCode result;
using (OpenSplice.CustomMarshalers.DataReaderQosMarshaler marshaler =
new OpenSplice.CustomMarshalers.DataReaderQosMarshaler())
{
result = Gapi.DataReader.get_qos(GapiPeer, marshaler.GapiPtr);
if (result == ReturnCode.Ok)
{
marshaler.CopyOut(ref qos);
}
}
return(result);
}
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);
}
public ReturnCode SetDefaultDataReaderQos(DataReaderQos qos)
{
DDS.ReturnCode result;
using (OpenSplice.CustomMarshalers.DataReaderQosMarshaler marshaler =
new OpenSplice.CustomMarshalers.DataReaderQosMarshaler())
{
result = marshaler.CopyIn(qos);
if (result == DDS.ReturnCode.Ok)
{
return(OpenSplice.Gapi.Subscriber.set_default_datareader_qos(
GapiPeer,
marshaler.GapiPtr));
}
}
return(result);
}
public ReturnCode CopyFromTopicQos(ref DataReaderQos dataReaderQos, TopicQos topicQos)
{
ReturnCode result = ReturnCode.Ok;
if (dataReaderQos == null)
{
result = GetDefaultDataReaderQos(ref dataReaderQos);
}
if (result == ReturnCode.Ok)
{
using (OpenSplice.CustomMarshalers.TopicQosMarshaler marshaler =
new OpenSplice.CustomMarshalers.TopicQosMarshaler())
{
result = marshaler.CopyIn(topicQos);
if (result == ReturnCode.Ok)
{
using (OpenSplice.CustomMarshalers.DataReaderQosMarshaler dataReaderMarshaler =
new OpenSplice.CustomMarshalers.DataReaderQosMarshaler())
{
result = dataReaderMarshaler.CopyIn(dataReaderQos);
if (result == ReturnCode.Ok)
{
result = OpenSplice.Gapi.Subscriber.copy_from_topic_qos(
GapiPeer,
dataReaderMarshaler.GapiPtr,
marshaler.GapiPtr);
if (result == ReturnCode.Ok)
{
dataReaderMarshaler.CopyOut(ref dataReaderQos);
}
}
}
}
}
}
return result;
}
public IDataReader CreateDataReader(
ITopicDescription topic,
DataReaderQos qos,
IDataReaderListener listener,
StatusKind mask)
{
DataReader dataReader = null;
if (topic != null)
{
SacsSuperClass superObj = (SacsSuperClass)topic;
using (OpenSplice.CustomMarshalers.DataReaderQosMarshaler marshaler =
new OpenSplice.CustomMarshalers.DataReaderQosMarshaler())
{
if (marshaler.CopyIn(qos) == ReturnCode.Ok)
{
if (listener != null)
{
OpenSplice.Gapi.gapi_dataReaderListener gapiListener;
DataReaderListenerHelper listenerHelper = new DataReaderListenerHelper();
listenerHelper.Listener = listener;
listenerHelper.CreateListener(out gapiListener);
using (DataReaderListenerMarshaler listenerMarshaler =
new DataReaderListenerMarshaler(ref gapiListener))
{
IntPtr gapiPtr = Gapi.Subscriber.create_datareader(
GapiPeer,
superObj.GapiPeer,
marshaler.GapiPtr,
listenerMarshaler.GapiPtr,
mask);
if (gapiPtr != IntPtr.Zero)
{
TypeSupport typeSupport = topic.Participant.GetTypeSupport(topic.TypeName)
as OpenSplice.TypeSupport;
dataReader = typeSupport.CreateDataReader(gapiPtr);
dataReader.SetListener(listenerHelper);
}
}
}
else
{
IntPtr gapiPtr = Gapi.Subscriber.create_datareader(
GapiPeer,
superObj.GapiPeer,
marshaler.GapiPtr,
IntPtr.Zero,
mask);
if (gapiPtr != IntPtr.Zero)
{
TypeSupport typeSupport = topic.Participant.GetTypeSupport(topic.TypeName)
as OpenSplice.TypeSupport;
dataReader = typeSupport.CreateDataReader(gapiPtr);
}
}
}
}
}
if (dataReader != null)
{
SubscriberQos subQos = null;
ReturnCode result = GetQos(ref subQos);
if (result == ReturnCode.Ok)
{
if (subQos.EntityFactory.AutoenableCreatedEntities)
{
dataReader.Enable();
}
}
}
return dataReader;
}
public ReturnCode GetDefaultDataReaderQos(ref DataReaderQos qos)
{
ReturnCode result;
using (OpenSplice.CustomMarshalers.DataReaderQosMarshaler marshaler =
new OpenSplice.CustomMarshalers.DataReaderQosMarshaler())
{
result = OpenSplice.Gapi.Subscriber.get_default_datareader_qos(
GapiPeer,
marshaler.GapiPtr);
if (result == ReturnCode.Ok)
{
marshaler.CopyOut(ref qos);
}
}
return result;
}
public ReturnCode SetDefaultDataReaderQos(DataReaderQos qos)
{
DDS.ReturnCode result;
using (OpenSplice.CustomMarshalers.DataReaderQosMarshaler marshaler =
new OpenSplice.CustomMarshalers.DataReaderQosMarshaler())
{
result = marshaler.CopyIn(qos);
if (result == DDS.ReturnCode.Ok)
{
return OpenSplice.Gapi.Subscriber.set_default_datareader_qos(
GapiPeer,
marshaler.GapiPtr);
}
}
return result;
}
public IDataReader CreateDataReader(ITopicDescription topic, DataReaderQos qos)
{
return CreateDataReader(topic, qos, null, 0);
}
static void Main(string[] args)
{
string domain = null;
/* Create a DomainParticipant */
DomainParticipantFactory dpf = DomainParticipantFactory.Instance;
IDomainParticipant participant = dpf.CreateParticipant(
domain,
null,
StatusKind.Any);
ErrorHandler.checkHandle(
participant, "DDS.DomainParticipantFactory.CreateParticipant");
/* Register the required datatype for ChatMessage. */
ChatMessageTypeSupport chatMessageTS = new ChatMessageTypeSupport();
string chatMessageTypeName = chatMessageTS.TypeName;
ReturnCode status = chatMessageTS.RegisterType(
participant, chatMessageTypeName);
ErrorHandler.checkStatus(
status, "Chat.ChatMessageTypeSupport.RegisterType");
/* Register the required datatype for NameService. */
NameServiceTypeSupport nameServiceTS = new NameServiceTypeSupport();
ErrorHandler.checkHandle(
nameServiceTS, "new NameServiceTypeSupport");
string nameServiceTypeName = nameServiceTS.TypeName;
status = nameServiceTS.RegisterType(
participant, nameServiceTypeName);
ErrorHandler.checkStatus(
status, "Chat.NameServiceTypeSupport.RegisterType");
/* Set the ReliabilityQosPolicy to RELIABLE. */
TopicQos reliableTopicQos = new TopicQos();
status = participant.GetDefaultTopicQos(ref reliableTopicQos);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipant.get_DefaultTopicQos");
reliableTopicQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos;
/* Make the tailored QoS the new default. */
status = participant.SetDefaultTopicQos(reliableTopicQos);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipant.SetDefaultTopicQos");
/* Use the changed policy when defining the ChatMessage topic */
ITopic chatMessageTopic = participant.CreateTopic(
"Chat_ChatMessage",
chatMessageTypeName,
reliableTopicQos);
ErrorHandler.checkHandle(
chatMessageTopic,
"DDS.DomainParticipant.CreateTopic (ChatMessage)");
/* Set the DurabilityQosPolicy to TRANSIENT. */
TopicQos settingTopicQos = new TopicQos();
status = participant.GetDefaultTopicQos(ref settingTopicQos);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipant.GetDefaultTopicQos");
settingTopicQos.Durability.Kind = DurabilityQosPolicyKind.TransientDurabilityQos;
/* Create the NameService Topic. */
ITopic nameServiceTopic = participant.CreateTopic(
"Chat_NameService",
nameServiceTypeName,
settingTopicQos);
ErrorHandler.checkHandle(
nameServiceTopic, "DDS.DomainParticipant.CreateTopic");
/* Adapt the default SubscriberQos to read from the
"ChatRoom" Partition. */
SubscriberQos subQos = new SubscriberQos();
status = participant.GetDefaultSubscriberQos(ref subQos);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipant.GetDefaultSubscriberQos");
subQos.Partition.Name = new string[1];
subQos.Partition.Name[0] = "ChatRoom";
/* Create a Subscriber for the UserLoad application. */
ISubscriber chatSubscriber = participant.CreateSubscriber(subQos);
ErrorHandler.checkHandle(
chatSubscriber, "DDS.DomainParticipant.CreateSubscriber");
/* Create a DataReader for the NameService Topic
(using the appropriate QoS). */
DataReaderQos nsQos = null;
status = chatSubscriber.GetDefaultDataReaderQos(ref nsQos);
ErrorHandler.checkStatus(
status, "DDS.Subscriber.GetDefaultDataReaderQos");
status = chatSubscriber.CopyFromTopicQos(ref nsQos, settingTopicQos);
ErrorHandler.checkStatus(
status, "DDS.Subscriber.CopyFromTopicQos");
IDataReader parentReader = chatSubscriber.CreateDataReader(
nameServiceTopic,
nsQos,
null,
StatusKind.Any);
ErrorHandler.checkHandle(
parentReader, "DDS.Subscriber.CreateDatareader (NameService)");
NameServiceDataReader nameServer = parentReader as NameServiceDataReader;
/* Adapt the DataReaderQos for the ChatMessageDataReader to
keep track of all messages. */
DataReaderQos messageQos = new DataReaderQos();
status = chatSubscriber.GetDefaultDataReaderQos(ref messageQos);
ErrorHandler.checkStatus(
status, "DDS.Subscriber.GetDefaultDataReaderQos");
status = chatSubscriber.CopyFromTopicQos(
ref messageQos, reliableTopicQos);
ErrorHandler.checkStatus(
status, "DDS.Subscriber.CopyFromTopicQos");
messageQos.History.Kind = HistoryQosPolicyKind.KeepAllHistoryQos;
/* Create a DataReader for the ChatMessage Topic
(using the appropriate QoS). */
parentReader = chatSubscriber.CreateDataReader(
chatMessageTopic,
messageQos);
ErrorHandler.checkHandle(
parentReader, "DDS.Subscriber.CreateDataReader (ChatMessage)");
/* Narrow the abstract parent into its typed representative. */
ChatMessageDataReader loadAdmin = parentReader as ChatMessageDataReader;
/* Initialize the Query Arguments. */
string[] parameters = { "0" };
/* Create a QueryCondition that will contain all messages
with userID=ownID */
IQueryCondition singleUser = loadAdmin.CreateQueryCondition("userID=%0", parameters);
ErrorHandler.checkHandle(singleUser, "DDS.DataReader.CreateQuerycondition");
/* Create a ReadCondition that will contain new users only */
IReadCondition newUser = nameServer.CreateReadCondition(SampleStateKind.NotRead, ViewStateKind.New, InstanceStateKind.Alive);
ErrorHandler.checkHandle(newUser, "DDS.DataReader.create_readcondition");
/* Obtain a StatusCondition that triggers only when a Writer
changes Liveliness */
IStatusCondition leftUser = loadAdmin.StatusCondition;
ErrorHandler.checkHandle(leftUser, "DDS.DataReader.GetStatusCondition");
status = leftUser.SetEnabledStatuses(StatusKind.LivelinessChanged);
ErrorHandler.checkStatus(status, "DDS.StatusCondition.SetEnabledStatuses");
/* Create a bare guard which will be used to close the room */
escape = new GuardCondition();
/* Create a waitset and add the ReadConditions */
WaitSet userLoadWS = new WaitSet();
status = userLoadWS.AttachCondition(newUser);
ErrorHandler.checkStatus(status, "DDS.WaitSet.AttachCondition (newUser)");
status = userLoadWS.AttachCondition(leftUser);
ErrorHandler.checkStatus(status, "DDS.WaitSet.AttachCondition (leftUser)");
status = userLoadWS.AttachCondition(escape);
ErrorHandler.checkStatus(status, "DDS.WaitSet.AttachCondition (escape)");
/* Initialize and pre-allocate the GuardList used to obtain
the triggered Conditions. */
ICondition[] guardList = new ICondition[3];
/* Remove all known Users that are not currently active. */
NameService[] nsMsgs = null;
SampleInfo[] nsInfos = null;
status = nameServer.Take(ref nsMsgs,
ref nsInfos,
Length.Unlimited,
SampleStateKind.Any,
ViewStateKind.Any,
InstanceStateKind.NotAlive);
ErrorHandler.checkStatus(
status, "Chat.NameServiceDataReader.Take");
status = nameServer.ReturnLoan(ref nsMsgs, ref nsInfos);
ErrorHandler.checkStatus(
status, "Chat.NameServiceDataReader.ReturnLoan");
/* Start the sleeper thread. */
new Thread(new UserLoad().doWait).Start();
bool closed = false;
int prevCount = 0;
ChatMessage[] msgs = null;
SampleInfo[] msgInfos = null;
while (!closed)
{
/* Wait until at least one of the Conditions in the
waitset triggers. */
status = userLoadWS.Wait(ref guardList, Duration.Infinite);
ErrorHandler.checkStatus(status, "DDS.WaitSet.Wait");
/* Walk over all guards to display information */
foreach (ICondition guard in guardList)
{
if (guard == newUser)
{
/* The newUser ReadCondition contains data */
status = nameServer.ReadWithCondition(ref nsMsgs, ref nsInfos, newUser);
ErrorHandler.checkStatus(status, "Chat.NameServiceDataReader.read_w_condition");
foreach (NameService ns in nsMsgs)
{
Console.WriteLine("New user: "******"Chat.NameServiceDataReader.ReturnLoan");
}
else if (guard == leftUser)
{
// Some liveliness has changed (either a DataWriter
// joined or a DataWriter left)
LivelinessChangedStatus livelinessStatus = new LivelinessChangedStatus() ;
status = loadAdmin.GetLivelinessChangedStatus(ref livelinessStatus);
ErrorHandler.checkStatus(status, "DDS.DataReader.getLivelinessChangedStatus");
if (livelinessStatus.AliveCount < prevCount)
{
/* A user has left the ChatRoom, since a DataWriter
lost its liveliness. Take the effected users
so they will not appear in the list later on. */
status = nameServer.Take(
ref nsMsgs,
ref nsInfos,
Length.Unlimited,
SampleStateKind.Any,
ViewStateKind.Any,
InstanceStateKind.NotAliveNoWriters);
ErrorHandler.checkStatus(status, "Chat.NameServiceDataReader.Take");
foreach (NameService nsMsg in nsMsgs)
{
/* re-apply query arguments */
parameters[0] = nsMsg.userID.ToString();
status = singleUser.SetQueryParameters(parameters);
ErrorHandler.checkStatus(status, "DDS.QueryCondition.SetQueryParameters");
/* Read this user's history */
status = loadAdmin.TakeWithCondition(
ref msgs,
ref msgInfos,
singleUser);
ErrorHandler.checkStatus(
status,
"Chat.ChatMessageDataReader.TakeWithCondition");
/* Display the user and his history */
Console.WriteLine("Departed user {0} has sent {1} messages ", nsMsg.name, msgs.Length);
status = loadAdmin.ReturnLoan(ref msgs, ref msgInfos);
ErrorHandler.checkStatus(status, "Chat.ChatMessageDataReader.ReturnLoan");
}
status = nameServer.ReturnLoan(ref nsMsgs, ref nsInfos);
ErrorHandler.checkStatus(status, "Chat.NameServiceDataReader.ReturnLoan");
}
prevCount = livelinessStatus.AliveCount;
}
else if (guard == escape)
{
Console.WriteLine("UserLoad has terminated.");
closed = true;
}
else
{
//System.Diagnostics.Debug.Fail("Unknown Condition");
}
} /* for */
} /* while (!closed) */
/* Remove all Conditions from the WaitSet. */
status = userLoadWS.DetachCondition(escape);
ErrorHandler.checkStatus(status, "DDS.WaitSet.DetachCondition (escape)");
status = userLoadWS.DetachCondition(leftUser);
ErrorHandler.checkStatus(status, "DDS.WaitSet.DetachCondition (leftUser)");
status = userLoadWS.DetachCondition(newUser);
ErrorHandler.checkStatus(status, "DDS.WaitSet.DetachCondition (newUser)");
/* Free all resources */
status = participant.DeleteContainedEntities();
ErrorHandler.checkStatus(status, "DDS.DomainParticipant.DeleteContainedEntities");
status = dpf.DeleteParticipant(participant);
ErrorHandler.checkStatus(status, "DDS.DomainParticipantFactory.DeleteParticipant");
}
internal static DDS.ReturnCode CopyIn(DataReaderQos from, IntPtr to)
{
DDS.ReturnCode result;
if (from != null) {
result = DurabilityQosPolicyMarshaler.CopyIn(
from.Durability, to, offset_durability);
if (result == DDS.ReturnCode.Ok) {
result = DeadlineQosPolicyMarshaler.CopyIn(
from.Deadline, to, offset_deadline);
}
if (result == DDS.ReturnCode.Ok) {
result = LatencyBudgetQosPolicyMarshaler.CopyIn(
from.LatencyBudget, to, offset_latency_budget);
}
if (result == DDS.ReturnCode.Ok) {
result = LivelinessQosPolicyMarshaler.CopyIn(
from.Liveliness, to, offset_liveliness);
}
if (result == DDS.ReturnCode.Ok) {
result = ReliabilityQosPolicyMarshaler.CopyIn(
from.Reliability, to, offset_reliability);
}
if (result == DDS.ReturnCode.Ok) {
result = DestinationOrderQosPolicyMarshaler.CopyIn(
from.DestinationOrder, to, offset_destination_order);
}
if (result == DDS.ReturnCode.Ok) {
result = HistoryQosPolicyMarshaler.CopyIn(
from.History, to, offset_history);
}
if (result == DDS.ReturnCode.Ok) {
result = ResourceLimitsQosPolicyMarshaler.CopyIn(
from.ResourceLimits, to, offset_resource_limits);
}
if (result == DDS.ReturnCode.Ok) {
result = UserDataQosPolicyMarshaler.CopyIn(
from.UserData, to, offset_user_data);
}
if (result == DDS.ReturnCode.Ok) {
result = OwnershipQosPolicyMarshaler.CopyIn(
from.Ownership, to, offset_ownership);
}
if (result == DDS.ReturnCode.Ok) {
result = TimeBasedFilterQosPolicyMarshaler.CopyIn(
from.TimeBasedFilter, to, offset_time_based_filter);
}
if (result == DDS.ReturnCode.Ok) {
result = ReaderDataLifecycleQosPolicyMarshaler.CopyIn(
from.ReaderDataLifecycle, to, offset_reader_data_lifecycle);
}
if (result == DDS.ReturnCode.Ok) {
result = SubscriptionKeyQosPolicyMarshaler.CopyIn(
from.SubscriptionKeys, to, offset_subscription_keys);
}
if (result == DDS.ReturnCode.Ok) {
result = ReaderLifespanQosPolicyMarshaler.CopyIn(
from.ReaderLifespan, to, offset_reader_lifespan);
}
if (result == DDS.ReturnCode.Ok) {
result = ShareQosPolicyMarshaler.CopyIn(
from.Share, to, offset_share);
}
} else {
result = DDS.ReturnCode.BadParameter;
DDS.OpenSplice.OS.Report(
DDS.OpenSplice.ReportType.OS_ERROR,
"DDS.OpenSplice.CustomMarshalers.DataReaderQosMarshaler.CopyIn",
"DDS/OpenSplice/CustomMarshalers/QosToplevelMarshalers.cs",
DDS.ErrorCode.InvalidValue,
"DataReaderQos attribute may not be a null pointer.");
}
return result;
}
public ReturnCode SetQos(DataReaderQos qos)
{
ReturnCode result;
using (OpenSplice.CustomMarshalers.DataReaderQosMarshaler marshaler =
new OpenSplice.CustomMarshalers.DataReaderQosMarshaler())
{
result = marshaler.CopyIn(qos);
if (result == ReturnCode.Ok)
{
result = Gapi.DataReader.set_qos(GapiPeer, marshaler.GapiPtr);
}
}
return result;
}
internal static void CopyOut(IntPtr from, ref DataReaderQos to)
{
if (to == null) to = new DataReaderQos();
DurabilityQosPolicyMarshaler.CopyOut(from, ref to.Durability, offset_durability);
DeadlineQosPolicyMarshaler.CopyOut(from, ref to.Deadline, offset_deadline);
LatencyBudgetQosPolicyMarshaler.CopyOut(from, ref to.LatencyBudget, offset_latency_budget);
LivelinessQosPolicyMarshaler.CopyOut(from, ref to.Liveliness, offset_liveliness);
ReliabilityQosPolicyMarshaler.CopyOut(from, ref to.Reliability, offset_reliability);
DestinationOrderQosPolicyMarshaler.CopyOut(from, ref to.DestinationOrder, offset_destination_order);
HistoryQosPolicyMarshaler.CopyOut(from, ref to.History, offset_history);
ResourceLimitsQosPolicyMarshaler.CopyOut(from, ref to.ResourceLimits, offset_resource_limits);
UserDataQosPolicyMarshaler.CopyOut(from, ref to.UserData, offset_user_data);
OwnershipQosPolicyMarshaler.CopyOut(from, ref to.Ownership, offset_ownership);
TimeBasedFilterQosPolicyMarshaler.CopyOut(from, ref to.TimeBasedFilter, offset_time_based_filter);
ReaderDataLifecycleQosPolicyMarshaler.CopyOut(from, ref to.ReaderDataLifecycle, offset_reader_data_lifecycle);
SubscriptionKeyQosPolicyMarshaler.CopyOut(from, ref to.SubscriptionKeys, offset_subscription_keys);
ReaderLifespanQosPolicyMarshaler.CopyOut(from, ref to.ReaderLifespan, offset_reader_lifespan);
ShareQosPolicyMarshaler.CopyOut(from, ref to.Share, offset_share);
}
internal DDS.ReturnCode CopyIn(DataReaderQos from)
{
cleanupRequired = true;
return CopyIn(from, GapiPtr);
}
GetDataReaderQos (
ref DataReaderQos datareaderQos,
string id)
{
NamedDataReaderQos drQos = new NamedDataReaderQos();
GCHandle qosHandle = GCHandle.Alloc(drQos, GCHandleType.Normal);
ReturnCode result = OpenSplice.Common.QosProvider.GetDataReaderQos(GapiPeer, id, GCHandle.ToIntPtr(qosHandle));
datareaderQos = drQos.DatareaderQos;
qosHandle.Free();
return result;
}
/***
* Operations
***/
public ITopic CreateSimulatedMultitopic(
string name,
string type_name,
string subscription_expression,
string[] expression_parameters)
{
/* Type-specific DDS entities */
ChatMessageDataReader chatMessageDR;
NameServiceDataReader nameServiceDR;
NamedMessageDataWriter namedMessageDW;
/* Query related stuff */
IQueryCondition nameFinder;
string[] nameFinderParams;
/* QosPolicy holders */
TopicQos namedMessageQos = new TopicQos();
SubscriberQos subQos = new SubscriberQos();
PublisherQos pubQos = new PublisherQos();
/* Others */
IDataReader parentReader;
IDataWriter parentWriter;
string partitionName = "ChatRoom";
string nameFinderExpr;
ReturnCode status;
/* Lookup both components that constitute the multi-topic. */
chatMessageTopic = realParticipant.FindTopic(
"Chat_ChatMessage", Duration.Infinite);
ErrorHandler.checkHandle(
chatMessageTopic,
"DDS.DomainParticipant.FindTopic (Chat_ChatMessage)");
nameServiceTopic = realParticipant.FindTopic(
"Chat_NameService", Duration.Infinite);
ErrorHandler.checkHandle(
nameServiceTopic,
"DDS.DomainParticipant.FindTopic (Chat_NameService)");
/* Create a ContentFilteredTopic to filter out
our own ChatMessages. */
filteredMessageTopic = realParticipant.CreateContentFilteredTopic(
"Chat_FilteredMessage",
chatMessageTopic,
"userID <> %0",
expression_parameters);
ErrorHandler.checkHandle(
filteredMessageTopic,
"DDS.DomainParticipant.CreateContentFilteredTopic");
/* Adapt the default SubscriberQos to read from the
"ChatRoom" Partition. */
status = realParticipant.GetDefaultSubscriberQos (ref subQos);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipant.GetDefaultSubscriberQos");
subQos.Partition.Name = new string[1];
subQos.Partition.Name[0] = partitionName;
/* Create a private Subscriber for the multitopic simulator. */
multiSub = realParticipant.CreateSubscriber(subQos);
ErrorHandler.checkHandle(
multiSub,
"DDS.DomainParticipant.CreateSubscriber (for multitopic)");
/* Create a DataReader for the FilteredMessage Topic
(using the appropriate QoS). */
DataReaderQos drQos = new DataReaderQos();
TopicQos topicQos = new TopicQos();
multiSub.GetDefaultDataReaderQos(ref drQos);
filteredMessageTopic.RelatedTopic.GetQos(ref topicQos);
multiSub.CopyFromTopicQos(ref drQos, topicQos);
parentReader = multiSub.CreateDataReader(filteredMessageTopic, drQos);
ErrorHandler.checkHandle(
parentReader, "DDS.Subscriber.create_datareader (ChatMessage)");
/* Narrow the abstract parent into its typed representative. */
chatMessageDR = parentReader as ChatMessageDataReader;
/* Allocate the DataReaderListener Implementation. */
msgListener = new DataReaderListenerImpl();
/* Attach the DataReaderListener to the DataReader,
only enabling the data_available event. */
status = chatMessageDR.SetListener(msgListener, StatusKind.DataAvailable);
ErrorHandler.checkStatus(status, "DDS.DataReader_set_listener");
/* Create a DataReader for the nameService Topic
(using the appropriate QoS). */
DataReaderQos nsDrQos = new DataReaderQos();
TopicQos nsQos = new TopicQos();
nameServiceTopic.GetQos(ref nsQos);
multiSub.CopyFromTopicQos(ref nsDrQos, nsQos);
parentReader = multiSub.CreateDataReader(nameServiceTopic, nsDrQos);
ErrorHandler.checkHandle(parentReader, "DDS.Subscriber.CreateDatareader (NameService)");
/* Narrow the abstract parent into its typed representative. */
nameServiceDR = parentReader as NameServiceDataReader;
/* Define the SQL expression (using a parameterized value). */
nameFinderExpr = "userID = %0";
/* Allocate and assign the query parameters. */
nameFinderParams = new string[1];
nameFinderParams[0] = expression_parameters[0];
/* Create a QueryCondition to only read corresponding
nameService information by key-value. */
nameFinder = nameServiceDR.CreateQueryCondition(
SampleStateKind.Any,
ViewStateKind.Any,
InstanceStateKind.Any,
nameFinderExpr,
nameFinderParams);
ErrorHandler.checkHandle(
nameFinder, "DDS.DataReader.create_querycondition (nameFinder)");
/* Create the Topic that simulates the multi-topic
(use Qos from chatMessage).*/
status = chatMessageTopic.GetQos(ref namedMessageQos);
ErrorHandler.checkStatus(status, "DDS.Topic.GetQos");
/* Create the NamedMessage Topic whose samples simulate
the MultiTopic */
namedMessageTopic = realParticipant.CreateTopic(
"Chat_NamedMessage",
type_name,
namedMessageQos);
ErrorHandler.checkHandle(
namedMessageTopic,
"DDS.DomainParticipant.CreateTopic (NamedMessage)");
/* Adapt the default PublisherQos to write into the
"ChatRoom" Partition. */
status = realParticipant.GetDefaultPublisherQos(ref pubQos);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipant.get_default_publisher_qos");
pubQos.Partition.Name = new string[1];
pubQos.Partition.Name[0] = partitionName;
/* Create a private Publisher for the multitopic simulator. */
multiPub = realParticipant.CreatePublisher(pubQos);
ErrorHandler.checkHandle(
multiPub,
"DDS.DomainParticipant.create_publisher (for multitopic)");
DataWriterQos nmDwQos = new DataWriterQos();
TopicQos nmQos = new TopicQos();
multiPub.GetDefaultDataWriterQos(ref nmDwQos);
namedMessageTopic.GetQos(ref nmQos);
multiPub.CopyFromTopicQos(ref nmDwQos, nmQos);
/* Create a DataWriter for the multitopic. */
parentWriter = multiPub.CreateDataWriter(namedMessageTopic, nmDwQos);
ErrorHandler.checkHandle(
parentWriter, "DDS.Publisher.CreateDatawriter (NamedMessage)");
/* Narrow the abstract parent into its typed representative. */
namedMessageDW = parentWriter as NamedMessageDataWriter;
/* Store the relevant Entities in our Listener. */
msgListener.ChatMessageDR = chatMessageDR;
msgListener.NameServiceDR = nameServiceDR;
msgListener.NamedMessageDW = namedMessageDW;
msgListener.NameFinder = nameFinder;
msgListener.NameFinderParams = nameFinderParams;
/* Return the simulated Multitopic. */
return namedMessageTopic;
}
internal void CopyOut(ref DataReaderQos to)
{
CopyOut(GapiPtr, ref to);
}