mirrors/LibHac
1
0
Fork 0
mirror of https://github.com/Thealexbarney/LibHac.git synced 2024-11-14 10:49:41 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Use inline arrays

Browse source
This commit is contained in:
Alex Barney 2023-12-08 23:54:46 -07:00
parent 48e7651291
commit f19b219e84
100 changed files with 292 additions and 1914 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

56
build/CodeGen/Stage2/KeysCodeGen.cs
View file

@ -103,46 +103,46 @@ public static class KeysCodeGen
RSAParameters betaNca0Params = RSAParameters betaNca0Params =
Rsa.RecoverParameters(BetaNca0Modulus, StandardPublicExponent, BetaNca0Exponent); Rsa.RecoverParameters(BetaNca0Modulus, StandardPublicExponent, BetaNca0Exponent);
betaNca0Params.D.AsSpan().CopyTo(keySet.BetaNca0KeyAreaKey.PrivateExponent.Items); betaNca0Params.D.AsSpan().CopyTo(keySet.BetaNca0KeyAreaKey.PrivateExponent);
betaNca0Params.DP.AsSpan().CopyTo(keySet.BetaNca0KeyAreaKey.Dp.Items); betaNca0Params.DP.AsSpan().CopyTo(keySet.BetaNca0KeyAreaKey.Dp);
betaNca0Params.DQ.AsSpan().CopyTo(keySet.BetaNca0KeyAreaKey.Dq.Items); betaNca0Params.DQ.AsSpan().CopyTo(keySet.BetaNca0KeyAreaKey.Dq);
betaNca0Params.Exponent.AsSpan().CopyTo(keySet.BetaNca0KeyAreaKey.PublicExponent.Items); betaNca0Params.Exponent.AsSpan().CopyTo(keySet.BetaNca0KeyAreaKey.PublicExponent);
betaNca0Params.InverseQ.AsSpan().CopyTo(keySet.BetaNca0KeyAreaKey.InverseQ.Items); betaNca0Params.InverseQ.AsSpan().CopyTo(keySet.BetaNca0KeyAreaKey.InverseQ);
betaNca0Params.Modulus.AsSpan().CopyTo(keySet.BetaNca0KeyAreaKey.Modulus.Items); betaNca0Params.Modulus.AsSpan().CopyTo(keySet.BetaNca0KeyAreaKey.Modulus);
betaNca0Params.P.AsSpan().CopyTo(keySet.BetaNca0KeyAreaKey.P.Items); betaNca0Params.P.AsSpan().CopyTo(keySet.BetaNca0KeyAreaKey.P);
betaNca0Params.Q.AsSpan().CopyTo(keySet.BetaNca0KeyAreaKey.Q.Items); betaNca0Params.Q.AsSpan().CopyTo(keySet.BetaNca0KeyAreaKey.Q);
// First populate the prod RSA keys // First populate the prod RSA keys
keySet.SetMode(KeySet.Mode.Prod); keySet.SetMode(KeySet.Mode.Prod);
StandardPublicExponent.CopyTo(keySet.NcaHeaderSigningKeys[0].PublicExponent.Items); StandardPublicExponent.CopyTo(keySet.NcaHeaderSigningKeys[0].PublicExponent);
StandardPublicExponent.CopyTo(keySet.NcaHeaderSigningKeys[1].PublicExponent.Items); StandardPublicExponent.CopyTo(keySet.NcaHeaderSigningKeys[1].PublicExponent);
NcaHdrFixedKeyModulus0Prod.CopyTo(keySet.NcaHeaderSigningKeys[0].Modulus.Items); NcaHdrFixedKeyModulus0Prod.CopyTo(keySet.NcaHeaderSigningKeys[0].Modulus);
NcaHdrFixedKeyModulus1Prod.CopyTo(keySet.NcaHeaderSigningKeys[1].Modulus.Items); NcaHdrFixedKeyModulus1Prod.CopyTo(keySet.NcaHeaderSigningKeys[1].Modulus);
StandardPublicExponent.CopyTo(keySet.AcidSigningKeys[0].PublicExponent.Items); StandardPublicExponent.CopyTo(keySet.AcidSigningKeys[0].PublicExponent);
StandardPublicExponent.CopyTo(keySet.AcidSigningKeys[1].PublicExponent.Items); StandardPublicExponent.CopyTo(keySet.AcidSigningKeys[1].PublicExponent);
AcidFixedKeyModulus0Prod.CopyTo(keySet.AcidSigningKeys[0].Modulus.Items); AcidFixedKeyModulus0Prod.CopyTo(keySet.AcidSigningKeys[0].Modulus);
AcidFixedKeyModulus1Prod.CopyTo(keySet.AcidSigningKeys[1].Modulus.Items); AcidFixedKeyModulus1Prod.CopyTo(keySet.AcidSigningKeys[1].Modulus);
StandardPublicExponent.CopyTo(keySet.Package2SigningKey.PublicExponent.Items); StandardPublicExponent.CopyTo(keySet.Package2SigningKey.PublicExponent);
Package2FixedKeyModulusProd.CopyTo(keySet.Package2SigningKey.Modulus.Items); Package2FixedKeyModulusProd.CopyTo(keySet.Package2SigningKey.Modulus);
// Populate the dev RSA keys // Populate the dev RSA keys
keySet.SetMode(KeySet.Mode.Dev); keySet.SetMode(KeySet.Mode.Dev);
StandardPublicExponent.CopyTo(keySet.NcaHeaderSigningKeys[0].PublicExponent.Items); StandardPublicExponent.CopyTo(keySet.NcaHeaderSigningKeys[0].PublicExponent);
StandardPublicExponent.CopyTo(keySet.NcaHeaderSigningKeys[1].PublicExponent.Items); StandardPublicExponent.CopyTo(keySet.NcaHeaderSigningKeys[1].PublicExponent);
NcaHdrFixedKeyModulus0Dev.CopyTo(keySet.NcaHeaderSigningKeys[0].Modulus.Items); NcaHdrFixedKeyModulus0Dev.CopyTo(keySet.NcaHeaderSigningKeys[0].Modulus);
NcaHdrFixedKeyModulus1Dev.CopyTo(keySet.NcaHeaderSigningKeys[1].Modulus.Items); NcaHdrFixedKeyModulus1Dev.CopyTo(keySet.NcaHeaderSigningKeys[1].Modulus);
StandardPublicExponent.CopyTo(keySet.AcidSigningKeys[0].PublicExponent.Items); StandardPublicExponent.CopyTo(keySet.AcidSigningKeys[0].PublicExponent);
StandardPublicExponent.CopyTo(keySet.AcidSigningKeys[1].PublicExponent.Items); StandardPublicExponent.CopyTo(keySet.AcidSigningKeys[1].PublicExponent);
AcidFixedKeyModulus0Dev.CopyTo(keySet.AcidSigningKeys[0].Modulus.Items); AcidFixedKeyModulus0Dev.CopyTo(keySet.AcidSigningKeys[0].Modulus);
AcidFixedKeyModulus1Dev.CopyTo(keySet.AcidSigningKeys[1].Modulus.Items); AcidFixedKeyModulus1Dev.CopyTo(keySet.AcidSigningKeys[1].Modulus);
StandardPublicExponent.CopyTo(keySet.Package2SigningKey.PublicExponent.Items); StandardPublicExponent.CopyTo(keySet.Package2SigningKey.PublicExponent);
Package2FixedKeyModulusDev.CopyTo(keySet.Package2SigningKey.Modulus.Items); Package2FixedKeyModulusDev.CopyTo(keySet.Package2SigningKey.Modulus);
return keySet; return keySet;
} }

2
src/LibHac/Bcat/Digest.cs
View file

@ -9,6 +9,6 @@ public struct Digest
public readonly override string ToString() public readonly override string ToString()
{ {
return Value.ItemsRo.ToHexString(); return Value[..].ToHexString();
} }
} }

4
src/LibHac/Bcat/DirectoryName.cs
View file

@ -12,7 +12,7 @@ public struct DirectoryName
public readonly bool IsValid() public readonly bool IsValid()
{ {
ReadOnlySpan<byte> name = Value.ItemsRo; ReadOnlySpan<byte> name = Value;
int i; int i;
for (i = 0; i < name.Length; i++) for (i = 0; i < name.Length; i++)
@ -32,6 +32,6 @@ public struct DirectoryName
public readonly override string ToString() public readonly override string ToString()
{ {
return StringUtils.Utf8ZToString(Value.ItemsRo); return StringUtils.Utf8ZToString(Value);
} }
} }

4
src/LibHac/Bcat/FileName.cs
View file

@ -12,7 +12,7 @@ public struct FileName
public readonly bool IsValid() public readonly bool IsValid()
{ {
ReadOnlySpan<byte> name = Value.ItemsRo; ReadOnlySpan<byte> name = Value;
int i; int i;
for (i = 0; i < name.Length; i++) for (i = 0; i < name.Length; i++)
@ -35,6 +35,6 @@ public struct FileName
public readonly override string ToString() public readonly override string ToString()
{ {
return StringUtils.Utf8ZToString(Value.ItemsRo); return StringUtils.Utf8ZToString(Value);
} }
} }

2
src/LibHac/Bcat/Impl/Service/DeliveryCacheStorageService.cs
View file

@ -76,7 +76,7 @@ internal class DeliveryCacheStorageService : IDeliveryCacheStorageService
break; break;
} }
StringUtils.Copy(nameBuffer[i].Value.Items, entry.Name.Value); StringUtils.Copy(nameBuffer[i].Value, entry.Name.Value);
} }
namesRead = i; namesRead = i;

10
src/LibHac/Boot/Package1.cs
View file

@ -39,7 +39,7 @@ public struct Package1MetaData
public byte Version; public byte Version;
[UnscopedRef] public U8Span BuildDate => new U8Span(_buildDate); [UnscopedRef] public U8Span BuildDate => new U8Span(_buildDate);
[UnscopedRef] public ReadOnlySpan<byte> Iv => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_buildDate.Items), 0x10); [UnscopedRef] public ReadOnlySpan<byte> Iv => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_buildDate[..]), 0x10);
} }
public struct Package1Stage1Footer public struct Package1Stage1Footer
@ -283,7 +283,7 @@ public class Package1
private Result ReadModernEristaMac() private Result ReadModernEristaMac()
{ {
return _baseStorage.Get.Read(ModernStage1Size + Pk11Size, _pk11Mac.Items); return _baseStorage.Get.Read(ModernStage1Size + Pk11Size, _pk11Mac);
} }
private Result SetPk11Storage() private Result SetPk11Storage()
@ -319,7 +319,7 @@ public class Package1
else else
{ {
decPk11Storage = new Aes128CtrStorage(encPk11Storage, decPk11Storage = new Aes128CtrStorage(encPk11Storage,
KeySet.Package1Keys[KeyRevision].DataRo.ToArray(), _stage1Footer.Iv.ItemsRo.ToArray(), true); KeySet.Package1Keys[KeyRevision].DataRo.ToArray(), _stage1Footer.Iv[..].ToArray(), true);
} }
_pk11Storage = new SubStorage(new CachedStorage(decPk11Storage, 0x4000, 1, true), 0, Pk11Size); _pk11Storage = new SubStorage(new CachedStorage(decPk11Storage, 0x4000, 1, true), 0, Pk11Size);
@ -383,7 +383,7 @@ public class Package1
// MarikoOemHeader must be read first // MarikoOemHeader must be read first
private bool IsMarikoImpl() private bool IsMarikoImpl()
{ {
return MarikoOemHeader.AesMac.ItemsRo.IsZeros() && MarikoOemHeader.Reserved.ItemsRo.IsZeros(); return MarikoOemHeader.AesMac[..].IsZeros() && MarikoOemHeader.Reserved[..].IsZeros();
} }
/// <summary> /// <summary>
@ -416,7 +416,7 @@ public class Package1
if (IsModern) if (IsModern)
{ {
storages.Add(new MemoryStorage(_pk11Mac.ItemsRo.ToArray())); storages.Add(new MemoryStorage(_pk11Mac[..].ToArray()));
} }
} }

4
src/LibHac/Boot/Package2StorageReader.cs
View file

@ -73,7 +73,7 @@ public class Package2StorageReader : IDisposable
return Result.Success; return Result.Success;
} }
byte[] iv = _header.Meta.PayloadIvs[index].ItemsRo.ToArray(); byte[] iv = _header.Meta.PayloadIvs[index][..].ToArray();
outPayloadStorage.Reset(new CachedStorage(new Aes128CtrStorage(payloadSubStorage, _key.DataRo.ToArray(), iv, true), 0x4000, 1, true)); outPayloadStorage.Reset(new CachedStorage(new Aes128CtrStorage(payloadSubStorage, _key.DataRo.ToArray(), iv, true), 0x4000, 1, true));
return Result.Success; return Result.Success;
} }
@ -231,7 +231,7 @@ public class Package2StorageReader : IDisposable
// The counter starts counting at the beginning of the meta struct, but the first block in // The counter starts counting at the beginning of the meta struct, but the first block in
// the struct isn't encrypted. Increase the counter by one to skip that block. // the struct isn't encrypted. Increase the counter by one to skip that block.
byte[] iv = _header.Meta.HeaderIv.ItemsRo.ToArray(); byte[] iv = _header.Meta.HeaderIv[..].ToArray();
Utilities.IncrementByteArray(iv); Utilities.IncrementByteArray(iv);
storages.Add(new CachedStorage(new Aes128CtrStorage(encMetaStorage, _key.DataRo.ToArray(), iv, true), 0x100, 1, true)); storages.Add(new CachedStorage(new Aes128CtrStorage(encMetaStorage, _key.DataRo.ToArray(), iv, true), 0x100, 1, true));

21
src/LibHac/Common/FixedArrays/Array1.cs
View file

@ -1,21 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
namespace LibHac.Common.FixedArrays;
public struct Array1<T>
{
public const int Length = 1;
private T _0;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef] public Span<T> Items => SpanHelpers.CreateSpan(ref _0, Length);
[UnscopedRef] public readonly ReadOnlySpan<T> ItemsRo => SpanHelpers.CreateReadOnlySpan(in _0, Length);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array1<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array100.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array100<T>
{
public const int Length = 100;
private Array64<T> _0;
private Array36<T> _64;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array100<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array1024.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array1024<T>
{
public const int Length = 1024;
private Array512<T> _0;
private Array512<T> _512;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array1024<T> value) => value.ItemsRo;
}

31
src/LibHac/Common/FixedArrays/Array11.cs
View file

@ -1,31 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
namespace LibHac.Common.FixedArrays;
public struct Array11<T>
{
public const int Length = 11;
private T _0;
private T _1;
private T _2;
private T _3;
private T _4;
private T _5;
private T _6;
private T _7;
private T _8;
private T _9;
private T _10;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef] public Span<T> Items => SpanHelpers.CreateSpan(ref _0, Length);
[UnscopedRef] public readonly ReadOnlySpan<T> ItemsRo => SpanHelpers.CreateReadOnlySpan(in _0, Length);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array11<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array112.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array112<T>
{
public const int Length = 112;
private Array80<T> _0;
private Array32<T> _80;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array112<T> value) => value.ItemsRo;
}

32
src/LibHac/Common/FixedArrays/Array12.cs
View file

