2 * Copyright 2015 Samsung Electronics All Rights Reserved.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 package oic.simulator.serviceprovider.utils;
19 import java.util.Vector;
21 import org.oic.simulator.AttributeValue;
23 public class AttributeValueBuilder {
24 public static AttributeValue build(String valueString,
25 AttributeValue.ValueType valueType) throws NullPointerException {
26 int depth = findDepth(valueString);
28 return handleDepth0(valueString, valueType);
29 } else if (1 == depth) {
30 return handleDepth1(valueString, valueType);
31 } else if (2 == depth) {
32 return handleDepth2(valueString, valueType);
33 } else if (3 == depth) {
34 return handleDepth3(valueString, valueType);
40 private static int findDepth(String value) {
42 for (char ch : value.toCharArray()) {
52 private static boolean isValidSyntax(String value) {
54 for (char ch : value.toCharArray()) {
67 private static AttributeValue handleDepth0(String valueString,
68 AttributeValue.ValueType valueType) {
69 valueString = valueString.trim();
70 if (0 != findDepth(valueString))
74 if (valueType == AttributeValue.ValueType.INTEGER)
75 return new AttributeValue(Integer.parseInt(valueString));
76 else if (valueType == AttributeValue.ValueType.DOUBLE) {
77 Double value = Double.parseDouble(valueString);
78 if (!value.isInfinite()) {
79 return new AttributeValue(value);
81 } else if (valueType == AttributeValue.ValueType.BOOLEAN) {
82 if (valueString.equalsIgnoreCase("true")
83 || valueString.equalsIgnoreCase("false"))
84 return new AttributeValue(Boolean.parseBoolean(valueString));
85 } else if (valueType == AttributeValue.ValueType.STRING)
86 return new AttributeValue(valueString);
87 } catch (Exception e) {
93 private static String[] splitIntoArrays(String valueString) {
94 Vector<String> values = new Vector<String>();
95 valueString = valueString.substring(valueString.indexOf('[') + 1,
96 valueString.lastIndexOf(']'));
100 char[] charArray = valueString.toCharArray();
101 for (int index = 0; index < charArray.length; index++) {
102 if (charArray[index] == '[' && 0 == count++) {
106 if (charArray[index] == ']' && 0 == --count) {
107 values.add(valueString.substring(startPos, index + 1));
111 String[] result = new String[values.size()];
112 values.toArray(result);
116 private static AttributeValue handleDepth1(String valueString,
117 AttributeValue.ValueType valueType) {
118 valueString = valueString.trim();
119 if (1 != findDepth(valueString) || false == isValidSyntax(valueString))
122 valueString = valueString.substring(valueString.indexOf('[') + 1,
123 valueString.lastIndexOf(']'));
124 String[] valuesString = valueString.split(",");
125 if (null == valuesString || 0 == valuesString.length)
128 if (valueType == AttributeValue.ValueType.INTEGER) {
129 if (1 == valuesString.length && valuesString[0].isEmpty()) {
130 return new AttributeValue(new Integer[0]);
133 Integer[] result = new Integer[valuesString.length];
134 for (int index = 0; index < valuesString.length; index++) {
135 if (null != valuesString[index]
136 && !valuesString[index].isEmpty()) {
137 AttributeValue attValue = handleDepth0(valuesString[index],
139 if (null == attValue)
142 Integer value = (Integer) attValue.get();
145 result[index] = value;
148 return new AttributeValue(result);
149 } else if (valueType == AttributeValue.ValueType.DOUBLE) {
150 if (1 == valuesString.length && valuesString[0].isEmpty()) {
151 return new AttributeValue(new Double[0]);
154 Double[] result = new Double[valuesString.length];
155 for (int index = 0; index < valuesString.length; index++) {
156 if (null != valuesString[index]
157 && !valuesString[index].isEmpty()) {
158 AttributeValue attValue = handleDepth0(valuesString[index],
160 if (null == attValue)
163 Double value = (Double) attValue.get();
166 result[index] = value;
169 return new AttributeValue(result);
170 } else if (valueType == AttributeValue.ValueType.BOOLEAN) {
171 if (1 == valuesString.length && valuesString[0].isEmpty()) {
172 return new AttributeValue(new Boolean[0]);
175 Boolean[] result = new Boolean[valuesString.length];
176 for (int index = 0; index < valuesString.length; index++) {
177 if (null != valuesString[index]
178 && !valuesString[index].isEmpty()) {
179 AttributeValue attValue = handleDepth0(valuesString[index],
181 if (null == attValue)
184 Boolean value = (Boolean) attValue.get();
187 result[index] = value;
190 return new AttributeValue(result);
191 } else if (valueType == AttributeValue.ValueType.STRING) {
192 if (1 == valuesString.length && valuesString[0].isEmpty()) {
193 return new AttributeValue(new String[0]);
196 for (int index = 0; index < valuesString.length; index++) {
197 if (null != valuesString[index]
198 && !valuesString[index].isEmpty()) {
199 valuesString[index] = valuesString[index].trim();
202 return new AttributeValue(valuesString);
208 private static AttributeValue handleDepth2(String valueString,
209 AttributeValue.ValueType valueType) {
210 valueString = valueString.trim();
211 if (2 != findDepth(valueString) || false == isValidSyntax(valueString))
214 String[] valuesString = splitIntoArrays(valueString);
215 if (null == valuesString || 0 == valuesString.length)
218 if (valueType == AttributeValue.ValueType.INTEGER) {
219 Integer[][] result = new Integer[valuesString.length][];
220 for (int index = 0; index < valuesString.length; index++) {
221 AttributeValue attValue = handleDepth1(valuesString[index],
223 if (null == attValue)
226 Integer[] value = (Integer[]) attValue.get();
229 result[index] = value;
231 return new AttributeValue(result);
232 } else if (valueType == AttributeValue.ValueType.DOUBLE) {
233 Double[][] result = new Double[valuesString.length][];
234 for (int index = 0; index < valuesString.length; index++) {
235 AttributeValue attValue = handleDepth1(valuesString[index],
237 if (null == attValue)
240 Double[] value = (Double[]) attValue.get();
243 result[index] = value;
245 return new AttributeValue(result);
246 } else if (valueType == AttributeValue.ValueType.BOOLEAN) {
247 Boolean[][] result = new Boolean[valuesString.length][];
248 for (int index = 0; index < valuesString.length; index++) {
249 AttributeValue attValue = handleDepth1(valuesString[index],
251 if (null == attValue)
254 Boolean[] value = (Boolean[]) attValue.get();
257 result[index] = value;
259 return new AttributeValue(result);
260 } else if (valueType == AttributeValue.ValueType.STRING) {
261 String[][] result = new String[valuesString.length][];
262 for (int index = 0; index < valuesString.length; index++) {
263 AttributeValue attValue = handleDepth1(valuesString[index],
265 if (null == attValue)
268 String[] value = (String[]) attValue.get();
271 result[index] = value;
273 return new AttributeValue(result);
279 public static AttributeValue handleDepth3(String valueString,
280 AttributeValue.ValueType valueType) {
281 valueString = valueString.trim();
282 if (3 != findDepth(valueString) || false == isValidSyntax(valueString))
285 String[] valuesString = splitIntoArrays(valueString);
286 if (null == valuesString || 0 == valuesString.length)
289 if (valueType == AttributeValue.ValueType.INTEGER) {
290 Integer[][][] result = new Integer[valuesString.length][][];
291 for (int index = 0; index < valuesString.length; index++) {
292 AttributeValue attValue = handleDepth2(valuesString[index],
294 if (null == attValue)
297 Integer[][] value = (Integer[][]) attValue.get();
300 result[index] = value;
302 return new AttributeValue(result);
303 } else if (valueType == AttributeValue.ValueType.DOUBLE) {
304 Double[][][] result = new Double[valuesString.length][][];
305 for (int index = 0; index < valuesString.length; index++) {
306 AttributeValue attValue = handleDepth2(valuesString[index],
308 if (null == attValue)
311 Double[][] value = (Double[][]) attValue.get();
314 result[index] = value;
316 return new AttributeValue(result);
317 } else if (valueType == AttributeValue.ValueType.BOOLEAN) {
318 Boolean[][][] result = new Boolean[valuesString.length][][];
319 for (int index = 0; index < valuesString.length; index++) {
320 AttributeValue attValue = handleDepth2(valuesString[index],
322 if (null == attValue)
325 Boolean[][] value = (Boolean[][]) attValue.get();
328 result[index] = value;
330 return new AttributeValue(result);
331 } else if (valueType == AttributeValue.ValueType.STRING) {
332 String[][][] result = new String[valuesString.length][][];
333 for (int index = 0; index < valuesString.length; index++) {
334 AttributeValue attValue = handleDepth2(valuesString[index],
336 if (null == attValue)
339 String[][] value = (String[][]) attValue.get();
342 result[index] = value;
344 return new AttributeValue(result);