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.io.Reader;
Wraps xml parser to implement the method signatures we need
 
 
 public class Builder {
     private final DocumentBuilder builder;

    
Create a non-validating builder
 
     public Builder() {
         this. = createDocumentBuilder();
     }

    
Create a validating builder
 
     public Builder(net.sf.beezle.sushi.fs.Node schemathrows IOExceptionSAXException {
         this. = createValidatingDocumentBuilder(schema);
     }

    
This method is not called "parse" to avoid confusion with file parsing methods
 
     public Document parseString(String textthrows SAXException {
         try {
             return parse(new InputSource(new StringReader(text)));
         } catch (IOException e) {
             throw new RuntimeException("unexpected world exception while reading memory stream"e);
         }
     }

    
asserts a valid document
 
     public Document literal(String text) {
         try {
             return parseString(text);        
         } catch (SAXException e) {
             throw new RuntimeException(texte);
         }
     }
 
     public Document parse(net.sf.beezle.sushi.fs.Node nodethrows SAXExceptionIOException {
         InputStream stream;
         InputSource src;
         Document doc;
         
         stream = node.createInputStream();
         src = new InputSource();
         src.setSystemId(node.toString());
         src.setByteStream(stream);
         doc = parse(src);
         stream.close();
         return doc;
     }
     
     public Document parse(Reader readerthrows SAXExceptionIOException {
         return parse(new InputSource(reader));
     }
 
     public Document parse(InputStream streamthrows SAXExceptionIOException {
         return parse(new InputSource(stream));
     }
 
     public Document parse(InputSource srcthrows SAXExceptionIOException {
         return .parse(src);
     }
 
     //--
     
    public Document createDocument() {
        return .newDocument();
    }
    public Document createDocument(String name) {
    	return createDocument(namenull);
    }
    public Document createDocument(String nameNamespace namespace) {
        Document doc;
        
        doc = createDocument();
        doc.appendChild(standaloneElement(docnamenamespace));
        return doc;
    }
    
    //-- create methods 
    
    public static void add(Element parentNodeList list) {
        int size;
        int i;
        size = list.getLength();
        for (i = 0; i < sizei++) {
            addNode(parentlist.item(i));
        }
        
    }
    
    public static Element add(Element parentElement child) {
        return (ElementaddNode(parentchild);
    }
    public static Node addNode(Element parentNode child) {
        Document doc;
        
        doc = parent.getOwnerDocument();
        child = doc.importNode(childtrue);
        parent.appendChild(child);
        return child;
    }
    
    

Returns:
newly created element
    public static Element element(Element parentString name) {
    	return element(parentnamenull);
    }

    

Returns:
newly created element
    public static Element element(Element parentString nameNamespace namespace) {
        Element result;
        
        result = standaloneElement(parent.getOwnerDocument(), namenamespace);
        parent.appendChild(result);
        return result;
    }
	public static Element standaloneElement(Document docString nameNamespace namespace) {
		if (namespace != null) {
            String prefixname = 
            	..equals(namespace) || ..getPrefix().equals(namespace.getPrefix()) ?
                 name : namespace.getPrefix() + ":" + name;
            return doc.createElementNS(namespace.getUri(), prefixname);
        } else {
            return doc.createElement(name);
        }
	}
    
    public static Text text(Element parentString content) {
        Document doc;
        Text result;
        
        doc = parent.getOwnerDocument();
        result = doc.createTextNode(content);
        parent.appendChild(result);
        return result;
    }
    public static Text textElement(Element parentString nameString content) {
        return textElement(parentnamenullcontent);
    }
    public static Text textElement(Element parentString nameNamespace namespaceString content) {
        return text(element(parentnamenamespace), content);
    }
    public static void clear(Element root) {
        Node child;
        
        while (true) {
            child = root.getFirstChild();
            if (child == null) {
                break;
            }
            root.removeChild(child);
        }
    }
    
    //-- document builder
    
    public static synchronized DocumentBuilder createDocumentBuilder() {
        DocumentBuilder result;
        try {
            result = .newDocumentBuilder();
        } catch (ParserConfigurationException e) {
            throw new RuntimeException("createDocumentBuilder failed"e);
        }
        result.setErrorHandler();
        return result;
    }
        DocumentBuilderFactory factory;
        DocumentBuilder builder;
        factory = Factories.document(schema);
        try {
            builder = factory.newDocumentBuilder();
        } catch (ParserConfigurationException e) {
            throw new RuntimeException(e);
        }
        builder.setErrorHandler();
        return builder;
    }
    public static SAXParser createValidatingSAXParser(net.sf.beezle.sushi.fs.Node schemathrows IOException {
        return Factories.saxParser(schema);
    }
    public static SAXParser createSAXParser() {
        return Factories.saxParser();
    }
    // TODO: avoid problems with old xerces versions in classpath
    private static final DocumentBuilderFactory FACTORY_NON_VALIDATING;
    private static final ErrorHandler ERROR_HANDLER;
    
    static {
         = Factories.document();
        if (!.isNamespaceAware()) {
            .setNamespaceAware(true);
        }
        if (.isValidating()) {
            .setValidating(false);
        }
        
         = new ErrorHandler() {
            public void error(SAXParseException exceptionthrows SAXException {
                report(exception);
            }
            public void fatalError(SAXParseException exceptionthrows SAXException {
                report(exception);
            }
            public void warning(SAXParseException exceptionthrows SAXException {
                report(exception);
            }
            private void report(SAXParseException exceptionthrows SAXException {
                throw exception;
            }
        };
    }
New to GrepCode? Check out our FAQ X