Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.thaiopensource.validate.nrl;
  
 
 
 class SchemaImpl extends AbstractSchema {
   static private final String IMPLICIT_MODE_NAME = "#implicit";
   static private final String WRAPPER_MODE_NAME = "#wrapper";
   static final String NRL_URI = . + "nrl";
   private final Hashtable modeMap = new Hashtable();
   private Mode startMode;
   private final Mode defaultBaseMode;
   private final boolean attributesSchema;
 
   static private final class WrappedIOException extends RuntimeException {
     private final IOException exception;
 
     private WrappedIOException(IOException exception) {
       this. = exception;
     }
 
     private IOException getException() {
       return ;
     }
   }
 
   static private class MustSupportOption {
     private final String name;
     private final PropertyId pid;
     private final Locator locator;
 
     MustSupportOption(String namePropertyId pidLocator locator) {
       this. = name;
       this. = pid;
       this. = locator;
     }
   }
 
   private class Handler extends DelegatingContentHandler implements SchemaFuture {
     private final SchemaReceiverImpl sr;
     private boolean hadError = false;
     private final ErrorHandler eh;
     private final CountingErrorHandler ceh;
     private final Localizer localizer = new Localizer(SchemaImpl.class);
     private Locator locator;
     private final XmlBaseHandler xmlBaseHandler = new XmlBaseHandler();
     private int foreignDepth = 0;
     private Mode currentMode = null;
     private String defaultSchemaType;
     private Validator validator;
     private ElementsOrAttributes match;
     private ActionSet actions;
     private String schemaUri;
     private String schemaType;
     private PropertyMapBuilder options;
     private final Vector mustSupportOptions = new Vector();
     private ModeUsage modeUsage;
     private boolean anyNamespace;
 
     Handler(SchemaReceiverImpl sr) {
       this. = sr;
       this. = ..get(sr.getProperties());
       this. = new CountingErrorHandler(this.);
     }
 
     public void setDocumentLocator(Locator locator) {
       .setLocator(locator);
       this. = locator;
    }
    public void startDocument() throws SAXException {
      try {
        PropertyMapBuilder builder = new PropertyMapBuilder(.getProperties());
        ..put(builder);
         = .getNrlSchema().createValidator(builder.toPropertyMap());
      }
      catch (IOException e) {
        throw new WrappedIOException(e);
      }
      catch (IncorrectSchemaException e) {
        throw new RuntimeException("internal error in RNG schema for NRL");
      }
      if ( != null)
        super.setDocumentLocator();
      super.startDocument();
    }
    public Schema getSchema() throws IncorrectSchemaExceptionSAXException {
      if ( == null || .getHadErrorOrFatalError())
        throw new IncorrectSchemaException();
      Hashset openModes = new Hashset();
      Hashset checkedModes = new Hashset();
      for (Enumeration enum = .keys(); enum.hasMoreElements();) {
        String modeName = (String)enum.nextElement();
        Mode mode = (Mode).get(modeName);
        if (!mode.isDefined())
          error("undefined_mode"modeNamemode.getWhereUsed());
        for (Mode tem = modetem != nulltem = tem.getBaseMode()) {
          if (checkedModes.contains(tem))
            break;
          if (openModes.contains(tem)) {
            error("mode_cycle"tem.getName(), tem.getWhereDefined());
            break;
          }
          openModes.add(tem);
        }
        checkedModes.addAll(openModes);
        openModes.clear();
      }
      if ()
        throw new IncorrectSchemaException();
      return SchemaImpl.this;
    }
      if (e instanceof WrappedIOException)
        throw ((WrappedIOException)e).getException();
      return e;
    }
    public void startElement(String uriString localName,
                             String qNameAttributes attributes)
            throws SAXException {
      super.startElement(urilocalNameqNameattributes);
      String xmlBase = attributes.getValue(."base");
      if (xmlBase != null)
        .xmlBaseAttribute(xmlBase);
      if (!.equals(uri) ||  > 0) {
        ++;
        return;
      }
      if (.getHadErrorOrFatalError())
        return;
      if (localName.equals("rules"))
        parseRules(attributes);
      else if (localName.equals("mode"))
        parseMode(attributes);
      else if (localName.equals("namespace"))
        parseNamespace(attributes);
      else if (localName.equals("anyNamespace"))
        parseAnyNamespace(attributes);
      else if (localName.equals("validate"))
        parseValidate(attributes);
      else if (localName.equals("reject"))
        parseReject(attributes);
      else if (localName.equals("attach"))
        parseAttach(attributes);
      else if (localName.equals("unwrap"))
        parseUnwrap(attributes);
      else if (localName.equals("allow"))
        parseAllow(attributes);
      else if (localName.equals("context"))
        parseContext(attributes);
      else if (localName.equals("option"))
        parseOption(attributes);
      else
        throw new RuntimeException("unexpected element \"" + localName + "\"");
    }
    public void endElement(String namespaceURIString localName,
                           String qName)
            throws SAXException {
      super.endElement(namespaceURIlocalNameqName);
      if ( > 0) {
        --;
        return;
      }
      if (.getHadErrorOrFatalError())
        return;
      if (localName.equals("validate"))
        finishValidate();
    }
    private void parseRules(Attributes attributes) {
       = getModeAttribute(attributes"startMode");
      if ( == null) {
         = ;
        .noteDefined(null);
      }
      if () {
        Mode wrapper = lookupCreateMode();
        ActionSet actions = new ActionSet();
        actions.addNoResultAction(new AllowAction(new ModeUsage()));
        wrapper.bindElement(.actions);
        wrapper.noteDefined(null);
         = wrapper;
      }
       = getSchemaType(attributes);
    }
    private void parseMode(Attributes attributesthrows SAXException {
       = getModeAttribute(attributes"name");
      if (.isDefined()) {
        error("duplicate_mode".getName());
        error("first_mode".getName(), .getWhereDefined());
      }
      else {
        Mode base = getModeAttribute(attributes"extends");
        if (base != null)
          .setBaseMode(base);
      }
    }
    private void parseNamespace(Attributes attributesthrows SAXException {
       = false;
      parseRule(getNs(attributes), attributes);
    }
    private void parseAnyNamespace(Attributes attributesthrows SAXException {
       = true;
      parseRule(.attributes);
    }
    private void parseRule(String nsAttributes attributesthrows SAXException {
       = toElementsOrAttributes(attributes.getValue("""match"),
                                     .);
      if (.containsAttributes()) {
         = new AttributeActionSet();
        if (!.bindAttribute(ns)) {
          if (ns.equals(.))
            error("duplicate_attribute_action_any_namespace");
          else
            error("duplicate_attribute_action"ns);
        }
      }
      if (.containsElements()) {
         = new ActionSet();
        if (!.bindElement(ns)) {
          if (ns.equals(.))
            error("duplicate_element_action_any_namespace");
          else
            error("duplicate_element_action"ns);
        }
      }
      else
         = null;
    }
    private void parseValidate(Attributes attributesthrows SAXException {
       = getSchema(attributes);
       = getSchemaType(attributes);
      if ( == null)
         = ;
      if ( != null)
         = getModeUsage(attributes);
      else
         = null;
       = new PropertyMapBuilder();
    }
    private void finishValidate() throws SAXException {
      try {
        if ( != null) {
          Schema schema = createSubSchema(true);
          .addSchema(schema);
        }
        if ( != null) {
          Schema schema = createSubSchema(false);
          .addNoResultAction(new ValidateAction(schema));
        }
      }
      catch (IncorrectSchemaException e) {
         = true;
      }
      catch (IOException e) {
        throw new WrappedIOException(e);
      }
    }
    private Schema createSubSchema(boolean isAttributesSchemathrows IOExceptionIncorrectSchemaExceptionSAXException {
      PropertyMap requestedProperties = .toPropertyMap();
      Schema schema = .createChildSchema(new InputSource(),
                                           ,
                                           requestedProperties,
                                           isAttributesSchema);
      PropertyMap actualProperties = schema.getProperties();
      for (Enumeration enum = .elements(); enum.hasMoreElements();) {
        MustSupportOption mso = (MustSupportOption)enum.nextElement();
        Object actualValue = actualProperties.get(mso.pid);
        if (actualValue == null)
          error("unsupported_option"mso.namemso.locator);
        else if (!actualValue.equals(requestedProperties.get(mso.pid)))
          error("unsupported_option_arg"mso.namemso.locator);
      }
      return schema;
    }
    private void parseOption(Attributes attributesthrows SAXException {
      boolean mustSupport;
      String mustSupportValue = attributes.getValue("""mustSupport");
      if (mustSupportValue != null) {
        mustSupportValue = mustSupportValue.trim();
        mustSupport = mustSupportValue.equals("1") || mustSupportValue.equals("true");
      }
      else
        mustSupport = false;
      String name = Uri.resolve(attributes.getValue("""name"));
      Option option = .getOption(name);
      if (option == null) {
        if (mustSupport)
          error("unknown_option"name);
      }
      else {
        String arg = attributes.getValue("""arg");
        try {
          PropertyId pid = option.getPropertyId();
          Object value = option.valueOf(arg);
          Object oldValue = .get(pid);
          if (oldValue != null) {
            value = option.combine(new Object[]{oldValuevalue});
            if (value == null)
              error("duplicate_option"name);
            else
              .put(pidvalue);
          }
          else {
            .put(pidvalue);
            .addElement(new MustSupportOption(namepid,
                                                                 == null
                                                                ? null
                                                                : new LocatorImpl()));
          }
        }
        catch (OptionArgumentPresenceException e) {
          error(arg == null ? "option_requires_argument" : "option_unexpected_argument"name);
        }
        catch (OptionArgumentException e) {
          if (arg == null)
            error("option_requires_argument"name);
          else
            error("option_bad_argument"namearg);
        }
      }
    }
    private void parseAttach(Attributes attributes) {
      if ( != null)
        .setAttach(true);
      if ( != null) {
         = getModeUsage(attributes);
      }
      else
         = null;
    }
    private void parseUnwrap(Attributes attributes) {
      if ( != null) {
         = getModeUsage(attributes);
      }
      else
         = null;
    }
    private void parseAllow(Attributes attributes) {
      if ( != null) {
         = getModeUsage(attributes);
      }
      else
         = null;
    }
    private void parseReject(Attributes attributes) {
      if ( != null) {
         = getModeUsage(attributes);
      }
      else
         = null;
      if ( != null)
        .setReject(true);
    }
    private void parseContext(Attributes attributesthrows SAXException {
      if () {
        error("context_any_namespace");
        return;
      }
      Mode mode = getUseMode(attributes);
      try {
        Vector paths = Path.parse(attributes.getValue("""path"));
        // XXX warning if modeUsage is null
        if ( != null) {
          for (int i = 0, len = paths.size(); i < leni++) {
            Path path = (Path)paths.elementAt(i);
            if (!.addContext(path.isRoot(), path.getNames(), mode))
              error("duplicate_path"path.toString());
          }
        }
      }
      catch (Path.ParseException e) {
        error(e.getMessageKey());
      }
    }
    private String getSchema(Attributes attributesthrows SAXException {
      String schemaUri = attributes.getValue("""schema");
      if (Uri.hasFragmentId(schemaUri))
        error("schema_fragment_id");
      return Uri.resolve(.getBaseUri(),
                         Uri.escapeDisallowedChars(schemaUri));
    }
    private String getSchemaType(Attributes attributes) {
      return attributes.getValue("""schemaType");
    }
    private ElementsOrAttributes toElementsOrAttributes(String valueElementsOrAttributes defaultValue) {
      if (value == null)
        return defaultValue;
      if (value.indexOf("elements") >= 0)
        eoa = eoa.addElements();
      if (value.indexOf("attributes") >= 0)
        eoa = eoa.addAttributes();
      return eoa;
    }
    private ModeUsage getModeUsage(Attributes attributes) {
      return new ModeUsage(getUseMode(attributes), );
    }
    private Mode getUseMode(Attributes attributes) {
      Mode mode = getModeAttribute(attributes"useMode");
      if (mode == null)
        return .;
      mode.noteUsed();
      return mode;
    }
    private String getNs(Attributes attributesthrows SAXException {
      String ns = attributes.getValue("""ns");
      if (ns != null && !Uri.isAbsolute(ns) && !ns.equals(""))
        error("ns_absolute");
      return ns;
    }
    void error(String keythrows SAXException {
       = true;
      if ( == null)
        return;
    }
    void error(String keyString argthrows SAXException {
       = true;
      if ( == null)
        return;
      .error(new SAXParseException(.message(keyarg), ));
    }
    void error(String keyString argLocator locatorthrows SAXException {
       = true;
      if ( == null)
        return;
      .error(new SAXParseException(.message(keyarg), locator));
    }
    void error(String keyString arg1String arg2throws SAXException {
       = true;
      if ( == null)
        return;
      .error(new SAXParseException(.message(keyarg1arg2), ));
    }
  }
  SchemaImpl(PropertyMap properties) {
    super(properties);
    makeBuiltinMode("#allow"AllowAction.class);
    makeBuiltinMode("#attach"AttachAction.class);
    makeBuiltinMode("#unwrap"UnwrapAction.class);
     = makeBuiltinMode("#reject"RejectAction.class);
  }
  private Mode makeBuiltinMode(String nameClass cls) {
    Mode mode = lookupCreateMode(name);
    ActionSet actions = new ActionSet();
    ModeUsage modeUsage = new ModeUsage(.mode);
    if (cls == AttachAction.class)
      actions.setResultAction(new AttachAction(modeUsage));
    else if (cls == AllowAction.class)
      actions.addNoResultAction(new AllowAction(modeUsage));
    else if (cls == UnwrapAction.class)
      actions.setResultAction(new UnwrapAction(modeUsage));
    else
      actions.addNoResultAction(new RejectAction(modeUsage));
    mode.bindElement(.actions);
    mode.noteDefined(null);
    AttributeActionSet attributeActions = new AttributeActionSet();
    if ()
      attributeActions.setReject(true);
    else
      attributeActions.setAttach(true);
    mode.bindAttribute(.attributeActions);
    return mode;
  }
    Handler h = new Handler(sr);
    in.setContentHandler(h);
    return h;
  }
  public Validator createValidator(PropertyMap properties) {
    return new ValidatorImpl(properties);
  }
  private Mode getModeAttribute(Attributes attributesString localName) {
    return lookupCreateMode(attributes.getValue(""localName));
  }
  private Mode lookupCreateMode(String name) {
    if (name == null)
      return null;
    name = name.trim();
    Mode mode = (Mode).get(name);
    if (mode == null) {
      mode = new Mode(name);
      .put(namemode);
    }
    return mode;
  }
New to GrepCode? Check out our FAQ X