Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2012 The Guava Authors
   *
   * Licensed 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.
  */
 
 package com.google.common.base;
 
An immutable small version of CharMatcher that uses an efficient hash table implementation, with non-power-of-2 sizing to try to use no reprobing, if possible.

Author(s):
Christopher Swenson
 
 final class SmallCharMatcher extends CharMatcher {
   static final int MAX_SIZE = 63;
   static final int MAX_TABLE_SIZE = 128;
   private final boolean reprobe;
   private final char[] table;
   private final boolean containsZero;
   final long filter;
 
   private SmallCharMatcher(char[] tablelong filterboolean containsZero,
       boolean reprobeString description) {
     super(description);
     this. = table;
     this. = filter;
     this. = containsZero;
     this. = reprobe;
   }
 
   private boolean checkFilter(int c) {
     return 1 == (1 & ( >> c));
   }
 
   @Override
   public CharMatcher precomputed() {
     return this;
   }
 
   static char[] buildTable(int moduluschar[] allCharsboolean reprobe) {
     char[] table = new char[modulus];
     for (int i = 0; i < allChars.lengthi++) {
       char c = allChars[i];
       int index = c % modulus;
       if (index < 0) {
         index += modulus;
       }
       if ((table[index] != 0) && !reprobe) {
         return null;
       } else if (reprobe) {
         while (table[index] != 0) {
           index = (index + 1) % modulus;
         }
       }
       table[index] = c;
     }
     return table;
   }
 
   static CharMatcher from(char[] charsString description) {
     long filter = 0;
     int size = chars.length;
     boolean containsZero = false;
     boolean reprobe = false;
     containsZero = chars[0] == 0;
 
     // Compute the filter.
     for (char c : chars) {
       filter |= 1L << c;
     }
     char[] table = null;
     for (int i = sizei < i++) {
       table = buildTable(icharsfalse);
       if (table != null) {
         break;
       }
     }
     // Compute the hash table.
     if (table == null) {
       table = buildTable(charstrue);
       reprobe = true;
     }
     return new SmallCharMatcher(tablefiltercontainsZeroreprobedescription);
  }
  public boolean matches(char c) {
    if (c == 0) {
      return ;
    }
    if (!checkFilter(c)) {
      return false;
    }
    int index = c % .;
    if (index < 0) {
      index += .;
    }
    while (true) {
      // Check for empty.
      if ([index] == 0) {
        return false;
      } else if ([index] == c) {
        return true;
      } else if () {
        // Linear probing will terminate eventually.
        index = (index + 1) % .;
      } else {
        return false;
      }
    }
  }
New to GrepCode? Check out our FAQ X