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
|
/*
* Copyright (C) 2011 Mathias Doenitz
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package spray.json
import java.lang.reflect.Modifier
import scala.util.control.NonFatal
/**
* Provides the helpers for constructing custom JsonFormat implementations for types implementing the Product trait
* (especially case classes)
*/
trait ProductFormats extends ProductFormatsInstances {
this: StandardFormats =>
def jsonFormat0[T](construct: () => T): RootJsonFormat[T] =
new RootJsonFormat[T] {
def write(p: T) = JsObject()
def read(value: JsValue) = value match {
case JsObject(_) => construct()
case _ => throw new DeserializationException("Object expected")
}
}
// helpers
protected def productElement2Field[T](fieldName: String, p: Product, ix: Int, rest: List[JsField] = Nil)
(implicit writer: JsonWriter[T]): List[JsField] = {
val value = p.productElement(ix).asInstanceOf[T]
writer match {
case _: OptionFormat[_] if (value == None) => rest
case _ => (fieldName, writer.write(value)) :: rest
}
}
protected def fromField[T](value: JsValue, fieldName: String)
(implicit reader: JsonReader[T]) = value match {
case x: JsObject if
(reader.isInstanceOf[OptionFormat[_]] &
!x.fields.contains(fieldName)) =>
None.asInstanceOf[T]
case x: JsObject =>
try reader.read(x.fields(fieldName))
catch {
case e: NoSuchElementException =>
deserializationError("Object is missing required member '" + fieldName + "'", e, fieldName :: Nil)
case DeserializationException(msg, cause, fieldNames) =>
deserializationError(msg, cause, fieldName :: fieldNames)
}
case _ => deserializationError("Object expected in field '" + fieldName + "'", fieldNames = fieldName :: Nil)
}
protected def extractFieldNames(classManifest: ClassManifest[_]): Array[String] = {
val clazz = classManifest.erasure
try {
// copy methods have the form copy$default$N(), we need to sort them in order, but must account for the fact
// that lexical sorting of ...8(), ...9(), ...10() is not correct, so we extract N and sort by N.toInt
val copyDefaultMethods = clazz.getMethods.filter(_.getName.startsWith("copy$default$")).sortBy(
_.getName.drop("copy$default$".length).takeWhile(_ != '(').toInt)
val fields = clazz.getDeclaredFields.filterNot { f =>
f.getName.startsWith("$") || Modifier.isTransient(f.getModifiers) || Modifier.isStatic(f.getModifiers)
}
if (copyDefaultMethods.length != fields.length)
sys.error("Case class " + clazz.getName + " declares additional fields")
if (fields.zip(copyDefaultMethods).exists { case (f, m) => f.getType != m.getReturnType })
sys.error("Cannot determine field order of case class " + clazz.getName)
fields.map(f => ProductFormats.unmangle(f.getName))
} catch {
case NonFatal(ex) => throw new RuntimeException("Cannot automatically determine case class field names and order " +
"for '" + clazz.getName + "', please use the 'jsonFormat' overload with explicit field name specification", ex)
}
}
}
object ProductFormats {
private val operators = Map(
"$eq" -> "=",
"$greater" -> ">",
"$less" -> "<",
"$plus" -> "+",
"$minus" -> "-",
"$times" -> "*",
"$div" -> "/",
"$bang" -> "!",
"$at" -> "@",
"$hash" -> "#",
"$percent" -> "%",
"$up" -> "^",
"$amp" -> "&",
"$tilde" -> "~",
"$qmark" -> "?",
"$bar" -> "|")
private def unmangle(name: String) = operators.foldLeft(name) { case (n, (mangled, unmangled)) =>
if (n.indexOf(mangled) >= 0) n.replace(mangled, unmangled) else n
}
}
/**
* This trait supplies an alternative rendering mode for optional case class members.
* Normally optional members that are undefined (`None`) are not rendered at all.
* By mixing in this trait into your custom JsonProtocol you can enforce the rendering of undefined members as `null`.
* (Note that this only affect JSON writing, spray-json will always read missing optional members as well as `null`
* optional members as `None`.)
*/
trait NullOptions extends ProductFormats {
this: StandardFormats =>
override protected def productElement2Field[T](fieldName: String, p: Product, ix: Int, rest: List[JsField])
(implicit writer: JsonWriter[T]) = {
val value = p.productElement(ix).asInstanceOf[T]
(fieldName, writer.write(value)) :: rest
}
}
|
