ldapexpr.java

OSGI这是一个中间件,与UPNP齐名,是用于移植到嵌入式平台之上

        for(int i=0; i<len; i++)
          if (compare(Array.get(obj, i), op, s)) 
            return true;
      } else {
	// Extended comparison
	// Allow simple EQ comparison on all classes having
	// a string constructor, and use compareTo if they
	// implement Comparable
	Class       clazz = obj.getClass();
	Constructor cons  = getConstructor(clazz);

	if(cons != null) {
	  Object     other = cons.newInstance(new Object [] { s } );
	  if(obj instanceof Comparable) {
	    int c = ((Comparable)obj).compareTo(other);
	    switch(op) {
	    case LE:
	      return c <= 0;
	    case GE:
	      return c >= 0;
	    default: /*APPROX and EQ*/
	      return c == 0;
	    }
	  } else {
	    boolean b = op == EQ && (obj.equals(other));
	    return b;
	  }
	}
      }
    } catch (Exception e) { 
      e.printStackTrace();
    }
    return false;
  }
  
  // Clazz -> Constructor(String)
  private static HashMap constructorMap = new HashMap();

  /**
   * Get cached String constructor for a class
   */
  private static Constructor getConstructor(Class clazz) {
    synchronized(constructorMap) {

      // This might be null
      Constructor cons = (Constructor)constructorMap.get(clazz);
      
      // ...check if we have tried before. A failed try
      // is stored as null
      if(!constructorMap.containsKey(clazz)) {
	try {
	  cons = clazz.getConstructor(new Class [] { String.class });
	} catch (Exception e) {
	  // remember by storing null in map
	}
	constructorMap.put(clazz, cons);
      }
      return cons;
    }
  }

  static {
    try {
      classBigDecimal = Class.forName("java.math.BigDecimal");
      consBigDecimal = getConstructor(classBigDecimal);
      compBigDecimal = classBigDecimal.getMethod("compareTo", new Class [] { classBigDecimal });
    } catch (Exception ignore) {
      classBigDecimal = null;
    }
    try {
      classBigInteger = Class.forName("java.math.BigInteger");
      consBigInteger = getConstructor(classBigInteger);
      compBigInteger = classBigInteger.getMethod("compareTo", new Class [] { classBigInteger });
    } catch (Exception ignore) {
      classBigInteger = null;
    }
  }


  private static boolean compareString(String s1, int op, String s2) {
    switch(op) {
    case LE:
      return s1.compareTo(s2) <= 0;
    case GE:
      return s1.compareTo(s2) >= 0;
    case EQ:
      return patSubstr(s1,s2);
    case APPROX:
      return fixupString(s2).equals(fixupString(s1));
    default:
      return false;
    }
  }

  private static String fixupString(String s) {
    StringBuffer sb = new StringBuffer();
    int len = s.length();
    boolean isStart = true;
    boolean isWhite = false;
    for(int i=0; i<len; i++) {
      char c = s.charAt(i);
      if (Character.isWhitespace(c)) {
        isWhite = true;
      } else {
        if (!isStart && isWhite) 
          sb.append(' ');
        if (Character.isUpperCase(c)) 
          c = Character.toLowerCase(c);
        sb.append(c);
        isStart = false;
        isWhite = false;
      }
    }
    return sb.toString();
  }

  private static boolean patSubstr(String s, String pat) {
    return s==null ? false : patSubstr(s.toCharArray(),0,pat.toCharArray(),0);
  }
  
  private static boolean patSubstr(char[] s, int si, char[] pat, int pi) {
    if (pat.length-pi == 0) 
      return s.length-si == 0;
    if (pat[pi] == WILDCARD) {
      pi++;
      for (;;) {
        if (patSubstr( s, si, pat, pi ))
          return true;
        if (s.length-si == 0)
          return false;
        si++;
      }
    } else {
      if (s.length-si==0 || s[si]!=pat[pi])
        return false;
      return patSubstr( s, ++si, pat, ++pi );
    }
  }

  private static LDAPExpr parseExpr(ParseState ps) 
    throws InvalidSyntaxException {
    ps.skipWhite();
    if (!ps.prefix("(")) 
      ps.error(MALFORMED);

    int operator;
    ps.skipWhite();
    switch(ps.peek()) {
    case '&': operator = AND; break;
    case '|': operator = OR; break;
    case '!': operator = NOT; break;
    default: return parseSimple(ps);
    }
    ps.skip(1); // Ignore the operator
    List v = new ArrayList();
    do {
      v.add(parseExpr(ps));
      ps.skipWhite();
    } while (ps.peek() == '(');
    int n = v.size();
    if (!ps.prefix(")") || n == 0 || (operator == NOT && n > 1))
      ps.error(MALFORMED);    
    LDAPExpr[] args = new LDAPExpr[n];
    v.toArray(args);
    return new LDAPExpr(operator, args);
  }

  private static LDAPExpr parseSimple(ParseState ps) 
    throws InvalidSyntaxException {
    String attrName = ps.getAttributeName(); 
    int operator = 0;
    if (ps.prefix("=")) 
      operator = EQ;
    else if (ps.prefix("<="))    
      operator = LE;
    else if(ps.prefix(">=")) 
      operator = GE;
    else if(ps.prefix("~=")) 
      operator = APPROX;
    else {
      //      System.out.println("undef op='" + ps.peek() + "'");
      ps.error(OPERATOR); // Does not return
    }
    String attrValue = ps.getAttributeValue();
    if (!ps.prefix(")"))
      ps.error(MALFORMED);        
    return new LDAPExpr(operator, attrName, attrValue);
  }

  public String toString() {
    if(Framework.R3_TESTCOMPLIANT) {
      if(bug != null) {
	return bug;
      }
    }

    StringBuffer res = new StringBuffer();
    res.append("(");
    if ((operator & SIMPLE) != 0) { 
      res.append(attrName);
      switch (operator) {
      case EQ:
        res.append("=");
        break;
      case LE:
        res.append("<=");
        break;
      case GE:
        res.append(">=");
        break;
      case APPROX:
        res.append("~=");
        break;
      }
      for (int i = 0; i < attrValue.length(); i++) {
        char c = attrValue.charAt(i);
        if (c ==  '(' || c == ')' || c == '*' || c == '\\') {
          res.append('\\');
        } else if (c == WILDCARD) {
          c = '*';
        }
        res.append(c);
      }
    } else {
      switch (operator) {
      case AND:
        res.append("&");
        break;
      case OR:
        res.append("|");
        break;
      case NOT:
        res.append("!");
        break;
      }
      for (int i = 0; i < args.length; i++) {
        res.append(args[i].toString());
      }
    }
    res.append(")");
    return res.toString();
  }

  /**
   * Contains the current parser position and parsing utility methods.
   */
  private static class ParseState {
    int pos;
    String str;

    public ParseState(String str) throws InvalidSyntaxException {
      this.str = str;
      if (str == null || str.length() == 0)
        error(NULL);
      pos = 0;
    }

    public int getPos() {
      return pos;
    }

    public boolean prefix(String pre) {
      if (!str.startsWith(pre, pos))
        return false;
      pos += pre.length();
      return true;
    }

    public char peek() {
      return str.charAt(pos);
    }

    public void skip(int n) {
      pos += n;
    }

    public String rest() {
      return str.substring(pos);
    }

    public void skipWhite() {
      while (Character.isWhitespace(str.charAt(pos))) {
        pos++;
      }
    }

    public String getAttributeName() {
      int start = pos;
      for(;; pos++) {
        char c = str.charAt(pos);
        if (Character.isWhitespace(c) ||
            c == '(' || c == ')' ||
            c == '<' || c == '>' ||
            c == '=' || c == '~' ||
            c == '*' || c == '\\') {
          break;
        }
      }
      String res = str.substring(start, pos).toLowerCase();
      skipWhite();
      return res;
    }

    public String getAttributeValue() {
      StringBuffer sb = new StringBuffer();
      label:
      for(;; pos++) {
        char c = str.charAt(pos);
        switch(c) {
        case '(':
        case ')':
          break label;
        case '*':
          sb.append(WILDCARD);
          break;
        case '\\':
          sb.append(str.charAt(++pos));
          break;
        default:
          sb.append(c);
          break;
        }
      }
      return sb.toString();
    }

    public void error(String m) throws InvalidSyntaxException {
      throw new InvalidSyntaxException(m, (str == null) ? "" : str.substring(pos));
    }
  }
}