public static RoaringArray Optimize(RoaringArray roaringArray)
{
var keys = new ushort[roaringArray.m_Size];
Array.Copy(roaringArray.m_Keys, keys, roaringArray.m_Size);
var containers = new Container[roaringArray.m_Size];
for (var i = 0; i < roaringArray.m_Size; i++)
{
var currentContainer = roaringArray.m_Values[i];
if (currentContainer.Equals(ArrayContainer.One))
{
containers[i] = ArrayContainer.One;
}
else if (currentContainer.Equals(BitmapContainer.One))
{
containers[i] = BitmapContainer.One;
}
else
{
containers[i] = currentContainer;
}
}
return(new RoaringArray(roaringArray.m_Size, keys, containers));
}
private static bool HasRunContainer(RoaringArray roaringArray)
{
for (var i = 0; i < roaringArray.m_Size; i++)
{
if (roaringArray.m_Values[i].Equals(ArrayContainer.One) || roaringArray.m_Values[i].Equals(BitmapContainer.One))
{
return(true);
}
}
return(false);
}
public static RoaringArray AndNot(RoaringArray x, RoaringArray y)
{
var xLength = x.m_Size;
var yLength = y.m_Size;
var keys = new List <ushort>(xLength);
var containers = new List <Container>(xLength);
var size = 0;
var xPos = 0;
var yPos = 0;
while ((xPos < xLength) && (yPos < yLength))
{
var xKey = x.m_Keys[xPos];
var yKey = y.m_Keys[yPos];
if (xKey == yKey)
{
var c = Container.AndNot(x.m_Values[xPos], y.m_Values[yPos]);
if (c.Cardinality > 0)
{
keys.Add(xKey);
containers.Add(c);
size++;
}
xPos++;
yPos++;
}
else if (xKey < yKey)
{
var next = x.AdvanceUntil(yKey, xPos);
for (var i = xPos; i < next; i++)
{
keys.Add(x.m_Keys[i]);
containers.Add(x.m_Values[i]);
size++;
}
xPos = next;
}
else
{
yPos = y.AdvanceUntil(xKey, yPos);
}
}
if (yPos == yLength)
{
for (var i = xPos; i < xLength; i++)
{
keys.Add(x.m_Keys[i]);
containers.Add(x.m_Values[i]);
size++;
}
}
return(new RoaringArray(size, keys, containers));
}
public bool Equals(RoaringArray other)
{
if (ReferenceEquals(this, other))
{
return(true);
}
if (ReferenceEquals(null, other))
{
return(false);
}
if (m_Size != other.m_Size)
{
return(false);
}
for (var i = 0; i < m_Size; i++)
{
if ((m_Keys[i] != other.m_Keys[i]) || !m_Values[i].Equals(other.m_Values[i]))
{
return(false);
}
}
return(true);
}
public static void Serialize(RoaringArray roaringArray, Stream stream)
{
var hasRun = HasRunContainer(roaringArray);
using (var binaryWriter = new BinaryWriter(stream, Encoding.UTF8, true))
{
var size = roaringArray.m_Size;
var keys = roaringArray.m_Keys;
var values = roaringArray.m_Values;
var startOffset = 0;
if (hasRun)
{
binaryWriter.Write(SerialCookie | ((size - 1) << 16));
var bitmapOfRunContainers = new byte[(size + 7) / 8];
for (var i = 0; i < size; ++i)
{
if (values[i].Equals(ArrayContainer.One) || values[i].Equals(BitmapContainer.One))
{
bitmapOfRunContainers[i / 8] |= (byte)(1 << (i % 8));
}
}
binaryWriter.Write(bitmapOfRunContainers);
}
else // no run containers
{
binaryWriter.Write(SerialCookieNoRuncontainer);
binaryWriter.Write(size);
startOffset = 4 + 4 + 4 * size + 4 * size;
}
for (var k = 0; k < size; ++k)
{
binaryWriter.Write(keys[k]);
binaryWriter.Write((ushort)(values[k].Cardinality - 1));
}
if (!hasRun || (size >= NoOffsetThreshold))
{
for (var k = 0; k < size; k++)
{
binaryWriter.Write(startOffset);
startOffset += values[k].ArraySizeInBytes;
}
}
for (var k = 0; k < size; ++k)
{
var container = values[k];
ArrayContainer ac;
BitmapContainer bc;
if ((ac = container as ArrayContainer) != null)
{
if (ac.Equals(ArrayContainer.One))
{
binaryWriter.Write((ushort)1);
binaryWriter.Write((ushort)0);
binaryWriter.Write((ushort)(Container.MaxSize - 1));
}
else
{
ArrayContainer.Serialize(ac, binaryWriter);
}
}
else if ((bc = container as BitmapContainer) != null)
{
if (bc.Equals(BitmapContainer.One))
{
binaryWriter.Write((ushort)1);
binaryWriter.Write((ushort)0);
binaryWriter.Write((ushort)(Container.MaxCapacity - 1));
}
else
{
BitmapContainer.Serialize(bc, binaryWriter);
}
}
}
binaryWriter.Flush();
}
}
/// <summary>
/// Optimizes a RoaringBitmap to prepare e.g. for Serialization/Deserialization
/// </summary>
/// <returns>RoaringBitmap</returns>
public RoaringBitmap Optimize()
{
return(new RoaringBitmap(RoaringArray.Optimize(m_HighLowContainer)));
}
/// <summary>
/// Deserializes a RoaringBitmap from astream using the 'official' RoaringBitmap file format
/// </summary>
/// <param name="stream">Stream</param>
public static RoaringBitmap Deserialize(Stream stream)
{
var ra = RoaringArray.Deserialize(stream);
return(new RoaringBitmap(ra));
}
/// <summary>
/// Serializes a RoaringBitmap into a stream using the 'official' RoaringBitmap file format
/// </summary>
/// <param name="roaringBitmap">RoaringBitmap</param>
/// <param name="stream">Stream</param>
public static void Serialize(RoaringBitmap roaringBitmap, Stream stream)
{
RoaringArray.Serialize(roaringBitmap.m_HighLowContainer, stream);
}
/// <summary>
/// Bitwise AndNot operation of two RoaringBitmaps
/// </summary>
/// <param name="x">RoaringBitmap</param>
/// <param name="y">RoaringBitmap</param>
/// <returns>RoaringBitmap</returns>
public static RoaringBitmap AndNot(RoaringBitmap x, RoaringBitmap y)
{
return(new RoaringBitmap(RoaringArray.AndNot(x.m_HighLowContainer, y.m_HighLowContainer)));
}
private RoaringBitmap(RoaringArray input)
{
m_HighLowContainer = input;
}
