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
166
167
168
169
170
171
172
|
// 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.Globalization;
using System.Text;
namespace Tango.Scripting.Editors.Utils
{
/// <summary>
/// Poor man's template specialization: extension methods for Rope<char>.
/// </summary>
public static class CharRope
{
/// <summary>
/// Creates a new rope from the specified text.
/// </summary>
public static Rope<char> Create(string text)
{
if (text == null)
throw new ArgumentNullException("text");
return new Rope<char>(InitFromString(text));
}
/// <summary>
/// Retrieves the text for a portion of the rope.
/// Runs in O(lg N + M), where M=<paramref name="length"/>.
/// </summary>
/// <exception cref="ArgumentOutOfRangeException">offset or length is outside the valid range.</exception>
/// <remarks>
/// This method counts as a read access and may be called concurrently to other read accesses.
/// </remarks>
public static string ToString(this Rope<char> rope, int startIndex, int length)
{
if (rope == null)
throw new ArgumentNullException("rope");
if (length == 0)
return string.Empty;
char[] buffer = new char[length];
rope.CopyTo(startIndex, buffer, 0, length);
return new string(buffer);
}
/// <summary>
/// Retrieves the text for a portion of the rope and writes it to the specified string builder.
/// Runs in O(lg N + M), where M=<paramref name="length"/>.
/// </summary>
/// <exception cref="ArgumentOutOfRangeException">offset or length is outside the valid range.</exception>
/// <remarks>
/// This method counts as a read access and may be called concurrently to other read accesses.
/// </remarks>
public static void WriteTo(this Rope<char> rope, StringBuilder output, int startIndex, int length)
{
if (rope == null)
throw new ArgumentNullException("rope");
if (output == null)
throw new ArgumentNullException("output");
rope.VerifyRange(startIndex, length);
rope.root.WriteTo(startIndex, output, length);
}
/// <summary>
/// Appends text to this rope.
/// Runs in O(lg N + M).
/// </summary>
/// <exception cref="ArgumentNullException">newElements is null.</exception>
public static void AddText(this Rope<char> rope, string text)
{
InsertText(rope, rope.Length, text);
}
/// <summary>
/// Inserts text into this rope.
/// Runs in O(lg N + M).
/// </summary>
/// <exception cref="ArgumentNullException">newElements is null.</exception>
/// <exception cref="ArgumentOutOfRangeException">index or length is outside the valid range.</exception>
public static void InsertText(this Rope<char> rope, int index, string text)
{
if (rope == null)
throw new ArgumentNullException("rope");
rope.InsertRange(index, text.ToCharArray(), 0, text.Length);
/*if (index < 0 || index > rope.Length) {
throw new ArgumentOutOfRangeException("index", index, "0 <= index <= " + rope.Length.ToString(CultureInfo.InvariantCulture));
}
if (text == null)
throw new ArgumentNullException("text");
if (text.Length == 0)
return;
rope.root = rope.root.Insert(index, text);
rope.OnChanged();*/
}
internal static RopeNode<char> InitFromString(string text)
{
if (text.Length == 0) {
return RopeNode<char>.emptyRopeNode;
}
RopeNode<char> node = RopeNode<char>.CreateNodes(text.Length);
FillNode(node, text, 0);
return node;
}
static void FillNode(RopeNode<char> node, string text, int start)
{
if (node.contents != null) {
text.CopyTo(start, node.contents, 0, node.length);
} else {
FillNode(node.left, text, start);
FillNode(node.right, text, start + node.left.length);
}
}
internal static void WriteTo(this RopeNode<char> node, int index, StringBuilder output, int count)
{
if (node.height == 0) {
if (node.contents == null) {
// function node
node.GetContentNode().WriteTo(index, output, count);
} else {
// leaf node: append data
output.Append(node.contents, index, count);
}
} else {
// concat node: do recursive calls
if (index + count <= node.left.length) {
node.left.WriteTo(index, output, count);
} else if (index >= node.left.length) {
node.right.WriteTo(index - node.left.length, output, count);
} else {
int amountInLeft = node.left.length - index;
node.left.WriteTo(index, output, amountInLeft);
node.right.WriteTo(0, output, count - amountInLeft);
}
}
}
/// <summary>
/// Gets the index of the first occurrence of any element in the specified array.
/// </summary>
/// <param name="rope">The target rope.</param>
/// <param name="anyOf">Array of characters being searched.</param>
/// <param name="startIndex">Start index of the search.</param>
/// <param name="length">Length of the area to search.</param>
/// <returns>The first index where any character was found; or -1 if no occurrence was found.</returns>
public static int IndexOfAny(this Rope<char> rope, char[] anyOf, int startIndex, int length)
{
if (rope == null)
throw new ArgumentNullException("rope");
if (anyOf == null)
throw new ArgumentNullException("anyOf");
rope.VerifyRange(startIndex, length);
while (length > 0) {
var entry = rope.FindNodeUsingCache(startIndex).UnsafePeek();
char[] contents = entry.node.contents;
int startWithinNode = startIndex - entry.nodeStartIndex;
int nodeLength = Math.Min(entry.node.length, startWithinNode + length);
for (int i = startIndex - entry.nodeStartIndex; i < nodeLength; i++) {
char element = contents[i];
foreach (char needle in anyOf) {
if (element == needle)
return entry.nodeStartIndex + i;
}
}
length -= nodeLength - startWithinNode;
startIndex = entry.nodeStartIndex + nodeLength;
}
return -1;
}
}
}
|
