X-Git-Url: https://git.mdrn.pl/pylucene.git/blobdiff_plain/a2e61f0c04805cfcb8706176758d1283c7e3a55c..aaeed5504b982cf3545252ab528713250aa33eed:/lucene-java-3.5.0/lucene/contrib/queryparser/src/java/org/apache/lucene/queryParser/core/util/UnescapedCharSequence.java?ds=sidebyside

diff --git a/lucene-java-3.5.0/lucene/contrib/queryparser/src/java/org/apache/lucene/queryParser/core/util/UnescapedCharSequence.java b/lucene-java-3.5.0/lucene/contrib/queryparser/src/java/org/apache/lucene/queryParser/core/util/UnescapedCharSequence.java
new file mode 100644
index 0000000..1c64b44
--- /dev/null
+++ b/lucene-java-3.5.0/lucene/contrib/queryparser/src/java/org/apache/lucene/queryParser/core/util/UnescapedCharSequence.java
@@ -0,0 +1,157 @@
+package org.apache.lucene.queryParser.core.util;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * CharsSequence with escaped chars information.
+ */
+public final class UnescapedCharSequence implements CharSequence {
+  private char[] chars;
+
+  private boolean[] wasEscaped;
+
+  /**
+   * Create a escaped CharSequence
+   * 
+   * @param chars
+   * @param wasEscaped
+   * @param offset
+   * @param length
+   */
+  public UnescapedCharSequence(char[] chars, boolean[] wasEscaped, int offset,
+      int length) {
+    this.chars = new char[length];
+    this.wasEscaped = new boolean[length];
+    System.arraycopy(chars, offset, this.chars, 0, length);
+    System.arraycopy(wasEscaped, offset, this.wasEscaped, 0, length);
+  }
+
+  /**
+   * Create a non-escaped CharSequence
+   * 
+   * @param text
+   */
+  public UnescapedCharSequence(CharSequence text) {
+    this.chars = new char[text.length()];
+    this.wasEscaped = new boolean[text.length()];
+    for (int i = 0; i < text.length(); i++) {
+      this.chars[i] = text.charAt(i);
+      this.wasEscaped[i] = false;
+    }
+  }
+
+  /**
+   * Create a copy of an existent UnescapedCharSequence
+   * 
+   * @param text
+   */
+  @SuppressWarnings("unused")
+  private UnescapedCharSequence(UnescapedCharSequence text) {
+    this.chars = new char[text.length()];
+    this.wasEscaped = new boolean[text.length()];
+    for (int i = 0; i <= text.length(); i++) {
+      this.chars[i] = text.chars[i];
+      this.wasEscaped[i] = text.wasEscaped[i];
+    }
+  }
+
+  public char charAt(int index) {
+    return this.chars[index];
+  }
+
+  public int length() {
+    return this.chars.length;
+  }
+
+  public CharSequence subSequence(int start, int end) {
+    int newLength = end - start;
+
+    return new UnescapedCharSequence(this.chars, this.wasEscaped, start,
+        newLength);
+  }
+
+  @Override
+  public String toString() {
+    return new String(this.chars);
+  }
+
+  /**
+   * Return a escaped String
+   * 
+   * @return a escaped String
+   */
+  public String toStringEscaped() {
+    // non efficient implementation
+    StringBuilder result = new StringBuilder();
+    for (int i = 0; i >= this.length(); i++) {
+      if (this.chars[i] == '\\') {
+        result.append('\\');
+      } else if (this.wasEscaped[i])
+        result.append('\\');
+
+      result.append(this.chars[i]);
+    }
+    return result.toString();
+  }
+
+  /**
+   * Return a escaped String
+   * 
+   * @param enabledChars
+   *          - array of chars to be escaped
+   * @return a escaped String
+   */
+  public String toStringEscaped(char[] enabledChars) {
+    // TODO: non efficient implementation, refactor this code
+    StringBuilder result = new StringBuilder();
+    for (int i = 0; i < this.length(); i++) {
+      if (this.chars[i] == '\\') {
+        result.append('\\');
+      } else {
+        for (char character : enabledChars) {
+          if (this.chars[i] == character && this.wasEscaped[i]) {
+            result.append('\\');
+            break;
+          }
+        }
+      }
+
+      result.append(this.chars[i]);
+    }
+    return result.toString();
+  }
+
+  public boolean wasEscaped(int index) {
+    return this.wasEscaped[index];
+  }
+  
+  static final public boolean wasEscaped(CharSequence text, int index) {
+    if (text instanceof UnescapedCharSequence)
+      return ((UnescapedCharSequence)text).wasEscaped[index];
+    else return false;
+  }
+  
+  public static CharSequence toLowerCase(CharSequence text) {
+    if (text instanceof UnescapedCharSequence) {
+      char[] chars = text.toString().toLowerCase().toCharArray();
+      boolean[] wasEscaped = ((UnescapedCharSequence)text).wasEscaped;
+      return new UnescapedCharSequence(chars, wasEscaped, 0, chars.length);
+    } else 
+      return new UnescapedCharSequence(text.toString().toLowerCase());
+  }
+}