plugins/org.eclipse.actf.ai.query/src/org/eclipse/actf/ai/query/impl/FlashQueryImpl.java - actf/org.eclipse.actf.ai - Git at Google

 /*******************************************************************************
  * Copyright (c) 2007 IBM Corporation and Others
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *    Hisashi MIYASHITA - initial API and implementation
  *******************************************************************************/

 package org.eclipse.actf.ai.query.impl;

 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 import org.eclipse.actf.model.dom.dombycom.IFlashNode;
 import org.w3c.dom.Attr;
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 import org.w3c.dom.Node;


 public class FlashQueryImpl {
     private static final String FLASH_QUERY_NS = "http://www.ibm.com/xmlns/prod/aiBrowser/fennec/flash-query";
     private final String base;

     private final Target[] targets;

     private final boolean isFrameRangeSpecified;
     private final int frameRangeMin;
     private final int frameRangeMax;

     private final boolean isDepthSpecified;
     private final int depth;

     private FlashQueryImpl(String base, List<Target> targetList,
                            boolean isDepthSpecified, int depth,
                            boolean isFrameRangeSpecified,
                            int frameRangeMin, int frameRangeMax) {
         this.base = base;
         this.targets = targetList.toArray(new Target[targetList.size()]);
         this.isDepthSpecified = isDepthSpecified;
         this.depth = depth;
         this.isFrameRangeSpecified = isFrameRangeSpecified;
         this.frameRangeMin = frameRangeMin;
         this.frameRangeMax = frameRangeMax;
     }

     static private abstract class Target {
         protected boolean isRelative;
         public abstract List<Node> query(IFlashNode fn, List<Node> r);
     }

     static private class SimpleTarget extends Target {
         private final String path;

         @Override
         public List<Node> query(IFlashNode fn, List<Node> l) {
             IFlashNode r;
             if (isRelative) {
                 if (path.length() > 0) {
                     r = fn.getNodeFromPath(fn.getTarget() + "." + path);
                 } else {
                     r = fn;
                 }
             } else {
                 r = fn.getNodeFromPath(path);
             }
             if (r != null) l.add(r);
             return l;
         }

         SimpleTarget(String path) {
             if (path.charAt(0) == '.') {
                 isRelative = true;
                 this.path = path.substring(1);
             } else {
                 isRelative = false;
                 this.path = path;
             }
         }
     }

     static private class WildCardTarget extends Target {
         private List<Object> pathSegments;

         static private Pattern regExpQuote(String pat, char wildCardChar) {
             StringBuffer r = new StringBuffer();
             for (int i = 0; i < pat.length(); i++) {
                 char c = pat.charAt(i);
                 if (c == wildCardChar) {
                     r.append(".*");
                 } else if (("\\?*+.[]{}()$^".indexOf(c) >= 0)) {
                     r.append('\\');
                     r.append(c);
                 } else {
                     r.append(c);
                 }
             }
             return Pattern.compile(r.toString());
         }

         private boolean match(Pattern p, IFlashNode fn) {
             String target = fn.getTarget();
             int idx = target.lastIndexOf(".");
             if (idx > 0) {
                 target = target.substring(idx + 1);
             }
             Matcher m = p.matcher(target);
             return m.matches();
         }

         private ArrayList<Node> queryWC(IFlashNode fn, Pattern p, ArrayList<Node> l) {
             IFlashNode[] fns = fn.getInnerNodes();
             for (int i = 0; i < fns.length; i++) {
                 if (match(p, fns[i])) {
                     l.add(fns[i]);
                 }
             }
             return l;
         }

         @Override
         public List<Node> query(IFlashNode fn, List<Node> l) {
             ArrayList<Node> cnl = new ArrayList<Node>();
             Iterator<Object> it = pathSegments.iterator();
             if (isRelative) {
                 cnl.add(fn);
             } else {
                 if (!it.hasNext()) return l;
                 Object ps = it.next();
                 if (!(ps instanceof String)) return l;
                 IFlashNode fn2 = fn.getNodeFromPath((String) ps);
                 if (fn2 == null) return l;
                 cnl.add(fn2);
             }
             while (it.hasNext()) {
                 ArrayList<Node> cnl2 = new ArrayList<Node>();
                 Object ps = it.next();
                 if (ps instanceof String) {
                     for (int i = 0; i < cnl.size(); i++) {
                         IFlashNode fn2 = (IFlashNode) cnl.get(i);
                         fn2 = fn2.getNodeFromPath(fn2.getTarget() + "." + ps);
                         if (fn2 != null) cnl2.add(fn2);
                     }
                 } else {
                     for (int i = 0; i < cnl.size(); i++) {
                         IFlashNode fn2 = (IFlashNode) cnl.get(i);
                         cnl2 = queryWC(fn2, (Pattern) ps, cnl2);
                     }
                 }
                 cnl = cnl2;
                 if (cnl.size() == 0) return l;
             }
             l.addAll(cnl);
             return l;
         }

         WildCardTarget(String target, String base) {
             pathSegments = new ArrayList<Object>();
             char ct = target.charAt(0);
             switch (ct) {
             case '/':
                 isRelative = false;
                 target = target.substring(1);
                 break;
             case '.':
                 isRelative = true;
                 target = target.substring(1);
                 break;
             default:
                 isRelative = false;
                 target = base + "." + target;
             }

             StringBuffer buf = new StringBuffer();
             String[] segs = target.split("\\.");
             for (int i = 0; i < segs.length; i++) {
                 if (segs[i].indexOf('*') >= 0) {
                     if (buf.length() > 0) {
                         pathSegments.add(buf.toString());
                         buf.setLength(0);
                     }
                     pathSegments.add(regExpQuote(segs[i], '*'));
                 } else {
                     if (buf.length() > 0) {
                         buf.append(".");
                     }
                     buf.append(segs[i]);
                 }
             }
             if (buf.length() > 0) {
                 pathSegments.add(buf.toString());
             }
         }
     }

     public boolean hasTarget() {
         return targets.length > 0;
     }

     public List<Node> query(Node base) {
         if (!(base instanceof IFlashNode)) return null;
         IFlashNode fn = (IFlashNode) base;

         List<Node> r = new ArrayList<Node>();
         for (int i = 0; i < targets.length; i++) {
             r = targets[i].query(fn, r);
         }

         if (isDepthSpecified) {
             List<Node> r2 = new ArrayList<Node>();
             Iterator<Node> it = r.iterator();
             while (it.hasNext()) {
                 IFlashNode fn2 = (IFlashNode) it.next();
                 IFlashNode fnd = fn2.getNodeAtDepth(depth);
                 if (fnd != null) r2.add(fnd);
             }
             r = r2;
         }
         if (isFrameRangeSpecified) {
             Iterator<Node> it = r.iterator();
             while (it.hasNext()) {
                 IFlashNode fn2 = (IFlashNode) it.next();
                 int f = fn2.getCurrentFrame();
                 if (!((frameRangeMin <= f) && (f < frameRangeMax))) it.remove();
             }
         }

         return r;
     }

     private static String computeBase(String path, String pbase) {
         char ct = path.charAt(0);
         switch (ct) {
         case '/':
             return path.substring(1);
         case '.':
             return path;
         default:
             if ((pbase.length() == 0) || (pbase.equals("."))) return path;
             return pbase + "." + path;
         }
     }

     static FlashQueryImpl parse(Element e, FlashQueryImpl parentQuery) {
         String base = e.getAttributeNS(FLASH_QUERY_NS, "base");

         String pbase = "";
         if (parentQuery != null) {
             pbase = parentQuery.base;
         }
         if (base.length() == 0) {
             base = pbase;
         } else {
             base = computeBase(base, pbase);
         }

         String targetStr = e.getAttributeNS(FLASH_QUERY_NS, "targets");
         ArrayList<Target> targetList = new ArrayList<Target>();
         if (targetStr.length() > 0) {
             String[] targets = targetStr.split("[ \t\r\n]");
             for (int i = 0; i < targets.length; i++) {
                 if (targets[i].indexOf('*') >= 0) {
                     targetList.add(new WildCardTarget(targets[i], base));
                 } else {
                     targetList.add(new SimpleTarget(computeBase(targets[i], base)));
                 }
             }
         }


         String depthStr = e.getAttributeNS(FLASH_QUERY_NS, "depth");
         boolean isDepthSpecified = false;
         int depth = 0;
         if (depthStr.length() > 0) {
             try {
                 depth = Integer.parseInt(depthStr.trim());
                 isDepthSpecified = true;
             } catch (NumberFormatException ex) {
             }
         }

         boolean isFrameRangeSpecified = false;
         int frameRangeMin = 0;
         int frameRangeMax = 0;
         String frameRangeStr = e.getAttributeNS(FLASH_QUERY_NS, "frameRange");
         if (frameRangeStr.length() > 0) {
             int pos = frameRangeStr.indexOf('-');
             try {
                 if (pos < 0) {
                     int m = Integer.parseInt(frameRangeStr.trim());
                     frameRangeMin = m;
                     frameRangeMax = m + 1;
                 } else {
                     frameRangeMin = Integer.parseInt(frameRangeStr.substring(0, pos).trim());
                     frameRangeMax = Integer.parseInt(frameRangeStr.substring(pos + 1).trim());
                 }
                 isFrameRangeSpecified = true;
             } catch (NumberFormatException ex) {
             }
         }

         FlashQueryImpl q = new FlashQueryImpl(base, targetList,
                                               isDepthSpecified, depth,
                                               isFrameRangeSpecified,
                                               frameRangeMin,
                                               frameRangeMax);

         return q;
     }

     static Attr serializeQuery(Node domNode, Node usrNode) {
         if (!(domNode instanceof IFlashNode))
             return null;
         Document doc = usrNode.getOwnerDocument();
         String target = ((IFlashNode)domNode).getTarget();
         if (target != null && target.length() > 0) {
             Attr attr = doc.createAttributeNS(FLASH_QUERY_NS, "flq:targets");
             attr.setNodeValue(target);
             return attr;
         }
         return null;
     }

 }
	/*******************************************************************************
	* Copyright (c) 2007 IBM Corporation and Others
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* Hisashi MIYASHITA - initial API and implementation
	*******************************************************************************/

	package org.eclipse.actf.ai.query.impl;

	import java.util.ArrayList;
	import java.util.Iterator;
	import java.util.List;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;

	import org.eclipse.actf.model.dom.dombycom.IFlashNode;
	import org.w3c.dom.Attr;
	import org.w3c.dom.Document;
	import org.w3c.dom.Element;
	import org.w3c.dom.Node;



	public class FlashQueryImpl {
	private static final String FLASH_QUERY_NS = "http://www.ibm.com/xmlns/prod/aiBrowser/fennec/flash-query";
	private final String base;

	private final Target[] targets;

	private final boolean isFrameRangeSpecified;
	private final int frameRangeMin;
	private final int frameRangeMax;

	private final boolean isDepthSpecified;
	private final int depth;

	private FlashQueryImpl(String base, List<Target> targetList,
	boolean isDepthSpecified, int depth,
	boolean isFrameRangeSpecified,
	int frameRangeMin, int frameRangeMax) {
	this.base = base;
	this.targets = targetList.toArray(new Target[targetList.size()]);
	this.isDepthSpecified = isDepthSpecified;
	this.depth = depth;
	this.isFrameRangeSpecified = isFrameRangeSpecified;
	this.frameRangeMin = frameRangeMin;
	this.frameRangeMax = frameRangeMax;
	}

	static private abstract class Target {
	protected boolean isRelative;
	public abstract List<Node> query(IFlashNode fn, List<Node> r);
	}

	static private class SimpleTarget extends Target {
	private final String path;

	@Override
	public List<Node> query(IFlashNode fn, List<Node> l) {
	IFlashNode r;
	if (isRelative) {
	if (path.length() > 0) {
	r = fn.getNodeFromPath(fn.getTarget() + "." + path);
	} else {
	r = fn;
	}
	} else {
	r = fn.getNodeFromPath(path);
	}
	if (r != null) l.add(r);
	return l;
	}

	SimpleTarget(String path) {
	if (path.charAt(0) == '.') {
	isRelative = true;
	this.path = path.substring(1);
	} else {
	isRelative = false;
	this.path = path;
	}
	}
	}

	static private class WildCardTarget extends Target {
	private List<Object> pathSegments;

	static private Pattern regExpQuote(String pat, char wildCardChar) {
	StringBuffer r = new StringBuffer();
	for (int i = 0; i < pat.length(); i++) {
	char c = pat.charAt(i);
	if (c == wildCardChar) {
	r.append(".*");
	} else if (("\\?*+.[]{}()$^".indexOf(c) >= 0)) {
	r.append('\\');
	r.append(c);
	} else {
	r.append(c);
	}
	}
	return Pattern.compile(r.toString());
	}

	private boolean match(Pattern p, IFlashNode fn) {
	String target = fn.getTarget();
	int idx = target.lastIndexOf(".");
	if (idx > 0) {
	target = target.substring(idx + 1);
	}
	Matcher m = p.matcher(target);
	return m.matches();
	}

	private ArrayList<Node> queryWC(IFlashNode fn, Pattern p, ArrayList<Node> l) {
	IFlashNode[] fns = fn.getInnerNodes();
	for (int i = 0; i < fns.length; i++) {
	if (match(p, fns[i])) {
	l.add(fns[i]);
	}
	}
	return l;
	}

	@Override
	public List<Node> query(IFlashNode fn, List<Node> l) {
	ArrayList<Node> cnl = new ArrayList<Node>();
	Iterator<Object> it = pathSegments.iterator();
	if (isRelative) {
	cnl.add(fn);
	} else {
	if (!it.hasNext()) return l;
	Object ps = it.next();
	if (!(ps instanceof String)) return l;
	IFlashNode fn2 = fn.getNodeFromPath((String) ps);
	if (fn2 == null) return l;
	cnl.add(fn2);
	}
	while (it.hasNext()) {
	ArrayList<Node> cnl2 = new ArrayList<Node>();
	Object ps = it.next();
	if (ps instanceof String) {
	for (int i = 0; i < cnl.size(); i++) {
	IFlashNode fn2 = (IFlashNode) cnl.get(i);
	fn2 = fn2.getNodeFromPath(fn2.getTarget() + "." + ps);
	if (fn2 != null) cnl2.add(fn2);
	}
	} else {
	for (int i = 0; i < cnl.size(); i++) {
	IFlashNode fn2 = (IFlashNode) cnl.get(i);
	cnl2 = queryWC(fn2, (Pattern) ps, cnl2);
	}
	}
	cnl = cnl2;
	if (cnl.size() == 0) return l;
	}
	l.addAll(cnl);
	return l;
	}

	WildCardTarget(String target, String base) {
	pathSegments = new ArrayList<Object>();
	char ct = target.charAt(0);
	switch (ct) {
	case '/':
	isRelative = false;
	target = target.substring(1);
	break;
	case '.':
	isRelative = true;
	target = target.substring(1);
	break;
	default:
	isRelative = false;
	target = base + "." + target;
	}

	StringBuffer buf = new StringBuffer();
	String[] segs = target.split("\\.");
	for (int i = 0; i < segs.length; i++) {
	if (segs[i].indexOf('*') >= 0) {
	if (buf.length() > 0) {
	pathSegments.add(buf.toString());
	buf.setLength(0);
	}
	pathSegments.add(regExpQuote(segs[i], '*'));
	} else {
	if (buf.length() > 0) {
	buf.append(".");
	}
	buf.append(segs[i]);
	}
	}
	if (buf.length() > 0) {
	pathSegments.add(buf.toString());
	}
	}
	}

	public boolean hasTarget() {
	return targets.length > 0;
	}

	public List<Node> query(Node base) {
	if (!(base instanceof IFlashNode)) return null;
	IFlashNode fn = (IFlashNode) base;

	List<Node> r = new ArrayList<Node>();
	for (int i = 0; i < targets.length; i++) {
	r = targets[i].query(fn, r);
	}

	if (isDepthSpecified) {
	List<Node> r2 = new ArrayList<Node>();
	Iterator<Node> it = r.iterator();
	while (it.hasNext()) {
	IFlashNode fn2 = (IFlashNode) it.next();
	IFlashNode fnd = fn2.getNodeAtDepth(depth);
	if (fnd != null) r2.add(fnd);
	}
	r = r2;
	}
	if (isFrameRangeSpecified) {
	Iterator<Node> it = r.iterator();
	while (it.hasNext()) {
	IFlashNode fn2 = (IFlashNode) it.next();
	int f = fn2.getCurrentFrame();
	if (!((frameRangeMin <= f) && (f < frameRangeMax))) it.remove();
	}
	}

	return r;
	}

	private static String computeBase(String path, String pbase) {
	char ct = path.charAt(0);
	switch (ct) {
	case '/':
	return path.substring(1);
	case '.':
	return path;
	default:
	if ((pbase.length() == 0) \|\| (pbase.equals("."))) return path;
	return pbase + "." + path;
	}
	}

	static FlashQueryImpl parse(Element e, FlashQueryImpl parentQuery) {
	String base = e.getAttributeNS(FLASH_QUERY_NS, "base");

	String pbase = "";
	if (parentQuery != null) {
	pbase = parentQuery.base;
	}
	if (base.length() == 0) {
	base = pbase;
	} else {
	base = computeBase(base, pbase);
	}

	String targetStr = e.getAttributeNS(FLASH_QUERY_NS, "targets");
	ArrayList<Target> targetList = new ArrayList<Target>();
	if (targetStr.length() > 0) {
	String[] targets = targetStr.split("[ \t\r\n]");
	for (int i = 0; i < targets.length; i++) {
	if (targets[i].indexOf('*') >= 0) {
	targetList.add(new WildCardTarget(targets[i], base));
	} else {
	targetList.add(new SimpleTarget(computeBase(targets[i], base)));
	}
	}
	}


	String depthStr = e.getAttributeNS(FLASH_QUERY_NS, "depth");
	boolean isDepthSpecified = false;
	int depth = 0;
	if (depthStr.length() > 0) {
	try {
	depth = Integer.parseInt(depthStr.trim());
	isDepthSpecified = true;
	} catch (NumberFormatException ex) {
	}
	}

	boolean isFrameRangeSpecified = false;
	int frameRangeMin = 0;
	int frameRangeMax = 0;
	String frameRangeStr = e.getAttributeNS(FLASH_QUERY_NS, "frameRange");
	if (frameRangeStr.length() > 0) {
	int pos = frameRangeStr.indexOf('-');
	try {
	if (pos < 0) {
	int m = Integer.parseInt(frameRangeStr.trim());
	frameRangeMin = m;
	frameRangeMax = m + 1;
	} else {
	frameRangeMin = Integer.parseInt(frameRangeStr.substring(0, pos).trim());
	frameRangeMax = Integer.parseInt(frameRangeStr.substring(pos + 1).trim());
	}
	isFrameRangeSpecified = true;
	} catch (NumberFormatException ex) {
	}
	}

	FlashQueryImpl q = new FlashQueryImpl(base, targetList,
	isDepthSpecified, depth,
	isFrameRangeSpecified,
	frameRangeMin,
	frameRangeMax);

	return q;
	}

	static Attr serializeQuery(Node domNode, Node usrNode) {
	if (!(domNode instanceof IFlashNode))
	return null;
	Document doc = usrNode.getOwnerDocument();
	String target = ((IFlashNode)domNode).getTarget();
	if (target != null && target.length() > 0) {
	Attr attr = doc.createAttributeNS(FLASH_QUERY_NS, "flq:targets");
	attr.setNodeValue(target);
	return attr;
	}
	return null;
	}

	}