Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.thaiopensource.validate.nrl;
  
 
 
 class ValidatorImpl extends DefaultHandler implements Validator {
   private static final String BEARER_URI = "";
   private static final String BEARER_LOCAL_NAME = "#bearer";
   private static final String NO_NS = "\0";
   private final ErrorHandler eh;
   private final PropertyMap properties;
   private Locator locator;
   private Section currentSection;
   private PrefixMapping prefixMapping = null;
   private final Hashtable validatorHandlerCache = new Hashtable();
   private final Localizer localizer = new Localizer(ValidatorImpl.class);
   private final Hashset noResultActions = new Hashset();
   private final Hashtable attributeNamespaceIndexSets = new Hashtable();
   private final Vector activeHandlersAttributeIndexSets = new Vector();
   private final Hashset attributeSchemas = new Hashset();
   private boolean attributeNamespaceRejected;
   private final Mode startMode;
 
   static private class PrefixMapping {
     final String prefix;
     final String uri;
     final PrefixMapping parent;
 
     PrefixMapping(String prefixString uriPrefixMapping parent) {
       this. = prefix;
       this. = uri;
       this. = parent;
     }
   }
 
   private class Section implements SectionState {
     final Section parent;
    
Namespace of this section. Empty string for absent.
 
     final String ns;
    
Number of open elements in this section.
 
     int depth = 0;
    
List of the Validators rooted in this section
 
     final Vector validators = new Vector();
     final Vector schemas = new Vector();
    
List of the ContentHandlers that want to see the elements in this section
 
     final Vector activeHandlers = new Vector();
     final Vector activeHandlersAttributeModeUsage = new Vector();
     final Vector attributeValidationModeUsages = new Vector();
    
List of Programs saying what to do with child sections
 
     final Vector childPrograms = new Vector();
     final Stack context = new Stack();
     boolean contextDependent = false;
 
     Section(String nsSection parent) {
       this. = ns;
       this. = parent;
     }
 
     public void addChildMode(ModeUsage modeUsageContentHandler handler) {
       .addElement(new Program(modeUsagehandler));
       if (modeUsage.isContextDependent())
         = true;
    }
    public void addValidator(Schema schemaModeUsage modeUsage) {
      .addElement(schema);
      Validator validator = createValidator(schema);
      .addElement(validator);
                                     modeUsage.getAttributeProcessing());
      .addElement(new Program(modeUsagevalidator.getContentHandler()));
      if (modeUsage.isContextDependent())
         = true;
    }
    public void addActiveHandler(ContentHandler handlerModeUsage attributeModeUsage) {
      .addElement(handler);
      .addElement(attributeModeUsage);
                                     attributeModeUsage.getAttributeProcessing());
      if (attributeModeUsage.isContextDependent())
         = true;
    }
    public void addAttributeValidationModeUsage(ModeUsage modeUsage) {
      int ap = modeUsage.getAttributeProcessing();
      if (ap != .) {
        .addElement(modeUsage);
         = Math.max(ap);
        if (modeUsage.isContextDependent())
           = true;
      }
    }
    public void reject() throws SAXException {
      if ( != null)
        .error(new SAXParseException(.message("reject_element"),
                                       ));
    }
  }
  static private class Program {
    final ModeUsage modeUsage;
    final ContentHandler handler;
    Program(ModeUsage modeUsageContentHandler handler) {
      this. = modeUsage;
      this. = handler;
    }
  }
  ValidatorImpl(Mode modePropertyMap properties) {
    this. = properties;
    this. = ..get(properties);
    this. = mode;
  }
  private void initCurrentSection() {
     = new Section(null);
  }
  public void setDocumentLocator(Locator locator) {
    this. = locator;
  }
  public void characters(char ch[], int startint length)
          throws SAXException {
    for (int i = 0, len = ..size(); i < leni++)
      ((ContentHandler)(..elementAt(i))).characters(chstartlength);
  }
  public void ignorableWhitespace(char ch[], int startint length)
          throws SAXException {
    for (int i = 0, len = ..size(); i < leni++)
  }
  public void startElement(String uriString localName,
                           String qNameAttributes attributes)
          throws SAXException {
    if (!uri.equals(.))
      startSection(uri);
      ..push(localName);
    boolean transformAttributes = processAttributes(attributes);
    for (int i = 0, len = ..size(); i < leni++) {
      handler.startElement(urilocalNameqName,
                           transformAttributes
                           ? filterAttributes((IntSet).elementAt(i),
                                              attributes)
                           : attributes);
    }
  }
  private static Attributes filterAttributes(IntSet indexSetAttributes attributes) {
    if (indexSet.size() == attributes.getLength())
      return attributes;
    return new FilteredAttributes(indexSetattributes);
  }
  private boolean processAttributes(Attributes attributesthrows SAXException {
        || attributes.getLength() == 0)
      return false;
    for (int i = 0, len = attributes.getLength(); i < leni++) {
      String ns = attributes.getURI(i);
      IntSet indexSet = (IntSet).get(ns);
      if (indexSet == null) {
        indexSet = new IntSet();
        .put(nsindexSet);
      }
      indexSet.add(i);
    }
        && .size() == 1
        && .get("") != null)
      return false;
    for (int i = 0, len = handlerModes.size(); i < leni++)
    boolean transform = false;
      String ns = (String)e.nextElement();
      IntSet indexSet = (IntSet).get(ns);
      .clear();
       = null;
       = false;
      for (int i = 0, len = handlerModes.size(); i < leni++) {
        ModeUsage modeUsage = (ModeUsage)handlerModes.elementAt(i);
        AttributeActionSet actions = processAttributeSection(modeUsagensindexSetattributes);
        if (actions.getAttach())
          ((IntSet).get(i)).addAll(indexSet);
        else
          transform = true;
      }
      for (int i = 0, len = validationModes.size(); i < leni++) {
        ModeUsage modeUsage = (ModeUsage)validationModes.elementAt(i);
        processAttributeSection(modeUsagensindexSetattributes);
      }
    }
    return transform;
  }
                                                     String ns,
                                                     IntSet indexSet,
                                                     Attributes attributes)
          throws SAXException {
    Mode mode = modeUsage.getMode(.);
    AttributeActionSet actions = mode.getAttributeActions(ns);
    if (actions.getReject() && !) {
       = true;
      if ( != null)
        .error(new SAXParseException(.message("reject_attribute"ns),
                                       ));
    }
    Schema[] schemas = actions.getSchemas();
    for (int j = 0; j < schemas.lengthj++) {
      if (.contains(schemas[j]))
        continue;
      .add(schemas[j]);
      if ( == null)
         = filterAttributes(indexSetattributes);
      validateAttributes(schemas[j], );
    }
    return actions;
  }
  private void validateAttributes(Schema schemaAttributes attributesthrows SAXException {
    Validator validator = createValidator(schema);
    ContentHandler ch = validator.getContentHandler();
    initHandler(ch);
    cleanupHandler(ch);
    releaseValidator(schemavalidator);
  }
  private void startSection(String urithrows SAXException {
    Section section = new Section(uri);
    Vector childPrograms = .;
    for (int i = 0, len = childPrograms.size(); i < leni++) {
      Program program = (Program)childPrograms.elementAt(i);
      ActionSet actions = program.modeUsage.getMode(.).getElementActions(uri);
      ResultAction resultAction = actions.getResultAction();
      if (resultAction != null)
        resultAction.perform(program.handlersection);
      NoResultAction[] nra = actions.getNoResultActions();
      for (int j = 0; j < nra.lengthj++) {
        NoResultAction tem = nra[j];
        if (!.contains(tem)) {
          nra[j].perform(section);
          .add(tem);
        }
      }
    }
    for (int i = 0, len = section.validators.size(); i < leni++)
      initHandler(((Validator)section.validators.elementAt(i)).getContentHandler());
     = section;
  }
  private void initHandler(ContentHandler chthrows SAXException {
    if ( != null)
    ch.startDocument();
    for (PrefixMapping pm = pm != nullpm = pm.parent)
      ch.startPrefixMapping(pm.prefixpm.uri);
  }
  public void endElement(String uriString localNameString qName)
          throws SAXException {
    for (int i = 0, len = ..size(); i < leni++)
      ((ContentHandler)(..elementAt(i))).endElement(urilocalNameqName);
    if (. == 0)
      endSection();
  }
  private void endSection() throws SAXException {
    for (int i = 0, len = ..size(); i < leni++) {
      Validator validator = (Validator)..elementAt(i);
      cleanupHandler(validator.getContentHandler());
      // endDocument() on one of the validators may throw an exception
      // in this case we don't want to release the validator twice
    }
  }
  private void cleanupHandler(ContentHandler vhthrows SAXException {
    for (PrefixMapping pm = pm != nullpm = pm.parent)
      vh.endPrefixMapping(pm.prefix);
    vh.endDocument();
  }
  public void endDocument()
          throws SAXException {
  }
  public void startPrefixMapping(String prefixString uri)
          throws SAXException {
    super.startPrefixMapping(prefixuri);
     = new PrefixMapping(prefixuri);
  }
  public void endPrefixMapping(String prefix)
          throws SAXException {
    super.endPrefixMapping(prefix);
  }
  private Validator createValidator(Schema schema) {
    Stack stack = (Stack).get(schema);
    if (stack == null) {
      stack = new Stack();
      .put(schemastack);
    }
    if (stack.empty())
      return schema.createValidator();
    return (Validator)stack.pop();
  }
  private void releaseValidator(Schema schemaValidator vh) {
    if (vh == null)
      return;
    vh.reset();
    ((Stack).get(schema)).push(vh);
  }
  public void reset() {
    for (;  != null = .) {
      for (int i = 0, len = ..size(); i < leni++)
                         (Validator)..elementAt(i));
    }
  }
    return this;
  }
  public DTDHandler getDTDHandler() {
    return this;
  }
New to GrepCode? Check out our FAQ X