< Summary

Class:Itinero.IO.BitCoderStream
Assembly:Itinero
File(s):/home/runner/work/routing2/routing2/src/Itinero/IO/BitCoderStream.cs
Covered lines:144
Uncovered lines:350
Coverable lines:494
Total lines:658
Line coverage:29.1% (144 of 494)
Covered branches:31
Total branches:108
Branch coverage:28.7% (31 of 108)
Tag:224_14471318300

Metrics

MethodBranch coverage Cyclomatic complexity Line coverage
WriteVarUInt32Nullable(...)100%2100%
WriteVarUInt32(...)87.5%881.39%
WriteVarUInt64Nullable(...)0%20%
WriteVarUInt64(...)0%180%
ReadVarUInt32Nullable(...)100%2100%
ReadVarUInt32(...)87.5%884.84%
ReadVarUInt64Nullable(...)0%20%
ReadVarUInt64(...)0%180%
ToUnsigned(...)0%40%
ToUnsigned(...)0%60%
ToUnsigned(...)50%453.84%
ToUnsigned(...)66.66%664.7%
FromUnsigned(...)0%20%
FromUnsigned(...)0%40%
FromUnsigned(...)100%2100%
FromUnsigned(...)75%476.92%
WriteVarInt32Nullable(...)100%1100%
WriteVarInt32(...)100%1100%
WriteGuid(...)100%1100%
ReadGuid(...)100%1100%
ReadVarInt32Nullable(...)100%1100%
ReadVarInt32(...)100%1100%
WriteVarInt64Nullable(...)100%10%
WriteVarInt64(...)100%10%
ReadVarInt64Nullable(...)100%10%
ReadVarInt64(...)100%10%
WriteInt64(...)0%20%
ReadInt64(...)100%2100%
WriteUInt32(...)0%20%
ReadUInt32(...)0%20%
WriteUInt64(...)0%20%
ReadUInt64(...)0%20%
WriteInt32(...)0%20%
ReadInt32(...)0%20%

File(s)

/home/runner/work/routing2/routing2/src/Itinero/IO/BitCoderStream.cs

