/// <summary>
/// Initializes a new instance of the <see cref="Bookmark"/> class.
/// </summary>
/// <param name="owner">The owner.</param>
/// <param name="position">The position.</param>
/// <param name="transientEntities">The transient entities.</param>
public Bookmark( IChangeTrackingService owner, IChange position, IEnumerable<Object> transientEntities )
{
Ensure.That( owner ).Named( "owner" ).IsNotNull();
this.Owner = owner;
this.Position = position;
this.TransientEntities = transientEntities ?? new ReadOnlyCollection<Object>( new Object[ 0 ] );
}
private void button6_Click(object sender, EventArgs e)
{
MachineCat mcat = new MachineCat("叮噹");
StoneMonkey wukong = new StoneMonkey("孙悟空");
IChange[] array = new IChange[2];
array[0] = mcat;
array[1] = wukong;
MessageBox.Show(array[0].ChangeThing("各种各样的东西！"));
MessageBox.Show(array[1].ChangeThing("各种各样的东西！"));
}
/// <summary>
/// Adds a new change to the history. It is expected that it was already executed.
/// </summary>
/// <param name="change"></param>
public void Add(IChange change)
{
PendingChanges.Clear();
ExecutedChanges.Push(change);
// x < 0 => clean state not reachable anymore.
if (_dirty < 0) _dirty = Capacity * 2;
else _dirty += 1;
RaiseChangeEvent();
}
private void Rename(IChange change, string pathInGitRepo, GitIndexInfo index, ITfsWorkspace workspace, IDictionary<string, GitObject> initialTree)
{
var oldPath = GetPathInGitRepo(GetPathBeforeRename(change.Item), initialTree);
if (oldPath != null)
{
Delete(oldPath, index, initialTree);
}
if (!change.ChangeType.IncludesOneOf(TfsChangeType.Delete))
{
Update(change, pathInGitRepo, index, workspace, initialTree);
}
}
public bool Equals(IChange other)
{
if (other == null)
return false;
if (ReferenceEquals(this, other))
return true;
return StringComparer.InvariantCultureIgnoreCase.Equals(Path, other.Path) &&
Type == other.Type &&
EqualityComparer<IFileReference>.Default.Equals(FromVersion, other.FromVersion) &&
EqualityComparer<IFileReference>.Default.Equals(ToVersion, other.ToVersion);
}
public void changeSet_ctor()
{
var expected = new IChange[]
{
MockRepository.GenerateStub<IChange>(),
MockRepository.GenerateStub<IChange>(),
MockRepository.GenerateStub<IChange>()
};
var actual = new ChangeSet( expected );
actual.Count.Should().Be.EqualTo( 3 );
actual.Should().Have.SameSequenceAs( expected );
}
private void Apply(IChange change, GitIndexInfo index, ITfsWorkspace workspace, IDictionary<string, GitObject> initialTree)
{
// If you make updates to a dir in TF, the changeset includes changes for all the children also,
// and git doesn't really care if you add or delete empty dirs.
if (change.Item.ItemType == TfsItemType.File)
{
var pathInGitRepo = GetPathInGitRepo(change.Item.ServerItem, initialTree);
if (pathInGitRepo == null || Summary.Remote.ShouldSkip(pathInGitRepo))
return;
if (change.ChangeType.IncludesOneOf(TfsChangeType.Rename))
{
Rename(change, pathInGitRepo, index, workspace, initialTree);
}
else if (change.ChangeType.IncludesOneOf(TfsChangeType.Delete))
{
Delete(pathInGitRepo, index, initialTree);
}
else
{
Update(change, pathInGitRepo, index, workspace, initialTree);
}
}
}
public void Resolve(BasketRegionModel model)
{
this.ResultOpt = this.transformer.TryTransformToChange(model);
}
public void Resolve(OtherModel model)
{
this.ResultOpt = null;
}
/// <summary>
/// Called when the change tracking service needs to remove handlers from the <c>IChange</c> supplied as parameter.
/// </summary>
/// <param name="change">The change to unwire from.</param>
protected virtual void OnUnwire( IChange change )
{
change.Committed -= this.onChangeCommitted;
change.Rejected -= this.onChangeRejected;
}
/// <summary>
/// Handles the change rejected event.
/// </summary>
/// <param name="change">The change that raises the rejected event.</param>
/// <param name="reason">The reason of the event raise.</param>
protected virtual void OnChangeRejected( IChange change, RejectReason reason )
{
this.OnUnwire( change );
switch ( reason )
{
case RejectReason.Undo:
case RejectReason.RejectChanges:
case RejectReason.Revert:
lock ( SyncRoot )
{
this.backwardChangesStack.Remove( change );
}
break;
case RejectReason.Redo:
lock ( SyncRoot )
{
this.forwardChangesStack.Remove( change );
}
break;
case RejectReason.None:
throw new ArgumentOutOfRangeException();
default:
throw new EnumValueOutOfRangeException();
}
}
private string AssertTrailingSlash(IChange change)
{
return(change.Item.ItemType == ItemType.Folder ?
AssertTrailingSlash(change.Item.ServerItem) :
change.Item.ServerItem);
}
/// <summary>
/// Adds a new change definition to this IChangeTrackingService.
/// </summary>
/// <param name="change">The change to store.</param>
/// <param name="behavior">The requested behavior.</param>
public virtual void Add( IChange change, AddChangeBehavior behavior )
{
this.EnsureNotSuspended();
Ensure.That( change )
.Named( "change" )
.IsNotNull();
if ( this.IsInAtomicOperation )
{
this.AtomicOperation.Add( change, behavior );
}
else
{
/*
* è necessario agganciare gli eventi
* Committed e Rejected su IChange perchè
* se viene manualmente chiamato Commit o Reject
* su una IChange dobbiamo liberarcene anche noi
*/
lock ( SyncRoot )
{
switch ( behavior )
{
case AddChangeBehavior.Default:
this.forwardChangesStack.Clear();
this.backwardChangesStack.Add( change );
break;
case AddChangeBehavior.RedoRequest:
this.backwardChangesStack.Add( change );
break;
case AddChangeBehavior.UndoRequest:
this.forwardChangesStack.Add( change );
break;
case AddChangeBehavior.None:
throw new ArgumentOutOfRangeException();
default:
throw new EnumValueOutOfRangeException();
}
this.OnWire( change );
}
this.OnTrackingServiceStateChanged();
}
}
public abstract IEnumerable <IOperation> UpdateObject(IObject obj, IObject baseObject, IChange change, ISyncContext context);
public ResolvedMerge(IChange <T> sourceA, IChange <T> sourceB, IChange <T> merged)
{
SourceA = sourceA ?? throw new ArgumentNullException(nameof(sourceA));
SourceB = sourceB ?? throw new ArgumentNullException(nameof(sourceB));
Merged = merged ?? throw new ArgumentNullException(nameof(merged));
}
public void AddCommand(IChange cmd)
{
changes.Add(cmd);
}
private void _onChange(PropertyInfo prop, IChange change)
{
_collectionChanges.Add(prop, change);
}
public Change(IChange change)
: base(change)
{
}
public void Add( IChange change, AddChangeBehavior behavior )
{
this.change.Add( change, behavior );
}
public bool IncludeInResult(IChange change) => true;
public ListChangeAdapter([NotNull] IChange <ListOperation <T> > adaptee)
{
_adaptee = adaptee;
}
public ChangeKey(IChange change)
{
Version = change.Version;
ChangeType = change.ChangeType;
}
public static CollectionChanges <T> Collect <T>(this IChange <T> change, IEnumerable <T> oldVals, IEnumerable <T> newVals)
{
return(new CollectionChanges <T>(change.Yield(), oldVals, newVals));
}
private void RecordChange(IChange change)
{
if (batch != null)
{
batch.Changes.Add(change);
}
else if (state != State.Undoing)
{
undoStack.Push(change);
if (state != State.Redoing) redoStack.Clear();
}
else
{
redoStack.Push(change);
}
}
public static IResolved <T> AsMerge <T>(IChange <T> sourceA, IChange <T> sourceB, IChange <T> merged)
{
return(new ResolvedMerge <T>
(
sourceA: sourceA,
sourceB: sourceB,
merged: merged
));
}
protected internal void OnChanged(IChange change)
{
Changed?.Invoke(change);
}
public override IEnumerable <IOperation> UpdateObject(IObject obj, IObject baseObject, IChange change, ISyncContext context)
{
yield return(new UpdateObjectOperation(obj, baseObject, change, context.ExecutionContext));
}
public void Add(IChange change, AddChangeBehavior behavior)
{
this.change.Add(change, behavior);
}
/// <summary>
/// Called when the change tracking service needs to add handlers to the <c>IChange</c> supplied as parameter.
/// </summary>
/// <param name="change">The change to wire to.</param>
protected virtual void OnWire( IChange change )
{
change.Committed += this.onChangeCommitted;
change.Rejected += this.onChangeRejected;
this.OnWire( change.Owner as IComponent );
}
public ChangeKey(IChange change)
{
Version = change.Version;
Tag = change.Tag;
}
/// <summary>
/// Called when change(s) have been committed from the <c>IChange</c> instance.
/// </summary>
/// <param name="change">The committed change.</param>
/// <param name="reason">The reason of the commit.</param>
protected virtual void OnChangeCommitted( IChange change, CommitReason reason )
{
this.OnUnwire( change );
switch ( reason )
{
case CommitReason.AcceptChanges:
lock ( SyncRoot )
{
this.backwardChangesStack.Remove( change );
}
break;
case CommitReason.None:
throw new ArgumentOutOfRangeException( "reason" );
default:
throw new EnumValueOutOfRangeException();
}
}
void IChangedNotification.OnChanged(CommandDoneType type, IChange change)
{
UndoRedoMemberExtender.OnChanged(this, type, ((ChangesList)change).NewState.Count, ((ChangesList)change).OldState.Count);
}
void IChangedNotification.OnChanged(CommandDoneType type, IChange change)
{
UndoRedoMemberExtender.OnChanged(this, type, change.NewObject, change.OldObject);
}
/// <summary>
/// Initializes a new instance of the <see cref="ChangeRejectedEventArgs<T>"/> class.
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="cachedValue">The cached value.</param>
/// <param name="source">The source.</param>
/// <param name="reason">The reason.</param>
public ChangeRejectedEventArgs(Object entity, T cachedValue, IChange source, RejectReason reason)
: base(entity, cachedValue, source)
{
this.Reason = reason;
}
public void Resolve(CountryModel model)
{
this.ResultOpt = null;
}
/// <summary>
/// Adds a change and immediately executes it.
/// </summary>
/// <param name="change"></param>
public void AddAndDo(IChange change)
{
this.Add(change);
change.Do();
}
public void Resolve(RegionModel model)
{
this.ResultOpt = null;
}
private void _notify(IChange <T> change)
{
_onChange.Invoke(change);
}
public void Revert(Level level, IChange change)
{
}
private void Update(IChange change, string pathInGitRepo, GitIndexInfo index, ITfsWorkspace workspace, IDictionary<string, GitObject> initialTree)
{
if (change.Item.DeletionId == 0)
{
index.Update(
GetMode(change, initialTree, pathInGitRepo),
pathInGitRepo,
workspace.GetLocalPath(pathInGitRepo)
);
}
}
private void Update(IChange change, string pathInGitRepo, GitIndexInfo index, IDictionary<string, GitObject> initialTree)
{
if (change.Item.DeletionId == 0)
{
using (var tempFile = new TemporaryFile())
{
change.Item.DownloadFile(tempFile);
index.Update(GetMode(change, initialTree, pathInGitRepo),
UpdateDirectoryToMatchExtantCasing(pathInGitRepo, initialTree),
tempFile);
}
}
}
private void PushChange(IChange change)
{
undoLevels.Add(change);
if(undoLevels.Count >= maxUndoLevels)
undoLevels.RemoveAt(0);
}
/// <summary>
/// Determines if the supplied IChange should be
/// included in the builded IChangeSet.
/// </summary>
/// <param name="change">The change to evaluate.</param>
/// <returns></returns>
public bool ShouldInclude( IChange change )
{
Ensure.That( change ).Named( "change" ).IsNotNull();
return true;
}
public void AddChange(IChange change)
{
_changes.Add(change);
}
private static void Show(IChange obj)
{
Console.WriteLine($"{obj.GetType()}: {nameof(obj.Change)}: {obj.Change}");
}
public bool Match(IChange change)
{
return(AssertTrailingSlash(change).StartsWith(TfsPath));
}
private void Update(IChange change, string pathInGitRepo, GitIndexInfo index, IDictionary<string, GitObject> initialTree)
{
if (change.Item.DeletionId == 0)
{
using (var temp = change.Item.DownloadFile())
{
index.Update(
GetMode(change, initialTree, pathInGitRepo),
pathInGitRepo,
temp
);
}
}
}
public IChange Parse(IChange overrideObject)
{
HandleVersion(overrideObject.Version.ToString());
return(overrideObject);
}
private string GetMode(IChange change, IDictionary<string, GitObject> initialTree, string pathInGitRepo)
{
if (initialTree.ContainsKey(pathInGitRepo) &&
!String.IsNullOrEmpty(initialTree[pathInGitRepo].Mode) &&
!change.ChangeType.IncludesOneOf(TfsChangeType.Add))
{
return initialTree[pathInGitRepo].Mode;
}
return Mode.NewFile;
}
public void Resolve(UnsavedBasketCountryModel model)
{
this.ResultOpt = this.transformer.TryTransformToChange(model);
}
public ResolvedNoMerge(IChange <T> sourceA, IChange <T> sourceB)
{
ChangeA = sourceA ?? throw new ArgumentNullException(nameof(sourceA));
ChangeB = sourceB ?? throw new ArgumentNullException(nameof(sourceB));
}
public UpdateObjectOperation(IObject obj, IObject baseObject, IChange change, IExecutionContext context) : base(context)
{
Object = obj;
BaseObject = baseObject;
Change = change;
}
