From fc8a05358a92cc3c77c5f1e30d536807ef0614fd Mon Sep 17 00:00:00 2001 From: Victoria Plitt Date: Mon, 8 Apr 2019 13:49:55 +0300 Subject: were added scripting projects --- .../Document/ChangeTrackingCheckpoint.cs | 140 +++++++++++++++++++++ 1 file changed, 140 insertions(+) create mode 100644 Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Document/ChangeTrackingCheckpoint.cs (limited to 'Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Document/ChangeTrackingCheckpoint.cs') diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Document/ChangeTrackingCheckpoint.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Document/ChangeTrackingCheckpoint.cs new file mode 100644 index 000000000..283731da8 --- /dev/null +++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Document/ChangeTrackingCheckpoint.cs @@ -0,0 +1,140 @@ +// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt) +// This code is distributed under the GNU LGPL (for details please see \doc\license.txt) + +using Tango.Scripting.Editors.Utils; +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; + +namespace Tango.Scripting.Editors.Document +{ + /// + /// A checkpoint that allows tracking changes to a TextDocument. + /// + /// Use to create a checkpoint. + /// + /// + /// + /// The class allows tracking document changes, even from background threads. + /// Once you have two checkpoints, you can call to retrieve the complete list + /// of document changes that happened between those versions of the document. + /// + public sealed class ChangeTrackingCheckpoint + { + // Object that is unique per document. + // Used to determine if two checkpoints belong to the same document. + // We don't use a reference to the document itself to allow the GC to reclaim the document memory + // even if there are still references to checkpoints. + readonly object documentIdentifier; + + // 'value' is the change from the previous checkpoint to this checkpoint + // TODO: store the change in the older checkpoint instead - if only a reference to the + // newest document version exists, the GC should be able to collect all DocumentChangeEventArgs. + readonly DocumentChangeEventArgs value; + readonly int id; + ChangeTrackingCheckpoint next; + + internal ChangeTrackingCheckpoint(object documentIdentifier) + { + this.documentIdentifier = documentIdentifier; + } + + internal ChangeTrackingCheckpoint(object documentIdentifier, DocumentChangeEventArgs value, int id) + { + this.documentIdentifier = documentIdentifier; + this.value = value; + this.id = id; + } + + internal ChangeTrackingCheckpoint Append(DocumentChangeEventArgs change) + { + Debug.Assert(this.next == null); + this.next = new ChangeTrackingCheckpoint(this.documentIdentifier, change, unchecked( this.id + 1 )); + return this.next; + } + + /// + /// Creates a change tracking checkpoint for the specified document. + /// This method is thread-safe. + /// If you need a ChangeTrackingCheckpoint that's consistent with a snapshot of the document, + /// use . + /// + public static ChangeTrackingCheckpoint Create(TextDocument document) + { + if (document == null) + throw new ArgumentNullException("document"); + return document.CreateChangeTrackingCheckpoint(); + } + + /// + /// Gets whether this checkpoint belongs to the same document as the other checkpoint. + /// + public bool BelongsToSameDocumentAs(ChangeTrackingCheckpoint other) + { + if (other == null) + throw new ArgumentNullException("other"); + return documentIdentifier == other.documentIdentifier; + } + + /// + /// Compares the age of this checkpoint to the other checkpoint. + /// + /// This method is thread-safe. + /// Raised if 'other' belongs to a different document than this checkpoint. + /// -1 if this checkpoint is older than . + /// 0 if this==. + /// 1 if this checkpoint is newer than . + public int CompareAge(ChangeTrackingCheckpoint other) + { + if (other == null) + throw new ArgumentNullException("other"); + if (other.documentIdentifier != this.documentIdentifier) + throw new ArgumentException("Checkpoints do not belong to the same document."); + // We will allow overflows, but assume that the maximum distance between checkpoints is 2^31-1. + // This is guaranteed on x86 because so many checkpoints don't fit into memory. + return Math.Sign(unchecked( this.id - other.id )); + } + + /// + /// Gets the changes from this checkpoint to the other checkpoint. + /// If 'other' is older than this checkpoint, reverse changes are calculated. + /// + /// This method is thread-safe. + /// Raised if 'other' belongs to a different document than this checkpoint. + public IEnumerable GetChangesTo(ChangeTrackingCheckpoint other) + { + int result = CompareAge(other); + if (result < 0) + return GetForwardChanges(other); + else if (result > 0) + return other.GetForwardChanges(this).Reverse().Select(change => change.Invert()); + else + return Empty.Array; + } + + IEnumerable GetForwardChanges(ChangeTrackingCheckpoint other) + { + // Return changes from this(exclusive) to other(inclusive). + ChangeTrackingCheckpoint node = this; + do { + node = node.next; + yield return node.value; + } while (node != other); + } + + /// + /// Calculates where the offset has moved in the other buffer version. + /// + /// This method is thread-safe. + /// Raised if 'other' belongs to a different document than this checkpoint. + public int MoveOffsetTo(ChangeTrackingCheckpoint other, int oldOffset, AnchorMovementType movement) + { + int offset = oldOffset; + foreach (DocumentChangeEventArgs e in GetChangesTo(other)) { + offset = e.GetNewOffset(offset, movement); + } + return offset; + } + } +} -- cgit v1.3.1