public void Cancelled(CancelledCallback cancelled)
{
if (cancelled == null)
{
return;
}
lock (_guard)
{
if (IsCompleted)
{
if (State == PromiseState.Cancelled)
{
cancelled(_exception as CancelledException);
}
}
else
{
_rejected += (ex, s) => {
var cancel = ex as CancelledException;
if (cancel != null)
{
cancelled(cancel);
}
};
}
}
}
private void HandleCompletedPromise(Promise previous)
{
try {
HandleResult(previous.State, previous.Value);
} catch (Exception ex) {
RejectCallback.Call(EcmaValue.Undefined, EcmaValueUtility.GetValueFromException(ex));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Change<T>"/> class.
/// </summary>
/// <param name="owner">The owner.</param>
/// <param name="valueToCache">The value to cache.</param>
/// <param name="rejectCallback">The reject callback.</param>
/// <param name="commitCallback">The commit callback.</param>
/// <param name="description">The description.</param>
protected Change(Object owner, T valueToCache, RejectCallback <T> rejectCallback, CommitCallback <T> commitCallback, string description)
{
Ensure.That(owner).Named("owner").IsNotNull();
Ensure.That(rejectCallback).Named("rejectCallback").IsNotNull();
this.Owner = owner;
this.CachedValue = valueToCache;
this._rejectCallback = rejectCallback;
this._commitCallback = commitCallback;
this.Description = description;
}
public void generic_iChange_commit_invoked_with_outOfRange_rejectReason()
{
var owner = new Object();
var value = "Foo";
RejectCallback <string> rc = e => { };
CommitCallback <string> cc = e => { };
var description = string.Empty;
var reason = (CommitReason)1000;
var target = new ChangeMock <string>(owner, value, rc, cc, description);
target.Commit(reason);
}
public void generic_iChange_reject_invoked_with_invalid_rejectReason()
{
var owner = new Object();
var value = "Foo";
RejectCallback <string> rc = e => { };
CommitCallback <string> cc = null;
var description = string.Empty;
var reason = RejectReason.None;
var target = new ChangeMock <string>(owner, value, rc, cc, description);
target.Reject(reason);
}
/// <summary>
/// Caches the supplied item in the active change tracking service.
/// </summary>
/// <typeparam name="T">The system type of the item to cache.</typeparam>
/// <param name="propertyName">Name of the property.</param>
/// <param name="value">The value to cache.</param>
/// <param name="restore">A delegate to call when the change tracking
/// service needs to restore the cached change.</param>
/// <param name="commit">A delegate to call when the change tracking
/// service needs to commit the cached change. Passing a null item for
/// this parameter means that this instance does not need to be notified when
/// the change is committed.</param>
/// <param name="direction">The direction.</param>
/// <returns>
/// A reference to the cached change as an instance of <see cref="IChange"/> interface.
/// </returns>
protected IChange CacheChange <T>(string propertyName, T value, RejectCallback <T> restore, CommitCallback <T> commit, AddChangeBehavior direction)
{
this.EnsureNotDisposed();
if (this.IsTracking)
{
IChange iChange = new PropertyValueChange <T>(this, propertyName, value, restore, commit, string.Empty);
((IMemento)this).Memento.Add(iChange, direction);
return(iChange);
}
return(null);
}
public void generic_iChange_getChangedEntities()
{
var owner = new Object();
var value = "Foo";
RejectCallback <string> rc = e => { };
CommitCallback <string> cc = e => { };
var description = string.Empty;
var target = new ChangeMock <string>(owner, value, rc, cc, description);
IEnumerable <Object> ce = target.GetChangedEntities();
ce.Should().Not.Be.Null();
ce.Count().Should().Be.EqualTo(1);
ce.First().Should().Be.EqualTo(owner);
}
public void generic_iChange_rejectCallback_is_invoked_on_reject()
{
var invoked = false;
var owner = new Object();
var value = "Foo";
RejectCallback <string> rc = e => { invoked = true; };
CommitCallback <string> cc = null;
var description = string.Empty;
var target = new ChangeMock <string>(owner, value, rc, cc, description);
target.Reject(RejectReason.Undo);
invoked.Should().Be.True();
}
public void generic_iChange_properties_tests()
{
var owner = new Object();
var value = "Foo";
RejectCallback <string> rc = e => { };
CommitCallback <string> cc = e => { };
var description = string.Empty;
var target = new ChangeMock <string>(owner, value, rc, cc, description);
target.Should().Not.Be.Null();
target.Owner.Should().Be.EqualTo(owner);
target.CachedValue.Should().Be.EqualTo(value);
target.Description.Should().Be.EqualTo(description);
target.IsCommitSupported.Should().Be.True();
}
public void generic_iChange_committed_fired()
{
int expected = 1;
int actual = 0;
var owner = new Object();
var value = "Foo";
RejectCallback <string> rc = e => { };
CommitCallback <string> cc = null;
var description = string.Empty;
var reason = CommitReason.AcceptChanges;
var target = new ChangeMock <string>(owner, value, rc, cc, description);
target.Committed += (s, e) => { actual++; };
target.Commit(reason);
actual.Should().Be.EqualTo(expected);
}
public void generic_iChange_rejectCallback_is_invoked_with_expected_values()
{
ChangeRejectedEventArgs <string> expected = null;
var owner = new Object();
var value = "Foo";
RejectCallback <string> rc = e => { expected = e; };
CommitCallback <string> cc = null;
var description = string.Empty;
var reason = RejectReason.Undo;
var target = new ChangeMock <string>(owner, value, rc, cc, description);
target.Reject(reason);
expected.Should().Not.Be.Null();
expected.Source.Should().Be.EqualTo(target);
expected.Reason.Should().Be.EqualTo(reason);
expected.Entity.Should().Be.EqualTo(owner);
expected.CachedValue.Should().Be.EqualTo(value);
}
RejectCallback <T> GetRejectCallback <T>(string propertyName)
{
Delegate d;
if (!this.rejectCallbacks.TryGetValue(propertyName, out d))
{
RejectCallback <T> callback = (pcr) =>
{
var owner = (MementoEntity)pcr.Source.Owner;
var actualValue = owner.GetPropertyValue <T>(propertyName);
var cb = this.GetRejectCallback <T>(propertyName);
owner.CacheChangeOnRejectCallback(propertyName, actualValue, cb, null, pcr);
owner.SetPropertyValueCore(propertyName, pcr.CachedValue, null);
};
this.rejectCallbacks.Add(propertyName, callback);
d = callback;
}
return((RejectCallback <T>)d);
}
/// <summary>
/// Initializes a new instance of the <see cref="CollectionClearedChange<T>"/> class.
/// </summary>
/// <param name="owner">The owner.</param>
/// <param name="descriptor">The descriptor.</param>
/// <param name="rejectCallback">The reject callback.</param>
/// <param name="commitCallback">The commit callback.</param>
/// <param name="description">The description.</param>
public CollectionClearedChange(Object owner, CollectionRangeDescriptor <T> descriptor, RejectCallback <CollectionRangeDescriptor <T> > rejectCallback, CommitCallback <CollectionRangeDescriptor <T> > commitCallback, string description)
: base(owner, descriptor, rejectCallback, commitCallback, description)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertyValueChange<T>"/> class.
/// </summary>
/// <param name="owner">The owner.</param>
/// <param name="propertyName">Name of the property.</param>
/// <param name="value">The value.</param>
/// <param name="restoreCallback">The restore callback.</param>
/// <param name="description">The description.</param>
public PropertyValueChange(Object owner, string propertyName, T value, RejectCallback <T> restoreCallback, string description)
: this(owner, propertyName, value, restoreCallback, null, description)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertyValueChange<T>"/> class.
/// </summary>
/// <param name="owner">The owner.</param>
/// <param name="propertyName">Name of the property.</param>
/// <param name="value">The value.</param>
/// <param name="restoreCallback">The restore callback.</param>
/// <param name="commitCallback">The commit callback.</param>
/// <param name="description">The description.</param>
public PropertyValueChange(Object owner, string propertyName, T value, RejectCallback <T> restoreCallback, CommitCallback <T> commitCallback, string description)
: base(owner, value, restoreCallback, commitCallback, description)
{
this.PropertyName = propertyName;
}
internal IChange InvokeCacheChangeOnRejectCallback <T>(T value, RejectCallback <T> rejectCallback, CommitCallback <T> commitCallback, ChangeRejectedEventArgs <T> args)
{
return(base.CacheChangeOnRejectCallback("property-name", value, rejectCallback, commitCallback, args));
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertyValueChange<T>"/> class.
/// </summary>
/// <param name="owner">The owner.</param>
/// <param name="propertyName">Name of the property.</param>
/// <param name="value">The value.</param>
/// <param name="restoreCallback">The restore callback.</param>
public PropertyValueChange(Object owner, string propertyName, T value, RejectCallback <T> restoreCallback)
: this(owner, propertyName, value, restoreCallback, null, string.Empty)
{
}
public ChangeMock(object owner, T valueToCache, RejectCallback <T> rejectCallback, CommitCallback <T> commitCallback, string description)
: base(owner, valueToCache, rejectCallback, commitCallback, description)
{
}
internal IChange InvokeCacheChange <T>(T value, RejectCallback <T> rc, CommitCallback <T> cc, AddChangeBehavior behavior)
{
return(base.CacheChange("property-name", value, rc, cc, behavior));
}
public abstract Promise Then(ResolveCallback then, RejectCallback fail);
/// <summary>
/// Called when during the inizialization process,
/// override this method to be notified when the default
/// ctor has been called.
/// </summary>
protected override void OnInitialize()
{
base.OnInitialize();
#region itemAddedRejectCallback
itemAddedRejectCallback = args =>
{
this.SuspendCaching();
switch (args.Reason)
{
case RejectReason.Undo:
/*
* Stiamo facendo l'Undo di un elemento
* che è stato aggiunto:
* - lo rimuoviamo;
* - lo aggiungiamo alla coda delle Redo
*/
this.Remove(args.CachedValue.Item);
this.Memento.Add(args.Source.Clone(), AddChangeBehavior.UndoRequest);
break;
case RejectReason.Redo:
/*
* Stiamo facendo la Redo di un elemento che è
* stato aggiunto:
* - dobbiamo riaggiungerlo;
* - lo aggiungiamo alla coda delle Undo
*/
this.Add(args.CachedValue.Item);
this.Memento.Add(args.Source.Clone(), AddChangeBehavior.RedoRequest);
break;
case RejectReason.RejectChanges:
case RejectReason.Revert:
/*
* Stiamo resettando lo stato di un elemento
* che è stato aggiunto:
* - ci limitiamo a rimuoverlo
*/
this.Remove(args.CachedValue.Item);
break;
}
this.ResumeCaching();
};
#endregion
#region itemMovedRejectCallback
this.itemMovedRejectCallback = args =>
{
this.SuspendCaching();
switch (args.Reason)
{
case RejectReason.Undo:
/*
* Stiamo facendo l'Undo di un elemento
* che è stato spostato:
* - lo rimettiamo al suo posto;
* - lo aggiungiamo alla coda delle Redo;
*/
this.Move(args.CachedValue.NewIndex, args.CachedValue.OldIndex);
this.Memento.Add(args.Source.Clone(), AddChangeBehavior.UndoRequest);
break;
case RejectReason.Redo:
/*
* Stiamo facendo la Redo di un elemento che è
* stato spostato:
* - dobbiamo rispostarlo;
* - lo aggiungiamo alla coda delle Undo
*/
this.Move(args.CachedValue.OldIndex, args.CachedValue.NewIndex);
this.Memento.Add(args.Source.Clone(), AddChangeBehavior.RedoRequest);
break;
case RejectReason.RejectChanges:
case RejectReason.Revert:
/*
* Stiamo resettando lo stato di un elemento
* che è stato spostato:
* - ci limitiamo a rimetterlo al posto originario
*/
this.Move(args.CachedValue.NewIndex, args.CachedValue.OldIndex);
break;
}
this.ResumeCaching();
};
#endregion
#region itemRemovedRejectCallback
this.itemRemovedRejectCallback = args =>
{
this.SuspendCaching();
switch (args.Reason)
{
case RejectReason.Undo:
/*
* Stiamo facendo l'Undo di un elemento
* che è stato rimosso:
* - lo rimettiamo al suo posto;
* - lo aggiungiamo alla coda delle Redo;
*/
this.Insert(args.CachedValue.Index, args.CachedValue.Item);
this.Memento.Add(args.Source.Clone(), AddChangeBehavior.UndoRequest);
break;
case RejectReason.Redo:
/*
* Stiamo facendo la Redo di un elemento che è
* stato rimosso:
* - dobbiamo rimuoverlo nuovamente;
* - lo aggiungiamo alla coda delle Undo
*/
this.Remove(args.CachedValue.Item);
this.Memento.Add(args.Source.Clone(), AddChangeBehavior.RedoRequest);
break;
case RejectReason.RejectChanges:
case RejectReason.Revert:
/*
* Stiamo resettando lo stato di un elemento
* che è stato rimosso:
* - ci limitiamo a rimetterlo definitivamente al posto originario
*/
this.Insert(args.CachedValue.Index, args.CachedValue.Item);
break;
}
this.ResumeCaching();
};
#endregion
#region itemInsertedRejectCallback
this.itemInsertedRejectCallback = args =>
{
this.SuspendCaching();
switch (args.Reason)
{
case RejectReason.Undo:
/*
* Stiamo facendo l'Undo di un elemento
* che è stato inserito:
* - lo togliamo;
* - lo aggiungiamo alla coda delle Redo;
*/
this.RemoveAt(args.CachedValue.Index);
this.Memento.Add(args.Source.Clone(), AddChangeBehavior.UndoRequest);
break;
case RejectReason.Redo:
/*
* Stiamo facendo la Redo di un elemento che è
* stato inserito:
* - dobbiamo reinserirlo;
* - lo aggiungiamo alla coda delle Undo
*/
this.Insert(args.CachedValue.Index, args.CachedValue.Item);
this.Memento.Add(args.Source.Clone(), AddChangeBehavior.RedoRequest);
break;
case RejectReason.RejectChanges:
case RejectReason.Revert:
/*
* Stiamo resettando lo stato di un elemento
* che è stato inserito:
* - ci limitiamo a rimoverlo definitivamente
*/
this.RemoveAt(args.CachedValue.Index);
break;
}
this.ResumeCaching();
};
#endregion
#region itemReplacedRejectCallback
this.itemReplacedRejectCallback = args =>
{
this.SuspendCaching();
switch (args.Reason)
{
case RejectReason.Undo:
/*
* Stiamo facendo l'Undo di un elemento
* che è stato sostituito:
* - lo togliamo e rimettiamo al suo posto quello vecchio;
* - lo aggiungiamo alla coda delle Redo;
*/
this[args.CachedValue.Index] = args.CachedValue.ReplacedItem;
this.Memento.Add(args.Source.Clone(), AddChangeBehavior.UndoRequest);
break;
case RejectReason.Redo:
/*
* Stiamo facendo la Redo di un elemento che è
* stato sostituito:
* - dobbiamo rimmetere quello nuovo;
* - lo aggiungiamo alla coda delle Undo
*/
this[args.CachedValue.Index] = args.CachedValue.NewItem;
this.Memento.Add(args.Source.Clone(), AddChangeBehavior.RedoRequest);
break;
case RejectReason.RejectChanges:
case RejectReason.Revert:
/*
* Stiamo resettando lo stato di un elemento
* che è stato sostituito:
* - ci limitiamo a rimettere posto quello vecchio;
*/
this[args.CachedValue.Index] = args.CachedValue.ReplacedItem;
break;
}
this.ResumeCaching();
};
#endregion
#region collectionClearedRejectCallback
this.collectionClearedRejectCallback = args =>
{
this.SuspendCaching();
switch (args.Reason)
{
case RejectReason.Undo:
/*
* Stiamo facendo l'Undo della clear:
* - rimettiamo a posto tutti gli elementi;
* - aggiungiamo alla coda delle Redo;
*/
this.AddRange(args.CachedValue.Items);
this.Memento.Add(args.Source.Clone(), AddChangeBehavior.UndoRequest);
break;
case RejectReason.Redo:
/*
* Stiamo facendo la Redo della Clear:
* - rifacciamo la Clear;
* - lo aggiungiamo alla coda delle Undo
*/
this.Clear();
this.Memento.Add(args.Source.Clone(), AddChangeBehavior.RedoRequest);
break;
case RejectReason.RejectChanges:
case RejectReason.Revert:
/*
* Stiamo resettando lo stato da una clear:
* - ci limitiamo a rimettere a posto tutti gli elementi;
*/
this.AddRange(args.CachedValue.Items);
break;
}
this.ResumeCaching();
};
#endregion
#region collectionAddRangeRejectCallback
this.collectionAddRangeRejectCallback = args =>
{
this.SuspendCaching();
switch (args.Reason)
{
case RejectReason.Undo:
/*
* Stiamo facendo l'Undo della AddRange:
* - dobbiamo rimuovere tutti gli elementi "added";
* - aggiungiamo alla coda delle Redo;
*/
foreach (var addedItem in args.CachedValue.Items)
{
this.Remove(addedItem);
}
this.Memento.Add(args.Source.Clone(), AddChangeBehavior.UndoRequest);
break;
case RejectReason.Redo:
/*
* Stiamo facendo la Redo della AddRange:
* - rifacciamo la AddRange;
* - lo aggiungiamo alla coda delle Undo
*/
this.AddRange(args.CachedValue.Items);
this.Memento.Add(args.Source.Clone(), AddChangeBehavior.RedoRequest);
break;
case RejectReason.RejectChanges:
case RejectReason.Revert:
/*
* Stiamo resettando lo stato di una AddRange:
* - Rimuoviamo tutti gli elementi added;
*/
foreach (var addedItem in args.CachedValue.Items)
{
this.Remove(addedItem);
}
break;
}
this.ResumeCaching();
};
#endregion
}
public abstract Promise <R> Then <R>(ResolveCallback <R> then, RejectCallback <R> fail);
protected virtual IChange CacheChangeOnRejectCallback <T>(string propertyName, T value, RejectCallback <T> rejectCallback, CommitCallback <T> commitCallback, ChangeRejectedEventArgs <T> args)
{
this.EnsureNotDisposed();
switch (args.Reason)
{
case RejectReason.Undo:
return(this.CacheChange(propertyName, value, rejectCallback, commitCallback, AddChangeBehavior.UndoRequest));
case RejectReason.Redo:
return(this.CacheChange(propertyName, value, rejectCallback, commitCallback, AddChangeBehavior.RedoRequest));
case RejectReason.RejectChanges:
case RejectReason.Revert:
return(null);
case RejectReason.None:
throw new ArgumentOutOfRangeException();
default:
throw new EnumValueOutOfRangeException();
}
}
/// <summary>
/// Caches the supplied item in the active change tracking service.
/// </summary>
/// <typeparam name="T">The system type of the item to cache.</typeparam>
/// <param name="value">The value to cache.</param>
/// <param name="restore">A delegate to call when the change tracking
/// service needs to restore the cached change.</param>
/// <param name="commit">A delegate to call when the change tracking
/// service needs to commit the cached change. Passing a null item for
/// this parameter means that this instance does not need to be notified when
/// the change is committed.</param>
/// <returns>
/// A reference to the cached change as an instance of <see cref="IChange"/> interface.
/// </returns>
protected IChange CacheChange <T>(string propertyName, T value, RejectCallback <T> restore, CommitCallback <T> commit)
{
this.EnsureNotDisposed();
return(this.CacheChange <T>(propertyName, value, restore, commit, AddChangeBehavior.Default));
}
public Promise Catch(RejectCallback fail)
{
return(Then(null, fail));
}
public HackedPropertyValueChange(Object owner, string value, RejectCallback <string> rc, CommitCallback <string> cc)
: base(owner, "property-name", value, rc, cc, string.Empty)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="CollectionChange<TDescriptor, TItem>"/> class.
/// </summary>
/// <param name="owner">The owner.</param>
/// <param name="descriptor">The descriptor.</param>
/// <param name="rejectCallback">The reject callback.</param>
/// <param name="commitCallback">The commit callback.</param>
/// <param name="description">The description.</param>
protected CollectionChange(Object owner, TDescriptor descriptor, RejectCallback <TDescriptor> rejectCallback, CommitCallback <TDescriptor> commitCallback, string description)
: base(owner, descriptor, rejectCallback, commitCallback, description)
{
}
internal IChange InvokeCacheChange <T>(T value, RejectCallback <T> rc)
{
return(base.CacheChange("property-name", value, rc));
}
/// <summary>
/// Initializes a new instance of the <see cref="ItemRemovedCollectionChange<T>"/> class.
/// </summary>
/// <param name="owner">The owner.</param>
/// <param name="descriptor">The descriptor.</param>
/// <param name="rejectCallback">The reject callback.</param>
/// <param name="commitCallback">The commit callback.</param>
/// <param name="description">The description.</param>
public ItemRemovedCollectionChange(Object owner, ItemChangedDescriptor <T> descriptor, RejectCallback <ItemChangedDescriptor <T> > rejectCallback, CommitCallback <ItemChangedDescriptor <T> > commitCallback, string description)
: base(owner, descriptor, rejectCallback, commitCallback, description)
{
}
protected virtual IChange <T> Mock <T>(Object owner, T value, RejectCallback <T> rejectCallback, CommitCallback <T> commitCallback, string description)
{
return(new ChangeMock <T>(owner, value, rejectCallback, commitCallback, description));
}
