service/simulator/java/eclipse-plugin/ServiceProviderPlugin/src/oic/simulator/serviceprovider/utils/AttributeValueBuilder.java

   1 /*
   2  * Copyright 2015 Samsung Electronics All Rights Reserved.
   3  *
   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
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  */
  16
  17 package oic.simulator.serviceprovider.utils;
  18
  19 import java.util.Vector;
  20
  21 import org.oic.simulator.AttributeValue;
  22
  23 public class AttributeValueBuilder {
  24     public static AttributeValue build(String valueString,
  25             AttributeValue.ValueType valueType) throws NullPointerException {
  26         int depth = findDepth(valueString);
  27         if (0 == depth) {
  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);
  35         }
  36
  37         return null;
  38     }
  39
  40     private static int findDepth(String value) {
  41         int depth = 0;
  42         for (char ch : value.toCharArray()) {
  43             if (ch == '[')
  44                 depth++;
  45             else
  46                 break;
  47         }
  48
  49         return depth;
  50     }
  51
  52     private static boolean isValidSyntax(String value) {
  53         int count = 0;
  54         for (char ch : value.toCharArray()) {
  55             if (ch == '[')
  56                 count++;
  57             if (ch == ']')
  58                 count--;
  59         }
  60
  61         if (count == 0)
  62             return true;
  63         return false;
  64
  65     }
  66
  67     private static AttributeValue handleDepth0(String valueString,
  68             AttributeValue.ValueType valueType) {
  69         valueString = valueString.trim();
  70         if (0 != findDepth(valueString))
  71             return null;
  72
  73         try {
  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);
  80                 }
  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) {
  88             return null;
  89         }
  90         return null;
  91     }
  92
  93     private static String[] splitIntoArrays(String valueString) {
  94         Vector<String> values = new Vector<String>();
  95         valueString = valueString.substring(valueString.indexOf('[') + 1,
  96                 valueString.lastIndexOf(']'));
  97
  98         int count = 0;
  99         int startPos = 0;
 100         char[] charArray = valueString.toCharArray();
 101         for (int index = 0; index < charArray.length; index++) {
 102             if (charArray[index] == '[' && 0 == count++) {
 103                 startPos = index;
 104             }
 105
 106             if (charArray[index] == ']' && 0 == --count) {
 107                 values.add(valueString.substring(startPos, index + 1));
 108             }
 109         }
 110
 111         String[] result = new String[values.size()];
 112         values.toArray(result);
 113         return result;
 114     }
 115
 116     private static AttributeValue handleDepth1(String valueString,
 117             AttributeValue.ValueType valueType) {
 118         valueString = valueString.trim();
 119         if (1 != findDepth(valueString) || false == isValidSyntax(valueString))
 120             return null;
 121
 122         valueString = valueString.substring(valueString.indexOf('[') + 1,
 123                 valueString.lastIndexOf(']'));
 124         String[] valuesString = valueString.split(",");
 125         if (null == valuesString || 0 == valuesString.length)
 126             return null;
 127
 128         if (valueType == AttributeValue.ValueType.INTEGER) {
 129             if (1 == valuesString.length && valuesString[0].isEmpty()) {
 130                 return new AttributeValue(new Integer[0]);
 131             }
 132
 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],
 138                             valueType);
 139                     if (null == attValue)
 140                         return null;
 141
 142                     Integer value = (Integer) attValue.get();
 143                     if (null == value)
 144                         return null;
 145                     result[index] = value;
 146                 }
 147             }
 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]);
 152             }
 153
 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],
 159                             valueType);
 160                     if (null == attValue)
 161                         return null;
 162
 163                     Double value = (Double) attValue.get();
 164                     if (null == value)
 165                         return null;
 166                     result[index] = value;
 167                 }
 168             }
 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]);
 173             }
 174
 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],
 180                             valueType);
 181                     if (null == attValue)
 182                         return null;
 183
 184                     Boolean value = (Boolean) attValue.get();
 185                     if (null == value)
 186                         return null;
 187                     result[index] = value;
 188                 }
 189             }
 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]);
 194             }
 195
 196             for (int index = 0; index < valuesString.length; index++) {
 197                 if (null != valuesString[index]
 198                         && !valuesString[index].isEmpty()) {
 199                     valuesString[index] = valuesString[index].trim();
 200                 }
 201             }
 202             return new AttributeValue(valuesString);
 203         }
 204
 205         return null;
 206     }
 207
 208     private static AttributeValue handleDepth2(String valueString,
 209             AttributeValue.ValueType valueType) {
 210         valueString = valueString.trim();
 211         if (2 != findDepth(valueString) || false == isValidSyntax(valueString))
 212             return null;
 213
 214         String[] valuesString = splitIntoArrays(valueString);
 215         if (null == valuesString || 0 == valuesString.length)
 216             return null;
 217
 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],
 222                         valueType);
 223                 if (null == attValue)
 224                     return null;
 225
 226                 Integer[] value = (Integer[]) attValue.get();
 227                 if (null == value)
 228                     return null;
 229                 result[index] = value;
 230             }
 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],
 236                         valueType);
 237                 if (null == attValue)
 238                     return null;
 239
 240                 Double[] value = (Double[]) attValue.get();
 241                 if (null == value)
 242                     return null;
 243                 result[index] = value;
 244             }
 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],
 250                         valueType);
 251                 if (null == attValue)
 252                     return null;
 253
 254                 Boolean[] value = (Boolean[]) attValue.get();
 255                 if (null == value)
 256                     return null;
 257                 result[index] = value;
 258             }
 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],
 264                         valueType);
 265                 if (null == attValue)
 266                     return null;
 267
 268                 String[] value = (String[]) attValue.get();
 269                 if (null == value)
 270                     return null;
 271                 result[index] = value;
 272             }
 273             return new AttributeValue(result);
 274         }
 275
 276         return null;
 277     }
 278
 279     public static AttributeValue handleDepth3(String valueString,
 280             AttributeValue.ValueType valueType) {
 281         valueString = valueString.trim();
 282         if (3 != findDepth(valueString) || false == isValidSyntax(valueString))
 283             return null;
 284
 285         String[] valuesString = splitIntoArrays(valueString);
 286         if (null == valuesString || 0 == valuesString.length)
 287             return null;
 288
 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],
 293                         valueType);
 294                 if (null == attValue)
 295                     return null;
 296
 297                 Integer[][] value = (Integer[][]) attValue.get();
 298                 if (null == value)
 299                     return null;
 300                 result[index] = value;
 301             }
 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],
 307                         valueType);
 308                 if (null == attValue)
 309                     return null;
 310
 311                 Double[][] value = (Double[][]) attValue.get();
 312                 if (null == value)
 313                     return null;
 314                 result[index] = value;
 315             }
 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],
 321                         valueType);
 322                 if (null == attValue)
 323                     return null;
 324
 325                 Boolean[][] value = (Boolean[][]) attValue.get();
 326                 if (null == value)
 327                     return null;
 328                 result[index] = value;
 329             }
 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],
 335                         valueType);
 336                 if (null == attValue)
 337                     return null;
 338
 339                 String[][] value = (String[][]) attValue.get();
 340                 if (null == value)
 341                     return null;
 342                 result[index] = value;
 343             }
 344             return new AttributeValue(result);
 345         }
 346
 347         return null;
 348     }
 349 }