Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.thaiopensource.relaxng.impl;
  
  
 
 
 public class IdTypeMapBuilder {
   private boolean hadError;
   private final ErrorHandler eh;
   private final PatternFunction idTypeFunction = new IdTypeFunction();
   private final IdTypeMapImpl idTypeMap = new IdTypeMapImpl();
   private final Hashtable elementProcessed = new Hashtable();
   private final Vector possibleConflicts = new Vector();
 
   private void notePossibleConflict(NameClass elementNameClassNameClass attributeNameClassLocator loc) {
     .addElement(new PossibleConflict(elementNameClassattributeNameClassloc));
   }
 
   private static class WrappedSAXException extends RuntimeException {
     private final SAXException cause;
     WrappedSAXException(SAXException cause) {
       this. = cause;
     }
   }
 
   private static class PossibleConflict {
     private final NameClass elementNameClass;
     private final NameClass attributeNameClass;
     private final Locator locator;
 
     private PossibleConflict(NameClass elementNameClassNameClass attributeNameClassLocator locator) {
       this. = elementNameClass;
       this. = attributeNameClass;
       this. = locator;
     }
   }
 
   private static class ScopedName {
     private final Name elementName;
     private final Name attributeName;
 
     private ScopedName(Name elementNameName attributeName) {
       this. = elementName;
       this. = attributeName;
     }
 
     public int hashCode() {
       return .hashCode() ^ .hashCode();
     }
 
     public boolean equals(Object obj) {
       if (!(obj instanceof ScopedName))
         return false;
       ScopedName other = (ScopedName)obj;
       return .equals(other.elementName) && .equals(other.attributeName);
     }
   }
 
   private static class IdTypeMapImpl implements IdTypeMap {
     private final Hashtable table = new Hashtable();
     public int getIdType(Name elementNameName attributeName) {
       Integer n = (Integer).get(new ScopedName(elementNameattributeName));
       if (n == null)
         return .;
       return n.intValue();
     }
     private void add(Name elementNameName attributeNameint idType) {
       .put(new ScopedName(elementNameattributeName), new Integer(idType));
     }
   }
 
   private class IdTypeFunction extends AbstractPatternFunction {
     public Object caseOther(Pattern p) {
       return new Integer(.);
     }
 
     public Object caseData(DataPattern p) {
       return new Integer(p.getDatatype().getIdType());
     }
 
     public Object caseDataExcept(DataExceptPattern p) {
       return new Integer(p.getDatatype().getIdType());
     }
 
     public Object caseValue(ValuePattern p) {
       return new Integer(p.getDatatype().getIdType());
     }
   }
 
   private class BuildFunction extends AbstractPatternFunction {
     private final NameClass elementNameClass;
    private final Locator locator;
    private final boolean attributeIsParent;
    BuildFunction(NameClass elementNameClassLocator locator) {
      this. = elementNameClass;
      this. = locator;
      this. = false;
    }
   BuildFunction(NameClass elementNameClassLocator locatorboolean attributeIsParent) {
      this. = elementNameClass;
      this. = locator;
      this. = attributeIsParent;
    }
    private BuildFunction down() {
      if (!)
        return this;
      return new BuildFunction(false);
    }
    public Object caseChoice(ChoicePattern p) {
      BuildFunction f = down();
      p.getOperand1().apply(f);
      p.getOperand2().apply(f);
      return null;
    }
      BuildFunction f = down();
      p.getOperand1().apply(f);
      p.getOperand2().apply(f);
      return null;
    }
    public Object caseGroup(GroupPattern p) {
      BuildFunction f = down();
      p.getOperand1().apply(f);
      p.getOperand2().apply(f);
      return null;
    }
    public Object caseOneOrMore(OneOrMorePattern p) {
      p.getOperand().apply(down());
      return null;
    }
    public Object caseElement(ElementPattern p) {
      if (.get(p) != null)
        return null;
      .put(pp);
      p.getContent().apply(new BuildFunction(p.getNameClass(), p.getLocator()));
      return null;
    }
    public Object caseAttribute(AttributePattern p) {
      int idType = ((Integer)p.getContent().apply()).intValue();
      if (idType != .) {
        NameClass attributeNameClass = p.getNameClass();
        if (!(attributeNameClass instanceof SimpleNameClass)) {
          error("id_attribute_name_class"p.getLocator());
          return null;
        }
        .accept(new ElementNameClassVisitor(((SimpleNameClass)attributeNameClass).getName(),
                                                            ,
                                                            idType));
      }
      else
      p.getContent().apply(new BuildFunction(nullp.getLocator(), true));
      return null;
    }
    private void datatype(Datatype dt) {
      if (dt.getIdType() != . && !)
        error("id_parent");
    }
    public Object caseData(DataPattern p) {
      datatype(p.getDatatype());
      return null;
    }
      datatype(p.getDatatype());
      p.getExcept().apply(down());
      return null;
    }
    public Object caseValue(ValuePattern p) {
      datatype(p.getDatatype());
      return null;
    }
    public Object caseList(ListPattern p) {
      p.getOperand().apply(down());
      return null;
    }
    public Object caseOther(Pattern p) {
      return null;
    }
  }
  private class ElementNameClassVisitor implements NameClassVisitor {
    private final Name attributeName;
    private final Locator locator;
    private final int idType;
    ElementNameClassVisitor(Name attributeNameLocator locatorint idType) {
      this. = attributeName;
      this. = locator;
      this. = idType;
    }
    public void visitChoice(NameClass nc1NameClass nc2) {
      nc1.accept(this);
      nc2.accept(this);
    }
    public void visitName(Name elementName) {
      int tem = .getIdType(elementName);
      if (tem !=  . && tem != )
        error("id_type_conflict"elementName);
      .add(elementName);
    }
    public void visitNsName(String ns) {
      visitOther();
    }
    public void visitNsNameExcept(String nsNameClass nc) {
      visitOther();
    }
    public void visitAnyName() {
      visitOther();
    }
    public void visitAnyNameExcept(NameClass nc) {
      visitOther();
    }
    public void visitNull() {
    }
    public void visitError() {
    }
    private void visitOther() {
      error("id_element_name_class");
    }
  }
  private void error(String keyLocator locator) {
     = true;
    if ( != null)
      try {
        .error(new SAXParseException(..message(key), locator));
      }
      catch (SAXException e) {
        throw new WrappedSAXException(e);
      }
  }
  private void error(String keyName arg1Name arg2Locator locator) {
    = true;
   if ( != null)
     try {
       .error(new SAXParseException(..message(key, NameFormatter.format(arg1), NameFormatter.format(arg2)),
                                      locator));
     }
     catch (SAXException e) {
       throw new WrappedSAXException(e);
     }
  }
  public IdTypeMapBuilder(ErrorHandler ehPattern patternthrows SAXException {
    this. = eh;
    try {
      pattern.apply(new BuildFunction(nullnull));
      for (Enumeration e = .elements();
           e.hasMoreElements();) {
        PossibleConflict pc = (PossibleConflict)e.nextElement();
        if (pc.elementNameClass instanceof SimpleNameClass
            && pc.attributeNameClass instanceof SimpleNameClass) {
          Name elementName = ((SimpleNameClass)pc.elementNameClass).getName();
          Name attributeName = ((SimpleNameClass)pc.attributeNameClass).getName();
          int idType = .getIdType(elementName,
                                           attributeName);
          if (idType != .)
            error("id_type_conflict"elementNameattributeNamepc.locator);
        }
        else {
          for (Enumeration f = ..keys(); f.hasMoreElements();) {
            ScopedName sn = (ScopedName)f.nextElement();
            if (pc.elementNameClass.contains(sn.elementName)
                && pc.attributeNameClass.contains(sn.attributeName)) {
              error("id_type_conflict"sn.elementNamesn.attributeNamepc.locator);
              break;
            }
          }
        }
      }
    }
    catch (WrappedSAXException e) {
      throw e.cause;
    }
  }
  public IdTypeMap getIdTypeMap() {
    if ()
      return null;
    return ;
  }
New to GrepCode? Check out our FAQ X