misc/rosetta/src/main/java/org/onap/aaf/misc/rosetta/env/RosettaDF.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.OutputStream;
  26 import java.io.OutputStreamWriter;
  27 import java.io.Reader;
  28 import java.io.StringReader;
  29 import java.io.StringWriter;
  30 import java.io.Writer;
  31
  32 import javax.xml.bind.JAXBException;
  33 import javax.xml.namespace.QName;
  34 import javax.xml.validation.Schema;
  35
  36 import org.onap.aaf.misc.env.APIException;
  37 import org.onap.aaf.misc.env.BaseDataFactory;
  38 import org.onap.aaf.misc.env.Data;
  39 import org.onap.aaf.misc.env.DataFactory;
  40 import org.onap.aaf.misc.env.Env;
  41 import org.onap.aaf.misc.env.TimeTaken;
  42 import org.onap.aaf.misc.env.Trans;
  43 import org.onap.aaf.misc.env.Data.TYPE;
  44 import org.onap.aaf.misc.env.jaxb.JAXBmar;
  45 import org.onap.aaf.misc.env.jaxb.JAXBumar;
  46 import org.onap.aaf.misc.rosetta.InJson;
  47 import org.onap.aaf.misc.rosetta.InXML;
  48 import org.onap.aaf.misc.rosetta.JaxInfo;
  49 import org.onap.aaf.misc.rosetta.Marshal;
  50 import org.onap.aaf.misc.rosetta.Out;
  51 import org.onap.aaf.misc.rosetta.OutJson;
  52 import org.onap.aaf.misc.rosetta.OutRaw;
  53 import org.onap.aaf.misc.rosetta.OutXML;
  54 import org.onap.aaf.misc.rosetta.Parse;
  55 import org.onap.aaf.misc.rosetta.ParseException;
  56 import org.onap.aaf.misc.rosetta.marshal.DocMarshal;
  57
  58 public class RosettaDF<T> extends BaseDataFactory implements DataFactory<T>  {
  59
  60     static InJson inJSON = new InJson();
  61     InXML  inXML;
  62
  63     static OutJson outJSON = new OutJson();
  64     OutXML outXML;
  65     static OutRaw outRAW = new OutRaw();
  66
  67     // Temporary until we write JAXB impl...
  68     JAXBmar jaxMar;
  69     JAXBumar jaxUmar;
  70
  71     private Parse<Reader,?> defaultIn;
  72     private Out defaultOut;
  73     private RosettaEnv env;
  74     private TYPE inType;
  75     private TYPE outType;
  76     private int defOption;
  77     Marshal<T> marshal = null;
  78
  79
  80     /**
  81      * Private constructor to setup Type specific data manipulators
  82      * @param schema
  83      * @param rootNs
  84      * @param cls
  85      * @throws SecurityException
  86      * @throws NoSuchFieldException
  87      * @throws ClassNotFoundException
  88      * @throws ParseException
  89      * @throws JAXBException
  90      */
  91     // package on purpose
  92     RosettaDF(RosettaEnv env, Schema schema, String rootNs, Class<T> cls) throws APIException {
  93         this.env = env;
  94         try {
  95         // Note: rootNs can be null, in order to derive content from Class.
  96         JaxInfo ji = rootNs==null?JaxInfo.build(cls):JaxInfo.build(cls,rootNs);
  97         // Note: JAXBmar sets qname to null if not exists
  98         jaxMar = new JAXBmar(rootNs==null?null:new QName("xmlns",rootNs),cls);
  99         // Note: JAXBumar sets schema to null if not exists
 100         jaxUmar = new JAXBumar(schema, cls);
 101
 102         defaultIn = inXML = new InXML(ji);
 103         defaultOut = outXML = new OutXML(ji);
 104         inType=outType=Data.TYPE.XML;
 105         defOption = 0;
 106         } catch (Exception e) {
 107             throw new APIException(e);
 108         }
 109     }
 110
 111
 112     // @Override
 113     public RosettaData<T> newData() {
 114         RosettaData<T> data = new RosettaData<T>(env, this)
 115             .in(inType)
 116             .out(outType)
 117             .option(defOption);
 118         return data;
 119     }
 120
 121     // @Override
 122     public RosettaData<T> newData(Env trans) {
 123         RosettaData<T> data = new RosettaData<T>(trans, this)
 124             .in(inType)
 125             .out(outType)
 126             .option(defOption);
 127         return data;
 128     }
 129
 130     @SuppressWarnings("unchecked")
 131     // @Override
 132     public Class<T> getTypeClass() {
 133         return (Class<T>)jaxMar.getMarshalClass();
 134     }
 135
 136     public RosettaDF<T> in(Data.TYPE type) {
 137         inType = type;
 138         defaultIn=getIn(type==Data.TYPE.DEFAULT?Data.TYPE.JSON:type);
 139         return this;
 140     }
 141
 142     /**
 143      * If exists, first option is "Pretty", second is "Fragment"
 144      *
 145      * @param options
 146      * @return
 147      */
 148     public RosettaDF<T> out(Data.TYPE type) {
 149         outType = type;
 150         defaultOut = getOut(type==Data.TYPE.DEFAULT?Data.TYPE.JSON:type);
 151         return this;
 152     }
 153
 154     public Parse<Reader,?> getIn(Data.TYPE type) {
 155         switch(type) {
 156             case DEFAULT:
 157                 return defaultIn;
 158             case JSON:
 159                 return inJSON;
 160             case XML:
 161                 return inXML;
 162             default:
 163                 return defaultIn;
 164         }
 165     }
 166
 167     public Out getOut(Data.TYPE type) {
 168         switch(type) {
 169             case DEFAULT:
 170                 return defaultOut;
 171             case JSON:
 172                 return outJSON;
 173             case XML:
 174                 return outXML;
 175             case RAW:
 176                 return outRAW;
 177             default:
 178                 return defaultOut;
 179         }
 180     }
 181
 182     public int logType(org.onap.aaf.misc.env.Data.TYPE ot) {
 183         switch(ot) {
 184             case JSON:
 185                 return Env.JSON;
 186             default:
 187                 return Env.XML;
 188         }
 189     }
 190
 191
 192     public RosettaEnv getEnv() {
 193         return env;
 194     }
 195
 196
 197     public Data.TYPE getInType() {
 198         return inType;
 199     }
 200
 201     public Data.TYPE getOutType() {
 202         return outType;
 203     }
 204
 205     public RosettaDF<T> option(int option) {
 206         defOption = option;
 207
 208         return this;
 209     }
 210
 211     /**
 212      * Assigning Root Marshal Object
 213      *
 214      * Will wrap with DocMarshal Object if not already
 215      *
 216      * @param marshal
 217      * @return
 218      */
 219     public RosettaDF<T> rootMarshal(Marshal<T> marshal) {
 220         if (marshal instanceof DocMarshal) {
 221             this.marshal = marshal;
 222         } else {
 223             this.marshal = DocMarshal.root(marshal);
 224         }
 225         return this;
 226     }
 227
 228     public void direct(Trans trans, T t, OutputStream os, boolean ... options) throws APIException, IOException {
 229         Out out = getOut(outType);
 230         TimeTaken tt = trans.start(out.logName(),logType(outType)); // determine from Out.. without dependency on Env?
 231         try {
 232             if (marshal==null) { // Unknown marshaller... do working XML marshal/extraction
 233                 StringWriter sw = new StringWriter();
 234                 jaxMar.marshal(trans.debug(), t, sw, options);
 235                 out.extract(new StringReader(sw.toString()), new OutputStreamWriter(os), inXML,options);
 236             } else {
 237                 out.extract(t, new OutputStreamWriter(os), marshal,options);
 238             }
 239         } catch (Exception e) {
 240             throw new APIException(e);
 241         } finally {
 242             tt.done();
 243         }
 244     }
 245
 246     public void direct(Trans trans, T t, Writer writer, boolean ... options) throws APIException, IOException {
 247         Out out = getOut(outType);
 248         TimeTaken tt = trans.start(out.logName(),logType(outType)); // determine from Out.. without dependency on Env?
 249         try {
 250             if (marshal==null) { // Unknown marshaller... do working XML marshal/extraction
 251                 StringWriter sw = new StringWriter();
 252                 jaxMar.marshal(trans.debug(), t, sw, options);
 253                 out.extract(new StringReader(sw.toString()), writer, inXML,options);
 254             } else {
 255                 out.extract(t, writer, marshal,options);
 256             }
 257         } catch (Exception e) {
 258             throw new APIException(e);
 259         } finally {
 260             tt.done();
 261         }
 262     }
 263
 264
 265 }