Zig() static private method

static private Zig ( int value ) : uint
value int
return uint
Ejemplo n.º 1
0
        public static void WriteInt64(long value, ProtoWriter writer)
        {
            byte[] numArray;
            int    num;

            if (writer == null)
            {
                throw new ArgumentNullException("writer");
            }
            ProtoBuf.WireType wireType = writer.wireType;
            switch (wireType)
            {
            case ProtoBuf.WireType.Variant:
            {
                if (value >= (long)0)
                {
                    ProtoWriter.WriteUInt64Variant((ulong)value, writer);
                    writer.wireType = ProtoBuf.WireType.None;
                    return;
                }
                ProtoWriter.DemandSpace(10, writer);
                numArray          = writer.ioBuffer;
                num               = writer.ioIndex;
                numArray[num]     = (byte)(value | (long)128);
                numArray[num + 1] = (byte)((int)(value >> 7) | 128);
                numArray[num + 2] = (byte)((int)(value >> 14) | 128);
                numArray[num + 3] = (byte)((int)(value >> 21) | 128);
                numArray[num + 4] = (byte)((int)(value >> 28) | 128);
                numArray[num + 5] = (byte)((int)(value >> 35) | 128);
                numArray[num + 6] = (byte)((int)(value >> 42) | 128);
                numArray[num + 7] = (byte)((int)(value >> 49) | 128);
                numArray[num + 8] = (byte)((int)(value >> 56) | 128);
                numArray[num + 9] = 1;
                ProtoWriter.IncrementedAndReset(10, writer);
                return;
            }

            case ProtoBuf.WireType.Fixed64:
            {
                ProtoWriter.DemandSpace(8, writer);
                numArray          = writer.ioBuffer;
                num               = writer.ioIndex;
                numArray[num]     = (byte)value;
                numArray[num + 1] = (byte)(value >> 8);
                numArray[num + 2] = (byte)(value >> 16);
                numArray[num + 3] = (byte)(value >> 24);
                numArray[num + 4] = (byte)(value >> 32);
                numArray[num + 5] = (byte)(value >> 40);
                numArray[num + 6] = (byte)(value >> 48);
                numArray[num + 7] = (byte)(value >> 56);
                ProtoWriter.IncrementedAndReset(8, writer);
                return;
            }

            default:
            {
                if (wireType == ProtoBuf.WireType.Fixed32)
                {
                    break;
                }
                else
                {
                    if (wireType != ProtoBuf.WireType.SignedVariant)
                    {
                        throw ProtoWriter.CreateException(writer);
                    }
                    ProtoWriter.WriteUInt64Variant(ProtoWriter.Zig(value), writer);
                    writer.wireType = ProtoBuf.WireType.None;
                    return;
                }
            }
            }
            ProtoWriter.WriteInt32(checked ((int)value), writer);
        }
Ejemplo n.º 2
0
        public static void WriteInt32(int value, ProtoWriter writer)
        {
            byte[] numArray;
            int    num;

            if (writer == null)
            {
                throw new ArgumentNullException("writer");
            }
            ProtoBuf.WireType wireType = writer.wireType;
            switch (wireType)
            {
            case ProtoBuf.WireType.Variant:
            {
                if (value >= 0)
                {
                    ProtoWriter.WriteUInt32Variant((uint)value, writer);
                    writer.wireType = ProtoBuf.WireType.None;
                    return;
                }
                ProtoWriter.DemandSpace(10, writer);
                numArray          = writer.ioBuffer;
                num               = writer.ioIndex;
                numArray[num]     = (byte)(value | 128);
                numArray[num + 1] = (byte)(value >> 7 | 128);
                numArray[num + 2] = (byte)(value >> 14 | 128);
                numArray[num + 3] = (byte)(value >> 21 | 128);
                numArray[num + 4] = (byte)(value >> 28 | 128);
                int  num1 = 255;
                byte num2 = (byte)num1;
                numArray[num + 8] = (byte)num1;
                byte num3 = num2;
                byte num4 = num3;
                numArray[num + 7] = num3;
                byte num5 = num4;
                byte num6 = num5;
                numArray[num + 6] = num5;
                numArray[num + 5] = num6;
                numArray[num + 9] = 1;
                ProtoWriter.IncrementedAndReset(10, writer);
                return;
            }

            case ProtoBuf.WireType.Fixed64:
            {
                ProtoWriter.DemandSpace(8, writer);
                numArray          = writer.ioBuffer;
                num               = writer.ioIndex;
                numArray[num]     = (byte)value;
                numArray[num + 1] = (byte)(value >> 8);
                numArray[num + 2] = (byte)(value >> 16);
                numArray[num + 3] = (byte)(value >> 24);
                int  num7 = 0;
                byte num8 = (byte)num7;
                numArray[num + 7] = (byte)num7;
                byte num9  = num8;
                byte num10 = num9;
                numArray[num + 6] = num9;
                byte num11 = num10;
                byte num12 = num11;
                numArray[num + 5] = num11;
                numArray[num + 4] = num12;
                ProtoWriter.IncrementedAndReset(8, writer);
                return;
            }

            default:
            {
                if (wireType == ProtoBuf.WireType.Fixed32)
                {
                    break;
                }
                else
                {
                    if (wireType != ProtoBuf.WireType.SignedVariant)
                    {
                        throw ProtoWriter.CreateException(writer);
                    }
                    ProtoWriter.WriteUInt32Variant(ProtoWriter.Zig(value), writer);
                    writer.wireType = ProtoBuf.WireType.None;
                    return;
                }
            }
            }
            ProtoWriter.DemandSpace(4, writer);
            ProtoWriter.WriteInt32ToBuffer(value, writer.ioBuffer, writer.ioIndex);
            ProtoWriter.IncrementedAndReset(4, writer);
        }
