Added DiscUtils.ExFat.Internal

* Formerly ExFat.Core in https://github.com/LTRData/ExFat, originally from https://github.com/picrap/ExFat

Author: LTRData

Library/DiscUtils.ExFat/DiscUtils.ExFat.csproj

@@ -15,10 +15,6 @@
 
   </PropertyGroup>
 
-  <ItemGroup>
-    <PackageReference Include="LTRData.ExFat.Core" Version="*" />
-  </ItemGroup>
-  
   <ItemGroup>
     <ProjectReference Include="..\DiscUtils.Core\DiscUtils.Core.csproj" />
   </ItemGroup>

Library/DiscUtils.ExFat/ExFatFileSystem.cs

@@ -7,10 +7,10 @@
 using System.IO;
 using System.Linq;
 using System.Text.RegularExpressions;
-using ExFat.Filesystem;
+using DiscUtils.ExFat.Internal.Filesystem;
 using DiscUtils.Streams;
-using ExFat.Partition;
-using ExFat;
+using DiscUtils.ExFat.Internal.Partition;
+using DiscUtils.ExFat.Internal;
 using LTRData.Extensions.Buffers;
 
 namespace DiscUtils.ExFat;
@@ -89,8 +89,15 @@ protected override void Dispose(bool disposing)
     /// <returns></returns>
     public static bool Detect(Stream partitionStream)
     {
-        var bootSector = ExFatPartition.ReadBootSector(partitionStream);
-        return bootSector.IsValid;
+        try
+        {
+            var bootSector = ExFatPartition.ReadBootSector(partitionStream);
+            return bootSector.IsValid;
+        }
+        catch
+        {
+            return false;
+        }
     }
 
     /// <inheritdoc />

Library/DiscUtils.ExFat/Internal/Buffers/BufferByteString.cs

