misc/rosetta/src/main/java/org/onap/aaf/misc/rosetta/JaxInfo.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;
  23
  24 import java.lang.reflect.Field;
  25 import java.lang.reflect.Type;
  26 import java.util.ArrayList;
  27 import java.util.HashMap;
  28 import java.util.List;
  29 import java.util.Map;
  30
  31 import javax.xml.bind.annotation.XmlElement;
  32 import javax.xml.bind.annotation.XmlRootElement;
  33 import javax.xml.bind.annotation.XmlSchema;
  34 import javax.xml.bind.annotation.XmlType;
  35 import javax.xml.datatype.XMLGregorianCalendar;
  36
  37 public class JaxInfo {
  38     private static final String DEFAULT = "##default";
  39     public static final int DATA = 0;
  40     public static final int ARRAY = 1;
  41     public static final int OBJECT = 2;
  42
  43     public final String name;
  44     public final Class<?> clss;
  45     public Map<String, JaxInfo> extensions; // Classes, which might be found at runtime, that extend this class.  Lazy Instantiation
  46     public final JaxInfo[] members;
  47     public final boolean isArray;
  48     public final boolean isString;
  49     public final boolean required;
  50     public final boolean nillable;
  51     public String ns;
  52     public boolean isObject() {return members!=null;}
  53
  54     private JaxInfo(String n, String ns, Class<?> c, JaxInfo[] members, boolean string, boolean array, boolean required, boolean nillable) {
  55         name = n;
  56         this.ns = ns;
  57         clss = c;
  58         this.members = members;
  59         this.isString = string;
  60         isArray = array;
  61         this.required = required;
  62         this.nillable = nillable;
  63         extensions = null;
  64     }
  65
  66
  67     public int getType() {
  68         if (isArray)return ARRAY;
  69         else if (members!=null)return OBJECT;
  70         return DATA;
  71     }
  72
  73     public JaxInfo getDerived(String derivedName) {
  74         JaxInfo derived;
  75         // Lazy Instantiation
  76         if (extensions == null) {
  77             extensions = new HashMap<>();
  78             derived = null;
  79         } else {
  80             derived = extensions.get(derivedName);
  81         }
  82
  83         if (derived == null) {
  84             //TODO for the moment, Classes are in same package
  85             Package pkg = clss.getPackage();
  86             try {
  87                 Class<?> dc = getClass().getClassLoader().loadClass(pkg.getName()+'.'+Character.toUpperCase(derivedName.charAt(0))+derivedName.substring(1));
  88                 derived = JaxInfo.build(dc, this); // Use this JAXInfo's name so the tags are correct
  89                 extensions.put(derivedName, derived);
  90             } catch (Exception e) {
  91                 e.printStackTrace();
  92             }
  93         }
  94         return derived;
  95     }
  96
  97     public static JaxInfo get(JaxInfo[] fields, String name) {
  98         for (JaxInfo f : fields) {
  99             if (name.equals(f.name)) return f;
 100         }
 101         return null;
 102     }
 103
 104     /**
 105      * Build up JAXB Information (recursively)
 106      *
 107      * @param cls
 108      * @param rootNns
 109      * @return
 110      * @throws SecurityException
 111      * @throws NoSuchFieldException
 112      * @throws ClassNotFoundException
 113      * @throws ParseException
 114      */
 115     public static JaxInfo build(Class<?> cls, JaxInfo parent) throws NoSuchFieldException, ClassNotFoundException, ParseException {
 116         return new JaxInfo(parent.name,parent.ns, cls,buildFields(cls,parent.ns),parent.isString, parent.isArray,parent.required,parent.nillable);
 117     }
 118     /**
 119      * Build up JAXB Information (recursively)
 120      *
 121      * @param cls
 122      * @param rootNns
 123      * @return
 124      * @throws SecurityException
 125      * @throws NoSuchFieldException
 126      * @throws ClassNotFoundException
 127      * @throws ParseException
 128      */
 129     public static JaxInfo build(Class<?> cls, String ... rootNns) throws SecurityException, NoSuchFieldException, ClassNotFoundException, ParseException {
 130         String defaultNS;
 131         if (rootNns.length>0 && rootNns[0]!=null) {
 132             defaultNS = rootNns[0];
 133         } else {
 134             Package pkg = cls.getPackage();
 135             XmlSchema xs = pkg.getAnnotation(XmlSchema.class);
 136             defaultNS = xs==null?"":xs.namespace();
 137         }
 138         String name;
 139         if (rootNns.length>1) {
 140             name = rootNns[1];
 141         } else {
 142             XmlRootElement xre = cls.getAnnotation(XmlRootElement.class);
 143             if (xre!=null) {
 144                 name = xre.name();
 145             } else {
 146                 XmlType xt = cls.getAnnotation(XmlType.class);
 147                 if (xt!=null) {
 148                     name=xt.name();
 149                 } else {
 150                     throw new ParseException("Need a JAXB Object with XmlRootElement, or stipulate in parms");
 151                 }
 152             }
 153         }
 154
 155         return new JaxInfo(name,defaultNS, cls,buildFields(cls,defaultNS),false,false,false,false);
 156     }
 157
 158     // Build up the name and members of this particular class
 159     // This is recursive, if a member is a JAXB Object as well.
 160     private static JaxInfo[] buildFields(Class<?> clazz, String defaultNS) throws SecurityException, NoSuchFieldException, ClassNotFoundException {
 161         ArrayList<JaxInfo> fields = null; // allow for lazy instantiation, because many structures won't have XmlType
 162         Class<?> cls = clazz;
 163         // Build up Method names from JAXB Annotations
 164         XmlType xt;
 165         while ((xt = cls.getAnnotation(XmlType.class))!=null) {
 166             if (fields==null)fields = new ArrayList<>();
 167             for (String field : xt.propOrder()) {
 168                 if ("".equals(field)) break; // odd bug.  "" returned when no fields exist, rather than empty array
 169                 Field rf = cls.getDeclaredField(field);
 170                 Class<?> ft = rf.getType();
 171
 172                 boolean required = false;
 173                 boolean nillable = false;
 174                 String xmlName = field;
 175                 String namespace = defaultNS;
 176
 177                 XmlElement xe = rf.getAnnotation(XmlElement.class);
 178                 if (xe!=null) {
 179                     xmlName=xe.name();
 180                     required = xe.required();
 181                     nillable = false;
 182                     if (DEFAULT.equals(xmlName)) {
 183                         xmlName = field;
 184                     }
 185                     namespace = xe.namespace();
 186                     if (DEFAULT.equals(namespace)) {
 187                         namespace = defaultNS;
 188                     }
 189                 }
 190                 // If object is a List, then it is possible multiple, per XML/JAXB evaluation
 191                 if (ft.isAssignableFrom(List.class)) {
 192                     Type t = rf.getGenericType();
 193                     String classname = t.toString();
 194                     int start = classname.indexOf('<');
 195                     int end = classname.indexOf('>');
 196                     Class<?> genClass = Class.forName(classname.substring(start+1, end));
 197                     xe = genClass.getAnnotation(XmlElement.class);
 198                     if (xe!=null && !DEFAULT.equals(xe.namespace())) {
 199                         namespace = xe.namespace();
 200                     }
 201                     // add recursed recursed member, marked as array
 202                     fields.add(new JaxInfo(xmlName,namespace,genClass,buildFields(genClass,namespace), genClass.equals(String.class),true,required,nillable));
 203                 } else {
 204                     boolean isString = ft.equals(String.class) || ft.equals(XMLGregorianCalendar.class);
 205                     // add recursed member
 206                     fields.add(new JaxInfo(xmlName,namespace,ft,buildFields(ft,namespace),isString,false,required,nillable));
 207                 }
 208             }
 209             cls = cls.getSuperclass();
 210         };
 211         if (fields!=null) {
 212             JaxInfo[] rv = new JaxInfo[fields.size()];
 213             fields.toArray(rv);
 214             return rv;
 215         } else {
 216             return null;
 217         }
 218     }
 219
 220
 221     public StringBuilder dump(StringBuilder sb, int idx) {
 222         for (int i=0;i<idx;++i)sb.append(' ');
 223         sb.append("Field ");
 224         sb.append(name);
 225         sb.append(" [");
 226         sb.append(clss.getName());
 227         sb.append("] ");
 228         if (isArray)sb.append(" (array)");
 229         if (required)sb.append(" (required)");
 230         if (nillable)sb.append(" (nillable)");
 231         if (members!=null) {
 232             for (JaxInfo f : members) {
 233                 sb.append('\n');
 234                 f.dump(sb,idx+2);
 235             }
 236         }
 237         return sb;
 238     }
 239
 240     public String toString() {
 241         StringBuilder sb = new StringBuilder();
 242         sb.append("Structure of ");
 243         sb.append(clss.getName());
 244         sb.append('\n');
 245         dump(sb,2);
 246         return sb.toString();
 247     }
 248 }