#LineLine coverage
 1using System;
 2using System.IO;
 3
 4namespace Itinero.IO;
 5
 6internal static class BitCoderStream
 7{
 8    private const byte Mask = 128 - 1;
 9
 10    public static void WriteVarUInt32Nullable(this Stream stream, uint? value)
 811    {
 812        if (value == null)
 613        {
 614            stream.WriteVarUInt32(0);
 615        }
 16        else
 217        {
 218            stream.WriteVarUInt32(value.Value + 1);
 219        }
 820    }
 21
 22    public static void WriteVarUInt32(this Stream stream, uint value)
 16023    {
 16024        var d0 = (byte)(value & Mask);
 16025        value >>= 7;
 16026        if (value == 0)
 14627        {
 14628            stream.WriteByte(d0);
 14629            return;
 30        }
 31
 1432        d0 += 128;
 1433        var d1 = (byte)(value & Mask);
 1434        value >>= 7;
 1435        if (value == 0)
 536        {
 537            stream.WriteByte(d0);
 538            stream.WriteByte(d1);
 539            return;
 40        }
 41
 942        d1 += 128;
 943        var d2 = (byte)(value & Mask);
 944        value >>= 7;
 945        if (value == 0)
 146        {
 147            stream.WriteByte(d0);
 148            stream.WriteByte(d1);
 149            stream.WriteByte(d2);
 150            return;
 51        }
 52
 853        d2 += 128;
 854        var d3 = (byte)(value & Mask);
 855        value >>= 7;
 856        if (value == 0)
 857        {
 858            stream.WriteByte(d0);
 859            stream.WriteByte(d1);
 860            stream.WriteByte(d2);
 861            stream.WriteByte(d3);
 862            return;
 63        }
 64
 065        d3 += 128;
 066        var d4 = (byte)(value & Mask);
 067        stream.WriteByte(d0);
 068        stream.WriteByte(d1);
 069        stream.WriteByte(d2);
 070        stream.WriteByte(d3);
 071        stream.WriteByte(d4);
 072        return;
 16073    }
 74
 75
 76    public static void WriteVarUInt64Nullable(this Stream stream, ulong? value)
 077    {
 078        if (value == null)
 079        {
 080            stream.WriteVarUInt64(0);
 081        }
 82        else
 083        {
 084            stream.WriteVarUInt64(value.Value + 1);
 085        }
 086    }
 87
 88    public static void WriteVarUInt64(this Stream stream, ulong value)
 089    {
 090        var d0 = (byte)(value & Mask);
 091        value >>= 7;
 092        if (value == 0)
 093        {
 094            stream.WriteByte(d0);
 095            return;
 96        }
 97
 098        d0 += 128;
 099        var d1 = (byte)(value & Mask);
 0100        value >>= 7;
 0101        if (value == 0)
 0102        {
 0103            stream.WriteByte(d0);
 0104            stream.WriteByte(d1);
 0105            return;
 106        }
 107
 0108        d1 += 128;
 0109        var d2 = (byte)(value & Mask);
 0110        value >>= 7;
 0111        if (value == 0)
 0112        {
 0113            stream.WriteByte(d0);
 0114            stream.WriteByte(d1);
 0115            stream.WriteByte(d2);
 0116            return;
 117        }
 118
 0119        d2 += 128;
 0120        var d3 = (byte)(value & Mask);
 0121        value >>= 7;
 0122        if (value == 0)
 0123        {
 0124            stream.WriteByte(d0);
 0125            stream.WriteByte(d1);
 0126            stream.WriteByte(d2);
 0127            stream.WriteByte(d3);
 0128            return;
 129        }
 130
 0131        d3 += 128;
 0132        var d4 = (byte)(value & Mask);
 0133        value >>= 7;
 0134        if (value == 0)
 0135        {
 0136            stream.WriteByte(d0);
 0137            stream.WriteByte(d1);
 0138            stream.WriteByte(d2);
 0139            stream.WriteByte(d3);
 0140            stream.WriteByte(d4);
 0141            return;
 142        }
 143
 0144        d4 += 128;
 0145        var d5 = (byte)(value & Mask);
 0146        value >>= 7;
 0147        if (value == 0)
 0148        {
 0149            stream.WriteByte(d0);
 0150            stream.WriteByte(d1);
 0151            stream.WriteByte(d2);
 0152            stream.WriteByte(d3);
 0153            stream.WriteByte(d4);
 0154            stream.WriteByte(d5);
 0155            return;
 156        }
 157
 0158        d5 += 128;
 0159        var d6 = (byte)(value & Mask);
 0160        value >>= 7;
 0161        if (value == 0)
 0162        {
 0163            stream.WriteByte(d0);
 0164            stream.WriteByte(d1);
 0165            stream.WriteByte(d2);
 0166            stream.WriteByte(d3);
 0167            stream.WriteByte(d4);
 0168            stream.WriteByte(d5);
 0169            stream.WriteByte(d6);
 0170            return;
 171        }
 172
 0173        d6 += 128;
 0174        var d7 = (byte)(value & Mask);
 0175        value >>= 7;
 0176        if (value == 0)
 0177        {
 0178            stream.WriteByte(d0);
 0179            stream.WriteByte(d1);
 0180            stream.WriteByte(d2);
 0181            stream.WriteByte(d3);
 0182            stream.WriteByte(d4);
 0183            stream.WriteByte(d5);
 0184            stream.WriteByte(d6);
 0185            stream.WriteByte(d7);
 0186            return;
 187        }
 188
 0189        d7 += 128;
 0190        var d8 = (byte)(value & Mask);
 0191        value >>= 7;
 0192        if (value == 0)
 0193        {
 0194            stream.WriteByte(d0);
 0195            stream.WriteByte(d1);
 0196            stream.WriteByte(d2);
 0197            stream.WriteByte(d3);
 0198            stream.WriteByte(d4);
 0199            stream.WriteByte(d5);
 0200            stream.WriteByte(d6);
 0201            stream.WriteByte(d7);
 0202            stream.WriteByte(d8);
 0203            return;
 204        }
 205
 0206        d8 += 128;
 0207        var d9 = (byte)(value & Mask);
 0208        stream.WriteByte(d0);
 0209        stream.WriteByte(d1);
 0210        stream.WriteByte(d2);
 0211        stream.WriteByte(d3);
 0212        stream.WriteByte(d4);
 0213        stream.WriteByte(d5);
 0214        stream.WriteByte(d6);
 0215        stream.WriteByte(d7);
 0216        stream.WriteByte(d8);
 0217        stream.WriteByte(d9);
 0218        return;
 0219    }
 220
 221    public static uint? ReadVarUInt32Nullable(this Stream stream)
 8222    {
 8223        var value = stream.ReadVarUInt32();
 8224        if (value == 0)
 6225        {
 6226            return null;
 227        }
 228
 2229        return value - 1;
 8230    }
 231
 232    public static uint ReadVarUInt32(this Stream stream)
 156233    {
 156234        var value = 0U;
 156235        var d = stream.ReadByte();
 156236        if (d < 128)
 142237        {
 142238            value = (uint)d;
 142239            return value;
 240        }
 241
 14242        value = (uint)d - 128;
 14243        d = stream.ReadByte();
 14244        if (d < 128)
 5245        {
 5246            value += (uint)d << 7;
 5247            return value;
 248        }
 249
 9250        d -= 128;
 9251        value += (uint)d << 7;
 9252        d = stream.ReadByte();
 9253        if (d < 128)
 1254        {
 1255            value += (uint)d << 14;
 1256            return value;
 257        }
 258
 8259        d -= 128;
 8260        value += (uint)d << 14;
 8261        d = stream.ReadByte();
 8262        if (d < 128)
 8263        {
 8264            value += (uint)d << 21;
 8265            return value;
 266        }
 267
 0268        d -= 128;
 0269        value += (uint)d << 21;
 0270        d = stream.ReadByte();
 0271        value += (uint)d << 28;
 0272        return value;
 156273    }
 274
 275    public static ulong? ReadVarUInt64Nullable(this Stream stream)
 0276    {
 0277        var value = stream.ReadVarUInt64();
 0278        if (value == 0)
 0279        {
 0280            return null;
 281        }
 282
 0283        return value - 1;
 0284    }
 285
 286    public static ulong ReadVarUInt64(this Stream stream)
 0287    {
 0288        var value = 0UL;
 0289        var d = stream.ReadByte();
 0290        if (d < 128)
 0291        {
 0292            value = (ulong)d;
 0293            return value;
 294        }
 295
 0296        value = (ulong)d - 128;
 0297        d = stream.ReadByte();
 0298        ;
 0299        if (d < 128)
 0300        {
 0301            value += (uint)d << 7;
 0302            return value;
 303        }
 304
 0305        d -= 128;
 0306        value += (ulong)d << 7;
 0307        d = stream.ReadByte();
 0308        ;
 0309        if (d < 128)
 0310        {
 0311            value += (uint)d << 14;
 0312            return value;
 313        }
 314
 0315        d -= 128;
 0316        value += (ulong)d << 14;
 0317        d = stream.ReadByte();
 0318        ;
 0319        if (d < 128)
 0320        {
 0321            value += (ulong)d << 21;
 0322            return value;
 323        }
 324
 0325        d -= 128;
 0326        value += (ulong)d << 21;
 0327        d = stream.ReadByte();
 0328        ;
 0329        if (d < 128)
 0330        {
 0331            value += (ulong)d << 28;
 0332            return value;
 333        }
 334
 0335        d -= 128;
 0336        value += (ulong)d << 28;
 0337        d = stream.ReadByte();
 0338        ;
 0339        if (d < 128)
 0340        {
 0341            value += (ulong)d << 35;
 0342            return value;
 343        }
 344
 0345        d -= 128;
 0346        value += (ulong)d << 35;
 0347        d = stream.ReadByte();
 0348        ;
 0349        if (d < 128)
 0350        {
 0351            value += (ulong)d << 42;
 0352            return value;
 353        }
 354
 0355        d -= 128;
 0356        value += (ulong)d << 42;
 0357        d = stream.ReadByte();
 0358        ;
 0359        if (d < 128)
 0360        {
 0361            value += (ulong)d << 49;
 0362            return value;
 363        }
 364
 0365        d -= 128;
 0366        value += (ulong)d << 49;
 0367        d = stream.ReadByte();
 0368        ;
 0369        if (d < 128)
 0370        {
 0371            value += (ulong)d << 56;
 0372            return value;
 373        }
 374
 0375        d -= 128;
 0376        value += (ulong)d << 56;
 0377        d = stream.ReadByte();
 0378        ;
 0379        value += (ulong)d << 63;
 0380        return value;
 0381    }
 382
 383    private static ulong ToUnsigned(long value)
 0384    {
 0385        var unsigned = (ulong)value;
 0386        if (value < 0)
 0387        {
 0388            unsigned = (ulong)-value;
 0389        }
 390
 0391        unsigned <<= 1;
 0392        if (value < 0)
 0393        {
 0394            unsigned += 1;
 0395        }
 396
 0397        return unsigned;
 0398    }
 399
 400    private static ulong? ToUnsigned(long? valueNullable)
 0401    {
 0402        if (valueNullable == null)
 0403        {
 0404            return null;
 405        }
 406
 0407        var value = valueNullable.Value;
 0408        var unsigned = (ulong)value;
 0409        if (value < 0)
 0410        {
 0411            unsigned = (ulong)-value;
 0412        }
 413
 0414        unsigned <<= 1;
 0415        if (value < 0)
 0416        {
 0417            unsigned += 1;
 0418        }
 419
 0420        return unsigned;
 0421    }
 422
 423    private static uint ToUnsigned(int value)
 63424    {
 63425        var unsigned = (uint)value;
 63426        if (value < 0)
 0427        {
 0428            unsigned = (uint)-value;
 0429        }
 430
 63431        unsigned <<= 1;
 63432        if (value < 0)
 0433        {
 0434            unsigned += 1;
 0435        }
 436
 63437        return unsigned;
 63438    }
 439
 440    private static uint? ToUnsigned(int? valueNullable)
 8441    {
 8442        if (valueNullable == null)
 6443        {
 6444            return null;
 445        }
 446
 2447        var value = valueNullable.Value;
 2448        var unsigned = (uint)value;
 2449        if (value < 0)
 0450        {
 0451            unsigned = (uint)-value;
 0452        }
 453
 2454        unsigned <<= 1;
 2455        if (value < 0)
 0456        {
 0457            unsigned += 1;
 0458        }
 459
 2460        return unsigned;
 8461    }
 462
 463    private static long FromUnsigned(ulong unsigned)
 0464    {
 0465        var sign = unsigned & (uint)1;
 466
 0467        var value = (long)(unsigned >> 1);
 0468        if (sign == 1)
 0469        {
 0470            value = -value;
 0471        }
 472
 0473        return value;
 0474    }
 475
 476    private static long? FromUnsigned(ulong? unsignedNullable)
 0477    {
 0478        if (unsignedNullable == null)
 0479        {
 0480            return null;
 481        }
 482
 0483        var unsigned = unsignedNullable.Value;
 0484        var sign = unsigned & (uint)1;
 485
 0486        var value = (long)(unsigned >> 1);
 0487        if (sign == 1)
 0488        {
 0489            value = -value;
 0490        }
 491
 0492        return value;
 0493    }
 494
 495    private static int FromUnsigned(uint unsigned)
 59496    {
 59497        var sign = unsigned & (uint)1;
 498
 59499        var value = (int)(unsigned >> 1);
 59500        if (sign == 1)
 1501        {
 1502            value = -value;
 1503        }
 504
 59505        return value;
 59506    }
 507
 508    private static int? FromUnsigned(uint? unsignedNullable)
 8509    {
 8510        if (unsignedNullable == null)
 6511        {
 6512            return null;
 513        }
 514
 2515        var unsigned = unsignedNullable.Value;
 2516        var sign = unsigned & (uint)1;
 517
 2518        var value = (int)(unsigned >> 1);
 2519        if (sign == 1)
 0520        {
 0521            value = -value;
 0522        }
 523
 2524        return value;
 8525    }
 526
 527    public static void WriteVarInt32Nullable(this Stream data, int? value)
 8528    {
 8529        data.WriteVarUInt32Nullable(ToUnsigned(value));
 8530    }
 531
 532    public static void WriteVarInt32(this Stream data, int value)
 63533    {
 63534        data.WriteVarUInt32(ToUnsigned(value));
 63535    }
 536
 537    public static void WriteGuid(this Stream data, Guid value)
 8538    {
 8539        data.Write(value.ToByteArray());
 8540    }
 541
 542    public static Guid ReadGuid(this Stream data)
 8543    {
 8544        var buffer = new byte[16];
 8545        data.Read(buffer);
 8546        return new Guid(buffer);
 8547    }
 548
 549    public static int? ReadVarInt32Nullable(this Stream data)
 8550    {
 8551        return FromUnsigned(data.ReadVarUInt32Nullable());
 8552    }
 553
 554    public static int ReadVarInt32(this Stream data)
 59555    {
 59556        return FromUnsigned(data.ReadVarUInt32());
 59557    }
 558
 559    public static void WriteVarInt64Nullable(this Stream data, long? value)
 0560    {
 0561        data.WriteVarUInt64Nullable(ToUnsigned(value));
 0562    }
 563
 564    public static void WriteVarInt64(this Stream data, long value)
 0565    {
 0566        data.WriteVarUInt64(ToUnsigned(value));
 0567    }
 568
 569    public static long? ReadVarInt64Nullable(this Stream data)
 0570    {
 0571        return FromUnsigned(data.ReadVarUInt64Nullable());
 0572    }
 573
 574    public static long ReadVarInt64(this Stream data)
 0575    {
 0576        return FromUnsigned(data.ReadVarUInt64());
 0577    }
 578
 579    public static void WriteInt64(this Stream stream, long value)
 0580    {
 0581        for (var b = 0; b < 8; b++)
 0582        {
 0583            stream.WriteByte((byte)(value & byte.MaxValue));
 0584            value >>= 8;
 0585        }
 0586    }
 587
 588    public static long ReadInt64(this Stream stream)
 23589    {
 23590        var value = 0L;
 414591        for (var b = 0; b < 8; b++)
 184592        {
 184593            value += (long)stream.ReadByte() << (b * 8);
 184594        }
 595
 23596        return value;
 23597    }
 598
 599    public static void WriteUInt32(this Stream stream, uint value)
 0600    {
 0601        for (var b = 0; b < 4; b++)
 0602        {
 0603            stream.WriteByte((byte)(value & byte.MaxValue));
 0604            value >>= 8;
 0605        }
 0606    }
 607
 608    public static uint ReadUInt32(this Stream stream)
 0609    {
 0610        var value = 0U;
 0611        for (var b = 0; b < 4; b++)
 0612        {
 0613            value += (uint)stream.ReadByte() << (b * 8);
 0614        }
 615
 0616        return value;
 0617    }
 618
 619    public static void WriteUInt64(this Stream stream, ulong value)
 0620    {
 0621        for (var b = 0; b < 8; b++)
 0622        {
 0623            stream.WriteByte((byte)(value & byte.MaxValue));
 0624            value >>= 8;
 0625        }
 0626    }
 627
 628    public static ulong ReadUInt64(this Stream stream)
 0629    {
 0630        var value = 0UL;
 0631        for (var b = 0; b < 8; b++)
 0632        {
 0633            value += (ulong)stream.ReadByte() << (b * 8);
 0634        }
 635
 0636        return value;
 0637    }
 638
 639    public static void WriteInt32(this Stream stream, int value)
 0640    {
 0641        for (var b = 0; b < 4; b++)
 0642        {
 0643            stream.WriteByte((byte)(value & byte.MaxValue));
 0644            value >>= 8;
 0645        }
 0646    }
 647
 648    public static int ReadInt32(this Stream stream)
 0649    {
 0650        var value = 0;
 0651        for (var b = 0; b < 4; b++)
 0652        {
 0653            value += stream.ReadByte() << (b * 8);
 0654        }
 655
 0656        return value;
 0657    }
 658}
Generated by: ReportGenerator 4.8.2.0
04/15/2025 - 13:59:49
GitHub | www.palmmedia.de

Methods/Properties

WriteVarUInt32Nullable(...)
WriteVarUInt32(...)
WriteVarUInt64Nullable(...)
WriteVarUInt64(...)
ReadVarUInt32Nullable(...)
ReadVarUInt32(...)
ReadVarUInt64Nullable(...)
ReadVarUInt64(...)
ToUnsigned(...)
ToUnsigned(...)
ToUnsigned(...)
ToUnsigned(...)
FromUnsigned(...)
FromUnsigned(...)
FromUnsigned(...)
FromUnsigned(...)
WriteVarInt32Nullable(...)
WriteVarInt32(...)
WriteGuid(...)
ReadGuid(...)
ReadVarInt32Nullable(...)
ReadVarInt32(...)
WriteVarInt64Nullable(...)
WriteVarInt64(...)
ReadVarInt64Nullable(...)
ReadVarInt64(...)
WriteInt64(...)
ReadInt64(...)
WriteUInt32(...)
ReadUInt32(...)
WriteUInt64(...)
ReadUInt64(...)
WriteInt32(...)
ReadInt32(...)