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
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2002-2007, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
// $Id$
package scala.runtime
import Predef._
final class RichString(val self: String) extends Proxy with RandomAccessSeq[Char] with Ordered[String] {
import RichString._
override def apply(n: Int) = self charAt n
override def length = self.length
override def toString = self
override def mkString = self
override def slice(from: Int, until: Int): RichString = {
val from0 = if (from < 0) 0 else from
val until0 = if (from >= until || from >= self.length) return new RichString("")
else if (until > self.length) self.length else until
new RichString(self.substring(from0, until0))
}
//override def ++ [B >: A](that: Iterable[B]): Seq[B] = {
override def ++[B >: Char](that: Iterable[B]): RandomAccessSeq[B] = that match {
case that: RichString => new RichString(self + that.self)
case that => super.++(that)
}
override def take(until: Int): RichString = slice(0, until)
override def drop(from: Int): RichString = slice(from, self.length)
override def startsWith[B](that: Seq[B]) = that match {
case that: RichString => self startsWith that.self
case that => super.startsWith(that)
}
override def endsWith[B](that: Seq[B]) = that match {
case that: RichString => self endsWith that.self
case that => super.endsWith(that)
}
override def indexOf[B](that: Seq[B]) = that match {
case that: RichString => self indexOf that.self
case that => super.indexOf(that)
}
override def containsSlice[B](that: Seq[B]) = that match {
case that: RichString => self contains that.self
case that => super.containsSlice(that)
}
override def compare(other: String) = self compareTo other
private def isLineBreak(c: Char) = c == LF || c == FF
/** <p>
* Strip trailing line end character from this string if it has one.
* A line end character is one of
* </p>
* <ul style="list-style-type: none;">
* <li>LF - line feed (0x0A hex)</li>
* <li>FF - form feed (0x0C hex)</li>
* </ul>
* <p>
* If a line feed character LF is preceded by a carriage return CR
* (0x0D hex), the CR character is also stripped (Windows convention).
* </p>
*/
def stripLineEnd: String = {
val len = self.length
if (len == 0) self
else {
val last = apply(len - 1)
if (isLineBreak(last))
self.substring(0, if (last == LF && len >= 2 && apply(len - 2) == CR) len - 2 else len - 1)
else
self
}
}
/** <p>
* Return all lines in this string in an iterator, including trailing
* line end characters.
* </p>
* <p>
* The number of strings returned is one greater than the number of line
* end characters in this string. For an empty string, a single empty
* line is returned. A line end character is one of
* </p>
* <ul style="list-style-type: none;">
* <li>LF - line feed (0x0A hex)</li>
* <li>FF - form feed (0x0C hex)</li>
* </ul>
*/
def linesWithSeparators = new Iterator[String] {
val len = self.length
var index = 0
def hasNext: Boolean = index < len
def next(): String = {
if (index >= len) throw new NoSuchElementException("next on empty iterator")
val start = index
while (index < len && !isLineBreak(apply(index))) index += 1
index += 1
self.substring(start, index min len)
}
}
/** Return all lines in this string in an iterator, excluding trailing line
* end characters, i.e. apply <code>.stripLineEnd</code> to all lines
* returned by <code>linesWithSeparators</code>.
*/
def lines: Iterator[String] =
linesWithSeparators map (line => new RichString(line).stripLineEnd)
/** Returns this string with first character converted to upper case */
def capitalize: String = {
val chars = self.toCharArray
chars(0) = chars(0).toUpperCase
new String(chars)
}
/** <p>
* For every line in this string:
* </p>
* <blockquote>
* Strip a leading prefix consisting of blanks or control characters
* followed by <code>marginChar</code> from the line.
* </blockquote>
*/
def stripMargin(marginChar: Char): String = {
val buf = new StringBuilder()
for (line <- linesWithSeparators) {
val len = line.length
var index = 0
while (index < len && line.charAt(index) <= ' ') index += 1
buf append
(if (index < len && line.charAt(index) == marginChar) line.substring(index + 1) else line)
}
buf.toString
}
/** <p>
* For every line in this string:
* </p>
* <blockquote>
* Strip a leading prefix consisting of blanks or control characters
* followed by <code>|</code> from the line.
* </blockquote>
*/
def stripMargin: String = stripMargin('|')
/** <p>
* Remove white space from both ends of each line and add
* a blank (" ") between lines before merging them.
* </p>
* <p>
* Equivalent to: <code>mergeLines(_.trim, " ")</code>.
* </p>
*/
def mergeLines: String = mergeLines(_.trim, " ")
/** <p>
* Apply function <code>f</code> to each line and add
* the string <code>eol</code> between lines before
* merging them.
* </p>
*/
def mergeLines(f: String => String, eol: String): String =
lines map f mkString eol
private def escape(ch: Char): String = ch match {
case '.' | '$' | '^' | '\\' => "\\" + ch
case _ => "" + ch
}
@throws(classOf[java.util.regex.PatternSyntaxException])
def split(separator: Char): Array[String] = self.split(escape(separator))
@throws(classOf[java.util.regex.PatternSyntaxException])
def split(separators: Array[Char]): Array[String] = {
val re = separators.foldLeft("[")(_+_) + "]"
self.split(re)
}
def toByte: Byte = java.lang.Byte.parseByte(self)
def toShort: Short = java.lang.Short.parseShort(self)
def toInt: Int = java.lang.Integer.parseInt(self)
def toLong: Long = java.lang.Long.parseLong(self)
def toFloat: Float = java.lang.Float.parseFloat(self)
def toDouble: Double = java.lang.Double.parseDouble(self)
}
object RichString {
// just statics for rich string.
private final val LF: Char = 0x0A
private final val FF: Char = 0x0C
private final val CR: Char = 0x0D
private final val SU: Char = 0x1A
}
|