@@ -0,0 +1,69 @@
+// This is ExFat, an exFAT accessor written in pure C#
+// Released under MIT license
+// https://github.com/picrap/ExFat
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace DiscUtils.ExFat.Internal.Buffers;
+/// <summary>
+/// 8-bit char string
+/// </summary>
+/// <seealso cref="string" />
+[DebuggerDisplay("{" + nameof(Value) + "}")]
+public readonly struct BufferByteString : IValueProvider<string>
+{
+    private readonly Encoding encoding;
+    private readonly Memory<byte> buffer;
+
+    private IEnumerable<byte> GetZeroBytes()
+    {
+        foreach (var b in MemoryMarshal.ToEnumerable<byte>(buffer))
+        {
+            if (b == 0)
+            {
+                break;
+            }
+
+            yield return b;
+        }
+    }
+
+    /// <inheritdoc />
+    /// <summary>
+    /// Gets or sets the value.
+    /// </summary>
+    /// <value>
+    /// The value.
+    /// </value>
+    public string Value
+    {
+        get => encoding.GetString(GetZeroBytes().ToArray());
+        set
+        {
+            var stringBytes = encoding.GetBytes(value);
+            // first of all, inject bytes
+            buffer.Set(stringBytes);
+            // then pad
+            for (var index = stringBytes.Length; index < buffer.Length; index++)
+            {
+                buffer.Span[index] = 0;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="BufferByteString" /> class.
+    /// </summary>
+    /// <param name="buffer">The buffer.</param>
+    /// <param name="encoding">The encoding (defaults to ASCII).</param>
+    public BufferByteString(Memory<byte> buffer, Encoding encoding = null)
+    {
+        this.buffer = buffer;
+        this.encoding = encoding ?? Encoding.ASCII;
+    }
+}

Library/DiscUtils.ExFat/Internal/Buffers/BufferBytes.cs

@@ -0,0 +1,87 @@
+// This is ExFat, an exFAT accessor written in pure C#
+// Released under MIT license
+// https://github.com/picrap/ExFat
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Runtime.InteropServices;
+
+namespace DiscUtils.ExFat.Internal.Buffers;
+/// <summary>
+/// Represents bytes in the buffer
+/// </summary>
+[DebuggerDisplay("{" + nameof(DebugLiteral) + "}")]
+public readonly struct BufferBytes : IEnumerable<byte>
+{
+    private readonly Memory<byte> buffer;
+
+    /// <summary>
+    /// Gets or sets the <see cref="byte"/> at the specified index.
+    /// </summary>
+    /// <value>
+    /// The <see cref="byte"/>.
+    /// </value>
+    /// <param name="index">The index.</param>
+    /// <returns></returns>
+    /// <exception cref="ArgumentOutOfRangeException">
+    /// </exception>
+    public byte this[int index]
+    {
+        get => buffer.Span[index];
+        set => buffer.Span[index] = value;
+    }
+
+    private string DebugLiteral
+    {
+        get
+        {
+            var s = string.Join(", ", this.Take(10).Select(b => $"0x{b:X2}"));
+            if (buffer.Length > 10)
+            {
+                s += " ...";
+            }
+
+            return s;
+        }
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="BufferBytes"/> class.
+    /// </summary>
+    /// <param name="buffer">The buffer.</param>
+    public BufferBytes(Memory<byte> buffer)
+    {
+        this.buffer = buffer;
+    }
+
+    /// <summary>
+    /// Sets the specified bytes.
+    /// </summary>
+    /// <param name="bytes">The bytes.</param>
+    public void Set(ReadOnlySpan<byte> bytes)
+    {
+        for (var offset = 0; offset < buffer.Length; offset++)
+        {
+            buffer.Span[offset] = bytes[offset];
+        }
+    }
+
+    /// <summary>
+    /// Returns an enumerator that iterates through the collection.
+    /// </summary>
+    /// <returns>
+    /// A <see cref="T:System.Collections.Generic.IEnumerator`1" /> that can be used to iterate through the collection.
+    /// </returns>
+    public IEnumerator<byte> GetEnumerator() => MemoryMarshal.ToEnumerable<byte>(buffer).GetEnumerator();
+
+    /// <summary>
+    /// Returns an enumerator that iterates through a collection.
+    /// </summary>
+    /// <returns>
+    /// An <see cref="T:System.Collections.IEnumerator" /> object that can be used to iterate through the collection.
+    /// </returns>
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+}

Library/DiscUtils.ExFat/Internal/Buffers/BufferUInt16.cs

@@ -0,0 +1,39 @@
+// This is ExFat, an exFAT accessor written in pure C#
+// Released under MIT license
+// https://github.com/picrap/ExFat
+
+using DiscUtils.Streams;
+using System;
+using System.Diagnostics;
+
+namespace DiscUtils.ExFat.Internal.Buffers;
+/// <summary>
+/// 16-bits unsigned int buffer
+/// </summary>
+/// <seealso cref="ushort" />
+[DebuggerDisplay("{" + nameof(Value) + "}")]
+public readonly struct BufferUInt16 : IValueProvider<ushort>
+{
+    private readonly Memory<byte> buffer;
+
+    /// <summary>
+    /// Gets or sets the value.
+    /// </summary>
+    /// <value>
+    /// The value.
+    /// </value>
+    public ushort Value
+    {
+        get => EndianUtilities.ToUInt16LittleEndian(buffer.Span);
+        set => EndianUtilities.WriteBytesLittleEndian(value, buffer.Span);
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="BufferUInt16"/> class.
+    /// </summary>
+    /// <param name="buffer">The buffer.</param>
+    public BufferUInt16(Memory<byte> buffer)
+    {
+        this.buffer = buffer.Slice(0, sizeof(ushort));
+    }
+}

Library/DiscUtils.ExFat/Internal/Buffers/BufferUInt32.cs

@@ -0,0 +1,39 @@
+// This is ExFat, an exFAT accessor written in pure C#
+// Released under MIT license
+// https://github.com/picrap/ExFat
+
+using DiscUtils.Streams;
+using System;
+using System.Diagnostics;
+
+namespace DiscUtils.ExFat.Internal.Buffers;
+/// <summary>
+/// 32-bits unsigned int buffer
+/// </summary>
+/// <seealso cref="uint" />
+[DebuggerDisplay("{" + nameof(Value) + "}")]
+public readonly struct BufferUInt32 : IValueProvider<uint>
+{
+    private readonly Memory<byte> _buffer;
+
+    /// <summary>
+    /// Gets or sets the value.
+    /// </summary>
+    /// <value>
+    /// The value.
+    /// </value>
+    public uint Value
+    {
+        get => EndianUtilities.ToUInt32LittleEndian(_buffer.Span);
+        set => EndianUtilities.WriteBytesLittleEndian(value, _buffer.Span);
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="BufferUInt32"/> class.
+    /// </summary>
+    /// <param name="buffer">The buffer.</param>
+    public BufferUInt32(Memory<byte> buffer)
+    {
+        _buffer = buffer.Slice(0, sizeof(uint));
+    }
+}

Library/DiscUtils.ExFat/Internal/Buffers/BufferUInt64.cs

@@ -0,0 +1,39 @@
+// This is ExFat, an exFAT accessor written in pure C#
+// Released under MIT license
+// https://github.com/picrap/ExFat
+
+using DiscUtils.Streams;
+using System;
+using System.Diagnostics;
+
+namespace DiscUtils.ExFat.Internal.Buffers;
+/// <summary>
+/// 64-bits unsigned int buffer
+/// </summary>
+/// <seealso cref="ulong" />
+[DebuggerDisplay("{" + nameof(Value) + "}")]
+public readonly struct BufferUInt64 : IValueProvider<ulong>
+{
+    private readonly Memory<byte> buffer;
+
+    /// <summary>
+    /// Gets or sets the value.
+    /// </summary>
+    /// <value>
+    /// The value.
+    /// </value>
+    public ulong Value
+    {
+        get => EndianUtilities.ToUInt64LittleEndian(buffer.Span);
+        set => EndianUtilities.WriteBytesLittleEndian(value, buffer.Span);
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="BufferUInt64"/> class.
+    /// </summary>
+    /// <param name="buffer">The buffer.</param>
+    public BufferUInt64(Memory<byte> buffer)
+    {
+        this.buffer = buffer.Slice(0, sizeof(ulong));
+    }
+}

Library/DiscUtils.ExFat/Internal/Buffers/BufferUInt8.cs

@@ -0,0 +1,39 @@
+// This is ExFat, an exFAT accessor written in pure C#
+// Released under MIT license
+// https://github.com/picrap/ExFat
+
+using System;
+using System.Diagnostics;
+
+namespace DiscUtils.ExFat.Internal.Buffers;
+/// <summary>
+/// 8-bit unsigned int buffer (in other words, a byte)
+/// </summary>
+/// <seealso cref="byte" />
+[DebuggerDisplay("{" + nameof(Value) + "}")]
+public readonly struct BufferUInt8 : IValueProvider<byte>
+{
+    private readonly Memory<byte> buffer;
+
+    /// <inheritdoc />
+    /// <summary>
+    /// Gets or sets the value.
+    /// </summary>
+    /// <value>
+    /// The value.
+    /// </value>
+    public byte Value
+    {
+        get => buffer.Span[0];
+        set => buffer.Span[0] = value;
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="BufferUInt8"/> class.
+    /// </summary>
+    /// <param name="buffer">The buffer.</param>
+    public BufferUInt8(Memory<byte> buffer)
+    {
+        this.buffer = buffer.Slice(0, sizeof(byte));
+    }
+}