misc/env/src/main/java/org/onap/aaf/misc/env/jaxb/JAXBData.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.jaxb;\r
  23 \r
  24 import java.io.ByteArrayInputStream;\r
  25 import java.io.IOException;\r
  26 import java.io.InputStream;\r
  27 import java.io.OutputStream;\r
  28 import java.io.Reader;\r
  29 import java.io.Writer;\r
  30 \r
  31 import javax.xml.bind.JAXBException;\r
  32 \r
  33 import org.onap.aaf.misc.env.APIException;\r
  34 import org.onap.aaf.misc.env.Data;\r
  35 import org.onap.aaf.misc.env.Env;\r
  36 import org.onap.aaf.misc.env.EnvJAXB;\r
  37 import org.onap.aaf.misc.env.old.IOStringifier;\r
  38 import org.onap.aaf.misc.env.old.Objectifier;\r
  39 import org.onap.aaf.misc.env.old.Stringifier;\r
  40 /**\r
  41  * <H1>Data</H1>\r
  42  * <i>Data</i> facilitates lazy marshaling of data with a pre-determined\r
  43  * marshaling mechanism.<p>\r
  44  * \r
  45  * It stores either Object (defined by Generic {@literal <T>}) or String.<p>  \r
  46  * \r
  47  * On asking for Object of type {@literal <T>}, it will respond with the object\r
  48  * if it exists, or unmarshal the string and pass the result back.<p>\r
  49  * \r
  50  * On asking for String, it will respond with the String\r
  51  * if it exists, or marshal the String and pass the result back.<p>\r
  52  * \r
  53  * @author Jonathan\r
  54  *\r
  55  * @param <T>\r
  56  */\r
  57 public final class JAXBData<T> implements Data<T>{\r
  58         private Stringifier<T> stringifier;\r
  59         private Objectifier<T> objectifier;\r
  60         private String dataAsString;\r
  61         private T dataAsObject;\r
  62         private Class<T> tclass;\r
  63         private JAXBDF<T> df;\r
  64         private Env creatingEnv;\r
  65         private boolean options[] = new boolean[] {false, false};\r
  66         \r
  67         /**\r
  68          * Construct a Data Object with an appropriate Stringifier, Objectifier and Class to support\r
  69          * \r
  70          * @param env\r
  71          * @param strfr\r
  72          * @param objfr\r
  73          * @param text\r
  74          * @param typeClass\r
  75          */\r
  76         JAXBData(Env env, JAXBDF<T> df, Stringifier<T> strfr, Objectifier<T> objfr, String text, Class<T> typeClass) {\r
  77                 dataAsString = text;\r
  78                 dataAsObject = null;\r
  79                 stringifier = strfr;\r
  80                 objectifier = objfr;\r
  81                 tclass = typeClass;\r
  82                 creatingEnv = env;\r
  83                 this.df = df;\r
  84         }\r
  85         \r
  86         \r
  87         /**\r
  88          * Construct a Data Object with an appropriate Stringifier, Objectifier and Object (which will\r
  89          * yield it's class)\r
  90          * \r
  91          * @param env\r
  92          * @param strfr\r
  93          * @param objfr\r
  94          * @param object\r
  95          */\r
  96         @SuppressWarnings("unchecked")\r
  97         JAXBData(Env env, JAXBDF<T> df, Stringifier<T> strfr, Objectifier<T> objfr, T object) {\r
  98                 dataAsString = null;\r
  99                 dataAsObject = object;\r
 100                 stringifier = strfr;\r
 101                 objectifier = objfr;\r
 102                 tclass = (Class<T>) object.getClass();\r
 103                 creatingEnv = env;\r
 104                 this.df = df;\r
 105         }\r
 106 \r
 107         /**\r
 108          * Respond with the String if it exists, or marshal the String and pass the result back.<p>\r
 109          * \r
 110          * Explicitly use a specific Env for logging purposes\r
 111          * \r
 112          * @param env\r
 113          * @return String\r
 114          * @throws APIException\r
 115          */\r
 116         public String asString(EnvJAXB env) throws APIException {\r
 117                 if(dataAsString!=null) {\r
 118                         return dataAsString;\r
 119                 } else {\r
 120                         return dataAsString = stringifier.stringify(env, dataAsObject);\r
 121                 }\r
 122         }\r
 123 \r
 124         /**\r
 125          * Respond with the String if it exists, or marshal the String and pass the result back.\r
 126          * \r
 127          * However, use the Env the Data Object was created with.\r
 128          * \r
 129          * @return String\r
 130          * @throws APIException\r
 131          */\r
 132         // @Override\r
 133         public String asString() throws APIException {\r
 134                 if(dataAsString!=null) {\r
 135                         return dataAsString;\r
 136                 } else {\r
 137                         return dataAsString = stringifier.stringify(creatingEnv, dataAsObject,options);\r
 138                 }\r
 139         }\r
 140         \r
 141         public Data<T> to(OutputStream os) throws APIException, IOException {\r
 142                 if(dataAsString!=null) {\r
 143                         os.write(dataAsString.getBytes());\r
 144                 } else if (stringifier instanceof IOStringifier){\r
 145                         ((IOStringifier<T>)stringifier).stringify(creatingEnv, dataAsObject, os, options);\r
 146                 } else {\r
 147                         dataAsString = stringifier.stringify(creatingEnv, dataAsObject, options);\r
 148                         os.write(dataAsString.getBytes());\r
 149                 }\r
 150                 return this;\r
 151         }\r
 152 \r
 153 \r
 154         // @Override\r
 155         public JAXBData<T> to(Writer writer) throws APIException, IOException {\r
 156                 if(dataAsString!=null) {\r
 157                         writer.write(dataAsString);\r
 158                 } else if (stringifier instanceof IOStringifier){\r
 159                         ((IOStringifier<T>)stringifier).stringify(creatingEnv, dataAsObject, writer, options);\r
 160                 } else {\r
 161                         dataAsString = stringifier.stringify(creatingEnv, dataAsObject, options);\r
 162                         writer.write(dataAsString);\r
 163                 }\r
 164                 return this;\r
 165         }\r
 166 \r
 167 \r
 168         public InputStream getInputStream() throws APIException {\r
 169                 if(dataAsString==null) {\r
 170                         dataAsString = stringifier.stringify(creatingEnv,dataAsObject,options);\r
 171                 }\r
 172                 return new ByteArrayInputStream(dataAsString.getBytes());\r
 173         }\r
 174         \r
 175         /**\r
 176          * Respond with the Object of type {@literal <T>} if it exists, or unmarshal from String \r
 177          * and pass the result back.<p>\r
 178          * \r
 179          * Explicitly use a specific Env for logging purposes\r
 180          * \r
 181          * @param env\r
 182          * @return T\r
 183          * @throws APIException\r
 184          */\r
 185 \r
 186         public T asObject(EnvJAXB env) throws APIException {\r
 187                 if(dataAsObject !=null) {\r
 188                         return dataAsObject;\r
 189                 } else {\r
 190                         // Some Java compilers need two statements here\r
 191                         dataAsObject = objectifier.objectify(env, dataAsString);\r
 192                         return dataAsObject;\r
 193                 }\r
 194         }\r
 195 \r
 196         /**\r
 197          * Respond with the Object of type {@literal <T>} if it exists, or unmarshal from String \r
 198          * and pass the result back.<p>\r
 199          *\r
 200          * However, use the Env the Data Object was created with.\r
 201          * \r
 202          * @return T\r
 203          * @throws APIException\r
 204          */\r
 205         // @Override\r
 206         public T asObject() throws APIException {\r
 207                 if(dataAsObject !=null) {\r
 208                         return dataAsObject;\r
 209                 } else {\r
 210                         // Some Java compilers need two statements here\r
 211                         dataAsObject = objectifier.objectify(creatingEnv, dataAsString);\r
 212                         return dataAsObject;\r
 213                 }\r
 214         }\r
 215         \r
 216 \r
 217         /**\r
 218          * Return the Class Type supported by this DataObject\r
 219          * \r
 220          * @return {@literal Class<T>}\r
 221          */\r
 222         // @Override\r
 223         public Class<T> getTypeClass() {\r
 224                 return tclass;\r
 225         }\r
 226         \r
 227         \r
 228         /**\r
 229          * For Debugging Convenience, we marshal to String if possible.\r
 230          * \r
 231          * Behavior is essentially the same as asString(), except asString() throws\r
 232          * an APIException.  <p>\r
 233          * Since toString() must not throw exceptions, the function just catches and prints an\r
 234          * error, which is probably not the behavior desired.<p>\r
 235          *  \r
 236          * Therefore, use "asString()" where possible in actual Transactional code. \r
 237          * \r
 238          * @see java.lang.Object#toString()\r
 239          */\r
 240         // @Override\r
 241         public String toString() {\r
 242                 if(dataAsString!=null) {\r
 243                         return dataAsString;\r
 244                 } else {\r
 245                         try {\r
 246                                 return dataAsString = stringifier.stringify(creatingEnv, dataAsObject);\r
 247                         } catch (APIException e) {\r
 248                                 return "ERROR - Can't Stringify from Object " + e.getLocalizedMessage();\r
 249                         }\r
 250                 }\r
 251         }\r
 252 \r
 253         public Data<T> load(T t) throws APIException {\r
 254                 dataAsObject = t;\r
 255                 dataAsString = null;\r
 256                 return this;\r
 257         }\r
 258 \r
 259 \r
 260         public Data<T> load(String str) throws APIException {\r
 261                 dataAsObject = null;\r
 262                 dataAsString = str;\r
 263                 return this;\r
 264         }\r
 265 \r
 266 \r
 267         public Data<T> load(InputStream is) throws APIException {\r
 268                 try {\r
 269                         dataAsObject = df.jumar.unmarshal(creatingEnv.debug(),is);\r
 270                         dataAsString = null;\r
 271                 } catch (JAXBException e) {\r
 272                         throw new APIException(e);\r
 273                 }\r
 274                 return this;\r
 275         }\r
 276 \r
 277 \r
 278         public Data<T> load(Reader rdr) throws APIException {\r
 279                 try {\r
 280                         dataAsObject = df.jumar.unmarshal(creatingEnv.debug(),rdr);\r
 281                         dataAsString = null;\r
 282                 } catch (JAXBException e) {\r
 283                         throw new APIException(e);\r
 284                 }\r
 285                 return this;\r
 286         }\r
 287 \r
 288 \r
 289         // @Override\r
 290         public void direct(InputStream input, OutputStream output) throws APIException, IOException {\r
 291                 byte b[] = new byte[128];\r
 292                 int count;\r
 293                 do {\r
 294                         count = input.read(b);\r
 295                         if(count>0)output.write(b, 0, count);\r
 296                 } while(count>=0);\r
 297         }\r
 298 \r
 299 \r
 300         // @Override\r
 301         public Data<T> out(TYPE type) {\r
 302                 // it's going to be XML regardless...\r
 303                 return this;\r
 304         }\r
 305 \r
 306 \r
 307         // @Override\r
 308         public Data<T> in(TYPE type) {\r
 309                 // Not Supported... will still be XML\r
 310                 return this;\r
 311         }\r
 312 \r
 313 \r
 314         // @Override\r
 315         public Data<T> option(int option) {\r
 316                 options[0] = (option&Data.PRETTY)==Data.PRETTY;\r
 317                 options[1] = (option&Data.FRAGMENT)==Data.FRAGMENT;\r
 318                 return this;\r
 319         }\r
 320         \r
 321 }