Package: ServiceXmlConfigPropertiesAdapter

ServiceXmlConfigPropertiesAdapter

name	instruction	branch	complexity	line	method
ServiceXmlConfigPropertiesAdapter()	M: 3 C: 0 0%	M: 0 C: 0 100%	M: 1 C: 0 0%	M: 1 C: 0 0%	M: 1 C: 0 0%
lambda$marshal$0(List, String, Object)	M: 517 C: 0 0%	M: 68 C: 0 0%	M: 35 C: 0 0%	M: 116 C: 0 0%	M: 1 C: 0 0%
marshal(Map)	M: 23 C: 0 0%	M: 2 C: 0 0%	M: 2 C: 0 0%	M: 6 C: 0 0%	M: 1 C: 0 0%
unmarshal(ServiceXmlConfigPropertiesAdapted)	M: 388 C: 0 0%	M: 60 C: 0 0%	M: 39 C: 0 0%	M: 83 C: 0 0%	M: 1 C: 0 0%

Coverage

1: /*******************************************************************************
2: * Copyright (c) 2019, 2022 Eurotech and/or its affiliates and others
3: *
4: * This program and the accompanying materials are made
5: * available under the terms of the Eclipse Public License 2.0
6: * which is available at https://www.eclipse.org/legal/epl-2.0/
7: *
8: * SPDX-License-Identifier: EPL-2.0
9: *
10: * Contributors:
11: * Eurotech - initial API and implementation
12: *******************************************************************************/
13: package org.eclipse.kapua.service.config;
14:
15: import org.eclipse.kapua.service.config.ServiceXmlConfigPropertyAdapted.ConfigPropertyType;
16:
17: import javax.xml.bind.annotation.adapters.XmlAdapter;
18: import java.util.ArrayList;
19: import java.util.HashMap;
20: import java.util.List;
21: import java.util.Map;
22:
23: /**
24: * Xml configuration properties adapter. It marshal and unmarshal configuration properties in a proper way.
25: *
26: * @since 1.0
27: */
28: public class ServiceXmlConfigPropertiesAdapter extends XmlAdapter<ServiceXmlConfigPropertiesAdapted, Map<String, Object>> {
29:
30: @Override
31: public ServiceXmlConfigPropertiesAdapted marshal(Map<String, Object> props) {
32: List<ServiceXmlConfigPropertyAdapted> adaptedValues = new ArrayList<>();
33:
34:• if (props != null) {
35: props.forEach((name, value) -> {
36:
37: ServiceXmlConfigPropertyAdapted adaptedValue = new ServiceXmlConfigPropertyAdapted();
38: adaptedValue.setName(name);
39:
40:• if (value instanceof String) {
41: adaptedValue.setArray(false);
42: adaptedValue.setType(ConfigPropertyType.stringType);
43: adaptedValue.setValues(new String[] { value.toString() });
44:• } else if (value instanceof Long) {
45: adaptedValue.setArray(false);
46: adaptedValue.setType(ConfigPropertyType.longType);
47: adaptedValue.setValues(new String[] { value.toString() });
48:• } else if (value instanceof Double) {
49: adaptedValue.setArray(false);
50: adaptedValue.setType(ConfigPropertyType.doubleType);
51: adaptedValue.setValues(new String[] { value.toString() });
52:• } else if (value instanceof Float) {
53: adaptedValue.setArray(false);
54: adaptedValue.setType(ConfigPropertyType.floatType);
55: adaptedValue.setValues(new String[] { value.toString() });
56:• } else if (value instanceof Integer) {
57: adaptedValue.setArray(false);
58: adaptedValue.setType(ConfigPropertyType.integerType);
59: adaptedValue.setValues(new String[] { value.toString() });
60:• } else if (value instanceof Byte) {
61: adaptedValue.setArray(false);
62: adaptedValue.setType(ConfigPropertyType.byteType);
63: adaptedValue.setValues(new String[] { value.toString() });
64:• } else if (value instanceof Character) {
65: adaptedValue.setArray(false);
66: adaptedValue.setType(ConfigPropertyType.charType);
67: adaptedValue.setValues(new String[] { value.toString() });
68:• } else if (value instanceof Boolean) {
69: adaptedValue.setArray(false);
70: adaptedValue.setType(ConfigPropertyType.booleanType);
71: adaptedValue.setValues(new String[] { value.toString() });
72:• } else if (value instanceof Short) {
73: adaptedValue.setArray(false);
74: adaptedValue.setType(ConfigPropertyType.shortType);
75: adaptedValue.setValues(new String[] { value.toString() });
76:• } else if (value instanceof String[]) {
77: adaptedValue.setArray(true);
78: adaptedValue.setType(ConfigPropertyType.stringType);
79: adaptedValue.setValues((String[]) value);
80:• } else if (value instanceof Long[]) {
81: adaptedValue.setArray(true);
82: adaptedValue.setType(ConfigPropertyType.longType);
83: Long[] nativeValues = (Long[]) value;
84: String[] stringValues = new String[nativeValues.length];
85:• for (int i = 0; i < nativeValues.length; i++) {
86:• if (nativeValues[i] != null) {
87: stringValues[i] = nativeValues[i].toString();
88: }
89: }
90: adaptedValue.setValues(stringValues);
91:• } else if (value instanceof Double[]) {
92: adaptedValue.setArray(true);
93: adaptedValue.setType(ConfigPropertyType.doubleType);
94: Double[] nativeValues = (Double[]) value;
95: String[] stringValues = new String[nativeValues.length];
96:• for (int i = 0; i < nativeValues.length; i++) {
97:• if (nativeValues[i] != null) {
98: stringValues[i] = nativeValues[i].toString();
99: }
100: }
101: adaptedValue.setValues(stringValues);
102:• } else if (value instanceof Float[]) {
103: adaptedValue.setArray(true);
104: adaptedValue.setType(ConfigPropertyType.floatType);
105: Float[] nativeValues = (Float[]) value;
106: String[] stringValues = new String[nativeValues.length];
107:• for (int i = 0; i < nativeValues.length; i++) {
108:• if (nativeValues[i] != null) {
109: stringValues[i] = nativeValues[i].toString();
110: }
111: }
112: adaptedValue.setValues(stringValues);
113:• } else if (value instanceof Integer[]) {
114: adaptedValue.setArray(true);
115: adaptedValue.setType(ConfigPropertyType.integerType);
116: Integer[] nativeValues = (Integer[]) value;
117: String[] stringValues = new String[nativeValues.length];
118:• for (int i = 0; i < nativeValues.length; i++) {
119:• if (nativeValues[i] != null) {
120: stringValues[i] = nativeValues[i].toString();
121: }
122: }
123: adaptedValue.setValues(stringValues);
124:• } else if (value instanceof Byte[]) {
125: adaptedValue.setArray(true);
126: adaptedValue.setType(ConfigPropertyType.byteType);
127: Byte[] nativeValues = (Byte[]) value;
128: String[] stringValues = new String[nativeValues.length];
129:• for (int i = 0; i < nativeValues.length; i++) {
130:• if (nativeValues[i] != null) {
131: stringValues[i] = nativeValues[i].toString();
132: }
133: }
134: adaptedValue.setValues(stringValues);
135:• } else if (value instanceof Character[]) {
136: adaptedValue.setArray(true);
137: adaptedValue.setType(ConfigPropertyType.charType);
138: Character[] nativeValues = (Character[]) value;
139: String[] stringValues = new String[nativeValues.length];
140:• for (int i = 0; i < nativeValues.length; i++) {
141:• if (nativeValues[i] != null) {
142: stringValues[i] = nativeValues[i].toString();
143: }
144: }
145: adaptedValue.setValues(stringValues);
146:• } else if (value instanceof Boolean[]) {
147: adaptedValue.setArray(true);
148: adaptedValue.setType(ConfigPropertyType.booleanType);
149: Boolean[] nativeValues = (Boolean[]) value;
150: String[] stringValues = new String[nativeValues.length];
151:• for (int i = 0; i < nativeValues.length; i++) {
152:• if (nativeValues[i] != null) {
153: stringValues[i] = nativeValues[i].toString();
154: }
155: }
156: adaptedValue.setValues(stringValues);
157:• } else if (value instanceof Short[]) {
158: adaptedValue.setArray(true);
159: adaptedValue.setType(ConfigPropertyType.shortType);
160: Short[] nativeValues = (Short[]) value;
161: String[] stringValues = new String[nativeValues.length];
162:• for (int i = 0; i < nativeValues.length; i++) {
163:• if (nativeValues[i] != null) {
164: stringValues[i] = nativeValues[i].toString();
165: }
166: }
167: adaptedValue.setValues(stringValues);
168: }
169:
170: adaptedValues.add(adaptedValue);
171: });
172: }
173:
174: ServiceXmlConfigPropertiesAdapted result = new ServiceXmlConfigPropertiesAdapted();
175: result.setProperties(adaptedValues.toArray(new ServiceXmlConfigPropertyAdapted[] {}));
176: return result;
177: }
178:
179: @Override
180: public Map<String, Object> unmarshal(ServiceXmlConfigPropertiesAdapted adaptedPropsAdapted) {
181: ServiceXmlConfigPropertyAdapted[] adaptedProps = adaptedPropsAdapted.getProperties();
182:• if (adaptedProps == null) {
183: return new HashMap<>();
184: }
185:
186: Map<String, Object> properties = new HashMap<>();
187:• for (ServiceXmlConfigPropertyAdapted adaptedProp : adaptedProps) {
188: String propName = adaptedProp.getName();
189: ConfigPropertyType type = adaptedProp.getType();
190:• if (type != null) {
191: Object propValue = null;
192:• if (!adaptedProp.getArray()) {
193:• switch (adaptedProp.getType()) {
194: case stringType:
195: propValue = adaptedProp.getValues()[0];
196: break;
197: case longType:
198: propValue = Long.parseLong(adaptedProp.getValues()[0]);
199: break;
200: case doubleType:
201: propValue = Double.parseDouble(adaptedProp.getValues()[0]);
202: break;
203: case floatType:
204: propValue = Float.parseFloat(adaptedProp.getValues()[0]);
205: break;
206: case integerType:
207: propValue = Integer.parseInt(adaptedProp.getValues()[0]);
208: break;
209: case byteType:
210: propValue = Byte.parseByte(adaptedProp.getValues()[0]);
211: break;
212: case charType:
213: String s = adaptedProp.getValues()[0];
214: propValue = s.charAt(0);
215: break;
216: case booleanType:
217: propValue = Boolean.parseBoolean(adaptedProp.getValues()[0]);
218: break;
219: case shortType:
220: propValue = Short.parseShort(adaptedProp.getValues()[0]);
221: break;
222: }
223: } else {
224:• switch (adaptedProp.getType()) {
225: case stringType:
226: propValue = adaptedProp.getValues();
227: break;
228: case longType:
229: Long[] longValues = new Long[adaptedProp.getValues().length];
230:• for (int i = 0; i < adaptedProp.getValues().length; i++) {
231:• if (adaptedProp.getValues()[i] != null) {
232: longValues[i] = Long.parseLong(adaptedProp.getValues()[i]);
233: }
234: }
235: propValue = longValues;
236: break;
237: case doubleType:
238: Double[] doubleValues = new Double[adaptedProp.getValues().length];
239:• for (int i = 0; i < adaptedProp.getValues().length; i++) {
240:• if (adaptedProp.getValues()[i] != null) {
241: doubleValues[i] = Double.parseDouble(adaptedProp.getValues()[i]);
242: }
243: }
244: propValue = doubleValues;
245: break;
246: case floatType:
247: Float[] floatValues = new Float[adaptedProp.getValues().length];
248:• for (int i = 0; i < adaptedProp.getValues().length; i++) {
249:• if (adaptedProp.getValues()[i] != null) {
250: floatValues[i] = Float.parseFloat(adaptedProp.getValues()[i]);
251: }
252: }
253: propValue = floatValues;
254: break;
255: case integerType:
256: Integer[] intValues = new Integer[adaptedProp.getValues().length];
257:• for (int i = 0; i < adaptedProp.getValues().length; i++) {
258:• if (adaptedProp.getValues()[i] != null) {
259: intValues[i] = Integer.parseInt(adaptedProp.getValues()[i]);
260: }
261: }
262: propValue = intValues;
263: break;
264: case byteType:
265: Byte[] byteValues = new Byte[adaptedProp.getValues().length];
266:• for (int i = 0; i < adaptedProp.getValues().length; i++) {
267:• if (adaptedProp.getValues()[i] != null) {
268: byteValues[i] = Byte.parseByte(adaptedProp.getValues()[i]);
269: }
270: }
271: propValue = byteValues;
272: break;
273: case charType:
274: Character[] charValues = new Character[adaptedProp.getValues().length];
275:• for (int i = 0; i < adaptedProp.getValues().length; i++) {
276:• if (adaptedProp.getValues()[i] != null) {
277: String s = adaptedProp.getValues()[i];
278: charValues[i] = s.charAt(0);
279: }
280: }
281: propValue = charValues;
282: break;
283: case booleanType:
284: Boolean[] booleanValues = new Boolean[adaptedProp.getValues().length];
285:• for (int i = 0; i < adaptedProp.getValues().length; i++) {
286:• if (adaptedProp.getValues()[i] != null) {
287: booleanValues[i] = Boolean.parseBoolean(adaptedProp.getValues()[i]);
288: }
289: }
290: propValue = booleanValues;
291: break;
292: case shortType:
293: Short[] shortValues = new Short[adaptedProp.getValues().length];
294:• for (int i = 0; i < adaptedProp.getValues().length; i++) {
295:• if (adaptedProp.getValues()[i] != null) {
296: shortValues[i] = Short.parseShort(adaptedProp.getValues()[i]);
297: }
298: }
299: propValue = shortValues;
300: break;
301: }
302: }
303: properties.put(propName, propValue);
304: }
305: }
306: return properties;
307: }
308: }