package scala.collection
package immutable
import generic._
import mutable.Builder
import scala.util.matching.Regex
import scala.math.ScalaNumber
object StringLike {
private final val LF: Char = 0x0A
private final val FF: Char = 0x0C
private final val CR: Char = 0x0D
private final val SU: Char = 0x1A
}
import StringLike._
trait StringLike[+Repr] extends collection.IndexedSeqOptimized[Char, Repr] with Ordered[String] {
self =>
protected[this] def newBuilder: Builder[Char, Repr]
def apply(n: Int): Char = toString charAt n
def length: Int = toString.length
override def mkString = toString
override def slice(from: Int, until: Int): Repr = {
val start = from max 0
val end = until min length
if (start >= end) newBuilder.result
else newBuilder ++= toString.substring(start, end) result
}
def * (n: Int): String = {
val buf = new StringBuilder
for (i <- 0 until n) buf append toString
buf.toString
}
override def compare(other: String) = toString compareTo other
private def isLineBreak(c: Char) = c == LF || c == FF
def stripLineEnd: String = {
val len = toString.length
if (len == 0) toString
else {
val last = apply(len - 1)
if (isLineBreak(last))
toString.substring(0, if (last == LF && len >= 2 && apply(len - 2) == CR) len - 2 else len - 1)
else
toString
}
}
def linesWithSeparators: Iterator[String] = new Iterator[String] {
val str = self.toString
private val len = str.length
private 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
str.substring(start, index min len)
}
}
def lines: Iterator[String] =
linesWithSeparators map (line => new WrappedString(line).stripLineEnd)
def linesIterator: Iterator[String] =
linesWithSeparators map (line => new WrappedString(line).stripLineEnd)
def capitalize: String =
if (toString == null) null
else if (toString.length == 0) ""
else {
val chars = toString.toCharArray
chars(0) = chars(0).toUpper
new String(chars)
}
def stripPrefix(prefix: String) =
if (toString.startsWith(prefix)) toString.substring(prefix.length)
else toString
def stripSuffix(suffix: String) =
if (toString.endsWith(suffix)) toString.substring(0, toString.length() - suffix.length)
else toString
def replaceAllLiterally(literal: String, replacement: String): String = {
val arg1 = java.util.regex.Pattern.quote(literal)
val arg2 = java.util.regex.Matcher.quoteReplacement(replacement)
toString.replaceAll(arg1, arg2)
}
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
}
def stripMargin: String = stripMargin('|')
private def escape(ch: Char): String = "\\Q" + ch + "\\E"
@throws(classOf[java.util.regex.PatternSyntaxException])
def split(separator: Char): Array[String] = toString.split(escape(separator))
@throws(classOf[java.util.regex.PatternSyntaxException])
def split(separators: Array[Char]): Array[String] = {
val re = separators.foldLeft("[")(_+escape(_)) + "]"
toString.split(re)
}
def r: Regex = new Regex(toString)
def toBoolean: Boolean = parseBoolean(toString)
def toByte: Byte = java.lang.Byte.parseByte(toString)
def toShort: Short = java.lang.Short.parseShort(toString)
def toInt: Int = java.lang.Integer.parseInt(toString)
def toLong: Long = java.lang.Long.parseLong(toString)
def toFloat: Float = java.lang.Float.parseFloat(toString)
def toDouble: Double = java.lang.Double.parseDouble(toString)
private def parseBoolean(s: String): Boolean =
if (s != null) s.toLowerCase match {
case "true" => true
case "false" => false
case _ => throw new NumberFormatException("For input string: \""+s+"\"")
}
else
throw new NumberFormatException("For input string: \"null\"")
override def toArray[B >: Char : ClassManifest]: Array[B] =
toString.toCharArray.asInstanceOf[Array[B]]
private def unwrapArg(arg: Any): AnyRef = arg match {
case x: ScalaNumber => x.underlying
case x => x.asInstanceOf[AnyRef]
}
def format(args : Any*): String =
java.lang.String.format(toString, args map unwrapArg: _*)
def formatLocal(l: java.util.Locale, args: Any*): String =
java.lang.String.format(l, toString, args map unwrapArg: _*)
}