@ -1,32 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
namespace LibHac.Common.FixedArrays;
public struct Array12<T>
{
public const int Length = 12;
private T _0;
private T _1;
private T _2;
private T _3;
private T _4;
private T _5;
private T _6;
private T _7;
private T _8;
private T _9;
private T _10;
private T _11;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef] public Span<T> Items => SpanHelpers.CreateSpan(ref _0, Length);
[UnscopedRef] public readonly ReadOnlySpan<T> ItemsRo => SpanHelpers.CreateReadOnlySpan(in _0, Length);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array12<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array128.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array128<T>
{
public const int Length = 128;
private Array64<T> _0;
private Array64<T> _64;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array128<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array14.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array14<T>
{
public const int Length = 14;
private Array8<T> _0;
private Array6<T> _8;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array14<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array144.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array144<T>
{
public const int Length = 144;
private Array128<T> _0;
private Array16<T> _128;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array144<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array15.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array15<T>
{
public const int Length = 15;
private Array8<T> _0;
private Array7<T> _8;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array15<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array16.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array16<T>
{
public const int Length = 16;
private Array8<T> _0;
private Array8<T> _8;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array16<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array16384.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array16384<T>
{
public const int Length = 16384;
private Array8192<T> _0;
private Array8192<T> _8192;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array16384<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array18.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array18<T>
{
public const int Length = 18;
private Array16<T> _0;
private Array2<T> _16;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array18<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array192.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array192<T>
{
public const int Length = 192;
private Array128<T> _0;
private Array64<T> _128;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array192<T> value) => value.ItemsRo;
}

22
src/LibHac/Common/FixedArrays/Array2.cs
View file

@ -1,22 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
namespace LibHac.Common.FixedArrays;
public struct Array2<T>
{
public const int Length = 2;
private T _0;
private T _1;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef] public Span<T> Items => SpanHelpers.CreateSpan(ref _0, Length);
[UnscopedRef] public readonly ReadOnlySpan<T> ItemsRo => SpanHelpers.CreateReadOnlySpan(in _0, Length);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array2<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array20.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array20<T>
{
public const int Length = 20;
private Array16<T> _0;
private Array4<T> _16;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array20<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array2048.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array2048<T>
{
public const int Length = 2048;
private Array1024<T> _0;
private Array1024<T> _1024;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array2048<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array24.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array24<T>
{
public const int Length = 24;
private Array16<T> _0;
private Array8<T> _16;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array24<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array256.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array256<T>
{
public const int Length = 256;
private Array128<T> _0;
private Array128<T> _128;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array256<T> value) => value.ItemsRo;
}

35
src/LibHac/Common/FixedArrays/Array26.cs
View file

@ -1,35 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array26<T>
{
public const int Length = 26;
private Array16<T> _0;
private Array8<T> _16;
private Array2<T> _24;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array26<T> value) => value.ItemsRo;
}

36
src/LibHac/Common/FixedArrays/Array27.cs
View file

@ -1,36 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array27<T>
{
public const int Length = 27;
private Array16<T> _0;
private Array8<T> _16;
private Array2<T> _24;
private T _26;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array27<T> value) => value.ItemsRo;
}

35
src/LibHac/Common/FixedArrays/Array28.cs
View file

@ -1,35 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array28<T>
{
public const int Length = 28;
private Array16<T> _0;
private Array8<T> _16;
private Array4<T> _24;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array28<T> value) => value.ItemsRo;
}

23
src/LibHac/Common/FixedArrays/Array3.cs
View file

@ -1,23 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
namespace LibHac.Common.FixedArrays;
public struct Array3<T>
{
public const int Length = 3;
private T _0;
private T _1;
private T _2;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef] public Span<T> Items => SpanHelpers.CreateSpan(ref _0, Length);
[UnscopedRef] public readonly ReadOnlySpan<T> ItemsRo => SpanHelpers.CreateReadOnlySpan(in _0, Length);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array3<T> value) => value.ItemsRo;
}

37
src/LibHac/Common/FixedArrays/Array3000.cs
View file

@ -1,37 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array3000<T>
{
public const int Length = 3000;
private Array2048<T> _0;
private Array512<T> _2048;
private Array256<T> _2560;
private Array128<T> _2816;
private Array56<T> _2944;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array3000<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array32.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array32<T>
{
public const int Length = 32;
private Array16<T> _0;
private Array16<T> _16;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array32<T> value) => value.ItemsRo;
}

36
src/LibHac/Common/FixedArrays/Array356.cs
View file

@ -1,36 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array356<T>
{
public const int Length = 356;
private Array256<T> _0;
private Array64<T> _256;
private Array32<T> _320;
private Array4<T> _352;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array356<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array36.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array36<T>
{
public const int Length = 36;
private Array32<T> _0;
private Array4<T> _32;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array36<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array37.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array37<T>
{
public const int Length = 37;
private Array32<T> _0;
private Array5<T> _32;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array37<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array38.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array38<T>
{
public const int Length = 38;
private Array32<T> _0;
private Array6<T> _32;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array38<T> value) => value.ItemsRo;
}

24
src/LibHac/Common/FixedArrays/Array4.cs
View file

@ -1,24 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
namespace LibHac.Common.FixedArrays;
public struct Array4<T>
{
public const int Length = 4;
private T _0;
private T _1;
private T _2;
private T _3;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef] public Span<T> Items => SpanHelpers.CreateSpan(ref _0, Length);
[UnscopedRef] public readonly ReadOnlySpan<T> ItemsRo => SpanHelpers.CreateReadOnlySpan(in _0, Length);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array4<T> value) => value.ItemsRo;
}

35
src/LibHac/Common/FixedArrays/Array400.cs
View file

@ -1,35 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array400<T>
{
public const int Length = 400;
private Array256<T> _0;
private Array128<T> _256;
private Array16<T> _384;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array400<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array4096.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array4096<T>
{
public const int Length = 4096;
private Array2048<T> _0;
private Array2048<T> _2048;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array4096<T> value) => value.ItemsRo;
}

36
src/LibHac/Common/FixedArrays/Array436.cs
View file

@ -1,36 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array436<T>
{
public const int Length = 436;
private Array256<T> _0;
private Array128<T> _256;
private Array32<T> _384;
private Array20<T> _416;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array436<T> value) => value.ItemsRo;
}

36
src/LibHac/Common/FixedArrays/Array452.cs
View file

@ -1,36 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array452<T>
{
public const int Length = 452;
private Array256<T> _0;
private Array128<T> _256;
private Array64<T> _384;
private Array4<T> _448;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array452<T> value) => value.ItemsRo;
}

36
src/LibHac/Common/FixedArrays/Array464.cs
View file

@ -1,36 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array464<T>
{
public const int Length = 464;
private Array256<T> _0;
private Array128<T> _256;
private Array64<T> _384;
private Array16<T> _448;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array464<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array48.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array48<T>
{
public const int Length = 48;
private Array32<T> _0;
private Array16<T> _32;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array48<T> value) => value.ItemsRo;
}

25
src/LibHac/Common/FixedArrays/Array5.cs
View file

@ -1,25 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
namespace LibHac.Common.FixedArrays;
public struct Array5<T>
{
public const int Length = 5;
private T _0;
private T _1;
private T _2;
private T _3;
private T _4;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef] public Span<T> Items => SpanHelpers.CreateSpan(ref _0, Length);
[UnscopedRef] public readonly ReadOnlySpan<T> ItemsRo => SpanHelpers.CreateReadOnlySpan(in _0, Length);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array5<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array512.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array512<T>
{
public const int Length = 512;
private Array256<T> _0;
private Array256<T> _256;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array512<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array56.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array56<T>
{
public const int Length = 56;
private Array32<T> _0;
private Array24<T> _32;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array56<T> value) => value.ItemsRo;
}

26
src/LibHac/Common/FixedArrays/Array6.cs
View file

@ -1,26 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
namespace LibHac.Common.FixedArrays;
public struct Array6<T>
{
public const int Length = 6;
private T _0;
private T _1;
private T _2;
private T _3;
private T _4;
private T _5;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef] public Span<T> Items => SpanHelpers.CreateSpan(ref _0, Length);
[UnscopedRef] public readonly ReadOnlySpan<T> ItemsRo => SpanHelpers.CreateReadOnlySpan(in _0, Length);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array6<T> value) => value.ItemsRo;
}

35
src/LibHac/Common/FixedArrays/Array60.cs
View file

@ -1,35 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array60<T>
{
public const int Length = 60;
private Array32<T> _0;
private Array16<T> _32;
private Array12<T> _48;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array60<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array64.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array64<T>
{
public const int Length = 64;
private Array32<T> _0;
private Array32<T> _32;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array64<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array65.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array65<T>
{
public const int Length = 65;
private Array64<T> _0;
private T _64;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array65<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array68.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array68<T>
{
public const int Length = 68;
private Array64<T> _0;
private Array4<T> _64;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array68<T> value) => value.ItemsRo;
}

27
src/LibHac/Common/FixedArrays/Array7.cs
View file

@ -1,27 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
namespace LibHac.Common.FixedArrays;
public struct Array7<T>
{
public const int Length = 7;
private T _0;
private T _1;
private T _2;
private T _3;
private T _4;
private T _5;
private T _6;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef] public Span<T> Items => SpanHelpers.CreateSpan(ref _0, Length);
[UnscopedRef] public readonly ReadOnlySpan<T> ItemsRo => SpanHelpers.CreateReadOnlySpan(in _0, Length);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array7<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array768.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array768<T>
{
public const int Length = 768;
private Array512<T> _0;
private Array256<T> _512;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array768<T> value) => value.ItemsRo;
}

35
src/LibHac/Common/FixedArrays/Array769.cs
View file

@ -1,35 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array769<T>
{
public const int Length = 769;
private Array512<T> _0;
private Array256<T> _512;
private Array1<T> _768;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array769<T> value) => value.ItemsRo;
}

28
src/LibHac/Common/FixedArrays/Array8.cs
View file

@ -1,28 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
namespace LibHac.Common.FixedArrays;
public struct Array8<T>
{
public const int Length = 8;
private T _0;
private T _1;
private T _2;
private T _3;
private T _4;
private T _5;
private T _6;
private T _7;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef] public Span<T> Items => SpanHelpers.CreateSpan(ref _0, Length);
[UnscopedRef] public readonly ReadOnlySpan<T> ItemsRo => SpanHelpers.CreateReadOnlySpan(in _0, Length);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array8<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array80.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array80<T>
{
public const int Length = 80;
private Array64<T> _0;
private Array16<T> _64;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array80<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array8192.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array8192<T>
{
public const int Length = 8192;
private Array4096<T> _0;
private Array4096<T> _4096;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array8192<T> value) => value.ItemsRo;
}

34
src/LibHac/Common/FixedArrays/Array96.cs
View file

@ -1,34 +0,0 @@
#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace LibHac.Common.FixedArrays;
public struct Array96<T>
{
public const int Length = 96;
private Array80<T> _0;
private Array16<T> _80;
[UnscopedRef] public ref T this[int i] => ref Items[i];
[UnscopedRef]
public Span<T> Items
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
}
[UnscopedRef]
public readonly ReadOnlySpan<T> ItemsRo
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<T>(in Array96<T> value) => value.ItemsRo;
}

50
src/LibHac/Common/FixedArrays/Arrays.cs Normal file
View file

@ -0,0 +1,50 @@
using System.Runtime.CompilerServices;
namespace LibHac.Common.FixedArrays;
[InlineArray(1)] public struct Array1<T> { public readonly int Length => 1; private T _0; }
[InlineArray(2)] public struct Array2<T> { public readonly int Length => 2; private T _0; }
[InlineArray(3)] public struct Array3<T> { public readonly int Length => 3; private T _0; }
[InlineArray(4)] public struct Array4<T> { public readonly int Length => 4; private T _0; }
[InlineArray(5)] public struct Array5<T> { public readonly int Length => 5; private T _0; }
[InlineArray(6)] public struct Array6<T> { public readonly int Length => 6; private T _0; }
[InlineArray(7)] public struct Array7<T> { public readonly int Length => 7; private T _0; }
[InlineArray(8)] public struct Array8<T> { public readonly int Length => 8; private T _0; }
[InlineArray(11)] public struct Array11<T> { public readonly int Length => 11; private T _0; }
[InlineArray(12)] public struct Array12<T> { public readonly int Length => 12; private T _0; }
[InlineArray(14)] public struct Array14<T> { public readonly int Length => 14; private T _0; }
[InlineArray(15)] public struct Array15<T> { public readonly int Length => 15; private T _0; }
[InlineArray(16)] public struct Array16<T> { public readonly int Length => 16; private T _0; }
[InlineArray(18)] public struct Array18<T> { public readonly int Length => 18; private T _0; }
[InlineArray(20)] public struct Array20<T> { public readonly int Length => 20; private T _0; }
[InlineArray(24)] public struct Array24<T> { public readonly int Length => 24; private T _0; }
[InlineArray(26)] public struct Array26<T> { public readonly int Length => 26; private T _0; }
[InlineArray(27)] public struct Array27<T> { public readonly int Length => 27; private T _0; }
[InlineArray(28)] public struct Array28<T> { public readonly int Length => 28; private T _0; }
[InlineArray(32)] public struct Array32<T> { public readonly int Length => 32; private T _0; }
[InlineArray(36)] public struct Array36<T> { public readonly int Length => 36; private T _0; }
[InlineArray(37)] public struct Array37<T> { public readonly int Length => 37; private T _0; }
[InlineArray(38)] public struct Array38<T> { public readonly int Length => 38; private T _0; }
[InlineArray(48)] public struct Array48<T> { public readonly int Length => 48; private T _0; }
[InlineArray(56)] public struct Array56<T> { public readonly int Length => 56; private T _0; }
[InlineArray(60)] public struct Array60<T> { public readonly int Length => 60; private T _0; }
[InlineArray(64)] public struct Array64<T> { public readonly int Length => 64; private T _0; }
[InlineArray(65)] public struct Array65<T> { public readonly int Length => 65; private T _0; }
[InlineArray(68)] public struct Array68<T> { public readonly int Length => 68; private T _0; }
[InlineArray(100)] public struct Array100<T> { public readonly int Length => 100; private T _0; }
[InlineArray(112)] public struct Array112<T> { public readonly int Length => 112; private T _0; }
[InlineArray(128)] public struct Array128<T> { public readonly int Length => 128; private T _0; }
[InlineArray(144)] public struct Array144<T> { public readonly int Length => 144; private T _0; }
[InlineArray(192)] public struct Array192<T> { public readonly int Length => 192; private T _0; }
[InlineArray(256)] public struct Array256<T> { public readonly int Length => 256; private T _0; }
[InlineArray(356)] public struct Array356<T> { public readonly int Length => 356; private T _0; }
[InlineArray(400)] public struct Array400<T> { public readonly int Length => 400; private T _0; }
[InlineArray(436)] public struct Array436<T> { public readonly int Length => 436; private T _0; }
[InlineArray(452)] public struct Array452<T> { public readonly int Length => 452; private T _0; }
[InlineArray(464)] public struct Array464<T> { public readonly int Length => 464; private T _0; }
[InlineArray(512)] public struct Array512<T> { public readonly int Length => 512; private T _0; }
[InlineArray(768)] public struct Array768<T> { public readonly int Length => 768; private T _0; }
[InlineArray(769)] public struct Array769<T> { public readonly int Length => 769; private T _0; }
[InlineArray(3000)] public struct Array3000<T> { public readonly int Length => 3000; private T _0; }
[InlineArray(8192)] public struct Array8192<T> { public readonly int Length => 8192; private T _0; }
[InlineArray(16384)] public struct Array16384<T> { public readonly int Length => 16384; private T _0; }

88
src/LibHac/Common/Keys/KeySet.cs
View file

