lucene-java-3.5.0/lucene/contrib/analyzers/common/src/java/org/apache/lucene/analysis/compound/hyphenation/ByteVector.java

   1 /*
   2  * Licensed to the Apache Software Foundation (ASF) under one or more
   3  * contributor license agreements.  See the NOTICE file distributed with
   4  * this work for additional information regarding copyright ownership.
   5  * The ASF licenses this file to You under the Apache License, Version 2.0
   6  * (the "License"); you may not use this file except in compliance with
   7  * the License.  You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18
  19 package org.apache.lucene.analysis.compound.hyphenation;
  20
  21 import java.io.Serializable;
  22
  23 /**
  24  * This class implements a simple byte vector with access to the underlying
  25  * array.
  26  * This class has been taken from the Apache FOP project (http://xmlgraphics.apache.org/fop/). They have been slightly modified.
  27  */
  28 public class ByteVector implements Serializable {
  29
  30   /**
  31    * Capacity increment size
  32    */
  33   private static final int DEFAULT_BLOCK_SIZE = 2048;
  34
  35   private int blockSize;
  36
  37   /**
  38    * The encapsulated array
  39    */
  40   private byte[] array;
  41
  42   /**
  43    * Points to next free item
  44    */
  45   private int n;
  46
  47   public ByteVector() {
  48     this(DEFAULT_BLOCK_SIZE);
  49   }
  50
  51   public ByteVector(int capacity) {
  52     if (capacity > 0) {
  53       blockSize = capacity;
  54     } else {
  55       blockSize = DEFAULT_BLOCK_SIZE;
  56     }
  57     array = new byte[blockSize];
  58     n = 0;
  59   }
  60
  61   public ByteVector(byte[] a) {
  62     blockSize = DEFAULT_BLOCK_SIZE;
  63     array = a;
  64     n = 0;
  65   }
  66
  67   public ByteVector(byte[] a, int capacity) {
  68     if (capacity > 0) {
  69       blockSize = capacity;
  70     } else {
  71       blockSize = DEFAULT_BLOCK_SIZE;
  72     }
  73     array = a;
  74     n = 0;
  75   }
  76
  77   public byte[] getArray() {
  78     return array;
  79   }
  80
  81   /**
  82    * return number of items in array
  83    */
  84   public int length() {
  85     return n;
  86   }
  87
  88   /**
  89    * returns current capacity of array
  90    */
  91   public int capacity() {
  92     return array.length;
  93   }
  94
  95   public void put(int index, byte val) {
  96     array[index] = val;
  97   }
  98
  99   public byte get(int index) {
 100     return array[index];
 101   }
 102
 103   /**
 104    * This is to implement memory allocation in the array. Like malloc().
 105    */
 106   public int alloc(int size) {
 107     int index = n;
 108     int len = array.length;
 109     if (n + size >= len) {
 110       byte[] aux = new byte[len + blockSize];
 111       System.arraycopy(array, 0, aux, 0, len);
 112       array = aux;
 113     }
 114     n += size;
 115     return index;
 116   }
 117
 118   public void trimToSize() {
 119     if (n < array.length) {
 120       byte[] aux = new byte[n];
 121       System.arraycopy(array, 0, aux, 0, n);
 122       array = aux;
 123     }
 124   }
 125
 126 }