Package: ArraySerializer$CharacterArraySerializer

ArraySerializer$CharacterArraySerializer

name	instruction	branch	complexity	line	method
ArraySerializer.CharacterArraySerializer(ModelSerializer)	M: 4 C: 0 0%	M: 0 C: 0 100%	M: 1 C: 0 0%	M: 2 C: 0 0%	M: 1 C: 0 0%
serializeArray(Object, JsonGenerator, SerializationContextImpl)	M: 27 C: 0 0%	M: 2 C: 0 0%	M: 2 C: 0 0%	M: 4 C: 0 0%	M: 1 C: 0 0%

Coverage

1: /*
2: * Copyright (c) 2021, 2022 Oracle and/or its affiliates. All rights reserved.
3: *
4: * This program and the accompanying materials are made available under the
5: * terms of the Eclipse Public License v. 2.0 which is available at
6: * http://www.eclipse.org/legal/epl-2.0,
7: * or the Eclipse Distribution License v. 1.0 which is available at
8: * http://www.eclipse.org/org/documents/edl-v10.php.
9: *
10: * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
11: */
12:
13: package org.eclipse.yasson.internal.serializer;
14:
15: import java.util.Base64;
16: import java.util.Map;
17: import java.util.function.Function;
18:
19: import jakarta.json.bind.JsonbException;
20: import jakarta.json.bind.config.BinaryDataStrategy;
21: import jakarta.json.stream.JsonGenerator;
22:
23: import org.eclipse.yasson.internal.JsonbContext;
24: import org.eclipse.yasson.internal.SerializationContextImpl;
25: import org.eclipse.yasson.internal.properties.MessageKeys;
26: import org.eclipse.yasson.internal.properties.Messages;
27:
28: /**
29: * Array container serializer.
30: */
31: abstract class ArraySerializer implements ModelSerializer {
32:
33: private static final Map<Class<?>, Function<ModelSerializer, ArraySerializer>> ARRAY_SERIALIZERS;
34:
35: static {
36: ARRAY_SERIALIZERS = Map.of(boolean[].class, BooleanArraySerializer::new,
37: byte[].class, ByteArraySerializer::new,
38: char[].class, CharacterArraySerializer::new,
39: double[].class, DoubleArraySerializer::new,
40: float[].class, FloatArraySerializer::new,
41: int[].class, IntegerArraySerializer::new,
42: long[].class, LongArraySerializer::new,
43: short[].class, ShortArraySerializer::new);
44: }
45:
46: private final ModelSerializer valueSerializer;
47:
48: protected ArraySerializer(ModelSerializer valueSerializer) {
49: this.valueSerializer = valueSerializer;
50: }
51:
52: public static ModelSerializer create(Class<?> arrayType,
53: JsonbContext jsonbContext,
54: ModelSerializer modelSerializer) {
55: String binaryDataStrategy = jsonbContext.getConfigProperties().getBinaryDataStrategy();
56: if (byte[].class.equals(arrayType) && !binaryDataStrategy.equals(BinaryDataStrategy.BYTE)) {
57: return new Base64ByteArraySerializer(binaryDataStrategy);
58: }
59: if (ARRAY_SERIALIZERS.containsKey(arrayType)) {
60: return ARRAY_SERIALIZERS.get(arrayType).apply(modelSerializer);
61: }
62: return new ObjectArraySerializer(modelSerializer);
63: }
64:
65: @Override
66: public void serialize(Object value, JsonGenerator generator, SerializationContextImpl context) {
67: generator.writeStartArray();
68: serializeArray(value, generator, context);
69: generator.writeEnd();
70: }
71:
72: abstract void serializeArray(Object value, JsonGenerator generator, SerializationContextImpl context);
73:
74: protected ModelSerializer getValueSerializer() {
75: return valueSerializer;
76: }
77:
78: private static final class ByteArraySerializer extends ArraySerializer {
79:
80: ByteArraySerializer(ModelSerializer valueSerializer) {
81: super(valueSerializer);
82: }
83:
84: @Override
85: public void serializeArray(Object value, JsonGenerator generator, SerializationContextImpl context) {
86: byte[] array = (byte[]) value;
87: for (byte b : array) {
88: getValueSerializer().serialize(b, generator, context);
89: }
90: }
91:
92: }
93:
94: private static final class Base64ByteArraySerializer implements ModelSerializer {
95:
96: private final Base64.Encoder encoder;
97:
98: Base64ByteArraySerializer(String strategy) {
99: this.encoder = getEncoder(strategy);
100: }
101:
102: @Override
103: public void serialize(Object value, JsonGenerator generator, SerializationContextImpl context) {
104: byte[] array = (byte[]) value;
105: generator.write(encoder.encodeToString(array));
106: }
107:
108: private Base64.Encoder getEncoder(String strategy) {
109: switch (strategy) {
110: case BinaryDataStrategy.BASE_64:
111: return Base64.getEncoder();
112: case BinaryDataStrategy.BASE_64_URL:
113: return Base64.getUrlEncoder();
114: default:
115: throw new JsonbException(Messages.getMessage(MessageKeys.INTERNAL_ERROR, "Invalid strategy: " + strategy));
116: }
117: }
118: }
119:
120: private static final class ShortArraySerializer extends ArraySerializer {
121:
122: ShortArraySerializer(ModelSerializer valueSerializer) {
123: super(valueSerializer);
124: }
125:
126: @Override
127: public void serializeArray(Object value, JsonGenerator generator, SerializationContextImpl context) {
128: short[] array = (short[]) value;
129: for (short s : array) {
130: getValueSerializer().serialize(s, generator, context);
131: }
132: }
133:
134: }
135:
136: private static final class IntegerArraySerializer extends ArraySerializer {
137:
138: IntegerArraySerializer(ModelSerializer valueSerializer) {
139: super(valueSerializer);
140: }
141:
142: @Override
143: public void serializeArray(Object value, JsonGenerator generator, SerializationContextImpl context) {
144: int[] array = (int[]) value;
145: for (int i : array) {
146: getValueSerializer().serialize(i, generator, context);
147: }
148: }
149:
150: }
151:
152: private static final class LongArraySerializer extends ArraySerializer {
153:
154: LongArraySerializer(ModelSerializer valueSerializer) {
155: super(valueSerializer);
156: }
157:
158: @Override
159: public void serializeArray(Object value, JsonGenerator generator, SerializationContextImpl context) {
160: long[] array = (long[]) value;
161: for (long l : array) {
162: getValueSerializer().serialize(l, generator, context);
163: }
164: }
165:
166: }
167:
168: private static final class FloatArraySerializer extends ArraySerializer {
169:
170: FloatArraySerializer(ModelSerializer valueSerializer) {
171: super(valueSerializer);
172: }
173:
174: @Override
175: public void serializeArray(Object value, JsonGenerator generator, SerializationContextImpl context) {
176: float[] array = (float[]) value;
177: for (float f : array) {
178: getValueSerializer().serialize(f, generator, context);
179: }
180: }
181:
182: }
183:
184: private static final class DoubleArraySerializer extends ArraySerializer {
185:
186: DoubleArraySerializer(ModelSerializer valueSerializer) {
187: super(valueSerializer);
188: }
189:
190: @Override
191: public void serializeArray(Object value, JsonGenerator generator, SerializationContextImpl context) {
192: double[] array = (double[]) value;
193: for (double d : array) {
194: getValueSerializer().serialize(d, generator, context);
195: }
196: }
197:
198: }
199:
200: private static final class BooleanArraySerializer extends ArraySerializer {
201:
202: BooleanArraySerializer(ModelSerializer valueSerializer) {
203: super(valueSerializer);
204: }
205:
206: @Override
207: public void serializeArray(Object value, JsonGenerator generator, SerializationContextImpl context) {
208: boolean[] array = (boolean[]) value;
209: for (boolean b : array) {
210: getValueSerializer().serialize(b, generator, context);
211: }
212: }
213:
214: }
215:
216: private static final class CharacterArraySerializer extends ArraySerializer {
217:
218: CharacterArraySerializer(ModelSerializer valueSerializer) {
219: super(valueSerializer);
220: }
221:
222: @Override
223: public void serializeArray(Object value, JsonGenerator generator, SerializationContextImpl context) {
224: char[] array = (char[]) value;
225:• for (char c : array) {
226: getValueSerializer().serialize(c, generator, context);
227: }
228: }
229:
230: }
231:
232: private static final class ObjectArraySerializer extends ArraySerializer {
233:
234: ObjectArraySerializer(ModelSerializer valueSerializer) {
235: super(valueSerializer);
236: }
237:
238: @Override
239: public void serializeArray(Object value, JsonGenerator generator, SerializationContextImpl context) {
240: Object[] array = (Object[]) value;
241: for (Object o : array) {
242: getValueSerializer().serialize(o, generator, context);
243: }
244: }
245:
246: }
247:
248: }