@ -54,37 +54,37 @@ public class KeySet
public ExternalKeySet ExternalKeySet { get; } = new ExternalKeySet(); public ExternalKeySet ExternalKeySet { get; } = new ExternalKeySet();
public Span<AesKey> MarikoAesClassKeys => RootKeys.MarikoAesClassKeys.Items; public Span<AesKey> MarikoAesClassKeys => RootKeys.MarikoAesClassKeys;
public ref AesKey MarikoKek => ref RootKeys.MarikoKek; public ref AesKey MarikoKek => ref RootKeys.MarikoKek;
public ref AesKey MarikoBek => ref RootKeys.MarikoBek; public ref AesKey MarikoBek => ref RootKeys.MarikoBek;
public Span<KeyBlob> KeyBlobs => RootKeys.KeyBlobs.Items; public Span<KeyBlob> KeyBlobs => RootKeys.KeyBlobs;
public Span<AesKey> KeyBlobKeySources => _keys.KeySeeds.KeyBlobKeySources.Items; public Span<AesKey> KeyBlobKeySources => _keys.KeySeeds.KeyBlobKeySources;
public ref AesKey KeyBlobMacKeySource => ref _keys.KeySeeds.KeyBlobMacKeySource; public ref AesKey KeyBlobMacKeySource => ref _keys.KeySeeds.KeyBlobMacKeySource;
public Span<AesKey> TsecSecrets => Secrets.Secrets.Items; public Span<AesKey> TsecSecrets => Secrets.Secrets;
public Span<AesKey> TsecRootKeks => RootKeys.TsecRootKeks.Items; public Span<AesKey> TsecRootKeks => RootKeys.TsecRootKeks;
public Span<AesKey> Package1MacKeks => RootKeys.Package1MacKeks.Items; public Span<AesKey> Package1MacKeks => RootKeys.Package1MacKeks;
public Span<AesKey> Package1Keks => RootKeys.Package1Keks.Items; public Span<AesKey> Package1Keks => RootKeys.Package1Keks;
public Span<AesKey> TsecAuthSignatures => _keys.KeySeeds.TsecAuthSignatures.Items; public Span<AesKey> TsecAuthSignatures => _keys.KeySeeds.TsecAuthSignatures;
public Span<AesKey> TsecRootKeys => RootKeys.TsecRootKeys.Items; public Span<AesKey> TsecRootKeys => RootKeys.TsecRootKeys;
public Span<AesKey> MasterKekSources => _keys.KeySeeds.MasterKekSources.Items; public Span<AesKey> MasterKekSources => _keys.KeySeeds.MasterKekSources;
public Span<AesKey> GcTitleKeyKeks => RootKeys.GcTitleKeyKeks.Items; public Span<AesKey> GcTitleKeyKeks => RootKeys.GcTitleKeyKeks;
public Span<AesKey> MarikoMasterKekSources => _mode == Mode.Dev public Span<AesKey> MarikoMasterKekSources => _mode == Mode.Dev
? _keys.KeySeeds.MarikoMasterKekSourcesDev.Items ? _keys.KeySeeds.MarikoMasterKekSourcesDev[..]
: _keys.KeySeeds.MarikoMasterKekSources.Items; : _keys.KeySeeds.MarikoMasterKekSources[..];
public Span<AesKey> MasterKeks => DerivedKeys.MasterKeks.Items; public Span<AesKey> MasterKeks => DerivedKeys.MasterKeks;
public ref AesKey MasterKeySource => ref _keys.KeySeeds.MasterKeySource; public ref AesKey MasterKeySource => ref _keys.KeySeeds.MasterKeySource;
public Span<AesKey> MasterKeys => DerivedKeys.MasterKeys.Items; public Span<AesKey> MasterKeys => DerivedKeys.MasterKeys;
public Span<AesKey> Package1MacKeys => DerivedKeys.Package1MacKeys.Items; public Span<AesKey> Package1MacKeys => DerivedKeys.Package1MacKeys;
public Span<AesKey> Package1Keys => DerivedKeys.Package1Keys.Items; public Span<AesKey> Package1Keys => DerivedKeys.Package1Keys;
public Span<AesKey> Package2Keys => DerivedKeys.Package2Keys.Items; public Span<AesKey> Package2Keys => DerivedKeys.Package2Keys;
public ref AesKey Package2KeySource => ref _keys.KeySeeds.Package2KeySource; public ref AesKey Package2KeySource => ref _keys.KeySeeds.Package2KeySource;
public ref AesKey PerConsoleKeySource => ref _keys.KeySeeds.PerConsoleKeySource; public ref AesKey PerConsoleKeySource => ref _keys.KeySeeds.PerConsoleKeySource;
public ref AesKey RetailSpecificAesKeySource => ref _keys.KeySeeds.RetailSpecificAesKeySource; public ref AesKey RetailSpecificAesKeySource => ref _keys.KeySeeds.RetailSpecificAesKeySource;
public ref AesKey BisKekSource => ref _keys.KeySeeds.BisKekSource; public ref AesKey BisKekSource => ref _keys.KeySeeds.BisKekSource;
public Span<AesXtsKey> BisKeySources => _keys.KeySeeds.BisKeySources.Items; public Span<AesXtsKey> BisKeySources => _keys.KeySeeds.BisKeySources;
public ref AesKey AesKekGenerationSource => ref _keys.KeySeeds.AesKekGenerationSource; public ref AesKey AesKekGenerationSource => ref _keys.KeySeeds.AesKekGenerationSource;
public ref AesKey AesKeyGenerationSource => ref _keys.KeySeeds.AesKeyGenerationSource; public ref AesKey AesKeyGenerationSource => ref _keys.KeySeeds.AesKeyGenerationSource;
public ref AesKey KeyAreaKeyApplicationSource => ref _keys.KeySeeds.KeyAreaKeyApplicationSource; public ref AesKey KeyAreaKeyApplicationSource => ref _keys.KeySeeds.KeyAreaKeyApplicationSource;
@ -93,15 +93,15 @@ public class KeySet
public ref AesKey TitleKekSource => ref _keys.KeySeeds.TitleKekSource; public ref AesKey TitleKekSource => ref _keys.KeySeeds.TitleKekSource;
public ref AesKey HeaderKekSource => ref _keys.KeySeeds.HeaderKekSource; public ref AesKey HeaderKekSource => ref _keys.KeySeeds.HeaderKekSource;
public ref AesKey SdCardKekSource => ref _keys.KeySeeds.SdCardKekSource; public ref AesKey SdCardKekSource => ref _keys.KeySeeds.SdCardKekSource;
public Span<AesXtsKey> SdCardKeySources => _keys.KeySeeds.SdCardKeySources.Items; public Span<AesXtsKey> SdCardKeySources => _keys.KeySeeds.SdCardKeySources;
public ref AesKey DeviceUniqueSaveMacKekSource => ref _keys.KeySeeds.DeviceUniqueSaveMacKekSource; public ref AesKey DeviceUniqueSaveMacKekSource => ref _keys.KeySeeds.DeviceUniqueSaveMacKekSource;
public Span<AesKey> DeviceUniqueSaveMacKeySources => _keys.KeySeeds.DeviceUniqueSaveMacKeySources.Items; public Span<AesKey> DeviceUniqueSaveMacKeySources => _keys.KeySeeds.DeviceUniqueSaveMacKeySources;
public ref AesKey SeedUniqueSaveMacKekSource => ref _keys.KeySeeds.SeedUniqueSaveMacKekSource; public ref AesKey SeedUniqueSaveMacKekSource => ref _keys.KeySeeds.SeedUniqueSaveMacKekSource;
public ref AesKey SeedUniqueSaveMacKeySource => ref _keys.KeySeeds.SeedUniqueSaveMacKeySource; public ref AesKey SeedUniqueSaveMacKeySource => ref _keys.KeySeeds.SeedUniqueSaveMacKeySource;
public ref AesXtsKey HeaderKeySource => ref _keys.KeySeeds.HeaderKeySource; public ref AesXtsKey HeaderKeySource => ref _keys.KeySeeds.HeaderKeySource;
public ref AesXtsKey HeaderKey => ref DerivedKeys.HeaderKey; public ref AesXtsKey HeaderKey => ref DerivedKeys.HeaderKey;
public Span<AesKey> TitleKeks => DerivedKeys.TitleKeks.Items; public Span<AesKey> TitleKeks => DerivedKeys.TitleKeks;
public Span<Array3<AesKey>> KeyAreaKeys => DerivedKeys.KeyAreaKeys.Items; public Span<Array3<AesKey>> KeyAreaKeys => DerivedKeys.KeyAreaKeys;
public ref AesKey XciHeaderKey => ref StoredKeys.XciHeaderKey; public ref AesKey XciHeaderKey => ref StoredKeys.XciHeaderKey;
public ref AesKey ETicketRsaKek => ref DerivedKeys.ETicketRsaKek; public ref AesKey ETicketRsaKek => ref DerivedKeys.ETicketRsaKek;
public ref AesKey SslRsaKek => ref DerivedKeys.SslRsaKek; public ref AesKey SslRsaKek => ref DerivedKeys.SslRsaKek;
@ -109,20 +109,20 @@ public class KeySet
public ref AesKey SecureBootKey => ref _keys.DeviceKeys.SecureBootKey; public ref AesKey SecureBootKey => ref _keys.DeviceKeys.SecureBootKey;
public ref AesKey TsecKey => ref _keys.DeviceKeys.TsecKey; public ref AesKey TsecKey => ref _keys.DeviceKeys.TsecKey;
public ref AesKey SdCardEncryptionSeed => ref _keys.DeviceKeys.SdCardEncryptionSeed; public ref AesKey SdCardEncryptionSeed => ref _keys.DeviceKeys.SdCardEncryptionSeed;
public Span<EncryptedKeyBlob> EncryptedKeyBlobs => _keys.DeviceKeys.EncryptedKeyBlobs.Items; public Span<EncryptedKeyBlob> EncryptedKeyBlobs => _keys.DeviceKeys.EncryptedKeyBlobs;
public Span<AesKey> KeyBlobKeys => DerivedDeviceKeys.KeyBlobKeys.Items; public Span<AesKey> KeyBlobKeys => DerivedDeviceKeys.KeyBlobKeys;
public Span<AesKey> KeyBlobMacKeys => DerivedDeviceKeys.KeyBlobMacKeys.Items; public Span<AesKey> KeyBlobMacKeys => DerivedDeviceKeys.KeyBlobMacKeys;
public ref AesKey DeviceKey => ref DerivedDeviceKeys.DeviceKey; public ref AesKey DeviceKey => ref DerivedDeviceKeys.DeviceKey;
public Span<AesXtsKey> BisKeys => DerivedDeviceKeys.BisKeys.Items; public Span<AesXtsKey> BisKeys => DerivedDeviceKeys.BisKeys;
public Span<AesKey> DeviceUniqueSaveMacKeys => DerivedDeviceKeys.DeviceUniqueSaveMacKeys.Items; public Span<AesKey> DeviceUniqueSaveMacKeys => DerivedDeviceKeys.DeviceUniqueSaveMacKeys;
public ref AesKey SeedUniqueSaveMacKey => ref DerivedDeviceKeys.SeedUniqueSaveMacKey; public ref AesKey SeedUniqueSaveMacKey => ref DerivedDeviceKeys.SeedUniqueSaveMacKey;
// Todo: Make a separate type? Not actually an AES-XTS key, but it's still the same shape. // Todo: Make a separate type? Not actually an AES-XTS key, but it's still the same shape.
public Span<AesXtsKey> SdCardEncryptionKeys => DerivedDeviceKeys.SdCardEncryptionKeys.Items; public Span<AesXtsKey> SdCardEncryptionKeys => DerivedDeviceKeys.SdCardEncryptionKeys;
public Span<RsaKey> NcaHeaderSigningKeys => RsaSigningKeys.NcaHeaderSigningKeys.Items; public Span<RsaKey> NcaHeaderSigningKeys => RsaSigningKeys.NcaHeaderSigningKeys;
public Span<RsaKey> AcidSigningKeys => RsaSigningKeys.AcidSigningKeys.Items; public Span<RsaKey> AcidSigningKeys => RsaSigningKeys.AcidSigningKeys;
public ref RsaKey Package2SigningKey => ref RsaSigningKeys.Package2SigningKey; public ref RsaKey Package2SigningKey => ref RsaSigningKeys.Package2SigningKey;
public ref RsaFullKey BetaNca0KeyAreaKey => ref RsaKeys.BetaNca0KeyAreaKey; public ref RsaFullKey BetaNca0KeyAreaKey => ref RsaKeys.BetaNca0KeyAreaKey;
public ref RsaKeyPair ETicketRsaKey => ref DeviceRsaKeys.ETicketRsaKey; public ref RsaKeyPair ETicketRsaKey => ref DeviceRsaKeys.ETicketRsaKey;
@ -147,7 +147,7 @@ public class KeySet
// Todo: Remove local variable after Roslyn issue #67697 is fixed // Todo: Remove local variable after Roslyn issue #67697 is fixed
ref Array2<RSAParameters> array = ref keys.Value; ref Array2<RSAParameters> array = ref keys.Value;
return array.Items; return array;
} }
} }
@ -166,7 +166,7 @@ public class KeySet
// Todo: Remove local variable after Roslyn issue #67697 is fixed // Todo: Remove local variable after Roslyn issue #67697 is fixed
ref Array2<RSAParameters> array = ref keys.Value; ref Array2<RSAParameters> array = ref keys.Value;
return array.Items; return array;
} }
} }
@ -207,7 +207,7 @@ public class KeySet
{ {
ref Optional<RSAParameters> keys = ref _rsaKeyParams.ETicketRsaKey; ref Optional<RSAParameters> keys = ref _rsaKeyParams.ETicketRsaKey;
if (!keys.HasValue && !ETicketRsaKey.PublicExponent.ItemsRo.IsZeros()) if (!keys.HasValue && !ETicketRsaKey.PublicExponent[..].IsZeros())
{ {
RSAParameters rsaParams = Rsa.RecoverParameters(ETicketRsaKey.Modulus, ETicketRsaKey.PublicExponent, ETicketRsaKey.PrivateExponent); RSAParameters rsaParams = Rsa.RecoverParameters(ETicketRsaKey.Modulus, ETicketRsaKey.PublicExponent, ETicketRsaKey.PrivateExponent);
keys.Set(rsaParams); keys.Set(rsaParams);
@ -261,8 +261,8 @@ public class KeySet
{ {
return new RSAParameters return new RSAParameters
{ {
Exponent = key.PublicExponent.ItemsRo.ToArray(), Exponent = key.PublicExponent[..].ToArray(),
Modulus = key.Modulus.ItemsRo.ToArray() Modulus = key.Modulus[..].ToArray()
}; };
} }
@ -270,14 +270,14 @@ public class KeySet
{ {
return new RSAParameters return new RSAParameters
{ {
D = key.PrivateExponent.ItemsRo.ToArray(), D = key.PrivateExponent[..].ToArray(),
DP = key.Dp.ItemsRo.ToArray(), DP = key.Dp[..].ToArray(),
DQ = key.Dq.ItemsRo.ToArray(), DQ = key.Dq[..].ToArray(),
Exponent = key.PublicExponent.ItemsRo.ToArray(), Exponent = key.PublicExponent[..].ToArray(),
InverseQ = key.InverseQ.ItemsRo.ToArray(), InverseQ = key.InverseQ[..].ToArray(),
Modulus = key.Modulus.ItemsRo.ToArray(), Modulus = key.Modulus[..].ToArray(),
P = key.P.ItemsRo.ToArray(), P = key.P[..].ToArray(),
Q = key.Q.ItemsRo.ToArray() Q = key.Q[..].ToArray()
}; };
} }

14
src/LibHac/Fs/Common/SaveDataTypes.cs
View file

@ -123,8 +123,8 @@ public struct HashSalt
{ {
private Array32<byte> _value; private Array32<byte> _value;
[UnscopedRef] public Span<byte> Hash => _value.Items; [UnscopedRef] public Span<byte> Hash => _value;
[UnscopedRef] public readonly ReadOnlySpan<byte> HashRo => _value.ItemsRo; [UnscopedRef] public readonly ReadOnlySpan<byte> HashRo => _value;
} }
public struct SaveDataAttribute : IEquatable<SaveDataAttribute>, IComparable<SaveDataAttribute> public struct SaveDataAttribute : IEquatable<SaveDataAttribute>, IComparable<SaveDataAttribute>
@ -385,19 +385,19 @@ internal static class SaveDataTypesValidity
public static bool IsValid(in SaveDataCreationInfo2 creationInfo) public static bool IsValid(in SaveDataCreationInfo2 creationInfo)
{ {
foreach (byte b in creationInfo.Reserved1.ItemsRo) foreach (byte b in creationInfo.Reserved1)
if (b != 0) return false; if (b != 0) return false;
foreach (byte b in creationInfo.Reserved2.ItemsRo) foreach (byte b in creationInfo.Reserved2)
if (b != 0) return false; if (b != 0) return false;
foreach (byte b in creationInfo.Reserved3.ItemsRo) foreach (byte b in creationInfo.Reserved3)
if (b != 0) return false; if (b != 0) return false;
foreach (byte b in creationInfo.Reserved4.ItemsRo) foreach (byte b in creationInfo.Reserved4)
if (b != 0) return false; if (b != 0) return false;
foreach (byte b in creationInfo.Attribute.Reserved.ItemsRo) foreach (byte b in creationInfo.Attribute.Reserved)
if (b != 0) return false; if (b != 0) return false;
return IsValid(in creationInfo.Attribute) return IsValid(in creationInfo.Attribute)

2
src/LibHac/Fs/EncryptionSeed.cs
View file

@ -7,5 +7,5 @@ public struct EncryptionSeed
{ {
public Array16<byte> Value; public Array16<byte> Value;
public readonly override string ToString() => Value.ItemsRo.ToHexString(); public readonly override string ToString() => Value[..].ToHexString();
} }

2
src/LibHac/Fs/MountName.cs
View file

@ -8,7 +8,7 @@ namespace LibHac.Fs;
internal struct MountName internal struct MountName
{ {
private Array16<byte> _nameArray; private Array16<byte> _nameArray;
[UnscopedRef] public Span<byte> Name => _nameArray.Items; [UnscopedRef] public Span<byte> Name => _nameArray;
public override string ToString() => new U8Span(Name).ToString(); public override string ToString() => new U8Span(Name).ToString();
} }

10
src/LibHac/Fs/RightsId.cs
View file

@ -20,19 +20,19 @@ public struct RightsId : IEquatable<RightsId>
Unsafe.SkipInit(out Value); Unsafe.SkipInit(out Value);
Span<ulong> longsThis = MemoryMarshal.Cast<byte, ulong>(Value.Items); Span<ulong> longsThis = MemoryMarshal.Cast<byte, ulong>(Value);
ReadOnlySpan<ulong> longsValue = MemoryMarshal.Cast<byte, ulong>(value); ReadOnlySpan<ulong> longsValue = MemoryMarshal.Cast<byte, ulong>(value);
longsThis[1] = longsValue[1]; longsThis[1] = longsValue[1];
longsThis[0] = longsValue[0]; longsThis[0] = longsValue[0];
} }
public readonly override string ToString() => Value.ItemsRo.ToHexString(); public readonly override string ToString() => Value[..].ToHexString();
public readonly string DebugDisplay() public readonly string DebugDisplay()
{ {
ReadOnlySpan<byte> highBytes = Value.ItemsRo.Slice(0, 8); ReadOnlySpan<byte> highBytes = Value[..].Slice(0, 8);
ReadOnlySpan<byte> lowBytes = Value.ItemsRo.Slice(8, 8); ReadOnlySpan<byte> lowBytes = Value[..].Slice(8, 8);
return $"{highBytes.ToHexString()} {lowBytes.ToHexString()}"; return $"{highBytes.ToHexString()} {lowBytes.ToHexString()}";
} }
@ -47,7 +47,7 @@ public struct RightsId : IEquatable<RightsId>
public readonly override int GetHashCode() public readonly override int GetHashCode()
{ {
ReadOnlySpan<ulong> longSpan = MemoryMarshal.Cast<byte, ulong>(Value.ItemsRo); ReadOnlySpan<ulong> longSpan = MemoryMarshal.Cast<byte, ulong>(Value[..]);
return HashCode.Combine(longSpan[0], longSpan[1]); return HashCode.Combine(longSpan[0], longSpan[1]);
} }

2
src/LibHac/Fs/Shim/Host.cs
View file

@ -69,7 +69,7 @@ public static class Host
public HostCommonMountNameGenerator(U8Span path) public HostCommonMountNameGenerator(U8Span path)
{ {
StringUtils.Strlcpy(_path.Items, path, PathTool.EntryNameLengthMax + 1); StringUtils.Strlcpy(_path, path, PathTool.EntryNameLengthMax + 1);
} }
public void Dispose() { } public void Dispose() { }

8
src/LibHac/FsSrv/DebugConfigurationService.cs
View file

@ -98,7 +98,7 @@ public class DebugConfigurationServiceImpl : IDisposable
using ScopedLock<SdkMutexType> scopedLock = ScopedLock.Lock(ref _mutex); using ScopedLock<SdkMutexType> scopedLock = ScopedLock.Lock(ref _mutex);
for (int i = 0; i < _entries.ItemsRo.Length; i++) for (int i = 0; i < _entries.Length; i++)
{ {
// Update the existing value if the key is already registered // Update the existing value if the key is already registered
if (_entries[i].Key == key) if (_entries[i].Key == key)
@ -108,7 +108,7 @@ public class DebugConfigurationServiceImpl : IDisposable
} }
} }
for (int i = 0; i < _entries.ItemsRo.Length; i++) for (int i = 0; i < _entries.Length; i++)
{ {
if (_entries[i].Key == 0) if (_entries[i].Key == 0)
{ {
@ -130,7 +130,7 @@ public class DebugConfigurationServiceImpl : IDisposable
using ScopedLock<SdkMutexType> scopedLock = ScopedLock.Lock(ref _mutex); using ScopedLock<SdkMutexType> scopedLock = ScopedLock.Lock(ref _mutex);
for (int i = 0; i < _entries.ItemsRo.Length; i++) for (int i = 0; i < _entries.Length; i++)
{ {
if (_entries[i].Key == key) if (_entries[i].Key == key)
{ {
@ -150,7 +150,7 @@ public class DebugConfigurationServiceImpl : IDisposable
using ScopedLock<SdkMutexType> scopedLock = ScopedLock.Lock(ref _mutex); using ScopedLock<SdkMutexType> scopedLock = ScopedLock.Lock(ref _mutex);
for (int i = 0; i < _entries.ItemsRo.Length; i++) for (int i = 0; i < _entries.Length; i++)
{ {
if (_entries[i].Key == (uint)key) if (_entries[i].Key == (uint)key)
{ {

4
src/LibHac/FsSrv/FileSystemProxyCoreImpl.cs
View file

@ -41,7 +41,7 @@ public class FileSystemProxyCoreImpl
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();
using scoped var path = new Path(); using scoped var path = new Path();
res = PathFunctions.SetUpFixedPathSingleEntry(ref path.Ref(), pathBuffer.Items, res = PathFunctions.SetUpFixedPathSingleEntry(ref path.Ref(), pathBuffer,
CustomStorage.GetCustomStorageDirectoryName(CustomStorageId.System)); CustomStorage.GetCustomStorageDirectoryName(CustomStorageId.System));
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();
@ -55,7 +55,7 @@ public class FileSystemProxyCoreImpl
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();
using scoped var path = new Path(); using scoped var path = new Path();
res = PathFunctions.SetUpFixedPathDoubleEntry(ref path.Ref(), pathBuffer.Items, res = PathFunctions.SetUpFixedPathDoubleEntry(ref path.Ref(), pathBuffer,
CommonDirNames.SdCardNintendoRootDirectoryName, CommonDirNames.SdCardNintendoRootDirectoryName,
CustomStorage.GetCustomStorageDirectoryName(CustomStorageId.System)); CustomStorage.GetCustomStorageDirectoryName(CustomStorageId.System));
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();

2
src/LibHac/FsSrv/FsCreator/SaveDataFileSystemCreator.cs
View file

@ -47,7 +47,7 @@ public class SaveDataFileSystemCreator : ISaveDataFileSystemCreator
Unsafe.SkipInit(out Array18<byte> saveImageNameBuffer); Unsafe.SkipInit(out Array18<byte> saveImageNameBuffer);
using scoped var saveImageName = new Path(); using scoped var saveImageName = new Path();
Result res = PathFunctions.SetUpFixedPathSaveId(ref saveImageName.Ref(), saveImageNameBuffer.Items, saveDataId); Result res = PathFunctions.SetUpFixedPathSaveId(ref saveImageName.Ref(), saveImageNameBuffer, saveDataId);
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();
res = baseFileSystem.Get.GetEntryType(out DirectoryEntryType type, in saveImageName); res = baseFileSystem.Get.GetEntryType(out DirectoryEntryType type, in saveImageName);

2
src/LibHac/FsSrv/Impl/LocationResolverSet.cs
View file

@ -58,7 +58,7 @@ internal class LocationResolverSet : IDisposable
public void Dispose() public void Dispose()
{ {
for (int i = 0; i < Array5<SharedRef<LocationResolver>>.Length; i++) for (int i = 0; i < _resolvers.Length; i++)
{ {
if (_resolvers[i].HasValue) if (_resolvers[i].HasValue)
{ {

10
src/LibHac/FsSrv/NcaFileSystemServiceImpl.cs
View file

@ -2,7 +2,6 @@
using System.Buffers.Text; using System.Buffers.Text;
using System.Runtime.CompilerServices; using System.Runtime.CompilerServices;
using LibHac.Common; using LibHac.Common;
using LibHac.Common.FixedArrays;
using LibHac.Fs; using LibHac.Fs;
using LibHac.Fs.Fsa; using LibHac.Fs.Fsa;
using LibHac.FsSrv.FsCreator; using LibHac.FsSrv.FsCreator;
@ -241,22 +240,23 @@ public class NcaFileSystemServiceImpl
return ResultFs.InvalidArgument.Log(); return ResultFs.InvalidArgument.Log();
} }
Unsafe.SkipInit(out Array64<byte> contentStoragePathBuffer); Span<byte> contentStoragePathBuffer = stackalloc byte[64];
//Unsafe.SkipInit(out Array64<byte> contentStoragePathBuffer);
// Build the appropriate path for the content storage ID // Build the appropriate path for the content storage ID
if (contentStorageId == ContentStorageId.SdCard) if (contentStorageId == ContentStorageId.SdCard)
{ {
var sb = new U8StringBuilder(contentStoragePathBuffer.Items); var sb = new U8StringBuilder(contentStoragePathBuffer);
sb.Append(StringTraits.DirectorySeparator).Append(CommonDirNames.SdCardNintendoRootDirectoryName); sb.Append(StringTraits.DirectorySeparator).Append(CommonDirNames.SdCardNintendoRootDirectoryName);
sb.Append(StringTraits.DirectorySeparator).Append(CommonDirNames.ContentStorageDirectoryName); sb.Append(StringTraits.DirectorySeparator).Append(CommonDirNames.ContentStorageDirectoryName);
} }
else else
{ {
var sb = new U8StringBuilder(contentStoragePathBuffer.Items); var sb = new U8StringBuilder(contentStoragePathBuffer);
sb.Append(StringTraits.DirectorySeparator).Append(CommonDirNames.ContentStorageDirectoryName); sb.Append(StringTraits.DirectorySeparator).Append(CommonDirNames.ContentStorageDirectoryName);
} }
using var contentStoragePath = new Path(); using scoped var contentStoragePath = new Path();
res = PathFunctions.SetUpFixedPath(ref contentStoragePath.Ref(), contentStoragePathBuffer); res = PathFunctions.SetUpFixedPath(ref contentStoragePath.Ref(), contentStoragePathBuffer);
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();

20
src/LibHac/FsSrv/SaveDataFileSystemServiceImpl.cs
View file

@ -128,7 +128,7 @@ public class SaveDataFileSystemServiceImpl : IDisposable
Unsafe.SkipInit(out Array18<byte> saveImageNameBuffer); Unsafe.SkipInit(out Array18<byte> saveImageNameBuffer);
using scoped var saveImageName = new Path(); using scoped var saveImageName = new Path();
res = PathFunctions.SetUpFixedPathSaveId(ref saveImageName.Ref(), saveImageNameBuffer.Items, saveDataId); res = PathFunctions.SetUpFixedPathSaveId(ref saveImageName.Ref(), saveImageNameBuffer, saveDataId);
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();
res = fileSystem.Get.GetEntryType(out _, in saveImageName); res = fileSystem.Get.GetEntryType(out _, in saveImageName);
@ -170,7 +170,7 @@ public class SaveDataFileSystemServiceImpl : IDisposable
// Create the save data directory on the host if needed. // Create the save data directory on the host if needed.
Unsafe.SkipInit(out Array18<byte> saveDirectoryNameBuffer); Unsafe.SkipInit(out Array18<byte> saveDirectoryNameBuffer);
using scoped var saveDirectoryName = new Path(); using scoped var saveDirectoryName = new Path();
res = PathFunctions.SetUpFixedPathSaveId(ref saveDirectoryName.Ref(), saveDirectoryNameBuffer.Items, saveDataId); res = PathFunctions.SetUpFixedPathSaveId(ref saveDirectoryName.Ref(), saveDirectoryNameBuffer, saveDataId);
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();
res = FsSystem.Utility.EnsureDirectory(fileSystem.Get, in saveDirectoryName); res = FsSystem.Utility.EnsureDirectory(fileSystem.Get, in saveDirectoryName);
@ -234,7 +234,7 @@ public class SaveDataFileSystemServiceImpl : IDisposable
using scoped var saveDataMetaIdDirectoryName = new Path(); using scoped var saveDataMetaIdDirectoryName = new Path();
Result res = PathFunctions.SetUpFixedPathSaveMetaDir(ref saveDataMetaIdDirectoryName.Ref(), Result res = PathFunctions.SetUpFixedPathSaveMetaDir(ref saveDataMetaIdDirectoryName.Ref(),
saveDataMetaIdDirectoryNameBuffer.Items, saveDataId); saveDataMetaIdDirectoryNameBuffer, saveDataId);
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();
return OpenSaveDataDirectoryFileSystemImpl(ref outFileSystem, spaceId, in saveDataMetaIdDirectoryName).Ret(); return OpenSaveDataDirectoryFileSystemImpl(ref outFileSystem, spaceId, in saveDataMetaIdDirectoryName).Ret();
@ -314,7 +314,7 @@ public class SaveDataFileSystemServiceImpl : IDisposable
Unsafe.SkipInit(out Array15<byte> saveDataMetaNameBuffer); Unsafe.SkipInit(out Array15<byte> saveDataMetaNameBuffer);
using scoped var saveDataMetaName = new Path(); using scoped var saveDataMetaName = new Path();
res = PathFunctions.SetUpFixedPathSaveMetaName(ref saveDataMetaName.Ref(), saveDataMetaNameBuffer.Items, res = PathFunctions.SetUpFixedPathSaveMetaName(ref saveDataMetaName.Ref(), saveDataMetaNameBuffer,
(uint)metaType); (uint)metaType);
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();
@ -334,7 +334,7 @@ public class SaveDataFileSystemServiceImpl : IDisposable
Unsafe.SkipInit(out Array15<byte> saveDataMetaNameBuffer); Unsafe.SkipInit(out Array15<byte> saveDataMetaNameBuffer);
using scoped var saveDataMetaName = new Path(); using scoped var saveDataMetaName = new Path();
res = PathFunctions.SetUpFixedPathSaveMetaName(ref saveDataMetaName.Ref(), saveDataMetaNameBuffer.Items, res = PathFunctions.SetUpFixedPathSaveMetaName(ref saveDataMetaName.Ref(), saveDataMetaNameBuffer,
(uint)metaType); (uint)metaType);
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();
@ -361,7 +361,7 @@ public class SaveDataFileSystemServiceImpl : IDisposable
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();
using scoped var saveDataIdDirectoryName = new Path(); using scoped var saveDataIdDirectoryName = new Path();
PathFunctions.SetUpFixedPathSaveId(ref saveDataIdDirectoryName.Ref(), saveDataIdDirectoryNameBuffer.Items, PathFunctions.SetUpFixedPathSaveId(ref saveDataIdDirectoryName.Ref(), saveDataIdDirectoryNameBuffer,
saveDataId); saveDataId);
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();
@ -390,7 +390,7 @@ public class SaveDataFileSystemServiceImpl : IDisposable
Unsafe.SkipInit(out Array15<byte> saveDataMetaNameBuffer); Unsafe.SkipInit(out Array15<byte> saveDataMetaNameBuffer);
using scoped var saveDataMetaName = new Path(); using scoped var saveDataMetaName = new Path();
res = PathFunctions.SetUpFixedPathSaveMetaName(ref saveDataMetaName.Ref(), saveDataMetaNameBuffer.Items, res = PathFunctions.SetUpFixedPathSaveMetaName(ref saveDataMetaName.Ref(), saveDataMetaNameBuffer,
(uint)metaType); (uint)metaType);
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();
@ -418,7 +418,7 @@ public class SaveDataFileSystemServiceImpl : IDisposable
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();
using scoped var saveImageName = new Path(); using scoped var saveImageName = new Path();
res = PathFunctions.SetUpFixedPathSaveId(ref saveImageName.Ref(), saveImageNameBuffer.Items, saveDataId); res = PathFunctions.SetUpFixedPathSaveId(ref saveImageName.Ref(), saveImageNameBuffer, saveDataId);
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();
bool isPseudoSaveFs = _config.IsPseudoSaveData(); bool isPseudoSaveFs = _config.IsPseudoSaveData();
@ -490,7 +490,7 @@ public class SaveDataFileSystemServiceImpl : IDisposable
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();
using scoped var saveImageName = new Path(); using scoped var saveImageName = new Path();
res = PathFunctions.SetUpFixedPathSaveId(ref saveImageName.Ref(), saveImageNameBuffer.Items, saveDataId); res = PathFunctions.SetUpFixedPathSaveId(ref saveImageName.Ref(), saveImageNameBuffer, saveDataId);
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();
// Check if the save data is a file or a directory // Check if the save data is a file or a directory
@ -758,7 +758,7 @@ public class SaveDataFileSystemServiceImpl : IDisposable
Unsafe.SkipInit(out Array64<byte> pathParentBuffer); Unsafe.SkipInit(out Array64<byte> pathParentBuffer);
using scoped var pathParent = new Path(); using scoped var pathParent = new Path();
res = PathFunctions.SetUpFixedPathSingleEntry(ref pathParent.Ref(), pathParentBuffer.Items, res = PathFunctions.SetUpFixedPathSingleEntry(ref pathParent.Ref(), pathParentBuffer,
CommonDirNames.SdCardNintendoRootDirectoryName); CommonDirNames.SdCardNintendoRootDirectoryName);
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();

6
src/LibHac/FsSrv/SaveDataIndexer.cs
View file

@ -77,8 +77,8 @@ public class SaveDataIndexer : ISaveDataIndexer
{ {
Assert.SdkRequires(!_isMounted); Assert.SdkRequires(!_isMounted);
int mountNameLength = StringUtils.Strlcpy(_mountName.Items, mountName, Array16<byte>.Length); int mountNameLength = StringUtils.Strlcpy(_mountName, mountName, _mountName.Length);
Assert.SdkLess(mountNameLength, Array16<byte>.Length); Assert.SdkLess(mountNameLength, _mountName.Length);
_fsClient.DisableAutoSaveDataCreation(); _fsClient.DisableAutoSaveDataCreation();
@ -227,7 +227,7 @@ public class SaveDataIndexer : ISaveDataIndexer
_handle = 1; _handle = 1;
_openReaders = new LinkedList<ReaderAccessor>(); _openReaders = new LinkedList<ReaderAccessor>();
_isDelayedReaderUnregistrationRequired = false; _isDelayedReaderUnregistrationRequired = false;
StringUtils.Copy(_mountName.Items, mountName); StringUtils.Copy(_mountName, mountName);
_fsClient = fsClient; _fsClient = fsClient;
} }

2
src/LibHac/FsSrv/SaveDataSharedFileStorage.cs
View file

@ -337,7 +337,7 @@ public class SaveDataFileStorageHolder
Unsafe.SkipInit(out Array18<byte> saveImageNameBuffer); Unsafe.SkipInit(out Array18<byte> saveImageNameBuffer);
using scoped var saveImageName = new Path(); using scoped var saveImageName = new Path();
Result res = PathFunctions.SetUpFixedPathSaveId(ref saveImageName.Ref(), saveImageNameBuffer.Items, saveDataId); Result res = PathFunctions.SetUpFixedPathSaveId(ref saveImageName.Ref(), saveImageNameBuffer, saveDataId);
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();
// If an open type isn't specified, open the save without the shared file storage layer // If an open type isn't specified, open the save without the shared file storage layer

8
src/LibHac/FsSrv/SaveDataTransferCryptoConfiguration.cs
View file

@ -11,10 +11,10 @@ public class SaveDataTransferCryptoConfiguration
private Array256<byte> _kekEncryptionKeyModulus; private Array256<byte> _kekEncryptionKeyModulus;
private Array256<byte> _keyPackageSigningModulus; private Array256<byte> _keyPackageSigningModulus;
public Span<byte> TokenSigningKeyModulus => _tokenSigningKeyModulus.Items; public Span<byte> TokenSigningKeyModulus => _tokenSigningKeyModulus;
public Span<byte> KeySeedPackageSigningKeyModulus => _keySeedPackageSigningKeyModulus.Items; public Span<byte> KeySeedPackageSigningKeyModulus => _keySeedPackageSigningKeyModulus;
public Span<byte> KekEncryptionKeyModulus => _kekEncryptionKeyModulus.Items; public Span<byte> KekEncryptionKeyModulus => _kekEncryptionKeyModulus;
public Span<byte> KeyPackageSigningModulus => _keyPackageSigningModulus.Items; public Span<byte> KeyPackageSigningModulus => _keyPackageSigningModulus;
public SaveTransferAesKeyGenerator GenerateAesKey { get; set; } public SaveTransferAesKeyGenerator GenerateAesKey { get; set; }
public RandomDataGenerator GenerateRandomData { get; set; } public RandomDataGenerator GenerateRandomData { get; set; }

12
src/LibHac/FsSystem/AesCtrCounterExtendedStorage.cs
View file

@ -44,12 +44,12 @@ public class AesCtrCounterExtendedStorage : IStorage
public void SetOffset(long value) public void SetOffset(long value)
{ {
BinaryPrimitives.WriteInt64LittleEndian(Offset.Items, value); BinaryPrimitives.WriteInt64LittleEndian(Offset, value);
} }
public readonly long GetOffset() public readonly long GetOffset()
{ {
return BinaryPrimitives.ReadInt64LittleEndian(Offset.ItemsRo); return BinaryPrimitives.ReadInt64LittleEndian(Offset);
} }
} }
@ -189,7 +189,7 @@ public class AesCtrCounterExtendedStorage : IStorage
return ResultFs.InvalidAesCtrCounterExtendedDataStorageSize.Log(); return ResultFs.InvalidAesCtrCounterExtendedDataStorageSize.Log();
_dataStorage.Set(in dataStorage); _dataStorage.Set(in dataStorage);
key.CopyTo(_key.Items); key.CopyTo(_key);
_secureValue = secureValue; _secureValue = secureValue;
_counterOffset = counterOffset; _counterOffset = counterOffset;
_decryptor.Set(ref decryptor); _decryptor.Set(ref decryptor);
@ -306,7 +306,7 @@ public class AesCtrCounterExtendedStorage : IStorage
}; };
Unsafe.SkipInit(out Array16<byte> counter); Unsafe.SkipInit(out Array16<byte> counter);
AesCtrStorage.MakeIv(counter.Items, upperIv.Value, counterOffset); AesCtrStorage.MakeIv(counter, upperIv.Value, counterOffset);
// Decrypt the data from the current entry. // Decrypt the data from the current entry.
res = _decryptor.Get.Decrypt(currentData.Slice(0, (int)dataSize), _key, counter); res = _decryptor.Get.Decrypt(currentData.Slice(0, (int)dataSize), _key, counter);
@ -440,7 +440,7 @@ public class AesCtrCounterExtendedStorage : IStorage
Assert.SdkRequiresEqual(iv.Length, IvSize); Assert.SdkRequiresEqual(iv.Length, IvSize);
Unsafe.SkipInit(out Array16<byte> counter); Unsafe.SkipInit(out Array16<byte> counter);
iv.CopyTo(counter.Items); iv.CopyTo(counter);
int remainingSize = destination.Length; int remainingSize = destination.Length;
int currentOffset = 0; int currentOffset = 0;
@ -466,7 +466,7 @@ public class AesCtrCounterExtendedStorage : IStorage
if (remainingSize > 0) if (remainingSize > 0)
{ {
Utility.AddCounter(counter.Items, (uint)currentSize / (uint)BlockSize); Utility.AddCounter(counter, (uint)currentSize / (uint)BlockSize);
} }
} }

14
src/LibHac/FsSystem/AesCtrStorage.cs
View file

@ -46,8 +46,8 @@ public class AesCtrStorage : IStorage
_baseStorage = baseStorage; _baseStorage = baseStorage;
key.CopyTo(_key.Items); key.CopyTo(_key);
iv.CopyTo(_iv.Items); iv.CopyTo(_iv);
} }
public AesCtrStorage(in SharedRef<IStorage> baseStorage, ReadOnlySpan<byte> key, ReadOnlySpan<byte> iv) public AesCtrStorage(in SharedRef<IStorage> baseStorage, ReadOnlySpan<byte> key, ReadOnlySpan<byte> iv)
@ -59,8 +59,8 @@ public class AesCtrStorage : IStorage
_baseStorage = baseStorage.Get; _baseStorage = baseStorage.Get;
_baseStorageShared = SharedRef<IStorage>.CreateCopy(in baseStorage); _baseStorageShared = SharedRef<IStorage>.CreateCopy(in baseStorage);
key.CopyTo(_key.Items); key.CopyTo(_key);
iv.CopyTo(_iv.Items); iv.CopyTo(_iv);
} }
public override void Dispose() public override void Dispose()
@ -88,7 +88,7 @@ public class AesCtrStorage : IStorage
using var changePriority = new ScopedThreadPriorityChanger(1, ScopedThreadPriorityChanger.Mode.Relative); using var changePriority = new ScopedThreadPriorityChanger(1, ScopedThreadPriorityChanger.Mode.Relative);
Array16<byte> counter = _iv; Array16<byte> counter = _iv;
Utility.AddCounter(counter.Items, (ulong)offset / (uint)BlockSize); Utility.AddCounter(counter, (ulong)offset / (uint)BlockSize);
int decSize = Aes.DecryptCtr128(destination, destination, _key, counter); int decSize = Aes.DecryptCtr128(destination, destination, _key, counter);
if (decSize != destination.Length) if (decSize != destination.Length)
@ -121,7 +121,7 @@ public class AesCtrStorage : IStorage
// Setup the counter. // Setup the counter.
var counter = new Array16<byte>(); var counter = new Array16<byte>();
Utility.AddCounter(counter.Items, (ulong)offset / (uint)BlockSize); Utility.AddCounter(counter, (ulong)offset / (uint)BlockSize);
// Loop until all data is written. // Loop until all data is written.
int remaining = source.Length; int remaining = source.Length;
@ -152,7 +152,7 @@ public class AesCtrStorage : IStorage
remaining -= writeSize; remaining -= writeSize;
if (remaining > 0) if (remaining > 0)
{ {
Utility.AddCounter(counter.Items, (uint)writeSize / (uint)BlockSize); Utility.AddCounter(counter, (uint)writeSize / (uint)BlockSize);
} }
} }

12
src/LibHac/FsSystem/AesXtsStorage.cs
View file

@ -52,9 +52,9 @@ public class AesXtsStorage : IStorage
Assert.SdkRequiresEqual(IvSize, iv.Length); Assert.SdkRequiresEqual(IvSize, iv.Length);
Assert.SdkRequiresAligned(blockSize, AesBlockSize); Assert.SdkRequiresAligned(blockSize, AesBlockSize);
key1.CopyTo(_key1.Items); key1.CopyTo(_key1);
key2.CopyTo(_key2.Items); key2.CopyTo(_key2);
iv.CopyTo(_iv.Items); iv.CopyTo(_iv);
} }
public AesXtsStorage(ref SharedRef<IStorage> baseStorage, ReadOnlySpan<byte> key1, ReadOnlySpan<byte> key2, public AesXtsStorage(ref SharedRef<IStorage> baseStorage, ReadOnlySpan<byte> key1, ReadOnlySpan<byte> key2,
@ -70,9 +70,9 @@ public class AesXtsStorage : IStorage
Assert.SdkRequiresEqual(IvSize, iv.Length); Assert.SdkRequiresEqual(IvSize, iv.Length);
Assert.SdkRequiresAligned(blockSize, AesBlockSize); Assert.SdkRequiresAligned(blockSize, AesBlockSize);
key1.CopyTo(_key1.Items); key1.CopyTo(_key1);
key2.CopyTo(_key2.Items); key2.CopyTo(_key2);
iv.CopyTo(_iv.Items); iv.CopyTo(_iv);
} }
public override void Dispose() public override void Dispose()

10
src/LibHac/FsSystem/AesXtsStorageExternal.cs
View file

@ -45,12 +45,12 @@ public class AesXtsStorageExternal : IStorage
Assert.SdkRequiresAligned(blockSize, AesBlockSize); Assert.SdkRequiresAligned(blockSize, AesBlockSize);
if (key1.Length != 0) if (key1.Length != 0)
key1.CopyTo(_key[0].Items); key1.CopyTo(_key[0]);
if (key2.Length != 0) if (key2.Length != 0)
key2.CopyTo(_key[1].Items); key2.CopyTo(_key[1]);
iv.CopyTo(_iv.Items); iv.CopyTo(_iv);
} }
public AesXtsStorageExternal(in SharedRef<IStorage> baseStorage, ReadOnlySpan<byte> key1, ReadOnlySpan<byte> key2, public AesXtsStorageExternal(in SharedRef<IStorage> baseStorage, ReadOnlySpan<byte> key1, ReadOnlySpan<byte> key2,
@ -93,7 +93,7 @@ public class AesXtsStorageExternal : IStorage
// Setup the counter. // Setup the counter.
Span<byte> counter = stackalloc byte[IvSize]; Span<byte> counter = stackalloc byte[IvSize];
_iv.ItemsRo.CopyTo(counter); _iv[..].CopyTo(counter);
Utility.AddCounter(counter, (ulong)offset / _blockSize); Utility.AddCounter(counter, (ulong)offset / _blockSize);
// Handle any unaligned data before the start. // Handle any unaligned data before the start.
@ -175,7 +175,7 @@ public class AesXtsStorageExternal : IStorage
// Setup the counter. // Setup the counter.
Span<byte> counter = stackalloc byte[IvSize]; Span<byte> counter = stackalloc byte[IvSize];
_iv.ItemsRo.CopyTo(counter); _iv[..].CopyTo(counter);
Utility.AddCounter(counter, (ulong)offset / _blockSize); Utility.AddCounter(counter, (ulong)offset / _blockSize);
// Handle any unaligned data before the start. // Handle any unaligned data before the start.

4
src/LibHac/FsSystem/ConcatenationFileSystem.cs
View file

@ -535,9 +535,9 @@ public class ConcatenationFileSystem : IFileSystem
private static Result AppendInternalFilePath(ref Path path, int index) private static Result AppendInternalFilePath(ref Path path, int index)
{ {
var buffer = new Array3<byte>(); var buffer = new Array3<byte>();
Utf8Formatter.TryFormat(index, buffer.Items, out _, new StandardFormat('d', 2)); Utf8Formatter.TryFormat(index, buffer, out _, new StandardFormat('d', 2));
return path.AppendChild(buffer.ItemsRo).Ret(); return path.AppendChild(buffer).Ret();
} }
private static Result GenerateInternalFilePath(ref Path outPath, int index, in Path basePath) private static Result GenerateInternalFilePath(ref Path outPath, int index, in Path basePath)

2
src/LibHac/FsSystem/Impl/PartitionFileSystemFormats.cs
View file

@ -37,7 +37,7 @@ public struct PartitionFileSystemFormat : IPartitionFileSystemFormat
{ {
get get
{ {
ReadOnlySpan<byte> span = _signature.ItemsRo; ReadOnlySpan<byte> span = _signature;
return MemoryMarshal.CreateReadOnlySpan(ref MemoryMarshal.GetReference(span), span.Length); return MemoryMarshal.CreateReadOnlySpan(ref MemoryMarshal.GetReference(span), span.Length);
} }
} }

8
src/LibHac/FsSystem/IndirectStorage.cs
View file

@ -73,7 +73,7 @@ public class IndirectStorage : IStorage
{ {
FinalizeObject(); FinalizeObject();
Span<ValueSubStorage> items = _dataStorage.Items; Span<ValueSubStorage> items = _dataStorage;
for (int i = 0; i < items.Length; i++) for (int i = 0; i < items.Length; i++)
items[i].Dispose(); items[i].Dispose();
@ -160,7 +160,7 @@ public class IndirectStorage : IStorage
{ {
_table.FinalizeObject(); _table.FinalizeObject();
Span<ValueSubStorage> storages = _dataStorage.Items; Span<ValueSubStorage> storages = _dataStorage;
for (int i = 0; i < storages.Length; i++) for (int i = 0; i < storages.Length; i++)
{ {
using var emptySubStorage = new ValueSubStorage(); using var emptySubStorage = new ValueSubStorage();
@ -303,9 +303,9 @@ public class IndirectStorage : IStorage
Result res = _table.InvalidateCache(); Result res = _table.InvalidateCache();
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();
for (int i = 0; i < _dataStorage.Items.Length; i++) for (int i = 0; i < _dataStorage.Length; i++)
{ {
res = _dataStorage.Items[i].OperateRange(OperationId.InvalidateCache, 0, long.MaxValue); res = _dataStorage[i].OperateRange(OperationId.InvalidateCache, 0, long.MaxValue);
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();
} }
} }

8
src/LibHac/FsSystem/IntegrityVerificationStorage.cs
View file

@ -70,7 +70,7 @@ public class IntegrityVerificationStorage : IStorage
[MethodImpl(MethodImplOptions.AggressiveInlining)] [MethodImpl(MethodImplOptions.AggressiveInlining)]
private static void SetValidationBit(ref BlockHash hash) private static void SetValidationBit(ref BlockHash hash)
{ {
hash.Hash.Items[HashSize - 1] |= 0x80; hash.Hash[HashSize - 1] |= 0x80;
} }
/// <summary> /// <summary>
@ -82,7 +82,7 @@ public class IntegrityVerificationStorage : IStorage
[MethodImpl(MethodImplOptions.AggressiveInlining)] [MethodImpl(MethodImplOptions.AggressiveInlining)]
private static bool IsValidationBit(in BlockHash hash) private static bool IsValidationBit(in BlockHash hash)
{ {
return (hash.Hash.ItemsRo[HashSize - 1] & 0x80) != 0; return (hash.Hash[HashSize - 1] & 0x80) != 0;
} }
public int GetBlockSize() public int GetBlockSize()
@ -611,9 +611,9 @@ public class IntegrityVerificationStorage : IStorage
if (IsValidationBit(in hash)) if (IsValidationBit(in hash))
return Result.Success; return Result.Success;
for (int i = 0; i < hash.Hash.ItemsRo.Length; i++) for (int i = 0; i < hash.Hash.Length; i++)
{ {
if (hash.Hash.ItemsRo[i] != 0) if (hash.Hash[i] != 0)
return ResultFs.InvalidZeroHash.Log(); return ResultFs.InvalidZeroHash.Log();
} }

2
src/LibHac/FsSystem/LocalDirectory.cs
View file

@ -40,7 +40,7 @@ public class LocalDirectory : IDirectory
DirectoryEntryType type = isDir ? DirectoryEntryType.Directory : DirectoryEntryType.File; DirectoryEntryType type = isDir ? DirectoryEntryType.Directory : DirectoryEntryType.File;
long length = isDir ? 0 : ((FileInfo)localEntry).Length; long length = isDir ? 0 : ((FileInfo)localEntry).Length;
StringUtils.Copy(entryBuffer[i].Name.Items, name); StringUtils.Copy(entryBuffer[i].Name, name);
entryBuffer[i].Name[PathTool.EntryNameLengthMax] = 0; entryBuffer[i].Name[PathTool.EntryNameLengthMax] = 0;
entryBuffer[i].Attributes = localEntry.Attributes.ToNxAttributes(); entryBuffer[i].Attributes = localEntry.Attributes.ToNxAttributes();

32
src/LibHac/FsSystem/NcaReader.cs
View file

@ -64,7 +64,7 @@ public class NcaReader : IDisposable
Unsafe.SkipInit(out Array2<Array16<byte>> commonDecryptionKeys); Unsafe.SkipInit(out Array2<Array16<byte>> commonDecryptionKeys);
for (int i = 0; i < NcaCryptoConfiguration.HeaderEncryptionKeyCount; i++) for (int i = 0; i < NcaCryptoConfiguration.HeaderEncryptionKeyCount; i++)
{ {
cryptoConfig.GenerateKey(commonDecryptionKeys[i].Items, cryptoConfig.HeaderEncryptedEncryptionKeys[i], cryptoConfig.GenerateKey(commonDecryptionKeys[i], cryptoConfig.HeaderEncryptedEncryptionKeys[i],
headerKeyTypes[i]); headerKeyTypes[i]);
} }
@ -158,18 +158,18 @@ public class NcaReader : IDisposable
if (cryptoConfig.IsAvailableSwKey) if (cryptoConfig.IsAvailableSwKey)
{ {
int keyTypeValue = NcaKeyFunctions.GetKeyTypeValue(_header.KeyAreaEncryptionKeyIndex, _header.GetProperKeyGeneration()); int keyTypeValue = NcaKeyFunctions.GetKeyTypeValue(_header.KeyAreaEncryptionKeyIndex, _header.GetProperKeyGeneration());
ReadOnlySpan<byte> encryptedKeyCtr = _header.EncryptedKeys.ItemsRo.Slice((int)NcaHeader.DecryptionKey.AesCtr * Aes.KeySize128, Aes.KeySize128); ReadOnlySpan<byte> encryptedKeyCtr = _header.EncryptedKeys[..].Slice((int)NcaHeader.DecryptionKey.AesCtr * Aes.KeySize128, Aes.KeySize128);
cryptoConfig.GenerateKey(_decryptionKeys[(int)NcaHeader.DecryptionKey.AesCtr].Items, encryptedKeyCtr, keyTypeValue); cryptoConfig.GenerateKey(_decryptionKeys[(int)NcaHeader.DecryptionKey.AesCtr], encryptedKeyCtr, keyTypeValue);
} }
// Copy the plaintext hardware key. // Copy the plaintext hardware key.
ReadOnlySpan<byte> keyCtrHw = _header.EncryptedKeys.ItemsRo.Slice((int)NcaHeader.DecryptionKey.AesCtrHw * Aes.KeySize128, Aes.KeySize128); ReadOnlySpan<byte> keyCtrHw = _header.EncryptedKeys[..].Slice((int)NcaHeader.DecryptionKey.AesCtrHw * Aes.KeySize128, Aes.KeySize128);
keyCtrHw.CopyTo(_decryptionKeys[(int)NcaHeader.DecryptionKey.AesCtrHw].Items); keyCtrHw.CopyTo(_decryptionKeys[(int)NcaHeader.DecryptionKey.AesCtrHw]);
} }
// Clear the external decryption key. // Clear the external decryption key.
_externalDataDecryptionKey.Items.Clear(); _externalDataDecryptionKey[..].Clear();
// Copy the configuration to the NcaReader. // Copy the configuration to the NcaReader.
_isAvailableSwKey = cryptoConfig.IsAvailableSwKey; _isAvailableSwKey = cryptoConfig.IsAvailableSwKey;
@ -212,7 +212,7 @@ public class NcaReader : IDisposable
{ {
Assert.SdkRequiresEqual(NcaHeader.HeaderSignSize, outBuffer.Length); Assert.SdkRequiresEqual(NcaHeader.HeaderSignSize, outBuffer.Length);
_header.Signature2.ItemsRo.CopyTo(outBuffer); _header.Signature2[..].CopyTo(outBuffer);
} }
public void GetHeaderSign2TargetHash(Span<byte> outBuffer) public void GetHeaderSign2TargetHash(Span<byte> outBuffer)
@ -294,7 +294,7 @@ public class NcaReader : IDisposable
{ {
Assert.SdkRequiresGreaterEqual(outBuffer.Length, NcaHeader.RightsIdSize); Assert.SdkRequiresGreaterEqual(outBuffer.Length, NcaHeader.RightsIdSize);
_header.RightsId.ItemsRo.CopyTo(outBuffer); _header.RightsId[..].CopyTo(outBuffer);
} }
public bool HasFsInfo(int index) public bool HasFsInfo(int index)
@ -377,7 +377,7 @@ public class NcaReader : IDisposable
Assert.SdkRequiresNotNull(_bodyStorage); Assert.SdkRequiresNotNull(_bodyStorage);
Assert.SdkRequiresGreaterEqual(outBuffer.Length, NcaHeader.EncryptedKeyAreaSize); Assert.SdkRequiresGreaterEqual(outBuffer.Length, NcaHeader.EncryptedKeyAreaSize);
_header.EncryptedKeys.ItemsRo.CopyTo(outBuffer); _header.EncryptedKeys[..].CopyTo(outBuffer);
} }
public ReadOnlySpan<byte> GetDecryptionKey(int index) public ReadOnlySpan<byte> GetDecryptionKey(int index)
@ -395,7 +395,7 @@ public class NcaReader : IDisposable
for (int i = 0; i < (int)NcaHeader.DecryptionKey.Count; i++) for (int i = 0; i < (int)NcaHeader.DecryptionKey.Count; i++)
{ {
if (!CryptoUtil.IsSameBytes(zeroKey, if (!CryptoUtil.IsSameBytes(zeroKey,
_header.EncryptedKeys.ItemsRo.Slice(i * Aes.KeySize128, Aes.KeySize128), Aes.KeySize128)) _header.EncryptedKeys[..].Slice(i * Aes.KeySize128, Aes.KeySize128), Aes.KeySize128))
{ {
return true; return true;
} }
@ -408,7 +408,7 @@ public class NcaReader : IDisposable
{ {
Array16<byte> zeroKey = default; Array16<byte> zeroKey = default;
return !CryptoUtil.IsSameBytes(zeroKey, GetDecryptionKey((int)NcaHeader.DecryptionKey.AesCtrHw), return !CryptoUtil.IsSameBytes(zeroKey, GetDecryptionKey((int)NcaHeader.DecryptionKey.AesCtrHw),
Array16<byte>.Length); zeroKey.Length);
} }
public bool IsSwAesPrioritized() public bool IsSwAesPrioritized()
@ -428,20 +428,20 @@ public class NcaReader : IDisposable
public void SetExternalDecryptionKey(ReadOnlySpan<byte> key) public void SetExternalDecryptionKey(ReadOnlySpan<byte> key)
{ {
Assert.SdkRequiresEqual(_externalDataDecryptionKey.ItemsRo.Length, key.Length); Assert.SdkRequiresEqual(_externalDataDecryptionKey[..].Length, key.Length);
key.CopyTo(_externalDataDecryptionKey.Items); key.CopyTo(_externalDataDecryptionKey);
} }
public ReadOnlySpan<byte> GetExternalDecryptionKey() public ReadOnlySpan<byte> GetExternalDecryptionKey()
{ {
return _externalDataDecryptionKey.ItemsRo; return _externalDataDecryptionKey;
} }
public bool HasExternalDecryptionKey() public bool HasExternalDecryptionKey()
{ {
Array16<byte> zeroKey = default; Array16<byte> zeroKey = default;
return !CryptoUtil.IsSameBytes(zeroKey, GetExternalDecryptionKey(), Array16<byte>.Length); return !CryptoUtil.IsSameBytes(zeroKey, GetExternalDecryptionKey(), zeroKey.Length);
} }
public void GetRawData(Span<byte> outBuffer) public void GetRawData(Span<byte> outBuffer)
@ -505,7 +505,7 @@ public class NcaFsHeaderReader
Unsafe.SkipInit(out Hash hash); Unsafe.SkipInit(out Hash hash);
IHash256GeneratorFactory generator = reader.GetHashGeneratorFactorySelector().GetFactory(HashAlgorithmType.Sha2); IHash256GeneratorFactory generator = reader.GetHashGeneratorFactorySelector().GetFactory(HashAlgorithmType.Sha2);
generator.GenerateHash(hash.Value.Items, SpanHelpers.AsReadOnlyByteSpan(in _header)); generator.GenerateHash(hash.Value, SpanHelpers.AsReadOnlyByteSpan(in _header));
if (!CryptoUtil.IsSameBytes(reader.GetFsHeaderHash(index).Value, hash.Value, Unsafe.SizeOf<Hash>())) if (!CryptoUtil.IsSameBytes(reader.GetFsHeaderHash(index).Value, hash.Value, Unsafe.SizeOf<Hash>()))
{ {

2
src/LibHac/FsSystem/PartitionFileSystem.cs
View file

@ -370,7 +370,7 @@ public class PartitionFileSystemCore<TMetaData, TFormat, THeader, TEntry> : IFil
dirEntry.Type = DirectoryEntryType.File; dirEntry.Type = DirectoryEntryType.File;
dirEntry.Size = entry.Size; dirEntry.Size = entry.Size;
U8Span entryName = _parent._metaData.GetEntryName(_currentIndex); U8Span entryName = _parent._metaData.GetEntryName(_currentIndex);
StringUtils.Strlcpy(dirEntry.Name.Items, entryName, dirEntry.Name.ItemsRo.Length - 1); StringUtils.Strlcpy(dirEntry.Name, entryName, dirEntry.Name[..].Length - 1);
_currentIndex++; _currentIndex++;
} }

6
src/LibHac/Gc/GameCardEmulated.cs
View file

@ -81,7 +81,7 @@ public sealed class GameCardEmulated : IGcApi
Abort.DoAbortUnlessSuccess(ReadBaseStorage(0x100, SpanHelpers.AsByteSpan(ref _cardHeader))); Abort.DoAbortUnlessSuccess(ReadBaseStorage(0x100, SpanHelpers.AsByteSpan(ref _cardHeader)));
Abort.DoAbortUnlessSuccess(ReadBaseStorage(GcCertAreaPageAddress * GcPageSize, SpanHelpers.AsByteSpan(ref _certificate))); Abort.DoAbortUnlessSuccess(ReadBaseStorage(GcCertAreaPageAddress * GcPageSize, SpanHelpers.AsByteSpan(ref _certificate)));
Sha256.GenerateSha256Hash(SpanHelpers.AsReadOnlyByteSpan(in _cardHeader), _imageHash.Items); Sha256.GenerateSha256Hash(SpanHelpers.AsReadOnlyByteSpan(in _cardHeader), _imageHash);
DecryptCardHeader(ref _cardHeader); DecryptCardHeader(ref _cardHeader);
@ -361,7 +361,7 @@ public sealed class GameCardEmulated : IGcApi
Result res = CheckCardReady(); Result res = CheckCardReady();
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();
_certificate.T1CardDeviceId.ItemsRo.CopyTo(destBuffer); _certificate.T1CardDeviceId[..].CopyTo(destBuffer);
return Result.Success; return Result.Success;
} }
@ -393,7 +393,7 @@ public sealed class GameCardEmulated : IGcApi
Result res = CheckCardReady(); Result res = CheckCardReady();
if (res.IsFailure()) return res.Miss(); if (res.IsFailure()) return res.Miss();
_imageHash.ItemsRo.CopyTo(destBuffer); _imageHash[..].CopyTo(destBuffer);
return Result.Success; return Result.Success;
} }

4
src/LibHac/GcSrv/GameCardStorageDevice.cs
View file

@ -48,8 +48,8 @@ internal class GameCardStorageDevice : GameCardStorageInterfaceAdapter, IStorage
_handle = handle; _handle = handle;
_isSecure = isSecure; _isSecure = isSecure;
cardDeviceId.CopyTo(_cardDeviceId.Items); cardDeviceId.CopyTo(_cardDeviceId);
cardImageHash.CopyTo(_cardImageHash.Items); cardImageHash.CopyTo(_cardImageHash);
_gc = gc; _gc = gc;
} }

