package java.lang
class StringBuilder(private var content: String) extends CharSequence
with Appendable
with java.io.Serializable {
def this() = this("")
def this(initialCapacity: Int) = this("")
def this(csq: CharSequence) = this(csq.toString)
def append(s: String): StringBuilder = {
content += { if (s == null) "null" else s }
this
}
def append(b: scala.Boolean): StringBuilder = append(b.toString())
def append(c: scala.Char): StringBuilder = append(c.toString())
def append(str: Array[scala.Char]): StringBuilder =
append(str, 0, str.length)
def append(str: Array[scala.Char], offset: Int, len: Int): StringBuilder = {
var i = 0
while (i < len) {
content += str(i + offset)
i += 1
}
this
}
def append(b: scala.Byte): StringBuilder = append(b.toString())
def append(s: scala.Short): StringBuilder = append(s.toString())
def append(i: scala.Int): StringBuilder = append(i.toString())
def append(lng: scala.Long): StringBuilder = append(lng.toString())
def append(f: scala.Float): StringBuilder = append(f.toString())
def append(d: scala.Double): StringBuilder = append(d.toString())
def append(obj: AnyRef): StringBuilder = {
if (obj == null) append(null: String)
else append(obj.toString())
}
def append(csq: CharSequence): StringBuilder = append(csq: AnyRef)
def append(csq: CharSequence, start: Int, end: Int): StringBuilder = {
if (csq == null) append("null", start, end)
else append(csq.subSequence(start, end).toString())
}
override def toString() = content
def length() = content.length()
def charAt(index: Int) = content.charAt(index)
def codePointAt(index: Int) = content.codePointAt(index)
def indexOf(str: String) = content.indexOf(str)
def indexOf(str: String, fromIndex: Int) = content.indexOf(str, fromIndex)
def lastIndexOf(str: String) = content.lastIndexOf(str)
def lastIndexOf(str: String, fromIndex: Int) = content.lastIndexOf(str, fromIndex)
def subSequence(start: Int, end: Int): CharSequence = substring(start, end)
def substring(start: Int): String = content.substring(start)
def substring(start: Int, end: Int): String = content.substring(start, end)
def reverse(): StringBuilder = {
val original = content
var result = ""
var i = 0
while (i < original.length) {
val c = original.charAt(i)
if (Character.isHighSurrogate(c) && (i+1 < original.length)) {
val c2 = original.charAt(i+1)
if (Character.isLowSurrogate(c2)) {
result = c.toString + c2.toString + result
i += 2
} else {
result = c.toString + result
i += 1
}
} else {
result = c.toString + result
i += 1
}
}
content = result
this
}
def deleteCharAt(index: Int): StringBuilder = {
if (index < 0 || index >= content.length)
throw new StringIndexOutOfBoundsException("String index out of range: " + index)
content = content.substring(0, index) + content.substring(index+1)
this
}
/**
* @param start The beginning index, inclusive.
* @param end The ending index, exclusive.
* @param str String that will replace previous contents.
* @return This StringBuilder.
*/
def replace(start: Int, end: Int, str: String): StringBuilder = {
val length = content.length
if (start < 0 || start > end || start >= length)
throw new StringIndexOutOfBoundsException(s"Illegal to replace substring at [$start - $end] in string of length $length")
val realEnd = if (end > length) length else end // java api convention
content = content.substring(0, start) + str + content.substring(realEnd)
this
}
def setCharAt(index: Int, ch: scala.Char): Unit = {
if (index < 0 || index >= content.length)
throw new IndexOutOfBoundsException("String index out of range: " + index)
content = content.substring(0, index) + ch + content.substring(index + 1)
}
def setLength(newLength: Int): Unit = {
if (newLength < 0)
throw new IndexOutOfBoundsException("String index out of range: " + newLength)
val len = length()
if (len == newLength) {
} else if (len < newLength) {
var index = len
while (index < newLength) {
append("\u0000")
index += 1
}
} else {
content = substring(0, newLength)
}
}
def insert(index: Int, b: scala.Boolean): StringBuilder = insert(index, b.toString)
def insert(index: Int, b: scala.Byte): StringBuilder = insert(index, b.toString)
def insert(index: Int, s: scala.Short): StringBuilder = insert(index, s.toString)
def insert(index: Int, i: scala.Int): StringBuilder = insert(index, i.toString)
def insert(index: Int, l: scala.Long): StringBuilder = insert(index, l.toString)
def insert(index: Int, f: scala.Float): StringBuilder = insert(index, f.toString)
def insert(index: Int, d: scala.Double): StringBuilder = insert(index, d.toString)
def insert(index: Int, c: scala.Char): StringBuilder = insert(index, c.toString)
def insert(index: Int, csq: CharSequence): StringBuilder = insert(index: Int, csq: AnyRef)
def insert(index: Int, arr: Array[scala.Char]): StringBuilder = insert(index, arr, 0, arr.length)
def insert(index: Int, ref: AnyRef): StringBuilder =
if (ref == null)
insert(index, null: String)
else
insert(index, ref.toString)
def insert(index: Int, csq: CharSequence, start: Int, end: Int): StringBuilder =
if (csq == null)
insert(index, "null", start, end)
else
insert(index, csq.subSequence(start, end).toString)
def insert(index: Int, arr: Array[scala.Char], offset: Int, len: Int): StringBuilder = {
var str = ""
var i = 0
while (i < len) {
str += arr(i + offset)
i += 1
}
insert(index, str)
}
def insert(index: Int, str: String): StringBuilder = {
val thisLength = length()
if (index < 0 || index > thisLength)
throw new StringIndexOutOfBoundsException(index)
else if (index == thisLength)
append(str)
else
content = content.substring(0, index) + Option(str).getOrElse("null") + content.substring(index)
this
}
}
