< Summary

Class:Itinero.IO.Osm.Tiles.StreamExtensions
Assembly:Itinero.IO.Osm.Tiles
File(s):/home/runner/work/routing2/routing2/src/Itinero.IO.Osm.Tiles/StreamExtensions.cs
Covered lines:123
Uncovered lines:378
Coverable lines:501
Total lines:667
Line coverage:24.5% (123 of 501)
Covered branches:21
Total branches:108
Branch coverage:19.4% (21 of 108)
Tag:236_17851749384

Metrics

MethodBranch coverage Cyclomatic complexity Line coverage
WriteVarUInt32Nullable(...)0%20%
WriteVarUInt32(...)50%851.16%
WriteVarUInt64Nullable(...)0%20%
WriteVarUInt64(...)22.22%1818.58%
ReadVarUInt32Nullable(...)0%20%
ReadVarUInt32(...)50%854.54%
ReadVarUInt64Nullable(...)0%20%
ReadVarUInt64(...)22.22%1825.97%
ToUnsigned(...)50%453.84%
ToUnsigned(...)0%60%
ToUnsigned(...)0%40%
ToUnsigned(...)0%60%
FromUnsigned(...)50%266.66%
FromUnsigned(...)0%40%
FromUnsigned(...)0%20%
FromUnsigned(...)0%40%
WriteVarInt32Nullable(...)100%10%
WriteVarInt32(...)100%10%
ReadVarInt32Nullable(...)100%10%
ReadVarInt32(...)100%10%
WriteVarInt64Nullable(...)100%10%
WriteVarInt64(...)100%1100%
ReadVarInt64Nullable(...)100%10%
ReadVarInt64(...)100%1100%
WriteInt64(...)0%20%
ReadInt64(...)100%2100%
WriteUInt32(...)0%20%
ReadUInt32(...)0%20%
WriteUInt64(...)0%20%
ReadUInt64(...)0%20%
WriteInt32(...)0%20%
ReadInt32(...)0%20%
WriteWithSize(...)100%1100%
WriteWithSize(...)100%1100%
ReadWithSizeString(...)100%1100%

File(s)

/home/runner/work/routing2/routing2/src/Itinero.IO.Osm.Tiles/StreamExtensions.cs