4
src/LibHac/Loader/NsoReader.cs
View file

@ -92,9 +92,9 @@ public class NsoReader
if (checkHash) if (checkHash)
{ {
var hash = new Array32<byte>(); var hash = new Array32<byte>();
Crypto.Sha256.GenerateSha256Hash(buffer.Slice(0, (int)segment.Size), hash.Items); Crypto.Sha256.GenerateSha256Hash(buffer.Slice(0, (int)segment.Size), hash);
if (hash.ItemsRo.SequenceCompareTo(fileHash) != 0) if (hash[..].SequenceCompareTo(fileHash) != 0)
return ResultLoader.InvalidNso.Log(); return ResultLoader.InvalidNso.Log();
} }

12
src/LibHac/Ns/ApplicationControlProperty.cs
View file

@ -71,18 +71,18 @@ public struct ApplicationControlProperty
public AccessibleLaunchRequiredVersionValue AccessibleLaunchRequiredVersion; public AccessibleLaunchRequiredVersionValue AccessibleLaunchRequiredVersion;
public Array3000<byte> Reserved3448; public Array3000<byte> Reserved3448;
[UnscopedRef] public readonly U8Span IsbnString => new U8Span(Isbn.ItemsRo); [UnscopedRef] public readonly U8Span IsbnString => new U8Span(Isbn);
[UnscopedRef] public readonly U8Span DisplayVersionString => new U8Span(DisplayVersion.ItemsRo); [UnscopedRef] public readonly U8Span DisplayVersionString => new U8Span(DisplayVersion);
[UnscopedRef] public readonly U8Span ApplicationErrorCodeCategoryString => new U8Span(ApplicationErrorCodeCategory.ItemsRo); [UnscopedRef] public readonly U8Span ApplicationErrorCodeCategoryString => new U8Span(ApplicationErrorCodeCategory);
[UnscopedRef] public readonly U8Span BcatPassphraseString => new U8Span(BcatPassphrase.ItemsRo); [UnscopedRef] public readonly U8Span BcatPassphraseString => new U8Span(BcatPassphrase);
public struct ApplicationTitle public struct ApplicationTitle
{ {
public Array512<byte> Name; public Array512<byte> Name;
public Array256<byte> Publisher; public Array256<byte> Publisher;
[UnscopedRef] public readonly U8Span NameString => new U8Span(Name.ItemsRo); [UnscopedRef] public readonly U8Span NameString => new U8Span(Name);
[UnscopedRef] public readonly U8Span PublisherString => new U8Span(Publisher.ItemsRo); [UnscopedRef] public readonly U8Span PublisherString => new U8Span(Publisher);
} }
public struct ApplicationNeighborDetectionClientConfiguration public struct ApplicationNeighborDetectionClientConfiguration

