View difference between Paste ID: 11zFuSTc and GLyzcUZC

-using System;
+namespace Utils
-using System.Collections.Generic;
+
-using System.Linq;
+	using System;
-using System.Text;
+	using System.Collections;
-using System.Globalization;
+	using System.Collections.Generic;
-using System.Diagnostics;
+	using System.Linq;
 	using System.Text;
-namespace CryptoClass
+	using System.Globalization;
 	using System.Threading;
-	public class BitArray
+
 	/// <summary>
-		private readonly bool[] bits;
+	/// A replacement for BitArray
-		public BitArray(IEnumerable<bool> bits)
+	/// </summary>
 	public class BoolArray : IEnumerable, ICollection,  ICloneable
-			this.bits = bits.ToArray();
+
 		private UInt32[] bits = null;
-		public BitArray(int length)
+		private int _length = 0;
 		private static UInt32 ONE = (UInt32)1 << 31;
-			this.bits = new bool[length];
+		private object _syncRoot;
 		private static Func<byte[], byte[]> EndianFixer = null;
 
-		public int Length { get { return bits.Length; } }
+		#region Constructors
 
-		public static BitArray ParseHex(string hex)
+		static BoolArray()
 		{
-			if (hex == null) return null; // or do something else, throw, ...
+			if (BitConverter.IsLittleEndian) EndianFixer = (a) => a.Reverse().ToArray();
 			else EndianFixer = (a) => a;
 		}
 
 		public BoolArray(BoolArray srcBits)
 		{
 			this.InitializeFrom(srcBits.ToArray());
 		}
 
 		public BoolArray(ICollection<bool> srcBits)
 		{
-			BitArray ba = new BitArray(bits.ToArray());
+			this.InitializeFrom(srcBits.ToArray());
 		}
 
-		public static BitArray FromBytes(IEnumerable<byte> bytes)
+		public BoolArray(ICollection<byte> srcBits)
 		{
-			List<bool> bits = new List<bool>(bytes.Count() * 8);
+			InitializeFrom(srcBits);
-			foreach (byte b in bytes)
+
 
-				byte v = b;
+		public BoolArray(ICollection<short> srcBits)
-				for (int i = 7; i >= 0; i--)
+
 			ICollection<byte> bytes = srcBits.SelectMany(v => EndianFixer(BitConverter.GetBytes(v))).ToList();
-					bits.Add((v & (1 << i)) != 0);
+			InitializeFrom(bytes);
 		}
 
