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;
 
 public class Dom {

Returns:
element
 
     public static Element addTextOpt(Element elementString text) {
         if ("".equals(text)) {
         	// nothing to do 
         } else {
         	Text txt = element.getOwnerDocument().createTextNode(text);
         	element.appendChild(txt);
         }
         return element;
     }
 	
     // TODO: replace by iterator?
     public static List<ElementgetAllChildElements(Element parent) {
         List<Elementresult;
         NodeList nodes;
         int i;
         int max;
         Node node;
 
         result = new ArrayList<Element>();
         nodes = parent.getChildNodes();
         max = nodes.getLength();
         for (i = 0; i < maxi++) {
             node = nodes.item(i);
             if (node instanceof Element) {
                 result.add((Elementnode);
             }
         }
         return result;
     }
 
     public static Element getChildElementOpt(Element eleString name) {
         List<Elementresult;
 
         result = Dom.getChildElements(elename);
         switch (result.size()) {
         case 0:
             return null;
         case 1:
             return result.get(0);
         default:
             throw new DomException("too many elements: " + name);
         }
     }
 
     public static Element getChildElement(Element eleString name) {
         List<Elementresult;
 
         result = Dom.getChildElements(elename);
         switch (result.size()) {
         case 0:
             throw new DomException("missing element: " + name);
         case 1:
             return result.get(0);
         default:
             throw new DomException("too many elements: " + name);
         }
     }
 
     public static Element getFirstChildElement(Node parentString localNamespace namespace) {
         NodeList children = parent.getChildNodes();
         for (int i = 0; i < children.getLength(); i++) {
             Node child = children.item(i);
             if ((child instanceof Element) && Dom.matches(childlocalnamespace)) {
                 return (Elementchild;
             }
         }
         return null;
     }

    
Steps may be empty strings
    public static List<ElementgetChildElements(Element rootString ... steps) {
        List<Elementlst;
        
        lst = new ArrayList<Element>();
        doGetChildElements(rootsteps, 0, lst);
        return lst;
    }
    private static void doGetChildElements(Element rootString[] stepsint iList<Elementresult) {
        if (i == steps.length) {
            result.add(root);
        } else {
            for (Element child : doGetChildElements(rootsteps[i])) {
                doGetChildElements(childstepsi + 1, result);
            }
        }
    }
    private static List<ElementdoGetChildElements(Element parentString name) {
        List<Elementresult;
        NodeList nodes;
        int i;
        int max;
        Node node;
        Element element;
        result = new ArrayList<Element>();
        nodes = parent.getChildNodes();
        max = nodes.getLength();
        for (i = 0; i < maxi++) {
            node = nodes.item(i);
            if (node instanceof Element) {
                element = (Elementnode;
                if (name.equals(element.getTagName())) {
                    result.add((Elementnode);
                }
            }
        }
        return result;
    }
    //--
    
    public static String getString(Node node) {
        if (node instanceof Attr) {
            return ((Attrnode).getValue();
        } else if (node instanceof Element) {
            return Dom.getString((Elementnode);
        } else {
            throw new RuntimeException(node.getClass().getName());
        }
    }
    public static String getString(Element root) {
        StringBuilder buffer;
        NodeList nodes;
        int i;
        int max;
        Node node;
        
        buffer = new StringBuilder();
        nodes = root.getChildNodes();
        max = nodes.getLength();
        for (i = 0; i < maxi++) {
            node = nodes.item(i);
            if (node instanceof Text) {
                buffer.append(node.getNodeValue());
            } else {
          		throw new IllegalArgumentException(node.getClass().getName());
            }
        }
        return buffer.toString();
    }
    
    //--
    
    public static String getAttribute(Element elementString name) {
        String attr;
        
        attr = getAttributeOpt(elementname);
        if (attr == null) {
            throw new DomException("missing attribute '" + name + "' in element '" + element.getTagName() + "'");
        }
        return attr;
    }
    public static String getAttribute(Element elementString nameString deflt) {
        String attr;
        attr = Dom.getAttributeOpt(elementname);
        return attr == null ? deflt : attr;
    }
    public static String getAttributeOpt(Element elementString name) {
        Attr attr;
        
        attr = element.getAttributeNode(name);
        if (attr == null) {
            return null;
        }
        return attr.getValue();
    }
    
    //--
    
    public static void require(Element eleString expected) {
        String got;
        
        got = ele.getTagName();
        if (!expected.equals(ele.getTagName())) {
            throw new DomException("'" + expected + "' element expected, got '" + got + "'");
        }
    }
    
    public static void require(Node nodeString localNamespace namespace) {
        if (!Dom.matches(nodelocalnamespace)) {
        	throw new DomException("no such node in namespace " + namespace + ": " + local);
        }
    }
    //--
    
    public static boolean matches(Node nodeString requiredLocalNameNamespace requiredNamespace) {
        return hasNamespace(noderequiredNamespace) && matchingLocalName(noderequiredLocalName);
    }
    private static boolean hasNamespace(Node nodeNamespace requiredNamespace) {
        return requiredNamespace == null || requiredNamespace.hasUri(node.getNamespaceURI());
    }
    private static boolean matchingLocalName(Node nodeString requiredLocalName) {
        if (requiredLocalName == null) {
            return true;
        } else {
            String localName = node.getLocalName();
            return requiredLocalName.equals(localName);
        }
    }
New to GrepCode? Check out our FAQ X