2
src/LibHac/Tools/Es/Ticket.cs
View file

@ -158,7 +158,7 @@ public class Ticket
return commonKey; return commonKey;
} }
if (keySet.ETicketRsaKey.PublicExponent.ItemsRo.IsZeros()) if (keySet.ETicketRsaKey.PublicExponent[..].IsZeros())
return null; return null;
try try

4
src/LibHac/Tools/Fs/InMemoryFileSystem.cs
View file

@ -252,7 +252,7 @@ public class InMemoryFileSystem : IAttributeFileSystem
{ {
ref DirectoryEntry entry = ref entryBuffer[i]; ref DirectoryEntry entry = ref entryBuffer[i];
StringUtils.Copy(entry.Name.Items, CurrentDir.Name); StringUtils.Copy(entry.Name, CurrentDir.Name);
entry.Name[PathTool.EntryNameLengthMax] = 0; entry.Name[PathTool.EntryNameLengthMax] = 0;
entry.Type = DirectoryEntryType.Directory; entry.Type = DirectoryEntryType.Directory;
@ -270,7 +270,7 @@ public class InMemoryFileSystem : IAttributeFileSystem
{ {
ref DirectoryEntry entry = ref entryBuffer[i]; ref DirectoryEntry entry = ref entryBuffer[i];
StringUtils.Copy(entry.Name.Items, CurrentFile.Name); StringUtils.Copy(entry.Name, CurrentFile.Name);
entry.Name[PathTool.EntryNameLengthMax] = 0; entry.Name[PathTool.EntryNameLengthMax] = 0;
entry.Type = DirectoryEntryType.File; entry.Type = DirectoryEntryType.File;

2
src/LibHac/Tools/Fs/SwitchFs.cs
View file

@ -232,7 +232,7 @@ public class SwitchFs : IDisposable
control.Get.Read(out _, 0, title.Control.ByteSpan).ThrowIfFailure(); control.Get.Read(out _, 0, title.Control.ByteSpan).ThrowIfFailure();
} }
foreach (ref readonly ApplicationControlProperty.ApplicationTitle desc in title.Control.Value.Title.ItemsRo) foreach (ref readonly ApplicationControlProperty.ApplicationTitle desc in title.Control.Value.Title)
{ {
if (!desc.NameString.IsEmpty()) if (!desc.NameString.IsEmpty())
{ {

6
src/LibHac/Tools/Fs/XciHeader.cs
View file

@ -220,14 +220,14 @@ public class XciHeader
ref readonly CardInitialData data = ref SpanHelpers.AsReadOnlyStruct<CardInitialData>(initialData); ref readonly CardInitialData data = ref SpanHelpers.AsReadOnlyStruct<CardInitialData>(initialData);
if (dest.Length != data.Payload.AuthData.ItemsRo.Length) if (dest.Length != data.Payload.AuthData[..].Length)
return ResultFs.GameCardPreconditionViolation.Log(); return ResultFs.GameCardPreconditionViolation.Log();
// Verify padding is all-zero. // Verify padding is all-zero.
bool anyNonZero = false; bool anyNonZero = false;
for (int i = 0; i < data.Padding.ItemsRo.Length; i++) for (int i = 0; i < data.Padding.Length; i++)
{ {
anyNonZero |= data.Padding.ItemsRo[i] != 0; anyNonZero |= data.Padding[i] != 0;
} }
if (anyNonZero) if (anyNonZero)

4
src/LibHac/Tools/FsSystem/NcaUtils/Nca.cs
View file

@ -173,7 +173,7 @@ public class Nca
ref NcaSparseInfo sparseInfo = ref fsHeader.GetSparseInfo(); ref NcaSparseInfo sparseInfo = ref fsHeader.GetSparseInfo();
Unsafe.SkipInit(out BucketTree.Header header); Unsafe.SkipInit(out BucketTree.Header header);
sparseInfo.MetaHeader.ItemsRo.CopyTo(SpanHelpers.AsByteSpan(ref header)); sparseInfo.MetaHeader[..].CopyTo(SpanHelpers.AsByteSpan(ref header));
header.Verify().ThrowIfFailure(); header.Verify().ThrowIfFailure();
var sparseStorage = new SparseStorage(); var sparseStorage = new SparseStorage();
@ -429,7 +429,7 @@ public class Nca
ref NcaCompressionInfo compressionInfo = ref header.GetCompressionInfo(); ref NcaCompressionInfo compressionInfo = ref header.GetCompressionInfo();
Unsafe.SkipInit(out BucketTree.Header bucketTreeHeader); Unsafe.SkipInit(out BucketTree.Header bucketTreeHeader);
compressionInfo.TableHeader.ItemsRo.CopyTo(SpanHelpers.AsByteSpan(ref bucketTreeHeader)); compressionInfo.TableHeader[..].CopyTo(SpanHelpers.AsByteSpan(ref bucketTreeHeader));
bucketTreeHeader.Verify().ThrowIfFailure(); bucketTreeHeader.Verify().ThrowIfFailure();
long nodeStorageSize = CompressedStorage.QueryNodeStorageSize(bucketTreeHeader.EntryCount); long nodeStorageSize = CompressedStorage.QueryNodeStorageSize(bucketTreeHeader.EntryCount);

4
src/LibHac/Tools/FsSystem/RomFs/RomFsDirectory.cs
View file

@ -50,7 +50,7 @@ public class RomFsDirectory : IDirectory
ref DirectoryEntry entry = ref entryBuffer[i]; ref DirectoryEntry entry = ref entryBuffer[i];
Span<byte> nameUtf8 = Encoding.UTF8.GetBytes(name); Span<byte> nameUtf8 = Encoding.UTF8.GetBytes(name);
StringUtils.Copy(entry.Name.Items, nameUtf8); StringUtils.Copy(entry.Name, nameUtf8);
entry.Name[PathTool.EntryNameLengthMax] = 0; entry.Name[PathTool.EntryNameLengthMax] = 0;
entry.Type = DirectoryEntryType.Directory; entry.Type = DirectoryEntryType.Directory;
@ -70,7 +70,7 @@ public class RomFsDirectory : IDirectory
ref DirectoryEntry entry = ref entryBuffer[i]; ref DirectoryEntry entry = ref entryBuffer[i];
Span<byte> nameUtf8 = Encoding.UTF8.GetBytes(name); Span<byte> nameUtf8 = Encoding.UTF8.GetBytes(name);
StringUtils.Copy(entry.Name.Items, nameUtf8); StringUtils.Copy(entry.Name, nameUtf8);
entry.Name[PathTool.EntryNameLengthMax] = 0; entry.Name[PathTool.EntryNameLengthMax] = 0;
entry.Type = DirectoryEntryType.File; entry.Type = DirectoryEntryType.File;

4
src/LibHac/Tools/FsSystem/Save/SaveDataDirectory.cs
View file

@ -50,7 +50,7 @@ public class SaveDataDirectory : IDirectory
ref DirectoryEntry entry = ref entryBuffer[i]; ref DirectoryEntry entry = ref entryBuffer[i];
Span<byte> nameUtf8 = Encoding.UTF8.GetBytes(name); Span<byte> nameUtf8 = Encoding.UTF8.GetBytes(name);
StringUtils.Copy(entry.Name.Items, nameUtf8); StringUtils.Copy(entry.Name, nameUtf8);
entry.Name[64] = 0; entry.Name[64] = 0;
entry.Type = DirectoryEntryType.Directory; entry.Type = DirectoryEntryType.Directory;
@ -70,7 +70,7 @@ public class SaveDataDirectory : IDirectory
ref DirectoryEntry entry = ref entryBuffer[i]; ref DirectoryEntry entry = ref entryBuffer[i];
Span<byte> nameUtf8 = Encoding.UTF8.GetBytes(name); Span<byte> nameUtf8 = Encoding.UTF8.GetBytes(name);
StringUtils.Copy(entry.Name.Items, nameUtf8); StringUtils.Copy(entry.Name, nameUtf8);
entry.Name[64] = 0; entry.Name[64] = 0;
entry.Type = DirectoryEntryType.File; entry.Type = DirectoryEntryType.File;

1
src/hactoolnet/ProcessNca.cs
View file

@ -13,7 +13,6 @@ using LibHac.Tools.Fs;
using LibHac.Tools.FsSystem; using LibHac.Tools.FsSystem;
using LibHac.Tools.FsSystem.NcaUtils; using LibHac.Tools.FsSystem.NcaUtils;
using LibHac.Tools.Npdm; using LibHac.Tools.Npdm;
using LibHac.Util;
using static hactoolnet.Print; using static hactoolnet.Print;
using NcaFsHeader = LibHac.Tools.FsSystem.NcaUtils.NcaFsHeader; using NcaFsHeader = LibHac.Tools.FsSystem.NcaUtils.NcaFsHeader;

14
src/hactoolnet/ProcessPackage.cs
View file

@ -65,9 +65,9 @@ internal static class ProcessPackage
if (package1.IsMariko) if (package1.IsMariko)
{ {
sb.AppendLine("Mariko OEM Header:"); sb.AppendLine("Mariko OEM Header:");
PrintItem(sb, colLen, " Signature:", package1.MarikoOemHeader.RsaSig.ItemsRo.ToArray()); PrintItem(sb, colLen, " Signature:", package1.MarikoOemHeader.RsaSig[..].ToArray());
PrintItem(sb, colLen, " Random Salt:", package1.MarikoOemHeader.Salt.ItemsRo.ToArray()); PrintItem(sb, colLen, " Random Salt:", package1.MarikoOemHeader.Salt[..].ToArray());
PrintItem(sb, colLen, " OEM Bootloader Hash:", package1.MarikoOemHeader.Hash.ItemsRo.ToArray()); PrintItem(sb, colLen, " OEM Bootloader Hash:", package1.MarikoOemHeader.Hash[..].ToArray());
PrintItem(sb, colLen, " OEM Bootloader Version:", $"{package1.MarikoOemHeader.Version:x2}"); PrintItem(sb, colLen, " OEM Bootloader Version:", $"{package1.MarikoOemHeader.Version:x2}");
PrintItem(sb, colLen, " OEM Bootloader Size:", $"{package1.MarikoOemHeader.Size:x8}"); PrintItem(sb, colLen, " OEM Bootloader Size:", $"{package1.MarikoOemHeader.Size:x8}");
PrintItem(sb, colLen, " OEM Bootloader Load Address:", $"{package1.MarikoOemHeader.LoadAddress:x8}"); PrintItem(sb, colLen, " OEM Bootloader Load Address:", $"{package1.MarikoOemHeader.LoadAddress:x8}");
@ -98,7 +98,7 @@ internal static class ProcessPackage
validity = mac.SequenceEqual(package1.Pk11Mac) ? " (Valid)" : " (Invalid)"; validity = mac.SequenceEqual(package1.Pk11Mac) ? " (Valid)" : " (Invalid)";
} }
PrintItem(sb, colLen, $" PK11 MAC:{validity}", package1.Pk11Mac.ItemsRo.ToArray()); PrintItem(sb, colLen, $" PK11 MAC:{validity}", package1.Pk11Mac[..].ToArray());
} }
if (package1.IsDecrypted) if (package1.IsDecrypted)
@ -178,7 +178,7 @@ internal static class ProcessPackage
sb.AppendLine(); sb.AppendLine();
sb.AppendLine("PK21:"); sb.AppendLine("PK21:");
PrintItem(sb, colLen, $"Signature{signatureValidity.GetValidityString()}:", package2.Header.Signature.ItemsRo.ToArray()); PrintItem(sb, colLen, $"Signature{signatureValidity.GetValidityString()}:", package2.Header.Signature[..].ToArray());
PrintItem(sb, colLen, "Header Version:", $"{package2.Header.Meta.GetKeyGeneration():x2}"); PrintItem(sb, colLen, "Header Version:", $"{package2.Header.Meta.GetKeyGeneration():x2}");
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
@ -186,8 +186,8 @@ internal static class ProcessPackage
string name = package2.Header.Meta.PayloadSizes[i] != 0 ? Package2SectionNames[i] : "Empty"; string name = package2.Header.Meta.PayloadSizes[i] != 0 ? Package2SectionNames[i] : "Empty";
sb.AppendLine($"Section {i} ({name}):"); sb.AppendLine($"Section {i} ({name}):");
PrintItem(sb, colLen, " Hash:", package2.Header.Meta.PayloadHashes[i].ItemsRo.ToArray()); PrintItem(sb, colLen, " Hash:", package2.Header.Meta.PayloadHashes[i][..].ToArray());
PrintItem(sb, colLen, " CTR:", package2.Header.Meta.PayloadIvs[i].ItemsRo.ToArray()); PrintItem(sb, colLen, " CTR:", package2.Header.Meta.PayloadIvs[i][..].ToArray());
PrintItem(sb, colLen, " Load Address:", $"{package2.Header.Meta.PayloadOffsets[i] + 0x80000000:x8}"); PrintItem(sb, colLen, " Load Address:", $"{package2.Header.Meta.PayloadOffsets[i] + 0x80000000:x8}");
PrintItem(sb, colLen, " Size:", $"{package2.Header.Meta.PayloadSizes[i]:x8}"); PrintItem(sb, colLen, " Size:", $"{package2.Header.Meta.PayloadSizes[i]:x8}");
} }

16
tests/LibHac.Tests/Common/FixedArraySizeTests.cs
View file

@ -6,35 +6,35 @@ namespace LibHac.Tests.Common;
public class FixedArraySizeTests public class FixedArraySizeTests
{ {
[Fact] public static void Array1SpanSizeIsCorrect() => Assert.Equal(1, new Array1<byte>().Items.Length); [Fact] public static void Array1SpanSizeIsCorrect() => Assert.Equal(1, new Array1<byte>().Length);
[Fact] public static void Array1ByteSizeIsCorrect() => Assert.Equal(sizeof(byte) * 1, Unsafe.SizeOf<Array1<byte>>()); [Fact] public static void Array1ByteSizeIsCorrect() => Assert.Equal(sizeof(byte) * 1, Unsafe.SizeOf<Array1<byte>>());
[Fact] public static void Array1LongSizeIsCorrect() => Assert.Equal(sizeof(long) * 1, Unsafe.SizeOf<Array1<long>>()); [Fact] public static void Array1LongSizeIsCorrect() => Assert.Equal(sizeof(long) * 1, Unsafe.SizeOf<Array1<long>>());
[Fact] public static void Array3SpanSizeIsCorrect() => Assert.Equal(3, new Array3<byte>().Items.Length); [Fact] public static void Array3SpanSizeIsCorrect() => Assert.Equal(3, new Array3<byte>().Length);
[Fact] public static void Array3ByteSizeIsCorrect() => Assert.Equal(sizeof(byte) * 3, Unsafe.SizeOf<Array3<byte>>()); [Fact] public static void Array3ByteSizeIsCorrect() => Assert.Equal(sizeof(byte) * 3, Unsafe.SizeOf<Array3<byte>>());
[Fact] public static void Array3LongSizeIsCorrect() => Assert.Equal(sizeof(long) * 3, Unsafe.SizeOf<Array3<long>>()); [Fact] public static void Array3LongSizeIsCorrect() => Assert.Equal(sizeof(long) * 3, Unsafe.SizeOf<Array3<long>>());
[Fact] public static void Array8SpanSizeIsCorrect() => Assert.Equal(8, new Array8<byte>().Items.Length); [Fact] public static void Array8SpanSizeIsCorrect() => Assert.Equal(8, new Array8<byte>().Length);
[Fact] public static void Array8ByteSizeIsCorrect() => Assert.Equal(sizeof(byte) * 8, Unsafe.SizeOf<Array8<byte>>()); [Fact] public static void Array8ByteSizeIsCorrect() => Assert.Equal(sizeof(byte) * 8, Unsafe.SizeOf<Array8<byte>>());
[Fact] public static void Array8LongSizeIsCorrect() => Assert.Equal(sizeof(long) * 8, Unsafe.SizeOf<Array8<long>>()); [Fact] public static void Array8LongSizeIsCorrect() => Assert.Equal(sizeof(long) * 8, Unsafe.SizeOf<Array8<long>>());
[Fact] public static void Array12SpanSizeIsCorrect() => Assert.Equal(12, new Array12<byte>().Items.Length); [Fact] public static void Array12SpanSizeIsCorrect() => Assert.Equal(12, new Array12<byte>().Length);
[Fact] public static void Array12ByteSizeIsCorrect() => Assert.Equal(sizeof(byte) * 12, Unsafe.SizeOf<Array12<byte>>()); [Fact] public static void Array12ByteSizeIsCorrect() => Assert.Equal(sizeof(byte) * 12, Unsafe.SizeOf<Array12<byte>>());
[Fact] public static void Array12LongSizeIsCorrect() => Assert.Equal(sizeof(long) * 12, Unsafe.SizeOf<Array12<long>>()); [Fact] public static void Array12LongSizeIsCorrect() => Assert.Equal(sizeof(long) * 12, Unsafe.SizeOf<Array12<long>>());
[Fact] public static void Array32SpanSizeIsCorrect() => Assert.Equal(32, new Array32<byte>().Items.Length); [Fact] public static void Array32SpanSizeIsCorrect() => Assert.Equal(32, new Array32<byte>().Length);
[Fact] public static void Array32ByteSizeIsCorrect() => Assert.Equal(sizeof(byte) * 32, Unsafe.SizeOf<Array32<byte>>()); [Fact] public static void Array32ByteSizeIsCorrect() => Assert.Equal(sizeof(byte) * 32, Unsafe.SizeOf<Array32<byte>>());
[Fact] public static void Array32LongSizeIsCorrect() => Assert.Equal(sizeof(long) * 32, Unsafe.SizeOf<Array32<long>>()); [Fact] public static void Array32LongSizeIsCorrect() => Assert.Equal(sizeof(long) * 32, Unsafe.SizeOf<Array32<long>>());
[Fact] public static void Array64SpanSizeIsCorrect() => Assert.Equal(64, new Array64<byte>().Items.Length); [Fact] public static void Array64SpanSizeIsCorrect() => Assert.Equal(64, new Array64<byte>().Length);
[Fact] public static void Array64ByteSizeIsCorrect() => Assert.Equal(sizeof(byte) * 64, Unsafe.SizeOf<Array64<byte>>()); [Fact] public static void Array64ByteSizeIsCorrect() => Assert.Equal(sizeof(byte) * 64, Unsafe.SizeOf<Array64<byte>>());
[Fact] public static void Array64LongSizeIsCorrect() => Assert.Equal(sizeof(long) * 64, Unsafe.SizeOf<Array64<long>>()); [Fact] public static void Array64LongSizeIsCorrect() => Assert.Equal(sizeof(long) * 64, Unsafe.SizeOf<Array64<long>>());
[Fact] public static void Array128SpanSizeIsCorrect() => Assert.Equal(128, new Array128<byte>().Items.Length); [Fact] public static void Array128SpanSizeIsCorrect() => Assert.Equal(128, new Array128<byte>().Length);
[Fact] public static void Array128ByteSizeIsCorrect() => Assert.Equal(sizeof(byte) * 128, Unsafe.SizeOf<Array128<byte>>()); [Fact] public static void Array128ByteSizeIsCorrect() => Assert.Equal(sizeof(byte) * 128, Unsafe.SizeOf<Array128<byte>>());
[Fact] public static void Array128LongSizeIsCorrect() => Assert.Equal(sizeof(long) * 128, Unsafe.SizeOf<Array128<long>>()); [Fact] public static void Array128LongSizeIsCorrect() => Assert.Equal(sizeof(long) * 128, Unsafe.SizeOf<Array128<long>>());
[Fact] public static void Array256SpanSizeIsCorrect() => Assert.Equal(256, new Array256<byte>().Items.Length); [Fact] public static void Array256SpanSizeIsCorrect() => Assert.Equal(256, new Array256<byte>().Length);
[Fact] public static void Array256ByteSizeIsCorrect() => Assert.Equal(sizeof(byte) * 256, Unsafe.SizeOf<Array256<byte>>()); [Fact] public static void Array256ByteSizeIsCorrect() => Assert.Equal(sizeof(byte) * 256, Unsafe.SizeOf<Array256<byte>>());
[Fact] public static void Array256LongSizeIsCorrect() => Assert.Equal(sizeof(long) * 256, Unsafe.SizeOf<Array256<long>>()); [Fact] public static void Array256LongSizeIsCorrect() => Assert.Equal(sizeof(long) * 256, Unsafe.SizeOf<Array256<long>>());
} }

34
tests/LibHac.Tests/FsSystem/TypeLayoutTests.cs
View file

@ -232,12 +232,12 @@ public class TypeLayoutTests
Assert.Equal(NcaHeader.Size, Unsafe.SizeOf<NcaHeader>()); Assert.Equal(NcaHeader.Size, Unsafe.SizeOf<NcaHeader>());
Assert.Equal(NcaHeader.SectorSize, 1 << NcaHeader.SectorShift); Assert.Equal(NcaHeader.SectorSize, 1 << NcaHeader.SectorShift);
Assert.Equal(NcaHeader.HeaderSignSize, s.Signature1.ItemsRo.Length); Assert.Equal(NcaHeader.HeaderSignSize, s.Signature1.Length);
Assert.Equal(NcaHeader.HeaderSignSize, s.Signature2.ItemsRo.Length); Assert.Equal(NcaHeader.HeaderSignSize, s.Signature2.Length);
Assert.Equal(NcaHeader.RightsIdSize, s.RightsId.ItemsRo.Length); Assert.Equal(NcaHeader.RightsIdSize, s.RightsId.Length);
Assert.Equal(NcaHeader.FsCountMax, s.FsInfos.ItemsRo.Length); Assert.Equal(NcaHeader.FsCountMax, s.FsInfos.Length);
Assert.Equal(NcaHeader.FsCountMax, s.FsHeaderHashes.ItemsRo.Length); Assert.Equal(NcaHeader.FsCountMax, s.FsHeaderHashes.Length);
Assert.Equal(NcaHeader.EncryptedKeyAreaSize, s.EncryptedKeys.ItemsRo.Length); Assert.Equal(NcaHeader.EncryptedKeyAreaSize, s.EncryptedKeys.Length);
} }
[Fact] [Fact]
@ -258,14 +258,14 @@ public class TypeLayoutTests
{ {
NcaCryptoConfiguration s = default; NcaCryptoConfiguration s = default;
Assert.Equal(NcaCryptoConfiguration.Header1SignatureKeyGenerationMax + 1, s.Header1SignKeyModuli.ItemsRo.Length); Assert.Equal(NcaCryptoConfiguration.Header1SignatureKeyGenerationMax + 1, s.Header1SignKeyModuli.Length);
Assert.Equal(NcaCryptoConfiguration.Rsa2048KeyModulusSize, s.Header1SignKeyModuli.ItemsRo[0].ItemsRo.Length); Assert.Equal(NcaCryptoConfiguration.Rsa2048KeyModulusSize, s.Header1SignKeyModuli[0].Length);
Assert.Equal(NcaCryptoConfiguration.Rsa2048KeyPublicExponentSize, s.Header1SignKeyPublicExponent.ItemsRo.Length); Assert.Equal(NcaCryptoConfiguration.Rsa2048KeyPublicExponentSize, s.Header1SignKeyPublicExponent.Length);
Assert.Equal(NcaCryptoConfiguration.KeyAreaEncryptionKeyIndexCount, s.KeyAreaEncryptionKeySources.ItemsRo.Length); Assert.Equal(NcaCryptoConfiguration.KeyAreaEncryptionKeyIndexCount, s.KeyAreaEncryptionKeySources.Length);
Assert.Equal(NcaCryptoConfiguration.Aes128KeySize, s.KeyAreaEncryptionKeySources.ItemsRo[0].ItemsRo.Length); Assert.Equal(NcaCryptoConfiguration.Aes128KeySize, s.KeyAreaEncryptionKeySources[0].Length);
Assert.Equal(NcaCryptoConfiguration.Aes128KeySize, s.HeaderEncryptionKeySource.ItemsRo.Length); Assert.Equal(NcaCryptoConfiguration.Aes128KeySize, s.HeaderEncryptionKeySource.Length);
Assert.Equal(NcaCryptoConfiguration.HeaderEncryptionKeyCount, s.HeaderEncryptedEncryptionKeys.ItemsRo.Length); Assert.Equal(NcaCryptoConfiguration.HeaderEncryptionKeyCount, s.HeaderEncryptedEncryptionKeys.Length);
Assert.Equal(NcaCryptoConfiguration.Aes128KeySize, s.HeaderEncryptedEncryptionKeys.ItemsRo[0].ItemsRo.Length); Assert.Equal(NcaCryptoConfiguration.Aes128KeySize, s.HeaderEncryptedEncryptionKeys[0].Length);
} }
[Fact] [Fact]
@ -306,7 +306,7 @@ public class TypeLayoutTests
Assert.Equal(0x04, GetOffset(in s, in s.Layers)); Assert.Equal(0x04, GetOffset(in s, in s.Layers));
Assert.Equal(0x94, GetOffset(in s, in s.HashSalt)); Assert.Equal(0x94, GetOffset(in s, in s.HashSalt));
Assert.Equal(Constants.IntegrityMaxLayerCount - 1, s.Layers.ItemsRo.Length); Assert.Equal(Constants.IntegrityMaxLayerCount - 1, s.Layers.Length);
} }
[Fact] [Fact]
@ -327,7 +327,7 @@ public class TypeLayoutTests
{ {
HierarchicalIntegrityVerificationSizeSet s = default; HierarchicalIntegrityVerificationSizeSet s = default;
Assert.Equal(Constants.IntegrityMaxLayerCount - 2, s.LayeredHashSizes.ItemsRo.Length); Assert.Equal(Constants.IntegrityMaxLayerCount - 2, s.LayeredHashSizes.Length);
} }
[Fact] [Fact]
@ -335,7 +335,7 @@ public class TypeLayoutTests
{ {
HierarchicalIntegrityVerificationStorageControlArea.InputParam s = default; HierarchicalIntegrityVerificationStorageControlArea.InputParam s = default;
Assert.Equal(Constants.IntegrityMaxLayerCount - 1, s.LevelBlockSizes.ItemsRo.Length); Assert.Equal(Constants.IntegrityMaxLayerCount - 1, s.LevelBlockSizes[..].Length);
} }
[Fact] [Fact]