-			return new BitArray(bits);
+		public BoolArray(ICollection<ushort> srcBits)
 		{
-		public static BitArray operator +(BitArray a, BitArray b)
+			ICollection<byte> bytes = srcBits.SelectMany(v => EndianFixer(BitConverter.GetBytes(v))).ToList();
 			InitializeFrom(bytes);
-			return a.Append(b);
+
 
-		public static BitArray FromByte(byte b)
+		public BoolArray(ICollection<int> srcBits)
 		{
-			return BitArray.FromBytes(new byte[] { b });
+			ICollection<byte> bytes = srcBits.SelectMany(v => EndianFixer(BitConverter.GetBytes(v))).ToList();
 			InitializeFrom(bytes);
-		public static BitArray FromString(string s, Encoding encoding = null)
+
 
-			if (encoding == null) encoding = Encoding.ASCII;
+		public BoolArray(ICollection<uint> srcBits)
-			return BitArray.FromBytes(encoding.GetBytes(s));
+
 			ICollection<byte> bytes = srcBits.SelectMany(v => EndianFixer(BitConverter.GetBytes(v))).ToList();
 			InitializeFrom(bytes);
-		public BitArray Append(BitArray bits)
+
 
-			List<bool> obits = new List<bool>(this.ToArray());
+		public BoolArray(ICollection<long> srcBits)
-			obits.AddRange(bits.ToArray());
+
-			return new BitArray(obits.ToArray());
+			ICollection<byte> bytes = srcBits.SelectMany(v => EndianFixer(BitConverter.GetBytes(v))).ToList();
 			InitializeFrom(bytes);
-		public BitArray Repeat(int numReps)
+
 
-			BitArray dv = new BitArray(0);
+		public BoolArray(ICollection<ulong> srcBits)
 		{
 			ICollection<byte> bytes = srcBits.SelectMany(v => EndianFixer(BitConverter.GetBytes(v))).ToList();
 			InitializeFrom(bytes);
-		public BitArray GetBits(int startBit, int numBits = -1)
+
 
 		public BoolArray(int capacity, bool defaultValue = false)
-			return new BitArray(bits.Skip(startBit).Take(numBits).ToArray());
+
 			this.bits = new UInt32[RequiredSize(capacity)];
-		public BitArray SetBits(int startBit, BitArray setBits)
+			this._length = capacity;
 
-			bool[] obits = bits.ToArray();
+			// Only need to do this if true, because default for all bits is false
-			bool[] nbits = setBits.ToArray();
+			if (defaultValue) for (int i = 0; i < this._length; i++) this[i] = true;
-			nbits.CopyTo(obits, startBit);
+
-			return new BitArray(obits);
+
 		private void InitializeFrom(ICollection<byte> srcBits)
-		public BitArray Increment(int v = 1)
+
 			this._length = srcBits.Count * 8;
-			byte[] bytes = ToBytes();
+			this.bits = new UInt32[RequiredSize(this._length)];
-			for (int i = bytes.Length - 1; i >= 0; i--)
+			for (int i = 0; i < srcBits.Count; i++)
 			{
-				int nv = (int)bytes[i] + v;
+				uint bv = srcBits.Skip(i).Take(1).Single();
-				bytes[i] = (byte)(nv % 256);
+				for (int b = 0; b < 8; b++)
-				if (nv < 256) break;
+
-				v = nv - 256;
+					bool bitVal = ((bv << b) & 0x0080) != 0;
 					int bi = 8 * i + b;
 					this[bi] = bitVal;
-			return BitArray.FromBytes(bytes);
+
 			}
-		public BitArray Left(int numBits)
+
 
-			return new BitArray(bits.Take(numBits));
+		private void InitializeFrom(ICollection<bool> srcBits)
 		{
-		public BitArray Xor(BitArray xor, int start = 0)
+			this._length = srcBits.Count;
 			this.bits = new UInt32[RequiredSize(this._length)];
-			bool[] allbits = this.ToArray();
+
-			bool[] xorbits = xor.ToArray();
+			int index = 0;
-			for (int i = 0; i < xorbits.Length; i++)
+			foreach (var b in srcBits) this[index++] = b;
 		}
-				if (start + i >= allbits.Length) break;
+
 		private static int RequiredSize(int bitCapacity)
-				allbits[start + i] = allbits[start + i] ^ xorbits[i];
+
 			return (bitCapacity + 31) >> 5;
-			return new BitArray(allbits);
+
 
-		public List<BitArray> Split(int numBits)
+		#endregion
 
 
-			List<BitArray> bitSplits = new List<BitArray>();
+		public bool this[int index]
-			while (i < bits.Length)
+
 			get
 			{
 				if (index >= _length) throw new IndexOutOfRangeException();
 
 				int byteIndex = index >> 5;
 				int bitIndex = index & 0x1f;
 				return ((bits[byteIndex] << bitIndex) & ONE) != 0;
-		public string ToAsciiString()
+
 			set
-			return Encoding.ASCII.GetString(ToBytes());
+
 				if (index >= _length) throw new IndexOutOfRangeException();
 
 				int byteIndex = index >> 5;
 				int bitIndex = index & 0x1f;
 				if (value) bits[byteIndex] |= (ONE >> bitIndex);
 				else bits[byteIndex] &= ~(ONE >> bitIndex);
-			for (int i = 1; i <= bits.Length; i++)
+
 		}
-				b = (b << 1) | (bits[i-1] ? 1 : 0);
+
 		#region IEnumerable
 		public IEnumerator GetEnumerator()
 		{
 			//for (int i = 0; i < _length; i++) yield return this[i];
 			return this.ToArray().GetEnumerator();
-
+		}
 		#endregion
 		#region ICollection
 		public void CopyTo(Array array, int index)
 		{
 			throw new NotImplementedException();
 
 			if (array == null) throw new ArgumentNullException("array");
 			if (index < 0) throw new ArgumentOutOfRangeException("index");
 			if (array.Rank != 1) throw new ArgumentException("Multidimentional array not supported");
-			int ebits = bits.Length % 4;
+			//if (array is UInt32[]) Array.Copy((Array)this.m_array, 0, array, index, BitArray.GetArrayLength(this.m_length, 32));
 			//else if (array is byte[])
 			//else if (array is bool[])
 		}
 
 		public int Count
 		{
 			get { return this._length; }
 		}
 
 		public bool IsSynchronized
-			return ToHexString(" ", " | ");
+
 			get { return false; }
 		}
 
 		public object SyncRoot
-			BitArray ba = GetBits(startBit, numBits);
+
-			int nb = (numBits / 8) + (((numBits % 8) > 0) ? 1 : 0);
+			get
 			{
-			for (int i = 0; i < ba.Length; i++)
+				if (this._syncRoot == null) Interlocked.CompareExchange<object>(ref this._syncRoot, new object(), null);
 				return _syncRoot;
-				if (!bits[i]) continue;
+
 		}
 		#endregion
 		#region ICloneable
 		public object Clone()
 		{
 			return new BoolArray(this.ToArray());
 		}
-			return bits.ToArray();
+		#endregion
 
 		public bool[] ToArray()
 		{
 			bool[] vbits = new bool[this._length];
 			for (int i = 0; i < _length; i++) vbits[i] = this[i];
 			return vbits;
 		}
 
 		public BoolArray Append(ICollection<bool> addBits)
 		{
 			int startPos = this._length;
 			Extend(addBits.Count);
 			bool[] bitArray = addBits.ToArray();
 			for (int i = 0; i < bitArray.Length; i++) this[i + startPos] = bitArray[i];
 			return this;
 		}
 
 		public BoolArray Append(BoolArray addBits)
 		{
 			return this.Append(addBits.ToArray());
 		}
 
 		public void Extend(int numBits)
 		{
 			numBits += this._length;
 			int reqBytes = RequiredSize(numBits);
 			if (reqBytes > this.bits.Length)
 			{
 				UInt32[] newBits = new UInt32[reqBytes];
 				this.bits.CopyTo(newBits, 0);
 				this.bits = newBits;
 			}
 			this._length = numBits;
 		}
 
 		public BoolArray Reverse()
 		{
 			this.InitializeFrom(this.ToArray().Reverse().ToList());
 			return this;
 		}
 
 		public static BoolArray operator +(BoolArray a, BoolArray b)
 		{
 			return new BoolArray(a).Append(b);
 		}
 
 		public static BoolArray FromHexString(string hex)
 		{
 			if (hex == null) throw new ArgumentNullException("hex");
 
 			List<bool> bits = new List<bool>();
 			for (int i = 0; i < hex.Length; i++)
 			{
 				int b = byte.Parse(hex[i].ToString(), NumberStyles.HexNumber);
 				bits.Add((b >> 3) == 1);
 				bits.Add(((b & 0x7) >> 2) == 1);
 				bits.Add(((b & 0x3) >> 1) == 1);
 				bits.Add((b & 0x1) == 1);
 			}
 			BoolArray ba = new BoolArray(bits.ToArray());
 			return ba;
 		}
 
 		public static BoolArray FromBinaryString(string bin, char[] trueChars = null)
 		{
 			if (trueChars == null) trueChars = new char[] { '1', 'Y', 'y', 'T', 't' };
 			if (bin == null) throw new ArgumentNullException("bin");
 			BoolArray ba = new BoolArray(bin.Length);
 			for (int i = 0; i < bin.Length; i++) ba[i] = bin[i].In(trueChars);
 			return ba;
 		}
 
 		public BoolArray Repeat(int numReps)
 		{
 			BoolArray dv = new BoolArray(0);
 			while (--numReps >= 0) dv = dv.Append(this);
 			return dv;
 		}
 
 		public BoolArray GetBits(int startBit = 0, int numBits = -1)
 		{
 			if (numBits == -1) numBits = bits.Length;
 			return new BoolArray(this.ToArray().Skip(startBit).Take(numBits).ToArray());
 		}
 
 		public BoolArray SetBits(int startBit, BoolArray setBits)
 		{
 			int diffSize = startBit + setBits.Count - this.Count;
 			if (diffSize > 0) Extend(diffSize);
 			for (int i = 0; i < setBits.Count; i++) this[startBit + i] = setBits[i];
 			return this;
 		}
 
 		public List<BoolArray> SplitEvery(int numBits)
 		{
 			int i = 0;
 			List<BoolArray> bitSplits = new List<BoolArray>();
 			while (i < this.Count)
 			{
 				bitSplits.Add(this.GetBits(i, numBits));
 				i += numBits;
 			}
 			return bitSplits;
 		}
 
 		#region Logical Bitwise Operations
 		public static BoolArray BinaryBitwiseOp(Func<bool, bool, bool> op, BoolArray left, BoolArray right, int start = 0)
 		{
 			bool[] leftbits = left.ToArray();
 			bool[] rightbits = right.ToArray();
 			for (int i = 0; i < rightbits.Length; i++)
 			{
 				if (start + i >= leftbits.Length) break;
 				leftbits[start + i] = op(leftbits[start + i], rightbits[i]);
 			}
 			return new BoolArray(leftbits);
 		}
 
 		public BoolArray Xor(BoolArray xor, int start = 0)
 		{
 			return BinaryBitwiseOp((a, b) => (a ^ b), this, xor, start);
 		}
 
 		public BoolArray And(BoolArray and, int start = 0)
 		{
 			return BinaryBitwiseOp((a, b) => (a & b), this, and, start);
 		}
 
 		public BoolArray Or(BoolArray or, int start = 0)
 		{
 			return BinaryBitwiseOp((a, b) => (a | b), this, or, start);
 		}
 
 		public BoolArray Not(int start = 0, int len = -1)
 		{
 			BoolArray b = (BoolArray)this.Clone();
 			for (int i = start; i < b.Count; i++)
 			{
 				if (--len == -1) break;
 				b[i] = !b[i];
 			}
 			return b;
 		}
 		#endregion
 
 		public string ToHexString(string bitSep8 = null, string bitSep128 = null)
 		{
 			string s = string.Empty;
 			int b = 0;
 			bool[] bbits = this.ToArray();
 
 			for (int i = 1; i <= bbits.Length; i++)
 			{
 				b = (b << 1) | (bbits[i - 1] ? 1 : 0);
 				if (i % 4 == 0)
 				{
 					s = s + string.Format("{0:x}", b);
 					b = 0;
 				}
 
 				if (i % (8 * 16) == 0)
 				{
 					s = s + bitSep128;
 				}
 				else if (i % 8 == 0)
 				{
 					s = s + bitSep8;
 				}
 			}
 			int ebits = bbits.Length % 4;
 			if (ebits != 0)
 			{
 				b = b << (4 - ebits);
 				s = s + string.Format("{0:x}", b);
 			}
 			return s;
 		}
 
 		public string ToBinaryString(char setChar = '1', char unsetChar = '0')
 		{
 			return new string(this.ToArray().Select(v => v ? setChar : unsetChar).ToArray());
 		}
 
 		public byte[] ToBytes(int startBit = 0, int numBits = -1)
 		{
 			if (numBits == -1) numBits = bits.Length - startBit;
 			BoolArray ba = GetBits(startBit, numBits);
 			int nb = (numBits + 7) / 8;
 			byte[] bb = new byte[nb];
 			for (int i = 0; i < ba.Count; i++)
 			{
 				if (!ba[i]) continue;
 				int bp = 7 - (i % 8);
 				bb[i / 8] = (byte)((int)bb[i / 8] | (1 << bp));
 			}
 			return bb;
 		}
 
 		public override string ToString()
 		{
 			return ToHexString(" ", " ■ ");
 		}
 	}
 
         public static class Misc
         {
                 public static bool In<T>(this T v, IEnumerable<T> vList) { return vList.Contains(v); }
                 public static bool In<T>(this T v, params T[] vList) { return vList.Contains(v); }
                 public static void Swap<T>(ref T rw, ref T rh)
                 {
                         T t = rw;
                         rw = rh;
                         rh = t;
                 }
         }
 }