misc/rosetta/src/main/java/org/onap/aaf/misc/rosetta/InXML.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.io.IOException;
  25 import java.io.Reader;
  26 import java.util.ArrayList;
  27 import java.util.HashMap;
  28 import java.util.List;
  29 import java.util.Map;
  30 import java.util.Stack;
  31
  32 import org.onap.aaf.misc.env.Env;
  33 import org.onap.aaf.misc.env.TimeTaken;
  34 import org.onap.aaf.misc.rosetta.InXML.State;
  35
  36 public class InXML implements Parse<Reader, State> {
  37         // package on purpose
  38         JaxInfo jaxInfo;
  39
  40         public InXML(JaxInfo jaxInfo) {
  41                 this.jaxInfo = jaxInfo;
  42         }
  43
  44         public InXML(Class<?> cls, String ... rootNs) throws SecurityException, NoSuchFieldException, ClassNotFoundException, ParseException {
  45                 jaxInfo = JaxInfo.build(cls,rootNs);
  46         }
  47
  48
  49         // @Override
  50         public Parsed<State> parse(Reader r, Parsed<State> parsed) throws ParseException {
  51                 State state = parsed.state;
  52
  53                 // OK, before anything else, see if there is leftover processing, if so, do it!
  54                 if(state.unevaluated!=null) {
  55                         DerTag dt = state.unevaluated;
  56                         state.unevaluated = null;
  57                         if(!state.greatExp.eval(parsed, dt))return parsed;
  58                 }
  59
  60                 if(state.hasAttributes()) {
  61                         Prop prop = state.pop();
  62                         parsed.event = Parse.ATTRIB;
  63                         parsed.name = prop.tag;
  64                         parsed.sb.append(prop.value);
  65                         parsed.isString=true;
  66                         return parsed;
  67                 }
  68                 int ch;
  69                 char c;
  70                 boolean inQuotes = false, escaped = false;
  71
  72                 StringBuilder sb = parsed.sb, tempSB = new StringBuilder();
  73                 boolean go = true;
  74
  75                 try {
  76                         while(go && (ch=r.read())>=0) {
  77                                 c = (char)ch;
  78                                 if(c == '"') {
  79                                         if(state.greatExp instanceof LeafExpectations) { // within a set of Tags, make a Quote
  80                                                 sb.append(c);
  81                                         } else {
  82                                                 if(inQuotes) {
  83                                                         if(escaped) {
  84                                                                 sb.append('\\');
  85                                                                 sb.append(c);
  86                                                                 escaped = false;
  87                                                         } else {
  88                                                                 inQuotes = false;
  89                                                         }
  90                                                 } else {
  91                                                         parsed.isString=true;
  92                                                         inQuotes = true;
  93                                                 }
  94                                         }
  95                                 } else if(inQuotes) {
  96                                         sb.append(c);
  97                                 } else if(c=='&') {
  98                                         XmlEscape.xmlEscape(sb,r);
  99                                 } else if(c=='\\') {
 100                                         escaped=true;
 101                                 } else {
 102                                         switch(c) {
 103                                                 case '<':
 104                                                         DerTag tag=new DerTag().parse(r, tempSB);
 105                                                         go = state.greatExp.eval(parsed, tag);
 106                                                         break;
 107                                                 default:
 108                                                         // don't add Whitespace to start of SB... saves removing later
 109                                                         if(sb.length()>0) {
 110                                                                 sb.append(c);
 111                                                         } else if(!Character.isWhitespace(c)) {
 112                                                                 sb.append(c);
 113                                                         }
 114                                                 }
 115                                 }
 116                         }
 117                         return parsed;
 118                 } catch (IOException e) {
 119                         throw new ParseException(e);
 120                 }
 121         }
 122
 123         public static final class DerTag {
 124                 public String name;
 125                 public boolean isEndTag;
 126                 public List<Prop> props;
 127                 private boolean isXmlInfo;
 128                 //private String ns;
 129
 130                 public DerTag() {
 131                         name=null;
 132                         isEndTag = false;
 133                         props = null;
 134                         isXmlInfo = false;
 135                 }
 136
 137                 public DerTag parse(Reader r, StringBuilder sb) throws ParseException {
 138                         int ch;
 139                         char c;
 140                         boolean inQuotes = false, escaped = false;
 141                         boolean go = true;
 142                         String tag = null;
 143
 144                         try {
 145                                 if((ch = r.read())<0) throw new ParseException("Reader content ended before complete");
 146                                 if(ch=='?') {
 147                                         isXmlInfo = true;
 148                                 }
 149                                 // TODO Check for !-- comments
 150                                 do {
 151                                         c=(char)ch;
 152                                         if(c=='"') {
 153                                                         if(inQuotes) {
 154                                                                 if(escaped) {
 155                                                                         sb.append(c);
 156                                                                         escaped = false;
 157                                                                 } else {
 158                                                                         inQuotes = false;
 159                                                                 }
 160                                                         } else {
 161                                                                 inQuotes = true;
 162                                                         }
 163                                         } else if(inQuotes) {
 164                                                 sb.append(c);
 165                                         } else {
 166                                                 switch(c) {
 167                                                         case '/':
 168                                                                 isEndTag = true;
 169                                                                 break;
 170                                                         case ' ':
 171                                                                 endField(tag,sb);
 172                                                                 tag = null;
 173                                                                 break;
 174                                                         case '>':
 175                                                                 endField(tag,sb);
 176                                                                 go = false;
 177                                                                 break;
 178                                                         case '=':
 179                                                                 tag = sb.toString();
 180                                                                 sb.setLength(0);
 181                                                                 break;
 182 //                                                      case ':':
 183 //                                                              ns = sb.toString();
 184 //                                                              sb.setLength(0);
 185 //                                                              break;
 186                                                         case '?':
 187                                                                 if(!isXmlInfo)sb.append(c);
 188                                                                 break;
 189                                                         default:
 190                                                                 sb.append(c);
 191                                                 }
 192                                         }
 193                                 } while(go && (ch=r.read())>=0);
 194                         } catch (IOException e) {
 195                                 throw new ParseException(e);
 196                         }
 197                         return this;
 198                 }
 199
 200                 private void endField(String tag, StringBuilder sb) {
 201                         if(name==null) {
 202                                 name = sb.toString();
 203                                 sb.setLength(0);
 204                         } else {
 205                                 String value = sb.toString();
 206                                 sb.setLength(0);
 207                                 if(tag !=null && value != null) {
 208                                         if(props==null)props = new ArrayList<>();
 209                                         props.add(new Prop(tag,value));
 210                                 }
 211                         }
 212                 }
 213
 214                 public String toString() {
 215                         StringBuilder sb = new StringBuilder();
 216                         sb.append(isEndTag?"End":"Start");
 217                         sb.append(" Tag\n");
 218                         sb.append("  Name: ");
 219                         sb.append(name);
 220                         if(props!=null) for(Prop p : props) {
 221                                 sb.append("\n     ");
 222                                 sb.append(p.tag);
 223                                 sb.append("=\"");
 224                                 sb.append(p.value);
 225                                 sb.append('"');
 226                         }
 227                         return sb.toString();
 228                 }
 229         }
 230
 231         private static class ArrayState {
 232                 public boolean firstObj = true;
 233                 public boolean didNext = false;
 234         }
 235
 236         public static class State {
 237                 public GreatExpectations greatExp;
 238                 public DerTag unevaluated;
 239                 public Stack<ArrayState> arrayInfo;
 240                 private List<Prop> attribs;
 241                 private int idx;
 242                 public State(JaxInfo ji, DerTag dt) throws ParseException {
 243                         greatExp = new RootExpectations(this, ji, null);
 244                         unevaluated = null;
 245                         attribs = null;;
 246                 }
 247
 248                 public boolean hasAttributes() {
 249                         return attribs!=null && idx<attribs.size();
 250                 }
 251
 252                 public void push(Prop prop) {
 253                         if(attribs==null) {
 254                                 attribs = new ArrayList<>();
 255                                 idx = 0;
 256                         }
 257                         attribs.add(prop);
 258                 }
 259
 260                 public Prop pop() {
 261                         Prop rv = null;
 262                         if(attribs!=null) {
 263                                 rv = attribs.get(idx++);
 264                                 if(idx>=attribs.size())attribs = null;
 265                         }
 266                         return rv;
 267                 }
 268         }
 269
 270         private static abstract class GreatExpectations {
 271                 protected JaxInfo ji;
 272                 protected GreatExpectations prev;
 273                 private Map<String,String> ns;
 274
 275                 public GreatExpectations(State state, JaxInfo curr, GreatExpectations prev, DerTag derTag) throws ParseException {
 276                         this.prev = prev;
 277                         ns = null;
 278                         ji = getDerived(state, curr,derTag);
 279                 }
 280
 281                 public abstract boolean eval(Parsed<State> parsed, DerTag derTag) throws ParseException;
 282
 283                 // Recursively look back for any namespaces
 284                 protected Map<String,String> getNS() {
 285                         if(ns!=null)return ns;
 286                         if(prev!=null) {
 287                                 return prev.getNS();
 288                         }
 289                         return null;
 290                 }
 291
 292                 private void addNS(Prop prop) {
 293                         Map<String,String> existingNS = getNS();
 294                         if(ns==null)ns = new HashMap<>();
 295                         // First make a copy of previous NSs so that we have everything we need, but can overwrite, if necessary
 296                         if(existingNS!=null && ns!=existingNS) {
 297                                 ns.putAll(ns);
 298                         }
 299                         ns.put(prop.tag, prop.value);
 300                 }
 301
 302                 private JaxInfo getDerived(State state, JaxInfo ji, DerTag derTag) throws ParseException {
 303                         if(derTag==null)return ji;
 304
 305                         List<Prop> props = derTag.props;
 306
 307                         Prop derived = null;
 308                         if(props!=null) {
 309                                 // Load Namespaces (if any)
 310                                 for(Prop prop : props) {
 311                                         if(prop.tag.startsWith("xmlns:")) {
 312                                                 addNS(prop);
 313                                         }
 314                                 }
 315                                 for(Prop prop : props) {
 316                                         if(prop.tag.endsWith(":type")) {
 317                                                 int idx = prop.tag.indexOf(':');
 318                                                 String potentialNS = "xmlns:"+prop.tag.substring(0,idx);
 319                                                 Map<String,String> ns = getNS();
 320                                                 boolean noNamespace = false;
 321                                                 if(ns==null) {
 322                                                         noNamespace = true;
 323                                                 } else {
 324                                                         String nsVal = ns.get(potentialNS);
 325                                                         if(nsVal==null) noNamespace = true;
 326                                                         else {
 327                                                                 derived = new Prop(Parsed.EXTENSION_TAG,prop.value);
 328                                                                 state.push(derived);
 329                                                         }
 330                                                 }
 331                                                 if(noNamespace) {
 332                                                         throw new ParseException(prop.tag + " utilizes an invalid Namespace prefix");
 333                                                 }
 334                                         } else if(!prop.tag.startsWith("xmlns")) {
 335                                                 state.push(prop);
 336                                         }
 337                                 }
 338                         }
 339                         return derived==null?ji:ji.getDerived(derived.value);
 340                 }
 341         }
 342
 343         private static class RootExpectations extends GreatExpectations {
 344
 345                 public RootExpectations(State state, JaxInfo curr, GreatExpectations prev) throws ParseException {
 346                         super(state,curr,prev, null);
 347                 }
 348
 349                 // @Override
 350                 public boolean eval(Parsed<State> parsed, DerTag derTag) throws ParseException {
 351                         if(derTag.isXmlInfo) {
 352                                 parsed.event = START_DOC;
 353                         } else if(ji.name.equals(derTag.name)) {
 354                                 if(derTag.isEndTag) {
 355                                         parsed.event = END_DOC;
 356                                         parsed.state.greatExp = prev;
 357                                 } else {
 358                                         //parsed.name = derTag.name;
 359                                         parsed.event = START_OBJ;
 360                                         parsed.state.greatExp = new ObjectExpectations(parsed.state,ji, this, false, derTag);
 361                                 }
 362                         }
 363                         return false;
 364                 }
 365         }
 366
 367         private static class ObjectExpectations extends GreatExpectations {
 368                 private boolean printName;
 369
 370                 public ObjectExpectations(State state, JaxInfo curr, GreatExpectations prev, boolean printName, DerTag derTag) throws ParseException {
 371                         super(state, curr, prev, derTag);
 372                         this.printName=printName;
 373                 }
 374
 375                 // @Override
 376                 public boolean eval(Parsed<State> parsed, DerTag derTag) throws ParseException {
 377                         if(derTag.isEndTag && ji.name.equals(derTag.name)) {
 378                                 parsed.state.greatExp = prev;
 379                                 parsed.event = END_OBJ;
 380                                 if(printName)parsed.name = ji.name;
 381                         } else {
 382                                 //Standard Members
 383                                 for(JaxInfo memb : ji.members) {
 384                                         if(memb.name.equals(derTag.name)) {
 385                                                 parsed.name = memb.name;
 386                                                 if(memb.isArray) {
 387                                                         parsed.state.unevaluated = derTag; // evaluate within Array Context
 388                                                         parsed.event = START_ARRAY;
 389                                                         parsed.state.greatExp = new ArrayExpectations(parsed.state,memb,this);
 390                                                         return false;
 391                                                 } else if(memb.isObject()) {
 392                                                         if(derTag.isEndTag) {
 393                                                                 throw new ParseException("Unexpected End Tag </" + derTag.name + '>');
 394                                                         } else {
 395                                                                 parsed.event = START_OBJ;
 396
 397                                                                 parsed.state.greatExp = new ObjectExpectations(parsed.state, memb,this,true,derTag);
 398                                                                 return false;
 399                                                         }
 400                                                 } else { // a leaf
 401                                                         if(derTag.isEndTag) {
 402                                                                  throw new ParseException("Misplaced End Tag </" + parsed.name + '>');
 403                                                         } else {
 404                                                                 parsed.state.greatExp = new LeafExpectations(parsed.state,memb, this);
 405                                                                 return true; // finish out Leaf without returning
 406                                                         }
 407                                                 }
 408                                         }
 409                                 }
 410
 411                                 throw new ParseException("Unexpected Tag <" + derTag.name + '>');
 412                         }
 413                         return false;
 414                 }
 415         }
 416
 417         private static class LeafExpectations extends GreatExpectations {
 418                 public LeafExpectations(State state, JaxInfo curr, GreatExpectations prev) throws ParseException {
 419                         super(state, curr, prev, null);
 420                 }
 421
 422                 // @Override
 423                 public boolean eval(Parsed<State> parsed, DerTag derTag) throws ParseException {
 424                         if(ji.name.equals(derTag.name) && derTag.isEndTag) {
 425                                 parsed.event = NEXT;
 426                                 parsed.isString = ji.isString;
 427                                 parsed.state.greatExp = prev;
 428                         } else {
 429                                 throw new ParseException("Expected </" + ji.name + '>');
 430                         }
 431                         return false;
 432                 }
 433         }
 434
 435         private static class ArrayExpectations extends GreatExpectations {
 436                 public ArrayExpectations(State state, JaxInfo ji, GreatExpectations prev) throws ParseException {
 437                         super(state, ji, prev,null);
 438                         if(state.arrayInfo==null)state.arrayInfo=new Stack<ArrayState>();
 439                         state.arrayInfo.push(new ArrayState());
 440                 }
 441                 // @Override
 442                 public boolean eval(Parsed<State> parsed, DerTag derTag) throws ParseException {
 443                         if(ji.name.equals(derTag.name) && !derTag.isEndTag) {
 444                                 if(ji.isObject()) {
 445                                         if(derTag.isEndTag) {
 446                                                 throw new ParseException("Unexpected End Tag </" + derTag.name + '>');
 447                                         } else {
 448                                                 ArrayState ai = parsed.state.arrayInfo.peek();
 449                                                 if(ai.firstObj || ai.didNext) {
 450                                                         ai.firstObj = false;
 451                                                         ai.didNext = false;
 452                                                         parsed.event = START_OBJ;
 453                                                         parsed.name=derTag.name;
 454                                                         parsed.state.greatExp = new ObjectExpectations(parsed.state,ji,this,true, derTag);
 455                                                 } else {
 456                                                         ai.didNext = true;
 457                                                         parsed.event = NEXT;
 458                                                         parsed.state.unevaluated = derTag;
 459                                                 }
 460                                         }
 461                                 } else { // a leave
 462                                         if(derTag.isEndTag) {
 463                                                  throw new ParseException("Misplaced End Tag </" + parsed.name + '>');
 464                                         } else {
 465                                                 parsed.state.greatExp = new LeafExpectations(parsed.state, ji, this);
 466                                                 return true; // finish out Leaf without returning
 467                                         }
 468                                 }
 469                         } else { // Tag now different... Array is done
 470                                 parsed.state.unevaluated = derTag;
 471                                 parsed.event=END_ARRAY;
 472                                 parsed.state.greatExp = prev;
 473                                 parsed.state.arrayInfo.pop();
 474                         }
 475                         return false;
 476                 }
 477         }
 478         // @Override
 479         public Parsed<State> newParsed() throws ParseException {
 480                 return new Parsed<State>(new State(jaxInfo, null));
 481         }
 482
 483         // @Override
 484         public TimeTaken start(Env env) {
 485                 return env.start("Rosetta XML In", Env.XML);
 486         }
 487
 488 }