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); }