internal override ReturnCode wlReq_deinit()
{
ReturnCode result = DDS.ReturnCode.Ok;
if (writerList.Count == 0)
{
IPublisherListener pubListener = listener as IPublisherListener;
if (pubListener != null)
{
this.SetListener(pubListener, (DDS.StatusKind) 0);
}
this.DisableCallbacks();
result = base.wlReq_deinit();
if (result == DDS.ReturnCode.Ok)
{
this.participant = null;
}
}
else
{
result = DDS.ReturnCode.PreconditionNotMet;
ReportStack.Report(result, "Publisher " + this + " cannot be deleted since it still contains " +
writerList.Count + " DataWriters.");
}
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);
}
internal override ReturnCode wlReq_deinit()
{
ReturnCode result = DDS.ReturnCode.Ok;
if (conditionList.Count == 0)
{
IDataReaderListener drListener = listener as IDataReaderListener;
if (drListener != null)
{
this.SetListener(drListener, (DDS.StatusKind) 0);
}
this.DisableCallbacks();
result = base.wlReq_deinit();
if (result == DDS.ReturnCode.Ok)
{
if (this.topic != null)
{
result = this.topic.DecrNrUsers();
if (result == DDS.ReturnCode.Ok)
{
this.topic = null;
}
this.subscriber = null;
}
}
}
else
{
result = DDS.ReturnCode.PreconditionNotMet;
ReportStack.Report(result, "DataReader " + this + " cannot be deleted since it still contains " +
conditionList.Count + " Read/QueryConditions.");
}
return(result);
}
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);
}
internal ReturnCode init(Topic relatedTopic)
{
ReturnCode result;
MyDomainId = relatedTopic.MyDomainId;
this.relatedTopic = relatedTopic;
lock (relatedTopic)
{
if (relatedTopic.rlReq_isAlive)
{
result = relatedTopic.ValidateFilter(filterExpression, filterParameters);
if (result == DDS.ReturnCode.Ok)
{
ITopicDescriptionImpl relatedTopicDescr = relatedTopic as ITopicDescriptionImpl;
relatedTopicDescr.wlReq_IncrNrUsers();
this.topicExpression = relatedTopicDescr.rlReq_TopicExpression + " where " + this.filterExpression;
this.typeSupport = relatedTopicDescr.rlReq_TypeSupport;
result = base.init(IntPtr.Zero, false);
}
}
else
{
result = DDS.ReturnCode.BadParameter;
ReportStack.Report(result, "ContentFilteredTopic \"" + topicName + "\" is referring to an already deleted topic.");
}
}
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 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);
}
internal override ReturnCode wlReq_deinit()
{
ReturnCode result = DDS.ReturnCode.Ok;
if (nrUsers > 0)
{
result = DDS.ReturnCode.PreconditionNotMet;
ReportStack.Report(result, "Topic \"" + topicName + "\" still in use by " + nrUsers + " Writers/Readers.");
}
else
{
ITopicListener tpListener = listener as ITopicListener;
if (tpListener != null)
{
this.SetListener(tpListener, (DDS.StatusKind) 0);
}
this.DisableCallbacks();
result = base.wlReq_deinit();
if (result == DDS.ReturnCode.Ok)
{
this.domainParticipant = null;
this.topicName = null;
this.typeName = null;
this.typeSupport = null;
this.topicExpression = null;
}
}
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);
}
internal ReturnCode init(
IntPtr uTopic,
DomainParticipant participant,
string topicName,
string typeName,
TypeSupport ts)
{
MyDomainId = participant.MyDomainId;
ReturnCode result = base.init(uTopic);
if (result == DDS.ReturnCode.Ok)
{
this.domainParticipant = participant;
this.topicName = topicName;
this.typeName = typeName;
this.typeSupport = ts;
this.topicExpression = "select * from " + topicName;
}
else
{
ReportStack.Report(result, "Could not create Topic" + topicName + ".");
}
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 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);
}
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);
}
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 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 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 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);
}
internal static int countErrors(Time o)
{
int errorCount = 0;
if (o.Sec < 0 || o.NanoSec > 1000000000)
{
if (o != Time.Invalid)
{
errorCount++;
ReportStack.Report(DDS.ReturnCode.BadParameter, "Time { " + o.Sec + ", " + o.NanoSec + "} is not properly normalized");
}
}
return(errorCount);
}
internal static int countErrors(Duration o)
{
int errorCount = 0;
if (!((o.Sec == Duration.InfiniteSec &&
o.NanoSec == Duration.InfiniteNanoSec) ||
(o.Sec != Duration.InfiniteSec &&
o.NanoSec < 1000000000)))
{
errorCount++;
ReportStack.Report(DDS.ReturnCode.BadParameter, "Duration { " + o.Sec + ", " + o.NanoSec + "} is not properly normalized");
}
return(errorCount);
}
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);
}
internal ReturnCode init(IntPtr userPtr)
{
ReturnCode result = base.init(userPtr, false);
if (result == DDS.ReturnCode.Ok)
{
myHandle = User.Entity.GetInstanceHandle(userPtr);
if (User.Observable.SetUserData(userPtr, rlReq_HandleSelf) != IntPtr.Zero)
{
ReportStack.Report(result, "Could not initialize Entity.");
result = DDS.ReturnCode.Error;
}
}
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);
}
private ReturnCode Stop()
{
ReturnCode result = DDS.ReturnCode.Ok;
V_RESULT uResult;
switch (State)
{
case ListenerThreadState.RUNNING:
uResult = User.Listener.Trigger(rlReq_UserPeer);
result = uResultToReturnCode(uResult);
if (result == DDS.ReturnCode.Ok)
{
State = ListenerThreadState.STOPPING;
}
break;
case ListenerThreadState.STARTING:
State = ListenerThreadState.STOPPING;
break;
default:
break;
}
while (result == DDS.ReturnCode.Ok &&
State == ListenerThreadState.STOPPING)
{
Monitor.Wait(this);
}
if (ListenerThread != null &&
State == ListenerThreadState.STOPPED)
{
ListenerThread.Join();
ListenerThread = null;
}
if (result != DDS.ReturnCode.Ok)
{
ReportStack.Report(result, "Could not stop listener dispatcher.");
}
Monitor.PulseAll(this);
return(result);
}
internal ReturnCode ValidateFilter(string filterExpression, string[] filterParameters)
{
ReturnCode result = DDS.ReturnCode.BadParameter;
int length = (filterParameters != null) ? filterParameters.Length : 0;
IntPtr qExpr = IntPtr.Zero;
IntPtr qParams = IntPtr.Zero;
ReportStack.Start();
if (length < 100)
{
qExpr = DDS.OpenSplice.Kernel.Parser.parse(filterExpression);
if (qExpr != IntPtr.Zero && length > 0)
{
SequenceStringToCValueArrMarshaler.CopyIn(filterParameters, ref qParams);
}
else
{
ReportStack.Report(result, "ContentFilteredTopic cannot be created. Invalid expression: " + filterExpression);
}
}
else
{
ReportStack.Report(result, "ContentFilteredTopic cannot be created. Too many parameters " + length + " (max = 99)");
}
if (qExpr != IntPtr.Zero)
{
if (User.Topic.ContentFilterValidate2(rlReq_UserPeer, qExpr, qParams) != 0)
{
result = DDS.ReturnCode.Ok;
}
else
{
ReportStack.Report(result, "ContentFilteredTopic cannot be created. Filter invalid: " + filterExpression);
}
if (qParams != IntPtr.Zero)
{
SequenceStringToCValueArrMarshaler.CleanupIn(ref qParams, length);
}
q.dispose(qExpr);
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
internal override ReturnCode wlReq_deinit()
{
ReturnCode result;
if (nrUsers > 0)
{
result = DDS.ReturnCode.PreconditionNotMet;
ReportStack.Report(result, "MultiTopic \"" + topicName + "\" still in use by " + nrUsers + " Writers/Readers.");
}
else
{
result = base.wlReq_deinit();
for (int i = 0; i < relatedTopics.Length && result == DDS.ReturnCode.Ok; i++)
{
result = relatedTopics[i].DecrNrUsers();
}
}
return(result);
}
internal override ReturnCode wlReq_deinit()
{
ReturnCode result;
if (nrUsers > 0)
{
result = DDS.ReturnCode.PreconditionNotMet;
ReportStack.Report(result, "ContentFilteredTopic \"" + topicName + "\" still in use by " + nrUsers + " Writers/Readers.");
}
else
{
result = base.wlReq_deinit();
if (result == DDS.ReturnCode.Ok)
{
result = (relatedTopic as ITopicDescriptionImpl).DecrNrUsers();
}
}
return(result);
}
private ReturnCode Start()
{
ReturnCode result = DDS.ReturnCode.Ok;
switch (State)
{
case ListenerThreadState.STOPPED:
if (StackSize == 0)
{
ListenerThread = new Thread(this.Run);
}
else
{
ListenerThread = new Thread(this.Run, StackSize);
}
ListenerThread.Priority = SchedulingPriority(SchedulingPolicy);
State = ListenerThreadState.STARTING;
ListenerThread.Start();
break;
case ListenerThreadState.STOPPING:
State = ListenerThreadState.RUNNING;
break;
default:
break;
}
while (result == DDS.ReturnCode.Ok &&
State == ListenerThreadState.STOPPING)
{
Monitor.Wait(this);
}
if (result != DDS.ReturnCode.Ok)
{
ReportStack.Report(result, "Could not start listener dispatcher.");
}
Monitor.PulseAll(this);
return(result);
}
internal static ReturnCode checkQos(DataWriterQos o)
{
ReturnCode result = DDS.ReturnCode.BadParameter;
if (o != null)
{
int errorCount = 0;
errorCount += countErrors(o.Durability);
errorCount += countErrors(o.Deadline);
errorCount += countErrors(o.LatencyBudget);
errorCount += countErrors(o.Liveliness);
errorCount += countErrors(o.Reliability);
errorCount += countErrors(o.DestinationOrder);
errorCount += countErrors(o.History);
errorCount += countErrors(o.ResourceLimits);
errorCount += countErrors(o.TransportPriority);
errorCount += countErrors(o.Lifespan);
errorCount += countErrors(o.UserData);
errorCount += countErrors(o.Ownership);
errorCount += countErrors(o.OwnershipStrength);
errorCount += countErrors(o.WriterDataLifecycle);
if (errorCount == 0)
{
result = DDS.ReturnCode.Ok;
if ((o.History.Kind == HistoryQosPolicyKind.KeepLastHistoryQos) &&
(o.ResourceLimits.MaxSamplesPerInstance != Length.Unlimited) &&
(o.History.Depth > o.ResourceLimits.MaxSamplesPerInstance))
{
ReportStack.Report(result,
"HistoryQosPolicy.depth is greater than " +
"ResourceLimitsQosPolicy.max_samples_per_instance.");
result = DDS.ReturnCode.InconsistentPolicy;
}
}
}
else
{
ReportStack.Report(result,
"DataWriterQos 'null' is invalid.");
}
return(result);
}
internal ReturnCode init(Entity entity)
{
ReturnCode result;
ReportStack.Start();
IntPtr userPtr = User.StatusCondition.New(entity.rlReq_UserPeer);
if (userPtr != IntPtr.Zero)
{
this.entity = entity;
enabledStatusMask = StatusKind.Any;
result = base.init(userPtr, false);
}
else
{
result = DDS.ReturnCode.Error;
ReportStack.Report(result, "Could not create StatusCondition.");
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}