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