Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (c) 2007-2008 Mozilla Foundation
   *
   * Permission is hereby granted, free of charge, to any person obtaining a 
   * copy of this software and associated documentation files (the "Software"), 
   * to deal in the Software without restriction, including without limitation 
   * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
   * and/or sell copies of the Software, and to permit persons to whom the 
   * Software is furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included in 
  * all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
  * DEALINGS IN THE SOFTWARE.
  */
 
 package nu.validator.xml;
 
 import java.util.Set;
 
This does not extend XMLFilterImpl, because XMLFilterImpl constructor overwrites handlers on the wrapped XMLReader.

Author(s):
hsivonen
Version:
$Id$
 
 public final class NamespaceDroppingXMLReaderWrapper implements XMLReaderContentHandler {
 
     private final static String[] ARRAY_TYPE = new String[0];
 
     private static String[] toInternedArray(Set<Stringset) {
         String[] rv = set.toArray();
         for (int i = 0; i < rv.lengthi++) {
             rv[i] = rv[i].intern();
         }
         return rv;
     }
 
     private final XMLReader wrappedReader;
     
     private final String[] namespacesToRemove;
 
     private ContentHandler contentHandler;
     
     private int depth;
 
     private boolean alreadyWarnedAboutForeign;
 
     private boolean alreadyWarnedAboutFiltering;
 
     private boolean rootSeen;
 
     private Locator locator = null;
 
     public NamespaceDroppingXMLReaderWrapper(XMLReader wrappedReader,
             Set<StringnamespacesToRemove) {
         this. = wrappedReader;
         this. = toInternedArray(namespacesToRemove);
         this. = wrappedReader.getContentHandler();
         wrappedReader.setContentHandler(this);
     }

    
 
     public void characters(char[] chint startint length)
             throws SAXException {
         if ( == 0) {
             .characters(chstartlength);
         }
     }

    
 
     public void endElement(String uriString localNameString qName)
            throws SAXException {
        if ( == 0) {
            .endElement(urilocalNameqName);
        } else {
            --;
        }
    }

    
    public void startDocument() throws SAXException {
         = 0;
         = false;
         = false;
         = false;
        .startDocument();
    }

    
    public void startElement(String uriString localNameString qName,
            Attributes attsthrows SAXException {
        if ( == 0) {
            if (isInNamespacesToRemove(uri)) {
                if () {
                     = 1;
                    if (!) {
                        warning(new SAXParseException(
                                "Content is being hidden from the validator based on namespace filtering.",
                                ));
                         = true;
                    }
                } else {
                    warning(new SAXParseException(
                            "Cannot filter out the root element."));
                    .startElement(urilocalNameqName,
                            filterAttributes(atts));
                }
            } else {
                .startElement(urilocalNameqName,
                        filterAttributes(atts));
            }
        } else {
            if (! && !isInNamespacesToRemove(uri)) {
                warning(new SAXParseException(
                        "Filtering out selected namespaces causes descendants in other namespaces to be dropped as well.",
                        ));
                 = true;
            }
            ++;
        }
         = true;
    }
    private void warning(SAXParseException exceptionthrows SAXException {
        .getErrorHandler().warning(exception);
    }
    private Attributes filterAttributes(Attributes attsthrows SAXException {
        int length = atts.getLength();
        int i = 0;
        while (i < length) {
            if (isInNamespacesToRemove(atts.getURI(i))) {
                if (!) {
                    warning(new SAXParseException(
                            "Content is being hidden from the validator based on namespace filtering.",
                            ));
                     = true;
                }
                AttributesImpl rv = new AttributesImpl();
                for (int j = 0; j < ij++) {
                    rv.addAttribute(atts.getURI(j), atts.getLocalName(j),
                            atts.getQName(j), atts.getType(j), atts.getValue(j));
                }
                i++;
                while (i < length) {
                    String uri = atts.getURI(i);
                    if (!isInNamespacesToRemove(uri)) {
                        rv.addAttribute(uriatts.getLocalName(i),
                                atts.getQName(i), atts.getType(i),
                                atts.getValue(i));
                    }
                    i++;
                }
                return rv;
            }
            i++;
        }
        return atts;
    }
    private boolean isInNamespacesToRemove(String uri) {
        for (int i = 0; i < .i++) {
            if (uri == [i]) {
                return true;
            }
        }
        return false;
    }

    
    public void setDocumentLocator(Locator locator) {
        this. = locator;
        .setDocumentLocator(locator);
    }
    public ContentHandler getContentHandler() {
        return ;
    }

    
    public void endDocument() throws SAXException {
        .endDocument();
    }

    
    public void endPrefixMapping(String prefixthrows SAXException {
        .endPrefixMapping(prefix);
    }

    
    public void ignorableWhitespace(char[] chint startint lengththrows SAXException {
        .ignorableWhitespace(chstartlength);
    }

    
    public void processingInstruction(String targetString datathrows SAXException {
        .processingInstruction(targetdata);
    }

    
    public void skippedEntity(String namethrows SAXException {
        .skippedEntity(name);
    }

    
    public void startPrefixMapping(String prefixString urithrows SAXException {
        .startPrefixMapping(prefixuri);
    }

    
    public DTDHandler getDTDHandler() {
        return .getDTDHandler();
    }

    
    public EntityResolver getEntityResolver() {
        return .getEntityResolver();
    }

    
    public ErrorHandler getErrorHandler() {
        return .getErrorHandler();
    }

    
    public boolean getFeature(String namethrows SAXNotRecognizedExceptionSAXNotSupportedException {
        return .getFeature(name);
    }

    
        return .getProperty(name);
    }

    
    public void parse(InputSource inputthrows IOExceptionSAXException {
        .parse(input);
    }

    
    public void parse(String systemIdthrows IOExceptionSAXException {
        .parse(systemId);
    }

    
    public void setContentHandler(ContentHandler handler) {
         = handler;
    }

    
    public void setDTDHandler(DTDHandler handler) {
        .setDTDHandler(handler);
    }

    
    public void setEntityResolver(EntityResolver resolver) {
        .setEntityResolver(resolver);
    }

    
    public void setErrorHandler(ErrorHandler handler) {
        .setErrorHandler(handler);
    }

    
    public void setFeature(String nameboolean valuethrows SAXNotRecognizedExceptionSAXNotSupportedException {
        .setFeature(namevalue);
    }

    
    public void setProperty(String nameObject valuethrows SAXNotRecognizedExceptionSAXNotSupportedException {
        .setProperty(namevalue);
    }
New to GrepCode? Check out our FAQ X