Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.thaiopensource.validate.schematron;
  
 
 
 class SchemaReaderImpl implements SchemaReader {
   static final String SCHEMATRON_URI = "http://www.ascc.net/xml/schematron";
   private static final String LOCATION_URI = "http://www.thaiopensource.com/ns/location";
   private static final String ERROR_URI = "http://www.thaiopensource.com/ns/error";
   private final Localizer localizer = new Localizer(SchemaReaderImpl.class);
 
   private final Class transformerFactoryClass;
   private final Templates schematron;
   private final Schema schematronSchema;
   private static final String SCHEMATRON_SCHEMA = "schematron.rnc";
   private static final String SCHEMATRON_STYLESHEET = "schematron.xsl";
   private static final PropertyId[] supportedPropertyIds = {
   };
 
     this. = transformerFactory.getClass();
     String resourceName = fullResourceName();
     StreamSource source = new StreamSource(getResourceAsStream(resourceName));
     initTransformerFactory(transformerFactory);
      = transformerFactory.newTemplates(source);
     PropertyMapBuilder builder = new PropertyMapBuilder();
     ..add(builder);
     try {
        = CompactSchemaReader.getInstance().createSchema(schemaSourcebuilder.toPropertyMap());
     }
     catch (SAXException e) {
       throw new IncorrectSchemaException();
     }
     catch (IOException e) {
       throw new IncorrectSchemaException();
     }
   }
 
   public Option getOption(String uri) {
     return SchematronProperty.getOption(uri);
   }
 
   private void initTransformerFactory(TransformerFactory factory) {
     String name = factory.getClass().getName();
     try {
       if (name.equals("com.icl.saxon.TransformerFactoryImpl"))
         factory.setAttribute("http://icl.com/saxon/feature/linenumbering",
                              .);
       else if (name.equals("org.apache.xalan.processor.TransformerFactoryImpl")) {
         // Try both the documented URI and the URI that the code expects.
         try {
           // This is the URI that the code expects.
           factory.setAttribute("http://xml.apache.org/xalan/properties/source-location",
                                .);
         }
         catch (IllegalArgumentException e) {
           // This is the URI that's documented.
          factory.setAttribute("http://apache.org/xalan/features/source_location",
                               .);
        }
      }
    }
    catch (IllegalArgumentException e) {
    }
  }
  static class ValidateStage extends XMLReaderImpl {
    private final ContentHandler validator;
    private final XMLReader reader;
    private final CountingErrorHandler ceh;
    ValidateStage(XMLReader readerValidator validatorCountingErrorHandler ceh) {
      this. = reader;
      this. = validator.getContentHandler();
      this. = ceh;
    }
    public void parse(InputSource input)
            throws SAXExceptionIOException {
      .parse(input);
      if (.getHadErrorOrFatalError())
        throw new SAXException(new IncorrectSchemaException());
    }
    public void setContentHandler(ContentHandler handler) {
      this. = handler;
    }
    public ContentHandler getContentHandler() {
      return ;
    }
  }
  static class UserException extends Exception {
    private final SAXException exception;
    UserException(SAXException exception) {
      this. = exception;
    }
      return ;
    }
  }
  static class UserWrapErrorHandler extends CountingErrorHandler {
    UserWrapErrorHandler(ErrorHandler errorHandler) {
      super(errorHandler);
    }
    public void warning(SAXParseException exception)
            throws SAXException {
      try {
        super.warning(exception);
      }
      catch (SAXException e) {
        throw new SAXException(new UserException(e));
      }
    }
    public void error(SAXParseException exception)
            throws SAXException {
      try {
        super.error(exception);
      }
      catch (SAXException e) {
        throw new SAXException(new UserException(e));
      }
    }
    public void fatalError(SAXParseException exception)
            throws SAXException {
      try {
        super.fatalError(exception);
      }
      catch (SAXException e) {
        throw new SAXException(new UserException(e));
      }
    }
  }
  static class ErrorFilter extends DelegatingContentHandler {
    private final ErrorHandler eh;
    private final Localizer localizer;
    private Locator locator;
    ErrorFilter(ContentHandler delegateErrorHandler ehLocalizer localizer) {
      super(delegate);
      this. = eh;
      this. = localizer;
    }
    public void setDocumentLocator(Locator locator) {
      this. = locator;
      super.setDocumentLocator(locator);
    }
    public void startElement(String namespaceURIString localName,
                             String qNameAttributes atts)
            throws SAXException {
      if (namespaceURI.equals() && localName.equals("error"))
        .error(new SAXParseException(.message(atts.getValue("""message"),
                                                         atts.getValue("""arg")),
                                       ));
      super.startElement(namespaceURIlocalNameqNameatts);
    }
  }
  static class LocationFilter extends DelegatingContentHandler implements Locator {
    private final String systemId;
    private int lineNumber = -1;
    private SAXException exception = null;
    LocationFilter(ContentHandler delegateString systemId) {
      super(delegate);
      this. = systemId;
    }
      return ;
    }
    public void setDocumentLocator(Locator locator) {
    }
    public void startDocument()
            throws SAXException {
      getDelegate().setDocumentLocator(this);
      super.startDocument();
    }
    public void startElement(String namespaceURIString localName,
                             String qNameAttributes atts)
            throws SAXException {
      String value = atts.getValue("line-number");
      if (value != null) {
        try {
           = Integer.parseInt(value);
        }
        catch (NumberFormatException e) {
           = -1;
        }
      }
      else
         = -1;
      try {
        super.startElement(namespaceURIlocalNameqNameatts);
      }
      catch (SAXException e) {
        this. = e;
        setDelegate(null);
      }
       = -1;
    }
    public String getPublicId() {
      return null;
    }
    public String getSystemId() {
      return ;
    }
    public int getLineNumber() {
      return ;
    }
    public int getColumnNumber() {
      return -1;
    }
  }
  static class TransformStage extends XMLReaderImpl {
    private final Transformer transformer;
    private final SAXSource transformSource;
    private final String systemId;
    private final CountingErrorHandler ceh;
    private final Localizer localizer;
    TransformStage(Transformer transformerSAXSource transformSourceString systemId,
                   CountingErrorHandler cehLocalizer localizer) {
      this. = transformer;
      this. = transformSource;
      this. = systemId;
      this. = ceh;
      this. = localizer;
    }
    public void parse(InputSource input)
            throws IOExceptionSAXException {
      try {
        LocationFilter handler = new LocationFilter(new ErrorFilter(),
                                                                    );
        .transform(new SAXResult(handler));
        SAXException exception = handler.getException();
        if (exception != null)
          throw exception;
      }
      catch (TransformerException e) {
        if (e.getException() instanceof IOException)
          throw (IOException)e.getException();
        throw ValidatorImpl.toSAXException(e);
      }
      if (.getHadErrorOrFatalError())
        throw new SAXException(new IncorrectSchemaException());
    }
    public ContentHandler getContentHandler() {
      return ;
    }
    public void setContentHandler(ContentHandler contentHandler) {
      this. = contentHandler;
    }
  }
  static class SAXErrorListener implements ErrorListener {
     private final ErrorHandler eh;
     private final String systemId;
     private boolean hadError = false;
     SAXErrorListener(ErrorHandler ehString systemId) {
       this. = eh;
       this. = systemId;
     }
     boolean getHadError() {
       return ;
     }
     public void warning(TransformerException exception)
             throws TransformerException {
       SAXParseException spe = transform(exception);
       try {
         .warning(spe);
       }
       catch (SAXException e) {
         throw new TransformerException(new UserException(e));
       }
     }
     public void error(TransformerException exception)
             throws TransformerException {
        = true;
       SAXParseException spe = transform(exception);
       try {
         .error(spe);
       }
       catch (SAXException e) {
         throw new TransformerException(new UserException(e));
       }
     }
     public void fatalError(TransformerException exception)
             throws TransformerException {
        = true;
       SAXParseException spe = transform(exception);
       try {
         .fatalError(spe);
       }
       catch (SAXException e) {
         throw new TransformerException(new UserException(e));
       }
     }
       Throwable cause = exception.getException();
       // Xalan takes it upon itself to catch exceptions and pass them to the ErrorListener.
       if (cause instanceof RuntimeException)
         throw (RuntimeException)cause;
       if (cause instanceof SAXException
           || cause instanceof IncorrectSchemaException
           || cause instanceof IOException)
         throw exception;
       SourceLocator locator = exception.getLocator();
       if (locator == null)
         return new SAXParseException(exception.getMessage(), null);
       // Xalan sometimes loses the systemId; work around this.
       String s = locator.getSystemId();
       if (s == null)
        s = ;
       return new SAXParseException(exception.getMessage(),
                                    null,
                                    s,
                                    locator.getLineNumber(),
                                    -1);
     }
   }
  public Schema createSchema(InputSource inPropertyMap properties)
          throws IOExceptionSAXExceptionIncorrectSchemaException {
    ErrorHandler eh = ..get(properties);
    SAXErrorListener errorListener = new SAXErrorListener(ehin.getSystemId());
    UserWrapErrorHandler ueh1 = new UserWrapErrorHandler(eh);
    UserWrapErrorHandler ueh2 = new UserWrapErrorHandler(eh);
    try {
      PropertyMapBuilder builder = new PropertyMapBuilder(properties);
      ..put(builderueh1);
      SAXSource source = createValidatingSource(inbuilder.toPropertyMap(), ueh1);
      source = createTransformingSource(source,
                                        ..get(properties),
                                        properties.contains(.),
                                        in.getSystemId(),
                                        ueh2);
      initTransformerFactory(transformerFactory);
      transformerFactory.setErrorListener(errorListener);
      Templates templates = transformerFactory.newTemplates(source);
      return new SchemaImpl(templatesproperties);
    }
      throw toSAXException(eerrorListener.getHadError()
                              || ueh1.getHadErrorOrFatalError()
                              || ueh2.getHadErrorOrFatalError());
    }
    catch (InstantiationException e) {
      throw new SAXException(e);
    }
    catch (IllegalAccessException e) {
      throw new SAXException(e);
    }
  }
    Validator validator = .createValidator(properties);
    XMLReader xr = xrc.createXMLReader();
    xr.setErrorHandler(ceh);
    return new SAXSource(new ValidateStage(xrvalidatorceh), in);
  }
  private SAXSource createTransformingSource(SAXSource inString phaseboolean diagnose,
                                             String systemIdCountingErrorHandler cehthrows SAXException {
    try {
      Transformer transformer = .newTransformer();
      transformer.setErrorListener(new DraconianErrorListener());
      if (phase != null)
        transformer.setParameter("phase"phase);
      if (diagnose)
        transformer.setParameter("diagnose".);
      return new SAXSource(new TransformStage(transformerinsystemIdceh),
                           new InputSource(systemId));
    }
      throw new SAXException(e);
    }
  }
  private SAXException toSAXException(TransformerException eboolean hadErrorthrows IOExceptionIncorrectSchemaException {
      return causeToSAXException(e.getException(), hadError);
    }
  private SAXException causeToSAXException(Throwable causeboolean hadErrorthrows IOExceptionIncorrectSchemaException {
      if (cause instanceof RuntimeException)
        throw (RuntimeException)cause;
      if (cause instanceof IOException)
        throw (IOException)cause;
      if (cause instanceof IncorrectSchemaException)
        throw (IncorrectSchemaException)cause;
      if (cause instanceof SAXException)
        return causeToSAXException(((SAXException)cause).getException(), hadError);
      if (cause instanceof TransformerException)
        return toSAXException((TransformerException)causehadError);
      if (cause instanceof UserException)
        return toSAXException((UserException)cause);
      if (hadError)
        throw new IncorrectSchemaException();
      return new SAXException(.message("unexpected_schema_creation_error"),
                              cause instanceof Exception ? (Exception)cause : null);
    }
      SAXException se = e.getException();
      Exception cause = se.getException();
      if (cause instanceof IncorrectSchemaException)
        throw (IncorrectSchemaException)cause;
      if (cause instanceof IOException)
        throw (IOException)cause;
      return se;
    }
  private static String fullResourceName(String name) {
    String className = SchemaReaderImpl.class.getName();
    return className.substring(0, className.lastIndexOf('.')).replace('.''/') + "/resources/" + name;
  }
  private static InputStream getResourceAsStream(String resourceName) {
    // XXX see if we should borrow 1.2 code from Service
    if (cl == null)
      return ClassLoader.getSystemResourceAsStream(resourceName);
    else
      return cl.getResourceAsStream(resourceName);
  }
New to GrepCode? Check out our FAQ X