-
-
Notifications
You must be signed in to change notification settings - Fork 142
/
ClassTagExtensions.scala
425 lines (369 loc) · 15.7 KB
/
ClassTagExtensions.scala
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
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
package com.fasterxml.jackson.module.scala
import com.fasterxml.jackson.core.{JsonParser, TreeNode}
import com.fasterxml.jackson.databind._
import com.fasterxml.jackson.databind.`type`.{MapLikeType, TypeFactory}
import com.fasterxml.jackson.databind.json.JsonMapper
import java.io.{File, InputStream, Reader}
import java.net.URL
import scala.collection.{immutable, mutable}
import scala.collection.immutable.IntMap
import scala.reflect.ClassTag
object ClassTagExtensions {
def ::(o: JsonMapper): JsonMapper with ClassTagExtensions = new Mixin(o)
def ::(o: ObjectMapper): ObjectMapper with ClassTagExtensions = new ObjectMapperMixin(o)
final class Mixin private[ClassTagExtensions](mapper: JsonMapper)
extends JsonMapper(mapper) with ClassTagExtensions
final class ObjectMapperMixin private[ClassTagExtensions](mapper: ObjectMapper)
extends ObjectMapper(mapper) with ClassTagExtensions
}
/**
* ClassTag equivalent of [[ScalaObjectMapper]] (which it is meant to replace).
* This only works with non parameterized types or parameterized types up to 5 type parameters.
*/
trait ClassTagExtensions {
self: ObjectMapper =>
/*
**********************************************************
* Configuration: mix-in annotations
**********************************************************
*/
/**
* Method to use for adding mix-in annotations to use for augmenting
* specified class or interface. All annotations from
* <code>mixinSource</code> are taken to override annotations
* that <code>target</code> (or its supertypes) has.
*
* @tparam Target Class (or interface) whose annotations to effectively override
* @tparam MixinSource Class (or interface) whose annotations are to
* be "added" to target's annotations, overriding as necessary
*/
@deprecated("this support in jackson-databind is moving to the MapperBuilder", "2.12.2")
final def addMixin[Target: ClassTag, MixinSource: ClassTag](): ObjectMapper = {
addMixIn(classFor[Target], classFor[MixinSource])
}
@deprecated("this support in jackson-databind is moving to the MapperBuilder", "2.12.2")
final def findMixInClassFor[T: ClassTag]: Class[_] = {
findMixInClassFor(classFor[T])
}
/*
**********************************************************
* Configuration, basic type handling
**********************************************************
*/
/**
* Convenience method for constructing [[com.fasterxml.jackson.databind.JavaType]] out of given
* type (typically <code>java.lang.Class</code>), but without explicit
* context.
*/
def constructType[T: JavaTypeable]: JavaType = {
implicitly[JavaTypeable[T]].asJavaType(getTypeFactory)
}
/*
**********************************************************
* Public API (from ObjectCodec): deserialization
* (mapping from JSON to Java types);
* main methods
**********************************************************
*/
/**
* Method to deserialize JSON content into a Java type, reference
* to which is passed as argument. Type is passed using so-called
* "super type token" (see )
* and specifically needs to be used if the root type is a
* parameterized (generic) container type.
*/
def readValue[T: JavaTypeable](jp: JsonParser): T = {
readValue(jp, constructType[T])
}
/**
* Method for reading sequence of Objects from parser stream.
* Sequence can be either root-level "unwrapped" sequence (without surrounding
* JSON array), or a sequence contained in a JSON Array.
* In either case [[com.fasterxml.jackson.core.JsonParser]] must point to the first token of
* the first element, OR not point to any token (in which case it is advanced
* to the next token). This means, specifically, that for wrapped sequences,
* parser MUST NOT point to the surrounding <code>START_ARRAY</code> but rather
* to the token following it.
* <p>
* Note that [[com.fasterxml.jackson.databind.ObjectReader]] has more complete set of variants.
*/
def readValues[T: JavaTypeable](jp: JsonParser): MappingIterator[T] = {
readValues(jp, constructType[T])
}
/*
**********************************************************
* Public API (from ObjectCodec): Tree Model support
**********************************************************
*/
/**
* Convenience conversion method that will bind data given JSON tree
* contains into specific value (usually bean) type.
* <p>
* Equivalent to:
* <pre>
* objectMapper.convertValue(n, valueClass);
* </pre>
*/
def treeToValue[T: JavaTypeable](n: TreeNode): T = {
treeToValue(n, constructType[T])
}
/*
**********************************************************
* Extended Public API, deserialization,
* convenience methods
**********************************************************
*/
def readValue[T: JavaTypeable](src: File): T = {
readValue(src, constructType[T])
}
def readValue[T: JavaTypeable](src: URL): T = {
readValue(src, constructType[T])
}
def readValue[T: JavaTypeable](content: String): T = {
readValue(content, constructType[T])
}
def readValue[T: JavaTypeable](src: Reader): T = {
readValue(src, constructType[T])
}
def readValue[T: JavaTypeable](src: InputStream): T = {
readValue(src, constructType[T])
}
def readValue[T: JavaTypeable](src: Array[Byte]): T = {
readValue(src, constructType[T])
}
def readValue[T: JavaTypeable](src: Array[Byte], offset: Int, len: Int): T = {
readValue(src, offset, len, constructType[T])
}
def updateValue[T: JavaTypeable](valueToUpdate: T, src: File): T = {
objectReaderFor(valueToUpdate).readValue(src)
}
def updateValue[T: JavaTypeable](valueToUpdate: T, src: URL): T = {
objectReaderFor(valueToUpdate).readValue(src)
}
def updateValue[T: JavaTypeable](valueToUpdate: T, content: String): T = {
objectReaderFor(valueToUpdate).readValue(content)
}
def updateValue[T: JavaTypeable](valueToUpdate: T, src: Reader): T = {
objectReaderFor(valueToUpdate).readValue(src)
}
def updateValue[T: JavaTypeable](valueToUpdate: T, src: InputStream): T = {
objectReaderFor(valueToUpdate).readValue(src)
}
def updateValue[T: JavaTypeable](valueToUpdate: T, src: Array[Byte]): T = {
objectReaderFor(valueToUpdate).readValue(src)
}
def updateValue[T: JavaTypeable](valueToUpdate: T, src: Array[Byte], offset: Int, len: Int): T = {
objectReaderFor(valueToUpdate).readValue(src, offset, len)
}
private def objectReaderFor[T: JavaTypeable](valueToUpdate: T): ObjectReader = {
readerForUpdating(valueToUpdate).forType(constructType[T])
}
/*
**********************************************************
* Extended Public API: constructing ObjectWriters
* for more advanced configuration
**********************************************************
*/
/**
* Factory method for constructing [[com.fasterxml.jackson.databind.ObjectWriter]] that will
* serialize objects using specified JSON View (filter).
*/
def writerWithView[T: ClassTag]: ObjectWriter = {
writerWithView(classFor[T])
}
/**
* Factory method for constructing [[com.fasterxml.jackson.databind.ObjectWriter]] that will
* serialize objects using specified root type, instead of actual
* runtime type of value. Type must be a super-type of runtime type.
* <p>
* Main reason for using this method is performance, as writer is able
* to pre-fetch serializer to use before write, and if writer is used
* more than once this avoids addition per-value serializer lookups.
*/
def writerFor[T: JavaTypeable]: ObjectWriter = {
writerFor(constructType[T])
}
/*
**********************************************************
* Extended Public API: constructing ObjectReaders
* for more advanced configuration
**********************************************************
*/
/**
* Factory method for constructing [[com.fasterxml.jackson.databind.ObjectReader]] that will
* read or update instances of specified type
*/
def readerFor[T: JavaTypeable]: ObjectReader = {
readerFor(constructType[T])
}
/**
* Factory method for constructing [[com.fasterxml.jackson.databind.ObjectReader]] that will
* deserialize objects using specified JSON View (filter).
*/
def readerWithView[T: ClassTag]: ObjectReader = {
readerWithView(classFor[T])
}
/*
**********************************************************
* Extended Public API: convenience type conversion
**********************************************************
*/
/**
* Convenience method for doing two-step conversion from given value, into
* instance of given value type. This is functionality equivalent to first
* serializing given value into JSON, then binding JSON data into value
* of given type, but may be executed without fully serializing into
* JSON. Same converters (serializers, deserializers) will be used as for
* data binding, meaning same object mapper configuration works.
*
* @throws java.lang.IllegalArgumentException If conversion fails due to incompatible type;
* if so, root cause will contain underlying checked exception data
* binding functionality threw
*/
def convertValue[T: JavaTypeable](fromValue: Any): T = {
convertValue(fromValue, constructType[T])
}
private def classFor[T: ClassTag]: Class[T] = {
implicitly[ClassTag[T]].runtimeClass.asInstanceOf[Class[T]]
}
}
trait JavaTypeable[T] {
def asJavaType(typeFactory: TypeFactory): JavaType
}
object JavaTypeable {
private val intClass = classOf[Int]
private val intMapClass = classOf[IntMap[_]]
private val longClass = classOf[Long]
private val immutableLongMapClass = classOf[immutable.LongMap[_]]
private val mutableLongMapClass = classOf[mutable.LongMap[_]]
// order of implicits matters for performance reasons, place most useful implicits last
implicit def gen5JavaTypeable[T[_, _, _, _, _], A: JavaTypeable, B: JavaTypeable, C: JavaTypeable, D: JavaTypeable, E: JavaTypeable](implicit ct: ClassTag[T[A, B, C, D, E]]): JavaTypeable[T[A, B, C, D, E]] = {
new JavaTypeable[T[A, B, C, D, E]] {
override def asJavaType(typeFactory: TypeFactory): JavaType = {
val typeArgs: Array[JavaType] = Array(
implicitly[JavaTypeable[A]].asJavaType(typeFactory),
implicitly[JavaTypeable[B]].asJavaType(typeFactory),
implicitly[JavaTypeable[C]].asJavaType(typeFactory),
implicitly[JavaTypeable[D]].asJavaType(typeFactory),
implicitly[JavaTypeable[E]].asJavaType(typeFactory)
)
typeFactory.constructParametricType(ct.runtimeClass, typeArgs: _*)
}
}
}
implicit def gen4JavaTypeable[T[_, _, _, _], A: JavaTypeable, B: JavaTypeable, C: JavaTypeable, D: JavaTypeable](implicit ct: ClassTag[T[A, B, C, D]]): JavaTypeable[T[A, B, C, D]] = {
new JavaTypeable[T[A, B, C, D]] {
override def asJavaType(typeFactory: TypeFactory): JavaType = {
val typeArgs: Array[JavaType] = Array(
implicitly[JavaTypeable[A]].asJavaType(typeFactory),
implicitly[JavaTypeable[B]].asJavaType(typeFactory),
implicitly[JavaTypeable[C]].asJavaType(typeFactory),
implicitly[JavaTypeable[D]].asJavaType(typeFactory)
)
typeFactory.constructParametricType(ct.runtimeClass, typeArgs: _*)
}
}
}
implicit def gen3JavaTypeable[T[_, _, _], A: JavaTypeable, B: JavaTypeable, C: JavaTypeable](implicit ct: ClassTag[T[A, B, C]]): JavaTypeable[T[A, B, C]] = {
new JavaTypeable[T[A, B, C]] {
override def asJavaType(typeFactory: TypeFactory): JavaType = {
val typeArgs: Array[JavaType] = Array(
implicitly[JavaTypeable[A]].asJavaType(typeFactory),
implicitly[JavaTypeable[B]].asJavaType(typeFactory),
implicitly[JavaTypeable[C]].asJavaType(typeFactory)
)
typeFactory.constructParametricType(ct.runtimeClass, typeArgs: _*)
}
}
}
implicit def gen2JavaTypeable[T[_, _], A: JavaTypeable, B: JavaTypeable](implicit ct: ClassTag[T[A, B]]): JavaTypeable[T[A, B]] = {
new JavaTypeable[T[A, B]] {
override def asJavaType(typeFactory: TypeFactory): JavaType = {
val typeArgs: Array[JavaType] = Array(
implicitly[JavaTypeable[A]].asJavaType(typeFactory),
implicitly[JavaTypeable[B]].asJavaType(typeFactory)
)
typeFactory.constructParametricType(ct.runtimeClass, typeArgs: _*)
}
}
}
implicit def gen1JavaTypeable[T[_], A: JavaTypeable](implicit ct: ClassTag[T[A]]): JavaTypeable[T[A]] = {
new JavaTypeable[T[A]] {
override def asJavaType(typeFactory: TypeFactory): JavaType = {
val typeArgs: Array[JavaType] = Array(
implicitly[JavaTypeable[A]].asJavaType(typeFactory)
)
typeFactory.constructParametricType(ct.runtimeClass, typeArgs: _*)
}
}
}
implicit def gen0JavaTypeable[T](implicit ct: ClassTag[T]): JavaTypeable[T] = {
new JavaTypeable[T] {
override def asJavaType(typeFactory: TypeFactory): JavaType = {
val typeArgs: Array[JavaType] = Array()
typeFactory.constructParametricType(ct.runtimeClass, typeArgs: _*)
}
}
}
implicit def arrayJavaTypeable[T : JavaTypeable]: JavaTypeable[Array[T]] = {
new JavaTypeable[Array[T]] {
override def asJavaType(typeFactory: TypeFactory): JavaType = {
val typeArg0 = implicitly[JavaTypeable[T]].asJavaType(typeFactory)
typeFactory.constructArrayType(typeArg0)
}
}
}
implicit def mapJavaTypeable[M[_,_] <: Map[_,_], K : JavaTypeable, V: JavaTypeable](implicit ct: ClassTag[M[K,V]]): JavaTypeable[M[K, V]] = {
new JavaTypeable[M[K, V]] {
override def asJavaType(typeFactory: TypeFactory): JavaType = {
val typeArg0 = implicitly[JavaTypeable[K]].asJavaType(typeFactory)
val typeArg1 = implicitly[JavaTypeable[V]].asJavaType(typeFactory)
typeFactory.constructMapLikeType(ct.runtimeClass, typeArg0, typeArg1)
}
}
}
implicit def collectionJavaTypeable[I[_] <: Iterable[_], T : JavaTypeable](implicit ct: ClassTag[I[T]]): JavaTypeable[I[T]] = {
new JavaTypeable[I[T]] {
override def asJavaType(typeFactory: TypeFactory): JavaType = {
val typeArg0 = implicitly[JavaTypeable[T]].asJavaType(typeFactory)
if (intMapClass.isAssignableFrom(ct.runtimeClass)) {
MapLikeType.upgradeFrom(
typeFactory.constructType(intMapClass),
typeFactory.constructType(intClass),
typeArg0
)
} else if (immutableLongMapClass.isAssignableFrom(ct.runtimeClass)) {
MapLikeType.upgradeFrom(
typeFactory.constructType(immutableLongMapClass),
typeFactory.constructType(longClass),
typeArg0
)
} else if (mutableLongMapClass.isAssignableFrom(ct.runtimeClass)) {
MapLikeType.upgradeFrom(
typeFactory.constructType(mutableLongMapClass),
typeFactory.constructType(longClass),
typeArg0
)
} else {
typeFactory.constructCollectionLikeType(ct.runtimeClass, typeArg0)
}
}
}
}
implicit def optionJavaTypeable[T : JavaTypeable]: JavaTypeable[Option[T]] = {
new JavaTypeable[Option[T]] {
override def asJavaType(typeFactory: TypeFactory): JavaType = {
val typeArg0 = implicitly[JavaTypeable[T]].asJavaType(typeFactory)
typeFactory.constructReferenceType(classOf[Option[_]], typeArg0)
}
}
}
implicit val anyJavaTypeable: JavaTypeable[Any] = {
new JavaTypeable[Any] {
override def asJavaType(typeFactory: TypeFactory): JavaType = {
val typeArgs: Array[JavaType] = Array()
typeFactory.constructParametricType(classOf[Object], typeArgs: _*)
}
}
}
}