← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to src/core/Mono.Texteditor/Mono.TextEditor/Document/SegmentTree.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/core/Mono.Texteditor/Mono.TextEditor/Document/SegmentTree.cs
62
62
                        }
63
63
                }
64
64
                
65
 
                bool isInstalled = false;
 
65
                TextDocument ownerDocument;
66
66
                public void InstallListener (TextDocument doc)
67
67
                {
68
 
                        if (isInstalled)
 
68
                        if (ownerDocument != null)
69
69
                                throw new InvalidOperationException ("Segment tree already installed");
70
 
                        isInstalled = true;
 
70
                        ownerDocument = doc;
71
71
                        doc.TextReplaced += UpdateOnTextReplace;
72
72
                }
73
73
 
74
 
                public void RemoveListener (TextDocument doc)
 
74
                public void RemoveListener ()
75
75
                {
76
 
                        if (!isInstalled)
 
76
                        if (ownerDocument == null)
77
77
                                throw new InvalidOperationException ("Segment tree is not installed");
78
 
                        isInstalled = false;
79
 
                        doc.TextReplaced -= UpdateOnTextReplace;
 
78
                        ownerDocument.TextReplaced -= UpdateOnTextReplace;
 
79
                        ownerDocument = null;
80
80
                }
81
81
                
82
82
                public void Clear ()
160
160
                        tree.InsertRight (tree.Root.GetOuterRight (), node);
161
161
                }
162
162
                
163
 
                public void Remove (TreeSegment node)
 
163
                public bool Remove (TreeSegment node)
164
164
                {
 
165
                        if (node.segmentTree == null)
 
166
                                return false;
 
167
                        if (node.segmentTree != this)
 
168
                                throw new InvalidOperationException ("Tried to remove tree segment from wrong tree.");
165
169
                        var calculatedOffset = node.Offset;
166
170
                        var next = node.GetNextNode ();
167
171
                        if (next != null)
172
176
                        node.segmentTree = null;
173
177
                        node.parent = node.left = node.right = null;
174
178
                        node.DistanceToPrevNode = calculatedOffset;
 
179
                        return true;
175
180
                }
176
181
                
177
182
                TreeSegment SearchFirstSegmentWithStartAfter (int startOffset)
183
188
                        var result = SearchNode (ref startOffset);
184
189
                        while (startOffset == 0) {
185
190
                                var pre = result == null ? tree.Root.GetOuterRight () : result.GetPrevNode ();
 
191
                                if (pre == null)
 
192
                                        return null;
186
193
                                startOffset += pre.DistanceToPrevNode;
187
194
                                result = pre;
188
195
                        }
253
260
                                var node = interval.node;
254
261
                                int nodeStart = interval.start - node.DistanceToPrevNode;
255
262
                                int nodeEnd = interval.end - node.DistanceToPrevNode;
256
 
                                if (node.left != null) {
257
 
                                        nodeStart -= node.left.TotalLength;
258
 
                                        nodeEnd -= node.left.TotalLength;
 
263
                                var leftNode = node.left;
 
264
                                if (leftNode != null) {
 
265
                                        nodeStart -= leftNode.TotalLength;
 
266
                                        nodeEnd -= leftNode.TotalLength;
259
267
                                }
260
268
                        
261
269
                                if (node.DistanceToMaxEnd < nodeStart) 
262
270
                                        continue;
263
271
                        
264
 
                                if (node.left != null)
265
 
                                        intervalStack.Push (new Interval (node.left, interval.start, interval.end));
 
272
                                if (leftNode != null)
 
273
                                        intervalStack.Push (new Interval (leftNode, interval.start, interval.end));
266
274
                                
267
275
                                if (nodeEnd < 0) 
268
276
                                        continue;
270
278
                                if (nodeStart <= node.Length)
271
279
                                        yield return (T)node;
272
280
                        
273
 
                                if (node.right != null) 
274
 
                                        intervalStack.Push (new Interval (node.right, nodeStart, nodeEnd));
 
281
                                var rightNode = node.right;
 
282
                                if (rightNode != null) 
 
283
                                        intervalStack.Push (new Interval (rightNode, nodeStart, nodeEnd));
275
284
                        }
276
285
                }
277
286
        }
279
288
        interface TextSegmentTree
280
289
        {
281
290
                void Add (TreeSegment segment);
282
 
                void Remove (TreeSegment segment);
 
291
                bool Remove (TreeSegment segment);
283
292
        }
284
293
        
285
294
        public class TreeSegment : IRedBlackTreeNode