1 files changed, 487 insertions, 0 deletions
diff --git a/rosetta/src/main/java/org/onap/aaf/rosetta/InXML.java b/rosetta/src/main/java/org/onap/aaf/rosetta/InXML.java
new file mode 100644
index 0000000..25e91db
--- /dev/null
+++ b/rosetta/src/main/java/org/onap/aaf/rosetta/InXML.java
@@ -0,0 +1,487 @@
+/*******************************************************************************
+ * ============LICENSE_START====================================================
+ * * org.onap.aaf
+ * * ===========================================================================
+ * * Copyright © 2017 AT&T Intellectual Property. All rights reserved.
+ * * ===========================================================================
+ * * Licensed under the Apache License, Version 2.0 (the "License");
+ * * you may not use this file except in compliance with the License.
+ * * You may obtain a copy of the License at
+ * * 
+ *  *      http://www.apache.org/licenses/LICENSE-2.0
+ * * 
+ *  * Unless required by applicable law or agreed to in writing, software
+ * * distributed under the License is distributed on an "AS IS" BASIS,
+ * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * * See the License for the specific language governing permissions and
+ * * limitations under the License.
+ * * ============LICENSE_END====================================================
+ * *
+ * * ECOMP is a trademark and service mark of AT&T Intellectual Property.
+ * *
+ ******************************************************************************/
+package org.onap.aaf.rosetta;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Stack;
+
+import org.onap.aaf.inno.env.Env;
+import org.onap.aaf.inno.env.TimeTaken;
+import org.onap.aaf.rosetta.InXML.State;
+
+public class InXML implements Parse<Reader, State> {
+	// package on purpose
+	JaxInfo jaxInfo;
+
+	public InXML(JaxInfo jaxInfo) {
+		this.jaxInfo = jaxInfo;
+	}
+	
+	public InXML(Class<?> cls, String ... rootNs) throws SecurityException, NoSuchFieldException, ClassNotFoundException, ParseException {
+		jaxInfo = JaxInfo.build(cls,rootNs);
+	}
+
+
+	// @Override
+	public Parsed<State> parse(Reader r, Parsed<State> parsed) throws ParseException {
+		State state = parsed.state;
+		
+		// OK, before anything else, see if there is leftover processing, if so, do it!
+		if(state.unevaluated!=null) {
+			DerTag dt = state.unevaluated;
+			state.unevaluated = null;
+			if(!state.greatExp.eval(parsed, dt))return parsed;
+		}
+
+		if(state.hasAttributes()) {
+			Prop prop = state.pop();
+			parsed.event = Parse.ATTRIB;
+			parsed.name = prop.tag;
+			parsed.sb.append(prop.value);
+			parsed.isString=true;
+			return parsed;
+		}
+		int ch;
+		char c;
+		boolean inQuotes = false, escaped = false;
+
+		StringBuilder sb = parsed.sb, tempSB = new StringBuilder();
+		boolean go = true;
+		
+		try {
+			while(go && (ch=r.read())>=0) {
+				c = (char)ch;
+				if(c == '"') {
+					if(state.greatExp instanceof LeafExpectations) { // within a set of Tags, make a Quote
+						sb.append(c);
+					} else {
+						if(inQuotes) {
+							if(escaped) {
+								sb.append('\\');
+								sb.append(c);
+								escaped = false;
+							} else {
+								inQuotes = false;
+							}
+						} else {
+							parsed.isString=true;
+							inQuotes = true;
+						}
+					}
+				} else if(inQuotes) {
+					sb.append(c);
+				} else if(c=='&') {
+					XmlEscape.xmlEscape(sb,r);
+				} else {
+					switch(c) {
+						case '<':
+							DerTag tag=new DerTag().parse(r, tempSB);
+							go = state.greatExp.eval(parsed, tag);
+							break;
+						default:
+							// don't add Whitespace to start of SB... saves removing later
+							if(sb.length()>0) {
+								sb.append(c);
+							} else if(!Character.isWhitespace(c)) { 
+								sb.append(c);
+							}
+						}
+				}
+			}
+			return parsed;
+		} catch (IOException e) {
+			throw new ParseException(e);
+		}
+	}
+	
+	public static final class DerTag {
+		public String name;
+		public boolean isEndTag;
+		public List<Prop> props;
+		private boolean isXmlInfo;
+		//private String ns; 
+		
+		public DerTag() {
+			name=null;
+			isEndTag = false;
+			props = null;
+			isXmlInfo = false;
+		}
+		
+		public DerTag parse(Reader r, StringBuilder sb) throws ParseException {
+			int ch;
+			char c;
+			boolean inQuotes = false, escaped = false;
+			boolean go = true;
+			String tag = null;
+			
+			try {
+				if((ch = r.read())<0) throw new ParseException("Reader content ended before complete");
+				if(ch=='?') {
+					isXmlInfo = true;
+				}
+				// TODO Check for !-- comments
+				do {
+					c=(char)ch;
+ 					if(c=='"') {
+							if(inQuotes) {
+								if(escaped) {
+									sb.append(c);
+									escaped = false;
+								} else {
+									inQuotes = false;
+								}
+							} else {
+								inQuotes = true;
+							}
+ 					} else if(inQuotes) {
+ 						sb.append(c);
+ 					} else {
+ 						switch(c) {
+							case '/':
+								isEndTag = true;
+								break;
+							case ' ':
+								endField(tag,sb);
+								tag = null;
+								break;
+							case '>':
+								endField(tag,sb);
+								go = false;
+								break;
+							case '=':
+								tag = sb.toString();
+								sb.setLength(0);
+								break;
+//							case ':':
+//								ns = sb.toString();
+//								sb.setLength(0);
+//								break;
+							case '?':
+								if(!isXmlInfo)sb.append(c);
+								break;
+							default:
+								sb.append(c);
+ 						}
+ 					}
+				} while(go && (ch=r.read())>=0);
+			} catch (IOException e) {
+				throw new ParseException(e);
+			}
+			return this;
+		}
+
+		private void endField(String tag, StringBuilder sb) {
+			if(name==null) {
+				name = sb.toString();
+				sb.setLength(0);
+			} else {
+				String value = sb.toString();
+				sb.setLength(0);
+				if(tag !=null && value != null) {
+					if(props==null)props = new ArrayList<Prop>();
+					props.add(new Prop(tag,value));
+				}
+			}
+		}
+		
+		public String toString() {
+			StringBuilder sb = new StringBuilder();
+			sb.append(isEndTag?"End":"Start");
+			sb.append(" Tag\n");
+			sb.append("  Name: ");
+			sb.append(name);
+			if(props!=null) for(Prop p : props) {
+				sb.append("\n     ");
+				sb.append(p.tag);
+				sb.append("=\"");
+				sb.append(p.value);
+				sb.append('"');
+			}
+			return sb.toString();
+		}
+	}
+	
+	private static class ArrayState {
+		public boolean firstObj = true;
+		public boolean didNext = false;
+	}
+
+	public static class State {
+		public GreatExpectations greatExp;
+		public DerTag unevaluated;
+		public Stack<ArrayState> arrayInfo;
+		private List<Prop> attribs;
+		private int idx;
+		public State(JaxInfo ji, DerTag dt) throws ParseException {
+			greatExp = new RootExpectations(this, ji, null);
+			unevaluated = null;
+			attribs = null;;
+		}
+		
+		public boolean hasAttributes() {
+			return attribs!=null && idx<attribs.size();
+		}
+
+		public void push(Prop prop) {
+			if(attribs==null) {
+				attribs = new ArrayList<Prop>();
+				idx = 0;
+			}
+			attribs.add(prop);
+		}
+		
+		public Prop pop() {
+			Prop rv = null;
+			if(attribs!=null) {
+				rv = attribs.get(idx++);
+				if(idx>=attribs.size())attribs = null;
+			}
+			return rv;
+		}
+	}
+	
+	private static abstract class GreatExpectations {
+		protected JaxInfo ji;
+		protected GreatExpectations prev;
+		private Map<String,String> ns;
+		
+		public GreatExpectations(State state, JaxInfo curr, GreatExpectations prev, DerTag derTag) throws ParseException {
+			this.prev = prev;
+			ns = null;
+			ji = getDerived(state, curr,derTag);
+		}
+		
+		public abstract boolean eval(Parsed<State> parsed, DerTag derTag) throws ParseException;
+
+		// Recursively look back for any namespaces
+		protected Map<String,String> getNS() {
+			if(ns!=null)return ns;
+			if(prev!=null) {
+				return prev.getNS();
+			}
+			return null;
+		}
+
+		private void addNS(Prop prop) {
+			Map<String,String> existingNS = getNS();
+			if(ns==null)ns = new HashMap<String,String>();
+			// First make a copy of previous NSs so that we have everything we need, but can overwrite, if necessary
+			if(existingNS!=null && ns!=existingNS) {
+				ns.putAll(ns);
+			}
+			ns.put(prop.tag, prop.value);
+		}
+
+		private JaxInfo getDerived(State state, JaxInfo ji, DerTag derTag) throws ParseException {
+			if(derTag==null)return ji;
+			
+			List<Prop> props = derTag.props;
+			
+			Prop derived = null;
+			if(props!=null) {
+				// Load Namespaces (if any)
+				for(Prop prop : props) {
+					if(prop.tag.startsWith("xmlns:")) {
+						addNS(prop);
+					}
+				}
+				for(Prop prop : props) {
+					if(prop.tag.endsWith(":type")) {
+						int idx = prop.tag.indexOf(':');
+						String potentialNS = "xmlns:"+prop.tag.substring(0,idx);
+						Map<String,String> ns = getNS();
+						boolean noNamespace = false;
+						if(ns==null) {
+							noNamespace = true;
+						} else {
+							String nsVal = ns.get(potentialNS);
+							if(nsVal==null) noNamespace = true;
+							else {
+								derived = new Prop(Parsed.EXTENSION_TAG,prop.value);
+								state.push(derived);
+							}
+						}
+						if(noNamespace) {
+							throw new ParseException(prop.tag + " utilizes an invalid Namespace prefix");
+						}
+					} else if(!prop.tag.startsWith("xmlns")) {
+						state.push(prop);
+					}
+				}
+			}
+			return derived==null?ji:ji.getDerived(derived.value);
+		}
+	}
+	
+	private static class RootExpectations extends GreatExpectations {
+		
+		public RootExpectations(State state, JaxInfo curr, GreatExpectations prev) throws ParseException {
+			super(state,curr,prev, null);
+		}
+		
+		// @Override
+		public boolean eval(Parsed<State> parsed, DerTag derTag) throws ParseException {
+			if(derTag.isXmlInfo) {
+				parsed.event = START_DOC;
+			} else if(ji.name.equals(derTag.name)) {
+				if(derTag.isEndTag) {
+					parsed.event = END_DOC;
+					parsed.state.greatExp = prev;
+				} else {
+					//parsed.name = derTag.name;
+					parsed.event = START_OBJ;
+					parsed.state.greatExp = new ObjectExpectations(parsed.state,ji, this, false, derTag);	
+				}
+			}
+			return false;
+		}
+	}
+	
+	private static class ObjectExpectations extends GreatExpectations {
+		private boolean printName;
+
+		public ObjectExpectations(State state, JaxInfo curr, GreatExpectations prev, boolean printName, DerTag derTag) throws ParseException {
+			super(state, curr, prev, derTag);
+			this.printName=printName;
+		}
+
+		// @Override
+		public boolean eval(Parsed<State> parsed, DerTag derTag) throws ParseException {
+			if(derTag.isEndTag && ji.name.equals(derTag.name)) {
+				parsed.state.greatExp = prev;
+				parsed.event = END_OBJ;
+				if(printName)parsed.name = ji.name;
+			} else {
+				//Standard Members
+				for(JaxInfo memb : ji.members) {
+					if(memb.name.equals(derTag.name)) {
+						parsed.name = memb.name;
+						if(memb.isArray) {
+							parsed.state.unevaluated = derTag; // evaluate within Array Context
+							parsed.event = START_ARRAY;
+							parsed.state.greatExp = new ArrayExpectations(parsed.state,memb,this);
+							return false;
+						} else if(memb.isObject()) {
+							if(derTag.isEndTag) {
+								throw new ParseException("Unexpected End Tag </" + derTag.name + '>');
+							} else {
+								parsed.event = START_OBJ;
+
+								parsed.state.greatExp = new ObjectExpectations(parsed.state, memb,this,true,derTag);
+								return false;
+							}
+						} else { // a leaf
+							if(derTag.isEndTag) {
+								 throw new ParseException("Misplaced End Tag </" + parsed.name + '>');
+							} else {
+								parsed.state.greatExp = new LeafExpectations(parsed.state,memb, this);
+								return true; // finish out Leaf without returning
+							}
+						}
+					}
+				}
+
+				throw new ParseException("Unexpected Tag <" + derTag.name + '>');
+			}
+			return false;
+		}
+	}
+	
+	private static class LeafExpectations extends GreatExpectations {
+		public LeafExpectations(State state, JaxInfo curr, GreatExpectations prev) throws ParseException {
+			super(state, curr, prev, null);
+		}
+
+		// @Override
+		public boolean eval(Parsed<State> parsed, DerTag derTag) throws ParseException {
+			if(ji.name.equals(derTag.name) && derTag.isEndTag) {
+				parsed.event = NEXT;
+				parsed.isString = ji.isString;
+				parsed.state.greatExp = prev;
+			} else {
+				throw new ParseException("Expected </" + ji.name + '>');
+			}
+			return false;
+		}		
+	}
+
+	private static class ArrayExpectations extends GreatExpectations {
+		public ArrayExpectations(State state, JaxInfo ji, GreatExpectations prev) throws ParseException {
+			super(state, ji, prev,null);
+			if(state.arrayInfo==null)state.arrayInfo=new Stack<ArrayState>();
+			state.arrayInfo.push(new ArrayState());
+		}
+		// @Override
+		public boolean eval(Parsed<State> parsed, DerTag derTag) throws ParseException {
+			if(ji.name.equals(derTag.name) && !derTag.isEndTag) {
+				if(ji.isObject()) {
+					if(derTag.isEndTag) {
+						throw new ParseException("Unexpected End Tag </" + derTag.name + '>');
+					} else {
+						ArrayState ai = parsed.state.arrayInfo.peek();  
+						if(ai.firstObj || ai.didNext) {
+							ai.firstObj = false;
+							ai.didNext = false;
+							parsed.event = START_OBJ;
+							parsed.name=derTag.name;
+							parsed.state.greatExp = new ObjectExpectations(parsed.state,ji,this,true, derTag);
+						} else {
+							ai.didNext = true;
+							parsed.event = NEXT;
+							parsed.state.unevaluated = derTag;
+						}
+					}
+				} else { // a leave
+					if(derTag.isEndTag) {
+						 throw new ParseException("Misplaced End Tag </" + parsed.name + '>');
+					} else {
+						parsed.state.greatExp = new LeafExpectations(parsed.state, ji, this);
+						return true; // finish out Leaf without returning
+					}
+				}
+			} else { // Tag now different... Array is done
+				parsed.state.unevaluated = derTag;
+				parsed.event=END_ARRAY;
+				parsed.state.greatExp = prev;
+				parsed.state.arrayInfo.pop();
+			}
+			return false;
+		}		
+	}
+	// @Override
+	public Parsed<State> newParsed() throws ParseException {
+		return new Parsed<State>(new State(jaxInfo, null));
+	}
+
+	// @Override
+	public TimeTaken start(Env env) {
+		return env.start("Rosetta XML In", Env.XML);
+	}
+	
+}