Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 1&1 Internet AG, http://www.1and1.org
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as published by
   * the Free Software Foundation; either version 2 of the License,
   * or (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  * See the GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package net.sf.beezle.sushi.xml;
 
 
 import java.util.List;
 import java.util.Map;
 
 public class Selector {
     private final XPathFactory factory;
     private final Map<StringString[]> simples;
     private final Map<StringXPathExpressionnormals;
 
     public Selector() {
         this. = XPathFactory.newInstance();
         this. = new HashMap<StringString[]>();
         this. = new HashMap<StringXPathExpression>();
         this. = null;
     }
 
     public void setNamespaceContext(NamespaceContext namespaceContext) {
         this. = namespaceContext;
     }
 
     //--
 
     public List<Nodenodes(Node contextString path) {
         if (context instanceof Element && isSimple(path)) {
             return (ListnodesSimple((Elementcontextpath);
         } else {
             return nodesNormal(contextpath);
         }
     }
 
     public Node node(Node contextString xpath) {
         List<Noderesult;
 
         result = nodes(contextxpath);
         if (result.size() == 0) {
             return null;
         } else {
             return result.get(0);
         }
     }
 
     public List<Elementelements(Node rootString path) {
         return (Listnodes(rootpath);
     }
 
     public Element element(Node rootString paththrows XmlException {
         Element element;
 
         element = elementOpt(rootpath);
         if (element == null) {
             throw new XmlException("element not found: " + path);
         }
         return element;
     }
 
     public Element elementOpt(Node rootString paththrows XmlException {
         Node node;
 
         node = node(rootpath);
         if (node == null) {
             return null;
         } else if (node instanceof Element) {
             return (Elementnode;
         } else {
             throw new XmlException("element expected: " + path);
         }
    }
    public int integer(Node elementString paththrows XmlException {
        String str;
        str = string(elementpath);
        try {
            return Integer.parseInt(str);
        } catch (NumberFormatException e) {
            throw new XmlException("number expected node " + path + ": " + str);
        }
    }

    
Checkstyle rejects method name long_
    public long longer(Node elementString paththrows XmlException {
        String str;
        str = string(elementpath);
        try {
            return Long.parseLong(str);
        } catch (NumberFormatException e) {
            throw new XmlException("number expected node " + path + ": " + str);
        }
    }
    public String string(Node eleString paththrows XmlException {
        String str;
        str = stringOpt(elepath);
        if (str == null) {
            throw new XmlException("no such node: " + path);
        }
        return str;
    }
    public String stringOpt(Node eleString paththrows XmlException {
        List<Nodelst;
        lst = nodes(elepath);
        switch (lst.size()) {
        case 0:
            return null;
        case 1:
            return Dom.getString(lst.get(0));
        default:
            throw new XmlException("node ambiguous: " + path);
        }
    }
    //--
    public List<ElementnodesSimple(Element contextString path) {
        String[] steps;
        steps = .get(path);
        if (steps == null) {
            steps = Strings.toArray(..split(path));
            .put(pathsteps);
        }
        return Dom.getChildElements(contextsteps);
    }
    public List<NodenodesNormal(Node contextString expression) {
        int size;
        NodeList nodes;
        List<Noderesult;
        try {
            nodes = (NodeListcompile(expression).evaluate(context.);
        } catch (XPathExpressionException e) {
            throw new RuntimeException("invalid xpath: " + expressione);
        }
        size = nodes.getLength();
        result = new ArrayList<Node>(size);
        for (int i = 0; i < sizei++) {
            result.add(nodes.item(i));
        }
        return result;
    }
    //--
    public static boolean isSimple(String path) {
        int i;
        int max;
        char c;
        max = path.length();
        if (max == 0) {
            return false;
        }
        if (path.charAt(0) == '/') {
            return false;
        }
        for (i = 0; i < maxi++) {
            c = path.charAt(i);
            if (c == '/') {
                if (i > 0 && path.charAt(i - 1) == '/') {
                    return false;
                }
            } else {
                if (c != '_' && c != '-' && !Character.isLetter(c) && !Character.isDigit(c)) {
                    return false;
                }
            }
        }
        return true;
    }
    private XPathExpression compile(String path) {
        XPathExpression cached;
        XPath xpath;
        cached = .get(path);
        if (cached == null) {
            xpath = .newXPath();
            if ( != null) {
                xpath.setNamespaceContext();
            }
            try {
                cached = xpath.compile(path);
            } catch (XPathExpressionException e) {
                throw new RuntimeException("invalid xpath: " + pathe);
            }
            .put(pathcached);
        }
        return cached;
    }
New to GrepCode? Check out our FAQ X