Example #1
0
            public static Helper Deserialize(BinaryReader reader)
            {
                Helper helper = new Helper();

                byte b = reader.ReadByte();

                helper.Sign           = (b & 0x80) != 0;
                helper.IsReady        = (b & 0x40) != 0;
                helper.AlwaysUseDelta = (b & 0x20) != 0;
                helper.Type           = (HelperType)(b & 0x1f);

                if (helper.Type == HelperType.Raw)
                {
                    return(helper);
                }

                if (helper.Type == HelperType.OneStep)
                {
                    helper.Delta = CountCompression.Deserialize(reader);
                    return(helper);
                }

                helper.DeltaBits = reader.ReadByte();
                helper.Delta     = (1UL << helper.DeltaBits) - 1;

                return(helper);
            }
Example #2
0
        public static void Decompress(BinaryReader reader, Action <int, long> values, int count)
        {
            if (reader.ReadByte() != VERSION)
            {
                throw new Exception("Invalid delta compression version.");
            }

            if (count == 0)
            {
                return;
            }

            int index = 0;

            long value = (long)CountCompression.Deserialize(reader);

            values(index, value);
            if (count == 1)
            {
                return;
            }

            var helper = Helper.Deserialize(reader);

            index++;
            count--;
            int maxIndex = index + count - 1;

            if (helper.Type == HelperType.Raw)
            {
                while (index <= maxIndex)
                {
                    values(index++, reader.ReadInt64());
                }

                return;
            }

            if (helper.Type == HelperType.OneStep)
            {
                long step = (long)helper.Delta;

                if (helper.Sign == false)
                {
                    while (index <= maxIndex)
                    {
                        values(index++, (value += step));
                    }
                }
                else
                {
                    while (index <= maxIndex)
                    {
                        values(index++, (value -= step));
                    }
                }

                return;
            }

            bool  readSign       = helper.Type == HelperType.Delta;
            ulong maxDelta       = helper.Delta;
            bool  alwaysUseDelta = helper.AlwaysUseDelta;
            bool  sign           = helper.Sign;
            int   bitCount       = helper.DeltaBits;

            CommonArray common     = new CommonArray();
            int         bytesCount = (int)CountCompression.Deserialize(reader);

            common.ByteArray = reader.ReadBytes(bytesCount);
            ulong[] data     = common.UInt64Array;
            int     bitIndex = 0;

            for (; index <= maxIndex; index++)
            {
                long newValue;
                bool useDelta = alwaysUseDelta || GetFlag(data, bitIndex++);

                if (useDelta)
                {
                    if (readSign)
                    {
                        sign = GetFlag(data, bitIndex);
                        bitIndex++;
                    }

                    long delta = (long)GetBits(data, bitIndex, bitCount);
                    bitIndex += bitCount;

                    newValue = sign ? value - delta : value + delta;
                }
                else
                {
                    newValue  = (long)GetValue(data, bitIndex);
                    bitIndex += 64;
                }

                values(index, newValue);
                value = newValue;
            }
        }