os.serial.internal.ToString.scala Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of com.optersoft.engine Show documentation
README
The newest version!
// Copyright 2013, 2014  Optersoft Inc. - www.optersoft.com

package os.serial

object ToString {

  def apply[S <: Serial](serial: S): String = new ToString(serial).run()

}

// http://es5.github.io/#x15.12.3
class ToString[S <: Serial](serial: S) {

  val sb = new StringBuilder
  var colon = false

  def run() = {
    //block(obj)
    sb.clear
    writeValue(serial)
    sb.toString
  }

  def writeValue(value: Any) {

    value match {
      case str: String =>
        sb += '"'
        encode(sb, str)
        sb += '"'
      case true => sb ++= "true"
      case int: Int => sb ++= int.toString
      case long: Long => sb ++= long.toString
      //case reflect: Reflect => block(reflect)
      case map: Map[_, _] => writeMap(map)
      case seq: Seq[_] =>
        var first = false
        sb += '['
        for (item <- seq) {
          if (first) sb += ','; first = true
          writeValue(item)
        }
        sb += ']'
      case () => sb ++= "null"
      case None => sb ++= "null"
      case Some(value) => writeValue(value)
      //case time: Time => writeValue(time.value)
      case _ => throw new SerialError("Not Serial: " + value)
    }
  }

  //  def block(obj: Reflect) {
  //
  //    val mirror = Reflect(obj)
  //
  //    colon = false
  //    sb += '{'
  //
  //    write("T", mirror.id)
  //    for (attribute <- mirror.attributes) {
  //      attribute.get(obj) match {
  //        case null =>
  //        case None =>
  //        //case s: Seq[_] if s.isEmpty =>
  //        case Some(value) => write(attribute, value)
  //        case value => write(attribute, value)
  //      }
  //    }
  //    sb += '}'
  //  }

  private[serial] def writeMap(map: Map[_, _]) {

    colon = false
    sb += '{'
    for ((key, value) <- map) {
      write(key.toString, value)
    }
    sb += '}'

  }

  //  private[serial] def write(attribute: Attribute, value: Any) {
  //
  //    value match {
  //      case 0 =>
  //      case false =>
  //      case _ => write(attribute.id, value)
  //    }
  //  }

  private[serial] def write(id: String, value: Any) {

    if (colon)
      sb += ','
    colon = true

    sb += '"'
    sb ++= id
    sb += '"'
    sb += ':'
    writeValue(value)
  }

  private[serial] def encode(sb: StringBuilder, string: String) {

    for (char <- string) {
      char match {
        case '"' => sb.append("\\\"")
        case '\\' => sb.append("\\\\")
        case '\b' => sb.append("\\b")
        case '\f' => sb.append("\\f")
        case '\n' => sb.append("\\n")
        case '\r' => sb.append("\\r")
        case '\t' => sb.append("\\t")
        case '/' => sb.append("\\/")
        case _ => //Reference: http://www.unicode.org/versions/Unicode5.1.0/
          if ((char >= '\u0000' && char <= '\u001F') ||
            (char >= '\u007F' && char <= '\u009F') ||
            (char >= '\u2000' && char <= '\u20FF')) {
            val ss = Integer.toHexString(char)
            sb.append("\\u")
            var k = 0; var to = 4 - ss.length()
            while (k < to) {
              sb.append('0')
              k += 1
            }
            sb.append(ss.toUpperCase());
          } else {
            sb.append(char);
          }
      }
    }
  }
}