misc/rosetta/src/main/java/org/onap/aaf/misc/rosetta/env/RosettaData.java

   1 /**
   2  * ============LICENSE_START====================================================
   3  * org.onap.aaf
   4  * ===========================================================================
   5  * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.
   6  * ===========================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END====================================================
  19  *
  20  */
  21
  22 package org.onap.aaf.misc.rosetta.env;
  23
  24 import java.io.IOException;
  25 import java.io.InputStream;
  26 import java.io.InputStreamReader;
  27 import java.io.OutputStream;
  28 import java.io.OutputStreamWriter;
  29 import java.io.Reader;
  30 import java.io.StringReader;
  31 import java.io.StringWriter;
  32 import java.io.Writer;
  33
  34 import org.onap.aaf.misc.env.APIException;
  35 import org.onap.aaf.misc.env.Data;
  36 import org.onap.aaf.misc.env.Env;
  37 import org.onap.aaf.misc.env.TimeTaken;
  38 import org.onap.aaf.misc.rosetta.Out;
  39 import org.onap.aaf.misc.rosetta.Parse;
  40 import org.onap.aaf.misc.rosetta.Saved;
  41
  42 public class RosettaData<T> implements Data<T>{
  43         private Env trans;
  44         private RosettaDF<T> df;
  45         private Saved saved;
  46         private TYPE inType, outType;
  47         // Note: This is an array of boolean in order to pass into other methods
  48         private boolean options[] = new boolean[] {false, false};
  49         // Temp Storage of XML.  Only when we must use JAXB to read in Objects
  50         private String xml,json;
  51
  52         // package on purpose
  53         RosettaData(Env env, RosettaDF<T> rosettaDF) {
  54                 df = rosettaDF;
  55                 saved = new Saved(); // Note: Saved constructs storage as needed...
  56                 trans = env;
  57                 inType = df.getInType();
  58                 outType = df.getOutType(); // take defaults
  59         }
  60
  61 //      // @Override
  62         public RosettaData<T> in(TYPE rosettaType) {
  63                 inType = rosettaType;
  64                 return this;
  65         }
  66
  67 //      // @Override
  68         public RosettaData<T> out(TYPE rosettaType) {
  69                 outType = rosettaType;
  70                 return this;
  71         }
  72
  73 //      // @Override
  74         public RosettaData<T> load(Reader rdr) throws APIException {
  75                 Parse<Reader,?> in = df.getIn(inType);
  76                 TimeTaken tt = in.start(trans);
  77                 try {
  78                         saved.extract(rdr, (Writer)null, in);
  79                         xml=json=null;
  80                 } catch (Exception e) {
  81                         throw new APIException(e);
  82                 } finally {
  83                         tt.done();
  84                 }
  85                 return this;
  86         }
  87
  88         // @Override
  89         public RosettaData<T> load(InputStream is) throws APIException {
  90                 Parse<Reader,?> in = df.getIn(inType);
  91                 TimeTaken tt = in.start(trans);
  92                 try {
  93                         saved.extract(new InputStreamReader(is), (Writer)null, in);
  94                         xml=json=null;
  95                 } catch (Exception e) {
  96                         throw new APIException(e);
  97                 } finally {
  98                         tt.done();
  99                 }
 100                 return this;
 101         }
 102
 103         // @Override
 104         public RosettaData<T> load(String str) throws APIException {
 105                 Parse<Reader,?> in = df.getIn(inType);
 106                 TimeTaken tt = in.start(trans);
 107                 try {
 108                         saved.extract(new StringReader(str), (Writer)null, in);
 109                         switch(inType) {
 110                                 case XML:
 111                                         xml = str;
 112                                         break;
 113                                 case JSON:
 114                                         json = str;
 115                                         break;
 116                                 default:
 117
 118                                 }
 119                 } catch (Exception e) {
 120                         throw new APIException(e);
 121                 } finally {
 122                         tt.done();
 123                 }
 124                 return this;
 125         }
 126
 127         // @Override
 128         public RosettaData<T> load(T t) throws APIException {
 129                 Parse<?,?> in = df.getIn(inType);
 130                 TimeTaken tt = in.start(trans);
 131                 try {
 132                         if(df.marshal==null) { // Unknown marshaller... do working XML marshal/extraction
 133                                 StringWriter sw = new StringWriter();
 134                                 df.jaxMar.marshal(trans.debug(), t, sw, options);
 135                                 saved.extract(new StringReader(xml = sw.toString()), (Writer)null, df.inXML);
 136                         } else {
 137                                 saved.extract(t, (Writer)null, df.marshal);
 138                         }
 139                 } catch (Exception e) {
 140                         throw new APIException(e);
 141                 } finally {
 142                         tt.done();
 143                 }
 144                 return this;
 145         }
 146
 147         public Saved getEvents() {
 148                 return saved;
 149         }
 150
 151         // @Override
 152         public T asObject() throws APIException {
 153                 Out out = df.getOut(TYPE.XML);
 154                 TimeTaken tt = trans.start(out.logName(),df.logType(outType)); // determine from Out.. without dependency on Env?
 155                 try {
 156                         //TODO Replace JAXB with Direct Object method!!!
 157                         StringWriter sw = new StringWriter();
 158                         out.extract(null, sw, saved);
 159                         return df.jaxUmar.unmarshal(trans.debug(), sw.toString());
 160                 } catch (Exception e) {
 161                         throw new APIException(e);
 162                 } finally {
 163                         tt.done();
 164                 }
 165         }
 166
 167         // @Override
 168         public String asString() throws APIException {
 169                 Out out = df.getOut(outType);
 170                 TimeTaken tt = trans.start(out.logName(),df.logType(outType)); // determine from Out.. without dependency on Env?
 171                 try {
 172                         if(outType==TYPE.XML) {
 173                                 if(xml==null) {
 174                                         StringWriter sw = new StringWriter();
 175                                         out.extract(null, sw, saved, options);
 176                                         xml = sw.toString();
 177                                 }
 178                                 return xml;
 179                         } else {  // is JSON
 180                                 if(json==null) {
 181                                         StringWriter sw = new StringWriter();
 182                                         out.extract(null, sw, saved, options);
 183                                         json = sw.toString();
 184                                 }
 185                                 return json;
 186                         }
 187                 } catch (Exception e) {
 188                         throw new APIException(e);
 189                 } finally {
 190                         tt.done();
 191                 }
 192         }
 193
 194
 195         // @Override
 196         public RosettaData<T> to(OutputStream os) throws APIException, IOException {
 197                 Out out = df.getOut(outType);
 198                 TimeTaken tt = trans.start(out.logName(),df.logType(outType)); // determine from Out.. without dependency on Env?
 199                 try {
 200                         if(outType==TYPE.XML && xml!=null) {
 201                                 os.write(xml.getBytes());
 202                         } else if(outType==TYPE.JSON && json!=null) {
 203                                 os.write(json.getBytes());
 204                         } else {
 205                                 out.extract(null, os, saved, options);
 206                         }
 207                 } catch (Exception e) {
 208                         throw new APIException(e);
 209                 } finally {
 210                         tt.done();
 211                 }
 212                 return this;
 213         }
 214
 215         // @Override
 216         public RosettaData<T> to(Writer writer) throws APIException, IOException {
 217                 Out out = df.getOut(outType);
 218                 TimeTaken tt = trans.start(out.logName(),df.logType(outType)); // determine from Out.. without dependency on Env?
 219                 try {
 220                         if(outType==TYPE.XML && xml!=null) {
 221                                 writer.append(xml);
 222                         } else if(outType==TYPE.JSON && json!=null) {
 223                                 writer.append(json);
 224                         } else {
 225                                 out.extract(null, writer, saved, options);
 226                         }
 227                 } catch (Exception e) {
 228                         throw new APIException(e);
 229                 } finally {
 230                         tt.done();
 231                 }
 232                 return this;
 233         }
 234
 235         // @Override
 236         public Class<T> getTypeClass() {
 237                 return df.getTypeClass();
 238         }
 239
 240         private static final boolean[] emptyOption = new boolean[0];
 241
 242         public void direct(InputStream is, OutputStream os) throws APIException, IOException {
 243                 direct(is,os,emptyOption);
 244         }
 245
 246         public void direct(Reader reader, Writer writer, boolean ... options) throws APIException, IOException {
 247                 Parse<Reader,?> in = df.getIn(inType);
 248                 Out out = df.getOut(outType);
 249                 TimeTaken tt = trans.start(out.logName(),df.logType(outType)); // determine from Out.. without dependency on Env?
 250                 try {
 251                         out.extract(reader, writer, in,options);
 252                 } catch (Exception e) {
 253                         throw new APIException(e);
 254                 } finally {
 255                         tt.done();
 256                 }
 257         }
 258
 259         public void direct(T t, Writer writer, boolean ... options) throws APIException, IOException {
 260                 Out out = df.getOut(outType);
 261                 TimeTaken tt = trans.start(out.logName(),df.logType(outType)); // determine from Out.. without dependency on Env?
 262                 try {
 263                         if(df.marshal==null) { // Unknown marshaller... do working XML marshal/extraction
 264                                 StringWriter sw = new StringWriter();
 265                                 df.jaxMar.marshal(trans.debug(), t, sw, options);
 266                                 out.extract(new StringReader(xml = sw.toString()), writer, df.inXML,options);
 267                         } else {
 268                                 out.extract(t, writer, df.marshal,options);
 269                         }
 270                 } catch (Exception e) {
 271                         throw new APIException(e);
 272                 } finally {
 273                         tt.done();
 274                 }
 275         }
 276
 277         public void direct(T t, OutputStream os, boolean ... options) throws APIException, IOException {
 278                 Out out = df.getOut(outType);
 279                 TimeTaken tt = trans.start(out.logName(),df.logType(outType)); // determine from Out.. without dependency on Env?
 280                 try {
 281                         if(df.marshal==null) { // Unknown marshaller... do working XML marshal/extraction
 282                                 if(outType.equals(TYPE.XML)) {
 283                                         df.jaxMar.marshal(trans.debug(), t, os, options);
 284                                 } else {
 285                                         StringWriter sw = new StringWriter();
 286                                         df.jaxMar.marshal(trans.debug(), t, sw, options);
 287                                         out.extract(new StringReader(xml = sw.toString()), new OutputStreamWriter(os), df.inXML,options);
 288                                 }
 289                         } else {
 290                                 out.extract(t, new OutputStreamWriter(os), df.marshal,options);
 291                         }
 292
 293                 } catch (Exception e) {
 294                         throw new APIException(e);
 295                 } finally {
 296                         tt.done();
 297                 }
 298         }
 299
 300
 301         public void direct(InputStream is, OutputStream os, boolean ... options) throws APIException, IOException {
 302                 direct(new InputStreamReader(is),new OutputStreamWriter(os), options);
 303         }
 304
 305         // // @Override
 306         public RosettaData<T> option(int option) {
 307                 options[0] = (option&Data.PRETTY)==Data.PRETTY;
 308                 options[1] = (option&Data.FRAGMENT)==Data.FRAGMENT;
 309                 return this;
 310         }
 311
 312 }