/*
 * Copyright 2010 Google Inc.
 *
 * 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.gwt.dev.util.editdistance;

/**
 * A bitmap array generator for the positions that a given character
 * appears within a pattern.  The array of bitmaps is indexed by a
 * CharIndex that represents the alphabet for the pattern.
 * One bitmap is produced for each character.  The bitmap for
 * a character "c" has the <tt>(1<<i)</tt> bit set for each position "i"
 * where that character appears in the pattern.
 *
 * Several implementations are provided for different string
 * sizes: int, long, int[].  The caller provides a (zeroed) array of the
 * desired type, sized according to the CharIndex; the array is
 * returned as a convenience.
 */
public class PatternBitmap {
  /**
   * Computes a pattern bitmap for a short character sequence.
   * For each character in the alphabet (represented by a CharIndex),
   * bits are set where that character appears in the sequence.
   * For this generator, the pattern must fit in an "int": the
   * character sequence must not be longer than Integer.SIZE.
   * @param s the character sequence defining the bits to be set
   * @param idx the alphabet for which bitmaps should be produced
   * @param result an array (of size <tt>idx.size()</tt> or greater) to
   *        hold the resulting bitmaps
   * @return the result array passed as a parameter, for convenience
   */
  public static int[] map(CharSequence s, CharIndex idx, int[] result) {
    int len = s.length();
    assert (len <= Integer.SIZE);
    for (int i = 0; i < len; i++) {
      result[idx.lookup(s.charAt(i))] |= (1 << i);
    }
    return result;
  }

  /**
   * Computes a pattern bitmap for a character sequence of any length.
   * For each character in the alphabet (represented by a CharIndex),
   * bits are set where that character appears in the sequence.
   * Each (per-character) bitmap is represented by an "int[]".
   * @param s the character sequence defining the bits to be set
   * @param idx the alphabet for which bitmaps should be produced
   * @param result an array (of size <tt>idx.size()</tt> or greater) to
   *        hold the resulting bitmaps
   * @param width how many bits to be use in each word, no more
   *        than Integer.SIZE
   * @return the result array passed as a parameter, for convenience
   */
  public static int[][] map(CharSequence s, CharIndex idx,
                             int[][] result, int width) {
    assert (width <= Integer.SIZE);
    int len = s.length();
    int rowSize = (len + width - 1) / width;

    /*
     * Use one zero-filled bitmap for alphabet characters not in the pattern
     */
    int[] nullElement = new int[rowSize];
    java.util.Arrays.fill(result, nullElement);

    int wordIndex = 0;          /* Which word we are on now */
    int bitWithinWord = 0;      /* Which bit within that word */

    for (int i = 0; i < s.length(); i++) {
      int[] r = result[idx.lookup(s.charAt(i))];
      if (r == nullElement) {

        /* Create a separate zero-filled bitmap for this alphabet character */
        r = result[idx.lookup(s.charAt(i))] = new int[rowSize];
      }
      r[wordIndex] |= (1 << bitWithinWord);

      /* Step to the next bit (and word if appropriate) */
      if (++bitWithinWord == width) {
        bitWithinWord = 0;
        wordIndex++;
      }
    }
    return result;
  }

  /**
   * Computes a pattern bitmap for a medium character sequence.
   * For each character in the alphabet (represented by a CharIndex),
   * bits are set where that character appears in the sequence.
   * For this generator, the pattern must fit in a "long": the
   * character sequence must not be longer than Long.SIZE.
   * @param s the character sequence defining the bits to be set
   * @param idx the alphabet for which bitmaps should be produced
   * @param result an array (of size <tt>idx.size()</tt> or greater) to
   *        hold the resulting bitmaps
   * @return the result array passed as a parameter, for convenience
   */
  public static long[] map(CharSequence s, CharIndex idx, long[] result) {
    int len = s.length();
    assert (len <= Long.SIZE);
    for (int i = 0; i < len; i++) {
      result[idx.lookup(s.charAt(i))] |= (1L << i);
    }
    return result;
  }
  private PatternBitmap() { /* Prevent instantiation */ }
}