private InstancePersistenceEvent FindEventHelper(InstancePersistenceEvent eventType, out InstanceOwner instanceOwner, bool withReset) { instanceOwner = null; InstanceOwner[] instanceOwners = base.GetInstanceOwners(); if (instanceOwners.Length > 0) { foreach (InstanceOwner owner in instanceOwners) { if (owner.InstanceOwnerId == this.storeLock.LockOwnerId) { instanceOwner = owner; break; } } if (instanceOwner != null) { if (withReset) { base.ResetEvent(eventType, instanceOwner); } foreach (InstancePersistenceEvent event2 in base.GetEvents(instanceOwner)) { if (event2 == eventType) { return(event2); } } } } return(null); }
internal void UpdateEventStatus(bool signalEvent, InstancePersistenceEvent eventToUpdate) { InstanceOwner owner; InstancePersistenceEvent persistenceEvent = this.FindEventWithReset(eventToUpdate, out owner); if ((persistenceEvent != null) && signalEvent) { base.SignalEvent(persistenceEvent, owner); } }
internal InstancePersistenceEvent AddHandleToEvent(InstanceHandle handle, InstancePersistenceEvent persistenceEvent, InstanceOwner owner) { lock (this.ThisLock) { InstanceNormalEvent ownerEventHelper = this.GetOwnerEventHelper(persistenceEvent, owner); ownerEventHelper.BoundHandles.Add(handle); ownerEventHelper.PendingHandles.Remove(handle); return (ownerEventHelper.IsSignaled ? ownerEventHelper : null); } }
internal void UpdateEventStatus(bool signalEvent, InstancePersistenceEvent eventToUpdate) { // FindEventWithReset will allow the event to be cleaned up, even if it is signalled. The returned event will // always be reset. InstanceOwner instanceOwner; InstancePersistenceEvent requiredEvent = this.FindEventWithReset(eventToUpdate, out instanceOwner); if (requiredEvent != null) { if (signalEvent) { base.SignalEvent(requiredEvent, instanceOwner); } } }
InstancePersistenceEvent FindEventHelper(InstancePersistenceEvent eventType, out InstanceOwner instanceOwner, bool withReset) { instanceOwner = null; InstanceOwner[] instanceOwners = GetInstanceOwners(); if (instanceOwners.Length > 0) { foreach (InstanceOwner owner in instanceOwners) { if (owner.InstanceOwnerId == this.storeLock.LockOwnerId) { instanceOwner = owner; break; } } if (instanceOwner != null) { // Reset first. That will allow the event to be cleaned up, so GetEvents won't return it (it will always return signalled events). if (withReset) { base.ResetEvent(eventType, instanceOwner); } InstancePersistenceEvent[] registeredEvents = base.GetEvents(instanceOwner); foreach (InstancePersistenceEvent persistenceEvent in registeredEvents) { if (persistenceEvent == eventType) { return(persistenceEvent); } } } } return(null); }
internal void PendHandleToEvent(InstanceHandle handle, InstancePersistenceEvent persistenceEvent, InstanceOwner owner) { lock (this.ThisLock) { this.GetOwnerEventHelper(persistenceEvent, owner).PendingHandles.Add(handle); } }
protected void ResetEvent(InstancePersistenceEvent persistenceEvent, InstanceOwner owner) { if (persistenceEvent == null) { throw Fx.Exception.ArgumentNull("persistenceEvent"); } if (owner == null) { throw Fx.Exception.ArgumentNull("owner"); } InstanceNormalEvent normal; lock (ThisLock) { WeakReference ownerReference; if (!this.owners.TryGetValue(owner.InstanceOwnerId, out ownerReference) || !object.ReferenceEquals(ownerReference.Target, owner)) { throw Fx.Exception.Argument("owner", SRCore.OwnerBelongsToWrongStore); } if (!owner.Events.TryGetValue(persistenceEvent.Name, out normal)) { return; } if (normal.IsSignaled) { normal.IsSignaled = false; if (normal.BoundHandles.Count == 0 && normal.PendingHandles.Count == 0) { owner.Events.Remove(persistenceEvent.Name); } } } }
private InstanceNormalEvent GetOwnerEventHelper(InstancePersistenceEvent persistenceEvent, InstanceOwner owner) { InstanceNormalEvent event2; if (!owner.Events.TryGetValue(persistenceEvent.Name, out event2)) { event2 = new InstanceNormalEvent(persistenceEvent); owner.Events.Add(persistenceEvent.Name, event2); } return event2; }
internal InstancePersistenceEvent FindEvent(InstancePersistenceEvent eventType, out InstanceOwner instanceOwner) { return(FindEventHelper(eventType, out instanceOwner, false)); }
internal void EventReady(InstancePersistenceEvent persistenceEvent) { WaitForEventsAsyncResult resultToComplete = null; lock (ThisLock) { if (this.waitResult != null) { resultToComplete = this.waitResult; this.waitResult = null; } } if (resultToComplete != null) { resultToComplete.Signaled(persistenceEvent); } }
internal void BindOwnerEvent(InstancePersistenceEvent persistenceEvent) { lock (this.ThisLock) { if (this.IsValid && ((this.boundOwnerEvents == null) || !this.boundOwnerEvents.Contains(persistenceEvent.Name))) { if (this.pendingOwnerEvents == null) { this.pendingOwnerEvents = new HashSet<InstancePersistenceEvent>(); } else if (this.pendingOwnerEvents.Contains(persistenceEvent)) { goto Label_0085; } this.pendingOwnerEvents.Add(persistenceEvent); this.Store.PendHandleToEvent(this, persistenceEvent, this.Owner); } Label_0085:; } }
private InstancePersistenceEvent FindEventHelper(InstancePersistenceEvent eventType, out InstanceOwner instanceOwner, bool withReset) { instanceOwner = null; InstanceOwner[] instanceOwners = base.GetInstanceOwners(); if (instanceOwners.Length > 0) { foreach (InstanceOwner owner in instanceOwners) { if (owner.InstanceOwnerId == this.storeLock.LockOwnerId) { instanceOwner = owner; break; } } if (instanceOwner != null) { if (withReset) { base.ResetEvent(eventType, instanceOwner); } foreach (InstancePersistenceEvent event2 in base.GetEvents(instanceOwner)) { if (event2 == eventType) { return event2; } } } } return null; }
internal void UpdateEventStatus(bool signalEvent, InstancePersistenceEvent eventToUpdate) { InstanceOwner owner; InstancePersistenceEvent persistenceEvent = this.FindEventWithReset(eventToUpdate, out owner); if ((persistenceEvent != null) && signalEvent) { base.SignalEvent(persistenceEvent, owner); } }
protected void SignalEvent(InstancePersistenceEvent persistenceEvent, InstanceOwner owner) { InstanceNormalEvent ownerEventHelper; if (persistenceEvent == null) { throw Fx.Exception.ArgumentNull("persistenceEvent"); } if (owner == null) { throw Fx.Exception.ArgumentNull("owner"); } InstanceHandle[] handleArray = null; lock (this.ThisLock) { WeakReference reference; if (!this.owners.TryGetValue(owner.InstanceOwnerId, out reference) || !object.ReferenceEquals(reference.Target, owner)) { throw Fx.Exception.Argument("owner", SRCore.OwnerBelongsToWrongStore); } ownerEventHelper = this.GetOwnerEventHelper(persistenceEvent, owner); if (!ownerEventHelper.IsSignaled) { ownerEventHelper.IsSignaled = true; if (ownerEventHelper.BoundHandles.Count > 0) { handleArray = ownerEventHelper.BoundHandles.ToArray<InstanceHandle>(); } } } if (handleArray != null) { foreach (InstanceHandle handle in handleArray) { handle.EventReady(ownerEventHelper); } } }
protected void ResetEvent(InstancePersistenceEvent persistenceEvent, InstanceOwner owner) { if (persistenceEvent == null) { throw Fx.Exception.ArgumentNull("persistenceEvent"); } if (owner == null) { throw Fx.Exception.ArgumentNull("owner"); } lock (this.ThisLock) { InstanceNormalEvent event2; WeakReference reference; if (!this.owners.TryGetValue(owner.InstanceOwnerId, out reference) || !object.ReferenceEquals(reference.Target, owner)) { throw Fx.Exception.Argument("owner", SRCore.OwnerBelongsToWrongStore); } if (owner.Events.TryGetValue(persistenceEvent.Name, out event2) && event2.IsSignaled) { event2.IsSignaled = false; if ((event2.BoundHandles.Count == 0) && (event2.PendingHandles.Count == 0)) { owner.Events.Remove(persistenceEvent.Name); } } } }
protected void SignalEvent(InstancePersistenceEvent persistenceEvent, InstanceOwner owner) { if (persistenceEvent == null) { throw Fx.Exception.ArgumentNull("persistenceEvent"); } if (owner == null) { throw Fx.Exception.ArgumentNull("owner"); } InstanceNormalEvent normal; InstanceHandle[] handlesToNotify = null; lock (ThisLock) { WeakReference ownerReference; if (!this.owners.TryGetValue(owner.InstanceOwnerId, out ownerReference) || !object.ReferenceEquals(ownerReference.Target, owner)) { throw Fx.Exception.Argument("owner", SRCore.OwnerBelongsToWrongStore); } normal = GetOwnerEventHelper(persistenceEvent, owner); if (!normal.IsSignaled) { normal.IsSignaled = true; if (normal.BoundHandles.Count > 0) { handlesToNotify = normal.BoundHandles.ToArray(); } } } if (handlesToNotify != null) { foreach (InstanceHandle handle in handlesToNotify) { handle.EventReady(normal); } } }
InstancePersistenceEvent FindEventHelper(InstancePersistenceEvent eventType, out InstanceOwner instanceOwner, bool withReset) { instanceOwner = null; InstanceOwner[] instanceOwners = GetInstanceOwners(); if (instanceOwners.Length > 0) { foreach (InstanceOwner owner in instanceOwners) { if (owner.InstanceOwnerId == this.storeLock.LockOwnerId) { instanceOwner = owner; break; } } if (instanceOwner != null) { // Reset first. That will allow the event to be cleaned up, so GetEvents won't return it (it will always return signalled events). if (withReset) { base.ResetEvent(eventType, instanceOwner); } InstancePersistenceEvent[] registeredEvents = base.GetEvents(instanceOwner); foreach (InstancePersistenceEvent persistenceEvent in registeredEvents) { if (persistenceEvent == eventType) { return persistenceEvent; } } } } return null; }
internal void UpdateEventStatus(bool signalEvent, InstancePersistenceEvent eventToUpdate) { // FindEventWithReset will allow the event to be cleaned up, even if it is signalled. The returned event will // always be reset. InstanceOwner instanceOwner; InstancePersistenceEvent requiredEvent = this.FindEventWithReset(eventToUpdate, out instanceOwner); if (requiredEvent != null) { if (signalEvent) { base.SignalEvent(requiredEvent, instanceOwner); } } }
internal InstanceNormalEvent(InstancePersistenceEvent persistenceEvent) : base(persistenceEvent.Name) { }
public void BindEvent (InstancePersistenceEvent persistenceEvent) { throw new NotImplementedException (); }
internal InstancePersistenceEvent FindEventWithReset(InstancePersistenceEvent eventType, out InstanceOwner instanceOwner) { return(this.FindEventHelper(eventType, out instanceOwner, true)); }
internal void PendHandleToEvent(InstanceHandle handle, InstancePersistenceEvent persistenceEvent, InstanceOwner owner) { lock (ThisLock) { Fx.Assert(this.owners.ContainsKey(owner.InstanceOwnerId), "InstanceHandle called PendHandleToEvent on wrong InstanceStore!!"); Fx.Assert(object.ReferenceEquals(this.owners[owner.InstanceOwnerId].Target, owner), "How did multiple of the same owner become simultaneously active?"); InstanceNormalEvent normal = GetOwnerEventHelper(persistenceEvent, owner); Fx.Assert(!normal.PendingHandles.Contains(handle), "Should not have already pended the handle."); Fx.Assert(!normal.BoundHandles.Contains(handle), "Should not be able to pend an already-bound handle."); normal.PendingHandles.Add(handle); } }
internal InstancePersistenceEvent FindEvent(InstancePersistenceEvent eventType, out InstanceOwner instanceOwner) { return this.FindEventHelper(eventType, out instanceOwner, false); }
internal InstancePersistenceEvent AddHandleToEvent(InstanceHandle handle, InstancePersistenceEvent persistenceEvent, InstanceOwner owner) { lock (ThisLock) { Fx.Assert(this.owners.ContainsKey(owner.InstanceOwnerId), "InstanceHandle called AddHandleToEvent on wrong InstanceStore!!"); Fx.Assert(object.ReferenceEquals(this.owners[owner.InstanceOwnerId].Target, owner), "How did multiple instances of the same owner become simultaneously active?"); InstanceNormalEvent normal = GetOwnerEventHelper(persistenceEvent, owner); Fx.Assert(normal.PendingHandles.Contains(handle), "Should have already pended the handle."); Fx.Assert(!normal.BoundHandles.Contains(handle), "Should not be able to add a handle to an event twice."); normal.BoundHandles.Add(handle); normal.PendingHandles.Remove(handle); return normal.IsSignaled ? normal : null; } }
internal InstancePersistenceEvent FindEventWithReset(InstancePersistenceEvent eventType, out InstanceOwner instanceOwner) { return this.FindEventHelper(eventType, out instanceOwner, true); }
// Must be called under ThisLock. Doesn't validate the InstanceOwner. InstanceNormalEvent GetOwnerEventHelper(InstancePersistenceEvent persistenceEvent, InstanceOwner owner) { InstanceNormalEvent normal; if (!owner.Events.TryGetValue(persistenceEvent.Name, out normal)) { normal = new InstanceNormalEvent(persistenceEvent); owner.Events.Add(persistenceEvent.Name, normal); } return normal; }
internal void BindOwnerEvent(InstancePersistenceEvent persistenceEvent) { lock (ThisLock) { Fx.Assert(OperationPending, "Should only be called during an operation."); Fx.Assert(AcquirePending == null, "Should only be called after acquiring the transaction."); Fx.Assert(Owner != null, "Must be bound to owner to have an owner-scoped event."); if (IsValid && (this.boundOwnerEvents == null || !this.boundOwnerEvents.Contains(persistenceEvent.Name))) { if (this.pendingOwnerEvents == null) { this.pendingOwnerEvents = new HashSet<InstancePersistenceEvent>(); } else if (this.pendingOwnerEvents.Contains(persistenceEvent)) { return; } this.pendingOwnerEvents.Add(persistenceEvent); Store.PendHandleToEvent(this, persistenceEvent, Owner); } } }
protected void SignalEvent (InstancePersistenceEvent persistenceEvent, InstanceOwner owner) { throw new NotImplementedException (); }
internal void Signaled(InstancePersistenceEvent persistenceEvent) { this.Signaled(new List<InstancePersistenceEvent>(1) { persistenceEvent }); }
internal InstanceNormalEvent(InstancePersistenceEvent persistenceEvent) : base(persistenceEvent.Name) { this.boundHandles = new HashSet<InstanceHandle>(); this.pendingHandles = new HashSet<InstanceHandle>(); }
internal void EventReady(InstancePersistenceEvent persistenceEvent) { WaitForEventsAsyncResult waitResult = null; lock (this.ThisLock) { if (this.waitResult != null) { waitResult = this.waitResult; this.waitResult = null; } } if (waitResult != null) { waitResult.Signaled(persistenceEvent); } }
public void BindEvent(InstancePersistenceEvent persistenceEvent) { if (persistenceEvent == null) { throw Fx.Exception.ArgumentNull("persistenceEvent"); } ThrowIfNotActive("BindEvent"); if (!InstanceView.IsBoundToInstanceOwner) { throw Fx.Exception.AsError(new InvalidOperationException(SRCore.ContextMustBeBoundToOwner)); } IsHandleDoomedByRollback = true; InstanceHandle.BindOwnerEvent(persistenceEvent); }