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 ReturnCode CopyFromTopicQos(ref DataWriterQos dataWriterQos, TopicQos topicQos)
{
ReturnCode result = DDS.ReturnCode.BadParameter;
ReportStack.Start();
if (topicQos != null)
{
if (dataWriterQos == null)
{
GetDefaultDataWriterQos(ref dataWriterQos);
}
dataWriterQos.Durability = topicQos.Durability;
dataWriterQos.Deadline = topicQos.Deadline;
dataWriterQos.LatencyBudget = topicQos.LatencyBudget;
dataWriterQos.Liveliness = topicQos.Liveliness;
dataWriterQos.Reliability = topicQos.Reliability;
dataWriterQos.DestinationOrder = topicQos.DestinationOrder;
dataWriterQos.History = topicQos.History;
dataWriterQos.ResourceLimits = topicQos.ResourceLimits;
dataWriterQos.TransportPriority = topicQos.TransportPriority;
dataWriterQos.Lifespan = topicQos.Lifespan;
dataWriterQos.Ownership = topicQos.Ownership;
result = DDS.ReturnCode.Ok;
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public ReturnCode GetMatchedSubscriptionData(
ref SubscriptionBuiltinTopicData subscriptionData,
InstanceHandle subscriptionHandle)
{
ReturnCode result = DDS.ReturnCode.BadParameter;
ReportStack.Start();
if (this.rlReq_isAlive)
{
if (subscriptionHandle != InstanceHandle.Nil)
{
GCHandle dataGCHandle = GCHandle.Alloc(subscriptionData, GCHandleType.Normal);
result = uResultToReturnCode(
User.Writer.GetMatchedSubscriptionData(
rlReq_UserPeer,
subscriptionHandle,
CopyMatchedSubscriptionData,
GCHandle.ToIntPtr(dataGCHandle)));
subscriptionData = dataGCHandle.Target as SubscriptionBuiltinTopicData;
dataGCHandle.Free();
}
else
{
result = ReturnCode.BadParameter;
ReportStack.Report(result, "subscriptionHandle = DDS.InstanceHandle.Nil.");
}
}
else
{
result = DDS.ReturnCode.AlreadyDeleted;
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public ReturnCode GetQos(ref PublisherQos qos)
{
IntPtr userQos = IntPtr.Zero;
ReturnCode result = DDS.ReturnCode.AlreadyDeleted;
ReportStack.Start();
if (this.rlReq_isAlive)
{
result = uResultToReturnCode(
User.Publisher.GetQos(rlReq_UserPeer, ref userQos));
if (result == ReturnCode.Ok)
{
using (OpenSplice.CustomMarshalers.PublisherQosMarshaler marshaler =
new OpenSplice.CustomMarshalers.PublisherQosMarshaler(userQos, true))
{
marshaler.CopyOut(ref qos);
}
}
else
{
ReportStack.Report(result, "Could not copy PublisherQos.");
}
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public ReturnCode GetMatchedPublications(ref InstanceHandle[] publicationHandles)
{
ReturnCode result;
ReportStack.Start();
if (this.rlReq_isAlive)
{
List <InstanceHandle> handleList = new List <InstanceHandle>();
GCHandle listGCHandle = GCHandle.Alloc(handleList, GCHandleType.Normal);
result = uResultToReturnCode(
User.Reader.GetMatchedPublications(
rlReq_UserPeer,
CopyMatchedPublication,
GCHandle.ToIntPtr(listGCHandle)));
handleList = listGCHandle.Target as List <InstanceHandle>;
publicationHandles = handleList.ToArray();
listGCHandle.Free();
}
else
{
result = DDS.ReturnCode.AlreadyDeleted;
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public ReturnCode DeleteContainedEntities()
{
ReturnCode result = DDS.ReturnCode.AlreadyDeleted;
ReportStack.Start();
lock (this)
{
if (this.rlReq_isAlive)
{
result = DDS.ReturnCode.Ok;
foreach (DataWriter dw in writerList)
{
result = dw.deinit();
if (result != DDS.ReturnCode.Ok)
{
break;
}
}
if (result == DDS.ReturnCode.Ok)
{
writerList.Clear();
}
}
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public ReturnCode WaitForHistoricalData(Duration maxWait)
{
ReturnCode result;
ReportStack.Start();
if (QosManager.countErrors(maxWait) > 0)
{
result = DDS.ReturnCode.BadParameter;
}
else
{
if (this.rlReq_isAlive)
{
result = uResultToReturnCode(
User.DataReader.WaitForHistoricalData(rlReq_UserPeer, maxWait.OsDuration));
}
else
{
result = DDS.ReturnCode.AlreadyDeleted;
}
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public ReturnCode SetQos(PublisherQos qos)
{
ReturnCode result = DDS.ReturnCode.AlreadyDeleted;
ReportStack.Start();
if (this.rlReq_isAlive)
{
result = QosManager.checkQos(qos);
if (result == DDS.ReturnCode.Ok)
{
using (OpenSplice.CustomMarshalers.PublisherQosMarshaler marshaler =
new OpenSplice.CustomMarshalers.PublisherQosMarshaler())
{
result = marshaler.CopyIn(qos);
if (result == ReturnCode.Ok)
{
result = uResultToReturnCode(
User.Publisher.SetQos(rlReq_UserPeer, marshaler.UserPtr));
if (result != ReturnCode.Ok)
{
ReportStack.Report(result, "Could not apply PublisherQos.");
}
}
else
{
ReportStack.Report(result, "Could not copy PublisherQos.");
}
}
}
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public ReturnCode DeleteContainedEntities()
{
ReturnCode result = DDS.ReturnCode.AlreadyDeleted;
ReportStack.Start();
lock (this)
{
if (this.rlReq_isAlive)
{
result = DDS.ReturnCode.Ok;
foreach (ReadCondition rc in conditionList)
{
result = rc.deinit();
if (result != DDS.ReturnCode.Ok)
{
break;
}
}
if (result == DDS.ReturnCode.Ok)
{
conditionList.Clear();
}
}
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public virtual ReturnCode Write(
T instanceData,
InstanceHandle instanceHandle,
Time sourceTimestamp)
{
ReturnCode result = DDS.ReturnCode.BadParameter;
ReportStack.Start();
if ((sourceTimestamp == Time.Current) ||
(QosManager.countErrors(sourceTimestamp)) == 0)
{
GCHandle tmpGCHandle = GCHandle.Alloc(instanceData, GCHandleType.Normal);
result = uResultToReturnCode(
User.Writer.Write(
rlReq_UserPeer,
sampleMarshaler.CopyIn,
GCHandle.ToIntPtr(tmpGCHandle),
sourceTimestamp.OsTimeW,
instanceHandle));
tmpGCHandle.Free();
}
ReportStack.Flush(this, (result != ReturnCode.Ok) && (result != ReturnCode.Timeout));
return(result);
}
public ReturnCode SetDefaultDataWriterQos(DataWriterQos 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.DataWriterQosMarshaler marshaler =
new OpenSplice.CustomMarshalers.DataWriterQosMarshaler())
{
result = marshaler.CopyIn(qos);
if (result == ReturnCode.Ok)
{
marshaler.CopyOut(ref defaultDataWriterQos);
}
}
}
}
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public virtual InstanceHandle RegisterInstance(
T instanceData,
Time sourceTimestamp)
{
ReturnCode result = DDS.ReturnCode.BadParameter;
InstanceHandle handle = DDS.InstanceHandle.Nil;
ReportStack.Start();
if ((sourceTimestamp == Time.Current) ||
(QosManager.countErrors(sourceTimestamp) == 0))
{
long uHandle = handle;
GCHandle tmpGCHandle = GCHandle.Alloc(instanceData, GCHandleType.Normal);
result = uResultToReturnCode(
User.Writer.RegisterInstance(
rlReq_UserPeer,
sampleMarshaler.CopyIn,
GCHandle.ToIntPtr(tmpGCHandle),
sourceTimestamp.OsTimeW,
ref uHandle));
handle = uHandle;
tmpGCHandle.Free();
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(handle);
}
public ReturnCode SetExpressionParameters(params string[] expressionParameters)
{
ReturnCode result = DDS.ReturnCode.Unsupported;
ReportStack.Start();
// using (SequenceStringToArrMarshaler marshaler = new SequenceStringToArrMarshaler())
// {
// result = WriteLock();
// if (result == DDS.ReturnCode.Ok)
// {
// result = marshaler.CopyIn(expressionParameters);
// if (result == ReturnCode.Ok)
// {
// result = uResultToReturnCode(
// User.ContentFilteredTopic.Set(rlReq_UserPeer, marshaler.UserPtr, (uint) expressionParameters.Length));
// if (result == ReturnCode.Ok)
// {
// marshaler.CopyOut(ref this.filterParameters); // Make deep copy.
// }
// }
// WriteUnlock();
// }
// }
ReportStack.Report(result, "Operation not yet supported.");
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public virtual ReturnCode ReturnLoan(
ref T[] data,
ref SampleInfo[] sampleInfos)
{
ReturnCode result = DDS.ReturnCode.AlreadyDeleted;
ReportStack.Start();
lock (this)
{
if (this.rlReq_isAlive)
{
if (data != null && sampleInfos != null)
{
if (data.Length == sampleInfos.Length)
{
data = null;
sampleInfos = null;
result = DDS.ReturnCode.Ok;
}
else
{
result = DDS.ReturnCode.PreconditionNotMet;
ReportStack.Report(result, "data and sampleInfo arrays have unequal length");
}
}
else
{
result = DDS.ReturnCode.PreconditionNotMet;
ReportStack.Report(result, "data and/or sampleInfo arrays may not be null");
}
}
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
internal ReturnCode init(DomainParticipant participant, string name, PublisherQos qos)
{
ReturnCode result;
ReportStack.Start();
MyDomainId = participant.MyDomainId;
using (OpenSplice.CustomMarshalers.PublisherQosMarshaler marshaler =
new OpenSplice.CustomMarshalers.PublisherQosMarshaler())
{
result = marshaler.CopyIn(qos);
if (result == ReturnCode.Ok)
{
IntPtr uPublisher = User.Publisher.New(participant.rlReq_UserPeer, name, marshaler.UserPtr, 0);
if (uPublisher != IntPtr.Zero)
{
result = base.init(uPublisher);
}
else
{
result = DDS.ReturnCode.Error;
ReportStack.Report(result, "Could not create Publisher.");
}
}
}
if (result == ReturnCode.Ok)
{
this.participant = participant;
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public ReturnCode GetSampleLostStatus(ref SampleLostStatus status)
{
ReturnCode result;
ReportStack.Start();
if (this.rlReq_isAlive)
{
if (status == null)
{
status = new SampleLostStatus();
}
GCHandle statusGCHandle = GCHandle.Alloc(status, GCHandleType.Normal);
result = uResultToReturnCode(
User.Reader.GetSampleLostStatus(
rlReq_UserPeer, 1, SampleLostStatusMarshaler.CopyOut, GCHandle.ToIntPtr(statusGCHandle)));
status = statusGCHandle.Target as SampleLostStatus;
statusGCHandle.Free();
}
else
{
result = DDS.ReturnCode.AlreadyDeleted;
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public ReturnCode DeleteDataWriter(IDataWriter dataWriter)
{
DataWriter dwObj = dataWriter as DataWriter;
ReturnCode result = DDS.ReturnCode.AlreadyDeleted;
ReportStack.Start();
lock (this)
{
if (this.rlReq_isAlive)
{
if (dwObj != null)
{
if (writerList.Remove(dwObj))
{
result = dwObj.deinit();
if (result != ReturnCode.Ok)
{
writerList.Add(dwObj);
}
}
else
{
/* The DataWriter can be AlreadyDeleted, or it can be from another
* Publisher. Its liveliness cannot be modified without the lock
* of its factory, so we are safe checking it here since we hold
* the lock to this factory. If the DataWriter is from another
* publisher, then the result may be PRECONDITION_NOT_MET while
* it should have been BAD_PARAMETER, but such a Use Case has
* an inherent race-condition anyway, and the result of such
* a test is by definition undefined.
*/
if (dwObj.rlReq_isAlive)
{
result = ReturnCode.PreconditionNotMet;
ReportStack.Report(result, "DataWriter " + dwObj + " unknown to Publisher " + this + ".");
}
else
{
// ALREADY_DELETED may only apply to the Publisher in this context,
// so for a deleted datawriter use BAD_PARAMETER instead.
result = DDS.ReturnCode.BadParameter;
ReportStack.Report(result, "DataWriter " + dwObj + " was already deleted.");
}
}
}
else
{
result = ReturnCode.BadParameter;
ReportStack.Report(result, "datawriter is invalid (null), or not of type " +
"DDS::OpenSplice::DataWriter.");
}
}
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public ReturnCode DeleteReadCondition(IReadCondition condition)
{
ReturnCode result = DDS.ReturnCode.AlreadyDeleted;
ReportStack.Start();
lock (this)
{
if (this.rlReq_isAlive)
{
ReadCondition condObj = condition as ReadCondition;
if (condObj != null)
{
if (conditionList.Remove(condObj))
{
result = condObj.deinit();
if (result != DDS.ReturnCode.Ok)
{
conditionList.Add(condObj);
}
}
else
{
/* The ReadCondition can be AlreadyDeleted, or it can be from another
* DataReader. Its liveliness cannot be modified without the lock
* of its factory, so we are safe checking it here since we hold
* the lock to this factory. If the ReadCondition is from another
* DataReader, then the result may be PRECONDITION_NOT_MET while
* it should have been BAD_PARAMETER, but such a Use Case has
* an inherent race-condition anyway, and the result of such
* a test is by definition undefined.
*/
if (condObj.rlReq_isAlive)
{
result = ReturnCode.PreconditionNotMet;
ReportStack.Report(result, "ReadCondition " + condObj + " unknown to DataReader " + this + ".");
}
else
{
// ALREADY_DELETED may only apply to the DataReader in this context,
// so for a deleted readcondition use BAD_PARAMETER instead.
result = DDS.ReturnCode.BadParameter;
ReportStack.Report(result, "ReadCondition " + condObj + " was already deleted.");
}
}
}
else
{
result = DDS.ReturnCode.BadParameter;
ReportStack.Report(result, "ReadCondition " + condObj + " is of unknown type.");
}
}
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public ReturnCode Enable()
{
ReportStack.Start();
DDS.ReturnCode result = uResultToReturnCode(
User.Entity.Enable(rlReq_UserPeer));
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public ReturnCode EndCoherentChanges()
{
ReportStack.Start();
ReturnCode result = SacsSuperClass.uResultToReturnCode(
User.Publisher.CoherentEnd(rlReq_UserPeer));
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public virtual ReturnCode TakeNextInstanceWithCondition(
ref T[] data,
ref SampleInfo[] sampleInfos,
int maxSamples,
InstanceHandle instanceHandle,
IReadCondition condition)
{
ReturnCode result;
ReadCondition rcObj = condition as ReadCondition;
ReportStack.Start();
if (rcObj == null)
{
result = DDS.ReturnCode.BadParameter;
ReportStack.Report(result, "condition is invalid (null), or not of type " +
"DDS::OpenSplice::ReadCondition.");
}
else
{
IntPtr sampleList = Common.SampleList.New(0);
if (sampleList == IntPtr.Zero)
{
result = DDS.ReturnCode.OutOfResources;
ReportStack.Report(result, "Unable to allocate sampleList.");
}
else
{
lock (this)
{
if (this.rlReq_isAlive)
{
result = wlReq_CheckReaderPreConditions(data, sampleInfos, maxSamples, rcObj);
if (result == DDS.ReturnCode.Ok)
{
int realMax = RealMaxSamples(data, maxSamples);
Common.SampleList.Reset(sampleList, realMax);
result = rcObj.TakeNextInstance(instanceHandle, sampleList);
}
}
else
{
result = DDS.ReturnCode.AlreadyDeleted;
}
}
if (result == DDS.ReturnCode.Ok || result == ReturnCode.NoData)
{
result = ReaderCopy(sampleList, ref data, ref sampleInfos);
}
Common.SampleList.Free(sampleList);
}
}
ReportStack.Flush(this, (result != ReturnCode.Ok) && (result != ReturnCode.NoData));
return(result);
}
public virtual ReturnCode TakeNextInstance(
ref T[] data,
ref SampleInfo[] sampleInfos,
int maxSamples,
InstanceHandle instanceHandle,
SampleStateKind sampleStates,
ViewStateKind viewStates,
InstanceStateKind instanceStates)
{
ReturnCode result;
ReportStack.Start();
IntPtr sampleList = Common.SampleList.New(0);
if (sampleList == IntPtr.Zero)
{
result = DDS.ReturnCode.OutOfResources;
ReportStack.Report(result, "Unable to allocate sampleList.");
}
else
{
lock (this)
{
if (this.rlReq_isAlive)
{
result = CheckReaderPreConditions(data, sampleInfos, maxSamples, sampleStates, viewStates, instanceStates);
if (result == DDS.ReturnCode.Ok)
{
uint mask = StateMask(sampleStates, viewStates, instanceStates);
int realMax = RealMaxSamples(data, maxSamples);
Common.SampleList.Reset(sampleList, realMax);
result = uResultToReturnCode(
User.Reader.TakeNextInstance(
rlReq_UserPeer,
instanceHandle,
mask,
Common.SampleList.ReaderAction,
sampleList, DDS.Duration.Zero.OsDuration));
}
}
else
{
result = DDS.ReturnCode.AlreadyDeleted;
}
}
if (result == DDS.ReturnCode.Ok || result == ReturnCode.NoData)
{
result = ReaderCopy(sampleList, ref data, ref sampleInfos);
}
Common.SampleList.Free(sampleList);
}
ReportStack.Flush(this, (result != ReturnCode.Ok) && (result != ReturnCode.NoData));
return(result);
}
public ReturnCode WaitForHistoricalDataWithCondition(
string filterExpression,
string[] filterParameters,
Time minSourceTimeStamp,
Time maxSourceTimeStamp,
ResourceLimitsQosPolicy resourceLimits,
Duration maxWait)
{
ReturnCode result;
ReportStack.Start();
if (QosManager.countErrors(minSourceTimeStamp) > 0 ||
QosManager.countErrors(maxSourceTimeStamp) > 0 ||
QosManager.countErrors(resourceLimits) > 0 ||
QosManager.countErrors(maxWait) > 0)
{
result = DDS.ReturnCode.BadParameter;
ReportStack.Report(result, "Invalid function parameter(s) passed.");
}
else
{
if (this.rlReq_isAlive)
{
using (SequenceStringToArrMarshaler marshaler = new SequenceStringToArrMarshaler())
{
result = marshaler.CopyIn(filterParameters);
if (result == ReturnCode.Ok)
{
uint length = filterParameters == null ? 0 : (uint)filterParameters.Length;
result = uResultToReturnCode(
User.DataReader.WaitForHistoricalDataWithCondition(
rlReq_UserPeer,
filterExpression,
marshaler.UserPtr,
length,
minSourceTimeStamp.OsTimeW,
maxSourceTimeStamp.OsTimeW,
resourceLimits.MaxSamples,
resourceLimits.MaxInstances,
resourceLimits.MaxSamplesPerInstance,
maxWait.OsDuration));
}
}
}
else
{
result = DDS.ReturnCode.AlreadyDeleted;
}
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public ReturnCode EndAccess()
{
ReturnCode result = DDS.ReturnCode.AlreadyDeleted;
ReportStack.Start();
if (this.rlReq_isAlive)
{
result = uResultToReturnCode(User.Subscriber.EndAccess(rlReq_UserPeer));
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public IReadCondition CreateReadCondition(
SampleStateKind sampleStates,
ViewStateKind viewStates,
InstanceStateKind instanceStates)
{
ReadCondition readCondition = null;
ReturnCode result = DDS.ReturnCode.AlreadyDeleted;
IntPtr uQuery;
ReportStack.Start();
lock (this)
{
if (this.rlReq_isAlive)
{
if (SampleStateMaskIsValid(sampleStates) &&
ViewStateMaskIsValid(viewStates) &&
InstanceStateMaskIsValid(instanceStates))
{
uint stateMask = StateMask(sampleStates, viewStates, instanceStates);
uQuery = User.Query.New(rlReq_UserPeer, null, "1=1", IntPtr.Zero, 0, stateMask);
if (uQuery != IntPtr.Zero)
{
readCondition = new ReadCondition(this, sampleStates, viewStates, instanceStates);
result = readCondition.init(uQuery);
if (result == ReturnCode.Ok)
{
conditionList.Add(readCondition);
}
else
{
ReportStack.Report(result, "Could not create ReadCondition.");
readCondition = null;
}
}
else
{
result = DDS.ReturnCode.Error;
ReportStack.Report(result, "Unable to create ReadCondition in kernel.");
}
}
else
{
result = DDS.ReturnCode.BadParameter;
ReportStack.Report(result, "One mor more of your SampleState/ViewState/InstanceState masks are invalid.");
}
}
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(readCondition);
}
public ReturnCode BeginCoherentChanges()
{
ReturnCode result = DDS.ReturnCode.AlreadyDeleted;
ReportStack.Start();
if (this.rlReq_isAlive)
{
result = SacsSuperClass.uResultToReturnCode(
User.Publisher.CoherentBegin(rlReq_UserPeer));
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public ReturnCode SuspendPublications()
{
ReturnCode result = DDS.ReturnCode.AlreadyDeleted;
ReportStack.Start();
if (this.rlReq_isAlive)
{
result = SacsSuperClass.uResultToReturnCode(
User.Publisher.Suspend(rlReq_UserPeer));
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public ReturnCode SetListener(IPublisherListener listener, StatusKind mask)
{
ReturnCode result = DDS.ReturnCode.AlreadyDeleted;
ReportStack.Start();
lock (this)
{
if (this.rlReq_isAlive)
{
result = wlReq_SetListener(listener, mask);
}
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public ReturnCode AssertLiveliness()
{
ReturnCode result;
ReportStack.Start();
if (this.rlReq_isAlive)
{
result = uResultToReturnCode(
User.Writer.AssertLiveliness(rlReq_UserPeer));
ReportStack.Flush(this, result != ReturnCode.Ok);
}
else
{
result = DDS.ReturnCode.AlreadyDeleted;
}
return(result);
}
public virtual ReturnCode RegisterType(
IDomainParticipant participant,
string typeName,
DatabaseMarshaler marshaler)
{
ReturnCode result = ReturnCode.BadParameter;
DomainParticipant dp;
ReportStack.Start();
if (participant == null)
{
ReportStack.Report(result, "domain '<NULL>' is invalid.");
}
else if (marshaler == null)
{
ReportStack.Report(result, "marshaler '<NULL>' is invalid.");
}
else
{
dp = participant as DomainParticipant;
if (dp == null)
{
ReportStack.Report(result, "domain is invalid, not of type " +
"DDS::OpenSplice::DomainParticipant");
}
else
{
if (typeName == null)
{
typeName = this.typeName;
}
result = dp.nlReq_LoadTypeSupport(this, typeName);
if (result == ReturnCode.AlreadyDeleted)
{
result = ReturnCode.BadParameter;
}
else
{
DatabaseMarshaler.Add(dp, dataType, marshaler);
marshaler.InitEmbeddedMarshalers(dp);
}
}
}
ReportStack.Flush(null, result != ReturnCode.Ok);
return(result);
}
