1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
// 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 System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using Tango.Scripting.Editors.Document;
namespace Tango.Scripting.Editors.Xml
{
/// <summary>
/// Holds all objects that need to keep offsets up to date.
/// </summary>
class TrackedSegmentCollection
{
/// <summary>
/// Holds all types of objects in one collection.
/// </summary>
TextSegmentCollection<TextSegment> segments = new TextSegmentCollection<TextSegment>();
/// <summary>
/// Is used to identify what memory range was touched by object
/// The default is (StartOffset, EndOffset + 1) which is not stored
/// </summary>
class TouchedRange: TextSegment
{
public AXmlObject TouchedByObject { get; set; }
}
public void UpdateOffsetsAndInvalidate(IEnumerable<DocumentChangeEventArgs> changes)
{
foreach(DocumentChangeEventArgs change in changes) {
// Update offsets of all items
segments.UpdateOffsets(change);
// Remove any items affected by the change
AXmlParser.Log("Changed {0}-{1}", change.Offset, change.Offset + change.InsertionLength);
// Removing will cause one of the ends to be set to change.Offset
// FindSegmentsContaining includes any segments touching
// so that conviniently takes care of the +1 byte
var segmentsContainingOffset = segments.FindOverlappingSegments(change.Offset, change.InsertionLength);
foreach(AXmlObject obj in segmentsContainingOffset.OfType<AXmlObject>().Where(o => o.IsCached)) {
InvalidateCache(obj, false);
}
foreach(TouchedRange range in segmentsContainingOffset.OfType<TouchedRange>()) {
AXmlParser.Log("Found that {0} dependeds on ({1}-{2})", range.TouchedByObject, range.StartOffset, range.EndOffset);
InvalidateCache(range.TouchedByObject, true);
segments.Remove(range);
}
}
}
/// <summary>
/// Invlidates all objects. That is, the whole document has changed.
/// </summary>
/// <remarks> We still have to keep the items becuase they might be in the document </remarks>
public void InvalidateAll()
{
AXmlParser.Log("Invalidating all objects");
foreach(AXmlObject obj in segments.OfType<AXmlObject>()) {
obj.IsCached = false;
}
}
/// <summary> Add object to cache, optionally adding extra memory tracking </summary>
public void AddParsedObject(AXmlObject obj, int? maxTouchedLocation)
{
if (!(obj.Length > 0 || obj is AXmlDocument))
AXmlParser.Assert(false, string.Format(CultureInfo.InvariantCulture, "Invalid object {0}. It has zero length.", obj));
// // Expensive check
// if (obj is AXmlContainer) {
// int objStartOffset = obj.StartOffset;
// int objEndOffset = obj.EndOffset;
// foreach(AXmlObject child in ((AXmlContainer)obj).Children) {
// AXmlParser.Assert(objStartOffset <= child.StartOffset && child.EndOffset <= objEndOffset, "Wrong nesting");
// }
// }
segments.Add(obj);
AddSyntaxErrorsOf(obj);
obj.IsCached = true;
if (maxTouchedLocation != null) {
// location is assumed to be read so the range ends at (location + 1)
// For example eg for "a_" it is (0-2)
TouchedRange range = new TouchedRange() {
StartOffset = obj.StartOffset,
EndOffset = maxTouchedLocation.Value + 1,
TouchedByObject = obj
};
segments.Add(range);
AXmlParser.Log("{0} touched range ({1}-{2})", obj, range.StartOffset, range.EndOffset);
}
}
/// <summary> Removes object with all of its non-cached children </summary>
public void RemoveParsedObject(AXmlObject obj)
{
// Cached objects may be used in the future - do not remove them
if (obj.IsCached) return;
segments.Remove(obj);
RemoveSyntaxErrorsOf(obj);
AXmlParser.Log("Stopped tracking {0}", obj);
AXmlContainer container = obj as AXmlContainer;
if (container != null) {
foreach (AXmlObject child in container.Children) {
RemoveParsedObject(child);
}
}
}
public void AddSyntaxErrorsOf(AXmlObject obj)
{
foreach(SyntaxError syntaxError in obj.MySyntaxErrors) {
segments.Add(syntaxError);
}
}
public void RemoveSyntaxErrorsOf(AXmlObject obj)
{
foreach(SyntaxError syntaxError in obj.MySyntaxErrors) {
segments.Remove(syntaxError);
}
}
IEnumerable<AXmlObject> FindParents(AXmlObject child)
{
int childStartOffset = child.StartOffset;
int childEndOffset = child.EndOffset;
foreach(AXmlObject parent in segments.FindSegmentsContaining(child.StartOffset).OfType<AXmlObject>()) {
// Parent is anyone wholy containg the child
if (parent.StartOffset <= childStartOffset && childEndOffset <= parent.EndOffset && parent != child) {
yield return parent;
}
}
}
/// <summary> Invalidates items, but keeps tracking them </summary>
/// <remarks> Can be called redundantly (from range tacking) </remarks>
void InvalidateCache(AXmlObject obj, bool includeParents)
{
if (includeParents) {
foreach(AXmlObject parent in FindParents(obj)) {
parent.IsCached = false;
AXmlParser.Log("Invalidating cached item {0} (it is parent)", parent);
}
}
obj.IsCached = false;
AXmlParser.Log("Invalidating cached item {0}", obj);
}
public T GetCachedObject<T>(int offset, int lookaheadCount, Predicate<T> conditon) where T: AXmlObject, new()
{
TextSegment obj = segments.FindFirstSegmentWithStartAfter(offset);
while(obj != null && offset <= obj.StartOffset && obj.StartOffset <= offset + lookaheadCount) {
if (obj is T && ((AXmlObject)obj).IsCached && conditon((T)obj)) {
return (T)obj;
}
obj = segments.GetNextSegment(obj);
}
return null;
}
}
}
|
