/ - Diff - Plateforme TXM - Forge du Centre Blaise Pascal

      * @author mdecorde
+     *
      */
     public class LocalNameHookActivator extends HookActivator {
     public class LocalNameHookActivator<T extends XMLParser> extends HookActivator<T> {
     	String localname;
     	/**
     	 * @param localname the element localname to match
     	 */
     	public LocalNameHookActivator(Hook hook, String localname) {
     	public LocalNameHookActivator(String localname) {
     		this(null, localname);
+    	}
     	/**
     	 * @param localname the element localname to match
     	 */
     	public LocalNameHookActivator(Hook<T> hook, String localname) {
     		super(hook);
     		this.localname = localname;
+    	}

     public class DOMIdentityHook extends Hook<XMLProcessor> {
     	Element dom;
     	/**
     	 * The constructed DOM element
     	 */
     	protected Element dom;
     	public DOMIdentityHook(String name, HookActivator activator, XMLProcessor processor) throws IOException, XMLStreamException {
     	public DOMIdentityHook(String name, HookActivator<XMLProcessor> activator, XMLProcessor processor) throws IOException, XMLStreamException {
     		super(name, activator, processor);
+    	}
-...
+    	}
     	private void writeDOM(Node node) throws XMLStreamException {
     		if (node == null) return; // nothing to write
     		if (node.getNodeType() == Node.ELEMENT_NODE) {
     			Element e = (Element) node;
     			NodeList children = e.getChildNodes();
-...
     			for (int i = 0; i < e.getAttributes().getLength(); i++) {
     				Node att = e.getAttributes().item(i);
     				parentParser.writer.writeAttribute(att.getNamespaceURI(), att.getNodeName(), att.getNodeValue());
     				if (att.getNamespaceURI() != null) {
     					parentParser.writer.writeAttribute(att.getNamespaceURI(), att.getNodeName(), att.getNodeValue());
+    				}
     				else {
     					parentParser.writer.writeAttribute(att.getNodeName(), att.getNodeValue());
+    				}
+    			}
     			for (int c = 0; c < children.getLength(); c++) {

      * @author mdecorde
+     *
      */
     public class LocalNamesHookActivator extends HookActivator {
     public class LocalNamesHookActivator<T extends XMLParser> extends HookActivator<T> {
     	HashSet<String> localnames;
     	/**
     	 * @param localnames the element localnames to match
     	 */
     	public LocalNamesHookActivator(Hook hook, List<String> localnames) {
     		super();
     	public LocalNamesHookActivator(List<String> localnames) {
     		this(null, localnames);
+    	}
     	/**
     	 * @param localnames the element localnames to match
     	 */
     	public LocalNamesHookActivator(Hook<T> hook, List<String> localnames) {
     		super(hook);
     		this.localnames = new HashSet<>();
     		this.localnames.addAll(localnames);
+    	}
-...
     	/**
     	 * @param localnames the element localnames to match
     	 */
     	public LocalNamesHookActivator(Hook hook, String... localnames) {
     	public LocalNamesHookActivator(Hook<T> hook, String... localnames) {
     		this(hook, Arrays.asList(localnames));
+    	}

      * @author mdecorde
+     *
      */
     public abstract class HookActivator {
     public abstract class HookActivator<T extends XMLParser> {
     	/**
     	 * to access to current parsing informations
     	 */
     	Hook hook;
     	Hook<T> hook;
     	/**
+    	 *
     	 * The Hook will be associated in the Hook constructor
+    	 *
     	 * @param hook if the hook is already defined. you can associated it that way (or call hook.setActivator() && activator.setHook(
     	 */
     	public HookActivator() {}
     	public HookActivator(Hook<T> hook) {
     		this.hook = hook;
     		if (hook != null) {
     			hook.setActivator(this);
+    		}
+    	}
     	/**
+    	 *
-...
+    	 *
     	 * @param hook this activators hook
     	 */
     	public void setHook(Hook hook) {
     	public void setHook(Hook<T> hook) {
     		this.hook = hook;
     		if (hook.getActivator() != this) {
     			hook.setActivator(this);
+    		}
+    	}
     	public Hook<T> getHook() {
     		return hook;
+    	}
+    }

     	protected T parentParser = null;
     	protected HookActivator activator = null;
     	protected HookActivator<T> activator = null;
     	protected String name;
-...
     	 * @throws IOException
     	 * @throws XMLStreamException
     	 */
     	public Hook(String name, HookActivator activator, T parentParser) throws IOException, XMLStreamException {
     	public Hook(String name, HookActivator<T> activator, T parentParser) throws IOException, XMLStreamException {
     		this.parentParser = parentParser;
     		this.name = name;
     		setActivator(activator); // set the activator
-...
     		this.parser = parentParser.parser;
+    	}
     	public void setActivator(HookActivator activator) {
     	public void setActivator(HookActivator<T> activator) {
     		this.activator = activator;
     		if (activator != null) {
     		if (activator.getHook() != this) {
     			activator.setHook(this);
+    		}
+    	}
-...
     	public String getLocalName() {
     		return parentParser.localname;
+    	}
     	public HookActivator<T> getActivator() {
     		return activator;
+    	}
+    }

      * @author mdecorde
+     *
      */
     public class XPathHookActivator extends HookActivator {
     public class XPathHookActivator<T extends XMLParser> extends HookActivator<T> {
     	String xpath;
-...
     	/**
     	 * @param localname the element localname to match
     	 */
     	public XPathHookActivator(Hook hook, String xpath) {
     	public XPathHookActivator(Hook<T> hook, String xpath) {
     		super(hook);
     		this.xpath = xpath;
     		String regex = xpath;

      * @author mdecorde
+     *
      */
     public class XPathsHookActivator extends XPathHookActivator {
     public class XPathsHookActivator<T extends XMLParser> extends XPathHookActivator<T> {
     	int currentXPath = 0;
     	List<String> xpaths;
     	/**
     	 * @param localname the element localname to match
     	 */
     	public XPathsHookActivator(Hook hook, List<String> xpaths) {
     	public XPathsHookActivator(Hook<T> hook, List<String> xpaths) {
     		super(hook, xpaths.get(0));
     		this.xpaths = xpaths;
-...
     		try {
     			this.p = Pattern.compile(regex);
     			if (debug) System.out.println("P="+p);
     		} catch(PatternSyntaxException e) {
     			String m = NLS.bind("Pattern not compiled correctly with: {0} at {1}.", xpath+" ("+currentXPath+")", hook.getLocation());
     			if (debug) System.out.println("P=" + p);
+    		}
     		catch (PatternSyntaxException e) {
     			String m = NLS.bind("Pattern not compiled correctly with: {0} at {1}.", xpath + " (" + currentXPath + ")", hook.getLocation());
     			Log.severe(m);
     			Log.severe("Pattern error: "+e);
     			Log.severe("Pattern error: " + e);
     			Log.printStackTrace(e);
     			p = null;
     			return false;
-...
+    	}
     	public static void main(String[] args) {
     		new XPathsHookActivator(null,
     		new XPathsHookActivator(null,
     				Arrays.asList("//text//p[@name='value']", "//text//p[@name='value']"));
+    	}
+    }

Laboratoire ICAR » Plateforme TXM