X-Git-Url: http://git.rot13.org/?a=blobdiff_plain;f=csharp%2Fqrcode%2Fencoder%2FBitVector.cs;fp=csharp%2Fqrcode%2Fencoder%2FBitVector.cs;h=0000000000000000000000000000000000000000;hb=b2b0b0673099f79ff8a43852d5cb762739b497bb;hp=32b5ea6839ce5469e4a37d51e12486ac8e5aabda;hpb=66affdb887502daf1213db55a0f0b348c5a74593;p=zxing.git

diff --git a/csharp/qrcode/encoder/BitVector.cs b/csharp/qrcode/encoder/BitVector.cs
deleted file mode 100755
index 32b5ea68..00000000
--- a/csharp/qrcode/encoder/BitVector.cs
+++ /dev/null
@@ -1,151 +0,0 @@
-/*
-* Copyright 2007 ZXing 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.
-*/
-using System;
-using System.Text;
-using com.google.zxing;
-using com.google.zxing.common;
-
-namespace com.google.zxing.qrcode.encoder
-{
-    public sealed class BitVector { 
-    
-          private int sizeInBits;
-          private sbyte[] array;
-
-          // For efficiency, start out with some room to work.
-          private static int DEFAULT_SIZE_IN_BYTES = 32;
-
-          public BitVector() {
-            sizeInBits = 0;
-            array = new sbyte[DEFAULT_SIZE_IN_BYTES];
-          }
-
-          // Return the bit value at "index".
-          public int at(int index) {
-            if (index < 0 || index >= sizeInBits) {
-              throw new ArgumentException("Bad index: " + index);
-            }
-            int value = array[index >> 3] & 0xff;
-            return (value >> (7 - (index & 0x7))) & 1;
-          }
-
-          // Return the number of bits in the bit vector.
-          public int size() {
-            return sizeInBits;
-          }
-
-          // Return the number of bytes in the bit vector.
-          public int sizeInBytes() {
-            return (sizeInBits + 7) >> 3;
-          }
-
-          // Append one bit to the bit vector.
-          public void appendBit(int bit) {
-            if (!(bit == 0 || bit == 1)) {
-              throw new ArgumentException("Bad bit");
-            }
-            int numBitsInLastByte = sizeInBits & 0x7;
-            // We'll expand array if we don't have bits in the last byte.
-            if (numBitsInLastByte == 0) {
-              appendByte(0);
-              sizeInBits -= 8;
-            }
-            // Modify the last byte.
-            array[sizeInBits >> 3] |= (sbyte)(bit << (7 - numBitsInLastByte));
-            ++sizeInBits;
-          }
-
-          // Append "numBits" bits in "value" to the bit vector.
-          // REQUIRES: 0<= numBits <= 32.
-          //
-          // Examples:
-          // - appendBits(0x00, 1) adds 0.
-          // - appendBits(0x00, 4) adds 0000.
-          // - appendBits(0xff, 8) adds 11111111.
-          public void appendBits(int value, int numBits) {
-            if (numBits < 0 || numBits > 32) {
-              throw new ArgumentException("Num bits must be between 0 and 32");
-            }
-            int numBitsLeft = numBits;
-            while (numBitsLeft > 0) {
-              // Optimization for byte-oriented appending.
-              if ((sizeInBits & 0x7) == 0 && numBitsLeft >= 8) {
-                int newByte = (value >> (numBitsLeft - 8)) & 0xff;
-                appendByte(newByte);
-                numBitsLeft -= 8;
-              } else {
-                int bit = (value >> (numBitsLeft - 1)) & 1;
-                appendBit(bit);
-                --numBitsLeft;
-              }
-            }
-          }
-
-          // Append "bits".
-          public void appendBitVector(BitVector bits) {
-            int size = bits.size();
-            for (int i = 0; i < size; ++i) {
-              appendBit(bits.at(i));
-            }
-          }
-
-          // Modify the bit vector by XOR'ing with "other"
-          public void xor(BitVector other) {
-            if (sizeInBits != other.size()) {
-              throw new ArgumentException("BitVector sizes don't match");
-            }
-            int sizeInBytes = (sizeInBits + 7) >> 3;
-            for (int i = 0; i < sizeInBytes; ++i) {
-              // The last byte could be incomplete (i.e. not have 8 bits in
-              // it) but there is no problem since 0 XOR 0 == 0.
-              array[i] ^= other.array[i];
-            }
-          }
-
-          // Return String like "01110111" for debugging.
-          public String toString() {
-              StringBuilder result = new StringBuilder(sizeInBits);
-            for (int i = 0; i < sizeInBits; ++i) {
-              if (at(i) == 0) {
-                result.Append('0');
-              } else if (at(i) == 1) {
-                result.Append('1');
-              } else {
-                throw new ArgumentException("Byte isn't 0 or 1");
-              }
-            }
-            return result.ToString();
-          }
-
-          // Callers should not assume that array.length is the exact number of bytes needed to hold
-          // sizeInBits - it will typically be larger for efficiency.
-          public sbyte[] getArray() {
-            return array;
-          }
-
-          // Add a new byte to the end, possibly reallocating and doubling the size of the array if we've
-          // run out of room.
-          private void appendByte(int value) {
-            if ((sizeInBits >> 3) == array.Length) {
-              sbyte[] newArray = new sbyte[(array.Length << 1)];
-              System.Array.Copy (array, 0, newArray, 0, array.Length);
-              array = newArray;
-            }
-            array[sizeInBits >> 3] = (sbyte) value;
-            sizeInBits += 8;
-          }
-    }
-}
\ No newline at end of file