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 }