1 /*
2  * Copyright 2017-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
3  */
4 @file:Suppress("DEPRECATION_ERROR")
5 package kotlinx.serialization.internal
6 
7 import kotlinx.serialization.*
8 import kotlinx.serialization.builtins.*
9 import kotlinx.serialization.encoding.*
10 
11 private const val INITIAL_SIZE = 10
12 
13 /**
14  * Serializer for [ByteArray].
15  *
16  * Encode elements one-by-one, as regular list,
17  * unless format's Encoder/Decoder have special handling for this serializer.
18  */
19 @PublishedApi
20 internal object ByteArraySerializer : KSerializer<ByteArray>,
21     PrimitiveArraySerializer<Byte, ByteArray, ByteArrayBuilder>(Byte.serializer()) {
22 
collectionSizenull23     override fun ByteArray.collectionSize(): Int = size
24     override fun ByteArray.toBuilder(): ByteArrayBuilder = ByteArrayBuilder(this)
25     override fun empty(): ByteArray = ByteArray(0)
26 
27     override fun readElement(decoder: CompositeDecoder, index: Int, builder: ByteArrayBuilder, checkIndex: Boolean) {
28         builder.append(decoder.decodeByteElement(descriptor, index))
29     }
30 
writeContentnull31     override fun writeContent(encoder: CompositeEncoder, content: ByteArray, size: Int) {
32         for (i in 0 until size)
33             encoder.encodeByteElement(descriptor, i, content[i])
34     }
35 }
36 
37 @PublishedApi
38 internal class ByteArrayBuilder internal constructor(
39     bufferWithData: ByteArray
40 ) : PrimitiveArrayBuilder<ByteArray>() {
41 
42     private var buffer: ByteArray = bufferWithData
43     override var position: Int = bufferWithData.size
44         private set
45 
46     init {
47         ensureCapacity(INITIAL_SIZE)
48     }
49 
ensureCapacitynull50     override fun ensureCapacity(requiredCapacity: Int) {
51         if (buffer.size < requiredCapacity)
52             buffer = buffer.copyOf(requiredCapacity.coerceAtLeast(buffer.size * 2))
53     }
54 
appendnull55     internal fun append(c: Byte) {
56         ensureCapacity()
57         buffer[position++] = c
58     }
59 
buildnull60     override fun build() = buffer.copyOf(position)
61 }
62 
63 // the rest of the serializers are merely copy-paste
64 /**
65  * Serializer for [ShortArray].
66  *
67  * Encode elements one-by-one, as regular list,
68  * unless format's Encoder/Decoder have special handling for this serializer.
69  */
70 @PublishedApi
71 internal object ShortArraySerializer : KSerializer<ShortArray>,
72     PrimitiveArraySerializer<Short, ShortArray, ShortArrayBuilder>(Short.serializer()) {
73 
74     override fun ShortArray.collectionSize(): Int = size
75     override fun ShortArray.toBuilder(): ShortArrayBuilder = ShortArrayBuilder(this)
76     override fun empty(): ShortArray = ShortArray(0)
77 
78     override fun readElement(decoder: CompositeDecoder, index: Int, builder: ShortArrayBuilder, checkIndex: Boolean) {
79         builder.append(decoder.decodeShortElement(descriptor, index))
80     }
81 
82     override fun writeContent(encoder: CompositeEncoder, content: ShortArray, size: Int) {
83         for (i in 0 until size)
84             encoder.encodeShortElement(descriptor, i, content[i])
85     }
86 }
87 
88 @PublishedApi
89 internal class ShortArrayBuilder internal constructor(
90     bufferWithData: ShortArray
91 ) : PrimitiveArrayBuilder<ShortArray>() {
92 
93     private var buffer: ShortArray = bufferWithData
94     override var position: Int = bufferWithData.size
95         private set
96 
97     init {
98         ensureCapacity(INITIAL_SIZE)
99     }
100 
ensureCapacitynull101     override fun ensureCapacity(requiredCapacity: Int) {
102         if (buffer.size < requiredCapacity)
103             buffer = buffer.copyOf(requiredCapacity.coerceAtLeast(buffer.size * 2))
104     }
105 
appendnull106     internal fun append(c: Short) {
107         ensureCapacity()
108         buffer[position++] = c
109     }
110 
buildnull111     override fun build() = buffer.copyOf(position)
112 }
113 
114 /**
115  * Serializer for [IntArray].
116  *
117  * Encode elements one-by-one, as regular list,
118  * unless format's Encoder/Decoder have special handling for this serializer.
119  */
120 @PublishedApi
121 internal object IntArraySerializer : KSerializer<IntArray>,
122     PrimitiveArraySerializer<Int, IntArray, IntArrayBuilder>(Int.serializer()) {
123 
124     override fun IntArray.collectionSize(): Int = size
125     override fun IntArray.toBuilder(): IntArrayBuilder = IntArrayBuilder(this)
126     override fun empty(): IntArray = IntArray(0)
127 
128     override fun readElement(decoder: CompositeDecoder, index: Int, builder: IntArrayBuilder, checkIndex: Boolean) {
129         builder.append(decoder.decodeIntElement(descriptor, index))
130     }
131 
132     override fun writeContent(encoder: CompositeEncoder, content: IntArray, size: Int) {
133         for (i in 0 until size)
134             encoder.encodeIntElement(descriptor, i, content[i])
135     }
136 }
137 
138 @PublishedApi
139 internal class IntArrayBuilder internal constructor(
140     bufferWithData: IntArray
141 ) : PrimitiveArrayBuilder<IntArray>() {
142 
143     private var buffer: IntArray = bufferWithData
144     override var position: Int = bufferWithData.size
145         private set
146 
147     init {
148         ensureCapacity(INITIAL_SIZE)
149     }
150 
ensureCapacitynull151     override fun ensureCapacity(requiredCapacity: Int) {
152         if (buffer.size < requiredCapacity)
153             buffer = buffer.copyOf(requiredCapacity.coerceAtLeast(buffer.size * 2))
154     }
155 
appendnull156     internal fun append(c: Int) {
157         ensureCapacity()
158         buffer[position++] = c
159     }
160 
buildnull161     override fun build() = buffer.copyOf(position)
162 }
163 
164 /**
165  * Serializer for [LongArray].
166  *
167  * Encode elements one-by-one, as regular list,
168  * unless format's Encoder/Decoder have special handling for this serializer.
169  */
170 @PublishedApi
171 internal object LongArraySerializer : KSerializer<LongArray>,
172     PrimitiveArraySerializer<Long, LongArray, LongArrayBuilder>(Long.serializer()) {
173 
174     override fun LongArray.collectionSize(): Int = size
175     override fun LongArray.toBuilder(): LongArrayBuilder = LongArrayBuilder(this)
176     override fun empty(): LongArray = LongArray(0)
177 
178     override fun readElement(decoder: CompositeDecoder, index: Int, builder: LongArrayBuilder, checkIndex: Boolean) {
179         builder.append(decoder.decodeLongElement(descriptor, index))
180     }
181 
182     override fun writeContent(encoder: CompositeEncoder, content: LongArray, size: Int) {
183         for (i in 0 until size)
184             encoder.encodeLongElement(descriptor, i, content[i])
185     }
186 }
187 
188 @PublishedApi
189 internal class LongArrayBuilder internal constructor(
190     bufferWithData: LongArray
191 ) : PrimitiveArrayBuilder<LongArray>() {
192 
193     private var buffer: LongArray = bufferWithData
194     override var position: Int = bufferWithData.size
195         private set
196 
197     init {
198         ensureCapacity(INITIAL_SIZE)
199     }
200 
ensureCapacitynull201     override fun ensureCapacity(requiredCapacity: Int) {
202         if (buffer.size < requiredCapacity)
203             buffer = buffer.copyOf(requiredCapacity.coerceAtLeast(buffer.size * 2))
204     }
205 
appendnull206     internal fun append(c: Long) {
207         ensureCapacity()
208         buffer[position++] = c
209     }
210 
buildnull211     override fun build() = buffer.copyOf(position)
212 }
213 
214 /**
215  * Serializer for [FloatArray].
216  *
217  * Encode elements one-by-one, as regular list,
218  * unless format's Encoder/Decoder have special handling for this serializer.
219  */
220 @PublishedApi
221 internal object FloatArraySerializer : KSerializer<FloatArray>,
222     PrimitiveArraySerializer<Float, FloatArray, FloatArrayBuilder>(Float.serializer()) {
223 
224     override fun FloatArray.collectionSize(): Int = size
225     override fun FloatArray.toBuilder(): FloatArrayBuilder = FloatArrayBuilder(this)
226     override fun empty(): FloatArray = FloatArray(0)
227 
228     override fun readElement(decoder: CompositeDecoder, index: Int, builder: FloatArrayBuilder, checkIndex: Boolean) {
229         builder.append(decoder.decodeFloatElement(descriptor, index))
230     }
231 
232     override fun writeContent(encoder: CompositeEncoder, content: FloatArray, size: Int) {
233         for (i in 0 until size)
234             encoder.encodeFloatElement(descriptor, i, content[i])
235     }
236 }
237 
238 @PublishedApi
239 internal class FloatArrayBuilder internal constructor(
240     bufferWithData: FloatArray
241 ) : PrimitiveArrayBuilder<FloatArray>() {
242 
243     private var buffer: FloatArray = bufferWithData
244     override var position: Int = bufferWithData.size
245         private set
246 
247     init {
248         ensureCapacity(INITIAL_SIZE)
249     }
250 
ensureCapacitynull251     override fun ensureCapacity(requiredCapacity: Int) {
252         if (buffer.size < requiredCapacity)
253             buffer = buffer.copyOf(requiredCapacity.coerceAtLeast(buffer.size * 2))
254     }
255 
appendnull256     internal fun append(c: Float) {
257         ensureCapacity()
258         buffer[position++] = c
259     }
260 
buildnull261     override fun build() = buffer.copyOf(position)
262 }
263 
264 /**
265  * Serializer for [DoubleArray].
266  *
267  * Encode elements one-by-one, as regular list,
268  * unless format's Encoder/Decoder have special handling for this serializer.
269  */
270 @PublishedApi
271 internal object DoubleArraySerializer : KSerializer<DoubleArray>,
272     PrimitiveArraySerializer<Double, DoubleArray, DoubleArrayBuilder>(Double.serializer()) {
273 
274     override fun DoubleArray.collectionSize(): Int = size
275     override fun DoubleArray.toBuilder(): DoubleArrayBuilder = DoubleArrayBuilder(this)
276     override fun empty(): DoubleArray = DoubleArray(0)
277 
278     override fun readElement(decoder: CompositeDecoder, index: Int, builder: DoubleArrayBuilder, checkIndex: Boolean) {
279         builder.append(decoder.decodeDoubleElement(descriptor, index))
280     }
281 
282     override fun writeContent(encoder: CompositeEncoder, content: DoubleArray, size: Int) {
283         for (i in 0 until size)
284             encoder.encodeDoubleElement(descriptor, i, content[i])
285     }
286 }
287 
288 @PublishedApi
289 internal class DoubleArrayBuilder internal constructor(
290     bufferWithData: DoubleArray
291 ) : PrimitiveArrayBuilder<DoubleArray>() {
292 
293     private var buffer: DoubleArray = bufferWithData
294     override var position: Int = bufferWithData.size
295         private set
296 
297     init {
298         ensureCapacity(INITIAL_SIZE)
299     }
300 
ensureCapacitynull301     override fun ensureCapacity(requiredCapacity: Int) {
302         if (buffer.size < requiredCapacity)
303             buffer = buffer.copyOf(requiredCapacity.coerceAtLeast(buffer.size * 2))
304     }
305 
appendnull306     internal fun append(c: Double) {
307         ensureCapacity()
308         buffer[position++] = c
309     }
310 
buildnull311     override fun build() = buffer.copyOf(position)
312 }
313 
314 /**
315  * Serializer for [CharArray].
316  *
317  * Encode elements one-by-one, as regular list,
318  * unless format's Encoder/Decoder have special handling for this serializer.
319  */
320 @PublishedApi
321 internal object CharArraySerializer : KSerializer<CharArray>,
322     PrimitiveArraySerializer<Char, CharArray, CharArrayBuilder>(Char.serializer()) {
323 
324     override fun CharArray.collectionSize(): Int = size
325     override fun CharArray.toBuilder(): CharArrayBuilder = CharArrayBuilder(this)
326     override fun empty(): CharArray = CharArray(0)
327 
328     override fun readElement(decoder: CompositeDecoder, index: Int, builder: CharArrayBuilder, checkIndex: Boolean) {
329         builder.append(decoder.decodeCharElement(descriptor, index))
330     }
331 
332     override fun writeContent(encoder: CompositeEncoder, content: CharArray, size: Int) {
333         for (i in 0 until size)
334             encoder.encodeCharElement(descriptor, i, content[i])
335     }
336 }
337 
338 @PublishedApi
339 internal class CharArrayBuilder internal constructor(
340     bufferWithData: CharArray
341 ) : PrimitiveArrayBuilder<CharArray>() {
342 
343     private var buffer: CharArray = bufferWithData
344     override var position: Int = bufferWithData.size
345         private set
346 
347     init {
348         ensureCapacity(INITIAL_SIZE)
349     }
350 
ensureCapacitynull351     override fun ensureCapacity(requiredCapacity: Int) {
352         if (buffer.size < requiredCapacity)
353             buffer = buffer.copyOf(requiredCapacity.coerceAtLeast(buffer.size * 2))
354     }
355 
appendnull356     internal fun append(c: Char) {
357         ensureCapacity()
358         buffer[position++] = c
359     }
360 
buildnull361     override fun build() = buffer.copyOf(position)
362 }
363 
364 /**
365  * Serializer for [BooleanArray].
366  * Encode elements one-by-one, as regular list, unless format's Encoder/Decoder have a special support for this serializer.
367  */
368 @PublishedApi
369 internal object BooleanArraySerializer : KSerializer<BooleanArray>,
370     PrimitiveArraySerializer<Boolean, BooleanArray, BooleanArrayBuilder>(Boolean.serializer()) {
371 
372     override fun BooleanArray.collectionSize(): Int = size
373     override fun BooleanArray.toBuilder(): BooleanArrayBuilder = BooleanArrayBuilder(this)
374     override fun empty(): BooleanArray = BooleanArray(0)
375 
376     override fun readElement(decoder: CompositeDecoder, index: Int, builder: BooleanArrayBuilder, checkIndex: Boolean) {
377         builder.append(decoder.decodeBooleanElement(descriptor, index))
378     }
379 
380     override fun writeContent(encoder: CompositeEncoder, content: BooleanArray, size: Int) {
381         for (i in 0 until size)
382             encoder.encodeBooleanElement(descriptor, i, content[i])
383     }
384 }
385 
386 @PublishedApi
387 internal class BooleanArrayBuilder internal constructor(
388     bufferWithData: BooleanArray
389 ) : PrimitiveArrayBuilder<BooleanArray>() {
390 
391     private var buffer: BooleanArray = bufferWithData
392     override var position: Int = bufferWithData.size
393         private set
394 
395     init {
396         ensureCapacity(INITIAL_SIZE)
397     }
398 
ensureCapacitynull399     override fun ensureCapacity(requiredCapacity: Int) {
400         if (buffer.size < requiredCapacity)
401             buffer = buffer.copyOf(requiredCapacity.coerceAtLeast(buffer.size * 2))
402     }
403 
appendnull404     internal fun append(c: Boolean) {
405         ensureCapacity()
406         buffer[position++] = c
407     }
408 
buildnull409     override fun build() = buffer.copyOf(position)
410 }
411 
412 
413 // Unsigned arrays
414 
415 /**
416  * Serializer for [UByteArray].
417  *
418  * Encode elements one-by-one, as regular list,
419  * unless format's Encoder/Decoder have special handling for this serializer.
420  */
421 @PublishedApi
422 @ExperimentalSerializationApi
423 @ExperimentalUnsignedTypes
424 internal object UByteArraySerializer : KSerializer<UByteArray>,
425     PrimitiveArraySerializer<UByte, UByteArray, UByteArrayBuilder>(UByte.serializer()) {
426 
427     override fun UByteArray.collectionSize(): Int = size
428     override fun UByteArray.toBuilder(): UByteArrayBuilder = UByteArrayBuilder(this)
429     override fun empty(): UByteArray = UByteArray(0)
430 
431     override fun readElement(decoder: CompositeDecoder, index: Int, builder: UByteArrayBuilder, checkIndex: Boolean) {
432         builder.append(decoder.decodeInlineElement(descriptor, index).decodeByte().toUByte())
433     }
434 
435     override fun writeContent(encoder: CompositeEncoder, content: UByteArray, size: Int) {
436         for (i in 0 until size)
437             encoder.encodeInlineElement(descriptor, i).encodeByte(content[i].toByte())
438     }
439 }
440 
441 @PublishedApi
442 @ExperimentalSerializationApi
443 @ExperimentalUnsignedTypes
444 internal class UByteArrayBuilder internal constructor(
445     bufferWithData: UByteArray
446 ) : PrimitiveArrayBuilder<UByteArray>() {
447 
448     private var buffer: UByteArray = bufferWithData
449     override var position: Int = bufferWithData.size
450         private set
451 
452     init {
453         ensureCapacity(INITIAL_SIZE)
454     }
455 
ensureCapacitynull456     override fun ensureCapacity(requiredCapacity: Int) {
457         if (buffer.size < requiredCapacity)
458             buffer = buffer.copyOf(requiredCapacity.coerceAtLeast(buffer.size * 2))
459     }
460 
appendnull461     internal fun append(c: UByte) {
462         ensureCapacity()
463         buffer[position++] = c
464     }
465 
buildnull466     override fun build() = buffer.copyOf(position)
467 }
468 
469 /**
470  * Serializer for [UShortArray].
471  *
472  * Encode elements one-by-one, as regular list,
473  * unless format's Encoder/Decoder have special handling for this serializer.
474  */
475 @PublishedApi
476 @ExperimentalSerializationApi
477 @ExperimentalUnsignedTypes
478 internal object UShortArraySerializer : KSerializer<UShortArray>,
479     PrimitiveArraySerializer<UShort, UShortArray, UShortArrayBuilder>(UShort.serializer()) {
480 
481     override fun UShortArray.collectionSize(): Int = size
482     override fun UShortArray.toBuilder(): UShortArrayBuilder = UShortArrayBuilder(this)
483     override fun empty(): UShortArray = UShortArray(0)
484 
485     override fun readElement(decoder: CompositeDecoder, index: Int, builder: UShortArrayBuilder, checkIndex: Boolean) {
486         builder.append(decoder.decodeInlineElement(descriptor, index).decodeShort().toUShort())
487     }
488 
489     override fun writeContent(encoder: CompositeEncoder, content: UShortArray, size: Int) {
490         for (i in 0 until size)
491             encoder.encodeInlineElement(descriptor, i).encodeShort(content[i].toShort())
492     }
493 }
494 
495 @PublishedApi
496 @ExperimentalSerializationApi
497 @ExperimentalUnsignedTypes
498 internal class UShortArrayBuilder internal constructor(
499     bufferWithData: UShortArray
500 ) : PrimitiveArrayBuilder<UShortArray>() {
501 
502     private var buffer: UShortArray = bufferWithData
503     override var position: Int = bufferWithData.size
504         private set
505 
506     init {
507         ensureCapacity(INITIAL_SIZE)
508     }
509 
ensureCapacitynull510     override fun ensureCapacity(requiredCapacity: Int) {
511         if (buffer.size < requiredCapacity)
512             buffer = buffer.copyOf(requiredCapacity.coerceAtLeast(buffer.size * 2))
513     }
514 
appendnull515     internal fun append(c: UShort) {
516         ensureCapacity()
517         buffer[position++] = c
518     }
519 
buildnull520     override fun build() = buffer.copyOf(position)
521 }
522 
523 /**
524  * Serializer for [UIntArray].
525  *
526  * Encode elements one-by-one, as regular list,
527  * unless format's Encoder/Decoder have special handling for this serializer.
528  */
529 @PublishedApi
530 @ExperimentalSerializationApi
531 @ExperimentalUnsignedTypes
532 internal object UIntArraySerializer : KSerializer<UIntArray>,
533     PrimitiveArraySerializer<UInt, UIntArray, UIntArrayBuilder>(UInt.serializer()) {
534 
535     override fun UIntArray.collectionSize(): Int = size
536     override fun UIntArray.toBuilder(): UIntArrayBuilder = UIntArrayBuilder(this)
537     override fun empty(): UIntArray = UIntArray(0)
538 
539     override fun readElement(decoder: CompositeDecoder, index: Int, builder: UIntArrayBuilder, checkIndex: Boolean) {
540         builder.append(decoder.decodeInlineElement(descriptor, index).decodeInt().toUInt())
541     }
542 
543     override fun writeContent(encoder: CompositeEncoder, content: UIntArray, size: Int) {
544         for (i in 0 until size)
545             encoder.encodeInlineElement(descriptor, i).encodeInt(content[i].toInt())
546     }
547 }
548 
549 @PublishedApi
550 @ExperimentalSerializationApi
551 @ExperimentalUnsignedTypes
552 internal class UIntArrayBuilder internal constructor(
553     bufferWithData: UIntArray
554 ) : PrimitiveArrayBuilder<UIntArray>() {
555 
556     private var buffer: UIntArray = bufferWithData
557     override var position: Int = bufferWithData.size
558         private set
559 
560     init {
561         ensureCapacity(INITIAL_SIZE)
562     }
563 
ensureCapacitynull564     override fun ensureCapacity(requiredCapacity: Int) {
565         if (buffer.size < requiredCapacity)
566             buffer = buffer.copyOf(requiredCapacity.coerceAtLeast(buffer.size * 2))
567     }
568 
appendnull569     internal fun append(c: UInt) {
570         ensureCapacity()
571         buffer[position++] = c
572     }
573 
buildnull574     override fun build() = buffer.copyOf(position)
575 }
576 
577 /**
578  * Serializer for [ULongArray].
579  *
580  * Encode elements one-by-one, as regular list,
581  * unless format's Encoder/Decoder have special handling for this serializer.
582  */
583 @PublishedApi
584 @ExperimentalSerializationApi
585 @ExperimentalUnsignedTypes
586 internal object ULongArraySerializer : KSerializer<ULongArray>,
587     PrimitiveArraySerializer<ULong, ULongArray, ULongArrayBuilder>(ULong.serializer()) {
588 
589     override fun ULongArray.collectionSize(): Int = size
590     override fun ULongArray.toBuilder(): ULongArrayBuilder = ULongArrayBuilder(this)
591     override fun empty(): ULongArray = ULongArray(0)
592 
593     override fun readElement(decoder: CompositeDecoder, index: Int, builder: ULongArrayBuilder, checkIndex: Boolean) {
594         builder.append(decoder.decodeInlineElement(descriptor, index).decodeLong().toULong())
595     }
596 
597     override fun writeContent(encoder: CompositeEncoder, content: ULongArray, size: Int) {
598         for (i in 0 until size)
599             encoder.encodeInlineElement(descriptor, i).encodeLong(content[i].toLong())
600     }
601 }
602 
603 @PublishedApi
604 @ExperimentalSerializationApi
605 @ExperimentalUnsignedTypes
606 internal class ULongArrayBuilder internal constructor(
607     bufferWithData: ULongArray
608 ) : PrimitiveArrayBuilder<ULongArray>() {
609 
610     private var buffer: ULongArray = bufferWithData
611     override var position: Int = bufferWithData.size
612         private set
613 
614     init {
615         ensureCapacity(INITIAL_SIZE)
616     }
617 
ensureCapacitynull618     override fun ensureCapacity(requiredCapacity: Int) {
619         if (buffer.size < requiredCapacity)
620             buffer = buffer.copyOf(requiredCapacity.coerceAtLeast(buffer.size * 2))
621     }
622 
appendnull623     internal fun append(c: ULong) {
624         ensureCapacity()
625         buffer[position++] = c
626     }
627 
buildnull628     override fun build() = buffer.copyOf(position)
629 }
630 
631