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 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 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 DeleteReadCondition(IReadCondition condition)
{
ReturnCode result = ReturnCode.BadParameter;
ReadCondition conditionObj = condition as ReadCondition;
if (conditionObj != null)
{
result = Gapi.DataReader.delete_readcondition(
GapiPeer,
conditionObj.GapiPeer);
}
return(result);
}
public IReadCondition CreateReadCondition(
SampleStateKind sampleStates,
ViewStateKind viewStates,
InstanceStateKind instanceStates)
{
IReadCondition readCondition = null;
IntPtr gapiPtr = Gapi.DataReader.create_readcondition(
GapiPeer,
sampleStates,
viewStates,
instanceStates);
if (gapiPtr != IntPtr.Zero)
{
readCondition = new ReadCondition(gapiPtr);
}
return(readCondition);
}
internal ReturnCode wlReq_CheckReaderPreConditions(
T[] data,
SampleInfo[] sampleInfos,
int maxSamples,
ReadCondition condition)
{
ReturnCode result;
if (maxSamples >= Length.Unlimited)
{
if (rlReq_ConditionList.Contains(condition))
{
if ((data == null && sampleInfos == null) ||
(data != null && sampleInfos != null && data.Length == sampleInfos.Length))
{
if (data == null || data.Length == 0 || data.Length >= maxSamples || maxSamples == DDS.Length.Unlimited)
{
result = DDS.ReturnCode.Ok;
}
else
{
result = DDS.ReturnCode.PreconditionNotMet;
}
}
else
{
result = DDS.ReturnCode.PreconditionNotMet;
}
}
else
{
result = DDS.ReturnCode.PreconditionNotMet;
}
}
else
{
result = DDS.ReturnCode.BadParameter;
}
return(result);
}
public IReadCondition CreateReadCondition(
SampleStateKind sampleStates,
ViewStateKind viewStates,
InstanceStateKind instanceStates)
{
IReadCondition readCondition = null;
IntPtr gapiPtr = Gapi.DataReader.create_readcondition(
GapiPeer,
sampleStates,
viewStates,
instanceStates);
if (gapiPtr != IntPtr.Zero)
{
readCondition = new ReadCondition(gapiPtr);
}
return readCondition;
}