Ejemplo n.º 3
0
        // Token: 0x06000160 RID: 352 RVA: 0x0000DAB0 File Offset: 0x0000BCB0
        public static void WriteInt32(int value, ProtoWriter writer)
        {
            if (writer == null)
            {
                throw new ArgumentNullException("writer");
            }
            WireType wireType = writer.wireType;

            if (wireType <= WireType.Fixed64)
            {
                if (wireType != WireType.Variant)
                {
                    if (wireType == WireType.Fixed64)
                    {
                        ProtoWriter.DemandSpace(8, writer);
                        byte[] array = writer.ioBuffer;
                        int    num   = writer.ioIndex;
                        array[num]     = (byte)value;
                        array[num + 1] = (byte)(value >> 8);
                        array[num + 2] = (byte)(value >> 16);
                        array[num + 3] = (byte)(value >> 24);
                        array[num + 4] = (array[num + 5] = (array[num + 6] = (array[num + 7] = 0)));
                        ProtoWriter.IncrementedAndReset(8, writer);
                        return;
                    }
                }
                else
                {
                    if (value >= 0)
                    {
                        ProtoWriter.WriteUInt32Variant((uint)value, writer);
                        writer.wireType = WireType.None;
                        return;
                    }
                    ProtoWriter.DemandSpace(10, writer);
                    byte[] array = writer.ioBuffer;
                    int    num   = writer.ioIndex;
                    array[num]     = (byte)(value | 128);
                    array[num + 1] = (byte)(value >> 7 | 128);
                    array[num + 2] = (byte)(value >> 14 | 128);
                    array[num + 3] = (byte)(value >> 21 | 128);
                    array[num + 4] = (byte)(value >> 28 | 128);
                    array[num + 5] = (array[num + 6] = (array[num + 7] = (array[num + 8] = byte.MaxValue)));
                    array[num + 9] = 1;
                    ProtoWriter.IncrementedAndReset(10, writer);
                    return;
                }
            }
            else
            {
                if (wireType == WireType.Fixed32)
                {
                    ProtoWriter.DemandSpace(4, writer);
                    ProtoWriter.WriteInt32ToBuffer(value, writer.ioBuffer, writer.ioIndex);
                    ProtoWriter.IncrementedAndReset(4, writer);
                    return;
                }
                if (wireType == WireType.SignedVariant)
                {
                    ProtoWriter.WriteUInt32Variant(ProtoWriter.Zig(value), writer);
                    writer.wireType = WireType.None;
                    return;
                }
            }
            throw ProtoWriter.CreateException(writer);
        }
