using System;

using System.Collections;

using System.Linq;

using System.Runtime.Serialization;

namespace BitsetsNET

{

public class UncompressedBitArray : IBitset

{

private BitArray array;

public UncompressedBitArray() { }

public UncompressedBitArray(UncompressedBitArray copy)

{

array = new BitArray(copy.array);

}

public UncompressedBitArray(int[] indices) : this(indices, indices.Max()) { }

public UncompressedBitArray(int[] indices, int capacity)

{

int length = capacity;

array = new BitArray(length);

foreach (int index in indices)

{

array.Set(index, true);

}

}

public int Length

{

get

{

return array.Length;

}

}

/// <summary>

/// Creates a new bitset that is the bitwise AND of this bitset with another

/// </summary>

/// <param name="otherSet">Other bitset</param>

/// <returns>A new IBitset</returns>

public IBitset And(IBitset otherSet)

{

IBitset result = this.Clone();

result.AndWith(otherSet);

return result;

}

/// <summary>

/// Performs an in-place intersection of two Roaring Bitsets.

/// </summary>

/// <param name="otherSet">the second Roaring Bitset to intersect</param>

public void AndWith(IBitset otherSet)

{

array = array.And(((UncompressedBitArray)otherSet).array);

}

/// <summary>

/// Create a new bitset that is a deep copy of this one.

/// </summary>

/// <returns>The cloned bitset</returns>

public IBitset Clone()

{

return new UncompressedBitArray(this);

}

/// <summary>

/// Return whether the given index is a member of this set

/// </summary>

/// <param name="index">the index to test</param>

/// <returns>True if the index is a member of this set</returns>

public bool Get(int index)

{

return array.Get(index);

}

/// <summary>

/// Creates a new bitset that is the bitwise OR of this bitset with another bitset.

/// </summary>

/// <param name="otherSet">Other bitset</param>

/// <returns>A new IBitset</returns>

public IBitset Or(IBitset otherSet)

{

IBitset result = this.Clone();

result.OrWith(otherSet);

return result;

}

/// <summary>

/// Computes the in-place bitwise OR of this bitset with another bitset.

/// </summary>

/// <param name="otherSet">Other bitset</param>

public void OrWith(IBitset otherSet)

{

array = array.Or(((UncompressedBitArray)otherSet).array);

}

/// <summary>

/// If the value is true and given index is not in the set add it. If

/// the value is false and the index is in the set remove it. Otherwise,

/// do nothing.

/// </summary>

/// <param name="index">the index to set</param>

public void Set(int index, bool value)

{

array.Set(index, value);

}

/// <summary>

/// Sets all bits in the array to the specified value

/// </summary>

/// <param name="value"></param>

public void SetAll(bool value)

{

array.SetAll(value);

}

public void GetObjectData(SerializationInfo info, StreamingContext context)

{

throw new NotImplementedException();

}

public IEnumerator GetEnumerator()

{

for (int i = 0; i < this.array.Length; i++)

{

if (this.array.Get(i) == true)

{

yield return i;

}

}

}

/// <summary>

/// Returns a new bitset that consists of all elements that are not

/// in this bitset.

/// </summary>

/// <returns>The new bitset</returns>

public IBitset Not()

{

var newSet = new UncompressedBitArray();

newSet.array = array.Not();

return newSet;

}

/// <summary>

/// The number of members in the set

/// </summary>

/// <returns>an integer for the number of members in the set</returns>

public int Cardinality()

{

int rtnValue = 0;

for (int i = 0; i < array.Length; i++)

{

if (array[i]) rtnValue += 1;

}

return rtnValue;

}

/// <summary>

/// For indices in the range [start, end) add the index to the set if

/// the value is true, otherwise remove it.

/// </summary>

/// <param name="start">the index to start from (inclusive)</param>

/// <param name="end">the index to stop at (exclusive)</param>

public void Set(int start, int end, bool value)

{

for (int i = start; i <= end; i++ )

{

array.Set(i, value);

}

}

/// <summary>

/// If the given index is not in the set add it, otherwise remove it.

/// </summary>

/// <param name="index">the index to flip</param>

public void Flip(int index)

{

array[index] = !array[index];

}

/// <summary>

/// For indices in the range [start, end) add the index to the set if

/// it does not exists, otherwise remove it.

/// </summary>

/// <param name="start">the index to start from (inclusive)</param>

/// <param name="end">the index to stop at (exclusive)</param>

public void Flip(int start, int end)

{

for (int i = start; i < end; i++)

{

Flip(i);

}

}

/// <summary>

/// Creates a new IBitSet that has the members of this BitSet that are

/// not members of the other bitset

/// </summary>

/// <param name="otherSet">The other bitset</param>

/// <returns>a new IBitSet</returns>

public IBitset Difference(IBitset otherSet)

{

UncompressedBitArray workset = null;

if (otherSet is UncompressedBitArray)

{

workset = (UncompressedBitArray)otherSet;

}

else

{

throw new InvalidOperationException("otherSet is not an UncompressedBitArray");

}

UncompressedBitArray newArray = (UncompressedBitArray) this.Clone();

for (int i = 0; i < workset.array.Length; i++)

{

if (workset.array[i] && i < this.Length)

{

newArray.Set(i, false);

}

}

return newArray;

}

public BitArray ToBitArray()

{

return new BitArray(this.array);

}

public void Serialize(System.IO.Stream stream)

{

throw new NotImplementedException();

}

public override bool Equals(object obj)

{

if (obj == null || GetType() != obj.GetType())

{

return false;

}

UncompressedBitArray compare = (UncompressedBitArray)obj;

bool equalLength = (this.Length == compare.Length);

if (equalLength)

{

for (int i = 0; i < this.Length; i++)

{

if (this.array.Get(i) != compare.array.Get(i))

{

equalLength = false;

}

}

}

return equalLength;

}

public override int GetHashCode()

{

unchecked

{

int hash = Length;

for (int i = 0; i < Length; i++)

{

hash = 17 * hash + array.Get(i).GetHashCode();

}

return hash;

}

}

}

}