#LineLine coverage
 1using System.IO;
 2
 3namespace Itinero.IO.Osm.Tiles;
 4
 5internal static class StreamExtensions
 6{
 7    private const byte Mask = 128 - 1;
 8
 9    public static void WriteVarUInt32Nullable(this Stream stream, uint? value)
 010    {
 011        if (value == null)
 012        {
 013            stream.WriteVarUInt32(0);
 014        }
 15        else
 016        {
 017            stream.WriteVarUInt32(value.Value + 1);
 018        }
 019    }
 20
 21    public static void WriteVarUInt32(this Stream stream, uint value)
 422    {
 423        var d0 = (byte)(value & Mask);
 424        value >>= 7;
 425        if (value == 0)
 026        {
 027            stream.WriteByte(d0);
 028            return;
 29        }
 30
 431        d0 += 128;
 432        var d1 = (byte)(value & Mask);
 433        value >>= 7;
 434        if (value == 0)
 235        {
 236            stream.WriteByte(d0);
 237            stream.WriteByte(d1);
 238            return;
 39        }
 40
 241        d1 += 128;
 242        var d2 = (byte)(value & Mask);
 243        value >>= 7;
 244        if (value == 0)
 245        {
 246            stream.WriteByte(d0);
 247            stream.WriteByte(d1);
 248            stream.WriteByte(d2);
 249            return;
 50        }
 51
 052        d2 += 128;
 053        var d3 = (byte)(value & Mask);
 054        value >>= 7;
 055        if (value == 0)
 056        {
 057            stream.WriteByte(d0);
 058            stream.WriteByte(d1);
 059            stream.WriteByte(d2);
 060            stream.WriteByte(d3);
 061            return;
 62        }
 63
 064        d3 += 128;
 065        var d4 = (byte)(value & Mask);
 066        stream.WriteByte(d0);
 067        stream.WriteByte(d1);
 068        stream.WriteByte(d2);
 069        stream.WriteByte(d3);
 070        stream.WriteByte(d4);
 071        return;
 472    }
 73
 74
 75    public static void WriteVarUInt64Nullable(this Stream stream, ulong? value)
 076    {
 077        if (value == null)
 078        {
 079            stream.WriteVarUInt64(0);
 080        }
 81        else
 082        {
 083            stream.WriteVarUInt64(value.Value + 1);
 084        }
 085    }
 86
 87    public static void WriteVarUInt64(this Stream stream, ulong value)
 388    {
 389        var d0 = (byte)(value & Mask);
 390        value >>= 7;
 391        if (value == 0)
 192        {
 193            stream.WriteByte(d0);
 194            return;
 95        }
 96
 297        d0 += 128;
 298        var d1 = (byte)(value & Mask);
 299        value >>= 7;
 2100        if (value == 0)
 0101        {
 0102            stream.WriteByte(d0);
 0103            stream.WriteByte(d1);
 0104            return;
 105        }
 106
 2107        d1 += 128;
 2108        var d2 = (byte)(value & Mask);
 2109        value >>= 7;
 2110        if (value == 0)
 2111        {
 2112            stream.WriteByte(d0);
 2113            stream.WriteByte(d1);
 2114            stream.WriteByte(d2);
 2115            return;
 116        }
 117
 0118        d2 += 128;
 0119        var d3 = (byte)(value & Mask);
 0120        value >>= 7;
 0121        if (value == 0)
 0122        {
 0123            stream.WriteByte(d0);
 0124            stream.WriteByte(d1);
 0125            stream.WriteByte(d2);
 0126            stream.WriteByte(d3);
 0127            return;
 128        }
 129
 0130        d3 += 128;
 0131        var d4 = (byte)(value & Mask);
 0132        value >>= 7;
 0133        if (value == 0)
 0134        {
 0135            stream.WriteByte(d0);
 0136            stream.WriteByte(d1);
 0137            stream.WriteByte(d2);
 0138            stream.WriteByte(d3);
 0139            stream.WriteByte(d4);
 0140            return;
 141        }
 142
 0143        d4 += 128;
 0144        var d5 = (byte)(value & Mask);
 0145        value >>= 7;
 0146        if (value == 0)
 0147        {
 0148            stream.WriteByte(d0);
 0149            stream.WriteByte(d1);
 0150            stream.WriteByte(d2);
 0151            stream.WriteByte(d3);
 0152            stream.WriteByte(d4);
 0153            stream.WriteByte(d5);
 0154            return;
 155        }
 156
 0157        d5 += 128;
 0158        var d6 = (byte)(value & Mask);
 0159        value >>= 7;
 0160        if (value == 0)
 0161        {
 0162            stream.WriteByte(d0);
 0163            stream.WriteByte(d1);
 0164            stream.WriteByte(d2);
 0165            stream.WriteByte(d3);
 0166            stream.WriteByte(d4);
 0167            stream.WriteByte(d5);
 0168            stream.WriteByte(d6);
 0169            return;
 170        }
 171
 0172        d6 += 128;
 0173        var d7 = (byte)(value & Mask);
 0174        value >>= 7;
 0175        if (value == 0)
 0176        {
 0177            stream.WriteByte(d0);
 0178            stream.WriteByte(d1);
 0179            stream.WriteByte(d2);
 0180            stream.WriteByte(d3);
 0181            stream.WriteByte(d4);
 0182            stream.WriteByte(d5);
 0183            stream.WriteByte(d6);
 0184            stream.WriteByte(d7);
 0185            return;
 186        }
 187
 0188        d7 += 128;
 0189        var d8 = (byte)(value & Mask);
 0190        value >>= 7;
 0191        if (value == 0)
 0192        {
 0193            stream.WriteByte(d0);
 0194            stream.WriteByte(d1);
 0195            stream.WriteByte(d2);
 0196            stream.WriteByte(d3);
 0197            stream.WriteByte(d4);
 0198            stream.WriteByte(d5);
 0199            stream.WriteByte(d6);
 0200            stream.WriteByte(d7);
 0201            stream.WriteByte(d8);
 0202            return;
 203        }
 204
 0205        d8 += 128;
 0206        var d9 = (byte)(value & Mask);
 0207        stream.WriteByte(d0);
 0208        stream.WriteByte(d1);
 0209        stream.WriteByte(d2);
 0210        stream.WriteByte(d3);
 0211        stream.WriteByte(d4);
 0212        stream.WriteByte(d5);
 0213        stream.WriteByte(d6);
 0214        stream.WriteByte(d7);
 0215        stream.WriteByte(d8);
 0216        stream.WriteByte(d9);
 0217        return;
 3218    }
 219
 220    public static uint? ReadVarUInt32Nullable(this Stream stream)
 0221    {
 0222        var value = stream.ReadVarUInt32();
 0223        if (value == 0)
 0224        {
 0225            return null;
 226        }
 227
 0228        return value - 1;
 0229    }
 230
 231    public static uint ReadVarUInt32(this Stream stream)
 4232    {
 4233        var value = 0U;
 4234        var d = stream.ReadByte();
 4235        if (d < 128)
 0236        {
 0237            value = (uint)d;
 0238            return value;
 239        }
 240
 4241        value = (uint)d - 128;
 4242        d = stream.ReadByte();
 4243        if (d < 128)
 2244        {
 2245            value += (uint)d << 7;
 2246            return value;
 247        }
 248
 2249        d -= 128;
 2250        value += (uint)d << 7;
 2251        d = stream.ReadByte();
 2252        if (d < 128)
 2253        {
 2254            value += (uint)d << 14;
 2255            return value;
 256        }
 257
 0258        d -= 128;
 0259        value += (uint)d << 14;
 0260        d = stream.ReadByte();
 0261        if (d < 128)
 0262        {
 0263            value += (uint)d << 21;
 0264            return value;
 265        }
 266
 0267        d -= 128;
 0268        value += (uint)d << 21;
 0269        d = stream.ReadByte();
 0270        value += (uint)d << 28;
 0271        return value;
 4272    }
 273
 274    public static ulong? ReadVarUInt64Nullable(this Stream stream)
 0275    {
 0276        var value = stream.ReadVarUInt64();
 0277        if (value == 0)
 0278        {
 0279            return null;
 280        }
 281
 0282        return value - 1;
 0283    }
 284
 285    public static ulong ReadVarUInt64(this Stream stream)
 3286    {
 3287        var value = 0UL;
 3288        var d = stream.ReadByte();
 3289        if (d < 128)
 1290        {
 1291            value = (ulong)d;
 1292            return value;
 293        }
 294
 2295        value = (ulong)d - 128;
 2296        d = stream.ReadByte();
 2297        ;
 2298        if (d < 128)
 0299        {
 0300            value += (uint)d << 7;
 0301            return value;
 302        }
 303
 2304        d -= 128;
 2305        value += (ulong)d << 7;
 2306        d = stream.ReadByte();
 2307        ;
 2308        if (d < 128)
 2309        {
 2310            value += (uint)d << 14;
 2311            return value;
 312        }
 313
 0314        d -= 128;
 0315        value += (ulong)d << 14;
 0316        d = stream.ReadByte();
 0317        ;
 0318        if (d < 128)
 0319        {
 0320            value += (ulong)d << 21;
 0321            return value;
 322        }
 323
 0324        d -= 128;
 0325        value += (ulong)d << 21;
 0326        d = stream.ReadByte();
 0327        ;
 0328        if (d < 128)
 0329        {
 0330            value += (ulong)d << 28;
 0331            return value;
 332        }
 333
 0334        d -= 128;
 0335        value += (ulong)d << 28;
 0336        d = stream.ReadByte();
 0337        ;
 0338        if (d < 128)
 0339        {
 0340            value += (ulong)d << 35;
 0341            return value;
 342        }
 343
 0344        d -= 128;
 0345        value += (ulong)d << 35;
 0346        d = stream.ReadByte();
 0347        ;
 0348        if (d < 128)
 0349        {
 0350            value += (ulong)d << 42;
 0351            return value;
 352        }
 353
 0354        d -= 128;
 0355        value += (ulong)d << 42;
 0356        d = stream.ReadByte();
 0357        ;
 0358        if (d < 128)
 0359        {
 0360            value += (ulong)d << 49;
 0361            return value;
 362        }
 363
 0364        d -= 128;
 0365        value += (ulong)d << 49;
 0366        d = stream.ReadByte();
 0367        ;
 0368        if (d < 128)
 0369        {
 0370            value += (ulong)d << 56;
 0371            return value;
 372        }
 373
 0374        d -= 128;
 0375        value += (ulong)d << 56;
 0376        d = stream.ReadByte();
 0377        ;
 0378        value += (ulong)d << 63;
 0379        return value;
 3380    }
 381
 382    private static ulong ToUnsigned(long value)
 3383    {
 3384        var unsigned = (ulong)value;
 3385        if (value < 0)
 0386        {
 0387            unsigned = (ulong)-value;
 0388        }
 389
 3390        unsigned <<= 1;
 3391        if (value < 0)
 0392        {
 0393            unsigned += 1;
 0394        }
 395
 3396        return unsigned;
 3397    }
 398
 399    private static ulong? ToUnsigned(long? valueNullable)
 0400    {
 0401        if (valueNullable == null)
 0402        {
 0403            return null;
 404        }
 405
 0406        var value = valueNullable.Value;
 0407        var unsigned = (ulong)value;
 0408        if (value < 0)
 0409        {
 0410            unsigned = (ulong)-value;
 0411        }
 412
 0413        unsigned <<= 1;
 0414        if (value < 0)
 0415        {
 0416            unsigned += 1;
 0417        }
 418
 0419        return unsigned;
 0420    }
 421
 422    private static uint ToUnsigned(int value)
 0423    {
 0424        var unsigned = (uint)value;
 0425        if (value < 0)
 0426        {
 0427            unsigned = (uint)-value;
 0428        }
 429
 0430        unsigned <<= 1;
 0431        if (value < 0)
 0432        {
 0433            unsigned += 1;
 0434        }
 435
 0436        return unsigned;
 0437    }
 438
 439    private static uint? ToUnsigned(int? valueNullable)
 0440    {
 0441        if (valueNullable == null)
 0442        {
 0443            return null;
 444        }
 445
 0446        var value = valueNullable.Value;
 0447        var unsigned = (uint)value;
 0448        if (value < 0)
 0449        {
 0450            unsigned = (uint)-value;
 0451        }
 452
 0453        unsigned <<= 1;
 0454        if (value < 0)
 0455        {
 0456            unsigned += 1;
 0457        }
 458
 0459        return unsigned;
 0460    }
 461
 462    private static long FromUnsigned(ulong unsigned)
 3463    {
 3464        var sign = unsigned & (uint)1;
 465
 3466        var value = (long)(unsigned >> 1);
 3467        if (sign == 1)
 0468        {
 0469            value = -value;
 0470        }
 471
 3472        return value;
 3473    }
 474
 475    private static long? FromUnsigned(ulong? unsignedNullable)
 0476    {
 0477        if (unsignedNullable == null)
 0478        {
 0479            return null;
 480        }
 481
 0482        var unsigned = unsignedNullable.Value;
 0483        var sign = unsigned & (uint)1;
 484
 0485        var value = (long)(unsigned >> 1);
 0486        if (sign == 1)
 0487        {
 0488            value = -value;
 0489        }
 490
 0491        return value;
 0492    }
 493
 494    private static int FromUnsigned(uint unsigned)
 0495    {
 0496        var sign = unsigned & (uint)1;
 497
 0498        var value = (int)(unsigned >> 1);
 0499        if (sign == 1)
 0500        {
 0501            value = -value;
 0502        }
 503
 0504        return value;
 0505    }
 506
 507    private static int? FromUnsigned(uint? unsignedNullable)
 0508    {
 0509        if (unsignedNullable == null)
 0510        {
 0511            return null;
 512        }
 513
 0514        var unsigned = unsignedNullable.Value;
 0515        var sign = unsigned & (uint)1;
 516
 0517        var value = (int)(unsigned >> 1);
 0518        if (sign == 1)
 0519        {
 0520            value = -value;
 0521        }
 522
 0523        return value;
 0524    }
 525
 526    public static void WriteVarInt32Nullable(this Stream data, int? value)
 0527    {
 0528        data.WriteVarUInt32Nullable(ToUnsigned(value));
 0529    }
 530
 531    public static void WriteVarInt32(this Stream data, int value)
 0532    {
 0533        data.WriteVarUInt32(ToUnsigned(value));
 0534    }
 535
 536    public static int? ReadVarInt32Nullable(this Stream data)
 0537    {
 0538        return FromUnsigned(data.ReadVarUInt32Nullable());
 0539    }
 540
 541    public static int ReadVarInt32(this Stream data)
 0542    {
 0543        return FromUnsigned(data.ReadVarUInt32());
 0544    }
 545
 546    public static void WriteVarInt64Nullable(this Stream data, long? value)
 0547    {
 0548        data.WriteVarUInt64Nullable(ToUnsigned(value));
 0549    }
 550
 551    public static void WriteVarInt64(this Stream data, long value)
 3552    {
 3553        data.WriteVarUInt64(ToUnsigned(value));
 3554    }
 555
 556    public static long? ReadVarInt64Nullable(this Stream data)
 0557    {
 0558        return FromUnsigned(data.ReadVarUInt64Nullable());
 0559    }
 560
 561    public static long ReadVarInt64(this Stream data)
 3562    {
 3563        return FromUnsigned(data.ReadVarUInt64());
 3564    }
 565
 566    public static void WriteInt64(this Stream stream, long value)
 0567    {
 0568        for (var b = 0; b < 8; b++)
 0569        {
 0570            stream.WriteByte((byte)(value & byte.MaxValue));
 0571            value >>= 8;
 0572        }
 0573    }
 574
 575    public static long ReadInt64(this Stream stream)
 1576    {
 1577        var value = 0L;
 18578        for (var b = 0; b < 8; b++)
 8579        {
 8580            value += (long)stream.ReadByte() << (b * 8);
 8581        }
 582
 1583        return value;
 1584    }
 585
 586    public static void WriteUInt32(this Stream stream, uint value)
 0587    {
 0588        for (var b = 0; b < 4; b++)
 0589        {
 0590            stream.WriteByte((byte)(value & byte.MaxValue));
 0591            value >>= 8;
 0592        }
 0593    }
 594
 595    public static uint ReadUInt32(this Stream stream)
 0596    {
 0597        var value = 0U;
 0598        for (var b = 0; b < 4; b++)
 0599        {
 0600            value += (uint)stream.ReadByte() << (b * 8);
 0601        }
 602
 0603        return value;
 0604    }
 605
 606    public static void WriteUInt64(this Stream stream, ulong value)
 0607    {
 0608        for (var b = 0; b < 8; b++)
 0609        {
 0610            stream.WriteByte((byte)(value & byte.MaxValue));
 0611            value >>= 8;
 0612        }
 0613    }
 614
 615    public static ulong ReadUInt64(this Stream stream)
 0616    {
 0617        var value = 0UL;
 0618        for (var b = 0; b < 8; b++)
 0619        {
 0620            value += (ulong)stream.ReadByte() << (b * 8);
 0621        }
 622
 0623        return value;
 0624    }
 625
 626    public static void WriteInt32(this Stream stream, int value)
 0627    {
 0628        for (var b = 0; b < 4; b++)
 0629        {
 0630            stream.WriteByte((byte)(value & byte.MaxValue));
 0631            value >>= 8;
 0632        }
 0633    }
 634
 635    public static int ReadInt32(this Stream stream)
 0636    {
 0637        var value = 0;
 0638        for (var b = 0; b < 4; b++)
 0639        {
 0640            value += stream.ReadByte() << (b * 8);
 0641        }
 642
 0643        return value;
 0644    }
 645
 646    internal static long WriteWithSize(this Stream stream, string value)
 1647    {
 1648        var bytes = System.Text.Encoding.Unicode.GetBytes(value);
 1649        return stream.WriteWithSize(bytes);
 1650    }
 651
 652    internal static long WriteWithSize(this Stream stream, byte[] value)
 1653    {
 1654        stream.Write(System.BitConverter.GetBytes((long)value.Length), 0, 8);
 1655        stream.Write(value, 0, value.Length);
 1656        return value.Length + 8;
 1657    }
 658
 659    internal static string ReadWithSizeString(this Stream stream)
 1660    {
 1661        var size = stream.ReadInt64();
 1662        var data = new byte[size];
 1663        stream.Read(data, 0, (int)size);
 664
 1665        return System.Text.Encoding.Unicode.GetString(data, 0, data.Length);
 1666    }
 667}
Generated by: ReportGenerator 4.8.2.0
09/19/2025 - 07:34:11
GitHub | www.palmmedia.de

Methods/Properties

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