Exemple #1
0
        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);
        }
Exemple #2
0
        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);
        }
Exemple #3
0
        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);
        }
Exemple #4
0
        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 WaitForAcknowledgments(Duration maxWait)
        {
            ReturnCode result = DDS.ReturnCode.BadParameter;

            if (QosManager.countErrors(maxWait) == 0)
            {
                if (this.rlReq_isAlive)
                {
                    /*result = uResultToReturnCode(
                     *      User.Publisher.WaitForAcknowledgments(rlReq_UserPeer, maxWait.DatabaseTime));*/
                    result = DDS.ReturnCode.Unsupported;
                }
                else
                {
                    result = DDS.ReturnCode.AlreadyDeleted;
                }
            }

            return(result);
        }
        public ReturnCode WaitForAcknowledgments(Duration maxWait)
        {
            ReturnCode result = DDS.ReturnCode.AlreadyDeleted;

            ReportStack.Start();
            if (QosManager.countErrors(maxWait) > 0)
            {
                result = DDS.ReturnCode.BadParameter;
            }
            else
            {
                if (this.rlReq_isAlive)
                {
                    result = uResultToReturnCode(
                        User.Writer.WaitForAcknowledgments(rlReq_UserPeer, maxWait.OsDuration));
                }
            }
            ReportStack.Flush(this, (result != ReturnCode.Ok) && (result != ReturnCode.Timeout));
            return(result);
        }