public ReturnCode GetMatchedPublicationData(
ref PublicationBuiltinTopicData publicationData,
InstanceHandle publicationHandle)
{
ReturnCode result;
ReportStack.Start();
if (publicationHandle != InstanceHandle.Nil)
{
if (this.rlReq_isAlive)
{
GCHandle dataGCHandle = GCHandle.Alloc(publicationData, GCHandleType.Normal);
result = uResultToReturnCode(
User.Reader.GetMatchedPublicationData(
rlReq_UserPeer,
publicationHandle,
CopyMatchedPublicationData,
GCHandle.ToIntPtr(dataGCHandle)));
publicationData = dataGCHandle.Target as PublicationBuiltinTopicData;
dataGCHandle.Free();
}
else
{
result = DDS.ReturnCode.AlreadyDeleted;
}
}
else
{
result = DDS.ReturnCode.BadParameter;
ReportStack.Report(result, "publication_handle 'HANDLE_NIL' is invalid.");
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public void TestLookupInstance()
{
PublicationBuiltinTopicData data = default;
SampleInfo info = new SampleInfo();
DomainParticipant otherParticipant = AssemblyInitializer.Factory.CreateParticipant(AssemblyInitializer.RTPS_DOMAIN);
Assert.IsNotNull(otherParticipant);
otherParticipant.BindRtpsUdpTransportConfig();
Assert.IsTrue(_participant.WaitForParticipants(1, 20_000));
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 publisher = otherParticipant.CreatePublisher();
Assert.IsNotNull(publisher);
DataWriterQos dwQos = TestHelper.CreateNonDefaultDataWriterQos();
dwQos.Ownership.Kind = OwnershipQosPolicyKind.SharedOwnershipQos;
DataWriter dataWriter = publisher.CreateDataWriter(topic, dwQos);
Assert.IsNotNull(dataWriter);
int count = 200;
ReturnCode ret = ReturnCode.NoData;
while (ret != ReturnCode.Ok && count > 0)
{
Thread.Sleep(100);
// Get an existing instance
ret = _dr.ReadNextSample(ref data, info);
count--;
}
Assert.AreEqual(ReturnCode.Ok, ret);
// Lookup for an existing instance
var handle = _dr.LookupInstance(data);
Assert.AreNotEqual(InstanceHandle.HandleNil, handle);
ret = otherParticipant.DeleteContainedEntities();
Assert.AreEqual(ReturnCode.Ok, ret);
TestHelper.TestNonDefaultPublicationData(data);
ret = AssemblyInitializer.Factory.DeleteParticipant(otherParticipant);
Assert.AreEqual(ReturnCode.Ok, ret);
}
public void TestGetKeyValue()
{
// Call GetKeyValue with HandleNil
PublicationBuiltinTopicData 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 publisher = otherParticipant.CreatePublisher();
Assert.IsNotNull(publisher);
DataWriterQos dwQos = TestHelper.CreateNonDefaultDataWriterQos();
dwQos.Ownership.Kind = OwnershipQosPolicyKind.SharedOwnershipQos;
DataWriter dataWriter = publisher.CreateDataWriter(topic, dwQos);
Assert.IsNotNull(dataWriter);
Thread.Sleep(500);
// Get the for an existing instance
ret = _dr.ReadNextSample(ref data, info);
Assert.AreEqual(ReturnCode.Ok, ret);
TestHelper.TestNonDefaultPublicationData(data);
PublicationBuiltinTopicData 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);
}
internal static V_RESULT CopyMatchedPublicationData(IntPtr info, IntPtr arg)
{
__PublicationBuiltinTopicData nativeImage =
(__PublicationBuiltinTopicData)Marshal.PtrToStructure(info, typeof(__PublicationBuiltinTopicData));
GCHandle argGCHandle = GCHandle.FromIntPtr(arg);
PublicationBuiltinTopicData to = argGCHandle.Target as PublicationBuiltinTopicData;
PublicationBuiltinTopicDataMarshaler.CopyOut(ref nativeImage, ref to);
argGCHandle.Target = to;
return(V_RESULT.OK);
}
public static void TestNonDefaultPublicationData(PublicationBuiltinTopicData data)
{
Assert.IsNotNull(data);
Assert.IsNotNull(data.Deadline);
Assert.IsNotNull(data.DestinationOrder);
Assert.IsNotNull(data.Durability);
Assert.IsNotNull(data.DurabilityService);
Assert.IsNotNull(data.LatencyBudget);
Assert.IsNotNull(data.Lifespan);
Assert.IsNotNull(data.Liveliness);
Assert.IsNotNull(data.Ownership);
Assert.IsNotNull(data.OwnershipStrength);
Assert.IsNotNull(data.Reliability);
Assert.IsNotNull(data.UserData);
Assert.IsNotNull(data.Key);
Assert.IsNotNull(data.ParticipantKey);
Assert.IsNotNull(data.GroupData);
Assert.IsNotNull(data.Partition);
Assert.IsNotNull(data.Presentation);
Assert.IsNotNull(data.TopicData);
Assert.IsFalse(string.IsNullOrWhiteSpace(data.TopicName));
Assert.IsFalse(string.IsNullOrWhiteSpace(data.TypeName));
Assert.IsNotNull(data.Deadline.Period);
Assert.AreEqual(5, data.Deadline.Period.Seconds);
Assert.AreEqual(Duration.ZeroNanoseconds, data.Deadline.Period.NanoSeconds);
Assert.AreEqual(DestinationOrderQosPolicyKind.BySourceTimestampDestinationOrderQos, data.DestinationOrder.Kind);
Assert.AreEqual(DurabilityQosPolicyKind.TransientLocalDurabilityQos, data.Durability.Kind);
Assert.AreEqual(HistoryQosPolicyKind.KeepAllHistoryQos, data.DurabilityService.HistoryKind);
Assert.AreEqual(5, data.DurabilityService.HistoryDepth);
Assert.AreEqual(5, data.DurabilityService.MaxInstances);
Assert.AreEqual(5, data.DurabilityService.MaxSamples);
Assert.AreEqual(5, data.DurabilityService.MaxSamplesPerInstance);
Assert.IsNotNull(data.LatencyBudget.Duration);
Assert.AreEqual(5, data.LatencyBudget.Duration.Seconds);
Assert.AreEqual((uint)5, data.LatencyBudget.Duration.NanoSeconds);
Assert.IsNotNull(data.Lifespan.Duration);
Assert.AreEqual(5, data.Lifespan.Duration.Seconds);
Assert.AreEqual((uint)5, data.Lifespan.Duration.NanoSeconds);
Assert.AreEqual(LivelinessQosPolicyKind.ManualByParticipantLivelinessQos, data.Liveliness.Kind);
Assert.IsNotNull(data.Liveliness.LeaseDuration);
Assert.AreEqual(5, data.Liveliness.LeaseDuration.Seconds);
Assert.AreEqual((uint)5, data.Liveliness.LeaseDuration.NanoSeconds);
Assert.AreEqual(OwnershipQosPolicyKind.SharedOwnershipQos, data.Ownership.Kind);
Assert.AreEqual(5, data.OwnershipStrength.Value);
Assert.AreEqual(ReliabilityQosPolicyKind.BestEffortReliabilityQos, data.Reliability.Kind);
Assert.IsNotNull(data.Reliability.MaxBlockingTime);
Assert.AreEqual(5, data.Reliability.MaxBlockingTime.Seconds);
Assert.AreEqual((uint)5, data.Reliability.MaxBlockingTime.NanoSeconds);
Assert.AreEqual(1, data.UserData.Value.Count());
Assert.AreEqual(0x5, data.UserData.Value.First());
}
public void TestTakeNextSample()
{
PublicationBuiltinTopicData data = default;
SampleInfo infos = new SampleInfo();
ReturnCode ret = _dr.TakeNextSample(ref data, infos);
Assert.AreEqual(ReturnCode.NoData, 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 publisher = otherParticipant.CreatePublisher();
Assert.IsNotNull(publisher);
DataWriterQos dwQos = TestHelper.CreateNonDefaultDataWriterQos();
dwQos.Ownership.Kind = OwnershipQosPolicyKind.SharedOwnershipQos;
DataWriter dataWriter = publisher.CreateDataWriter(topic, dwQos);
Assert.IsNotNull(dataWriter);
Thread.Sleep(500);
ret = _dr.TakeNextSample(ref data, infos);
Assert.AreEqual(ReturnCode.Ok, ret);
TestHelper.TestNonDefaultPublicationData(data);
ret = otherParticipant.DeleteContainedEntities();
Assert.AreEqual(ReturnCode.Ok, ret);
ret = AssemblyInitializer.Factory.DeleteParticipant(otherParticipant);
Assert.AreEqual(ReturnCode.Ok, ret);
}
public ReturnCode GetMatchedPublicationData(
ref PublicationBuiltinTopicData publicationData,
InstanceHandle publicationHandle)
{
ReturnCode result;
using (OpenSplice.CustomMarshalers.PublicationBuiltinTopicDataMarshaler marshaler =
new OpenSplice.CustomMarshalers.PublicationBuiltinTopicDataMarshaler())
{
result = Gapi.DataReader.get_matched_publication_data(
GapiPeer,
marshaler.GapiPtr,
publicationHandle);
if (result == ReturnCode.Ok)
{
marshaler.CopyOut(ref publicationData);
}
}
return(result);
}
public override PublicationBuiltinTopicData CopyFrom(PublicationBuiltinTopicData other)
{
throw new NotImplementedException();
}
internal void CopyOut(ref PublicationBuiltinTopicData to)
{
CopyOut(GapiPtr, ref to);
}
internal DDS.ReturnCode CopyIn(PublicationBuiltinTopicData from)
{
cleanupRequired = true;
return CopyIn(from, GapiPtr);
}
internal static void CopyOut(IntPtr from, ref PublicationBuiltinTopicData to)
{
if (to == null) to = new PublicationBuiltinTopicData();
BuiltinTopicKeyMarshaler.CopyOut(from, ref to.Key, offset_key);
BuiltinTopicKeyMarshaler.CopyOut(from, ref to.ParticipantKey, offset_participant_key);
IntPtr namePtr = BaseMarshaler.ReadIntPtr(from, offset_topic_name);
to.TopicName = Marshal.PtrToStringAnsi(namePtr);
IntPtr typeNamePtr = BaseMarshaler.ReadIntPtr(from, offset_type_name);
to.TypeName = Marshal.PtrToStringAnsi(typeNamePtr);
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);
LifespanQosPolicyMarshaler.CopyOut(from, ref to.Lifespan, offset_lifespan);
DestinationOrderQosPolicyMarshaler.CopyOut(from, ref to.DestinationOrder, offset_destination_order);
UserDataQosPolicyMarshaler.CopyOut(from, ref to.UserData, offset_user_data);
OwnershipQosPolicyMarshaler.CopyOut(from, ref to.Ownership, offset_ownership);
OwnershipStrengthQosPolicyMarshaler.CopyOut(from, ref to.OwnershipStrength, offset_ownership_strength);
PresentationQosPolicyMarshaler.CopyOut(from, ref to.Presentation, offset_presentation);
PartitionQosPolicyMarshaler.CopyOut(from, ref to.Partition, offset_partition);
TopicDataQosPolicyMarshaler.CopyOut(from, ref to.TopicData, offset_topic_data);
GroupDataQosPolicyMarshaler.CopyOut(from, ref to.GroupData, offset_group_data);
}
internal static DDS.ReturnCode CopyIn(PublicationBuiltinTopicData from, IntPtr to)
{
DDS.ReturnCode result;
if (from != null) {
result = BuiltinTopicKeyMarshaler.CopyIn(from.Key, to, offset_key);
if (result == DDS.ReturnCode.Ok) {
result = BuiltinTopicKeyMarshaler.CopyIn(from.ParticipantKey, to, offset_participant_key);
}
if (result == DDS.ReturnCode.Ok) {
IntPtr namePtr = Marshal.StringToHGlobalAnsi(from.TopicName);
BaseMarshaler.Write(to, offset_topic_name, namePtr);
IntPtr typeNamePtr = Marshal.StringToHGlobalAnsi(from.TypeName);
BaseMarshaler.Write(to, offset_type_name, typeNamePtr);
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 = LifespanQosPolicyMarshaler.CopyIn(from.Lifespan, to, offset_lifespan);
}
if (result == DDS.ReturnCode.Ok) {
result = DestinationOrderQosPolicyMarshaler.CopyIn(from.DestinationOrder, to, offset_destination_order);
}
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 = OwnershipStrengthQosPolicyMarshaler.CopyIn(from.OwnershipStrength, to, offset_ownership_strength);
}
if (result == DDS.ReturnCode.Ok) {
result = PresentationQosPolicyMarshaler.CopyIn(from.Presentation, to, offset_presentation);
}
if (result == DDS.ReturnCode.Ok) {
result = PartitionQosPolicyMarshaler.CopyIn(from.Partition, to, offset_partition);
}
if (result == DDS.ReturnCode.Ok) {
result = TopicDataQosPolicyMarshaler.CopyIn(from.TopicData, to, offset_topic_data);
}
if (result == DDS.ReturnCode.Ok) {
result = GroupDataQosPolicyMarshaler.CopyIn(from.GroupData, to, offset_group_data);
}
} else {
result = DDS.ReturnCode.BadParameter;
DDS.OpenSplice.OS.Report(
DDS.OpenSplice.ReportType.OS_ERROR,
"DDS.OpenSplice.CustomMarshalers.PublicationBuiltinTopicDataMarshaler.CopyIn",
"DDS/OpenSplice/CustomMarshalers/QosToplevelMarshalers.cs",
DDS.ErrorCode.InvalidValue,
"PublicationBuiltinTopicData attribute may not be a null pointer.");
}
return result;
}
public ReturnCode GetMatchedPublicationData(
ref PublicationBuiltinTopicData publicationData,
InstanceHandle publicationHandle)
{
ReturnCode result;
using (OpenSplice.CustomMarshalers.PublicationBuiltinTopicDataMarshaler marshaler =
new OpenSplice.CustomMarshalers.PublicationBuiltinTopicDataMarshaler())
{
result = Gapi.DataReader.get_matched_publication_data(
GapiPeer,
marshaler.GapiPtr,
publicationHandle);
if (result == ReturnCode.Ok)
{
marshaler.CopyOut(ref publicationData);
}
}
return result;
}
