misc/env/src/main/java/org/onap/aaf/misc/env/BaseDataFactory.java

   1 /**\r
   2  * ============LICENSE_START====================================================\r
   3  * org.onap.aaf\r
   4  * ===========================================================================\r
   5  * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.\r
   6  * ===========================================================================\r
   7  * Licensed under the Apache License, Version 2.0 (the "License");\r
   8  * you may not use this file except in compliance with the License.\r
   9  * You may obtain a copy of the License at\r
  10  * \r
  11  *      http://www.apache.org/licenses/LICENSE-2.0\r
  12  * \r
  13  * Unless required by applicable law or agreed to in writing, software\r
  14  * distributed under the License is distributed on an "AS IS" BASIS,\r
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  16  * See the License for the specific language governing permissions and\r
  17  * limitations under the License.\r
  18  * ============LICENSE_END====================================================\r
  19  *\r
  20  */\r
  21 \r
  22 package org.onap.aaf.misc.env;\r
  23 \r
  24 import java.io.File;\r
  25 import java.io.FileInputStream;\r
  26 import java.io.FileNotFoundException;\r
  27 import java.io.IOException;\r
  28 \r
  29 import javax.xml.XMLConstants;\r
  30 import javax.xml.bind.annotation.XmlRootElement;\r
  31 import javax.xml.bind.annotation.XmlSchema;\r
  32 import javax.xml.namespace.QName;\r
  33 import javax.xml.transform.Source;\r
  34 import javax.xml.transform.stream.StreamSource;\r
  35 import javax.xml.validation.Schema;\r
  36 import javax.xml.validation.SchemaFactory;\r
  37 \r
  38 import org.onap.aaf.misc.env.impl.EnvFactory;\r
  39 import org.xml.sax.SAXException;\r
  40 \r
  41 \r
  42 \r
  43 /**\r
  44  * DataFactory Constructor will create the Stringifiers and Objectifiers necessary \r
  45  * by Type and store the Class of the Type for quick creation of Data Objects\r
  46  * with reused (and thread safe) components\r
  47  * s\r
  48  * Native Types are included.\r
  49  * Those types covered by Env Implementation are covered dynamically.\r
  50  * Types outside of Env mechanism can be added with "add" function\r
  51  * \r
  52  * @author Jonathan\r
  53  *\r
  54  * @param <T>\r
  55  */\r
  56 public class BaseDataFactory {\r
  57         private static final Object LOCK = new Object();\r
  58         /**\r
  59          * Generate a Schema Object for use in validation based on FileNames.\r
  60          * \r
  61          * WARNING: The java.xml.binding code requires YOU to figure out what order the\r
  62          * files go in.  If there is an import from A in B, then you must list A first.\r
  63          * \r
  64          * @param err\r
  65          * @param filenames\r
  66          * @return\r
  67          * @throws APIException\r
  68          */\r
  69         public static Schema genSchema(Store env, String ... filenames) throws APIException {\r
  70                 String schemaDir = env.get(\r
  71                                 env.staticSlot(EnvFactory.SCHEMA_DIR),\r
  72                                 EnvFactory.DEFAULT_SCHEMA_DIR);\r
  73                 File dir = new File(schemaDir);\r
  74                 if(!dir.exists())throw new APIException("Schema Directory " + schemaDir + " does not exist.  You can set this with " + EnvFactory.SCHEMA_DIR + " property");\r
  75                 FileInputStream[] fis = new FileInputStream[filenames.length];\r
  76                 Source[] sources = new Source[filenames.length];\r
  77                 File f; \r
  78                 for(int i=0; i<filenames.length; ++i) {\r
  79                         if(!(f=new File(schemaDir + File.separatorChar + filenames[i])).exists()) {\r
  80                                 if(!f.exists()) throw new APIException("Cannot find " + f.getName() + " for schema validation");\r
  81                         }\r
  82                         try {\r
  83                                 fis[i]=new FileInputStream(f);\r
  84                         } catch (FileNotFoundException e) {\r
  85                                 throw new APIException(e);\r
  86                         }\r
  87                         sources[i]= new StreamSource(fis[i]);\r
  88                 }\r
  89                 try {\r
  90                         //Note: SchemaFactory is not reentrant or very thread safe either... see docs\r
  91                         synchronized(LOCK) { // SchemaFactory is not reentrant\r
  92                                 return SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI)\r
  93                                         .newSchema(sources);\r
  94                         }\r
  95                 } catch (SAXException e) {\r
  96                         throw new APIException(e);\r
  97                 } finally {\r
  98                         for(FileInputStream d : fis) {\r
  99                                 try {\r
 100                                         d.close();\r
 101                                 } catch (IOException e) {\r
 102                                  // Never mind... we did our best\r
 103                                 }\r
 104                         }\r
 105                 }\r
 106 \r
 107         }\r
 108 \r
 109         public static QName getQName(Class<?> clss) throws APIException {\r
 110                 // Obtain the Necessary info for QName from Requirement\r
 111                 XmlRootElement xre = clss.getAnnotation(XmlRootElement.class);\r
 112                 if(xre==null)throw new APIException(clss.getName() + " does not have an XmlRootElement annotation");\r
 113                 Package pkg = clss.getPackage();\r
 114                 XmlSchema xs = pkg.getAnnotation(XmlSchema.class);\r
 115                 if(xs==null) throw new APIException(clss.getName() + " package-info does not have an XmlSchema annotation");\r
 116                 return new QName(xs.namespace(),xre.name());\r
 117         }\r
 118 \r
 119         /////////////////////////////////////////////\r
 120         // Native Type Converters\r
 121         /////////////////////////////////////////////\r
 122 //      /**\r
 123 //       * StringStringifier\r
 124 //       * \r
 125 //       * Support the Native Type String.. just return it back\r
 126 //       * \r
 127 //       * @author Jonathan\r
 128 //       *\r
 129 //       */\r
 130 //      public static class StringStringifier extends NullLifeCycle implements Stringifier<String> {\r
 131 //              /* (non-Javadoc)\r
 132 //               * @see com.att.env.Stringifier#stringify(com.att.env.Env, java.lang.Object)\r
 133 //               */\r
 134 //              public String stringify(Env env, String input) throws APIException {\r
 135 //                      return input;\r
 136 //              }\r
 137 //      };              \r
 138 //\r
 139 //      /**\r
 140 //       * StringObjectifier\r
 141 //       * \r
 142 //       * Support the Native Type String.. just return it back\r
 143 //       * \r
 144 //       * @author Jonathan\r
 145 //       *\r
 146 //       */\r
 147 //      public static class StringObjectifier extends NullLifeCycle implements Objectifier<String> {\r
 148 //              /* (non-Javadoc)\r
 149 //               * @see com.att.env.Objectifier#objectify(com.att.env.Env, java.lang.String)\r
 150 //               */\r
 151 //              public String objectify(Env env, String input) throws APIException {\r
 152 //                      return input;\r
 153 //              }\r
 154 //\r
 155 //              /* (non-Javadoc)\r
 156 //               * @see com.att.env.Objectifier#newObject()\r
 157 //               */\r
 158 //              public String newInstance() throws APIException {\r
 159 //                      return "";\r
 160 //              }\r
 161 //      };\r
 162 //      \r
 163 //      /**\r
 164 //       * LongStringifier\r
 165 //       * \r
 166 //       * Support the Native Type Long.. use Long parse functions\r
 167 //       * \r
 168 //       * @author Jonathan\r
 169 //       *\r
 170 //       */\r
 171 //      public static class LongStringifier extends NullLifeCycle implements Stringifier<Long> {\r
 172 //              public String stringify(Env env, Long input) throws APIException {\r
 173 //                      return input.toString();\r
 174 //              }\r
 175 //      }\r
 176 //      \r
 177 //      /**\r
 178 //       * LongObjectifier\r
 179 //       * \r
 180 //       * Support the Native Type Long.. use Long parse functions\r
 181 //       * \r
 182 //       * @author Jonathan\r
 183 //       *\r
 184 //       */\r
 185 //      public static class LongObjectifier extends NullLifeCycle implements Objectifier<Long> {\r
 186 //              /* (non-Javadoc)\r
 187 //               * @see com.att.env.Objectifier#objectify(com.att.env.Env, java.lang.String)\r
 188 //               */\r
 189 //              public Long objectify(Env env, String input) throws APIException {\r
 190 //                      try {\r
 191 //                              return new Long(input);\r
 192 //                      } catch (Exception e) {\r
 193 //                              APIException ae = new APIException("Cannot create a \"Long\" from [" + input + ']');\r
 194 //                              ae.initCause(e);\r
 195 //                              throw ae;\r
 196 //                      }\r
 197 //              }\r
 198 //\r
 199 //              /* (non-Javadoc)\r
 200 //               * @see com.att.env.Objectifier#newObject()\r
 201 //               */\r
 202 //              public Long newInstance() throws APIException {\r
 203 //                      return 0L;\r
 204 //              }\r
 205 //      }\r
 206 //\r
 207 //      /**\r
 208 //       * IntegerStringifier\r
 209 //       * \r
 210 //       * Support the Native Integer.. use Integer parse functions\r
 211 //       * \r
 212 //       * @author Jonathan\r
 213 //       *\r
 214 //       */\r
 215 //      public static class IntegerStringifier extends NullLifeCycle implements Stringifier<Integer> {\r
 216 //              /* (non-Javadoc)\r
 217 //               * @see com.att.env.Stringifier#stringify(com.att.env.Env, java.lang.Object)\r
 218 //               */\r
 219 //              public String stringify(Env env, Integer input) throws APIException {\r
 220 //                      return input.toString();\r
 221 //              }\r
 222 //      }\r
 223 //      \r
 224 //      /**\r
 225 //       * IntegerObjectifier\r
 226 //       * \r
 227 //       * Support the Native Integer.. use Integer parse functions\r
 228 //       * \r
 229 //       * @author Jonathan\r
 230 //       *\r
 231 //       */\r
 232 //      public static class IntegerObjectifier extends NullLifeCycle implements Objectifier<Integer> {\r
 233 //              /* (non-Javadoc)\r
 234 //               * @see com.att.env.Objectifier#objectify(com.att.env.Env, java.lang.String)\r
 235 //               */\r
 236 //              public Integer objectify(Env env, String input) throws APIException {\r
 237 //                      try {\r
 238 //                              return new Integer(input);\r
 239 //                      } catch (Exception e) {\r
 240 //                              APIException ae = new APIException("Cannot create a \"Integer\" from [" + input + ']');\r
 241 //                              ae.initCause(e);\r
 242 //                              throw ae;\r
 243 //                      }\r
 244 //              }\r
 245 //\r
 246 //              /* (non-Javadoc)\r
 247 //               * @see com.att.env.Objectifier#newObject()\r
 248 //               */\r
 249 //              public Integer newInstance() throws APIException {\r
 250 //                      return 0;\r
 251 //              }\r
 252 //      }\r
 253 //\r
 254 //      /**\r
 255 //       * ShortStringifier\r
 256 //       * \r
 257 //       * Support the Native Short.. use Short parse functions\r
 258 //       * \r
 259 //       * @author Jonathan\r
 260 //       *\r
 261 //       */\r
 262 //      public static class ShortStringifier extends NullLifeCycle implements Stringifier<Short> {\r
 263 //              public String stringify(Env env, Short input) throws APIException {\r
 264 //                      return input.toString();\r
 265 //              }\r
 266 //      }\r
 267 //      \r
 268 //      /**\r
 269 //       * ShortObjectifier\r
 270 //       * \r
 271 //       * Support the Native Short.. use Short parse functions\r
 272 //       * \r
 273 //       * @author Jonathan\r
 274 //       *\r
 275 //       */\r
 276 //      public static class ShortObjectifier extends NullLifeCycle implements Objectifier<Short> {\r
 277 //              public Short objectify(Env env, String input) throws APIException {\r
 278 //                      try {\r
 279 //                              return new Short(input);\r
 280 //                      } catch (Exception e) {\r
 281 //                              APIException ae = new APIException("Cannot create a \"Short\" from [" + input + ']');\r
 282 //                              ae.initCause(e);\r
 283 //                              throw ae;\r
 284 //                      }\r
 285 //              }\r
 286 //\r
 287 //              public Short newInstance() throws APIException {\r
 288 //                      return 0;\r
 289 //              }\r
 290 //      }\r
 291 //      \r
 292 //      /**\r
 293 //       * ByteStringifier\r
 294 //       * \r
 295 //       * Support the Native Byte.. use Byte parse functions\r
 296 //       * \r
 297 //       * @author Jonathan\r
 298 //       *\r
 299 //       */\r
 300 //      public static class ByteStringifier extends NullLifeCycle implements Stringifier<Byte> {\r
 301 //              /* (non-Javadoc)\r
 302 //               * @see com.att.env.Stringifier#stringify(com.att.env.Env, java.lang.Object)\r
 303 //               */\r
 304 //              public String stringify(Env env, Byte input) throws APIException {\r
 305 //                      return input.toString();\r
 306 //              }\r
 307 //      }\r
 308 //      \r
 309 //      /**\r
 310 //       * ByteObjectifier\r
 311 //       * \r
 312 //       * Support the Native Byte.. use Byte parse functions\r
 313 //       * \r
 314 //       * @author Jonathan\r
 315 //       *\r
 316 //       */\r
 317 //      public static class ByteObjectifier extends NullLifeCycle implements Objectifier<Byte> {\r
 318 //              /* (non-Javadoc)\r
 319 //               * @see com.att.env.Objectifier#objectify(com.att.env.Env, java.lang.String)\r
 320 //               */\r
 321 //              public Byte objectify(Env env, String input) throws APIException {\r
 322 //                      try {\r
 323 //                              return new Byte(input);\r
 324 //                      } catch (Exception e) {\r
 325 //                              APIException ae = new APIException("Cannot create a \"Byte\" from [" + input + ']');\r
 326 //                              ae.initCause(e);\r
 327 //                              throw ae;\r
 328 //                      }\r
 329 //              }\r
 330 //\r
 331 //              /* (non-Javadoc)\r
 332 //               * @see com.att.env.Objectifier#newObject()\r
 333 //               */\r
 334 //              public Byte newInstance() throws APIException {\r
 335 //                      return 0;\r
 336 //              }\r
 337 //      }\r
 338 //\r
 339 //      /**\r
 340 //       * CharacterStringifier\r
 341 //       * \r
 342 //       * Support the Native Character.. use Character parse functions\r
 343 //       * \r
 344 //       * @author Jonathan\r
 345 //       *\r
 346 //       */\r
 347 //      public static class CharacterStringifier extends NullLifeCycle implements Stringifier<Character> {\r
 348 //              /* (non-Javadoc)\r
 349 //               * @see com.att.env.Stringifier#stringify(com.att.env.Env, java.lang.Object)\r
 350 //               */\r
 351 //              public String stringify(Env env, Character input) throws APIException {\r
 352 //                      return input.toString();\r
 353 //              }\r
 354 //      }\r
 355 //      \r
 356 //      /**\r
 357 //       * CharacterObjectifier\r
 358 //       * \r
 359 //       * Support the Native Character.. use Character parse functions\r
 360 //       * \r
 361 //       * @author Jonathan\r
 362 //       *\r
 363 //       */\r
 364 //      public static class CharacterObjectifier extends NullLifeCycle implements Objectifier<Character> {\r
 365 //              /* (non-Javadoc)\r
 366 //               * @see com.att.env.Objectifier#objectify(com.att.env.Env, java.lang.String)\r
 367 //               */\r
 368 //              public Character objectify(Env env, String input) throws APIException {\r
 369 //                      int length = input.length();\r
 370 //                      if(length<1 || length>1) {\r
 371 //                              throw new APIException("String [" + input + "] does not represent a single Character");\r
 372 //                      }\r
 373 //                      return input.charAt(0);\r
 374 //              }\r
 375 //\r
 376 //              /* (non-Javadoc)\r
 377 //               * @see com.att.env.Objectifier#newObject()\r
 378 //               */\r
 379 //              public Character newInstance() throws APIException {\r
 380 //                      return 0;\r
 381 //              }\r
 382 //      }\r
 383 //\r
 384 //      /**\r
 385 //       * FloatStringifier\r
 386 //       * \r
 387 //       * Support the Native Float.. use Float parse functions\r
 388 //       * \r
 389 //       * @author Jonathan\r
 390 //       *\r
 391 //       */\r
 392 //      public static class FloatStringifier extends NullLifeCycle implements Stringifier<Float> {\r
 393 //              /* (non-Javadoc)\r
 394 //               * @see com.att.env.Stringifier#stringify(com.att.env.Env, java.lang.Object)\r
 395 //               */\r
 396 //              public String stringify(Env env, Float input) throws APIException {\r
 397 //                      return input.toString();\r
 398 //              }\r
 399 //      }\r
 400 //      \r
 401 //      /**\r
 402 //       * FloatObjectifier\r
 403 //       * \r
 404 //       * Support the Native Float.. use Float parse functions\r
 405 //       * \r
 406 //       * @author Jonathan\r
 407 //       *\r
 408 //       */\r
 409 //      public static class FloatObjectifier extends NullLifeCycle implements Objectifier<Float> {\r
 410 //              /* (non-Javadoc)\r
 411 //               * @see com.att.env.Objectifier#objectify(com.att.env.Env, java.lang.String)\r
 412 //               */\r
 413 //              public Float objectify(Env env, String input) throws APIException {\r
 414 //                      try {\r
 415 //                              return new Float(input);\r
 416 //                      } catch (Exception e) {\r
 417 //                              APIException ae = new APIException("Cannot create a \"Float\" from [" + input + ']');\r
 418 //                              ae.initCause(e);\r
 419 //                              throw ae;\r
 420 //                      }\r
 421 //              }\r
 422 //\r
 423 //              /* (non-Javadoc)\r
 424 //               * @see com.att.env.Objectifier#newObject()\r
 425 //               */\r
 426 //              public Float newInstance() throws APIException {\r
 427 //                      return 0.0f;\r
 428 //              }\r
 429 //      }\r
 430 //\r
 431 //      /**\r
 432 //       * DoubleStringifier\r
 433 //       * \r
 434 //       * Support the Native Double.. use Double parse functions\r
 435 //       * \r
 436 //       * @author Jonathan\r
 437 //       *\r
 438 //       */\r
 439 //      public static class DoubleStringifier extends NullLifeCycle implements Stringifier<Double> {\r
 440 //              /* (non-Javadoc)\r
 441 //               * @see com.att.env.Stringifier#stringify(com.att.env.Env, java.lang.Object)\r
 442 //               */\r
 443 //              public String stringify(Env env, Double input) throws APIException {\r
 444 //                      return input.toString();\r
 445 //              }\r
 446 //      }\r
 447 //      \r
 448 //      /**\r
 449 //       * DoubleObjectifier\r
 450 //       * \r
 451 //       * Support the Native Double.. use Double parse functions\r
 452 //       * \r
 453 //       * @author Jonathan\r
 454 //       *\r
 455 //       */\r
 456 //      public static class DoubleObjectifier extends NullLifeCycle implements Objectifier<Double> {\r
 457 //              /* (non-Javadoc)\r
 458 //               * @see com.att.env.Objectifier#objectify(com.att.env.Env, java.lang.String)\r
 459 //               */\r
 460 //              public Double objectify(Env env, String input) throws APIException {\r
 461 //                      try {\r
 462 //                              return new Double(input);\r
 463 //                      } catch (Exception e) {\r
 464 //                              APIException ae = new APIException("Cannot create a \"Double\" from [" + input + ']');\r
 465 //                              ae.initCause(e);\r
 466 //                              throw ae;\r
 467 //                      }\r
 468 //              }\r
 469 //\r
 470 //              /* (non-Javadoc)\r
 471 //               * @see com.att.env.Objectifier#newObject()\r
 472 //               */\r
 473 //              public Double newInstance() throws APIException {\r
 474 //                      return 0.0;\r
 475 //              }\r
 476 //      }\r
 477 \r
 478 }\r