Ejemplo n.º 4
0
        public static void WriteInt32(int value, ProtoWriter writer)
        {
            if (writer == null)
            {
                throw new ArgumentNullException("writer");
            }
            WireType wireType = writer.wireType;

            switch (wireType)
            {
            case WireType.Variant:
                if (value >= 0)
                {
                    ProtoWriter.WriteUInt32Variant((uint)value, writer);
                    writer.wireType = WireType.None;
                }
                else
                {
                    ProtoWriter.DemandSpace(10, writer);
                    byte[] array = writer.ioBuffer;
                    int    num   = writer.ioIndex;
                    array[num]     = (byte)(value | 128);
                    array[num + 1] = (byte)(value >> 7 | 128);
                    array[num + 2] = (byte)(value >> 14 | 128);
                    array[num + 3] = (byte)(value >> 21 | 128);
                    array[num + 4] = (byte)(value >> 28 | 128);
                    array[num + 5] = (array[num + 6] = (array[num + 7] = (array[num + 8] = 255)));
                    array[num + 9] = 1;
                    ProtoWriter.IncrementedAndReset(10, writer);
                }
                return;

            case WireType.Fixed64:
            {
                ProtoWriter.DemandSpace(8, writer);
                byte[] array = writer.ioBuffer;
                int    num   = writer.ioIndex;
                array[num]     = (byte)value;
                array[num + 1] = (byte)(value >> 8);
                array[num + 2] = (byte)(value >> 16);
                array[num + 3] = (byte)(value >> 24);
                array[num + 4] = (array[num + 5] = (array[num + 6] = (array[num + 7] = 0)));
                ProtoWriter.IncrementedAndReset(8, writer);
                return;
            }

            case WireType.String:
            case WireType.StartGroup:
            case WireType.EndGroup:
IL_36:
                if (wireType != WireType.SignedVariant)
                {
                    throw ProtoWriter.CreateException(writer);
                }
                ProtoWriter.WriteUInt32Variant(ProtoWriter.Zig(value), writer);
                writer.wireType = WireType.None;
                return;

            case WireType.Fixed32:
                ProtoWriter.DemandSpace(4, writer);
                ProtoWriter.WriteInt32ToBuffer(value, writer.ioBuffer, writer.ioIndex);
                ProtoWriter.IncrementedAndReset(4, writer);
                return;
            }
            goto IL_36;
        }
Ejemplo n.º 5
0
        // Token: 0x06000159 RID: 345 RVA: 0x0000D8C4 File Offset: 0x0000BAC4
        public static void WriteInt64(long value, ProtoWriter writer)
        {
            if (writer == null)
            {
                throw new ArgumentNullException("writer");
            }
            WireType wireType = writer.wireType;

            if (wireType <= WireType.Fixed64)
            {
                if (wireType != WireType.Variant)
                {
                    if (wireType == WireType.Fixed64)
                    {
                        ProtoWriter.DemandSpace(8, writer);
                        byte[] array = writer.ioBuffer;
                        int    num   = writer.ioIndex;
                        array[num]     = (byte)value;
                        array[num + 1] = (byte)(value >> 8);
                        array[num + 2] = (byte)(value >> 16);
                        array[num + 3] = (byte)(value >> 24);
                        array[num + 4] = (byte)(value >> 32);
                        array[num + 5] = (byte)(value >> 40);
                        array[num + 6] = (byte)(value >> 48);
                        array[num + 7] = (byte)(value >> 56);
                        ProtoWriter.IncrementedAndReset(8, writer);
                        return;
                    }
                }
                else
                {
                    if (value >= 0L)
                    {
                        ProtoWriter.WriteUInt64Variant((ulong)value, writer);
                        writer.wireType = WireType.None;
                        return;
                    }
                    ProtoWriter.DemandSpace(10, writer);
                    byte[] array2 = writer.ioBuffer;
                    int    num    = writer.ioIndex;
                    array2[num]     = (byte)(value | 128L);
                    array2[num + 1] = (byte)((int)(value >> 7) | 128);
                    array2[num + 2] = (byte)((int)(value >> 14) | 128);
                    array2[num + 3] = (byte)((int)(value >> 21) | 128);
                    array2[num + 4] = (byte)((int)(value >> 28) | 128);
                    array2[num + 5] = (byte)((int)(value >> 35) | 128);
                    array2[num + 6] = (byte)((int)(value >> 42) | 128);
                    array2[num + 7] = (byte)((int)(value >> 49) | 128);
                    array2[num + 8] = (byte)((int)(value >> 56) | 128);
                    array2[num + 9] = 1;
                    ProtoWriter.IncrementedAndReset(10, writer);
                    return;
                }
            }
            else
            {
                if (wireType == WireType.Fixed32)
                {
                    ProtoWriter.WriteInt32(checked ((int)value), writer);
                    return;
                }
                if (wireType == WireType.SignedVariant)
                {
                    ProtoWriter.WriteUInt64Variant(ProtoWriter.Zig(value), writer);
                    writer.wireType = WireType.None;
                    return;
                }
            }
            throw ProtoWriter.CreateException(writer);
        }