From f5b32f84ea6af403ac85057d33b5553dcd80ebed Mon Sep 17 00:00:00 2001 From: James Courtney Date: Wed, 25 Jan 2023 11:39:58 -0800 Subject: [PATCH 01/66] Add C# 8 Build Step (#362) Validate C#8 compatibility --- .github/workflows/charp8build.yml | 55 +++++++++++++++++++ .../SchemaModel/RpcServiceSchemaModel.cs | 11 +++- src/Tests/CompileTests/CSharp8/CSharp8.csproj | 24 ++++++++ 3 files changed, 87 insertions(+), 3 deletions(-) create mode 100644 .github/workflows/charp8build.yml create mode 100644 src/Tests/CompileTests/CSharp8/CSharp8.csproj diff --git a/.github/workflows/charp8build.yml b/.github/workflows/charp8build.yml new file mode 100644 index 00000000..35073a1f --- /dev/null +++ b/.github/workflows/charp8build.yml @@ -0,0 +1,55 @@ +name: C# 8 Build Verification + +on: + push: + branches: [ main ] + pull_request: + branches: [ main ] + workflow_dispatch: + +jobs: + build: + runs-on: windows-2019 + env: + AppVeyorBuild: true + steps: + - uses: actions/checkout@v2 + + - name: Setup .NET 7 + uses: actions/setup-dotnet@v1 + with: + dotnet-version: 7.0.x + + - name: Setup .NET 6 + uses: actions/setup-dotnet@v1 + with: + dotnet-version: 6.0.x + + - name: Restore dependencies + working-directory: src + run: dotnet restore + + - name: Build FlatSharp.Compiler + working-directory: src/FlatSharp.Compiler + run: dotnet build -c Release + + - name: Run FlatSharp.Compiler + # You may pin to the exact commit or the version. + # uses: Amadevus/pwsh-script@97a8b211a5922816aa8a69ced41fa32f23477186 + uses: Amadevus/pwsh-script@v2.0.3 + with: + # PowerShell script to execute in Actions-hydrated context + script: | + $fbs = (gci -r src/tests/FlatsharpEndToEndTests/*.fbs | where Name -ne "AccessModifiers.fbs") -join ";" + dotnet src/FlatSharp.Compiler/bin/Release/net7.0/FlatSharp.Compiler.dll --nullable-warnings false --normalize-field-names true --input "$fbs" -o src/tests/CompileTests/CSharp8 + + - name: Build + working-directory: src/tests/CompileTests/CSharp8 + run: dotnet build -c Release + + - name: Upload Files + uses: actions/upload-artifact@v3 + if: failure() + with: + name: generated-csharp + path: src/tests/CompileTests/CSharp8/**/*.* diff --git a/src/FlatSharp.Compiler/SchemaModel/RpcServiceSchemaModel.cs b/src/FlatSharp.Compiler/SchemaModel/RpcServiceSchemaModel.cs index 8f8e6068..917b2232 100644 --- a/src/FlatSharp.Compiler/SchemaModel/RpcServiceSchemaModel.cs +++ b/src/FlatSharp.Compiler/SchemaModel/RpcServiceSchemaModel.cs @@ -217,7 +217,7 @@ private void DefineServerBaseClass(CodeWriter writer, Dictionary { foreach (var method in this.calls) { - writer.AppendLine($".AddMethod({methodNameMap[method.Name]}, serviceImpl == null ? null : serviceImpl.{method.Name})"); + writer.AppendLine($".AddMethod({methodNameMap[method.Name]}, serviceImpl == null ? ({this.GetServerHandlerDelegateType(method)}?)null : serviceImpl.{method.Name})"); } writer.AppendLine(".Build();"); @@ -234,7 +234,7 @@ private void DefineServerBaseClass(CodeWriter writer, Dictionary foreach (var method in this.calls) { string serverDelegate = GetServerHandlerDelegate(method); - writer.AppendLine($"serviceBinder.AddMethod({methodNameMap[method.Name]}, serviceImpl == null ? null : {serverDelegate});"); + writer.AppendLine($"serviceBinder.AddMethod({methodNameMap[method.Name]}, serviceImpl == null ? ({this.GetServerHandlerDelegateType(method)}?)null : {serverDelegate});"); } writer.AppendLine("#pragma warning restore CS8604"); } @@ -568,8 +568,13 @@ private void WriteNoRequestParameterMethod( } private string GetServerHandlerDelegate(RpcCallSchemaModel call) + { + return $"new {this.GetServerHandlerDelegateType(call)}(serviceImpl.{call.Name})"; + } + + private string GetServerHandlerDelegateType(RpcCallSchemaModel call) { string methodType = GetGrpcMethodType(call.StreamingType); - return $"new {GrpcCore}.{methodType}ServerMethod<{call.RequestType}, {call.ResponseType}>(serviceImpl.{call.Name})"; + return $"{GrpcCore}.{methodType}ServerMethod<{call.RequestType}, {call.ResponseType}>"; } } diff --git a/src/Tests/CompileTests/CSharp8/CSharp8.csproj b/src/Tests/CompileTests/CSharp8/CSharp8.csproj new file mode 100644 index 00000000..34587b25 --- /dev/null +++ b/src/Tests/CompileTests/CSharp8/CSharp8.csproj @@ -0,0 +1,24 @@ + + + net472;netstandard2.0;netstandard2.1 + false + CSharp8CompileTest + CSharp8CompileTest + true + annotations + CS1591 + 8.0 + + + + + + + + + + + + + + From 0d17ad4dbf951d183d415fa282ab45ebd03a67cd Mon Sep 17 00:00:00 2001 From: James Courtney Date: Fri, 27 Jan 2023 20:38:25 -0800 Subject: [PATCH 02/66] Create stryker.yml (#311) Add mutation testing --- .github/workflows/codecov.yml | 17 + .github/workflows/stryker.yml | 56 ++ .gitignore | 1 + README.md | 2 +- src/FlatSharp.Compiler/CompilerOptions.cs | 4 + src/FlatSharp.Compiler/FlatSharpCompiler.cs | 15 +- .../BaseReferenceTypeSchemaModel.cs | 6 + .../SchemaModel/RootModel.cs | 23 +- .../StructVectorPropertyFieldModel.cs | 2 +- .../SchemaModel/TableSchemaModel.cs | 6 +- .../Attributes/FlatBufferTableAttribute.cs | 5 + .../Properties/AssemblyInfo.cs | 2 + src/FlatSharp.Runtime/stryker-config.json | 11 + src/FlatSharp.sln | 2 +- src/FlatSharp/FlatBufferSerializerOptions.cs | 3 - src/FlatSharp/FlatBufferVectorHelpers.cs | 4 +- .../DeserializeClassDefinition.cs | 7 +- .../RoslynSerializerGenerator.cs | 29 +- src/FlatSharp/TypeModel/StructMemberModel.cs | 14 +- src/FlatSharp/TypeModel/TableMemberModel.cs | 20 +- src/FlatSharp/TypeModel/TableTypeModel.cs | 5 + src/FlatSharp/TypeModel/UnionTypeModel.cs | 2 - .../FlatSharpCompilerTests/IncludeTests.cs | 12 - .../FlatSharpCompilerTests/StructTests.cs | 17 - src/Tests/FlatSharpEndToEndTests/Helpers.cs | 314 ++++++++++- src/Tests/Stryker/CodeGen/CodeGen.csproj | 17 + src/Tests/Stryker/CodeGen/FieldsPartial.cs | 19 + src/Tests/Stryker/CodeGen/FlatSharp.cs | 0 src/Tests/Stryker/CodeGen/KeyPartial.cs | 19 + src/Tests/Stryker/CodeGen/MockBitConverter.cs | 20 + src/Tests/Stryker/CodeGen/RefStructPartial.cs | 26 + src/Tests/Stryker/CodeGen/RootPartial.cs | 19 + src/Tests/Stryker/CodeGen/Schema.fbs | 111 ++++ src/Tests/Stryker/CodeGen/VectorPartial.cs | 19 + src/Tests/Stryker/Tests/FullTreeTests.cs | 206 +++++++ src/Tests/Stryker/Tests/GlobalUsings.cs | 32 ++ src/Tests/Stryker/Tests/IndexedVectorTests.cs | 282 ++++++++++ src/Tests/Stryker/Tests/MemoryVectorTests.cs | 77 +++ .../Stryker/Tests/PrimitivesFieldsTests.cs | 166 ++++++ .../Stryker/Tests/RefStructVectorTests.cs | 133 +++++ src/Tests/Stryker/Tests/StringVectorTests.cs | 83 +++ src/Tests/Stryker/Tests/StructFieldTests.cs | 242 ++++++++ src/Tests/Stryker/Tests/StrykerTests.csproj | 32 ++ src/Tests/Stryker/Tests/UnionFieldTests.cs | 517 ++++++++++++++++++ src/Tests/Stryker/Tests/UnionVectorTests.cs | 336 ++++++++++++ .../Stryker/Tests/ValueStructVectorTests.cs | 118 ++++ src/Tests/Stryker/Tests/stryker-config.json | 13 + 47 files changed, 2983 insertions(+), 83 deletions(-) create mode 100644 .github/workflows/stryker.yml create mode 100644 src/FlatSharp.Runtime/stryker-config.json create mode 100644 src/Tests/Stryker/CodeGen/CodeGen.csproj create mode 100644 src/Tests/Stryker/CodeGen/FieldsPartial.cs create mode 100644 src/Tests/Stryker/CodeGen/FlatSharp.cs create mode 100644 src/Tests/Stryker/CodeGen/KeyPartial.cs create mode 100644 src/Tests/Stryker/CodeGen/MockBitConverter.cs create mode 100644 src/Tests/Stryker/CodeGen/RefStructPartial.cs create mode 100644 src/Tests/Stryker/CodeGen/RootPartial.cs create mode 100644 src/Tests/Stryker/CodeGen/Schema.fbs create mode 100644 src/Tests/Stryker/CodeGen/VectorPartial.cs create mode 100644 src/Tests/Stryker/Tests/FullTreeTests.cs create mode 100644 src/Tests/Stryker/Tests/GlobalUsings.cs create mode 100644 src/Tests/Stryker/Tests/IndexedVectorTests.cs create mode 100644 src/Tests/Stryker/Tests/MemoryVectorTests.cs create mode 100644 src/Tests/Stryker/Tests/PrimitivesFieldsTests.cs create mode 100644 src/Tests/Stryker/Tests/RefStructVectorTests.cs create mode 100644 src/Tests/Stryker/Tests/StringVectorTests.cs create mode 100644 src/Tests/Stryker/Tests/StructFieldTests.cs create mode 100644 src/Tests/Stryker/Tests/StrykerTests.csproj create mode 100644 src/Tests/Stryker/Tests/UnionFieldTests.cs create mode 100644 src/Tests/Stryker/Tests/UnionVectorTests.cs create mode 100644 src/Tests/Stryker/Tests/ValueStructVectorTests.cs create mode 100644 src/Tests/Stryker/Tests/stryker-config.json diff --git a/.github/workflows/codecov.yml b/.github/workflows/codecov.yml index dddd331b..e8028d18 100644 --- a/.github/workflows/codecov.yml +++ b/.github/workflows/codecov.yml @@ -78,6 +78,23 @@ jobs: --output pooling.coverage.xml ` --targetargs "src\FlatSharp.Compiler\bin\Debug\net7.0\FlatSharp.Compiler.dll --nullable-warnings false --normalize-field-names true --gen-poolable true --input `"$fbs`" -o src/tests/FlatSharpPoolableEndToEndTests" + - name: Run FlatSharp.Compiler (Stryker Tests) + # You may pin to the exact commit or the version. + # uses: Amadevus/pwsh-script@97a8b211a5922816aa8a69ced41fa32f23477186 + uses: Amadevus/pwsh-script@v2.0.3 + with: + # PowerShell script to execute in Actions-hydrated context + script: | + $fbs = (gci -r src/tests/Stryker/*.fbs) -join ";" + coverlet ` + .\src\FlatSharp.Compiler\bin\Debug\net7.0 ` + --skipautoprops ` + --use-source-link ` + --format opencover ` + --target "dotnet" ` + --output stryker.coverage.xml ` + --targetargs "src/FlatSharp.Compiler/bin/Debug/net7.0/FlatSharp.Compiler.dll --nullable-warnings false --normalize-field-names true --input `"$fbs`" -o src/tests/Stryker/CodeGen --mutation-testing-mode" + - name: Test working-directory: src run: dotnet test -c Debug -p:SignAssembly=false --collect:"XPlat Code Coverage" --settings Tests/coverlet.runsettings -f net7.0 diff --git a/.github/workflows/stryker.yml b/.github/workflows/stryker.yml new file mode 100644 index 00000000..ff68262e --- /dev/null +++ b/.github/workflows/stryker.yml @@ -0,0 +1,56 @@ +name: Mutation Testing + +on: + push: + branches: [ main ] + pull_request: + branches: [ main ] + workflow_dispatch: + +jobs: + build: + runs-on: windows-2019 + env: + AppVeyorBuild: true + steps: + - uses: actions/checkout@v2 + + - name: Setup .NET 7 + uses: actions/setup-dotnet@v1 + with: + dotnet-version: 7.0.x + + - name: Install Stryker + run: dotnet tool install -g dotnet-stryker + + - name: Build FlatSharp.Compiler + working-directory: src/FlatSharp.Compiler + run: dotnet build -c Release + + - name: Run FlatSharp.Compiler (Mutation Tests) + # You may pin to the exact commit or the version. + # uses: Amadevus/pwsh-script@97a8b211a5922816aa8a69ced41fa32f23477186 + uses: Amadevus/pwsh-script@v2.0.3 + with: + # PowerShell script to execute in Actions-hydrated context + script: | + $fbs = (gci -r src/tests/Stryker/*.fbs) -join ";" + dotnet src/FlatSharp.Compiler/bin/Release/net7.0/FlatSharp.Compiler.dll --nullable-warnings false --normalize-field-names true --input "$fbs" -o src/tests/Stryker/CodeGen --mutation-testing-mode + + - name: Build + working-directory: src/Tests/Stryker/Tests + run: dotnet build -c Release + + - name: Test + working-directory: src/Tests/Stryker/Tests + run: dotnet test -c Release + + - name: Mutate + working-directory: src/Tests/Stryker/Tests + run: dotnet-stryker + + - name: Upload Results + uses: actions/upload-artifact@v2 + with: + name: Stryker Results + path: ./**/StrykerOutput/**/*.* diff --git a/.gitignore b/.gitignore index f03fe2b0..caad5ae2 100644 --- a/.gitignore +++ b/.gitignore @@ -17,3 +17,4 @@ /src/Tests/FlatSharpEndToEndTests/FlatSharpEndToEndTests.xml /src/Tests/FlatSharpEndToEndTests/FlatSharp.generated.cs /src/Benchmarks/ExperimentalBenchmark/FlatSharp.generated.cs +/src/Tests/FlatSharpEndToEndTests_Generated/FlatSharpEndToEndTestsGenerated.xml diff --git a/README.md b/README.md index 89891cbb..624eb80e 100644 --- a/README.md +++ b/README.md @@ -14,7 +14,7 @@ All FlatSharp packages are published on nuget.org: - **FlatSharp.Runtime**: The runtime library. You always need this. - **FlatSharp.Compiler**: Build time compiler for generating C# from an FBS schema. -FlatSharp is a mature library and has been shipped to production at Microsoft, Unity3D, and others. Full status can be found at [ProjectStatus.md](ProjectStatus.md). +FlatSharp is a mature library and has been shipped to production at Microsoft, Unity3D, and others. Full status can be found at [ProjectStatus.md](ProjectStatus.md). FlatSharp is [extensively tested](https://github.com/jamescourtney/FlatSharp/wiki/Testing), using Mutation Testing, Code Coverage, Oracle Testing, and other techniques to ensure the library doesn't regress. ### Getting Started If you're completely new to FlatBuffers, take a minute to look over [the FlatBuffer overview](https://google.github.io/flatbuffers/index.html#flatbuffers_overview). Additionally, it's worth the time to understand the different elements of [FlatBuffer schemas](https://google.github.io/flatbuffers/flatbuffers_guide_writing_schema.html). diff --git a/src/FlatSharp.Compiler/CompilerOptions.cs b/src/FlatSharp.Compiler/CompilerOptions.cs index 819feb47..62609437 100644 --- a/src/FlatSharp.Compiler/CompilerOptions.cs +++ b/src/FlatSharp.Compiler/CompilerOptions.cs @@ -49,4 +49,8 @@ public record CompilerOptions [Option("instrument", Hidden = true, Default = false)] public bool Instrument { get; set; } + + // Suppress auto generated markers for mutation testing. + [Option("mutation-testing-mode", Hidden = true, Default = false)] + public bool MutationTestingMode { get; set; } } diff --git a/src/FlatSharp.Compiler/FlatSharpCompiler.cs b/src/FlatSharp.Compiler/FlatSharpCompiler.cs index 8a1d6564..11929d08 100644 --- a/src/FlatSharp.Compiler/FlatSharpCompiler.cs +++ b/src/FlatSharp.Compiler/FlatSharpCompiler.cs @@ -32,6 +32,8 @@ public class FlatSharpCompiler { public const string FailureMessage = "// !! FLATSHARP CODE GENERATION FAILED. THIS FILE MAY CONTAIN INCOMPLETE OR INACCURATE DATA !!"; + internal static CompilerOptions? CommandLineOptions { get; private set; } + private static string AssemblyVersion => typeof(ISchemaMutator).Assembly.GetCustomAttribute()?.Version ?? "unknown"; [ExcludeFromCodeCoverage] @@ -44,6 +46,7 @@ static int Main(string[] args) CommandLine.Parser.Default.ParseArguments(args) .WithParsed(x => { + CommandLineOptions = x; exitCode = RunCompiler(x); }); } @@ -83,7 +86,12 @@ private static int RunCompiler(CompilerOptions options) } // Read existing file to see if we even need to do any work. - const string outputFileName = "FlatSharp.generated.cs"; + string outputFileName = options.MutationTestingMode switch + { + true => "FlatSharp.cs", + false => "FlatSharp.generated.cs", + }; + string outputFullPath = Path.Combine(options.OutputDirectory, outputFileName); try @@ -107,6 +115,11 @@ private static int RunCompiler(CompilerOptions options) try { cSharp = CreateCSharp(bfbs, inputHash, options); + + if (options.MutationTestingMode) + { + cSharp = cSharp.Replace("BitConverter", "MockBitConverter"); + } } catch (Exception ex) { diff --git a/src/FlatSharp.Compiler/SchemaModel/BaseReferenceTypeSchemaModel.cs b/src/FlatSharp.Compiler/SchemaModel/BaseReferenceTypeSchemaModel.cs index 9db916f6..a9b642b2 100644 --- a/src/FlatSharp.Compiler/SchemaModel/BaseReferenceTypeSchemaModel.cs +++ b/src/FlatSharp.Compiler/SchemaModel/BaseReferenceTypeSchemaModel.cs @@ -145,6 +145,12 @@ private void EmitDefaultConstrutor(CodeWriter writer, CompileContext context) } writer.AppendLine("#pragma warning disable CS8618"); // nullable + + if (context.Options.MutationTestingMode) + { + writer.AppendLine($"[{typeof(ExcludeFromCodeCoverageAttribute).GetCompilableTypeName()}]"); + } + writer.AppendLine($"public {this.Name}()"); using (writer.WithBlock()) { diff --git a/src/FlatSharp.Compiler/SchemaModel/RootModel.cs b/src/FlatSharp.Compiler/SchemaModel/RootModel.cs index 77c6e8c4..a4723153 100644 --- a/src/FlatSharp.Compiler/SchemaModel/RootModel.cs +++ b/src/FlatSharp.Compiler/SchemaModel/RootModel.cs @@ -66,16 +66,19 @@ public void AddElement(BaseSchemaModel model) internal void WriteCode(CodeWriter writer, CompileContext context) { - writer.AppendLine($@" -//------------------------------------------------------------------------------ -// -// This code was generated by the FlatSharp FBS to C# compiler (source hash: {context.InputHash}) -// -// Changes to this file may cause incorrect behavior and will be lost if -// the code is regenerated. -// -//------------------------------------------------------------------------------ -"); + if (!context.Options.MutationTestingMode) + { + writer.AppendLine($$""" + //------------------------------------------------------------------------------ + // + // This code was generated by the FlatSharp FBS to C# compiler (source hash: {{context.InputHash}}) + // + // Changes to this file may cause incorrect behavior and will be lost if + // the code is regenerated. + // + //------------------------------------------------------------------------------ + """); + } writer.AppendLine("using System;"); writer.AppendLine("using System.Collections.Generic;"); diff --git a/src/FlatSharp.Compiler/SchemaModel/StructVectorPropertyFieldModel.cs b/src/FlatSharp.Compiler/SchemaModel/StructVectorPropertyFieldModel.cs index 7a1e330e..996bbaac 100644 --- a/src/FlatSharp.Compiler/SchemaModel/StructVectorPropertyFieldModel.cs +++ b/src/FlatSharp.Compiler/SchemaModel/StructVectorPropertyFieldModel.cs @@ -55,7 +55,7 @@ public StructVectorPropertyFieldModel( $"{field.Name}[{i}]", modifiedAttributes) { - ProtectedGetter = true, + ProtectedGetter = FlatSharpCompiler.CommandLineOptions?.MutationTestingMode != true, }; propertyModels.Add(model); diff --git a/src/FlatSharp.Compiler/SchemaModel/TableSchemaModel.cs b/src/FlatSharp.Compiler/SchemaModel/TableSchemaModel.cs index b5dcbdac..564488aa 100644 --- a/src/FlatSharp.Compiler/SchemaModel/TableSchemaModel.cs +++ b/src/FlatSharp.Compiler/SchemaModel/TableSchemaModel.cs @@ -86,10 +86,12 @@ protected override void EmitClassDefinition(CodeWriter writer, CompileContext co string fileId = string.Empty; if (this.Schema.RootTable?.Name == this.FullName && !string.IsNullOrEmpty(this.Schema.FileIdentifier)) { - fileId = $"{nameof(FlatBufferTableAttribute.FileIdentifier)} = \"{this.Schema.FileIdentifier}\""; + fileId = $", {nameof(FlatBufferTableAttribute.FileIdentifier)} = \"{this.Schema.FileIdentifier}\""; } - string attribute = $"[FlatBufferTable({fileId})]"; + string emitSerializer = $"{nameof(FlatBufferTableAttribute.BuildSerializer)} = {(this.Attributes.DeserializationOption is not null ? "true" : "false")}"; + + string attribute = $"[FlatBufferTable({emitSerializer}{fileId})]"; writer.AppendSummaryComment(this.Documentation); writer.AppendLine(attribute); diff --git a/src/FlatSharp.Runtime/Attributes/FlatBufferTableAttribute.cs b/src/FlatSharp.Runtime/Attributes/FlatBufferTableAttribute.cs index f5663935..be8006af 100644 --- a/src/FlatSharp.Runtime/Attributes/FlatBufferTableAttribute.cs +++ b/src/FlatSharp.Runtime/Attributes/FlatBufferTableAttribute.cs @@ -26,4 +26,9 @@ public class FlatBufferTableAttribute : Attribute /// Specifies the file identifier for serialized tables. Must be precisely 4 ASCII characters. /// public string? FileIdentifier { get; set; } + + /// + /// Indicates that a serializer should be built for the given table. + /// + public bool BuildSerializer { get; set; } = true; } diff --git a/src/FlatSharp.Runtime/Properties/AssemblyInfo.cs b/src/FlatSharp.Runtime/Properties/AssemblyInfo.cs index ee458b9b..0a7ba5ca 100644 --- a/src/FlatSharp.Runtime/Properties/AssemblyInfo.cs +++ b/src/FlatSharp.Runtime/Properties/AssemblyInfo.cs @@ -21,6 +21,7 @@ [assembly: InternalsVisibleTo("FlatSharp, PublicKey=0024000004800000940000000602000000240000525341310004000001000100898185ce69dca04430ab296e094cd7eb6c66f5a3cfb0631ef64586fa183f0cb5ca64c47539a3a3c6351a9cf8d976a8d94350af430d5adc10536b3904cc1d6ecaaf3d0cb708aa318c559625f05d3b2d89da1c2bb323bb40e36dcf9245f21c3a4b6793c56ffface5e6e18290afb13c7eac1ea9c7a0c22f289c622bfa7b247d81a2")] [assembly: InternalsVisibleTo("FlatSharpTests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100898185ce69dca04430ab296e094cd7eb6c66f5a3cfb0631ef64586fa183f0cb5ca64c47539a3a3c6351a9cf8d976a8d94350af430d5adc10536b3904cc1d6ecaaf3d0cb708aa318c559625f05d3b2d89da1c2bb323bb40e36dcf9245f21c3a4b6793c56ffface5e6e18290afb13c7eac1ea9c7a0c22f289c622bfa7b247d81a2")] [assembly: InternalsVisibleTo("FlatSharpEndToEndTests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100898185ce69dca04430ab296e094cd7eb6c66f5a3cfb0631ef64586fa183f0cb5ca64c47539a3a3c6351a9cf8d976a8d94350af430d5adc10536b3904cc1d6ecaaf3d0cb708aa318c559625f05d3b2d89da1c2bb323bb40e36dcf9245f21c3a4b6793c56ffface5e6e18290afb13c7eac1ea9c7a0c22f289c622bfa7b247d81a2")] +[assembly: InternalsVisibleTo("FlatSharpEndToEndTestsGenerated, PublicKey=0024000004800000940000000602000000240000525341310004000001000100898185ce69dca04430ab296e094cd7eb6c66f5a3cfb0631ef64586fa183f0cb5ca64c47539a3a3c6351a9cf8d976a8d94350af430d5adc10536b3904cc1d6ecaaf3d0cb708aa318c559625f05d3b2d89da1c2bb323bb40e36dcf9245f21c3a4b6793c56ffface5e6e18290afb13c7eac1ea9c7a0c22f289c622bfa7b247d81a2")] [assembly: InternalsVisibleTo("PoolingTests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100898185ce69dca04430ab296e094cd7eb6c66f5a3cfb0631ef64586fa183f0cb5ca64c47539a3a3c6351a9cf8d976a8d94350af430d5adc10536b3904cc1d6ecaaf3d0cb708aa318c559625f05d3b2d89da1c2bb323bb40e36dcf9245f21c3a4b6793c56ffface5e6e18290afb13c7eac1ea9c7a0c22f289c622bfa7b247d81a2")] [assembly: InternalsVisibleTo("FlatSharpCompilerTests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100898185ce69dca04430ab296e094cd7eb6c66f5a3cfb0631ef64586fa183f0cb5ca64c47539a3a3c6351a9cf8d976a8d94350af430d5adc10536b3904cc1d6ecaaf3d0cb708aa318c559625f05d3b2d89da1c2bb323bb40e36dcf9245f21c3a4b6793c56ffface5e6e18290afb13c7eac1ea9c7a0c22f289c622bfa7b247d81a2")] [assembly: InternalsVisibleTo("FlatSharp.Compiler, PublicKey=0024000004800000940000000602000000240000525341310004000001000100898185ce69dca04430ab296e094cd7eb6c66f5a3cfb0631ef64586fa183f0cb5ca64c47539a3a3c6351a9cf8d976a8d94350af430d5adc10536b3904cc1d6ecaaf3d0cb708aa318c559625f05d3b2d89da1c2bb323bb40e36dcf9245f21c3a4b6793c56ffface5e6e18290afb13c7eac1ea9c7a0c22f289c622bfa7b247d81a2")] @@ -33,6 +34,7 @@ [assembly: InternalsVisibleTo("FlatSharpTests")] [assembly: InternalsVisibleTo("FlatSharpCompilerTests")] [assembly: InternalsVisibleTo("FlatSharpEndToEndTests")] +[assembly: InternalsVisibleTo("FlatSharpEndToEndTestsGenerated")] [assembly: InternalsVisibleTo("PoolingTests")] [assembly: InternalsVisibleTo("FlatSharp.Compiler")] [assembly: InternalsVisibleTo("ExperimentalBenchmark")] diff --git a/src/FlatSharp.Runtime/stryker-config.json b/src/FlatSharp.Runtime/stryker-config.json new file mode 100644 index 00000000..89ec9684 --- /dev/null +++ b/src/FlatSharp.Runtime/stryker-config.json @@ -0,0 +1,11 @@ +{ + "stryker-config": + { + "project": "FlatSharp.Runtime.csproj", + "test-projects": [ + "../Tests/FlatSharpTests/FlatSharpTests.csproj", + "../Tests/FlatSharpCompilerTests/FlatSharpCompilerTests.csproj" + ], + "target-framework": "net6.0" + } +} \ No newline at end of file diff --git a/src/FlatSharp.sln b/src/FlatSharp.sln index b44ac9cf..d0f5af60 100644 --- a/src/FlatSharp.sln +++ b/src/FlatSharp.sln @@ -35,7 +35,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microbench.6.3.3", "Benchma EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "FlatSharpPoolableEndToEndTests", "Tests\FlatSharpPoolableEndToEndTests\FlatSharpPoolableEndToEndTests.csproj", "{7E55A248-4BBD-48AD-B27D-A7E0E705DC89}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FlatSharp.UnityPolyfills", "FlatSharp.UnityPolyfills\FlatSharp.UnityPolyfills.csproj", "{E439E4AF-B948-4E6C-8791-1830619EB35B}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "FlatSharp.UnityPolyfills", "FlatSharp.UnityPolyfills\FlatSharp.UnityPolyfills.csproj", "{E439E4AF-B948-4E6C-8791-1830619EB35B}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution diff --git a/src/FlatSharp/FlatBufferSerializerOptions.cs b/src/FlatSharp/FlatBufferSerializerOptions.cs index bccb577d..02da36a7 100644 --- a/src/FlatSharp/FlatBufferSerializerOptions.cs +++ b/src/FlatSharp/FlatBufferSerializerOptions.cs @@ -81,9 +81,6 @@ public FlatBufferSerializerOptions( /// /// Indicates if the object is immutable OR changes to the object are guaranteed to be written back to the buffer. /// - /// - /// VectorCacheMutable is not eligible here, since only some changes are written back. - /// public bool CanSerializeWithMemoryCopy => this.DeserializationOption == FlatBufferDeserializationOption.Lazy || this.DeserializationOption == FlatBufferDeserializationOption.Progressive; diff --git a/src/FlatSharp/FlatBufferVectorHelpers.cs b/src/FlatSharp/FlatBufferVectorHelpers.cs index 4fb5dda9..a46e347b 100644 --- a/src/FlatSharp/FlatBufferVectorHelpers.cs +++ b/src/FlatSharp/FlatBufferVectorHelpers.cs @@ -66,11 +66,11 @@ internal struct {className}<{context.InputBufferTypeName}> : IVectorItemAccessor [MethodImpl(MethodImplOptions.AggressiveInlining)] public {className}(int offset, TInputBuffer buffer) {{ - this.count = checked((int)buffer.ReadUInt(offset)); + this.count = (int)buffer.ReadUInt(offset); // Advance to the start of the element at index 0. Easiest to do this once // in the .ctor than repeatedly for each index. - this.offset = checked(offset + sizeof(uint)); + this.offset = offset + sizeof(uint); }} public int ItemSize => {inlineSize}; diff --git a/src/FlatSharp/Serialization/DeserializeClassDefinition.cs b/src/FlatSharp/Serialization/DeserializeClassDefinition.cs index 4c501d06..2bb74a76 100644 --- a/src/FlatSharp/Serialization/DeserializeClassDefinition.cs +++ b/src/FlatSharp/Serialization/DeserializeClassDefinition.cs @@ -284,6 +284,7 @@ public override string ToString() } string interfaceGlobalName = typeof(IFlatBufferDeserializedObject).GetGlobalCompilableTypeName(); + bool isProgressive = this.options.DeserializationOption == FlatBufferDeserializationOption.Progressive; return $@" @@ -292,7 +293,6 @@ private sealed class {this.ClassName} , {interfaceGlobalName} , {typeof(IPoolableObject).GetGlobalCompilableTypeName()} , {typeof(IPoolableObjectDebug).GetGlobalCompilableTypeName()} - where TInputBuffer : IInputBuffer {{ private static readonly {typeof(FlatBufferDeserializationContext).GetGlobalCompilableTypeName()} {CtorContextVariableName} @@ -329,7 +329,6 @@ private sealed class {this.ClassName} }} "; } - protected virtual string GetSetterBody(ItemMemberModel itemModel) { List setterLines = new List(); @@ -538,9 +537,7 @@ public override void ReturnToPool(bool unsafeForce = false) protected static string GetFieldName(ItemMemberModel itemModel) => $"__index{itemModel.Index}Value"; - protected static string GetHasValueFieldName(int index) => $"__mask{index}"; - - protected static string GetHasValueFieldName(ItemMemberModel itemModel) => GetHasValueFieldName(itemModel.Index / 8); + protected static string GetHasValueFieldName(ItemMemberModel itemModel) => $"__mask{itemModel.Index / 8}"; protected static string GetHasValueFieldMask(ItemMemberModel itemModel) => $"(byte){1 << (itemModel.Index % 8)}"; diff --git a/src/FlatSharp/Serialization/RoslynSerializerGenerator.cs b/src/FlatSharp/Serialization/RoslynSerializerGenerator.cs index 63efda25..383dea7c 100644 --- a/src/FlatSharp/Serialization/RoslynSerializerGenerator.cs +++ b/src/FlatSharp/Serialization/RoslynSerializerGenerator.cs @@ -485,6 +485,7 @@ namespace {resolvedName.@namespace} internal class {resolvedName.name} : {nameof(IGeneratedSerializer)}<{rootType.GetGlobalCompilableTypeName()}> {{ // Method generated to help AOT compilers make good decisions about generics. + [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage] public void __AotHelper() {{ this.Write(default!, new byte[10], default!, default!); @@ -623,8 +624,14 @@ internal string ImplementHelperClass(ITypeModel typeModel, IMethodNameResolver r string serializerBody = string.Empty; if (typeModel.SchemaType == FlatBufferSchemaType.Table) { - // Generate a serializer as well. - (serializerBody, _) = ImplementInterfaceMethod(typeModel.ClrType, resolver); + TableTypeModel? tableModel = typeModel as TableTypeModel; + FlatSharpInternal.Assert(tableModel is not null, "expecting table"); + + if (tableModel.ShouldBuildISerializer) + { + // Generate a serializer as well. + (serializerBody, _) = ImplementInterfaceMethod(typeModel.ClrType, resolver); + } } string @class = @@ -657,12 +664,13 @@ private static SyntaxNode ApplySyntaxTransformations(SyntaxNode rootNode) rootNode.DescendantNodes().OfType(), (a, b) => { - if (a.Body != null) + // Ignore empty methods. + if (b.Body == null || b.Body.Statements.Count == 0) { - return b.WithBody(SyntaxFactory.Block(SyntaxFactory.CheckedStatement(SyntaxKind.CheckedStatement, a.Body))); + return a; } - return a; + return b.WithBody(SyntaxFactory.Block(SyntaxFactory.CheckedStatement(SyntaxKind.CheckedStatement, b.Body))); }); // Add checked{} to constructors. @@ -670,7 +678,12 @@ private static SyntaxNode ApplySyntaxTransformations(SyntaxNode rootNode) rootNode.DescendantNodes().OfType(), (a, b) => { - return b.WithBody(SyntaxFactory.Block(SyntaxFactory.CheckedStatement(SyntaxKind.CheckedStatement, a.Body))); + // Ignore empty methods. + if (b.Body == null || b.Body.Statements.Count == 0) + { + return a; + } + return b.WithBody(SyntaxFactory.Block(SyntaxFactory.CheckedStatement(SyntaxKind.CheckedStatement, b.Body))); }); // Add checked{} to property accessors. @@ -678,11 +691,11 @@ private static SyntaxNode ApplySyntaxTransformations(SyntaxNode rootNode) rootNode.DescendantNodes().OfType(), (a, b) => { - if (b.Body == null) + // Ignore empty methods. + if (b.Body == null || b.Body.Statements.Count == 0) { return a; } - return b.WithBody(SyntaxFactory.Block(SyntaxFactory.CheckedStatement(SyntaxKind.CheckedStatement, b.Body))); }); diff --git a/src/FlatSharp/TypeModel/StructMemberModel.cs b/src/FlatSharp/TypeModel/StructMemberModel.cs index ec8ac90d..a10f65e8 100644 --- a/src/FlatSharp/TypeModel/StructMemberModel.cs +++ b/src/FlatSharp/TypeModel/StructMemberModel.cs @@ -70,7 +70,7 @@ public override string CreateReadItemBody( { context = context with { - OffsetVariableName = $"{context.OffsetVariableName} + {this.Offset}", + OffsetVariableName = $"{context.OffsetVariableName}{GetOffsetAdjustment(this.Offset)}", }; return $"return {context.GetParseInvocation(this.ItemTypeModel.ClrType)};"; @@ -82,9 +82,19 @@ public override string CreateWriteThroughBody( { context = context with { - OffsetVariableName = $"{context.OffsetVariableName} + {this.Offset}" + OffsetVariableName = $"{context.OffsetVariableName}{GetOffsetAdjustment(this.Offset)}" }; return context.GetSerializeInvocation(this.ItemTypeModel.ClrType) + ";"; } + + private static string GetOffsetAdjustment(int offset) + { + if (offset == 0) + { + return string.Empty; + } + + return $"+ {offset}"; + } } diff --git a/src/FlatSharp/TypeModel/TableMemberModel.cs b/src/FlatSharp/TypeModel/TableMemberModel.cs index 5e0e97bf..76bdfe71 100644 --- a/src/FlatSharp/TypeModel/TableMemberModel.cs +++ b/src/FlatSharp/TypeModel/TableMemberModel.cs @@ -216,10 +216,9 @@ private string CreateWideReadItemBody( relativeOffsets.Add($@" int relativeOffset{i} = {vtableVariableName}.OffsetOf<{context.InputBufferTypeName}>({context.InputBufferVariableName}, {idx}); - if (relativeOffset{i} == 0) - {{ - {this.GetNotPresentStatement()} - }} + bool isZero{i} = relativeOffset{i} == 0; + allZero &= isZero{i}; + anyZero |= isZero{i}; "); absoluteLocations.Add($"relativeOffset{i} + {context.OffsetVariableName}"); @@ -232,8 +231,21 @@ private string CreateWideReadItemBody( }; return $@" + bool allZero = true; + bool anyZero = false; + {string.Join("\r\n", relativeOffsets)} + if (allZero) + {{ + {GetNotPresentStatement()} + }} + + if (anyZero) + {{ + throw new {typeof(System.IO.InvalidDataException).GetGlobalCompilableTypeName()}(""FlatBuffer table property '{this.FriendlyName}' was only partially included in the buffer.""); + }} + var absoluteLocations = ({string.Join(", ", absoluteLocations)}); return {adjustedContext.GetParseInvocation(this.PropertyInfo.PropertyType)};"; } diff --git a/src/FlatSharp/TypeModel/TableTypeModel.cs b/src/FlatSharp/TypeModel/TableTypeModel.cs index 398158cf..2d73f201 100644 --- a/src/FlatSharp/TypeModel/TableTypeModel.cs +++ b/src/FlatSharp/TypeModel/TableTypeModel.cs @@ -109,6 +109,11 @@ internal TableTypeModel(Type clrType, TypeModelContainer typeModelProvider) : ba /// public TableMemberModel? KeyMember { get; private set; } + /// + /// If we should build an ISerailizer implementation for this type. + /// + public bool ShouldBuildISerializer => this.attribute.BuildSerializer; + /// /// Gets the maximum size of a table assuming all members are populated include the vtable offset. /// Does not consider alignment of the table, but does consider worst-case alignment of the members. diff --git a/src/FlatSharp/TypeModel/UnionTypeModel.cs b/src/FlatSharp/TypeModel/UnionTypeModel.cs index e04ab9b3..1f41bf37 100644 --- a/src/FlatSharp/TypeModel/UnionTypeModel.cs +++ b/src/FlatSharp/TypeModel/UnionTypeModel.cs @@ -172,8 +172,6 @@ public override CodeGeneratedMethod CreateParseMethodBody(ParserCodeGenContext c string body = $@" byte discriminator = {context.InputBufferVariableName}.{nameof(IInputBuffer.ReadByte)}({context.OffsetVariableName}.offset0); int offsetLocation = {context.OffsetVariableName}.offset1; - if (discriminator != 0 && offsetLocation == 0) - throw new System.IO.InvalidDataException(""FlatBuffer union had discriminator set but no offset.""); switch (discriminator) {{ diff --git a/src/Tests/FlatSharpCompilerTests/IncludeTests.cs b/src/Tests/FlatSharpCompilerTests/IncludeTests.cs index ecff5a8a..0d86b18f 100644 --- a/src/Tests/FlatSharpCompilerTests/IncludeTests.cs +++ b/src/Tests/FlatSharpCompilerTests/IncludeTests.cs @@ -51,12 +51,6 @@ namespace Foobar; PropertyInfo tableB = aType.GetProperty("TableB"); Assert.Equal(bType, tableB.PropertyType); - - var compiled = CompilerTestHelpers.CompilerTestSerializer.Compile(aType); - - byte[] data = new byte[100]; - compiled.Write(data, Activator.CreateInstance(aType)); - compiled.Parse(data); }); } @@ -139,12 +133,6 @@ namespace Foobar; Assert.Equal(bType, tableB.PropertyType); Assert.Equal(cType, tableC.PropertyType); Assert.Equal(dType, tableD.PropertyType); - - var compiled = CompilerTestHelpers.CompilerTestSerializer.Compile(aType); - - byte[] data = new byte[100]; - compiled.Write(data, Activator.CreateInstance(aType)); - compiled.Parse(data); }); } diff --git a/src/Tests/FlatSharpCompilerTests/StructTests.cs b/src/Tests/FlatSharpCompilerTests/StructTests.cs index ad619170..9de80fa9 100644 --- a/src/Tests/FlatSharpCompilerTests/StructTests.cs +++ b/src/Tests/FlatSharpCompilerTests/StructTests.cs @@ -59,22 +59,5 @@ struct Bar { dynamic dTable = table; Assert.Equal(3, dTable.defaultInt); dTable.foo = dFoo; - - byte[] destination = new byte[1024]; - - var serializer = CompilerTestHelpers.CompilerTestSerializer.Compile(table); - int bytesWritten = serializer.Write(destination, table); - object parsed = serializer.Parse(destination); - - Assert.True(tableType.IsAssignableFrom(parsed.GetType())); - - dynamic dParsedTable = parsed; - Assert.Equal(3, dParsedTable.defaultInt); - - dynamic dParsedFoo = dParsedTable.foo; - Assert.Equal(dFoo.id, dParsedFoo.id); - Assert.Equal(dFoo.count, dParsedFoo.count); - Assert.Equal(dFoo.prefix, dParsedFoo.prefix); - Assert.Equal(dFoo.length, dParsedFoo.length); } } diff --git a/src/Tests/FlatSharpEndToEndTests/Helpers.cs b/src/Tests/FlatSharpEndToEndTests/Helpers.cs index e4aef176..2e557643 100644 --- a/src/Tests/FlatSharpEndToEndTests/Helpers.cs +++ b/src/Tests/FlatSharpEndToEndTests/Helpers.cs @@ -14,21 +14,15 @@ * limitations under the License. */ +using FlatSharp.Internal; +using System.Linq.Expressions; +using System.Reflection; +using System.Threading; + namespace FlatSharpEndToEndTests; public static class Helpers { - public static IEnumerable AllOptions - { - get - { - yield return FlatBufferDeserializationOption.Lazy; - yield return FlatBufferDeserializationOption.Progressive; - yield return FlatBufferDeserializationOption.Greedy; - yield return FlatBufferDeserializationOption.GreedyMutable; - } - } - public static byte[] AllocateAndSerialize(this T item) where T : class, IFlatBufferSerializable { return item.AllocateAndSerialize(item.Serializer); @@ -63,5 +57,301 @@ public static T SerializeAndParse( byte[] buffer = item.AllocateAndSerialize(); return serializer.Parse(buffer); } -} + public static T SerializeAndParse( + this T item, + FlatBufferDeserializationOption option, + out byte[] buffer) where T : class, IFlatBufferSerializable + { + buffer = item.AllocateAndSerialize(); + return item.Serializer.Parse(buffer, option); + } + + public static void AssertSequenceEqual( + Span expected, + Span actual) + { + //var combined = expected.ToArray().Zip(actual.ToArray()).ToArray(); + Assert.Equal(expected.Length, actual.Length); + + for (int i = 0; i < expected.Length; ++i) + { + if (expected[i] != actual[i]) + { + throw new Exception($"Buffers differed at position {i}. Expected = {expected[i]}. Actual = {actual[i]}"); + } + } + } + + public static void AssertMutationWorks( + FlatBufferDeserializationOption option, + TSource parent, + bool isWriteThrough, + Expression> propertyLambda, + TProperty newValue) + { + Assert.True(parent is IFlatBufferDeserializedObject); + + { + var dobj = (IFlatBufferDeserializedObject)parent; + + Assert.Equal(option, dobj.DeserializationContext.DeserializationOption); + Assert.Equal(typeof(TSource), dobj.TableOrStructType); + + switch (option) + { + case FlatBufferDeserializationOption.Greedy: + case FlatBufferDeserializationOption.GreedyMutable: + Assert.False(dobj.CanSerializeWithMemoryCopy); + Assert.Null(dobj.InputBuffer); + break; + + default: + Assert.True(dobj.CanSerializeWithMemoryCopy); + Assert.NotNull(dobj.InputBuffer); + break; + } + } + + MemberExpression member = propertyLambda.Body as MemberExpression; + PropertyInfo propInfo = member.Member as PropertyInfo; + Action action = () => propInfo.SetMethod.Invoke(parent, new object[] { newValue }); + + switch (option) + { + case FlatBufferDeserializationOption.Lazy when isWriteThrough: + case FlatBufferDeserializationOption.Progressive when isWriteThrough: + case FlatBufferDeserializationOption.GreedyMutable when isWriteThrough is false: + action(); + + // For value types, validate that they are the same. + if (typeof(TProperty).IsValueType) + { + TProperty readValue = (TProperty)propInfo.GetMethod.Invoke(parent, null); + Assert.Equal(newValue, readValue); + } + else if (option != FlatBufferDeserializationOption.Lazy) + { + TProperty readValue = (TProperty)propInfo.GetMethod.Invoke(parent, null); + Assert.True(object.ReferenceEquals(newValue, readValue)); + } + + return; + + default: + var ex = Assert.Throws(new Action(() => + { + var ex = Assert.Throws(action).InnerException; + throw ex; + })); + + if (isWriteThrough && option == FlatBufferDeserializationOption.GreedyMutable) + { + Assert.Equal("WriteThrough fields are implemented as readonly when using 'GreedyMutable' serializers.", ex.Message); + } + + return; + } + } + + public static void AssertMutationWorks( + FlatBufferDeserializationOption option, + bool isWriteThrough, + IList items, + T newValue) + { + if (option != FlatBufferDeserializationOption.Lazy) + { + T[] target = new T[items.Count]; + items.CopyTo(target, 0); + + for (int i = 0; i < items.Count; ++i) + { + Assert.Equal(i, items.IndexOf(items[i])); + Assert.True(items.Contains(items[i])); + Assert.Equal(items[i], target[i]); + } + } + + for (int i = 0; i < items.Count; ++i) + { + switch (option) + { + case FlatBufferDeserializationOption.Lazy when isWriteThrough: + case FlatBufferDeserializationOption.Progressive when isWriteThrough: + case FlatBufferDeserializationOption.GreedyMutable when isWriteThrough is false: + items[i] = newValue; + + // For value types, validate that they are the same. + if (typeof(T).IsValueType) + { + Assert.Equal(newValue, items[i]); + } + else if (option != FlatBufferDeserializationOption.Lazy) + { + Assert.True(object.ReferenceEquals(newValue, items[i])); + } + + break; + + default: + var ex = Assert.Throws(new Action(() => + { + items[i] = newValue; + })); + + if (isWriteThrough && option == FlatBufferDeserializationOption.GreedyMutable) + { + Assert.Equal("WriteThrough fields are implemented as readonly when using 'GreedyMutable' serializers.", ex.Message); + } + + break; + } + } + + if (option == FlatBufferDeserializationOption.GreedyMutable) + { + items.Clear(); + items.Add(default); + items.Remove(items[0]); + items.Insert(0, default); + items.RemoveAt(0); + } + else + { + Assert.Throws(() => items.Clear()); + Assert.Throws(() => items.Add(default)); + Assert.Throws(() => items.Remove(items[0])); + Assert.Throws(() => items.Insert(0, default)); + Assert.Throws(() => items.RemoveAt(0)); + } + } + + public static T TestProgressiveFieldLoad(int index, bool expected, P parent, Func getter) + { + IFlatBufferDeserializedObject obj = (IFlatBufferDeserializedObject)parent; + + int maskNum = index / 8; + byte bitMask = (byte)(1 << (index % 8)); + + FieldInfo mask = parent.GetType().GetField($"__mask{maskNum}", BindingFlags.NonPublic | BindingFlags.Instance); + FieldInfo vtable = parent.GetType().GetField("__vtable", BindingFlags.NonPublic | BindingFlags.Instance); + + bool IsFieldLoaded() + { + byte value = (byte)mask.GetValue(parent); + return (value & bitMask) != 0; + } + + bool IsFieldPresent() + { + if (typeof(P).GetCustomAttribute() is not null) + { + return true; + } + + IVTable vt = (IVTable)vtable.GetValue(parent); + return vt.OffsetOf(obj.InputBuffer!, index) != 0; + } + + Assert.False(IsFieldLoaded()); + Assert.Equal(expected, IsFieldPresent()); + + for (int i = 0; i < 10; ++i) + { + T item = getter(parent); + + Assert.True(IsFieldLoaded()); + T next = getter(parent); + + if (typeof(T).IsValueType) + { + Assert.Equal(item, next); + } + else + { + Assert.True(object.ReferenceEquals(item, next)); + } + } + + return getter(parent); + } + + private static int counter; + + public static IList CreateList(params T[] values) + { + return (Interlocked.Increment(ref counter) % 3) switch + { + 0 => values, + 1 => new List(values), + _ => new DummyList(values), + }; + } + + private class DummyList : IList, IReadOnlyList + { + private readonly List list = new(); + + public DummyList(T[] values) + { + this.list.AddRange(values); + } + + public T this[int index] { get => ((IList)list)[index]; set => ((IList)list)[index] = value; } + + public int Count => ((ICollection)list).Count; + + public bool IsReadOnly => ((ICollection)list).IsReadOnly; + + public void Add(T item) + { + ((ICollection)list).Add(item); + } + + public void Clear() + { + ((ICollection)list).Clear(); + } + + public bool Contains(T item) + { + return ((ICollection)list).Contains(item); + } + + public void CopyTo(T[] array, int arrayIndex) + { + ((ICollection)list).CopyTo(array, arrayIndex); + } + + public IEnumerator GetEnumerator() + { + return ((IEnumerable)list).GetEnumerator(); + } + + public int IndexOf(T item) + { + return ((IList)list).IndexOf(item); + } + + public void Insert(int index, T item) + { + ((IList)list).Insert(index, item); + } + + public bool Remove(T item) + { + return ((ICollection)list).Remove(item); + } + + public void RemoveAt(int index) + { + ((IList)list).RemoveAt(index); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return ((IEnumerable)list).GetEnumerator(); + } + } +} \ No newline at end of file diff --git a/src/Tests/Stryker/CodeGen/CodeGen.csproj b/src/Tests/Stryker/CodeGen/CodeGen.csproj new file mode 100644 index 00000000..9db6bcf6 --- /dev/null +++ b/src/Tests/Stryker/CodeGen/CodeGen.csproj @@ -0,0 +1,17 @@ + + + + net7.0 + StrykerTestsCodeGen + FlatSharpStrykerTests + true + annotations + CS1591 + + + + + + + + diff --git a/src/Tests/Stryker/CodeGen/FieldsPartial.cs b/src/Tests/Stryker/CodeGen/FieldsPartial.cs new file mode 100644 index 00000000..ceeb45e4 --- /dev/null +++ b/src/Tests/Stryker/CodeGen/FieldsPartial.cs @@ -0,0 +1,19 @@ +using FlatSharp; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace FlatSharpStrykerTests; + +public partial class Fields : IReferenceItem +{ + public static bool IsStaticInitialized { get; set; } + + public bool IsInitialized { get; set; } + + partial void OnInitialized(FlatBufferDeserializationContext? context) => this.IsInitialized = true; + + static partial void OnStaticInitialize() => IsStaticInitialized = true; +} diff --git a/src/Tests/Stryker/CodeGen/FlatSharp.cs b/src/Tests/Stryker/CodeGen/FlatSharp.cs new file mode 100644 index 00000000..e69de29b diff --git a/src/Tests/Stryker/CodeGen/KeyPartial.cs b/src/Tests/Stryker/CodeGen/KeyPartial.cs new file mode 100644 index 00000000..8fc4c48a --- /dev/null +++ b/src/Tests/Stryker/CodeGen/KeyPartial.cs @@ -0,0 +1,19 @@ +using FlatSharp; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace FlatSharpStrykerTests; + +public partial class Key : IReferenceItem +{ + public static bool IsStaticInitialized { get; set; } + + public bool IsInitialized { get; set; } + + partial void OnInitialized(FlatBufferDeserializationContext? context) => this.IsInitialized = true; + + static partial void OnStaticInitialize() => IsStaticInitialized = true; +} diff --git a/src/Tests/Stryker/CodeGen/MockBitConverter.cs b/src/Tests/Stryker/CodeGen/MockBitConverter.cs new file mode 100644 index 00000000..36bcbadc --- /dev/null +++ b/src/Tests/Stryker/CodeGen/MockBitConverter.cs @@ -0,0 +1,20 @@ +using FlatSharp; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace FlatSharp.Internal; + +public static class MockBitConverter +{ + private static readonly ThreadLocal isLE = new(() => true); + + public static bool IsLittleEndian + { + get => isLE.Value; + set => isLE.Value = value; + } +} diff --git a/src/Tests/Stryker/CodeGen/RefStructPartial.cs b/src/Tests/Stryker/CodeGen/RefStructPartial.cs new file mode 100644 index 00000000..aa8aa46a --- /dev/null +++ b/src/Tests/Stryker/CodeGen/RefStructPartial.cs @@ -0,0 +1,26 @@ +using FlatSharp; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace FlatSharpStrykerTests; + +public interface IReferenceItem +{ + static abstract bool IsStaticInitialized { get; } + + bool IsInitialized { get; } +} + +public partial class RefStruct : IReferenceItem +{ + public static bool IsStaticInitialized { get; set; } + + public bool IsInitialized { get; set; } + + partial void OnInitialized(FlatBufferDeserializationContext? context) => this.IsInitialized = true; + + static partial void OnStaticInitialize() => IsStaticInitialized = true; +} diff --git a/src/Tests/Stryker/CodeGen/RootPartial.cs b/src/Tests/Stryker/CodeGen/RootPartial.cs new file mode 100644 index 00000000..abf19f6b --- /dev/null +++ b/src/Tests/Stryker/CodeGen/RootPartial.cs @@ -0,0 +1,19 @@ +using FlatSharp; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace FlatSharpStrykerTests; + +public partial class Root : IReferenceItem +{ + public static bool IsStaticInitialized { get; set; } + + public bool IsInitialized { get; set; } + + partial void OnInitialized(FlatBufferDeserializationContext? context) => this.IsInitialized = true; + + static partial void OnStaticInitialize() => IsStaticInitialized = true; +} diff --git a/src/Tests/Stryker/CodeGen/Schema.fbs b/src/Tests/Stryker/CodeGen/Schema.fbs new file mode 100644 index 00000000..96d33f75 --- /dev/null +++ b/src/Tests/Stryker/CodeGen/Schema.fbs @@ -0,0 +1,111 @@ + +attribute "fs_serializer"; +attribute "fs_unsafeStructVector"; +attribute "fs_valueStruct"; +attribute "fs_writeThrough"; +attribute "fs_vector"; +attribute "fs_sharedString"; + +namespace FlatSharpStrykerTests; + +enum Fruit : uint +{ + Apple, + Banana, + Strawberry, + Pear +} + +/// Poorly Aligned. Total Size = 10, Alignment = 4 +struct ValueStruct (fs_valueStruct) +{ + /// Position 0, Length 4, Alignment 4 + a : int; + + /// Position 4, Length 1, Alignment 1 + b : byte; + + /// Position 6, Length 4, Alignment 2 + c : [ short : 2 ] (fs_unsafeStructVector); +} + +/// Poorly aligned. Total Size == 26, Alignemnt = 8 +struct RefStruct +{ + /// Position 0, Length 8, Alignment 8, WriteThrough = true + a : long (fs_writeThrough); + + /// Position 8, Length 4, Alignment 4, WriteThrough = false + b : Fruit; + + /// Position 12, Length 2, Alignment 1, WriteThrough = true + c : [ byte : 2 ] (fs_writeThrough); + + /// Position 14, length 2, Alignment 1, WriteThrough = false + d : [ byte : 2 ]; + + /// Position 16, Length 10, Alignment 4, WriteThrough = false + e : ValueStruct; +} + +table Key +{ + /// Field 0 + name : string (key, required); + + /// Field 1 + value : Fruit = Banana; +} + +union FunUnion { RefStruct, ValueStruct, str : string, Key } + +table Root (fs_serializer) +{ + /// Field 0 + fields : Fields; + + /// Field 1 + vectors : Vectors; +} + +table Fields +{ + /// Field 0 + ref_struct : RefStruct; + + /// Field 1 + value_struct : ValueStruct; + + /// Field 2 + memory : ubyte; + + /// Field 3 + str : string; + + /// Field 4, 5 + union : FunUnion; + + /// Field 6 + scalar_with_default : int = 3; +} + +table Vectors +{ + /// Field 0 + ref_struct : [ RefStruct ]; + + /// Field 1 + value_struct : [ ValueStruct ]; + + /// Field 2 + memory : [ ubyte ]; + + /// Field 3 + str : [ string ]; + + /// Field 4, 5 + union : [ FunUnion ]; + + /// Field 6 + indexed : [ Key ] (fs_vector:"IIndexedVector"); +} \ No newline at end of file diff --git a/src/Tests/Stryker/CodeGen/VectorPartial.cs b/src/Tests/Stryker/CodeGen/VectorPartial.cs new file mode 100644 index 00000000..e669bb66 --- /dev/null +++ b/src/Tests/Stryker/CodeGen/VectorPartial.cs @@ -0,0 +1,19 @@ +using FlatSharp; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace FlatSharpStrykerTests; + +public partial class Vectors : IReferenceItem +{ + public static bool IsStaticInitialized { get; set; } + + public bool IsInitialized { get; set; } + + partial void OnInitialized(FlatBufferDeserializationContext? context) => this.IsInitialized = true; + + static partial void OnStaticInitialize() => IsStaticInitialized = true; +} diff --git a/src/Tests/Stryker/Tests/FullTreeTests.cs b/src/Tests/Stryker/Tests/FullTreeTests.cs new file mode 100644 index 00000000..861d4c06 --- /dev/null +++ b/src/Tests/Stryker/Tests/FullTreeTests.cs @@ -0,0 +1,206 @@ +using FlatSharp.Internal; +using NuGet.Frameworks; +using System.Linq.Expressions; +using System.Net.Http.Headers; +using System.Threading; + +namespace FlatSharpStrykerTests; + +public class FullTreeTests +{ + [Fact] + public void GetMaxSize() + { + Root root = this.CreateRoot(); + int maxSize = Root.Serializer.GetMaxSize(root); + + Assert.Equal(730, maxSize); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void Clone(FlatBufferDeserializationOption option) + { + Root root = this.CreateRoot().SerializeAndParse(option); + + Root copy = new Root(root); + + Assert.NotSame(root, copy); + Assert.Equal(typeof(Root), copy.GetType()); + Assert.NotEqual(typeof(Root), root.GetType()); + + { + Vectors rv = root.Vectors; + Vectors cv = copy.Vectors; + + Assert.NotSame(rv, cv); + Assert.NotSame(rv.GetType(), cv.GetType()); + Assert.Equal(typeof(Vectors), cv.GetType()); + + Verify(rv.RefStruct, cv.RefStruct, Verify); + Verify(rv.ValueStruct, cv.ValueStruct, Verify); + Verify(rv.Str, cv.Str, Assert.Equal); + Verify(rv.Union, cv.Union, Assert.Equal); + Verify(rv.Indexed, cv.Indexed, Verify); + } + + { + Fields rf = root.Fields; + Fields cf = copy.Fields; + + Assert.NotSame(rf, cf); + Assert.NotSame(rf.GetType(), cf.GetType()); + Assert.Equal(typeof(Fields), cf.GetType()); + + Assert.Equal(rf.Memory, cf.Memory); + Assert.Equal(rf.ScalarWithDefault, cf.ScalarWithDefault); + Assert.Equal(rf.Str, cf.Str); + Verify(rf.RefStruct, cf.RefStruct); + Verify(rf.ValueStruct, cf.ValueStruct, Verify); + Verify(rf.Union, cf.Union, Verify); + Assert.Equal(rf.Memory, cf.Memory); + } + } + + private static void Verify(IIndexedVector a, IIndexedVector b, Action verify) + where T : class + { + Assert.NotSame(a, b); + Assert.Equal(a.Count, b.Count); + + foreach (var kvp in a) + { + TKey key = kvp.Key; + T value = kvp.Value; + + Assert.True(b.TryGetValue(key, out T? bValue)); + verify(value, bValue); + } + } + + private static void Verify(IList a, IList b, Action comparer) + { + Assert.NotSame(a, b); + Assert.Equal(a.Count, b.Count); + + for (int i = 0; i < a.Count; ++i) + { + comparer(a[i], b[i]); + } + } + + private static void Verify(T? a, T? b, Action action) where T : struct + { + Assert.Equal(a.HasValue, b.HasValue); + if (a.HasValue) + { + action(a.Value, b.Value); + } + } + + private static void Verify(ValueStruct a, ValueStruct b) + { + Assert.Equal(a.A, b.A); + Assert.Equal(a.B, b.B); + Assert.Equal(a.C(0), b.C(0)); + Assert.Equal(a.C(1), b.C(1)); + } + + private static void Verify(FunUnion a, FunUnion b) + { + Assert.Equal(a.Discriminator, b.Discriminator); + + switch (a.Kind) + { + case FunUnion.ItemKind.Key: + Verify(a.Key, b.Key); + return; + + case FunUnion.ItemKind.RefStruct: + Verify(a.RefStruct, b.RefStruct); + return; + + case FunUnion.ItemKind.str: + Assert.Equal(a.str, b.str); + return; + + case FunUnion.ItemKind.ValueStruct: + Verify(a.ValueStruct, b.ValueStruct); + return; + + default: + Assert.False(true); + return; + } + } + + private static void Verify(Key a, Key b) + { + Assert.NotSame(a, b); + Assert.Equal(a.Name, b.Name); + Assert.Equal(a.Value, b.Value); + } + + private static void Verify(RefStruct a, RefStruct b) + { + Assert.NotSame(a, b); + Assert.Equal(a.A, b.A); + Assert.Equal(a.B, b.B); + Assert.Equal(a.C[0], b.C[0]); + Assert.Equal(a.C[1], b.C[1]); + Assert.Equal(a.D[0], b.D[0]); + Assert.Equal(a.D[1], b.D[1]); + Verify(a.E, b.E); + } + + private Root CreateRoot() + { + static RefStruct CreateRefStruct() + { + RefStruct rs = new() + { + A = 1, + B = Fruit.Strawberry, + E = new ValueStruct + { + A = 4, + B = 5, + } + }; + + rs.C.CopyFrom(new sbyte[] { 1, 2 }.AsSpan()); + rs.D.CopyFrom(new sbyte[] { 1, 2 }.ToList()); + + return rs; + } + + return new() + { + Fields = new() + { + Memory = 1, + RefStruct = CreateRefStruct(), + ScalarWithDefault = 1234, + Str = "hello", + Union = new(new Key() { Name = "fred", Value = Fruit.Strawberry }), + ValueStruct = CreateRefStruct().E + }, + + Vectors = new() + { + Indexed = new IndexedVector + { + { new Key { Name = "velma", Value = Fruit.Banana } }, + { new Key { Name = "scooby", Value = Fruit.Pear } }, + { new Key { Name = "shaggy", Value = Fruit.Apple } }, + }, + + Memory = new byte[] { 1, 2, 3, 4, }, + RefStruct = Helpers.CreateList(CreateRefStruct(), CreateRefStruct()), + Str = Helpers.CreateList("abc", "def"), + Union = Helpers.CreateList(new FunUnion("hi"), new FunUnion(new ValueStruct())), + ValueStruct = Helpers.CreateList(CreateRefStruct().E, CreateRefStruct().E), + }, + }; + } +} diff --git a/src/Tests/Stryker/Tests/GlobalUsings.cs b/src/Tests/Stryker/Tests/GlobalUsings.cs new file mode 100644 index 00000000..723f7c0a --- /dev/null +++ b/src/Tests/Stryker/Tests/GlobalUsings.cs @@ -0,0 +1,32 @@ + +/* + * Copyright 2021 James Courtney + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +global using System; +global using System.Buffers; +global using System.Buffers.Binary; +global using System.Collections; +global using System.Collections.Generic; +global using System.ComponentModel; +global using System.Diagnostics; +global using System.Diagnostics.CodeAnalysis; +global using System.Linq; +global using System.Reflection; +global using System.Runtime.CompilerServices; +global using FlatSharp; +global using FlatSharp.Attributes; +global using Xunit; +global using FlatSharpEndToEndTests; \ No newline at end of file diff --git a/src/Tests/Stryker/Tests/IndexedVectorTests.cs b/src/Tests/Stryker/Tests/IndexedVectorTests.cs new file mode 100644 index 00000000..0d3f14fa --- /dev/null +++ b/src/Tests/Stryker/Tests/IndexedVectorTests.cs @@ -0,0 +1,282 @@ +using FlatSharp.Internal; +using System.IO; +using System.Linq.Expressions; +using System.Threading; + +namespace FlatSharpStrykerTests; + +public class IndexedVectorTests +{ + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void Present(FlatBufferDeserializationOption option) + { + Root root = CreateRoot(out byte[] expectedData); + Root parsed = root.SerializeAndParse(option, out byte[] buffer); + + Vectors vectors = parsed.Vectors; + Assert.True(vectors.IsInitialized); + Assert.True(Vectors.IsStaticInitialized); + + IIndexedVector vector = vectors.Indexed; + + var expected = root.Vectors.Indexed.ToArray(); + + foreach (var pair in expected) + { + Fruit f = pair.Value.Value; + string name = pair.Value.Name; + + Assert.True(vector.TryGetValue(name, out Key key)); + Assert.Equal(f, key.Value); + Assert.Equal(name, key.Name); + + key = vector[name]; + Assert.Equal(f, key.Value); + + Assert.True(vector.ContainsKey(name)); + } + + Assert.False(vector.ContainsKey("z")); + Assert.False(vector.TryGetValue("z", out _)); + + Helpers.AssertSequenceEqual(expectedData, buffer); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void Missing(FlatBufferDeserializationOption option) + { + Root root = CreateRoot_Missing(out byte[] expectedData); + Root parsed = root.SerializeAndParse(option, out byte[] buffer); + + Vectors vectors = parsed.Vectors; + Assert.True(vectors.IsInitialized); + Assert.True(Vectors.IsStaticInitialized); + + Assert.Null(vectors.Indexed); + Helpers.AssertSequenceEqual(expectedData, buffer); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void KeyNotSet_Serialize(FlatBufferDeserializationOption option) + { + Key key = new Key { Name = "fred", Value = Fruit.Apple }; + + Root root = new() + { + Vectors = new() + { + Indexed = new IndexedVector + { + { key } + } + } + }; + + key.Name = null!; + + var ex = Assert.Throws(() => root.SerializeAndParse(option)); + Assert.Equal("Table property 'FlatSharpStrykerTests.Key.Name' is marked as required, but was not set.", ex.Message); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void KeyNotSet_Parse(FlatBufferDeserializationOption option) + { + // missing required field. + byte[] data = + { + 4, 0, 0, 0, + 248, 255, 255, 255, + 12, 0, 0, 0, + + 6, 0, 8, 0, + 4, 0, 0, 0, + + 246, 255, 255, 255, + 24, 0, 0, 0, + 4, 0, + + 16, 0, 9, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + 8, 0, 4, 0, + + 0, 0, + + 248, 255, 255, 255, + 0, 0, 0, 0, + + 8, 0, 8, 0, + 0, 0, 4, 0, + }; + + var ex = Assert.Throws(() => + { + var root = Root.Serializer.Parse(data, option); + string name = root.Fields.Union.Value.Key.Name; + }); + + Assert.Equal("Table property 'FlatSharpStrykerTests.Key.Name' is marked as required, but was missing from the buffer.", ex.Message); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void Big(FlatBufferDeserializationOption option) + { + Root root = new Root + { + Vectors = new() + { + Indexed = new IndexedVector(), + } + }; + + List expectedKeys = new(); + for (int i = 0; i < 1000; ++i) + { + Key key = new() { Name = Guid.NewGuid().ToString("n"), Value = Fruit.Apple }; + expectedKeys.Add(key.Name); + root.Vectors.Indexed.Add(key); + } + + Root parsed = root.SerializeAndParse(option, out byte[] buffer); + + var parsedIndexed = parsed.Vectors.Indexed; + + for (int i = 0; i < expectedKeys.Count; ++i) + { + Assert.True(parsedIndexed.ContainsKey(expectedKeys[i])); + Assert.NotNull(parsedIndexed[expectedKeys[i]]); + Assert.True(parsedIndexed.TryGetValue(expectedKeys[i], out Key key)); + Assert.NotNull(key); + Assert.Equal(expectedKeys[i], key.Name); + } + + for (int i = 0; i < expectedKeys.Count; ++i) + { + string unexpectedKey = Guid.NewGuid().ToString("n"); + + Assert.False(parsedIndexed.ContainsKey(unexpectedKey)); + Assert.Throws(() => parsedIndexed[unexpectedKey]); + Assert.False(parsedIndexed.TryGetValue(unexpectedKey, out Key key)); + Assert.Null(key); + } + } + + private Root CreateRoot(out byte[] expectedData) + { + static byte B(char c) => (byte)c; + + var vector = new IndexedVector + { + new Key { Name = "a", Value = Fruit.Apple }, + new Key { Name = "b", Value = Fruit.Banana }, + new Key { Name = "p", Value = Fruit.Pear }, + new Key { Name = "s", Value = Fruit.Strawberry }, + }; + + Root root = new() + { + Vectors = new() + { + Indexed = vector, + } + }; + + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Vectors subtable. + + // Vtable for Root + 8, 0, 8, 0, + 0, 0, 4, 0, + + 248, 255, 255, 255, // soffset to vtable + 24, 0, 0, 0, // uoffset to vector + + 18, 0, // vtable length + 8, 0, // table length + 0, 0, // field 0 + 0, 0, // field 1 + 0, 0, // field 2 (scalar) + 0, 0, // field 3 (str) + 0, 0, // field 4, 5 (union) + 0, 0, + 4, 0, // field 6 (indexed) + 0, 0, + + 4, 0, 0, 0, // vector length + 16, 0, 0, 0, + 40, 0, 0, 0, + 60, 0, 0, 0, + 76, 0, 0, 0, + + 244, 255, 255, 255, // soffset to vtable. + 0, 0, 0, 0, // apple + 12, 0, 0, 0, // offset to 'a' + + 8, 0, 12, 0, // vtable + 8, 0, 4, 0, + + 1, 0, 0, 0, + B('a'), 0, 0, 0, + + 248, 255, 255, 255, // non-shared vtable. (banana is default) + 12, 0, 0, 0, + + 6, 0, 8, 0, // vtable + 4, 0, 0, 0, + + 1, 0, 0, 0, + B('b'), 0, 0, 0, + + 40, 0, 0, 0, // shares vtable + 3, 0, 0, 0, // pear + 4, 0, 0, 0, + + 1, 0, 0, 0, + B('p'), 0, 0, 0, + + 60, 0, 0, 0, // shares vtable + 2, 0, 0, 0, // strawberry + 4, 0, 0, 0, + + 1, 0, 0, 0, + B('s'), 0, + }; + + return root; + } + + + private Root CreateRoot_Missing(out byte[] expectedData) + { + Root root = new() + { + Vectors = new() + }; + + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Vectors subtable. + + // Vtable for Root + 8, 0, 8, 0, + 0, 0, 4, 0, + + 252, 255, 255, 255, // soffset to vtable + + 4, 0, // vtable length + 4, 0, // table length + }; + + return root; + } +} diff --git a/src/Tests/Stryker/Tests/MemoryVectorTests.cs b/src/Tests/Stryker/Tests/MemoryVectorTests.cs new file mode 100644 index 00000000..f555c386 --- /dev/null +++ b/src/Tests/Stryker/Tests/MemoryVectorTests.cs @@ -0,0 +1,77 @@ +using FlatSharp.Internal; +using System.Linq.Expressions; +using System.Threading; + +namespace FlatSharpStrykerTests; + +public class MemoryVectorTests +{ + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void MemoryVector(FlatBufferDeserializationOption option) + { + Root root = CreateRoot(out byte[] expectedData); + Root parsed = root.SerializeAndParse(option, out byte[] buffer); + + Vectors vectors = parsed.Vectors; + Assert.True(vectors.IsInitialized); + Assert.True(Vectors.IsStaticInitialized); + + Memory vector = vectors.Memory.Value; + Assert.Equal(5, vector.Length); + for (int i = 0; i < vector.Length; ++i) + { + Assert.Equal(i + 1, vector.Span[i]); + } + + Helpers.AssertMutationWorks(option, vectors, false, s => s.Memory, new byte[0]); + Helpers.AssertSequenceEqual(expectedData, buffer); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void MemoryVector_NotPresent(FlatBufferDeserializationOption option) + { + Root root = new Root() { Vectors = new() }; + Root parsed = root.SerializeAndParse(option, out byte[] buffer); + + Assert.Null(parsed.Vectors.Memory); + } + + private Root CreateRoot(out byte[] expectedData) + { + Root root = new() + { + Vectors = new() + { + Memory = new byte[] { 1, 2, 3, 4, 5, } + } + }; + + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Vectors subtable. + + // Vtable for Root + 8, 0, 8, 0, + 0, 0, 4, 0, + + 248, 255, 255, 255, // soffset to vtable + 16, 0, 0, 0, // uoffset to vector + + 10, 0, // vtable length + 8, 0, // table length + 0, 0, // field 0 + 0, 0, // field 1 + 4, 0, // field 2 (memory) + 0, 0, // padding + + 5, 0, 0, 0, // vector length + 1, 2, 3, 4, 5, + }; + + return root; + } +} diff --git a/src/Tests/Stryker/Tests/PrimitivesFieldsTests.cs b/src/Tests/Stryker/Tests/PrimitivesFieldsTests.cs new file mode 100644 index 00000000..ec8ba39c --- /dev/null +++ b/src/Tests/Stryker/Tests/PrimitivesFieldsTests.cs @@ -0,0 +1,166 @@ +using FlatSharp.Internal; +using System.Linq.Expressions; + +namespace FlatSharpStrykerTests; + +public class PrimitivesFieldsTests +{ + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void StringTableField(FlatBufferDeserializationOption option) + { + Root root = CreateRoot(out byte[] expectedData); + Root parsed = root.SerializeAndParse(option, out byte[] buffer); + + Fields fields = parsed.Fields; + Assert.Equal("hello", fields.Str); + + Helpers.AssertMutationWorks(option, fields, false, s => s.Str, string.Empty); + Helpers.AssertSequenceEqual(expectedData, buffer); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void ScalarTableField(FlatBufferDeserializationOption option) + { + Root root = CreateRoot(out byte[] expectedData); + Root parsed = root.SerializeAndParse(option, out byte[] buffer); + Fields fields = parsed.Fields; + + Assert.Equal(3, fields.Memory); + Helpers.AssertMutationWorks(option, fields, false, s => s.Memory, (byte)0); + Helpers.AssertSequenceEqual(expectedData, buffer); + } + + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void ScalarTableField_WithDefaultValue(FlatBufferDeserializationOption option) + { + Root root = CreateRoot(out byte[] expectedData); + Root parsed = root.SerializeAndParse(option, out byte[] buffer); + Fields fields = parsed.Fields; + + Assert.Equal(3, fields.ScalarWithDefault); + Helpers.AssertMutationWorks(option, fields, false, s => s.ScalarWithDefault, 8); + Helpers.AssertSequenceEqual(expectedData, buffer); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void ScalarTableField_WithoutDefaultValue(FlatBufferDeserializationOption option) + { + Root root = CreateRoot_NotDefault(out byte[] expectedData); + Root parsed = root.SerializeAndParse(option, out byte[] buffer); + Fields fields = parsed.Fields; + + Assert.Equal(root.Fields.ScalarWithDefault, fields.ScalarWithDefault); + Helpers.AssertMutationWorks(option, fields, false, s => s.ScalarWithDefault, 8); + Helpers.AssertSequenceEqual(expectedData, buffer); + } + + [Fact] + public void ProgressiveStringTableField() + { + Root root = CreateRoot(out byte[] expectedData); + Root parsed = root.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out byte[] buffer); + Fields fields = parsed.Fields; + Assert.Equal("hello", Helpers.TestProgressiveFieldLoad(3, true, fields, f => f.Str)); + } + + [Fact] + public void ProgressiveScalarTableField() + { + Root root = CreateRoot(out byte[] expectedData); + Root parsed = root.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out byte[] buffer); + Fields fields = parsed.Fields; + Assert.Equal(3, Helpers.TestProgressiveFieldLoad(2, true, fields, f => f.Memory)); + } + + [Fact] + public void ProgressiveScalarTableFieldWithDefaultValue() + { + Root root = CreateRoot(out byte[] expectedData); + Root parsed = root.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out byte[] buffer); + Fields fields = parsed.Fields; + Assert.Equal(3, Helpers.TestProgressiveFieldLoad(6, false, fields, f => f.ScalarWithDefault)); + } + + private Root CreateRoot(out byte[] expectedData) + { + static byte B(char c) => (byte)c; + + Root root = new() + { + Fields = new() + { + Memory = 3, + Str = "hello", + ScalarWithDefault = 3, + } + }; + + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Fields subtable. + + // Vtable for Root (2 bytes padding) + 6, 0, 8, 0, + 4, 0, 0, 0, + + 246, 255, 255, 255, // soffset to vtable + 20, 0, 0, 0, // uoffset to string + 3, 0, // ubyte scalar, padding + 12, 0, // vtable length + 9, 0, // table length + 0, 0, // field 0 + 0, 0, // field 1 + 8, 0, // field 2 (scalar) + 4, 0, // field 3 (str) + 0, 0, // padding + 5, 0, 0, 0, // string length + B('h'), B('e'), B('l'), B('l'), + B('o'), 0 + }; + + return root; + } + + private Root CreateRoot_NotDefault(out byte[] expectedData) + { + Root root = new() + { + Fields = new() + { + ScalarWithDefault = 1, + } + }; + + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Fields subtable. + + // Vtable for Root (2 bytes padding) + 6, 0, 8, 0, + 4, 0, 0, 0, + + 248, 255, 255, 255, // soffset to vtable + 1, 0, 0, 0, // scalar + 18, 0, // vtable length + 8, 0, // table length + 0, 0, // field 0 + 0, 0, // field 1 + 0, 0, // field 2 (scalar) + 0, 0, // field 3 (str) + 0, 0, // field 4 + 0, 0, // field 5 + 4, 0, // field 6 + }; + + return root; + } +} diff --git a/src/Tests/Stryker/Tests/RefStructVectorTests.cs b/src/Tests/Stryker/Tests/RefStructVectorTests.cs new file mode 100644 index 00000000..bf287feb --- /dev/null +++ b/src/Tests/Stryker/Tests/RefStructVectorTests.cs @@ -0,0 +1,133 @@ +using FlatSharp.Internal; +using System.Linq.Expressions; +using System.Threading; + +namespace FlatSharpStrykerTests; + +public class RefStructVectorTests +{ + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void Present(FlatBufferDeserializationOption option) + { + Root root = CreateRoot(out byte[] expectedData); + Root parsed = root.SerializeAndParse(option, out byte[] actualData); + + Assert.NotNull(root.Vectors.RefStruct); + + var vsr = root.Vectors.RefStruct; + var vsp = parsed.Vectors.RefStruct; + + Assert.Equal(vsr.Count, vsp.Count); + + for (int i = 0; i < vsr.Count; ++i) + { + var r = vsr[i]; + var p = vsp[i]; + + Assert.Equal(r.A, p.A); + Assert.Equal(r.B, p.B); + Assert.Equal(r.C[0], p.C[0]); + Assert.Equal(r.C[1], p.C[1]); + Assert.Equal(r.D[0], p.D[0]); + Assert.Equal(r.D[1], p.D[1]); + } + + Helpers.AssertSequenceEqual(expectedData, actualData); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void Missing(FlatBufferDeserializationOption option) + { + Root root = CreateRoot_Missing(out byte[] expectedData); + root.SerializeAndParse(option, out byte[] actualData); + + Assert.Null(root.Vectors.RefStruct); + Helpers.AssertSequenceEqual(expectedData, actualData); + } + + private Root CreateRoot(out byte[] expectedData) + { + var rs1 = new RefStruct { A = 1, B = Fruit.Banana }; + rs1.C.CopyFrom(new sbyte[] { 3, 4 }.AsSpan()); + rs1.D.CopyFrom(new List { 5, 6, }); + + var rs2 = new RefStruct { A = 7, B = Fruit.Pear }; + rs2.C.CopyFrom(new sbyte[] { 9, 10 }.AsSpan()); + rs2.D.CopyFrom(new List { 11, 12, }); + + Root root = new() + { + Vectors = new() + { + RefStruct = Helpers.CreateList(rs1, rs2) + } + }; + + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Vectors subtable. + + // Vtable for Root + 8, 0, 8, 0, + 0, 0, 4, 0, + + 248, 255, 255, 255, // soffset to vtable (shared) + 12, 0, 0, 0, // uoffset to vector + + 6, 0, 8, 0, // vtable + 4, 0, 0, 0, + + 2, 0, 0, 0, + + 1, 0, 0, 0, + 0, 0, 0, 0, + 1, 0, 0, 0, + 3, 4, 5, 6, + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + + 7, 0, 0, 0, + 0, 0, 0, 0, + 3, 0, 0, 0, + 9, 10, 11, 12, + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + }; + + return root; + } + + private Root CreateRoot_Missing(out byte[] expectedData) + { + Root root = new() + { + Vectors = new() + }; + + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Vectors subtable. + + // Vtable for Root + 8, 0, 8, 0, + 0, 0, 4, 0, + + 252, 255, 255, 255, // soffset to vtable + + 4, 0, // vtable length + 4, 0, // table length + }; + + return root; + } +} diff --git a/src/Tests/Stryker/Tests/StringVectorTests.cs b/src/Tests/Stryker/Tests/StringVectorTests.cs new file mode 100644 index 00000000..8fb23636 --- /dev/null +++ b/src/Tests/Stryker/Tests/StringVectorTests.cs @@ -0,0 +1,83 @@ +using FlatSharp.Internal; +using System.Linq.Expressions; +using System.Threading; + +namespace FlatSharpStrykerTests; + +public class StringVectorTests +{ + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void StringTableField(FlatBufferDeserializationOption option) + { + Root root = CreateRoot(out byte[] expectedData); + Root parsed = root.SerializeAndParse(option, out byte[] buffer); + + Vectors vectors = parsed.Vectors; + Assert.True(vectors.IsInitialized); + Assert.True(Vectors.IsStaticInitialized); + + IList theBoys = vectors.Str; + Assert.Equal(3, theBoys.Count); + Assert.Equal("billy", theBoys[0]); + Assert.Equal("mm", theBoys[1]); + Assert.Equal("frenchie", theBoys[2]); + + Helpers.AssertMutationWorks(option, vectors, false, s => s.Str, new string[0]); + Helpers.AssertMutationWorks(option, false, theBoys, string.Empty); + Helpers.AssertSequenceEqual(expectedData, buffer); + } + + private Root CreateRoot(out byte[] expectedData) + { + static byte B(char c) => (byte)c; + + Root root = new() + { + Vectors = new() + { + Str = Helpers.CreateList("billy", "mm", "frenchie") + } + }; + + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Vectors subtable. + + // Vtable for Root + 8, 0, 8, 0, + 0, 0, 4, 0, + + 248, 255, 255, 255, // soffset to vtable + 16, 0, 0, 0, // uoffset to vector + + 12, 0, // vtable length + 8, 0, // table length + 0, 0, // field 0 + 0, 0, // field 1 + 0, 0, // field 2 (scalar) + 4, 0, // field 3 (str) + + 3, 0, 0, 0, // vector length + 12, 0, 0, 0, + 20, 0, 0, 0, + 24, 0, 0, 0, + + 5, 0, 0, 0, + B('b'), B('i'), B('l'), B('l'), B('y'), 0, + 0, 0, + + 2, 0, 0, 0, + B('m'), B('m'), 0, 0, + + 8, 0, 0, 0, + B('f'), B('r'), B('e'), B('n'), + B('c'), B('h'), B('i'), B('e'), + 0, + }; + + return root; + } +} diff --git a/src/Tests/Stryker/Tests/StructFieldTests.cs b/src/Tests/Stryker/Tests/StructFieldTests.cs new file mode 100644 index 00000000..82798787 --- /dev/null +++ b/src/Tests/Stryker/Tests/StructFieldTests.cs @@ -0,0 +1,242 @@ +using FlatSharp.Internal; +using System.Linq.Expressions; + +namespace FlatSharpStrykerTests; + +public class StructFieldTests +{ + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void ValueStructTableField(FlatBufferDeserializationOption option) + { + try + { + for (int i = 0; i < 2; ++i) + { + MockBitConverter.IsLittleEndian = i == 0; + + ValueStruct vs = new() + { + A = 4, + B = 3, + }; + + vs.C(0) = 1; + vs.C(1) = 2; + + Assert.Throws(() => vs.C(2) = 4); + Assert.Throws(() => vs.C(-1) = 4); + + Root root = new Root + { + Fields = new() + { + ValueStruct = vs, + } + }; + + Root parsed = root.SerializeAndParse(option, out byte[] buffer); + Fields fields = parsed.Fields; + + Assert.NotNull(fields); + Assert.Null(parsed.Vectors); + + Assert.NotNull(parsed.Fields.ValueStruct); + + ValueStruct vsParsed = parsed.Fields.ValueStruct.Value; + + Assert.Equal(vs.A, vsParsed.A); + Assert.Equal(vs.B, vsParsed.B); + Assert.Equal(vs.C(0), vsParsed.C(0)); + Assert.Equal(vs.C(1), vsParsed.C(1)); + + byte[] expectedBytes = + { + 4, 0, 0, 0, // offset to table start + 248, 255, 255, 255, // soffset to vtable. + 12, 0, 0, 0, // uoffset to field 0 (fields table) + 6, 0, // vtable length + 8, 0, // table length + 4, 0, // offset of field 0 + 0, 0, // padding + + 242, 255, 255, 255, // soffset to vtable + 4, 0, 0, 0, // valuestruct.a + 3, 0, // valuestruct.b, padding + 1, 0, // valuestruct.c[0] + 2, 0, // valuestruct.c[1] + + 8, 0, // vtable length + 14, 0, // table length + 0, 0, // field 0 (not present) + 4, 0, // field 1 + }; + + Helpers.AssertSequenceEqual(expectedBytes, buffer); + Helpers.AssertMutationWorks(option, fields, false, p => p.ValueStruct, default); + } + } + finally + { + MockBitConverter.IsLittleEndian = BitConverter.IsLittleEndian; + } + } + + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void ReferenceStructTableField(FlatBufferDeserializationOption option) + { + Root root = CreateRootReferenceStruct(out RefStruct rs, out ValueStruct vs, out byte[] expectedBytes); + Root parsed = root.SerializeAndParse(option, out byte[] buffer); + + Assert.Throws(() => rs.C[-1] = 4); + Assert.Throws(() => rs.D[3] = 4); + + Assert.NotNull(parsed.Fields); + Assert.Null(parsed.Vectors); + Assert.NotNull(parsed.Fields.RefStruct); + + RefStruct rsParsed = parsed.Fields.RefStruct; + Assert.Equal(rs.A, rsParsed.A); + Assert.Equal(rs.B, rsParsed.B); + Assert.Equal(rs.C[0], rsParsed.C[0]); + Assert.Equal(rs.C[1], rsParsed.C[1]); + Assert.Equal(rs.D[0], rsParsed.D[0]); + Assert.Equal(rs.D[1], rsParsed.D[1]); + + ValueStruct vsParsed = rsParsed.E; + Assert.Equal(vs.A, vsParsed.A); + Assert.Equal(vs.B, vsParsed.B); + Assert.Equal(vs.C(0), vsParsed.C(0)); + Assert.Equal(vs.C(1), vsParsed.C(1)); + + Helpers.AssertSequenceEqual(expectedBytes, buffer); + Helpers.AssertMutationWorks(option, parsed.Fields, false, p => p.RefStruct, new RefStruct()); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void ReferenceStructWriteThrough(FlatBufferDeserializationOption option) + { + Root root = CreateRootReferenceStruct(out RefStruct rs, out ValueStruct vs, out byte[] expectedBytes); + Root parsed = root.SerializeAndParse(option, out byte[] buffer); + + RefStruct rsp = parsed.Fields.RefStruct; + + Helpers.AssertMutationWorks(option, rsp, true, rsp => rsp.A, 10); + Helpers.AssertMutationWorks(option, rsp, false, rsp => rsp.B, Fruit.Strawberry); + Helpers.AssertMutationWorks(option, rsp, true, rsp => rsp.__flatsharp__C_0, (sbyte)3); + Helpers.AssertMutationWorks(option, rsp, true, rsp => rsp.__flatsharp__C_1, (sbyte)6); + Helpers.AssertMutationWorks(option, rsp, false, rsp => rsp.__flatsharp__D_0, (sbyte)3); + Helpers.AssertMutationWorks(option, rsp, false, rsp => rsp.__flatsharp__D_1, (sbyte)6); + Helpers.AssertMutationWorks(option, rsp, false, rsp => rsp.E, new ValueStruct()); + + var parsed2 = Root.Serializer.Parse(buffer, option); + + Assert.Equal(rsp.A, parsed2.Fields.RefStruct.A); + Assert.Equal(rsp.C[0], parsed2.Fields.RefStruct.C[0]); + Assert.Equal(rsp.C[1], parsed2.Fields.RefStruct.C[1]); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void ReferenceStructOnDeserialized(FlatBufferDeserializationOption option) + { + Root root = CreateRootReferenceStruct(out RefStruct rs, out ValueStruct vs, out byte[] expectedBytes); + + Root parsed = root.SerializeAndParse(option, out byte[] buffer); + Fields fields = parsed.Fields; + RefStruct rsp = fields.RefStruct; + + Assert.True(parsed.IsInitialized); + Assert.True(Root.IsStaticInitialized); + + Assert.True(fields.IsInitialized); + Assert.True(Fields.IsStaticInitialized); + + Assert.True(rsp.IsInitialized); + Assert.True(RefStruct.IsStaticInitialized); + } + + [Fact] + public void ProgressiveFieldLoads() + { + Root root = CreateRootReferenceStruct(out RefStruct rs, out ValueStruct vs, out byte[] expectedBytes); + Root parsed = root.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out byte[] buffer); + + Fields fields = Helpers.TestProgressiveFieldLoad(0, true, parsed, p => p.Fields); + Assert.NotNull(fields); + + { + RefStruct @ref = Helpers.TestProgressiveFieldLoad(0, true, fields, f => f.RefStruct); + Assert.Equal(root.Fields.RefStruct.A, Helpers.TestProgressiveFieldLoad(0, true, @ref, r => r.A)); + Assert.Equal(root.Fields.RefStruct.B, Helpers.TestProgressiveFieldLoad(1, true, @ref, r => r.B)); + Assert.Equal(root.Fields.RefStruct.C[0], Helpers.TestProgressiveFieldLoad(2, true, @ref, r => r.__flatsharp__C_0)); + Assert.Equal(root.Fields.RefStruct.C[1], Helpers.TestProgressiveFieldLoad(3, true, @ref, r => r.__flatsharp__C_1)); + Assert.Equal(root.Fields.RefStruct.D[0], Helpers.TestProgressiveFieldLoad(4, true, @ref, r => r.__flatsharp__D_0)); + Assert.Equal(root.Fields.RefStruct.D[1], Helpers.TestProgressiveFieldLoad(5, true, @ref, r => r.__flatsharp__D_1)); + Helpers.TestProgressiveFieldLoad(6, true, @ref, r => r.E); + } + } + + private static Root CreateRootReferenceStruct(out RefStruct rs, out ValueStruct vs, out byte[] expectedBuffer) + { + vs = new() + { + A = 4, + B = 3, + }; + + vs.C(0) = 1; + vs.C(1) = 2; + + rs = new() + { + A = 12, + B = Fruit.Pear, + E = vs + }; + + rs.C[0] = 2; + rs.C[1] = 3; + rs.D[0] = 4; + rs.D[1] = 5; + + Root root = new Root + { + Fields = new() + { + RefStruct = rs, + } + }; + + expectedBuffer = new byte[] + { + 4, 0, 0, 0, // offset to table start + 248, 255, 255, 255, // soffset to vtable. + 12, 0, 0, 0, // uoffset to field 0 (fields table) + 6, 0, // vtable length + 8, 0, // table length + 4, 0, // offset of field 0 + 0, 0, // padding + + 226, 255, 255, 255, // soffset to vtable + + 12, 0, 0, 0, // refStruct.A (ulong) + 0, 0, 0, 0, + 3, 0, 0, 0, // refStruct.Fruit (pear) + 2, 3, 4, 5, // refStruct.C[0,1], refStruct.D[0,1] + 4, 0, 0, 0, // valuestruct.a + 3, 0, // valuestruct.b, padding + 1, 0, // valuestruct.c[0] + 2, 0, // valuestruct.c[1] + + 6, 0, // vtable length + 30, 0, // table length + 4, 0, // field 0 + }; + + return root; + } +} diff --git a/src/Tests/Stryker/Tests/StrykerTests.csproj b/src/Tests/Stryker/Tests/StrykerTests.csproj new file mode 100644 index 00000000..55a3f637 --- /dev/null +++ b/src/Tests/Stryker/Tests/StrykerTests.csproj @@ -0,0 +1,32 @@ + + + net7.0 + false + FlatSharpStrykerTests + FlatSharpStrykerTests + annotations + CS1591 + + + + + + + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + + + + + diff --git a/src/Tests/Stryker/Tests/UnionFieldTests.cs b/src/Tests/Stryker/Tests/UnionFieldTests.cs new file mode 100644 index 00000000..71e18561 --- /dev/null +++ b/src/Tests/Stryker/Tests/UnionFieldTests.cs @@ -0,0 +1,517 @@ +using FlatSharp.Internal; +using System.IO; +using System.Linq.Expressions; + +namespace FlatSharpStrykerTests; + +public class UnionFieldTests +{ + [Fact] + public void InvalidConstructors() + { + Assert.Throws(() => new FunUnion((string)null)); + Assert.Throws(() => new FunUnion((RefStruct)null)); + Assert.Throws(() => new FunUnion((Key)null)); + } + + [Fact] + public void InvalidGetters() + { + FunUnion a = new FunUnion(new RefStruct()); + + Assert.Throws(() => a.ValueStruct); + Assert.Throws(() => a.Key); + Assert.Throws(() => a.str); + + a = new FunUnion(new ValueStruct()); + Assert.Throws(() => a.RefStruct); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void StringMember(FlatBufferDeserializationOption option) + { + Root root = this.CreateRoot_StringMember(out var expectedData); + Root parsed = root.SerializeAndParse(option, out var actualData); + + Helpers.AssertSequenceEqual(expectedData, actualData); + + FunUnion union = parsed.Fields.Union.Value; + Assert.Equal(FunUnion.ItemKind.str, union.Kind); + Assert.Equal(3, union.Discriminator); + Assert.Equal("hello", union.str); + Assert.Equal("hello", union.Item3); + Assert.True(union.TryGet(out string str)); + Assert.Equal("hello", str); + + Helpers.AssertMutationWorks(option, parsed.Fields, false, f => f.Union, default); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void ValueStructMember(FlatBufferDeserializationOption option) + { + void VerifyVs(ValueStruct expected, ValueStruct actual) + { + Assert.Equal(expected.A, actual.A); + Assert.Equal(expected.B, actual.B); + Assert.Equal(expected.C(0), actual.C(0)); + Assert.Equal(expected.C(1), actual.C(1)); + } + + Root root = this.CreateRoot_ValueStructMember(out var expectedData); + Root parsed = root.SerializeAndParse(option, out var actualData); + + Helpers.AssertSequenceEqual(expectedData, actualData); + + FunUnion sourceUnion = root.Fields.Union.Value; + FunUnion union = parsed.Fields.Union.Value; + + Assert.Equal(FunUnion.ItemKind.ValueStruct, union.Kind); + Assert.Equal(2, union.Discriminator); + VerifyVs(sourceUnion.ValueStruct, union.ValueStruct); + VerifyVs(sourceUnion.Item2, union.Item2); + + Assert.True(union.TryGet(out ValueStruct test)); + VerifyVs(sourceUnion.Item2, test); + + Helpers.AssertMutationWorks(option, parsed.Fields, false, f => f.Union, default); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void RefStructMember(FlatBufferDeserializationOption option) + { + void VerifyVs(RefStruct expected, RefStruct actual) + { + Assert.Equal(expected.A, actual.A); + Assert.Equal(expected.B, actual.B); + Assert.Equal(expected.C[0], actual.C[0]); + Assert.Equal(expected.C[1], actual.C[1]); + Assert.Equal(expected.D[0], actual.D[0]); + Assert.Equal(expected.D[1], actual.D[1]); + } + + Root root = this.CreateRoot_RefStructMember(out var expectedData); + Root parsed = root.SerializeAndParse(option, out var actualData); + + Helpers.AssertSequenceEqual(expectedData, actualData); + + FunUnion sourceUnion = root.Fields.Union.Value; + FunUnion union = parsed.Fields.Union.Value; + + Assert.Equal(FunUnion.ItemKind.RefStruct, union.Kind); + Assert.Equal(1, union.Discriminator); + VerifyVs(sourceUnion.RefStruct, union.RefStruct); + VerifyVs(sourceUnion.Item1, union.Item1); + + Assert.True(union.TryGet(out RefStruct test)); + VerifyVs(sourceUnion.Item1, test); + + Helpers.AssertMutationWorks(option, parsed.Fields, false, f => f.Union, default); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void KeyTableMember(FlatBufferDeserializationOption option) + { + void VerifyVs(Key expected, Key actual) + { + Assert.Equal(expected.Name, actual.Name); + Assert.Equal(expected.Value, actual.Value); + } + + Root root = this.CreateRoot_KeyMember(out var expectedData); + Root parsed = root.SerializeAndParse(option, out var actualData); + + Helpers.AssertSequenceEqual(expectedData, actualData); + + FunUnion sourceUnion = root.Fields.Union.Value; + FunUnion union = parsed.Fields.Union.Value; + + Assert.Equal(FunUnion.ItemKind.Key, union.Kind); + Assert.Equal(4, union.Discriminator); + VerifyVs(sourceUnion.Key, union.Key); + VerifyVs(sourceUnion.Item4, union.Item4); + + Assert.True(union.TryGet(out Key test)); + VerifyVs(sourceUnion.Item4, test); + + Helpers.AssertMutationWorks(option, test, false, k => k.Name, string.Empty); + Helpers.AssertMutationWorks(option, test, false, k => k.Value, Fruit.Apple); + Helpers.AssertMutationWorks(option, parsed.Fields, false, f => f.Union, default); + + Assert.True(test.IsInitialized); + Assert.True(Key.IsStaticInitialized); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void InvalidUnion_NoOffset(FlatBufferDeserializationOption option) + { + this.Create_InvalidUnion_NoOffset(out byte[] data); + + var ex = Assert.Throws(() => + { + Root root = Root.Serializer.Parse(data, option); + FunUnion union = root.Fields.Union.Value; + }); + + Assert.Equal("FlatBuffer table property 'FlatSharpStrykerTests.Fields.Union' was only partially included in the buffer.", ex.Message); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void InvalidUnion_NoDiscriminator(FlatBufferDeserializationOption option) + { + this.Create_InvalidUnion_NoDiscriminator(out byte[] data); + + var ex = Assert.Throws(() => + { + Root root = Root.Serializer.Parse(data, option); + FunUnion union = root.Fields.Union.Value; + }); + + Assert.Equal("FlatBuffer table property 'FlatSharpStrykerTests.Fields.Union' was only partially included in the buffer.", ex.Message); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void InvalidUnion_InvalidDiscriminator(FlatBufferDeserializationOption option) + { + this.Create_InvalidUnion_InvalidDiscriminator(out byte[] data); + + var ex = Assert.Throws(() => + { + Root root = Root.Serializer.Parse(data, option); + FunUnion union = root.Fields.Union.Value; + }); + + Assert.Equal("Exception parsing union 'FlatSharpStrykerTests.FunUnion'. Discriminator = 10", ex.Message); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void UnionNotPresent(FlatBufferDeserializationOption option) + { + Root source = this.CreateRoot_UnionNotPresent(out byte[] expectedData); + Root parsed = source.SerializeAndParse(option, out byte[] buffer); + + Assert.Null(parsed.Fields.Union); + Helpers.AssertSequenceEqual(expectedData, buffer); + } + + private Root CreateRoot_UnionNotPresent(out byte[] expectedData) + { + RefStruct vs = new() + { + A = 3, + B = Fruit.Apple, + __flatsharp__C_0 = -1, + __flatsharp__C_1 = -2, + E = default, + }; + + Root root = new() + { + Fields = new() + }; + + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Fields subtable. + + // Vtable for Root (2 bytes padding) + 6, 0, 8, 0, + 4, 0, 0, 0, + + 252, 255, 255, 255, // soffset to vtable + 4, 0, 4, 0 // vtable + }; + + return root; + } + + private Root CreateRoot_RefStructMember(out byte[] expectedData) + { + RefStruct vs = new() + { + A = 3, + B = Fruit.Apple, + __flatsharp__C_0 = -1, + __flatsharp__C_1 = -2, + E = default, + }; + + Root root = new() + { + Fields = new() + { + Union = new(vs) + } + }; + + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Fields subtable. + + // Vtable for Root (2 bytes padding) + 6, 0, 8, 0, + 4, 0, 0, 0, + + 246, 255, 255, 255, // soffset to vtable + 24, 0, 0, 0, // uoffset to union + 1, 0, // ubyte discriminator, padding + + 16, 0, // vtable length + 9, 0, // table length + 0, 0, // field 0 + 0, 0, // field 1 + 0, 0, // field 2 (scalar) + 0, 0, // field 3 (str) + 8, 0, // field 4 (discriminator) + 4, 0, // field 5 (uoffset) + + 0, 0, // padding + 3, 0, 0, 0, // 3 (ulong) + 0, 0, 0, 0, + 0, 0, 0, 0, // apple + 255, 254, // C[0,1] + 0, 0, // D[0,1] + 0, 0, 0, 0, // ValueStruct (default) + 0, 0, 0, 0, + 0, 0 + }; + + return root; + } + + private Root CreateRoot_ValueStructMember(out byte[] expectedData) + { + ValueStruct vs = new() + { + A = 3, + B = 4, + }; + + vs.C(0) = 1; + vs.C(1) = 2; + + Root root = new() + { + Fields = new() + { + Union = new(vs) + } + }; + + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Fields subtable. + + // Vtable for Root (2 bytes padding) + 6, 0, 8, 0, + 4, 0, 0, 0, + + 246, 255, 255, 255, // soffset to vtable + 24, 0, 0, 0, // uoffset to union + 2, 0, // ubyte discriminator, padding + + 16, 0, // vtable length + 9, 0, // table length + 0, 0, // field 0 + 0, 0, // field 1 + 0, 0, // field 2 (scalar) + 0, 0, // field 3 (str) + 8, 0, // field 4 (discriminator) + 4, 0, // field 5 (uoffset) + + 0, 0, // padding + 3, 0, 0, 0, + 4, 0, + 1, 0, + 2, 0, + }; + + return root; + } + + private Root CreateRoot_StringMember(out byte[] expectedData) + { + static byte B(char c) => (byte)c; + + Root root = new() + { + Fields = new() + { + Union = new("hello") + } + }; + + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Fields subtable. + + // Vtable for Root (2 bytes padding) + 6, 0, 8, 0, + 4, 0, 0, 0, + + 246, 255, 255, 255, // soffset to vtable + 24, 0, 0, 0, // uoffset to union + 3, 0, // ubyte discriminator, padding + + 16, 0, // vtable length + 9, 0, // table length + 0, 0, // field 0 + 0, 0, // field 1 + 0, 0, // field 2 (scalar) + 0, 0, // field 3 (str) + 8, 0, // field 4 (discriminator) + 4, 0, // field 5 (uoffset) + + 0, 0, // padding + 5, 0, 0, 0, // string length + B('h'), B('e'), B('l'), B('l'), + B('o'), 0 + }; + + return root; + } + + private Root CreateRoot_KeyMember(out byte[] expectedData) + { + static byte B(char c) => (byte)c; + + Key key = new() + { + Name = "fred", + Value = Fruit.Banana, + }; + + Root root = new() + { + Fields = new() + { + Union = new(key) + } + }; + + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Fields subtable. + + // Vtable for Root (2 bytes padding) + 6, 0, 8, 0, + 4, 0, 0, 0, + + 246, 255, 255, 255, // soffset to vtable + 24, 0, 0, 0, // uoffset to union + 4, 0, // ubyte discriminator, padding + + 16, 0, // vtable length + 9, 0, // table length + 0, 0, // field 0 + 0, 0, // field 1 + 0, 0, // field 2 (scalar) + 0, 0, // field 3 (str) + 8, 0, // field 4 (discriminator) + 4, 0, // field 5 (uoffset) + + 0, 0, // padding + 36, 0, 0, 0, // soffset to vtable (note: vtable is shared since banana is default value) + 4, 0, 0, 0, // uoffset to string (name) + 4, 0, 0, 0, // string length + B('f'), B('r'), B('e'), B('d'), 0 + }; + + return root; + } + + private void Create_InvalidUnion_NoOffset(out byte[] data) + { + data = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Fields subtable. + + // Vtable for Root (2 bytes padding) + 6, 0, 8, 0, + 4, 0, 0, 0, + + 250, 255, 255, 255, // soffset to vtable + 4, 0, // ubyte discriminator, padding + + 14, 0, // vtable length + 5, 0, // table length + 0, 0, // field 0 + 0, 0, // field 1 + 0, 0, // field 2 (scalar) + 0, 0, // field 3 (str) + 4, 0, // field 4 (discriminator) + }; + } + + private void Create_InvalidUnion_NoDiscriminator(out byte[] data) + { + data = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Fields subtable. + + // Vtable for Root (2 bytes padding) + 6, 0, 8, 0, + 4, 0, 0, 0, + + 248, 255, 255, 255, // soffset to vtable + 4, 0, 0, 0, // union offset + + 16, 0, // vtable length + 5, 0, // table length + 0, 0, // field 0 + 0, 0, // field 1 + 0, 0, // field 2 (scalar) + 0, 0, // field 3 (str) + 0, 0, // field 4 (discriminator) + 4, 0, // field 5 (offset) + }; + } + + private void Create_InvalidUnion_InvalidDiscriminator(out byte[] data) + { + data = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Fields subtable. + + // Vtable for Root (2 bytes padding) + 6, 0, 8, 0, + 4, 0, 0, 0, + + 246, 255, 255, 255, // soffset to vtable + 4, 0, 0, 0, // union offset + 10, 0, // discriminator + padding + + 16, 0, // vtable length + 5, 0, // table length + 0, 0, // field 0 + 0, 0, // field 1 + 0, 0, // field 2 (scalar) + 0, 0, // field 3 (str) + 8, 0, // field 4 (discriminator) + 4, 0, // field 5 (offset) + }; + } +} diff --git a/src/Tests/Stryker/Tests/UnionVectorTests.cs b/src/Tests/Stryker/Tests/UnionVectorTests.cs new file mode 100644 index 00000000..8745a127 --- /dev/null +++ b/src/Tests/Stryker/Tests/UnionVectorTests.cs @@ -0,0 +1,336 @@ +using FlatSharp.Internal; +using System.IO; +using System.Linq.Expressions; +using System.Threading; + +namespace FlatSharpStrykerTests; + +public class UnionVectorTests +{ + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void UnionVector(FlatBufferDeserializationOption option) + { + Root root = CreateRoot(out byte[] expectedData); + Root parsed = root.SerializeAndParse(option, out byte[] buffer); + + Vectors vectors = parsed.Vectors; + Assert.True(vectors.IsInitialized); + Assert.True(Vectors.IsStaticInitialized); + + IList sourceUnions = root.Vectors.Union; + IList unions = vectors.Union; + + Assert.NotNull(unions); + Assert.Equal(sourceUnions.Count, unions.Count); + + for (int i = 0; i < unions.Count; ++i) + { + FunUnion left = sourceUnions[i]; + FunUnion right = unions[i]; + + Assert.Equal(sourceUnions[i].Discriminator, unions[i].Discriminator); + Assert.Equal(sourceUnions[i].Kind, unions[i].Kind); + + { + object li = left.Accept(new()); + object ri = right.Accept(new()); + + Assert.IsAssignableFrom(li.GetType(), ri); + } + + switch (left.Kind) + { + case FunUnion.ItemKind.Key: + { + Assert.Equal(left.Key.Name, right.Key.Name); + Assert.Equal(left.Item4.Value, right.Item4.Value); + + Assert.True(left.TryGet(out Key _)); + Assert.True(right.TryGet(out Key _)); + Assert.False(left.TryGet(out RefStruct _)); + Assert.False(right.TryGet(out RefStruct _)); + } + break; + + + case FunUnion.ItemKind.RefStruct: + { + Assert.Equal(left.RefStruct.A, right.RefStruct.A); + Assert.Equal(left.Item1.B, right.Item1.B); + Assert.True(left.TryGet(out RefStruct _)); + Assert.True(right.TryGet(out RefStruct _)); + Assert.False(left.TryGet(out Key _)); + Assert.False(right.TryGet(out Key _)); + } + break; + + case FunUnion.ItemKind.str: + { + Assert.Equal(left.str, right.str); + Assert.Equal(left.Item3, right.Item3); + Assert.True(left.TryGet(out string _)); + Assert.True(right.TryGet(out string _)); + Assert.False(left.TryGet(out ValueStruct _)); + Assert.False(right.TryGet(out ValueStruct _)); + } + break; + + case FunUnion.ItemKind.ValueStruct: + { + Assert.Equal(left.ValueStruct.A, right.ValueStruct.A); + Assert.Equal(left.Item2.B, right.Item2.B); + Assert.True(left.TryGet(out ValueStruct _)); + Assert.True(right.TryGet(out ValueStruct _)); + Assert.False(left.TryGet(out string _)); + Assert.False(right.TryGet(out string _)); + } + break; + } + } + + Helpers.AssertSequenceEqual(expectedData, buffer); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void UnionVector_Invalid_MissingOffset(FlatBufferDeserializationOption option) + { + CreateInvalid_MissingOffset(out byte[] buffer); + + Assert.Throws(() => + { + var item = Root.Serializer.Parse(buffer, option); + var x = item.Vectors.Union[0]; + }); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void UnionVector_Invalid_InvalidDiscriminator(FlatBufferDeserializationOption option) + { + CreateInvalid_InvalidDiscriminator(out byte[] buffer); + + var ex = Assert.Throws(() => + { + var item = Root.Serializer.Parse(buffer, option); + var x = item.Vectors.Union[0]; + }); + + Assert.Equal("Exception parsing union 'FlatSharpStrykerTests.FunUnion'. Discriminator = 7", ex.Message); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void UnionVector_Invalid_MismatchedCounts(FlatBufferDeserializationOption option) + { + CreateInvalid_MismatchedCounts(out byte[] buffer); + + var ex = Assert.Throws(() => + { + var item = Root.Serializer.Parse(buffer, option); + var x = item.Vectors.Union[0]; + }); + + Assert.Equal("Union vector had mismatched number of discriminators and offsets.", ex.Message); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void NotPresent(FlatBufferDeserializationOption option) + { + Root root = new Root() { Vectors = new() }; + Root parsed = root.SerializeAndParse(option, out byte[] buffer); + + Assert.Null(parsed.Vectors.Union); + } + + private struct Visitor : FunUnion.Visitor + { + public object Visit(RefStruct item) => item; + + public object Visit(ValueStruct item) => item; + + public object Visit(string item) => item; + + public object Visit(Key item) => item; + } + + private Root CreateRoot(out byte[] expectedData) + { + static byte B(char c) => (byte)c; + + Root root = new() + { + Vectors = new() + { + Union = Helpers.CreateList( + new FunUnion(new Key { Name = "b", Value = Fruit.Apple }), + new FunUnion(new ValueStruct { A = 1, B = 2 }), + new FunUnion(new RefStruct { A = 3, B = Fruit.Banana, __flatsharp__C_0 = 5, __flatsharp__C_1 = 6, __flatsharp__D_0 = 7, __flatsharp__D_1 = 8 }), + new FunUnion("c")) + } + }; + + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Vectors subtable. + + // Vtable for Root + 8, 0, 8, 0, + 0, 0, 4, 0, + + 244, 255, 255, 255, // soffset to vtable + 24, 0, 0, 0, // uoffset to union discriminators + 28, 0, 0, 0, // uoffset to union offsets + + 16, 0, // vtable length + 12, 0, // table length + 0, 0, // field 0 + 0, 0, // field 1 + 0, 0, // field 2 (memory) + 0, 0, // field 3 (stirng) + 4, 0, // field 4 (union vector discriminators) + 8, 0, // field 5 (union vector offsets) + + 4, 0, 0, 0, + 4, 2, 1, 3, // discriminators + + 4, 0, 0, 0, // union offsets + 16, 0, 0, 0, + 40, 0, 0, 0, + 52, 0, 0, 0, + 76, 0, 0, 0, + + 244, 255, 255, 255, // key soffset to vtable + 0, 0, 0, 0, // apple + 12, 0, 0, 0, // offset to name. + + 8, 0, 12, 0, // key vtable + 8, 0, 4, 0, + + 1, 0, 0, 0, // key name. + B('b'), 0, 0, 0, + + 1, 0, 0, 0, // valuestruct + 2, 0, 0, 0, + 0, 0, 0, 0, // end value struct + padding + + 0, 0, 0, 0, // padding to 8 byte alignment. + + 3, 0, 0, 0, // ref struct + 0, 0, 0, 0, + 1, 0, 0, 0, + 5, 6, 7, 8, + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + + 1, 0, 0, 0, // string + B('c'), 0 + }; + + return root; + } + + private void CreateInvalid_MissingOffset(out byte[] expectedData) + { + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Vectors subtable. + + // Vtable for Root + 8, 0, 8, 0, + 0, 0, 4, 0, + + 244, 255, 255, 255, // soffset to vtable + 24, 0, 0, 0, // uoffset to union discriminators + 28, 0, 0, 0, // uoffset to union offsets + + 16, 0, // vtable length + 12, 0, // table length + 0, 0, // field 0 + 0, 0, // field 1 + 0, 0, // field 2 (memory) + 0, 0, // field 3 (stirng) + 4, 0, // field 4 (union vector discriminators) + 8, 0, // field 5 (union vector offsets) + + 1, 0, 0, 0, + 4, 0, 0, 0, // discriminators + + 1, 0, 0, 0, // union offsets + 0, 0, 0, 0, + }; + } + + private void CreateInvalid_InvalidDiscriminator(out byte[] expectedData) + { + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Vectors subtable. + + // Vtable for Root + 8, 0, 8, 0, + 0, 0, 4, 0, + + 244, 255, 255, 255, // soffset to vtable + 24, 0, 0, 0, // uoffset to union discriminators + 28, 0, 0, 0, // uoffset to union offsets + + 16, 0, // vtable length + 12, 0, // table length + 0, 0, // field 0 + 0, 0, // field 1 + 0, 0, // field 2 (memory) + 0, 0, // field 3 (stirng) + 4, 0, // field 4 (union vector discriminators) + 8, 0, // field 5 (union vector offsets) + + 1, 0, 0, 0, + 7, 0, 0, 0, // discriminators + + 1, 0, 0, 0, // union offsets + 0, 0, 0, 0, + }; + } + + private void CreateInvalid_MismatchedCounts(out byte[] expectedData) + { + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Vectors subtable. + + // Vtable for Root + 8, 0, 8, 0, + 0, 0, 4, 0, + + 244, 255, 255, 255, // soffset to vtable + 24, 0, 0, 0, // uoffset to union discriminators + 28, 0, 0, 0, // uoffset to union offsets + + 16, 0, // vtable length + 12, 0, // table length + 0, 0, // field 0 + 0, 0, // field 1 + 0, 0, // field 2 (memory) + 0, 0, // field 3 (stirng) + 4, 0, // field 4 (union vector discriminators) + 8, 0, // field 5 (union vector offsets) + + 3, 0, 0, 0, + 1, 2, 3, 0, // discriminators + + 1, 0, 0, 0, // union offsets + 0, 0, 0, 0, + }; + } +} diff --git a/src/Tests/Stryker/Tests/ValueStructVectorTests.cs b/src/Tests/Stryker/Tests/ValueStructVectorTests.cs new file mode 100644 index 00000000..3e09fc49 --- /dev/null +++ b/src/Tests/Stryker/Tests/ValueStructVectorTests.cs @@ -0,0 +1,118 @@ +using FlatSharp.Internal; +using System.Linq.Expressions; +using System.Threading; + +namespace FlatSharpStrykerTests; + +public class ValueStructVectorTests +{ + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void Present(FlatBufferDeserializationOption option) + { + Root root = CreateRoot(out byte[] expectedData); + Root parsed = root.SerializeAndParse(option, out byte[] actualData); + + Assert.NotNull(parsed.Vectors.ValueStruct); + + var vsr = root.Vectors.ValueStruct; + var vsp = parsed.Vectors.ValueStruct; + + Assert.Equal(vsr.Count, vsp.Count); + + for (int i = 0; i < vsr.Count; ++i) + { + var r = vsr[i]; + var p = vsp[i]; + + Assert.Equal(r.A, p.A); + Assert.Equal(r.B, p.B); + Assert.Equal(r.C(0), p.C(0)); + Assert.Equal(r.C(1), p.C(1)); + } + + Helpers.AssertSequenceEqual(expectedData, actualData); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void Missing(FlatBufferDeserializationOption option) + { + Root root = CreateRoot_Missing(out byte[] expectedData); + root.SerializeAndParse(option, out byte[] actualData); + + Assert.Null(root.Vectors.ValueStruct); + Helpers.AssertSequenceEqual(expectedData, actualData); + } + + private Root CreateRoot(out byte[] expectedData) + { + var vs1 = new ValueStruct { A = 1, B = 2 }; + var vs2 = new ValueStruct { A = 5, B = 6 }; + + vs1.C(0) = 3; + vs1.C(1) = 4; + vs2.C(0) = 7; + vs2.C(1) = 8; + + Root root = new() + { + Vectors = new() + { + ValueStruct = Helpers.CreateList(vs1, vs2) + } + }; + + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Vectors subtable. + + // Vtable for Root + 8, 0, 8, 0, + 0, 0, 4, 0, + + 8, 0, 0, 0, // soffset to vtable (shared) + 4, 0, 0, 0, // uoffset to vector + + 2, 0, 0, 0, + + 1, 0, 0, 0, + 2, 0, 3, 0, + 4, 0, 0, 0, + + 5, 0, 0, 0, + 6, 0, 7, 0, + 8, 0, 0, 0, + }; + + return root; + } + + private Root CreateRoot_Missing(out byte[] expectedData) + { + Root root = new() + { + Vectors = new() + }; + + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Vectors subtable. + + // Vtable for Root + 8, 0, 8, 0, + 0, 0, 4, 0, + + 252, 255, 255, 255, // soffset to vtable + + 4, 0, // vtable length + 4, 0, // table length + }; + + return root; + } +} diff --git a/src/Tests/Stryker/Tests/stryker-config.json b/src/Tests/Stryker/Tests/stryker-config.json new file mode 100644 index 00000000..b7de38b4 --- /dev/null +++ b/src/Tests/Stryker/Tests/stryker-config.json @@ -0,0 +1,13 @@ +{ + "stryker-config": { + "project": "CodeGen.csproj", + + "ignore-methods": + [ + "FlatSharp.Internal.FlatSharpInternal.AssertSizeOf" // Ignore assertions. + ], + + "reporters": [ "html", "cleartext" ], + "thresholds": { "high": 90, "low": 80, "break": 80 } + } +} From 576e735d85f185080c8d7ac725cb530918b14d5e Mon Sep 17 00:00:00 2001 From: James Courtney Date: Sun, 29 Jan 2023 16:07:28 -0800 Subject: [PATCH 03/66] Exclude some progressive stuff from Stryker (#364) --- src/FlatSharp.Compiler/FlatSharpCompiler.cs | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/src/FlatSharp.Compiler/FlatSharpCompiler.cs b/src/FlatSharp.Compiler/FlatSharpCompiler.cs index 11929d08..f9101274 100644 --- a/src/FlatSharp.Compiler/FlatSharpCompiler.cs +++ b/src/FlatSharp.Compiler/FlatSharpCompiler.cs @@ -19,6 +19,7 @@ using System.Runtime.InteropServices; using System.Security.Cryptography; using System.Text; +using System.Text.RegularExpressions; using System.Threading; using CommandLine; @@ -118,7 +119,26 @@ private static int RunCompiler(CompilerOptions options) if (options.MutationTestingMode) { + string[] patterns = + { + @"\s*this\.__mask\d+\s*\|=\s*\(byte\)\d+;", + @".+AssertSizeOf.+", + }; + + foreach (var pattern in patterns) + { + Regex progressiveMaskRegex = new Regex(pattern, RegexOptions.Compiled); + cSharp = progressiveMaskRegex.Replace(cSharp, m => + { + return $$""" + {{Environment.NewLine}}//Stryker disable once all + {{m.Value}} + """; + }); + } + cSharp = cSharp.Replace("BitConverter", "MockBitConverter"); + } } catch (Exception ex) From 4163907b8415553960101690681fb89d68f92995 Mon Sep 17 00:00:00 2001 From: James Courtney Date: Mon, 30 Jan 2023 01:09:38 -0800 Subject: [PATCH 04/66] Faster Vectors (#363) Redo entire vector stack. Faster now! --- .../ExperimentalBenchmark/Benchmark.fbs | 22 +- .../ExperimentalBenchmark/Program.cs | 77 ++- .../MicroBench.6.3.3/Microbench.6.3.3.csproj | 7 +- .../Microbench.Current.csproj | 4 +- .../MicroBench.Current/ParseBenchmarks.cs | 42 +- src/Benchmarks/MicroBench.Current/Program.cs | 6 +- src/Benchmarks/Microbench.fbs | 10 +- src/FlatSharp.Compiler/FlatSharpCompiler.cs | 40 +- .../GeneratedSerializerWrapper.cs | 9 - .../IFlatBufferDeserializedVector.cs | 9 +- src/FlatSharp.Runtime/SerializationHelpers.cs | 9 + src/FlatSharp.Runtime/SortedVectorHelpers.cs | 98 +--- .../Vectors/FlatBufferIndexedVector.cs | 33 +- .../FlatBufferProgressiveIndexedVector.cs | 25 +- .../Vectors/FlatBufferProgressiveVector.cs | 274 ----------- .../Vectors/FlatBufferVectorBase.cs | 247 ---------- .../Vectors/GreedyIndexedVector.cs | 28 +- .../Vectors/IVectorItemAccessor.cs | 34 -- .../Vectors/ImmutableList.cs | 151 ------ src/FlatSharp.Runtime/Vectors/PoolableList.cs | 126 ----- .../Vectors/VectorExceptions.cs | 53 ++ .../Vectors/VectorsCommon.cs | 71 +++ src/FlatSharp/FlatBufferVectorHelpers.cs | 268 ++++++----- .../FlatBufferVectorHelpers_Greedy.cs | 131 +++++ .../FlatBufferVectorHelpers_GreedyMutable.cs | 185 +++++++ ...tBufferVectorHelpers_GreedyMutableUnion.cs | 180 +++++++ .../FlatBufferVectorHelpers_GreedyUnion.cs | 147 ++++++ src/FlatSharp/FlatBufferVectorHelpers_Lazy.cs | 137 ++++++ .../FlatBufferVectorHelpers_LazyUnion.cs | 148 ++++++ .../FlatBufferVectorHelpers_Progressive.cs | 272 +++++++++++ ...latBufferVectorHelpers_ProgressiveUnion.cs | 255 ++++++++++ src/FlatSharp/FlatSharp.csproj | 4 + src/FlatSharp/Serialization/CSharpHelpers.cs | 5 +- .../DeserializeClassDefinition.cs | 10 +- .../RoslynSerializerGenerator.cs | 4 +- src/FlatSharp/StrykerSuppressor.cs | 51 ++ src/FlatSharp/TypeModel/EnumTypeModel.cs | 5 + src/FlatSharp/TypeModel/ITypeModel.cs | 5 + src/FlatSharp/TypeModel/NullableTypeModel.cs | 5 + src/FlatSharp/TypeModel/RuntimeTypeModel.cs | 2 + src/FlatSharp/TypeModel/ScalarTypeModels.cs | 55 +++ src/FlatSharp/TypeModel/ScalarTypeModels.tt | 5 + src/FlatSharp/TypeModel/StringTypeModel.cs | 5 + src/FlatSharp/TypeModel/StructTypeModel.cs | 14 +- src/FlatSharp/TypeModel/TableMemberModel.cs | 2 + src/FlatSharp/TypeModel/TableTypeModel.cs | 12 +- src/FlatSharp/TypeModel/UnionTypeModel.cs | 6 + .../TypeModel/ValueStructTypeModel.cs | 15 +- .../Vectors/IndexedVectorTypeModel.cs | 46 +- .../TypeModel/Vectors/ListVectorTypeModel.cs | 83 +--- .../Vectors/MemoryVectorTypeModel.cs | 5 + .../UnityNativeArrayVectorTypeModel.cs | 5 + .../ListVectorOfUnionTypeModel.cs | 52 +- .../CopyConstructorTests.cs | 451 ------------------ .../ClassLib/ImmutableListTests.cs | 119 ----- .../ClassLib/PoolableListTests.cs | 148 ------ src/Tests/FlatSharpEndToEndTests/Helpers.cs | 79 ++- .../Vectors/Standard/StandardVectorTests.cs | 24 +- src/Tests/FlatSharpTests/ModuleInitializer.cs | 2 + .../TableSerializationTests.cs | 4 +- .../VectorDeserializationTests.cs | 4 +- .../SerializationTests/WriteThroughTests.cs | 2 +- src/Tests/Stryker/CodeGen/Schema.fbs | 9 +- src/Tests/Stryker/Tests/FullTreeTests.cs | 55 ++- src/Tests/Stryker/Tests/IndexedVectorTests.cs | 25 + .../Stryker/Tests/RefStructVectorTests.cs | 35 +- src/Tests/Stryker/Tests/RootObjectTests.cs | 13 + src/Tests/Stryker/Tests/StringVectorTests.cs | 55 ++- src/Tests/Stryker/Tests/StructFieldTests.cs | 22 + src/Tests/Stryker/Tests/TableVectorTests.cs | 200 ++++++++ src/Tests/Stryker/Tests/UnionFieldTests.cs | 26 + src/Tests/Stryker/Tests/UnionVectorTests.cs | 101 +++- .../Stryker/Tests/ValueStructVectorTests.cs | 71 ++- src/Tests/Stryker/Tests/stryker-config.json | 9 +- 74 files changed, 2854 insertions(+), 2094 deletions(-) delete mode 100644 src/FlatSharp.Runtime/Vectors/FlatBufferProgressiveVector.cs delete mode 100644 src/FlatSharp.Runtime/Vectors/FlatBufferVectorBase.cs delete mode 100644 src/FlatSharp.Runtime/Vectors/IVectorItemAccessor.cs delete mode 100644 src/FlatSharp.Runtime/Vectors/ImmutableList.cs delete mode 100644 src/FlatSharp.Runtime/Vectors/PoolableList.cs create mode 100644 src/FlatSharp.Runtime/Vectors/VectorExceptions.cs create mode 100644 src/FlatSharp.Runtime/Vectors/VectorsCommon.cs create mode 100644 src/FlatSharp/FlatBufferVectorHelpers_Greedy.cs create mode 100644 src/FlatSharp/FlatBufferVectorHelpers_GreedyMutable.cs create mode 100644 src/FlatSharp/FlatBufferVectorHelpers_GreedyMutableUnion.cs create mode 100644 src/FlatSharp/FlatBufferVectorHelpers_GreedyUnion.cs create mode 100644 src/FlatSharp/FlatBufferVectorHelpers_Lazy.cs create mode 100644 src/FlatSharp/FlatBufferVectorHelpers_LazyUnion.cs create mode 100644 src/FlatSharp/FlatBufferVectorHelpers_Progressive.cs create mode 100644 src/FlatSharp/FlatBufferVectorHelpers_ProgressiveUnion.cs create mode 100644 src/FlatSharp/StrykerSuppressor.cs delete mode 100644 src/Tests/FlatSharpCompilerTests/CopyConstructorTests.cs delete mode 100644 src/Tests/FlatSharpEndToEndTests/ClassLib/ImmutableListTests.cs delete mode 100644 src/Tests/FlatSharpEndToEndTests/ClassLib/PoolableListTests.cs create mode 100644 src/Tests/Stryker/Tests/RootObjectTests.cs create mode 100644 src/Tests/Stryker/Tests/TableVectorTests.cs diff --git a/src/Benchmarks/ExperimentalBenchmark/Benchmark.fbs b/src/Benchmarks/ExperimentalBenchmark/Benchmark.fbs index 047cc8d7..7b1d040b 100644 --- a/src/Benchmarks/ExperimentalBenchmark/Benchmark.fbs +++ b/src/Benchmarks/ExperimentalBenchmark/Benchmark.fbs @@ -8,30 +8,22 @@ attribute "fs_sortedVector"; attribute "fs_unsafeExternal"; attribute "fs_memoryMarshal"; attribute "fs_vector"; +attribute "fs_writeThrough"; namespace BenchmarkCore; -struct ExternalVector3(fs_unsafeExternal:"System.Numerics.Vector3", fs_valueStruct) +struct ValueStruct (fs_valueStruct) { - X : float32; - Y : float32; - Z : float32; + a : int; } -struct ExternalVectorAvx2(fs_unsafeExternal:"System.Numerics.Vector", fs_valueStruct) +struct RefStruct { - Data : [ float32 : 4 ]; -} - -table Item -{ - Key : string (key, required); - Value : int; - Vec3 : ExternalVector3; - AVX : ExternalVectorAvx2; + a : int (fs_writeThrough); } table Outer (fs_serializer:"Lazy") { - Items : [ Item ] (fs_vector:"IIndexedVector"); + value_items : [ ValueStruct ]; + ref_items : [ RefStruct ]; } \ No newline at end of file diff --git a/src/Benchmarks/ExperimentalBenchmark/Program.cs b/src/Benchmarks/ExperimentalBenchmark/Program.cs index 8f9598cd..f9aa879d 100644 --- a/src/Benchmarks/ExperimentalBenchmark/Program.cs +++ b/src/Benchmarks/ExperimentalBenchmark/Program.cs @@ -29,32 +29,83 @@ namespace BenchmarkCore { - public class Program + public class IterationTests { - public static void Main(string[] args) + public const int Length = 1000; + public byte[] buffer; + + [Params(FlatBufferDeserializationOption.Lazy, FlatBufferDeserializationOption.Progressive)] + public FlatBufferDeserializationOption Option { get; set; } + + [GlobalSetup] + public void Setup() { - IndexedVector values = new(); - for (int i = 0; i < 10000; ++i) + var outer = new Outer { RefItems = new List(), ValueItems = new List(), }; + + for (int i = 0; i < Length; ++i) { - string key = Guid.NewGuid().ToString(); - Item item = new Item() { Key = key, Value = i, Vec3 = new Vector3(i), AVX = new Vector(i) }; - values.Add(item); + outer.RefItems.Add(new RefStruct { A = i }); + outer.ValueItems.Add(new ValueStruct { A = i }); } - Outer outer = new Outer { Items = values }; - byte[] buffer = new byte[Outer.Serializer.GetMaxSize(outer)]; + buffer = new byte[Outer.Serializer.GetMaxSize(outer)]; Outer.Serializer.Write(buffer, outer); + } - var parsed = Outer.Serializer.Parse(buffer); + [Benchmark] + public int RefNormalTraversal() + { + var outer = Outer.Serializer.Parse(buffer, this.Option); int sum = 0; - foreach (var kvp in values) + IList items = outer.RefItems!; + + for (int i = 0; i < Length; ++i) { - sum += parsed.Items[kvp.Key].Value; + var item = items[i]; + item.A += 3; } - Console.WriteLine(sum); + return sum; + } + + [Benchmark] + public int ValueNormalTraversal() + { + var outer = Outer.Serializer.Parse(buffer, this.Option); + + int sum = 0; + IList items = outer.ValueItems!; + + if (items is null) + { + return sum; + } + + for (int i = 0; i < Length; ++i) + { + sum += items[i].A; + } + + return sum; + } + } + + public class Program + { + public static void Main(string[] args) + { + //BenchmarkRunner.Run(typeof(Program).Assembly); + IterationTests t = new(); + + t.Option = FlatBufferDeserializationOption.Lazy; + t.Setup(); + + while (true) + { + t.RefNormalTraversal(); + } } } } diff --git a/src/Benchmarks/MicroBench.6.3.3/Microbench.6.3.3.csproj b/src/Benchmarks/MicroBench.6.3.3/Microbench.6.3.3.csproj index f1a03e9e..f77ccb98 100644 --- a/src/Benchmarks/MicroBench.6.3.3/Microbench.6.3.3.csproj +++ b/src/Benchmarks/MicroBench.6.3.3/Microbench.6.3.3.csproj @@ -3,17 +3,18 @@ Exe - net7.0 + net7.0 false false enable + true - - + + all runtime; build; native; contentfiles; analyzers; buildtransitive diff --git a/src/Benchmarks/MicroBench.Current/Microbench.Current.csproj b/src/Benchmarks/MicroBench.Current/Microbench.Current.csproj index 7a9cb065..a7ec7568 100644 --- a/src/Benchmarks/MicroBench.Current/Microbench.Current.csproj +++ b/src/Benchmarks/MicroBench.Current/Microbench.Current.csproj @@ -3,11 +3,11 @@ Exe - net7.0 + net7.0 false false enable - $(DefineConstants);PUBLIC_IVTABLE + $(DefineConstants);PUBLIC_IVTABLE;VECTOR_VISITORS true $([System.IO.Path]::GetFullPath('$(MSBuildThisFileDirectory)\..\..\FlatSharp.Compiler\bin\$(Configuration)\net7.0\FlatSharp.Compiler.dll')) false diff --git a/src/Benchmarks/MicroBench.Current/ParseBenchmarks.cs b/src/Benchmarks/MicroBench.Current/ParseBenchmarks.cs index b46be0c9..09607579 100644 --- a/src/Benchmarks/MicroBench.Current/ParseBenchmarks.cs +++ b/src/Benchmarks/MicroBench.Current/ParseBenchmarks.cs @@ -23,17 +23,23 @@ namespace Microbench public class ParseBenchmarks { + [Params(FlatBufferDeserializationOption.Lazy, + FlatBufferDeserializationOption.Progressive, + FlatBufferDeserializationOption.Greedy, + FlatBufferDeserializationOption.GreedyMutable)] + public FlatBufferDeserializationOption Option { get; set; } + [Benchmark] public int Parse_StringTable_SingleString() { - return ParseAndTraverse(StringTable.Serializer.Parse(Constants.Buffers.StringTable_WithString)); + return ParseAndTraverse(StringTable.Serializer.Parse(Constants.Buffers.StringTable_WithString, this.Option)); } // Subtracting the vector results below from this should give the approximate overhead of using a vector. [Benchmark] public int Parse_StringTable_SingleString_Repeated() { - StringTable table = StringTable.Serializer.Parse(Constants.Buffers.StringTable_WithString); + StringTable table = StringTable.Serializer.Parse(Constants.Buffers.StringTable_WithString, this.Option); int length = 0; for (int i = 0; i < Constants.VectorLength; ++i) @@ -49,31 +55,31 @@ public int Parse_StringTable_SingleString_Repeated() [Benchmark] public int Parse_StringTable_Vector() { - return ParseAndTraverse(StringTable.Serializer.Parse(Constants.Buffers.StringTable_WithVector)); + return ParseAndTraverse(StringTable.Serializer.Parse(Constants.Buffers.StringTable_WithVector, this.Option)); } [Benchmark] public int Parse_StringTable_Empty() { - return ParseAndTraverse(StringTable.Serializer.Parse(Constants.Buffers.Stringtable_Empty)); + return ParseAndTraverse(StringTable.Serializer.Parse(Constants.Buffers.Stringtable_Empty, this.Option)); } [Benchmark] public int Parse_PrimitivesTable_Empty() { - return ParseAndTraverse(PrimitivesTable.Serializer.Parse(Constants.Buffers.PrimitivesTable_Empty)); + return ParseAndTraverse(PrimitivesTable.Serializer.Parse(Constants.Buffers.PrimitivesTable_Empty, this.Option)); } [Benchmark] public int Parse_PrimitivesTable_Full() { - return ParseAndTraverse(PrimitivesTable.Serializer.Parse(Constants.Buffers.PrimitivesTable_Full)); + return ParseAndTraverse(PrimitivesTable.Serializer.Parse(Constants.Buffers.PrimitivesTable_Full, this.Option)); } [Benchmark] public int Parse_StructTable_SingleRef() { - var st = StructsTable.Serializer.Parse(Constants.Buffers.StructTable_SingleRef); + var st = StructsTable.Serializer.Parse(Constants.Buffers.StructTable_SingleRef, this.Option); var singleRef = st.SingleRef!; int result = singleRef.Value; @@ -87,7 +93,7 @@ public int Parse_StructTable_SingleRef() [Benchmark] public void Parse_StructTable_SingleRef_WriteThrough() { - var st = StructsTable.Serializer.Parse(Constants.Buffers.StructTable_SingleRef); + var st = StructsTable.Serializer.Parse(Constants.Buffers.StructTable_SingleRef, this.Option); var singleRef = st.SingleRef!; singleRef.Value = 3; @@ -98,7 +104,7 @@ public void Parse_StructTable_SingleRef_WriteThrough() [Benchmark] public int Parse_StructTable_SingleValue() { - var st = StructsTable.Serializer.Parse(Constants.Buffers.StructTable_SingleValue); + var st = StructsTable.Serializer.Parse(Constants.Buffers.StructTable_SingleValue, this.Option); var value = st.SingleValue.Value; st.TryReturnToPool(); @@ -109,7 +115,7 @@ public int Parse_StructTable_SingleValue() [Benchmark] public void Parse_StructTable_SingleValue_WriteThrough() { - var st = StructsTable.Serializer.Parse(Constants.Buffers.StructTable_SingleValue); + var st = StructsTable.Serializer.Parse(Constants.Buffers.StructTable_SingleValue, this.Option); st.SingleValue = new ValueStruct { Value = 3 }; st.TryReturnToPool(); @@ -118,7 +124,7 @@ public void Parse_StructTable_SingleValue_WriteThrough() [Benchmark] public int Parse_StructTable_VecRef() { - var st = StructsTable.Serializer.Parse(Constants.Buffers.StructTable_VecRef); + var st = StructsTable.Serializer.Parse(Constants.Buffers.StructTable_VecRef, this.Option); int sum = 0; var vecRef = st.VecRef!; @@ -140,7 +146,7 @@ public int Parse_StructTable_VecRef() [Benchmark] public void Parse_StructTable_VecRef_WriteThrough() { - var st = StructsTable.Serializer.Parse(Constants.Buffers.StructTable_VecRef); + var st = StructsTable.Serializer.Parse(Constants.Buffers.StructTable_VecRef, this.Option); var vecRef = st.VecRef!; int count = vecRef.Count; @@ -148,7 +154,7 @@ public void Parse_StructTable_VecRef_WriteThrough() for (int i = 0; i < count; ++i) { var item = vecRef[i]; - item.Value++; + item.Value = (item.Value) + 1; //item.TryReturnToPool(); } @@ -159,7 +165,7 @@ public void Parse_StructTable_VecRef_WriteThrough() [Benchmark] public int Parse_StructTable_VecValue() { - var st = StructsTable.Serializer.Parse(Constants.Buffers.StructTable_VecValue); + var st = StructsTable.Serializer.Parse(Constants.Buffers.StructTable_VecValue, this.Option); int sum = 0; var vecValue = st.VecValue!; @@ -179,7 +185,7 @@ public int Parse_StructTable_VecValue() [Benchmark] public void Parse_StructTable_VecValue_WriteThrough() { - var st = StructsTable.Serializer.Parse(Constants.Buffers.StructTable_VecValue); + var st = StructsTable.Serializer.Parse(Constants.Buffers.StructTable_VecValue, this.Option); var vecValue = st.VecValue!; int count = vecValue.Count; @@ -198,7 +204,7 @@ public void Parse_StructTable_VecValue_WriteThrough() [Benchmark] public int ParseAndTraverse_SafeUnionVector() { - var st = UnionTable.Serializer.Parse(Constants.Buffers.UnionTable_Safe); + var st = UnionTable.Serializer.Parse(Constants.Buffers.UnionTable_Safe, this.Option); var vector = st.Safe; int count = vector!.Count; @@ -218,7 +224,7 @@ public int ParseAndTraverse_SafeUnionVector() [Benchmark] public int ParseAndTraverse_UnsafeUnionVector() { - var st = UnionTable.Serializer.Parse(Constants.Buffers.UnionTable_Unsafe); + var st = UnionTable.Serializer.Parse(Constants.Buffers.UnionTable_Unsafe, this.Option); var vector = st.Unsafe; int count = vector!.Count; @@ -238,7 +244,7 @@ public int ParseAndTraverse_UnsafeUnionVector() [Benchmark] public int ParseAndTraverse_MixedUnionVector() { - var st = UnionTable.Serializer.Parse(Constants.Buffers.UnionTable_Mixed); + var st = UnionTable.Serializer.Parse(Constants.Buffers.UnionTable_Mixed, this.Option); var vector = st.Mixed; int count = vector!.Count; diff --git a/src/Benchmarks/MicroBench.Current/Program.cs b/src/Benchmarks/MicroBench.Current/Program.cs index 0f18e517..e4495c8c 100644 --- a/src/Benchmarks/MicroBench.Current/Program.cs +++ b/src/Benchmarks/MicroBench.Current/Program.cs @@ -38,7 +38,7 @@ public static void Main(string[] args) Job job = Job.ShortRun .WithAnalyzeLaunchVariance(true) .WithLaunchCount(1) - .WithWarmupCount(2) + .WithWarmupCount(3) .WithIterationCount(6) .WithRuntime(CoreRuntime.Core70); //.WithEnvironmentVariable(new EnvironmentVariable("DOTNET_TieredPGO", "1")); @@ -55,9 +55,9 @@ public static void Main(string[] args) //.AddHardwareCounters(HardwareCounter.BranchInstructions, HardwareCounter.BranchMispredictions) .AddJob(job.DontEnforcePowerPlan()); - //summaries.Add(BenchmarkRunner.Run(typeof(SerializeBenchmarks), config)); + summaries.Add(BenchmarkRunner.Run(typeof(SerializeBenchmarks), config)); summaries.Add(BenchmarkRunner.Run(typeof(ParseBenchmarks), config)); - //summaries.Add(BenchmarkRunner.Run(typeof(SortedVectorBenchmarks), config)); + summaries.Add(BenchmarkRunner.Run(typeof(SortedVectorBenchmarks), config)); //summaries.Add(BenchmarkRunner.Run(typeof(VTableBenchmarks), config)); foreach (var item in summaries) diff --git a/src/Benchmarks/Microbench.fbs b/src/Benchmarks/Microbench.fbs index d846112e..79ac4f89 100644 --- a/src/Benchmarks/Microbench.fbs +++ b/src/Benchmarks/Microbench.fbs @@ -12,12 +12,12 @@ attribute "fs_unsafeUnion"; namespace Microbench; // Tests reading and writing a string. -table StringTable (fs_serializer:"Progressive") { +table StringTable (fs_serializer:"Lazy") { SingleString : string; Vector : [string]; } -table PrimitivesTable (fs_serializer:"Progressive") { +table PrimitivesTable (fs_serializer:"Lazy") { Bool : bool; Byte : ubyte; SByte : byte; @@ -34,7 +34,7 @@ table PrimitivesTable (fs_serializer:"Progressive") { struct RefStruct (fs_writeThrough) { Value : int; } struct ValueStruct (fs_valueStruct) { Value : int; } -table StructsTable (fs_serializer:"Progressive") +table StructsTable (fs_serializer:"Lazy") { SingleRef : RefStruct; SingleValue : ValueStruct (fs_writeThrough, required); @@ -45,7 +45,7 @@ table StructsTable (fs_serializer:"Progressive") table StringKey { Key : string (key); } table IntKey { Key : int (key); } -table SortedTable (fs_serializer:"Progressive") +table SortedTable (fs_serializer:"Lazy") { Strings : [StringKey] (fs_vector:"IIndexedVector"); Ints : [IntKey] (fs_vector:"IIndexedVector"); @@ -60,7 +60,7 @@ union UnsafeUnion (fs_unsafeUnion) { ValueStructA, ValueStructB, ValueStructC } union SafeUnion { ValueStructA, ValueStructB, ValueStructC } union MixedUnion { ValueStructA, ValueStructB, ValueStructC, Something : string } -table UnionTable (fs_serializer:"Progressive") +table UnionTable (fs_serializer:"Lazy") { Unsafe : [ UnsafeUnion ]; Safe : [ SafeUnion ]; diff --git a/src/FlatSharp.Compiler/FlatSharpCompiler.cs b/src/FlatSharp.Compiler/FlatSharpCompiler.cs index f9101274..cdfdf5d6 100644 --- a/src/FlatSharp.Compiler/FlatSharpCompiler.cs +++ b/src/FlatSharp.Compiler/FlatSharpCompiler.cs @@ -79,19 +79,19 @@ private static int RunCompiler(CompilerOptions options) Console.Error.WriteLine("FlatSharp compiler: No output directory specified."); return -1; } - + if (!string.IsNullOrEmpty(options.UnityAssemblyPath) && !File.Exists(options.UnityAssemblyPath)) { Console.Error.WriteLine("FlatSharp compiler: Unity assembly path specified does not exist."); return -1; } - // Read existing file to see if we even need to do any work. - string outputFileName = options.MutationTestingMode switch + string outputFileName = "FlatSharp.generated.cs"; + if (options.MutationTestingMode) { - true => "FlatSharp.cs", - false => "FlatSharp.generated.cs", - }; + StrykerSuppressor.IsEnabled = true; + outputFileName = "FlatSharp.cs"; + } string outputFullPath = Path.Combine(options.OutputDirectory, outputFileName); @@ -116,30 +116,6 @@ private static int RunCompiler(CompilerOptions options) try { cSharp = CreateCSharp(bfbs, inputHash, options); - - if (options.MutationTestingMode) - { - string[] patterns = - { - @"\s*this\.__mask\d+\s*\|=\s*\(byte\)\d+;", - @".+AssertSizeOf.+", - }; - - foreach (var pattern in patterns) - { - Regex progressiveMaskRegex = new Regex(pattern, RegexOptions.Compiled); - cSharp = progressiveMaskRegex.Replace(cSharp, m => - { - return $$""" - {{Environment.NewLine}}//Stryker disable once all - {{m.Value}} - """; - }); - } - - cSharp = cSharp.Replace("BitConverter", "MockBitConverter"); - - } } catch (Exception ex) { @@ -568,7 +544,7 @@ private static string CreateCSharp( } ErrorContext.Current.ThrowIfHasErrors(); - + Assembly[] additionalRefs = BuildAdditionalReferences(options); foreach (var step in steps) @@ -679,7 +655,7 @@ private static Assembly[] BuildAdditionalReferences(CompilerOptions options, IEn references.AddRange(additionalReferences); if (options.UnityAssemblyPath is not null) references.Add(Assembly.LoadFrom(options.UnityAssemblyPath)); - + return references.ToArray(); } } diff --git a/src/FlatSharp.Runtime/GeneratedSerializerWrapper.cs b/src/FlatSharp.Runtime/GeneratedSerializerWrapper.cs index a6a67e3f..14380c4f 100644 --- a/src/FlatSharp.Runtime/GeneratedSerializerWrapper.cs +++ b/src/FlatSharp.Runtime/GeneratedSerializerWrapper.cs @@ -180,10 +180,6 @@ item is IFlatBufferDeserializedObject deserializedObj && return inputBuffer.Length; } -#if DEBUG - int expectedMaxSize = this.GetMaxSize(item); -#endif - var serializationContext = SerializationContext.ThreadLocalContext.Value!; serializationContext.Reset(destination.Length); @@ -214,11 +210,6 @@ item is IFlatBufferDeserializedObject deserializedObj && throw; } -#if DEBUG - Trace.WriteLine($"Serialized Size: {serializationContext.Offset + 1}, Max Size: {expectedMaxSize}"); - Debug.Assert(serializationContext.Offset <= expectedMaxSize - 1); -#endif - return serializationContext.Offset; } diff --git a/src/FlatSharp.Runtime/IFlatBufferDeserializedVector.cs b/src/FlatSharp.Runtime/IFlatBufferDeserializedVector.cs index 0c122e60..9746ebe6 100644 --- a/src/FlatSharp.Runtime/IFlatBufferDeserializedVector.cs +++ b/src/FlatSharp.Runtime/IFlatBufferDeserializedVector.cs @@ -14,13 +14,13 @@ * limitations under the License. */ -namespace FlatSharp; +namespace FlatSharp.Internal; /// /// An interface implemented on buffer-backed Flatbuffer vectors. This interface is internal to FlatSharp and exposes some /// functionality to assist with binary searching. /// -internal interface IFlatBufferDeserializedVector +public interface IFlatBufferDeserializedVector { /// /// Gets the input buffer. @@ -37,6 +37,11 @@ internal interface IFlatBufferDeserializedVector /// int Count { get; } + /// + /// Gets the base offset of the vector. + /// + int OffsetBase { get; } + /// /// Returns the absolute position in the Input Buffer of the given index in the vector. /// diff --git a/src/FlatSharp.Runtime/SerializationHelpers.cs b/src/FlatSharp.Runtime/SerializationHelpers.cs index 5ad52842..61e86b90 100644 --- a/src/FlatSharp.Runtime/SerializationHelpers.cs +++ b/src/FlatSharp.Runtime/SerializationHelpers.cs @@ -61,6 +61,15 @@ public static int GetMaxPadding(int alignment) return alignment - 1; } + /// + /// Applies a bitwise OR to the operands. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void CombineMask(ref byte source, byte mask) + { + source |= mask; + } + /// /// Returns the number of padding bytes to be added to the given offset to acheive the given alignment. /// diff --git a/src/FlatSharp.Runtime/SortedVectorHelpers.cs b/src/FlatSharp.Runtime/SortedVectorHelpers.cs index 980d5eab..50e21658 100644 --- a/src/FlatSharp.Runtime/SortedVectorHelpers.cs +++ b/src/FlatSharp.Runtime/SortedVectorHelpers.cs @@ -34,6 +34,7 @@ of this software and associated documentation files (the "Software"), to deal using FlatSharp.Attributes; using System.Reflection; using System.Diagnostics.CodeAnalysis; +using System.Net.WebSockets; namespace FlatSharp; @@ -71,66 +72,6 @@ public static class SortedVectorHelpers } } - /// - /// Performs a binary search on the given sorted vector with the given key. The vector is presumed to be sorted. - /// - /// A value if found, null otherwise. - internal static TTable? BinarySearchByFlatBufferKey(FlatBufferVectorBase sortedVector, TKey key) - where TInputBuffer : IInputBuffer - where TItemAccessor : IVectorItemAccessor - where TTable : class, ISortableTable - where TKey : notnull - { - CheckKeyNotNull(key); - - if (key is string str) - { - using SimpleStringComparer cmp = new SimpleStringComparer(str); - - return BinarySearchByFlatBufferKey, TTable, string?, SimpleStringComparer>( - new LazyVectorIndexable(sortedVector), - sortedVector, - cmp); - } - else - { - return BinarySearchByFlatBufferKey, TTable, TKey, NaiveComparer>( - new LazyVectorIndexable(sortedVector), - sortedVector, - new NaiveComparer(key)); - } - } - - /// - /// Performs a binary search on the given sorted vector with the given key. The vector is presumed to be sorted. - /// - /// A value if found, null otherwise. - internal static TTable? BinarySearchByFlatBufferKey(FlatBufferProgressiveVector sortedVector, TKey key) - where TInputBuffer : IInputBuffer - where TItemAccessor : IVectorItemAccessor - where TTable : class, ISortableTable - where TKey : notnull - { - CheckKeyNotNull(key); - - if (key is string str) - { - using SimpleStringComparer cmp = new SimpleStringComparer(str); - - return BinarySearchByFlatBufferKey, TTable, string?, SimpleStringComparer>( - new ProgressiveVectorIndexable(sortedVector), - sortedVector, - cmp); - } - else - { - return BinarySearchByFlatBufferKey, TTable, TKey, NaiveComparer>( - new ProgressiveVectorIndexable(sortedVector), - sortedVector, - new NaiveComparer(key)); - } - } - /// /// Performs a binary search on the given sorted vector with the given key. The vector is presumed to be sorted. /// @@ -314,43 +255,6 @@ private interface IIndexable TKey KeyAt(int index); } - private struct LazyVectorIndexable : IIndexable - where TInputBuffer : IInputBuffer - where TItemAccessor : IVectorItemAccessor - { - private readonly FlatBufferVectorBase items; - - public LazyVectorIndexable(FlatBufferVectorBase items) - { - this.items = items; - } - - public T this[int index] => this.items[index]; - - public TKey KeyAt(int index) => KeyLookup.KeyGetter(this[index]); - - public int Count => this.items.Count; - } - - private struct ProgressiveVectorIndexable : IIndexable - where TInputBuffer : IInputBuffer - where TItemAccessor : IVectorItemAccessor - where T : notnull - { - private readonly FlatBufferProgressiveVector items; - - public ProgressiveVectorIndexable(FlatBufferProgressiveVector items) - { - this.items = items; - } - - public T this[int index] => this.items[index]; - - public TKey KeyAt(int index) => KeyLookup.KeyGetter(this[index]); - - public int Count => this.items.Count; - } - private struct ListIndexable : IIndexable { private readonly IList items; diff --git a/src/FlatSharp.Runtime/Vectors/FlatBufferIndexedVector.cs b/src/FlatSharp.Runtime/Vectors/FlatBufferIndexedVector.cs index 2956cb39..3aadbb6d 100644 --- a/src/FlatSharp.Runtime/Vectors/FlatBufferIndexedVector.cs +++ b/src/FlatSharp.Runtime/Vectors/FlatBufferIndexedVector.cs @@ -22,16 +22,13 @@ namespace FlatSharp.Internal; /// An implementation of IIndexedVector for use after deserializing an object. This class is not intended to be used /// directly -- only from code generated by FlatSharp. /// -public class FlatBufferIndexedVector +public class FlatBufferIndexedVector : IIndexedVector where TValue : class, ISortableTable where TKey : notnull - where TInputBuffer : IInputBuffer - where TVectorItemAccessor : IVectorItemAccessor { - private FlatBufferDeserializationOption deserializationOption; - private FlatBufferVectorBase vector; + private IList list; #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable. private FlatBufferIndexedVector() @@ -39,21 +36,14 @@ private FlatBufferIndexedVector() { } - private void Initialize(FlatBufferVectorBase vector) + public static FlatBufferIndexedVector GetOrCreate(IList list) { - this.deserializationOption = vector.DeserializationOption; - this.vector = vector; - } - - public static FlatBufferIndexedVector GetOrCreate( - FlatBufferVectorBase vector) - { - if (!ObjectPool.TryGet>(out var item)) + if (!ObjectPool.TryGet>(out var item)) { item = new(); } - item.Initialize(vector); + item.list = list; return item; } @@ -78,7 +68,7 @@ public TValue this[TKey key] /// /// Gets the count of items. /// - public int Count => this.vector.Count; + public int Count => this.list.Count; /// /// No-op. We are already immutable. @@ -94,7 +84,7 @@ public void AddOrReplace(TValue value) public IEnumerator> GetEnumerator() { - foreach (var value in this.vector) + foreach (var value in this.list) { yield return new KeyValuePair(IndexedVector.GetKey(value), value); } @@ -109,7 +99,7 @@ public bool Add(TValue value) public bool TryGetValue(TKey key, [NotNullWhen(true)] out TValue? value) { - value = SortedVectorHelpers.BinarySearchByFlatBufferKey(this.vector, key); + value = SortedVectorHelpers.BinarySearchByFlatBufferKey(this.list, key); return value is not null; } @@ -130,13 +120,12 @@ public bool Remove(TKey key) public void ReturnToPool(bool force = false) { - if (this.deserializationOption.ShouldReturnToPool(force)) + if (FlatBufferDeserializationOption.Lazy.ShouldReturnToPool(force)) { - var vec = Interlocked.Exchange(ref this.vector!, null); + var vec = Interlocked.Exchange(ref this.list!, null); if (vec is not null) { - vec.ReturnToPool(true); - this.vector = null!; + (vec as IPoolableObject)?.ReturnToPool(true); ObjectPool.Return(this); } } diff --git a/src/FlatSharp.Runtime/Vectors/FlatBufferProgressiveIndexedVector.cs b/src/FlatSharp.Runtime/Vectors/FlatBufferProgressiveIndexedVector.cs index be3d7b22..9f8e949c 100644 --- a/src/FlatSharp.Runtime/Vectors/FlatBufferProgressiveIndexedVector.cs +++ b/src/FlatSharp.Runtime/Vectors/FlatBufferProgressiveIndexedVector.cs @@ -21,18 +21,14 @@ namespace FlatSharp.Internal; /// /// An implementation that loads data progressively. /// -public sealed class FlatBufferProgressiveIndexedVector +public sealed class FlatBufferProgressiveIndexedVector : IIndexedVector where TValue : class, ISortableTable where TKey : notnull - where TInputBuffer : IInputBuffer - where TVectorItemAccessor : IVectorItemAccessor { private readonly Dictionary backingDictionary = new(); - private FlatBufferProgressiveVector backingVector; - - private FlatBufferDeserializationOption deserializationOption; + private IList backingVector; #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable. private FlatBufferProgressiveIndexedVector() @@ -40,20 +36,15 @@ private FlatBufferProgressiveIndexedVector() { } - private void Initialize(FlatBufferVectorBase items) + public static FlatBufferProgressiveIndexedVector GetOrCreate(IList items) { - this.deserializationOption = items.DeserializationOption; - this.backingVector = FlatBufferProgressiveVector.GetOrCreate(items); - } - - public static FlatBufferProgressiveIndexedVector GetOrCreate(FlatBufferVectorBase items) - { - if (!ObjectPool.TryGet>(out var item)) + if (!ObjectPool.TryGet>(out var item)) { item = new(); } - item.Initialize(items); + item.backingVector = items; + return item; } @@ -161,12 +152,12 @@ public bool Remove(TKey key) public void ReturnToPool(bool force = false) { - if (this.deserializationOption.ShouldReturnToPool(force)) + if (FlatBufferDeserializationOption.Progressive.ShouldReturnToPool(force)) { var backingVector = Interlocked.Exchange(ref this.backingVector!, null); if (backingVector is not null) { - backingVector.ReturnToPool(true); + (backingVector as IPoolableObject)?.ReturnToPool(true); this.backingDictionary.Clear(); ObjectPool.Return(this); diff --git a/src/FlatSharp.Runtime/Vectors/FlatBufferProgressiveVector.cs b/src/FlatSharp.Runtime/Vectors/FlatBufferProgressiveVector.cs deleted file mode 100644 index 5f853a0f..00000000 --- a/src/FlatSharp.Runtime/Vectors/FlatBufferProgressiveVector.cs +++ /dev/null @@ -1,274 +0,0 @@ -/* - * Copyright 2020 James Courtney - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -using System.Buffers; -using System.Threading; - -namespace FlatSharp.Internal; - -/// -/// A vector implementation that is filled on demand. Optimized -/// for data locality, random access, and reasonably low memory overhead. -/// -public sealed class FlatBufferProgressiveVector - : IList - , IReadOnlyList - , IPoolableObject - - where T : notnull - where TInputBuffer : IInputBuffer - where TVectorItemAccessor : IVectorItemAccessor -{ - // The chunk size here matches the number of bits in the presenceMask array below. - private const uint ChunkSize = 32; - - // A semi-sparse array. Each row contains ChunkSize items. - // This approach allows fast access while not broadly over allocating. - // Using "mini arrays" also ensures good sequential access performance. - private T?[]?[] items; - private FlatBufferVectorBase innerVector; - -#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable. - private FlatBufferProgressiveVector() - { - } -#pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable. - - private void Initialize(FlatBufferVectorBase innerVector) - { - this.Count = innerVector.Count; - this.innerVector = innerVector; - this.DeserializationOption = innerVector.DeserializationOption; - int minLength = (int)(innerVector.Count / ChunkSize + 1); - this.items = ArrayPool.Shared.Rent(minLength); - } - - public static FlatBufferProgressiveVector GetOrCreate(FlatBufferVectorBase innerVector) - { - if (!ObjectPool.TryGet>(out var item)) - { - item = new FlatBufferProgressiveVector(); - } - - item.Initialize(innerVector); - - return item; - } - - /// - /// Gets or sets the item at the given index. - /// - public T this[int index] - { - get - { - uint uindex = (uint)index; - if (uindex >= this.Count) - { - throw new IndexOutOfRangeException(); - } - - GetAddress(uindex, out uint rowIndex, out uint colIndex); - - T?[]?[] items = this.items; - T?[]? row = this.GetOrCreateRow(items, rowIndex); - T? item = row[colIndex]; - - if (!typeof(T).IsValueType) - { - if (item is null) - { - item = this.innerVector[index]; - row[colIndex] = item; - } - } - - return item!; - } - - set - { - // Let inner vector do the validation of the index. - this.innerVector[index] = value; - - GetAddress((uint)index, out uint rowIndex, out uint colIndex); - - T?[]?[] items = this.items; - T?[] row = this.GetOrCreateRow(items, rowIndex); - row[colIndex] = value; - } - } - - public int Count { get; private set; } - - public bool IsReadOnly => true; - - internal FlatBufferDeserializationOption DeserializationOption { get; private set; } - - public void Add(T item) - { - throw new NotMutableException("FlatBufferVector does not allow adding items."); - } - - public void Clear() - { - throw new NotMutableException("FlatBufferVector does not support clearing."); - } - - public bool Contains(T? item) - { - return this.IndexOf(item) >= 0; - } - - public void CopyTo(T[]? array, int arrayIndex) - { - if (array is null) - { - throw new ArgumentNullException(); - } - - int count = this.Count; - for (int i = 0; i < count; ++i) - { - array[arrayIndex + i] = this[i]; - } - } - - public IEnumerator GetEnumerator() - { - int count = this.Count; - for (int i = 0; i < count; ++i) - { - yield return this[i]; - } - } - - public int IndexOf(T? item) - { - // FlatBuffer vectors are not allowed to have null by definition. - if (item is null) - { - return -1; - } - - int count = this.Count; - for (int i = 0; i < count; ++i) - { - if (item.Equals(this[i])) - { - return i; - } - } - - return -1; - } - - public void Insert(int index, T item) - { - throw new NotMutableException("FlatBufferVector does not support inserting."); - } - - public bool Remove(T item) - { - throw new NotMutableException("FlatBufferVector does not support removing."); - } - - public void RemoveAt(int index) - { - throw new NotMutableException("FlatBufferVector does not support removing."); - } - - IEnumerator IEnumerable.GetEnumerator() - { - return this.GetEnumerator(); - } - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static void GetAddress(uint index, out uint rowIndex, out uint colIndex) - { - rowIndex = index / ChunkSize; - colIndex = index % ChunkSize; - } - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private T?[] GetOrCreateRow(T?[]?[] items, uint rowIndex) - { - T?[]? row = items[rowIndex]; - - if (row is null) - { - row = ArrayPool.Shared.Rent((int)ChunkSize); - items[rowIndex] = row; - - // For value types -- we can't rely on null to tell - // us if the value is allocated or not, so just greedily - // allocate the whole chunk. Chunks are relatively - // small, so the overhead here is not enormous, and there - // is no extra allocation since this is a value type. - if (typeof(T).IsValueType) - { - int rowStartIndex = checked((int)(ChunkSize * rowIndex)); - this.innerVector.CopyRangeTo(rowStartIndex, row, ChunkSize); - } - } - - return row; - } - - public void ReturnToPool(bool force = false) - { - if (this.DeserializationOption.ShouldReturnToPool(force)) - { - T?[]?[]? items = Interlocked.Exchange(ref this.items!, null); - - if (items is null) - { - return; - } - - for (int i = 0; i < items.Length; ++i) - { - T?[]? block = items[i]; - - if (block is not null) - { - // For reference types, we should try to return them. - if (!typeof(T).IsValueType && typeof(IPoolableObject).IsAssignableFrom(typeof(T))) - { - for (int j = 0; j < block.Length; ++j) - { - if (block[j] is IPoolableObject poolable) - { - poolable.ReturnToPool(true); - } - } - } - - ArrayPool.Shared.Return(block, true); - items[i] = null; - } - } - - ArrayPool.Shared.Return(items); - - this.Count = 0; - this.innerVector.ReturnToPool(true); - this.innerVector = default!; - - ObjectPool.Return(this); - } - } -} diff --git a/src/FlatSharp.Runtime/Vectors/FlatBufferVectorBase.cs b/src/FlatSharp.Runtime/Vectors/FlatBufferVectorBase.cs deleted file mode 100644 index a088029d..00000000 --- a/src/FlatSharp.Runtime/Vectors/FlatBufferVectorBase.cs +++ /dev/null @@ -1,247 +0,0 @@ -/* - * Copyright 2021 James Courtney - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -using System.Threading; - -namespace FlatSharp.Internal; - -/// -/// A base flat buffer vector, common to standard vectors and unions. -/// -public sealed class FlatBufferVectorBase - : IList - , IReadOnlyList - , IFlatBufferDeserializedVector - , IPoolableObject - - where TInputBuffer : IInputBuffer - where TItemAccessor : IVectorItemAccessor -{ - private TInputBuffer memory; - private TableFieldContext fieldContext; - private short remainingDepth; - private TItemAccessor itemAccessor; - -#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable. - private FlatBufferVectorBase() -#pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable. - { - } - - private void Initialize( - TInputBuffer memory, - TItemAccessor itemAccessor, - short remainingDepth, - TableFieldContext fieldContext, - FlatBufferDeserializationOption option) - { - this.memory = memory; - this.remainingDepth = remainingDepth; - this.itemAccessor = itemAccessor; - this.DeserializationOption = option; - this.fieldContext = fieldContext; - } - - public static FlatBufferVectorBase GetOrCreate( - TInputBuffer memory, - TItemAccessor itemAccessor, - short remainingDepth, - TableFieldContext fieldContext, - FlatBufferDeserializationOption option) - { - if (!ObjectPool.TryGet>(out var item)) - { - item = new FlatBufferVectorBase(); - } - - item.Initialize(memory, itemAccessor, remainingDepth, fieldContext, option); - - return item; - } - - /// - /// Gets the item at the given index. - /// - public T this[int index] - { - get - { - this.CheckIndex(index); - this.itemAccessor.ParseItem(index, this.memory, this.remainingDepth, this.fieldContext, out T item); - return item; - } - set - { - this.CheckIndex(index); - this.itemAccessor.WriteThrough(index, value, this.memory, this.fieldContext); - } - } - - public FlatBufferDeserializationOption DeserializationOption { get; private set; } - - public int Count => this.itemAccessor.Count; - - public bool IsReadOnly => true; - - IInputBuffer IFlatBufferDeserializedVector.InputBuffer => this.memory; - - int IFlatBufferDeserializedVector.ItemSize => this.itemAccessor.ItemSize; - - int IFlatBufferDeserializedVector.Count => this.Count; - - public bool Contains(T? item) - { - return this.IndexOf(item) >= 0; - } - - public void CopyTo(T[]? array, int arrayIndex) - { - if (array is null) - { - throw new ArgumentNullException(nameof(array)); - } - - var count = this.Count; - var context = this.fieldContext; - var remainingDepth = this.remainingDepth; - var buffer = this.memory; - - for (int i = 0; i < count; ++i) - { - this.itemAccessor.ParseItem(i, buffer, remainingDepth, context, out array[arrayIndex + i]); - } - } - - internal void CopyRangeTo(int startIndex, T?[] array, uint count) - { - if (startIndex < 0) - { - throw new ArgumentOutOfRangeException(); - } - - // might have more elements than we do. - count = Math.Min( - checked((uint)(this.Count - startIndex)), - count); - - var context = this.fieldContext; - var remainingDepth = this.remainingDepth; - var buffer = this.memory; - - for (int i = 0; i < count; ++i) - { - this.itemAccessor.ParseItem(i + startIndex, buffer, remainingDepth, context, out array[i]); - } - } - - public IEnumerator GetEnumerator() - { - int count = this.Count; - var context = this.fieldContext; - var remainingDepth = this.remainingDepth; - var buffer = this.memory; - - for (int i = 0; i < count; ++i) - { - this.itemAccessor.ParseItem(i, buffer, remainingDepth, context, out T parsed); - yield return parsed; - } - } - - public int IndexOf(T? item) - { - // FlatBuffer vectors are not allowed to have null by definition. - if (item is null) - { - return -1; - } - - var context = this.fieldContext; - var remainingDepth = this.remainingDepth; - var buffer = this.memory; - - int count = this.Count; - for (int i = 0; i < count; ++i) - { - this.itemAccessor.ParseItem(i, buffer, remainingDepth, context, out T parsed); - if (item.Equals(parsed)) - { - return i; - } - } - - return -1; - } - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private void CheckIndex(int index) - { - if ((uint)index >= this.Count) - { - throw new IndexOutOfRangeException(); - } - } - - public void Add(T item) - { - throw new NotMutableException("FlatBufferVector does not allow adding items."); - } - - public void Clear() - { - throw new NotMutableException("FlatBufferVector does not support clearing."); - } - - public void Insert(int index, T item) - { - throw new NotMutableException("FlatBufferVector does not support inserting."); - } - - public bool Remove(T item) - { - throw new NotMutableException("FlatBufferVector does not support removing."); - } - - public void RemoveAt(int index) - { - throw new NotMutableException("FlatBufferVector does not support removing."); - } - - [ExcludeFromCodeCoverage] - IEnumerator IEnumerable.GetEnumerator() - { - return this.GetEnumerator(); - } - - int IFlatBufferDeserializedVector.OffsetOf(int index) => this.itemAccessor.OffsetOf(index); - - object IFlatBufferDeserializedVector.ItemAt(int index) => this[index]!; - - public void ReturnToPool(bool force = false) - { - if (this.DeserializationOption.ShouldReturnToPool(force)) - { - var context = Interlocked.Exchange(ref this.fieldContext!, null); - if (context is not null) - { - this.memory = default!; - this.remainingDepth = default; - this.itemAccessor = default!; - ObjectPool.Return(this); - } - } - } -} diff --git a/src/FlatSharp.Runtime/Vectors/GreedyIndexedVector.cs b/src/FlatSharp.Runtime/Vectors/GreedyIndexedVector.cs index 7527ab92..b23d4886 100644 --- a/src/FlatSharp.Runtime/Vectors/GreedyIndexedVector.cs +++ b/src/FlatSharp.Runtime/Vectors/GreedyIndexedVector.cs @@ -14,6 +14,7 @@ * limitations under the License. */ +using System.Collections.Generic; using System.Threading; namespace FlatSharp.Internal; @@ -24,48 +25,47 @@ public sealed class GreedyIndexedVector : IIndexedVector backingDictionary; + private IList backingVector; // hang on until we return to pool. private bool mutable; private GreedyIndexedVector() { this.backingDictionary = new Dictionary(); + this.backingVector = null!; this.mutable = true; } - public static GreedyIndexedVector GetOrCreate( - FlatBufferVectorBase backing, - bool mutable) - where TInputBuffer : IInputBuffer - where TItemAccessor : IVectorItemAccessor + public static GreedyIndexedVector GetOrCreate(IList backing, bool mutable) { if (!ObjectPool.TryGet(out GreedyIndexedVector? vector)) { vector = new(); } + vector.backingVector = backing; vector.mutable = mutable; vector.alive = 1; - var dict = vector.backingDictionary; + var dictionary = vector.backingDictionary; #if !NETSTANDARD2_0 - dict.EnsureCapacity(backing.Count); + dictionary.EnsureCapacity(backing.Count); #endif - foreach (TValue value in backing) + int count = backing.Count; + for (int i = 0; i < count; ++i) { + TValue value = backing[i]; TKey key = SortedVectorHelpers.KeyLookup.KeyGetter(value); - if (dict.TryGetValue(key, out var existingValue)) + + if (dictionary.TryGetValue(key, out var existingValue)) { (existingValue as IPoolableObject)?.ReturnToPool(); } - dict[key] = value; + dictionary[key] = value; } - // we don't need "backing" any longer - backing.ReturnToPool(true); - return vector; } @@ -200,6 +200,8 @@ public void ReturnToPool(bool unsafeForce = false) dict.Clear(); this.mutable = false; + (this.backingVector as IPoolableObject)?.ReturnToPool(true); + this.backingVector = null!; ObjectPool.Return(this); } diff --git a/src/FlatSharp.Runtime/Vectors/IVectorItemAccessor.cs b/src/FlatSharp.Runtime/Vectors/IVectorItemAccessor.cs deleted file mode 100644 index 5fae487f..00000000 --- a/src/FlatSharp.Runtime/Vectors/IVectorItemAccessor.cs +++ /dev/null @@ -1,34 +0,0 @@ -/* - * Copyright 2022 James Courtney - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -namespace FlatSharp.Internal; - -/// -/// Small interface for reading and writing to/from vectors. Implementations should -/// prefer using a struct as that will enable devirtualization. -/// -public interface IVectorItemAccessor -{ - int Count { get; } - - int ItemSize { get; } - - void ParseItem(int index, TInputBuffer buffer, short remainingDepth, TableFieldContext context, out TItem item); - - void WriteThrough(int index, TItem value, TInputBuffer inputBuffer, TableFieldContext context); - - int OffsetOf(int index); -} diff --git a/src/FlatSharp.Runtime/Vectors/ImmutableList.cs b/src/FlatSharp.Runtime/Vectors/ImmutableList.cs deleted file mode 100644 index 090d1af1..00000000 --- a/src/FlatSharp.Runtime/Vectors/ImmutableList.cs +++ /dev/null @@ -1,151 +0,0 @@ -/* - * Copyright 2022 James Courtney - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -using System.Buffers; -using System.Linq; -using System.Threading; - -namespace FlatSharp.Internal; - -/// -/// An immutable wrapper around a List{T}. -/// -/// -/// This class serves broadly the same purpose as . -/// However, it is superior for two reasons: -/// - First, it throws the FlatSharp NotMutableException, which is consistent with Lazy and Progressive Deserialization modes -/// - Second, it does not reference internally, which means it is able to skip a level of virtual indirection -/// by using [] directly. -/// -public sealed class ImmutableList : IList, IReadOnlyList, IPoolableObject -{ - private List list; - private int isAlive; - - public ImmutableList(IList template) - { - this.list = template.ToList(); - } - - public ImmutableList(int capacity) - { - this.list = new List(capacity); - } - - public static ImmutableList GetOrCreate(FlatBufferVectorBase vector) - where TInputBuffer : IInputBuffer - where TItemAccessor : IVectorItemAccessor - { - int count = vector.Count; - - if (ObjectPool.TryGet(out ImmutableList? list)) - { -#if NET6_0_OR_GREATER - list.list.EnsureCapacity(count); -#endif - } - else - { - list = new(count); - } - - list.isAlive = 1; - - for (int i = 0; i < count; ++i) - { - list.list.Add(vector[i]); - } - - // We've copied our stuff -- send the base vector back to where it came from! - vector.ReturnToPool(true); - - return list; - } - - public T this[int index] - { - get => this.list[index]; - set => throw new NotMutableException(); - } - - public int Count => this.list.Count; - - public bool IsReadOnly => true; - - public void Add(T item) - { - throw new NotMutableException(); - } - - public void Clear() - { - throw new NotMutableException(); - } - - public bool Contains(T item) => this.list.Contains(item); - - public void CopyTo(T[] array, int arrayIndex) => this.list.CopyTo(array, arrayIndex); - - public IEnumerator GetEnumerator() - { - return this.list.GetEnumerator(); - } - - public int IndexOf(T item) => this.list.IndexOf(item); - - public void Insert(int index, T item) - { - throw new NotMutableException(); - } - - public bool Remove(T item) - { - throw new NotMutableException(); - } - - public void RemoveAt(int index) - { - throw new NotMutableException(); - } - - public void ReturnToPool(bool force) - { - if (force) - { - if (Interlocked.Exchange(ref this.isAlive, 0) != 0) - { - if (!typeof(T).IsValueType) - { - foreach (var item in this.list) - { - if (item is IPoolableObject poolable) - { - poolable.ReturnToPool(true); - } - } - } - - this.list.Clear(); - ObjectPool.Return(this); - } - } - } - - IEnumerator IEnumerable.GetEnumerator() - { - return this.GetEnumerator(); - } -} \ No newline at end of file diff --git a/src/FlatSharp.Runtime/Vectors/PoolableList.cs b/src/FlatSharp.Runtime/Vectors/PoolableList.cs deleted file mode 100644 index fc85c831..00000000 --- a/src/FlatSharp.Runtime/Vectors/PoolableList.cs +++ /dev/null @@ -1,126 +0,0 @@ -/* - * Copyright 2022 James Courtney - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -using System.Linq; -using System.Threading; - -namespace FlatSharp.Internal; - -/// -/// A wrapper around a List{T}. -/// -public sealed class PoolableList : IList, IReadOnlyList, IPoolableObject -{ - private List list; - private int isAlive; - - public PoolableList(IList template) - { - this.list = template.ToList(); - } - - public PoolableList(int capacity) - { - this.list = new(capacity); - } - - public static PoolableList GetOrCreate(FlatBufferVectorBase item) - where TInputBuffer : IInputBuffer - where TItemAccessor : IVectorItemAccessor - { - int count = item.Count; - - if (ObjectPool.TryGet(out PoolableList? list)) - { -#if NET6_0_OR_GREATER - list.list.EnsureCapacity(count); -#endif - } - else - { - list = new(count); - } - - list.isAlive = 1; - - for (int i = 0; i < count; ++i) - { - list.Add(item[i]); - } - - // We've copied our stuff -- send the base vector back to where it came from! - item.ReturnToPool(true); - - return list; - } - - public T this[int index] - { - get => this.list[index]; - set => this.list[index] = value; - } - - public int Count => this.list.Count; - - public bool IsReadOnly => false; - - public void Add(T item) => this.list.Add(item); - - public void Clear() => this.list.Clear(); - - public bool Contains(T item) => this.list.Contains(item); - - public void CopyTo(T[] array, int arrayIndex) => this.list.CopyTo(array, arrayIndex); - - public IEnumerator GetEnumerator() => this.list.GetEnumerator(); - - public int IndexOf(T item) => this.list.IndexOf(item); - - public void Insert(int index, T item) => this.list.Insert(index, item); - - public bool Remove(T item) => this.list.Remove(item); - - public void RemoveAt(int index) => this.list.RemoveAt(index); - - public void ReturnToPool(bool force) - { - if (force) - { - var isAlive = Interlocked.Exchange(ref this.isAlive, 0); - if (isAlive != 0) - { - if (!typeof(T).IsValueType) - { - foreach (var item in this.list) - { - if (item is IPoolableObject poolable) - { - poolable.ReturnToPool(true); - } - } - } - - this.list.Clear(); - ObjectPool.Return(this); - } - } - } - - IEnumerator IEnumerable.GetEnumerator() - { - return this.GetEnumerator(); - } -} \ No newline at end of file diff --git a/src/FlatSharp.Runtime/Vectors/VectorExceptions.cs b/src/FlatSharp.Runtime/Vectors/VectorExceptions.cs new file mode 100644 index 00000000..dc968666 --- /dev/null +++ b/src/FlatSharp.Runtime/Vectors/VectorExceptions.cs @@ -0,0 +1,53 @@ +/* + * Copyright 2021 James Courtney + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +namespace FlatSharp.Internal; + +public static class VectorUtilities +{ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void CheckIndex(int index, int count) + { + if ((uint)index >= count) + { + throw new IndexOutOfRangeException(); + } + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public static void ThrowIndexOutOfRange() + { + throw new IndexOutOfRangeException(); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool ThrowInlineNotMutableException() + { + throw new NotMutableException("FlatBufferVector does not support this operation."); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public static bool ThrowNotMutableException() + { + throw new NotMutableException("FlatBufferVector does not support this operation."); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public static void ThrowGreedyMutableWriteThroughNotSupportedException() + { + throw new NotMutableException("WriteThrough fields are implemented as readonly when using 'GreedyMutable' serializers."); + } +} \ No newline at end of file diff --git a/src/FlatSharp.Runtime/Vectors/VectorsCommon.cs b/src/FlatSharp.Runtime/Vectors/VectorsCommon.cs new file mode 100644 index 00000000..4734b615 --- /dev/null +++ b/src/FlatSharp.Runtime/Vectors/VectorsCommon.cs @@ -0,0 +1,71 @@ +/* + * Copyright 2023 James Courtney + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +namespace FlatSharp.Internal; + +/// +/// Common methods for all vectors. +/// +public static class VectorsCommon +{ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int IndexOf(IList vector, T? item) + { + if (!typeof(T).IsValueType) + { + if (item is null) + { + return -1; + } + } + + int count = vector.Count; + for (int i = 0; i < count; ++i) + { + if (item!.Equals(vector[i])) + { + return i; + } + } + + return -1; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void CopyTo(IList vector, T[]? array, int arrayIndex) + { + if (array is null) + { + throw new ArgumentNullException(nameof(array)); + } + + var count = vector.Count; + for (int i = 0; i < count; ++i) + { + array[arrayIndex + i] = vector[i]; + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static IEnumerator GetEnumerator(IList vector) + { + int count = vector.Count; + for (int i = 0; i < count; ++i) + { + yield return vector[i]; + } + } +} \ No newline at end of file diff --git a/src/FlatSharp/FlatBufferVectorHelpers.cs b/src/FlatSharp/FlatBufferVectorHelpers.cs index a46e347b..56030433 100644 --- a/src/FlatSharp/FlatBufferVectorHelpers.cs +++ b/src/FlatSharp/FlatBufferVectorHelpers.cs @@ -15,153 +15,165 @@ */ using System.IO; +using System.Linq; +using System.Numerics; +using System.Security.Cryptography; +using System.Text; namespace FlatSharp.TypeModel; -internal static class FlatBufferVectorHelpers +internal static partial class FlatBufferVectorHelpers { - public static (string classDef, string className) CreateVectorItemAccessor( + private static string If(bool condition, string value) + { + if (condition) + { + return value; + } + + return string.Empty; + } + + private static string IfNot(bool condition, string value) + { + return If(!condition, value); + } + + private static string CreateVectorClassName(ITypeModel itemModel, FlatBufferDeserializationOption option) + { + // Horribly inefficient + using SHA256 sha = SHA256.Create(); + byte[] hash = sha.ComputeHash(Encoding.UTF8.GetBytes(itemModel.GetCompilableTypeName())); + Guid g = new Guid(hash.Take(16).ToArray()); + + return $"GeneratedVector_{g:n}_{option}"; + } + + private static string GetNullableReferenceAnnotation(ITypeModel model) + { + return model.ClrType.IsValueType + ? string.Empty + : "?"; + } + + public static string CreateCommonReadOnlyVectorMethods( ITypeModel itemTypeModel, + string derivedTypeName) + { + string baseTypeName = itemTypeModel.GetGlobalCompilableTypeName(); + string nullableReference = GetNullableReferenceAnnotation(itemTypeModel); + + return $$""" + public bool Contains({{baseTypeName}}{{nullableReference}} item) => this.IndexOf(item) >= 0; + + public int IndexOf({{baseTypeName}}{{nullableReference}} item) + => {{typeof(VectorsCommon).GetGlobalCompilableTypeName()}}.IndexOf(this, item); + + public void CopyTo({{baseTypeName}}[]? array, int arrayIndex) + => {{typeof(VectorsCommon).GetGlobalCompilableTypeName()}}.CopyTo(this, array, arrayIndex); + + public IEnumerator<{{baseTypeName}}> GetEnumerator() + => {{typeof(VectorsCommon).GetGlobalCompilableTypeName()}}.GetEnumerator(this); + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => this.GetEnumerator(); + """; + } + + private static string GetEfficientMultiply( int inlineSize, - ParserCodeGenContext context, - bool isEverWriteThrough) + string indexVariableName) { - string className = $"ItemAccessor_{Guid.NewGuid():n}"; - string itemTypeName = itemTypeModel.GetGlobalCompilableTypeName(); + FlatSharpInternal.Assert(inlineSize != 0, "invalid inline size"); + bool isPowerOf2 = (inlineSize & (inlineSize - 1)) == 0; + if (!isPowerOf2) + { + // Slow multiply. + return $"{inlineSize} * {indexVariableName}"; + } - context = context with + int mask = inlineSize; + int shift = 0; + while (mask > 1) { - InputBufferTypeName = "TInputBuffer", - InputBufferVariableName = "buffer", - IsOffsetByRef = false, - TableFieldContextVariableName = "fieldContext", - RemainingDepthVariableName = "remainingDepth", - }; - - var serializeContext = context.GetWriteThroughContext("data", "item", "0"); - string writeThroughBody = $"throw new NotMutableException(\"FlatBufferVector does not support mutation.\");"; + mask >>= 1; + shift++; + } + + FlatSharpInternal.Assert((1 << shift) == inlineSize, $"expected to recompute inlinesize. Expected = {inlineSize}, Actual = {(1 << shift)}"); + return $"{indexVariableName} << {shift}"; + } + + private static string CreateIFlatBufferDeserializedVectorMethods( + int inlineSize, + string inputBufferVariableName, + string offsetVariableName, + string checkedParseItemMethodName) + { + return + $$""" + IInputBuffer IFlatBufferDeserializedVector.InputBuffer => this.{{inputBufferVariableName}}; + + int IFlatBufferDeserializedVector.ItemSize => {{inlineSize}}; + + int IFlatBufferDeserializedVector.OffsetBase => this.{{offsetVariableName}}; + + object IFlatBufferDeserializedVector.ItemAt(int index) => this.{{checkedParseItemMethodName}}(index)!; + + int IFlatBufferDeserializedVector.OffsetOf(int index) + { + {{nameof(VectorUtilities)}}.{{nameof(VectorUtilities.CheckIndex)}}(index, this.Count); + return this.{{offsetVariableName}} + ({{GetEfficientMultiply(inlineSize, "index")}}); + } + """; + } + + private static string CreateImmutableVectorMethods( + ITypeModel itemTypeModel) + { + string baseTypeName = itemTypeModel.GetGlobalCompilableTypeName(); + string nullableReference = GetNullableReferenceAnnotation(itemTypeModel); + + return + $$""" + public bool IsReadOnly => true; + + public void Add({{baseTypeName}} item) => {{nameof(VectorUtilities)}}.{{nameof(VectorUtilities.ThrowInlineNotMutableException)}}(); + public void Clear() => {{nameof(VectorUtilities)}}.{{nameof(VectorUtilities.ThrowInlineNotMutableException)}}(); + public void Insert(int index, {{baseTypeName}} item) => {{nameof(VectorUtilities)}}.{{nameof(VectorUtilities.ThrowInlineNotMutableException)}}(); + public void RemoveAt(int index) => {{nameof(VectorUtilities)}}.{{nameof(VectorUtilities.ThrowInlineNotMutableException)}}(); + public bool Remove({{baseTypeName}} item) => {{nameof(VectorUtilities)}}.{{nameof(VectorUtilities.ThrowInlineNotMutableException)}}(); + """; + } + + public static string CreateWriteThroughMethod( + ITypeModel itemTypeModel, + int inlineSize, + ParserCodeGenContext context, + bool isEverWriteThrough) + { + string writeThroughBody = $"{nameof(VectorUtilities)}.{nameof(VectorUtilities.ThrowInlineNotMutableException)}();"; if (isEverWriteThrough) { + var serializeContext = context.GetWriteThroughContext("data", "value", "0"); + writeThroughBody = @$" - if (!context.WriteThrough) + if (!{context.TableFieldContextVariableName}.WriteThrough) {{ - {writeThroughBody} + {nameof(VectorUtilities)}.{nameof(VectorUtilities.ThrowNotMutableException)}(); }} - int offset = checked(this.offset + ({inlineSize} * index)); - Span {serializeContext.SpanVariableName} = inputBuffer.GetSpan().Slice(offset, {inlineSize}); + int offset = this.offset + ({GetEfficientMultiply(inlineSize, "index")}); + Span {serializeContext.SpanVariableName} = {context.InputBufferVariableName}.GetSpan().Slice(offset, {inlineSize}); {serializeContext.GetSerializeInvocation(itemTypeModel.ClrType)}; "; } - string body = $@" - -internal struct {className}<{context.InputBufferTypeName}> : IVectorItemAccessor<{itemTypeName}, {context.InputBufferTypeName}> - where {context.InputBufferTypeName} : IInputBuffer -{{ - private readonly int offset; - private readonly int count; - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public {className}(int offset, TInputBuffer buffer) - {{ - this.count = (int)buffer.ReadUInt(offset); - - // Advance to the start of the element at index 0. Easiest to do this once - // in the .ctor than repeatedly for each index. - this.offset = offset + sizeof(uint); - }} - - public int ItemSize => {inlineSize}; - - public int Count => this.count; - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public void ParseItem(int index, {context.InputBufferTypeName} {context.InputBufferVariableName}, short {context.RemainingDepthVariableName}, TableFieldContext {context.TableFieldContextVariableName}, out {itemTypeName} item) - {{ - int {context.OffsetVariableName} = this.offset + ({inlineSize} * index); - item = {context.GetParseInvocation(itemTypeModel.ClrType)}; - }} - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public void WriteThrough(int index, {itemTypeName} {serializeContext.ValueVariableName}, {context.InputBufferTypeName} inputBuffer, TableFieldContext context) - {{ - {writeThroughBody} - }} - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public int OffsetOf(int index) => this.offset + ({inlineSize} * index); -}}"; - return (body, className); - } - - public static (string classDef, string className) CreateVectorOfUnionItemAccessor( - ITypeModel typeModel, - ParserCodeGenContext context) - { - string className = $"FlatBufferUnionVectorAccessor_{Guid.NewGuid():n}"; - string itemTypeName = typeModel.GetGlobalCompilableTypeName(); - - context = context with - { - InputBufferTypeName = "TInputBuffer", - InputBufferVariableName = "memory", - IsOffsetByRef = true, - TableFieldContextVariableName = "fieldContext", - OffsetVariableName = "temp", - RemainingDepthVariableName = "remainingDepth", - }; - - string classDef = $@" - -internal struct {className}<{context.InputBufferTypeName}> : IVectorItemAccessor<{itemTypeName}, {context.InputBufferTypeName}> - where {context.InputBufferTypeName} : IInputBuffer -{{ - private readonly int discriminatorVectorOffset; - private readonly int offsetVectorOffset; - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public {className}( - {context.InputBufferTypeName} memory, - int discriminatorOffset, - int offsetVectorOffset) - {{ - uint discriminatorCount = memory.ReadUInt(discriminatorOffset); - uint offsetCount = memory.ReadUInt(offsetVectorOffset); - - if (discriminatorCount != offsetCount) - {{ - throw new {typeof(InvalidDataException).GetGlobalCompilableTypeName()}($""Union vector had mismatched number of discriminators and offsets.""); - }} - - this.Count = (int)offsetCount; - this.discriminatorVectorOffset = discriminatorOffset + sizeof(int); - this.offsetVectorOffset = offsetVectorOffset + sizeof(int); - }} - - public int Count {{ get; }} - - public int ItemSize => throw new NotImplementedException(); - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public void ParseItem(int index, {context.InputBufferTypeName} {context.InputBufferVariableName}, short {context.RemainingDepthVariableName}, TableFieldContext {context.TableFieldContextVariableName}, out {itemTypeName} item) - {{ - var {context.OffsetVariableName} = (this.discriminatorVectorOffset + index, this.offsetVectorOffset + (index * sizeof(int))); - item = {context.GetParseInvocation(typeModel.ClrType)}; - }} - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public void WriteThrough(int index, {itemTypeName} value, {context.InputBufferTypeName} inputBuffer, TableFieldContext context) - {{ - throw new NotMutableException(); - }} - - public int OffsetOf(int index) => throw new NotImplementedException(); -}} -"; - - - return (classDef, className); + return $@" + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private void UnsafeWriteThrough(int index, {itemTypeModel.GetGlobalCompilableTypeName()} value) + {{ + {writeThroughBody} + }}"; } } diff --git a/src/FlatSharp/FlatBufferVectorHelpers_Greedy.cs b/src/FlatSharp/FlatBufferVectorHelpers_Greedy.cs new file mode 100644 index 00000000..b57ba7ec --- /dev/null +++ b/src/FlatSharp/FlatBufferVectorHelpers_Greedy.cs @@ -0,0 +1,131 @@ +/* + * Copyright 2020 James Courtney + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +namespace FlatSharp.TypeModel; + +internal static partial class FlatBufferVectorHelpers +{ + public static (string classDef, string className) CreateGreedyVector( + ITypeModel itemTypeModel, + int inlineSize, + ParserCodeGenContext context, + bool isEverWriteThrough) + { + FlatSharpInternal.Assert(context.Options.DeserializationOption == FlatBufferDeserializationOption.Greedy, "Expecting greedy"); + + string className = CreateVectorClassName(itemTypeModel, FlatBufferDeserializationOption.Greedy); + + string baseTypeName = itemTypeModel.GetGlobalCompilableTypeName(); + string derivedTypeName = itemTypeModel.GetDeserializedTypeName(context.MethodNameResolver, context.Options.DeserializationOption, context.InputBufferTypeName); + + string nullableReference = itemTypeModel.ClrType.IsValueType ? string.Empty : "?"; + + string classDef = +$$"""" + internal sealed class {{className}} + : object + , IList<{{baseTypeName}}> + , IReadOnlyList<{{baseTypeName}}> + , IPoolableObject + where TInputBuffer : IInputBuffer + { + private readonly List<{{derivedTypeName}}> list; + private int inUse = 1; + + private {{className}}(int count) + { + this.list = new List<{{derivedTypeName}}>(count); + } + + public static {{className}} GetOrCreate( + TInputBuffer {{context.InputBufferVariableName}}, + int {{context.OffsetVariableName}}, + short {{context.RemainingDepthVariableName}}, + TableFieldContext {{context.TableFieldContextVariableName}}) + { + int count = (int){{context.InputBufferVariableName}}.ReadUInt({{context.OffsetVariableName}}); + {{context.OffsetVariableName}} += sizeof(int); + + if (ObjectPool.TryGet(out {{className}}? list)) + {{StrykerSuppressor.SuppressNextLine("block")}} + { + #if NET6_0_OR_GREATER + {{StrykerSuppressor.SuppressNextLine("statement")}} + list.list.EnsureCapacity(count); + #endif + } + else + { + list = new {{className}}(count); + } + + var innerList = list.list; + for (int i = 0; i < count; ++i) + { + var item = {{context.GetParseInvocation(itemTypeModel.ClrType)}}; + innerList.Add(item); + {{context.OffsetVariableName}} += {{inlineSize}}; + } + + list.inUse = 1; + + return list; + } + + {{StrykerSuppressor.ExcludeFromCodeCoverage()}} + public void ReturnToPool(bool force) + { + if (force) + { + if (System.Threading.Interlocked.Exchange(ref this.inUse, 0) != 0) + { + {{If( + !itemTypeModel.ClrType.IsValueType && typeof(IPoolableObject).IsAssignableFrom(itemTypeModel.ClrType), + $$""" + foreach (var item in this.list) + { + item.ReturnToPool(true); + } + """ + )}} + + this.list.Clear(); + ObjectPool.Return(this); + } + } + } + + public {{baseTypeName}} this[int index] + { + get => this.GetItem(index); + set => this.SetItem(index, value); + } + + public int Count => this.list.Count; + + public FlatBufferDeserializationOption DeserializationOption => {{nameof(FlatBufferDeserializationOption)}}.{{context.Options.DeserializationOption}}; + + private {{derivedTypeName}} GetItem(int index) => this.list[index]; + private void SetItem(int index, {{baseTypeName}} value) => {{nameof(VectorUtilities)}}.{{nameof(VectorUtilities.ThrowInlineNotMutableException)}}(); + + {{CreateCommonReadOnlyVectorMethods(itemTypeModel, derivedTypeName)}} + {{CreateImmutableVectorMethods(itemTypeModel)}} + } +""""; + + return (classDef, className); + } +} diff --git a/src/FlatSharp/FlatBufferVectorHelpers_GreedyMutable.cs b/src/FlatSharp/FlatBufferVectorHelpers_GreedyMutable.cs new file mode 100644 index 00000000..0b7482d3 --- /dev/null +++ b/src/FlatSharp/FlatBufferVectorHelpers_GreedyMutable.cs @@ -0,0 +1,185 @@ +/* + * Copyright 2020 James Courtney + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +namespace FlatSharp.TypeModel; + +internal static partial class FlatBufferVectorHelpers +{ + public static (string classDef, string className) CreateGreedyMutableVector( + ITypeModel itemTypeModel, + int inlineSize, + ParserCodeGenContext context, + bool isEverWriteThrough) + { + FlatSharpInternal.Assert(context.Options.DeserializationOption == FlatBufferDeserializationOption.GreedyMutable, "Expecting greedymutable"); + + string className = CreateVectorClassName(itemTypeModel, FlatBufferDeserializationOption.GreedyMutable); + + string baseTypeName = itemTypeModel.GetGlobalCompilableTypeName(); + string nullableReference = itemTypeModel.ClrType.IsValueType ? string.Empty : "?"; + + string IfMutable(string str) + { + if (isEverWriteThrough) + { + return $$""" + if ({{context.TableFieldContextVariableName}}.{{nameof(TableFieldContext.WriteThrough)}}) + { + {{nameof(VectorUtilities)}}.{{nameof(VectorUtilities.ThrowGreedyMutableWriteThroughNotSupportedException)}}(); + } + + {{str}} + """; + } + + return str; + } + + string classDef = +$$"""" + internal sealed class {{className}} + : object + , IList<{{baseTypeName}}> + , IReadOnlyList<{{baseTypeName}}> + , IPoolableObject + where TInputBuffer : IInputBuffer + { + private TableFieldContext {{context.TableFieldContextVariableName}}; + private readonly List<{{baseTypeName}}> list; + private int inUse = 1; + +#pragma warning disable CS8618 + private {{className}}(int count) + { + this.list = new List<{{baseTypeName}}>(count); + } +#pragma warning restore CS8618 + + public static {{className}} GetOrCreate( + TInputBuffer {{context.InputBufferVariableName}}, + int {{context.OffsetVariableName}}, + short {{context.RemainingDepthVariableName}}, + TableFieldContext {{context.TableFieldContextVariableName}}) + { + int count = (int){{context.InputBufferVariableName}}.ReadUInt({{context.OffsetVariableName}}); + {{context.OffsetVariableName}} += sizeof(int); + + if (ObjectPool.TryGet(out {{className}}? list)) + {{StrykerSuppressor.SuppressNextLine("block")}} + { + #if NET6_0_OR_GREATER + {{StrykerSuppressor.SuppressNextLine("statement")}} + list.list.EnsureCapacity(count); + #endif + } + else + { + list = new {{className}}(count); + } + + var innerList = list.list; + for (int i = 0; i < count; ++i) + { + var item = {{context.GetParseInvocation(itemTypeModel.ClrType)}}; + innerList.Add(item); + {{context.OffsetVariableName}} += {{inlineSize}}; + } + + list.{{context.TableFieldContextVariableName}} = {{context.TableFieldContextVariableName}}; + list.inUse = 1; + + return list; + } + + {{StrykerSuppressor.ExcludeFromCodeCoverage()}} + public void ReturnToPool(bool force) + { + if (force) + { + if (System.Threading.Interlocked.Exchange(ref this.inUse, 0) != 0) + { + {{If( + !itemTypeModel.ClrType.IsValueType && typeof(IPoolableObject).IsAssignableFrom(itemTypeModel.ClrType), + $$""" + foreach (var item in this.list) + { + item.ReturnToPool(true); + } + """ + )}} + + this.list.Clear(); + ObjectPool.Return(this); + } + } + } + + public {{baseTypeName}} this[int index] + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get => this.GetItem(index); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set => this.SetItem(index, value); + } + + public int Count => this.list.Count; + + public bool IsReadOnly => false; + + public FlatBufferDeserializationOption DeserializationOption => {{nameof(FlatBufferDeserializationOption)}}.{{context.Options.DeserializationOption}}; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private {{baseTypeName}} GetItem(int index) => this.list[index]; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private void SetItem(int index, {{baseTypeName}} value) + { + {{IfMutable("this.list[index] = value;")}} + } + + public void Add({{baseTypeName}} item) + { + {{IfMutable("this.list.Add(item);")}} + } + + public void Clear() + { + {{IfMutable("this.list.Clear();")}} + } + + public void Insert(int index, {{baseTypeName}} item) + { + {{IfMutable("this.list.Insert(index, item);")}} + } + + public void RemoveAt(int index) + { + {{IfMutable("this.list.RemoveAt(index);")}} + } + + public bool Remove({{baseTypeName}} item) + { + {{IfMutable("return this.list.Remove(item);")}} + } + + {{CreateCommonReadOnlyVectorMethods(itemTypeModel, baseTypeName)}} + } +""""; + + return (classDef, className); + } +} diff --git a/src/FlatSharp/FlatBufferVectorHelpers_GreedyMutableUnion.cs b/src/FlatSharp/FlatBufferVectorHelpers_GreedyMutableUnion.cs new file mode 100644 index 00000000..ee493c06 --- /dev/null +++ b/src/FlatSharp/FlatBufferVectorHelpers_GreedyMutableUnion.cs @@ -0,0 +1,180 @@ +/* + * Copyright 2020 James Courtney + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +using System.IO; + +namespace FlatSharp.TypeModel; + +internal static partial class FlatBufferVectorHelpers +{ + public static (string classDef, string className) CreateGreedyMutableUnionVector( + ITypeModel itemTypeModel, + ParserCodeGenContext context) + { + FlatSharpInternal.Assert(context.Options.DeserializationOption == FlatBufferDeserializationOption.GreedyMutable, "Expecting greedymutable"); + + string className = CreateVectorClassName(itemTypeModel, FlatBufferDeserializationOption.GreedyMutable); + + string baseTypeName = itemTypeModel.GetGlobalCompilableTypeName(); + string nullableReference = itemTypeModel.ClrType.IsValueType ? string.Empty : "?"; + + string classDef = +$$"""" + internal sealed class {{className}} + : object + , IList<{{baseTypeName}}> + , IReadOnlyList<{{baseTypeName}}> + , IPoolableObject + where TInputBuffer : IInputBuffer + { + private readonly List<{{baseTypeName}}> list; + private int inUse = 1; + + private {{className}}(int count) + { + this.list = new List<{{baseTypeName}}>(count); + } + + public static {{className}} GetOrCreate( + TInputBuffer {{context.InputBufferVariableName}}, + ref (int offset0, int offset1) offsets, + short {{context.RemainingDepthVariableName}}, + TableFieldContext {{context.TableFieldContextVariableName}}) + { + int dvo = offsets.offset0; + int ovo = offsets.offset1; + + int discriminatorCount = (int){{context.InputBufferVariableName}}.ReadUInt(dvo); + int offsetCount = (int){{context.InputBufferVariableName}}.ReadUInt(ovo); + + if (discriminatorCount != offsetCount) + { + throw new {{typeof(InvalidDataException).GetGlobalCompilableTypeName()}}($"Union vector had mismatched number of discriminators and offsets."); + } + + dvo += sizeof(uint); + ovo += sizeof(uint); + + if (ObjectPool.TryGet(out {{className}}? list)) + {{StrykerSuppressor.SuppressNextLine("block")}} + { + #if NET6_0_OR_GREATER + {{StrykerSuppressor.SuppressNextLine("statement")}} + list.list.EnsureCapacity(discriminatorCount); + #endif + } + else + { + list = new {{className}}(discriminatorCount); + } + + var innerList = list.list; + for (int i = 0; i < discriminatorCount; ++i) + { + var {{context.OffsetVariableName}} = (dvo, ovo); + var item = {{context.GetParseInvocation(itemTypeModel.ClrType)}}; + + innerList.Add(item); + + dvo += sizeof(byte); + ovo += sizeof(uint); + } + + list.inUse = 1; + + return list; + } + + {{StrykerSuppressor.ExcludeFromCodeCoverage()}} + public void ReturnToPool(bool force) + { + if (force) + { + if (System.Threading.Interlocked.Exchange(ref this.inUse, 0) != 0) + { + {{( + !itemTypeModel.ClrType.IsValueType && typeof(IPoolableObject).IsAssignableFrom(itemTypeModel.ClrType) + ? $$""" + foreach (var item in this.list) + { + item.ReturnToPool(true); + } + """ + : string.Empty + )}} + + this.list.Clear(); + ObjectPool.Return(this); + } + } + } + + public {{baseTypeName}} this[int index] + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get => this.GetItem(index); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set => this.SetItem(index, value); + } + + public int Count => this.list.Count; + + public bool IsReadOnly => false; + + public FlatBufferDeserializationOption DeserializationOption => {{nameof(FlatBufferDeserializationOption)}}.{{context.Options.DeserializationOption}}; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private {{baseTypeName}} GetItem(int index) => this.list[index]; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private void SetItem(int index, {{baseTypeName}} value) + { + this.list[index] = value; + } + + public void Add({{baseTypeName}} item) + { + this.list.Add(item); + } + + public void Clear() + { + this.list.Clear(); + } + + public void Insert(int index, {{baseTypeName}} item) + { + this.list.Insert(index, item); + } + + public void RemoveAt(int index) + { + this.list.RemoveAt(index); + } + + public bool Remove({{baseTypeName}} item) + { + return this.list.Remove(item); + } + + {{CreateCommonReadOnlyVectorMethods(itemTypeModel, baseTypeName)}} + } +""""; + + return (classDef, className); + } +} diff --git a/src/FlatSharp/FlatBufferVectorHelpers_GreedyUnion.cs b/src/FlatSharp/FlatBufferVectorHelpers_GreedyUnion.cs new file mode 100644 index 00000000..78eff0c4 --- /dev/null +++ b/src/FlatSharp/FlatBufferVectorHelpers_GreedyUnion.cs @@ -0,0 +1,147 @@ +/* + * Copyright 2020 James Courtney + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +using System.IO; + +namespace FlatSharp.TypeModel; + +internal static partial class FlatBufferVectorHelpers +{ + public static (string classDef, string className) CreateGreedyUnionVector( + ITypeModel itemTypeModel, + ParserCodeGenContext context) + { + FlatSharpInternal.Assert(context.Options.DeserializationOption == FlatBufferDeserializationOption.Greedy, "Expecting greedy"); + + string className = CreateVectorClassName(itemTypeModel, FlatBufferDeserializationOption.Greedy); + + string baseTypeName = itemTypeModel.GetGlobalCompilableTypeName(); + string derivedTypeName = itemTypeModel.GetDeserializedTypeName(context.MethodNameResolver, context.Options.DeserializationOption, context.InputBufferTypeName); + + string nullableReference = itemTypeModel.ClrType.IsValueType ? string.Empty : "?"; + + string classDef = +$$"""" + internal sealed class {{className}} + : object + , IList<{{baseTypeName}}> + , IReadOnlyList<{{baseTypeName}}> + , IPoolableObject + where TInputBuffer : IInputBuffer + { + private readonly List<{{derivedTypeName}}> list; + private int inUse = 1; + + private {{className}}(int count) + { + this.list = new List<{{derivedTypeName}}>(count); + } + + public static {{className}} GetOrCreate( + TInputBuffer {{context.InputBufferVariableName}}, + ref (int offset0, int offset1) offsets, + short {{context.RemainingDepthVariableName}}, + TableFieldContext {{context.TableFieldContextVariableName}}) + { + int dvo = offsets.offset0; + int ovo = offsets.offset1; + + int discriminatorCount = (int){{context.InputBufferVariableName}}.ReadUInt(dvo); + int offsetCount = (int){{context.InputBufferVariableName}}.ReadUInt(ovo); + + if (discriminatorCount != offsetCount) + { + throw new {{typeof(InvalidDataException).GetGlobalCompilableTypeName()}}($"Union vector had mismatched number of discriminators and offsets."); + } + + dvo += sizeof(uint); + ovo += sizeof(uint); + + if (ObjectPool.TryGet(out {{className}}? list)) + {{StrykerSuppressor.SuppressNextLine("block")}} + { + #if NET6_0_OR_GREATER + {{StrykerSuppressor.SuppressNextLine("statement")}} + list.list.EnsureCapacity(discriminatorCount); + #endif + } + else + { + list = new {{className}}(discriminatorCount); + } + + var innerList = list.list; + for (int i = 0; i < discriminatorCount; ++i) + { + var {{context.OffsetVariableName}} = (dvo, ovo); + var item = {{context.GetParseInvocation(itemTypeModel.ClrType)}}; + + innerList.Add(item); + + dvo += sizeof(byte); + ovo += sizeof(uint); + } + + list.inUse = 1; + + return list; + } + + {{StrykerSuppressor.ExcludeFromCodeCoverage()}} + public void ReturnToPool(bool force) + { + if (force) + { + if (System.Threading.Interlocked.Exchange(ref this.inUse, 0) != 0) + { + {{( + !itemTypeModel.ClrType.IsValueType && typeof(IPoolableObject).IsAssignableFrom(itemTypeModel.ClrType) + ? $$""" + foreach (var item in this.list) + { + item.ReturnToPool(true); + } + """ + : string.Empty + )}} + + this.list.Clear(); + ObjectPool.Return(this); + } + } + } + + public {{baseTypeName}} this[int index] + { + get => this.GetItem(index); + set => this.SetItem(index, value); + } + + public int Count => this.list.Count; + + public FlatBufferDeserializationOption DeserializationOption => {{nameof(FlatBufferDeserializationOption)}}.{{context.Options.DeserializationOption}}; + + private {{derivedTypeName}} GetItem(int index) => this.list[index]; + private void SetItem(int index, {{baseTypeName}} value) => {{nameof(VectorUtilities)}}.{{nameof(VectorUtilities.ThrowInlineNotMutableException)}}(); + + {{CreateCommonReadOnlyVectorMethods(itemTypeModel, derivedTypeName)}} + {{CreateImmutableVectorMethods(itemTypeModel)}} + } +""""; + + return (classDef, className); + } +} diff --git a/src/FlatSharp/FlatBufferVectorHelpers_Lazy.cs b/src/FlatSharp/FlatBufferVectorHelpers_Lazy.cs new file mode 100644 index 00000000..b2d6090f --- /dev/null +++ b/src/FlatSharp/FlatBufferVectorHelpers_Lazy.cs @@ -0,0 +1,137 @@ +/* + * Copyright 2020 James Courtney + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +namespace FlatSharp.TypeModel; + +internal static partial class FlatBufferVectorHelpers +{ + /// + /// Creates a Lazy vector for non-unions. + /// + public static (string classDef, string className) CreateLazyVector( + ITypeModel itemTypeModel, + int inlineSize, + ParserCodeGenContext context, + bool isEverWriteThrough) + { + FlatSharpInternal.Assert(context.Options.DeserializationOption == FlatBufferDeserializationOption.Lazy, "Expecting lazy"); + + string className = CreateVectorClassName(itemTypeModel, FlatBufferDeserializationOption.Lazy); + string baseTypeName = itemTypeModel.GetGlobalCompilableTypeName(); + string derivedTypeName = itemTypeModel.GetDeserializedTypeName(context.MethodNameResolver, context.Options.DeserializationOption, context.InputBufferTypeName); + string nullableReference = itemTypeModel.ClrType.IsValueType ? string.Empty : "?"; + + string classDef = +$$"""" + internal sealed class {{className}} + : object + , IList<{{baseTypeName}}> + , IReadOnlyList<{{baseTypeName}}> + , IFlatBufferDeserializedVector + , IPoolableObject + where TInputBuffer : IInputBuffer + { + private int {{context.OffsetVariableName}}; + private int count; + private {{context.InputBufferTypeName}} {{context.InputBufferVariableName}}; + private TableFieldContext {{context.TableFieldContextVariableName}}; + private short {{context.RemainingDepthVariableName}}; + + private int inUse = 1; + +#pragma warning disable CS8618 + private {{className}}() { } +#pragma warning restore CS8618 + + public static {{className}} GetOrCreate( + TInputBuffer memory, + int offset, + short remainingDepth, + TableFieldContext fieldContext) + { + if (!ObjectPool.TryGet<{{className}}>(out var item)) + { + item = new {{className}}(); + } + + item.count = (int)memory.ReadUInt(offset); + item.offset = offset + sizeof(uint); + item.{{context.InputBufferVariableName}} = memory; + item.{{context.TableFieldContextVariableName}} = fieldContext; + item.{{context.RemainingDepthVariableName}} = remainingDepth; + + item.inUse = 1; + + return item; + } + + public {{baseTypeName}} this[int index] + { + get => this.SafeParseItem(index); + set + { + {{nameof(VectorUtilities)}}.{{nameof(VectorUtilities.CheckIndex)}}(index, this.count); + this.UnsafeWriteThrough(index, value); + } + } + + public int Count => this.count; + + public FlatBufferDeserializationOption DeserializationOption => {{nameof(FlatBufferDeserializationOption)}}.{{context.Options.DeserializationOption}}; + + {{StrykerSuppressor.ExcludeFromCodeCoverage()}} + public void ReturnToPool(bool force = false) + { + if (this.DeserializationOption.ShouldReturnToPool(force)) + { + if (System.Threading.Interlocked.Exchange(ref inUse, 0) == 1) + { + this.count = -1; + this.offset = -1; + + this.{{context.InputBufferVariableName}} = default({{context.InputBufferTypeName}})!; + this.{{context.TableFieldContextVariableName}} = null!; + this.{{context.RemainingDepthVariableName}} = -1; + + ObjectPool.Return(this); + } + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private {{derivedTypeName}} SafeParseItem(int index) + { + {{nameof(VectorUtilities)}}.{{nameof(VectorUtilities.CheckIndex)}}(index, this.count); + return this.UnsafeParseItem(index); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private {{derivedTypeName}} UnsafeParseItem(int index) + { + int {{context.OffsetVariableName}} = this.offset + ({{GetEfficientMultiply(inlineSize, "index")}}); + return {{context.GetParseInvocation(itemTypeModel.ClrType)}}; + } + + {{CreateWriteThroughMethod(itemTypeModel, inlineSize, context, isEverWriteThrough)}} + {{CreateCommonReadOnlyVectorMethods(itemTypeModel, derivedTypeName)}} + {{CreateImmutableVectorMethods(itemTypeModel)}} + {{CreateIFlatBufferDeserializedVectorMethods(inlineSize, context.InputBufferVariableName, context.OffsetVariableName, "SafeParseItem")}} + } +""""; + + return (classDef, className); + } +} diff --git a/src/FlatSharp/FlatBufferVectorHelpers_LazyUnion.cs b/src/FlatSharp/FlatBufferVectorHelpers_LazyUnion.cs new file mode 100644 index 00000000..fbdeb9af --- /dev/null +++ b/src/FlatSharp/FlatBufferVectorHelpers_LazyUnion.cs @@ -0,0 +1,148 @@ +/* + * Copyright 2020 James Courtney + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +using System.IO; + +namespace FlatSharp.TypeModel; + +internal static partial class FlatBufferVectorHelpers +{ + /// + /// Creates a Lazy vector for non-unions. + /// + public static (string classDef, string className) CreateLazyUnionVector( + ITypeModel itemTypeModel, + ParserCodeGenContext context) + { + FlatSharpInternal.Assert(context.Options.DeserializationOption == FlatBufferDeserializationOption.Lazy, "Expecting lazy"); + + string className = CreateVectorClassName(itemTypeModel, FlatBufferDeserializationOption.Lazy); + string baseTypeName = itemTypeModel.GetGlobalCompilableTypeName(); + string derivedTypeName = itemTypeModel.GetDeserializedTypeName(context.MethodNameResolver, context.Options.DeserializationOption, context.InputBufferTypeName); + string nullableReference = itemTypeModel.ClrType.IsValueType ? string.Empty : "?"; + + string classDef = +$$"""" + internal sealed class {{className}} + : object + , IList<{{baseTypeName}}> + , IReadOnlyList<{{baseTypeName}}> + , IPoolableObject + where TInputBuffer : IInputBuffer + { + private int discriminatorVectorOffset; + private int offsetVectorOffset; + private int count; + private {{context.InputBufferTypeName}} {{context.InputBufferVariableName}}; + private TableFieldContext {{context.TableFieldContextVariableName}}; + private short {{context.RemainingDepthVariableName}}; + + private int inUse = 1; + +#pragma warning disable CS8618 + private {{className}}() { } +#pragma warning restore CS8618 + + public static {{className}} GetOrCreate( + TInputBuffer memory, + ref (int offset0, int offset1) offsets, + short remainingDepth, + TableFieldContext fieldContext) + { + if (!ObjectPool.TryGet<{{className}}>(out var item)) + { + item = new {{className}}(); + } + + int dvo = offsets.offset0; + int ovo = offsets.offset1; + + uint discriminatorCount = memory.ReadUInt(dvo); + uint offsetCount = memory.ReadUInt(ovo); + + if (discriminatorCount != offsetCount) + { + throw new {{typeof(InvalidDataException).GetGlobalCompilableTypeName()}}($"Union vector had mismatched number of discriminators and offsets."); + } + + item.count = (int)offsetCount; + item.discriminatorVectorOffset = dvo + sizeof(int); + item.offsetVectorOffset = ovo + sizeof(int); + item.{{context.InputBufferVariableName}} = memory; + item.{{context.TableFieldContextVariableName}} = fieldContext; + item.{{context.RemainingDepthVariableName}} = remainingDepth; + item.inUse = 1; + + return item; + } + + public {{baseTypeName}} this[int index] + { + get => this.SafeParseItem(index); + set => this.WriteThrough(index, value); + } + + public int Count => this.count; + + public FlatBufferDeserializationOption DeserializationOption => {{nameof(FlatBufferDeserializationOption)}}.{{context.Options.DeserializationOption}}; + + {{StrykerSuppressor.ExcludeFromCodeCoverage()}} + public void ReturnToPool(bool force = false) + { + if (this.DeserializationOption.ShouldReturnToPool(force)) + { + if (System.Threading.Interlocked.Exchange(ref inUse, 0) == 1) + { + this.count = -1; + this.discriminatorVectorOffset = -1; + this.offsetVectorOffset = -1; + + this.{{context.InputBufferVariableName}} = default({{context.InputBufferTypeName}})!; + this.{{context.TableFieldContextVariableName}} = null!; + this.{{context.RemainingDepthVariableName}} = -1; + + ObjectPool.Return(this); + } + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private {{derivedTypeName}} SafeParseItem(int index) + { + {{nameof(VectorUtilities)}}.{{nameof(VectorUtilities.CheckIndex)}}(index, this.count); + return this.UnsafeParseItem(index); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private {{derivedTypeName}} UnsafeParseItem(int index) + { + var {{context.OffsetVariableName}} = (this.discriminatorVectorOffset + index, this.offsetVectorOffset + ({{GetEfficientMultiply(sizeof(uint), "index")}})); + return {{context.GetParseInvocation(itemTypeModel.ClrType)}}; + } + + private void WriteThrough(int index, {{baseTypeName}} value) + { + {{nameof(VectorUtilities)}}.{{nameof(VectorUtilities.ThrowInlineNotMutableException)}}(); + } + + {{CreateCommonReadOnlyVectorMethods(itemTypeModel, derivedTypeName)}} + {{CreateImmutableVectorMethods(itemTypeModel)}} + } +""""; + + return (classDef, className); + } +} diff --git a/src/FlatSharp/FlatBufferVectorHelpers_Progressive.cs b/src/FlatSharp/FlatBufferVectorHelpers_Progressive.cs new file mode 100644 index 00000000..0c1cb7c0 --- /dev/null +++ b/src/FlatSharp/FlatBufferVectorHelpers_Progressive.cs @@ -0,0 +1,272 @@ +/* + * Copyright 2020 James Courtney + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +using System.IO; + +namespace FlatSharp.TypeModel; + +internal static partial class FlatBufferVectorHelpers +{ + public static (string classDef, string className) CreateProgressiveVector( + ITypeModel itemTypeModel, + int inlineSize, + ParserCodeGenContext context, + bool isEverWriteThrough) + { + FlatSharpInternal.Assert(context.Options.DeserializationOption == FlatBufferDeserializationOption.Progressive, "Expecting progressive"); + + string className = CreateVectorClassName(itemTypeModel, FlatBufferDeserializationOption.Progressive); + string baseTypeName = itemTypeModel.GetGlobalCompilableTypeName(); + string derivedTypeName = itemTypeModel.GetDeserializedTypeName(context.MethodNameResolver, context.Options.DeserializationOption, context.InputBufferTypeName); + + string nullableReference = itemTypeModel.ClrType.IsValueType ? string.Empty : "?"; + + int chunkSize = 32; + + string classDef = +$$"""" + internal sealed class {{className}} + : object + , IList<{{baseTypeName}}> + , IReadOnlyList<{{baseTypeName}}> + , IFlatBufferDeserializedVector + , IPoolableObject + where TInputBuffer : IInputBuffer + { + private const uint ChunkSize = {{chunkSize}}; + + private int {{context.OffsetVariableName}}; + private int count; + private {{context.InputBufferTypeName}} {{context.InputBufferVariableName}}; + private TableFieldContext {{context.TableFieldContextVariableName}}; + private short {{context.RemainingDepthVariableName}}; + private {{derivedTypeName}}{{nullableReference}}[]?[] items; + private int inUse = 1; + +#pragma warning disable CS8618 + private {{className}}() { } +#pragma warning restore CS8618 + + public static {{className}} GetOrCreate( + TInputBuffer memory, + int offset, + short remainingDepth, + TableFieldContext fieldContext) + { + if (!ObjectPool.TryGet<{{className}}>(out var item)) + { + item = new {{className}}(); + } + + item.count = (int)memory.ReadUInt(offset); + item.offset = offset + sizeof(uint); + item.{{context.InputBufferVariableName}} = memory; + item.{{context.TableFieldContextVariableName}} = fieldContext; + item.{{context.RemainingDepthVariableName}} = remainingDepth; + + {{StrykerSuppressor.SuppressNextLine()}} + int progressiveMinLength = (int)(item.count / ChunkSize) + 1; + item.items = System.Buffers.ArrayPool<{{derivedTypeName}}{{nullableReference}}[]?>.Shared.Rent(progressiveMinLength); + item.inUse = 1; + + return item; + } + + public {{baseTypeName}} this[int index] + { + get => this.ProgressiveGet(index); + set => this.ProgressiveSet(index, value); + } + + public int Count => this.count; + + public FlatBufferDeserializationOption DeserializationOption => {{nameof(FlatBufferDeserializationOption)}}.{{context.Options.DeserializationOption}}; + + {{StrykerSuppressor.ExcludeFromCodeCoverage()}} + public void ReturnToPool(bool force = false) + { + if (this.DeserializationOption.ShouldReturnToPool(force)) + { + if (System.Threading.Interlocked.Exchange(ref inUse, 0) == 1) + { + this.count = -1; + this.offset = -1; + + this.{{context.InputBufferVariableName}} = default({{context.InputBufferTypeName}})!; + this.{{context.TableFieldContextVariableName}} = null!; + this.{{context.RemainingDepthVariableName}} = -1; + + var items = this.items; + this.items = null!; + + if (items is null) + { + return; + } + + for (int i = 0; i < items.Length; ++i) + { + var block = items[i]; + + if (block is null) + { + continue; + } + + {{( + // return poolable reference types at this point. + !itemTypeModel.ClrType.IsValueType && typeof(IPoolableObject).IsAssignableFrom(itemTypeModel.ClrType) + ? $$""" + for (int j = 0; j < block.Length; ++j) + { + block[j]?.ReturnToPool(true); + } + """ + : string.Empty + )}} + + System.Buffers.ArrayPool<{{derivedTypeName}}{{nullableReference}}>.Shared.Return(block, true); + items[i] = null; + } + + System.Buffers.ArrayPool<{{derivedTypeName}}{{nullableReference}}[]?>.Shared.Return(items); + ObjectPool.Return(this); + } + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void GetAddress(uint index, out uint rowIndex, out uint colIndex) + { + rowIndex = index / ChunkSize; + colIndex = index % ChunkSize; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private {{derivedTypeName}}{{nullableReference}}[] GetOrCreateRow({{derivedTypeName}}{{nullableReference}}[]?[] items, uint rowIndex) + { + return items[rowIndex] ?? this.CreateRow(items, rowIndex); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private {{derivedTypeName}}{{nullableReference}}[] CreateRow({{derivedTypeName}}{{nullableReference}}[]?[] items, uint rowIndex) + { + var row = System.Buffers.ArrayPool<{{derivedTypeName}}{{nullableReference}}>.Shared.Rent((int)ChunkSize); + items[rowIndex] = row; + + {{ + // For value types -- we can't rely on null to tell + // us if the value is allocated or not, so just greedily + // allocate the whole chunk. Chunks are relatively + // small, so the overhead here is not enormous, and there + // is no extra allocation since this is a value type. + // Unchecked is considered safe here since we have already + // validated indexes. + If(itemTypeModel.ClrType.IsValueType, + $$""" + unchecked + { + int absoluteStartIndex = (int)({{GetEfficientMultiply(chunkSize, "rowIndex")}}); + int copyCount = {{chunkSize}}; + int remainingItems = this.count - absoluteStartIndex; + + {{StrykerSuppressor.SuppressNextLine("equality")}} + if (remainingItems < {{chunkSize}}) + { + copyCount = remainingItems; + } + + int offset = this.offset + ({{GetEfficientMultiply(inlineSize, "absoluteStartIndex")}}); + for (int i = 0; i < copyCount; ++i) + { + row[i] = this.UnsafeParseFromOffset(offset); + offset += {{inlineSize}}; + } + } + """ + )}} + + return row; + } + + private {{derivedTypeName}} ProgressiveGet(int index) + { + {{nameof(VectorUtilities)}}.{{nameof(VectorUtilities.CheckIndex)}}(index, this.count); + + uint uindex = unchecked((uint)index); + GetAddress(uindex, out uint rowIndex, out uint colIndex); + + var items = this.items; + var row = this.GetOrCreateRow(items, rowIndex); + var item = row[colIndex]; + + {{ // Initialize the reference type if null. + IfNot(itemTypeModel.ClrType.IsValueType, + $$""" + if (item is null) + { + item = this.UnsafeParseItem(index); + row[colIndex] = item; + } + """ + )}} + + return item!; + } + + private void ProgressiveSet(int index, {{baseTypeName}} value) => this.InlineProgressiveSet(index, value); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private void InlineProgressiveSet(int index, {{baseTypeName}} value) + { + {{nameof(VectorUtilities)}}.{{nameof(VectorUtilities.CheckIndex)}}(index, this.count); + {{If(itemTypeModel.ClrType.IsValueType, + // value types can just be assigned directly. + // Note: vector write through is not allowed for reference types, + // so the below will simply throw. + $$""" + uint uindex = (uint)index; + GetAddress(uindex, out uint rowIndex, out uint colIndex); + var row = this.GetOrCreateRow(this.items, rowIndex); + row[colIndex] = value; + """ + )}} + this.UnsafeWriteThrough(index, value); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private {{derivedTypeName}} UnsafeParseItem(int index) + { + int offset = this.offset + ({{GetEfficientMultiply(inlineSize, "index")}}); + return UnsafeParseFromOffset(offset); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private {{derivedTypeName}} UnsafeParseFromOffset(int {{context.OffsetVariableName}}) + { + return {{context.GetParseInvocation(itemTypeModel.ClrType)}}; + } + + {{CreateWriteThroughMethod(itemTypeModel, inlineSize, context, isEverWriteThrough)}} + {{CreateCommonReadOnlyVectorMethods(itemTypeModel, derivedTypeName)}} + {{CreateImmutableVectorMethods(itemTypeModel)}} + {{CreateIFlatBufferDeserializedVectorMethods(inlineSize, context.InputBufferVariableName, context.OffsetVariableName, "ProgressiveGet")}} + } +""""; + + return (classDef, className); + } +} diff --git a/src/FlatSharp/FlatBufferVectorHelpers_ProgressiveUnion.cs b/src/FlatSharp/FlatBufferVectorHelpers_ProgressiveUnion.cs new file mode 100644 index 00000000..e442920a --- /dev/null +++ b/src/FlatSharp/FlatBufferVectorHelpers_ProgressiveUnion.cs @@ -0,0 +1,255 @@ +/* + * Copyright 2020 James Courtney + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +using System.IO; + +namespace FlatSharp.TypeModel; + +internal static partial class FlatBufferVectorHelpers +{ + public static (string classDef, string className) CreateProgressiveUnionVector( + ITypeModel itemTypeModel, + ParserCodeGenContext context) + { + FlatSharpInternal.Assert(context.Options.DeserializationOption == FlatBufferDeserializationOption.Progressive, "Expecting progressive"); + + string className = CreateVectorClassName(itemTypeModel, FlatBufferDeserializationOption.Progressive); + string baseTypeName = itemTypeModel.GetGlobalCompilableTypeName(); + string derivedTypeName = itemTypeModel.GetDeserializedTypeName(context.MethodNameResolver, context.Options.DeserializationOption, context.InputBufferTypeName); + + string nullableReference = itemTypeModel.ClrType.IsValueType ? string.Empty : "?"; + int chunkSize = itemTypeModel.ClrType.IsValueType ? 8 : 32; + + string classDef = +$$"""" + internal sealed class {{className}} + : object + , IList<{{baseTypeName}}> + , IReadOnlyList<{{baseTypeName}}> + , IPoolableObject + where TInputBuffer : IInputBuffer + { + private const uint ChunkSize = {{chunkSize}}; + + private int discriminatorVectorOffset; + private int offsetVectorOffset; + private int count; + private {{context.InputBufferTypeName}} {{context.InputBufferVariableName}}; + private TableFieldContext {{context.TableFieldContextVariableName}}; + private short {{context.RemainingDepthVariableName}}; + private {{derivedTypeName}}{{nullableReference}}[]?[] items; + private int inUse = 1; + +#pragma warning disable CS8618 + private {{className}}() { } +#pragma warning restore CS8618 + + public static {{className}} GetOrCreate( + TInputBuffer memory, + ref (int offset0, int offset1) offsets, + short remainingDepth, + TableFieldContext fieldContext) + { + if (!ObjectPool.TryGet<{{className}}>(out var item)) + { + item = new {{className}}(); + } + + int dvo = offsets.offset0; + int ovo = offsets.offset1; + + uint discriminatorCount = memory.ReadUInt(dvo); + uint offsetCount = memory.ReadUInt(ovo); + + if (discriminatorCount != offsetCount) + { + throw new {{typeof(InvalidDataException).GetGlobalCompilableTypeName()}}($"Union vector had mismatched number of discriminators and offsets."); + } + + item.count = (int)offsetCount; + item.discriminatorVectorOffset = dvo + sizeof(int); + item.offsetVectorOffset = ovo + sizeof(int); + + item.{{context.InputBufferVariableName}} = memory; + item.{{context.TableFieldContextVariableName}} = fieldContext; + item.{{context.RemainingDepthVariableName}} = remainingDepth; + + {{StrykerSuppressor.SuppressNextLine()}} + int progressiveMinLength = (int)(item.count / ChunkSize) + 1; + item.items = System.Buffers.ArrayPool<{{derivedTypeName}}{{nullableReference}}[]?>.Shared.Rent(progressiveMinLength); + item.inUse = 1; + + return item; + } + + public {{baseTypeName}} this[int index] + { + get => this.ProgressiveGet(index); + set => this.ProgressiveSet(index, value); + } + + public int Count => this.count; + + public FlatBufferDeserializationOption DeserializationOption => {{nameof(FlatBufferDeserializationOption)}}.{{context.Options.DeserializationOption}}; + + {{StrykerSuppressor.ExcludeFromCodeCoverage()}} + public void ReturnToPool(bool force = false) + { + if (this.DeserializationOption.ShouldReturnToPool(force)) + { + if (System.Threading.Interlocked.Exchange(ref inUse, 0) == 1) + { + this.count = -1; + this.discriminatorVectorOffset = -1; + this.offsetVectorOffset = -1; + + this.{{context.InputBufferVariableName}} = default({{context.InputBufferTypeName}})!; + this.{{context.TableFieldContextVariableName}} = null!; + this.{{context.RemainingDepthVariableName}} = -1; + + var items = this.items; + this.items = null!; + + if (items is null) + { + return; + } + + for (int i = 0; i < items.Length; ++i) + { + var block = items[i]; + + if (block is null) + { + continue; + } + + {{( + // return poolable reference types at this point. + !itemTypeModel.ClrType.IsValueType && typeof(IPoolableObject).IsAssignableFrom(itemTypeModel.ClrType) + ? $$""" + for (int j = 0; j < block.Length; ++j) + { + block[j]?.ReturnToPool(true); + } + """ + : string.Empty + )}} + + System.Buffers.ArrayPool<{{derivedTypeName}}{{nullableReference}}>.Shared.Return(block, true); + items[i] = null; + } + + System.Buffers.ArrayPool<{{derivedTypeName}}{{nullableReference}}[]?>.Shared.Return(items); + ObjectPool.Return(this); + } + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void GetAddress(uint index, out uint rowIndex, out uint colIndex) + { + rowIndex = index / ChunkSize; + colIndex = index % ChunkSize; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private {{derivedTypeName}}{{nullableReference}}[] GetOrCreateRow({{derivedTypeName}}{{nullableReference}}[]?[] items, uint rowIndex) + { + return items[rowIndex] ?? this.CreateRow(items, rowIndex); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private {{derivedTypeName}}{{nullableReference}}[] CreateRow({{derivedTypeName}}{{nullableReference}}[]?[] items, uint rowIndex) + { + var row = System.Buffers.ArrayPool<{{derivedTypeName}}{{nullableReference}}>.Shared.Rent((int)ChunkSize); + items[rowIndex] = row; + + {{ // For value types -- we can't rely on null to tell + // us if the value is allocated or not, so just greedily + // allocate the whole chunk. Chunks are relatively + // small, so the overhead here is not enormous, and there + // is no extra allocation since this is a value type. + // Unchecked is considered safe here since we have already + // validated indexes. + If(itemTypeModel.ClrType.IsValueType, + $$""" + unchecked + { + int absoluteStartIndex = (int)({{GetEfficientMultiply(chunkSize, "rowIndex")}}); + int copyCount = {{chunkSize}}; + int remainingItems = this.count - absoluteStartIndex; + if (remainingItems < {{chunkSize}}) + { + copyCount = remainingItems; + } + + for (int i = 0; i < copyCount; ++i) + { + row[i] = this.UnsafeParseItem(i + absoluteStartIndex); + } + } + """ + )}} + + return row; + } + + private {{derivedTypeName}} ProgressiveGet(int index) + { + {{nameof(VectorUtilities)}}.{{nameof(VectorUtilities.CheckIndex)}}(index, this.count); + + uint uindex = (uint)index; + GetAddress(uindex, out uint rowIndex, out uint colIndex); + + var items = this.items; + var row = this.GetOrCreateRow(items, rowIndex); + var item = row[colIndex]; + + {{ // Initialize the reference type if null. + IfNot(itemTypeModel.ClrType.IsValueType, + $$""" + if (item is null) + { + item = this.UnsafeParseItem(index); + row[colIndex] = item; + } + """ + )}} + + return item!; + } + + private void ProgressiveSet(int index, {{baseTypeName}} value) + { + {{nameof(VectorUtilities)}}.{{nameof(VectorUtilities.ThrowInlineNotMutableException)}}(); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private {{derivedTypeName}} UnsafeParseItem(int index) + { + var {{context.OffsetVariableName}} = (this.discriminatorVectorOffset + index, this.offsetVectorOffset + ({{GetEfficientMultiply(sizeof(uint), "index")}})); + return {{context.GetParseInvocation(itemTypeModel.ClrType)}}; + } + + {{CreateCommonReadOnlyVectorMethods(itemTypeModel, derivedTypeName)}} + {{CreateImmutableVectorMethods(itemTypeModel)}} + } +""""; + + return (classDef, className); + } +} diff --git a/src/FlatSharp/FlatSharp.csproj b/src/FlatSharp/FlatSharp.csproj index 35d96ffc..2bf65683 100644 --- a/src/FlatSharp/FlatSharp.csproj +++ b/src/FlatSharp/FlatSharp.csproj @@ -16,6 +16,10 @@ enable + + + + ScalarTypeModels.cs diff --git a/src/FlatSharp/Serialization/CSharpHelpers.cs b/src/FlatSharp/Serialization/CSharpHelpers.cs index 65f627cd..e786331a 100644 --- a/src/FlatSharp/Serialization/CSharpHelpers.cs +++ b/src/FlatSharp/Serialization/CSharpHelpers.cs @@ -140,6 +140,9 @@ internal static AccessModifier GetAccessModifier(this MethodInfo method) internal static string GetAssertSizeOfStatement(ITypeModel model, object size) { string globalName = model.GetGlobalCompilableTypeName(); - return $"{typeof(FlatSharpInternal).GetGlobalCompilableTypeName()}.AssertSizeOf<{globalName}>({size});"; + return $$""" + {{StrykerSuppressor.SuppressNextLine()}} + {{typeof(FlatSharpInternal).GetGlobalCompilableTypeName()}}.AssertSizeOf<{{globalName}}>({{size}}); + """; } } diff --git a/src/FlatSharp/Serialization/DeserializeClassDefinition.cs b/src/FlatSharp/Serialization/DeserializeClassDefinition.cs index 2bb74a76..a456ac68 100644 --- a/src/FlatSharp/Serialization/DeserializeClassDefinition.cs +++ b/src/FlatSharp/Serialization/DeserializeClassDefinition.cs @@ -132,10 +132,6 @@ public void AddProperty( { this.AddWriteThroughMethod(itemModel, context); } - else - { - - } } } @@ -288,7 +284,7 @@ public override string ToString() return $@" - private sealed class {this.ClassName} + internal sealed class {this.ClassName} : {typeModel.GetGlobalCompilableTypeName()} , {interfaceGlobalName} , {typeof(IPoolableObject).GetGlobalCompilableTypeName()} @@ -339,7 +335,7 @@ protected virtual string GetSetterBody(ItemMemberModel itemModel) { FlatSharpInternal.Assert(options.DeserializationOption == FlatBufferDeserializationOption.Progressive, "Expecting progressive"); setterLines.Add($"this.{GetFieldName(itemModel)} = value;"); - setterLines.Add($"this.{GetHasValueFieldName(itemModel)} |= {GetHasValueFieldMask(itemModel)};"); + setterLines.Add($"{typeof(SerializationHelpers).GetGlobalCompilableTypeName()}.{nameof(SerializationHelpers.CombineMask)}(ref this.{GetHasValueFieldName(itemModel)}, {GetHasValueFieldMask(itemModel)});"); } setterLines.Add($"{GetWriteMethodName(itemModel)}({this.GetBufferReference()}, {OffsetVariableName}, value, {this.vtableAccessor});"); @@ -384,7 +380,7 @@ protected virtual string GetGetterBody(ItemMemberModel itemModel) if ((this.{GetHasValueFieldName(itemModel)} & {GetHasValueFieldMask(itemModel)}) == 0) {{ this.{GetFieldName(itemModel)} = {readUnderlyingInvocation}; - this.{GetHasValueFieldName(itemModel)} |= {GetHasValueFieldMask(itemModel)}; + {typeof(SerializationHelpers).GetGlobalCompilableTypeName()}.{nameof(SerializationHelpers.CombineMask)}(ref this.{GetHasValueFieldName(itemModel)}, {GetHasValueFieldMask(itemModel)}); }} return this.{GetFieldName(itemModel)}; "; diff --git a/src/FlatSharp/Serialization/RoslynSerializerGenerator.cs b/src/FlatSharp/Serialization/RoslynSerializerGenerator.cs index 383dea7c..07dfa87e 100644 --- a/src/FlatSharp/Serialization/RoslynSerializerGenerator.cs +++ b/src/FlatSharp/Serialization/RoslynSerializerGenerator.cs @@ -518,6 +518,7 @@ public void __AotHelper() throw new InvalidOperationException(""__AotHelper is not intended to be invoked""); }} + [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage] public {resolvedName.name}() {{ string? runtimeVersion = System.Reflection.CustomAttributeExtensions.GetCustomAttribute(typeof(SpanWriter).Assembly)?.Version; @@ -733,6 +734,7 @@ private string GenerateParseMethod(bool requiresDepthTracking, ITypeModel typeMo } string clrType = typeModel.GetGlobalCompilableTypeName(); + string parsedType = typeModel.GetDeserializedTypeName(context.MethodNameResolver, context.Options.DeserializationOption, context.InputBufferTypeName); // If we require depth tracking due to the schema, inject the if statement and the decrement instruction. string depthCheck = string.Empty; @@ -747,7 +749,7 @@ private string GenerateParseMethod(bool requiresDepthTracking, ITypeModel typeMo string fullText = $@" {method.GetMethodImplAttribute()} - internal static {clrType} {context.MethodNameResolver.ResolveParse(context.Options.DeserializationOption, typeModel).methodName}( + internal static {parsedType} {context.MethodNameResolver.ResolveParse(context.Options.DeserializationOption, typeModel).methodName}( TInputBuffer {context.InputBufferVariableName}, {GetVTableOffsetVariableType(typeModel.PhysicalLayout.Length)} {context.OffsetVariableName}, short {context.RemainingDepthVariableName} diff --git a/src/FlatSharp/StrykerSuppressor.cs b/src/FlatSharp/StrykerSuppressor.cs new file mode 100644 index 00000000..70f53a28 --- /dev/null +++ b/src/FlatSharp/StrykerSuppressor.cs @@ -0,0 +1,51 @@ +/* + * Copyright 2021 James Courtney + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +using FlatSharp.Attributes; +using System.Linq; + +namespace FlatSharp; + +public static class StrykerSuppressor +{ + public static bool IsEnabled + { + get; + set; + } + + public static string BitConverterTypeName => IsEnabled ? "MockBitConverter" : "BitConverter"; + + public static string SuppressNextLine(string condition = "all") + { + if (IsEnabled) + { + return $"//Stryker disable once {condition}"; + } + + return string.Empty; + } + + public static string ExcludeFromCodeCoverage() + { + if (IsEnabled) + { + return $"[{typeof(ExcludeFromCodeCoverageAttribute).GetCompilableTypeName()}]"; + } + + return string.Empty; + } +} diff --git a/src/FlatSharp/TypeModel/EnumTypeModel.cs b/src/FlatSharp/TypeModel/EnumTypeModel.cs index a1378e23..4b99bbf8 100644 --- a/src/FlatSharp/TypeModel/EnumTypeModel.cs +++ b/src/FlatSharp/TypeModel/EnumTypeModel.cs @@ -152,4 +152,9 @@ public override bool ValidateDefaultValue(object defaultValue) { return defaultValue.GetType() == this.ClrType; } + + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + return this.GetGlobalCompilableTypeName(); + } } diff --git a/src/FlatSharp/TypeModel/ITypeModel.cs b/src/FlatSharp/TypeModel/ITypeModel.cs index e6004e95..638c71fa 100644 --- a/src/FlatSharp/TypeModel/ITypeModel.cs +++ b/src/FlatSharp/TypeModel/ITypeModel.cs @@ -206,4 +206,9 @@ public interface ITypeModel /// Validates the type model for correctness after the entire type graph has been loaded. Validates cross-object dependencies. /// void Validate(); + + /// + /// Gets the fully qualified name of the deserialized type. + /// + string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName); } diff --git a/src/FlatSharp/TypeModel/NullableTypeModel.cs b/src/FlatSharp/TypeModel/NullableTypeModel.cs index be074cdd..0983f3d9 100644 --- a/src/FlatSharp/TypeModel/NullableTypeModel.cs +++ b/src/FlatSharp/TypeModel/NullableTypeModel.cs @@ -169,4 +169,9 @@ public override CodeGeneratedMethod CreateCloneMethodBody(CloneCodeGenContext co IsMethodInline = true, }; } + + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + return this.ClrType.GetGlobalCompilableTypeName(); + } } diff --git a/src/FlatSharp/TypeModel/RuntimeTypeModel.cs b/src/FlatSharp/TypeModel/RuntimeTypeModel.cs index 235c55fa..21c7f1a4 100644 --- a/src/FlatSharp/TypeModel/RuntimeTypeModel.cs +++ b/src/FlatSharp/TypeModel/RuntimeTypeModel.cs @@ -190,4 +190,6 @@ public IEnumerable GetReferencedTypes() { return new[] { this.ClrType }; } + + public abstract string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName); } diff --git a/src/FlatSharp/TypeModel/ScalarTypeModels.cs b/src/FlatSharp/TypeModel/ScalarTypeModels.cs index b7d2809e..a4802041 100644 --- a/src/FlatSharp/TypeModel/ScalarTypeModels.cs +++ b/src/FlatSharp/TypeModel/ScalarTypeModels.cs @@ -38,6 +38,11 @@ public override bool TryGetSpanComparerType([NotNullWhen(true)] out Type? compar protected override string InputBufferReadMethodName => nameof(InputBufferExtensions.ReadBool); protected override string SpanWriterWriteMethodName => nameof(SpanWriterExtensions.WriteBool); + + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + return "bool"; + } } @@ -60,6 +65,11 @@ public override bool TryGetSpanComparerType([NotNullWhen(true)] out Type? compar protected override string InputBufferReadMethodName => nameof(IInputBuffer.ReadByte); protected override string SpanWriterWriteMethodName => nameof(ISpanWriter.WriteByte); + + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + return "byte"; + } } @@ -82,6 +92,11 @@ public override bool TryGetSpanComparerType([NotNullWhen(true)] out Type? compar protected override string InputBufferReadMethodName => nameof(IInputBuffer.ReadSByte); protected override string SpanWriterWriteMethodName => nameof(ISpanWriter.WriteSByte); + + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + return "sbyte"; + } } @@ -104,6 +119,11 @@ public override bool TryGetSpanComparerType([NotNullWhen(true)] out Type? compar protected override string InputBufferReadMethodName => nameof(IInputBuffer.ReadUShort); protected override string SpanWriterWriteMethodName => nameof(ISpanWriter.WriteUShort); + + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + return "ushort"; + } } @@ -126,6 +146,11 @@ public override bool TryGetSpanComparerType([NotNullWhen(true)] out Type? compar protected override string InputBufferReadMethodName => nameof(IInputBuffer.ReadShort); protected override string SpanWriterWriteMethodName => nameof(ISpanWriter.WriteShort); + + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + return "short"; + } } @@ -148,6 +173,11 @@ public override bool TryGetSpanComparerType([NotNullWhen(true)] out Type? compar protected override string InputBufferReadMethodName => nameof(IInputBuffer.ReadInt); protected override string SpanWriterWriteMethodName => nameof(ISpanWriter.WriteInt); + + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + return "int"; + } } @@ -170,6 +200,11 @@ public override bool TryGetSpanComparerType([NotNullWhen(true)] out Type? compar protected override string InputBufferReadMethodName => nameof(IInputBuffer.ReadUInt); protected override string SpanWriterWriteMethodName => nameof(ISpanWriter.WriteUInt); + + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + return "uint"; + } } @@ -192,6 +227,11 @@ public override bool TryGetSpanComparerType([NotNullWhen(true)] out Type? compar protected override string InputBufferReadMethodName => nameof(IInputBuffer.ReadLong); protected override string SpanWriterWriteMethodName => nameof(ISpanWriter.WriteLong); + + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + return "long"; + } } @@ -214,6 +254,11 @@ public override bool TryGetSpanComparerType([NotNullWhen(true)] out Type? compar protected override string InputBufferReadMethodName => nameof(IInputBuffer.ReadULong); protected override string SpanWriterWriteMethodName => nameof(ISpanWriter.WriteULong); + + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + return "ulong"; + } } @@ -236,6 +281,11 @@ public override bool TryGetSpanComparerType([NotNullWhen(true)] out Type? compar protected override string InputBufferReadMethodName => nameof(IInputBuffer.ReadFloat); protected override string SpanWriterWriteMethodName => nameof(ISpanWriter.WriteFloat); + + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + return "float"; + } } @@ -258,6 +308,11 @@ public override bool TryGetSpanComparerType([NotNullWhen(true)] out Type? compar protected override string InputBufferReadMethodName => nameof(IInputBuffer.ReadDouble); protected override string SpanWriterWriteMethodName => nameof(ISpanWriter.WriteDouble); + + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + return "double"; + } } diff --git a/src/FlatSharp/TypeModel/ScalarTypeModels.tt b/src/FlatSharp/TypeModel/ScalarTypeModels.tt index a0e419c1..359ac5ed 100644 --- a/src/FlatSharp/TypeModel/ScalarTypeModels.tt +++ b/src/FlatSharp/TypeModel/ScalarTypeModels.tt @@ -68,6 +68,11 @@ public partial class <#= className #> : ScalarTypeModel protected override string InputBufferReadMethodName => nameof(<#= pair.readNameClass ?? "IInputBuffer" #>.Read<#= casedName #>); protected override string SpanWriterWriteMethodName => nameof(<#= pair.writeNameClass ?? "ISpanWriter" #>.Write<#= casedName #>); + + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + return "<#=typeName#>"; + } } <# } #> diff --git a/src/FlatSharp/TypeModel/StringTypeModel.cs b/src/FlatSharp/TypeModel/StringTypeModel.cs index 3939c05c..cb8b7b4a 100644 --- a/src/FlatSharp/TypeModel/StringTypeModel.cs +++ b/src/FlatSharp/TypeModel/StringTypeModel.cs @@ -163,4 +163,9 @@ public override bool TryGetSpanComparerType(out Type comparerType) comparerType = typeof(StringSpanComparer); return true; } + + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + return "string"; + } } diff --git a/src/FlatSharp/TypeModel/StructTypeModel.cs b/src/FlatSharp/TypeModel/StructTypeModel.cs index 28f5ef0b..4cfbce26 100644 --- a/src/FlatSharp/TypeModel/StructTypeModel.cs +++ b/src/FlatSharp/TypeModel/StructTypeModel.cs @@ -31,6 +31,7 @@ public class StructTypeModel : RuntimeTypeModel private int maxAlignment = 1; private ConstructorInfo? preferredConstructor; private MethodInfo? onDeserializeMethod; + private readonly Guid guid = Guid.NewGuid(); internal StructTypeModel(Type clrType, TypeModelContainer container) : base(clrType, container) { @@ -108,7 +109,7 @@ public override CodeGeneratedMethod CreateParseMethodBody(ParserCodeGenContext c { // We have to implement two items: The table class and the overall "read" method. // Let's start with the read method. - string className = "structReader_" + Guid.NewGuid().ToString("n"); + string className = this.GetDeserializedClassName(context.Options.DeserializationOption); DeserializeClassDefinition classDef = DeserializeClassDefinition.Create( className, this.onDeserializeMethod, @@ -277,6 +278,12 @@ public override void Validate() } } + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + var (ns, name) = nameResolver.ResolveHelperClassName(this); + return $"{ns}.{name}.{this.GetDeserializedClassName(option)}<{inputBufferTypeName}>"; + } + private IEnumerable<(PropertyInfo Property, FlatBufferItemAttribute Attribute)> GetProperties() { return this.ClrType @@ -285,4 +292,9 @@ public override void Validate() .Where(x => x.Attribute is not null) .OrderBy(x => x.Attribute.Index); } + + private string GetDeserializedClassName(FlatBufferDeserializationOption option) + { + return $"structReader_{this.guid:n}_{option}"; + } } diff --git a/src/FlatSharp/TypeModel/TableMemberModel.cs b/src/FlatSharp/TypeModel/TableMemberModel.cs index 76bdfe71..5a754dcb 100644 --- a/src/FlatSharp/TypeModel/TableMemberModel.cs +++ b/src/FlatSharp/TypeModel/TableMemberModel.cs @@ -218,6 +218,8 @@ private string CreateWideReadItemBody( int relativeOffset{i} = {vtableVariableName}.OffsetOf<{context.InputBufferTypeName}>({context.InputBufferVariableName}, {idx}); bool isZero{i} = relativeOffset{i} == 0; allZero &= isZero{i}; + + {StrykerSuppressor.SuppressNextLine("assignment")} anyZero |= isZero{i}; "); diff --git a/src/FlatSharp/TypeModel/TableTypeModel.cs b/src/FlatSharp/TypeModel/TableTypeModel.cs index 2d73f201..86b9d26e 100644 --- a/src/FlatSharp/TypeModel/TableTypeModel.cs +++ b/src/FlatSharp/TypeModel/TableTypeModel.cs @@ -599,6 +599,7 @@ private string GetPrepareSerializeBlock( int vTableLength = this.GetVTableLength(index + i); string prepareBlock = $@" + {StrykerSuppressor.SuppressNextLine("assignment")} currentOffset += {nameof(SerializationHelpers)}.{nameof(SerializationHelpers.GetAlignmentError)}(currentOffset, {layout.Alignment}); {OffsetVariableName(index, i)} = currentOffset; currentOffset += {layout.InlineSize};"; @@ -616,6 +617,7 @@ private string GetPrepareSerializeBlock( else { setVtableBlock = $@" + {StrykerSuppressor.SuppressNextLine("equality")} if ({vTableLength} > vtableLength) {{ vtableLength = {vTableLength}; @@ -713,7 +715,7 @@ private string GetSerializeCoreBlock( public override CodeGeneratedMethod CreateParseMethodBody(ParserCodeGenContext context) { - string className = this.GetTableReaderClassName(context); + string className = this.GetTableReaderClassName(context.Options.DeserializationOption); // We have to implement two items: The table class and the overall "read" method. // Let's start with the read method. @@ -829,9 +831,15 @@ public override bool TryGetTableKeyMember([NotNullWhen(true)] out TableMemberMod return tableMember != null; } + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + var (ns, name) = nameResolver.ResolveHelperClassName(this); + return $"{ns}.{name}.{this.GetTableReaderClassName(option)}<{inputBufferTypeName}>"; + } + private int GetVTableLength(int index) => 4 + (2 * (index + 1)); private int GetVTablePosition(int index) => 4 + (2 * index); - private string GetTableReaderClassName(ParserCodeGenContext context) => $"tableReader_{this.GuidBase}_{context.Options.DeserializationOption}"; + private string GetTableReaderClassName(FlatBufferDeserializationOption option) => $"tableReader_{this.GuidBase}_{option}"; } diff --git a/src/FlatSharp/TypeModel/UnionTypeModel.cs b/src/FlatSharp/TypeModel/UnionTypeModel.cs index 1f41bf37..5d31f2db 100644 --- a/src/FlatSharp/TypeModel/UnionTypeModel.cs +++ b/src/FlatSharp/TypeModel/UnionTypeModel.cs @@ -378,4 +378,10 @@ public override void Validate() base.Validate(); } + + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + // improve? + return this.ClrType.GetGlobalCompilableTypeName(); + } } diff --git a/src/FlatSharp/TypeModel/ValueStructTypeModel.cs b/src/FlatSharp/TypeModel/ValueStructTypeModel.cs index 380494f1..895617dd 100644 --- a/src/FlatSharp/TypeModel/ValueStructTypeModel.cs +++ b/src/FlatSharp/TypeModel/ValueStructTypeModel.cs @@ -118,13 +118,14 @@ public override CodeGeneratedMethod CreateParseMethodBody(ParserCodeGenContext c for (int i = 0; i < this.members.Count; ++i) { var member = this.members[i]; + var offsetAdjustment = member.offset != 0 ? $" + {member.offset}" : string.Empty; var parts = context.MethodNameResolver.ResolveParse(context.Options.DeserializationOption, member.model); propertyStatements.Add($@" item.{member.accessor} = {parts.@namespace}.{parts.className}.{parts.methodName}<{context.InputBufferTypeName}>( {context.InputBufferVariableName}, - {context.OffsetVariableName} + {member.offset}, + {context.OffsetVariableName}{offsetAdjustment}, {context.RemainingDepthVariableName});"); } @@ -144,7 +145,8 @@ public override CodeGeneratedMethod CreateParseMethodBody(ParserCodeGenContext c // For little endian architectures, we can do the equivalent of a reinterpret_cast operation. This will be // generally faster than reading fields individually, since we will read entire words. string body = $@" - if (BitConverter.IsLittleEndian) + {StrykerSuppressor.SuppressNextLine("boolean")} + if ({StrykerSuppressor.BitConverterTypeName}.IsLittleEndian) {{ var mem = {context.InputBufferVariableName}.{nameof(IInputBuffer.GetReadOnlySpan)}().Slice({context.OffsetVariableName}, {this.inlineSize}); return {typeof(MemoryMarshal).GetGlobalCompilableTypeName()}.{nameof(MemoryMarshal.Read)}<{globalName}>(mem); @@ -185,7 +187,9 @@ public override CodeGeneratedMethod CreateSerializeMethodBody(SerializationCodeG { body = $@" {slice} - if (BitConverter.IsLittleEndian) + + {StrykerSuppressor.SuppressNextLine("boolean")} + if ({StrykerSuppressor.BitConverterTypeName}.IsLittleEndian) {{ {typeof(MemoryMarshal).GetGlobalCompilableTypeName()}.Write(sizedSpan, ref {context.ValueVariableName}); }} @@ -349,4 +353,9 @@ private static int UnsafeSizeOf(Type t) FlatSharpInternal.Assert(value is not null, "Unsafe.SizeOf returned null."); return (int)value; } + + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + return this.GetGlobalCompilableTypeName(); + } } diff --git a/src/FlatSharp/TypeModel/Vectors/IndexedVectorTypeModel.cs b/src/FlatSharp/TypeModel/Vectors/IndexedVectorTypeModel.cs index cf05d2fc..94f61c96 100644 --- a/src/FlatSharp/TypeModel/Vectors/IndexedVectorTypeModel.cs +++ b/src/FlatSharp/TypeModel/Vectors/IndexedVectorTypeModel.cs @@ -14,6 +14,8 @@ * limitations under the License. */ +using System.Linq; + namespace FlatSharp.TypeModel; /// @@ -23,6 +25,7 @@ public class IndexedVectorTypeModel : BaseVectorTypeModel { private ITypeModel keyTypeModel; private ITypeModel valueTypeModel; + private ITypeModel listTypeModel; private TableMemberModel keyMemberModel; internal IndexedVectorTypeModel(Type vectorType, TypeModelContainer provider) : base(vectorType, provider) @@ -30,6 +33,7 @@ internal IndexedVectorTypeModel(Type vectorType, TypeModelContainer provider) : this.keyTypeModel = null!; this.valueTypeModel = null!; this.keyMemberModel = null!; + this.listTypeModel = null!; } public override string LengthPropertyName => "Count"; @@ -45,6 +49,7 @@ public override Type OnInitialize() this.keyTypeModel = this.typeModelContainer.CreateTypeModel(keyType); this.valueTypeModel = this.typeModelContainer.CreateTypeModel(valueType); + this.listTypeModel = this.typeModelContainer.CreateTypeModel(typeof(IList<>).MakeGenericType(valueType)); return valueType; } @@ -90,54 +95,32 @@ public override void AdjustTableMember(TableMemberModel source) public override CodeGeneratedMethod CreateParseMethodBody(ParserCodeGenContext context) { - bool isEverWriteThrough = ValidateWriteThrough( - writeThroughSupported: false, - this, - context.AllFieldContexts, - context.Options); - string body; string keyTypeName = CSharpHelpers.GetGlobalCompilableTypeName(this.keyTypeModel.ClrType); string valueTypeName = CSharpHelpers.GetGlobalCompilableTypeName(this.valueTypeModel.ClrType); FlatSharpInternal.Assert(!string.IsNullOrEmpty(context.TableFieldContextVariableName), "field context was null/empty"); - (string vectorClassDef, string vectorClassName) = FlatBufferVectorHelpers.CreateVectorItemAccessor( - this.ItemTypeModel, - this.PaddedMemberInlineSize, - context, - isEverWriteThrough); - - string accessorClassName = $"{vectorClassName}<{context.InputBufferTypeName}>"; - - string createFlatBufferVector = - $@"FlatBufferVectorBase<{this.ItemTypeModel.GetGlobalCompilableTypeName()}, {context.InputBufferTypeName}, {accessorClassName}>.GetOrCreate( - {context.InputBufferVariableName}, - new {accessorClassName}( - {context.OffsetVariableName} + {context.InputBufferVariableName}.{nameof(InputBufferExtensions.ReadUOffset)}({context.OffsetVariableName}), - {context.InputBufferVariableName}), - {context.RemainingDepthVariableName}, - {context.TableFieldContextVariableName}, - {typeof(FlatBufferDeserializationOption).GetGlobalCompilableTypeName()}.{context.Options.DeserializationOption})"; - + string inner = context.GetParseInvocation(this.listTypeModel.ClrType); string mutable = context.Options.GenerateMutableObjects.ToString().ToLowerInvariant(); + if (context.Options.GreedyDeserialize) { // Eager indexed vector. - body = $@"return GreedyIndexedVector<{keyTypeName}, {valueTypeName}>.GetOrCreate<{context.InputBufferTypeName}, {accessorClassName}>({createFlatBufferVector}, {mutable});"; + body = $@"return GreedyIndexedVector<{keyTypeName}, {valueTypeName}>.GetOrCreate({inner}, {mutable});"; } else if (context.Options.Lazy) { // Lazy indexed vector. - body = $@"return FlatBufferIndexedVector<{keyTypeName}, {valueTypeName}, {context.InputBufferTypeName}, {accessorClassName}>.GetOrCreate({createFlatBufferVector});"; + body = $@"return FlatBufferIndexedVector<{keyTypeName}, {valueTypeName}>.GetOrCreate({inner});"; } else { FlatSharpInternal.Assert(context.Options.Progressive, "expecting progressive"); - body = $@"return FlatBufferProgressiveIndexedVector<{keyTypeName}, {valueTypeName}, {context.InputBufferTypeName}, {accessorClassName}>.GetOrCreate({createFlatBufferVector});"; + body = $@"return FlatBufferProgressiveIndexedVector<{keyTypeName}, {valueTypeName}>.GetOrCreate({inner});"; } - return new CodeGeneratedMethod(body) { IsMethodInline = true, ClassDefinition = vectorClassDef }; + return new CodeGeneratedMethod(body) { IsMethodInline = true }; } protected override string CreateLoop( @@ -166,4 +149,11 @@ public override CodeGeneratedMethod CreateCloneMethodBody(CloneCodeGenContext co IsMethodInline = true, }; } + + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + return this.GetGlobalCompilableTypeName(); + } + + public override IEnumerable Children => base.Children.Concat(new[] { this.listTypeModel }); } diff --git a/src/FlatSharp/TypeModel/Vectors/ListVectorTypeModel.cs b/src/FlatSharp/TypeModel/Vectors/ListVectorTypeModel.cs index 4b291e88..638af72e 100644 --- a/src/FlatSharp/TypeModel/Vectors/ListVectorTypeModel.cs +++ b/src/FlatSharp/TypeModel/Vectors/ListVectorTypeModel.cs @@ -35,7 +35,7 @@ public override Type OnInitialize() FlatSharpInternal.Assert( genericDef == typeof(IList<>) || genericDef == typeof(IReadOnlyList<>), - $"Cannot build a vector from type: {this.ClrType}. Only List, ReadOnlyList, Memory, ReadOnlyMemory, and Arrays are supported."); + $"Cannot build a vector from type: {this.ClrType}. Only List, ReadOnlyList, Memory, and ReadOnlyMemory."); this.isReadOnly = genericDef == typeof(IReadOnlyList<>); return this.ClrType.GetGenericArguments()[0]; @@ -104,72 +104,39 @@ public override CodeGeneratedMethod CreateParseMethodBody(ParserCodeGenContext c context.AllFieldContexts, context.Options); - (string vectorClassDef, string vectorClassName) = FlatBufferVectorHelpers.CreateVectorItemAccessor( + Func? createVector = context.Options.DeserializationOption switch + { + FlatBufferDeserializationOption.Lazy => FlatBufferVectorHelpers.CreateLazyVector, + FlatBufferDeserializationOption.Progressive => FlatBufferVectorHelpers.CreateProgressiveVector, + FlatBufferDeserializationOption.Greedy => FlatBufferVectorHelpers.CreateGreedyVector, + FlatBufferDeserializationOption.GreedyMutable => FlatBufferVectorHelpers.CreateGreedyMutableVector, + _ => null, + }; + + FlatSharpInternal.Assert(createVector is not null, "unexpected deserialization mode"); + + (string classDef, string className) = createVector( this.ItemTypeModel, this.PaddedMemberInlineSize, context, isEverWriteThrough); - string accessorClassName = $"{vectorClassName}<{context.InputBufferTypeName}>"; - - string createFlatBufferVector = - $@"FlatBufferVectorBase<{this.ItemTypeModel.GetGlobalCompilableTypeName()}, {context.InputBufferTypeName}, {accessorClassName}>.GetOrCreate( - {context.InputBufferVariableName}, - new {accessorClassName}( - {context.OffsetVariableName} + {context.InputBufferVariableName}.{nameof(InputBufferExtensions.ReadUOffset)}({context.OffsetVariableName}), - {context.InputBufferVariableName}), + string body = + $@"return {className}<{context.InputBufferTypeName}>.GetOrCreate( + {context.InputBufferVariableName}, + {context.OffsetVariableName} + {context.InputBufferVariableName}.{nameof(InputBufferExtensions.ReadUOffset)}({context.OffsetVariableName}), {context.RemainingDepthVariableName}, - {context.TableFieldContextVariableName}, - {typeof(FlatBufferDeserializationOption).GetGlobalCompilableTypeName()}.{context.Options.DeserializationOption})"; + {context.TableFieldContextVariableName});"; - return new CodeGeneratedMethod(CreateParseBody(this.ItemTypeModel, createFlatBufferVector, accessorClassName, context, isEverWriteThrough)) { ClassDefinition = vectorClassDef }; + return new CodeGeneratedMethod(body) + { + ClassDefinition = classDef, + IsMethodInline = true, + }; } - internal static string CreateParseBody( - ITypeModel itemTypeModel, - string createFlatBufferVector, - string itemAccessorTypeName, - ParserCodeGenContext context, - bool isEverWriteThrough = false) + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) { - FlatSharpInternal.Assert(!string.IsNullOrEmpty(context.TableFieldContextVariableName), "expecting table field context"); - - if (context.Options.DeserializationOption == FlatBufferDeserializationOption.GreedyMutable && isEverWriteThrough) - { - string body = $$""" - - var result = {{createFlatBufferVector}}; - if ({{context.TableFieldContextVariableName}}.{{nameof(TableFieldContext.WriteThrough)}}) - { - // WriteThrough vectors are not mutable in greedymutable mode. - return ImmutableList<{{itemTypeModel.ClrType.GetGlobalCompilableTypeName()}}>.GetOrCreate(result); - } - else - { - return PoolableList<{{itemTypeModel.ClrType.GetGlobalCompilableTypeName()}}>.GetOrCreate(result); - } - """; - - return body; - } - else if (context.Options.GreedyDeserialize) - { - string transform = "ImmutableList"; - if (context.Options.GenerateMutableObjects) - { - transform = "PoolableList"; - } - - return $"return {transform}<{itemTypeModel.ClrType.GetGlobalCompilableTypeName()}>.GetOrCreate({createFlatBufferVector});"; - } - else if (context.Options.Lazy) - { - return $"return {createFlatBufferVector};"; - } - else - { - FlatSharpInternal.Assert(context.Options.Progressive, "expecting progressive"); - return $"return FlatBufferProgressiveVector<{itemTypeModel.GetGlobalCompilableTypeName()}, {context.InputBufferTypeName}, {itemAccessorTypeName}>.GetOrCreate({createFlatBufferVector});"; - } + return this.GetGlobalCompilableTypeName(); } } diff --git a/src/FlatSharp/TypeModel/Vectors/MemoryVectorTypeModel.cs b/src/FlatSharp/TypeModel/Vectors/MemoryVectorTypeModel.cs index b2dc999d..c5172c9d 100644 --- a/src/FlatSharp/TypeModel/Vectors/MemoryVectorTypeModel.cs +++ b/src/FlatSharp/TypeModel/Vectors/MemoryVectorTypeModel.cs @@ -91,4 +91,9 @@ public override CodeGeneratedMethod CreateCloneMethodBody(CloneCodeGenContext co IsMethodInline = true, }; } + + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + return this.GetGlobalCompilableTypeName(); + } } diff --git a/src/FlatSharp/TypeModel/Vectors/UnityNativeArrayVectorTypeModel.cs b/src/FlatSharp/TypeModel/Vectors/UnityNativeArrayVectorTypeModel.cs index a758f79a..155c8b22 100644 --- a/src/FlatSharp/TypeModel/Vectors/UnityNativeArrayVectorTypeModel.cs +++ b/src/FlatSharp/TypeModel/Vectors/UnityNativeArrayVectorTypeModel.cs @@ -110,4 +110,9 @@ public override CodeGeneratedMethod CreateCloneMethodBody(CloneCodeGenContext co IsMethodInline = true, }; } + + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + return this.GetGlobalCompilableTypeName(); + } } diff --git a/src/FlatSharp/TypeModel/VectorsOfUnion/ListVectorOfUnionTypeModel.cs b/src/FlatSharp/TypeModel/VectorsOfUnion/ListVectorOfUnionTypeModel.cs index 84f81833..b3a9c491 100644 --- a/src/FlatSharp/TypeModel/VectorsOfUnion/ListVectorOfUnionTypeModel.cs +++ b/src/FlatSharp/TypeModel/VectorsOfUnion/ListVectorOfUnionTypeModel.cs @@ -30,30 +30,37 @@ public ListVectorOfUnionTypeModel(Type clrType, TypeModelContainer container) public override CodeGeneratedMethod CreateParseMethodBody(ParserCodeGenContext context) { - var (classDef, className) = FlatBufferVectorHelpers.CreateVectorOfUnionItemAccessor( - this.ItemTypeModel, - context); + Func? createVector = context.Options.DeserializationOption switch + { + FlatBufferDeserializationOption.Lazy => FlatBufferVectorHelpers.CreateLazyUnionVector, + FlatBufferDeserializationOption.Progressive => FlatBufferVectorHelpers.CreateProgressiveUnionVector, + FlatBufferDeserializationOption.Greedy => FlatBufferVectorHelpers.CreateGreedyUnionVector, + FlatBufferDeserializationOption.GreedyMutable => FlatBufferVectorHelpers.CreateGreedyMutableUnionVector, + _ => null, + }; + + FlatSharpInternal.Assert(createVector is not null, "unexpected deserialization mode"); + + (string classDef, string className) = createVector(this.ItemTypeModel, context); - string itemAccessorTypeName = $"{className}<{context.InputBufferTypeName}>"; + string body = + $@" + var offsets = + ( + {context.OffsetVariableName}.offset0 + {context.InputBufferVariableName}.{nameof(InputBufferExtensions.ReadUOffset)}({context.OffsetVariableName}.offset0), + {context.OffsetVariableName}.offset1 + {context.InputBufferVariableName}.{nameof(InputBufferExtensions.ReadUOffset)}({context.OffsetVariableName}.offset1) + ); - string createFlatBufferVector = - $@"FlatBufferVectorBase<{this.ItemTypeModel.GetGlobalCompilableTypeName()}, {context.InputBufferTypeName}, {itemAccessorTypeName}>.GetOrCreate( - {context.InputBufferVariableName}, - new {itemAccessorTypeName}( - {context.InputBufferVariableName}, - {context.OffsetVariableName}.offset0 + {context.InputBufferVariableName}.{nameof(InputBufferExtensions.ReadUOffset)}({context.OffsetVariableName}.offset0), - {context.OffsetVariableName}.offset1 + {context.InputBufferVariableName}.{nameof(InputBufferExtensions.ReadUOffset)}({context.OffsetVariableName}.offset1)), + return {className}<{context.InputBufferTypeName}>.GetOrCreate( + {context.InputBufferVariableName}, + ref offsets, {context.RemainingDepthVariableName}, - {context.TableFieldContextVariableName}, - {typeof(FlatBufferDeserializationOption).GetGlobalCompilableTypeName()}.{context.Options.DeserializationOption})"; + {context.TableFieldContextVariableName});"; - return new CodeGeneratedMethod(ListVectorTypeModel.CreateParseBody( - this.ItemTypeModel, - createFlatBufferVector, - itemAccessorTypeName, - context)) - { - ClassDefinition = classDef + return new CodeGeneratedMethod(body) + { + ClassDefinition = classDef, + IsMethodInline = true, }; } @@ -67,4 +74,9 @@ public override Type OnInitialize() return this.ClrType.GetGenericArguments()[0]; } + + public override string GetDeserializedTypeName(IMethodNameResolver nameResolver, FlatBufferDeserializationOption option, string inputBufferTypeName) + { + return this.GetGlobalCompilableTypeName(); + } } diff --git a/src/Tests/FlatSharpCompilerTests/CopyConstructorTests.cs b/src/Tests/FlatSharpCompilerTests/CopyConstructorTests.cs deleted file mode 100644 index b7acea4c..00000000 --- a/src/Tests/FlatSharpCompilerTests/CopyConstructorTests.cs +++ /dev/null @@ -1,451 +0,0 @@ -/* - * Copyright 2021 James Courtney - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -using FlatSharp.Internal; -using System.Linq; -using Unity.Collections; - -namespace FlatSharpTests.Compiler; - -#if NETCOREAPP3_1_OR_GREATER - -public class CopyConstructorTests -{ - [Fact] - public void CopyConstructorsTest() - { - string schema = $@" -{MetadataHelpers.AllAttributes} -namespace CopyConstructorTest; - -union Union {{ OuterTable, InnerTable, OuterStruct, InnerStruct }} // Optionally add more tables. - -table OuterTable ({MetadataKeys.SerializerKind}: ""Greedy"") {{ - A:string (id: 0); - - B:byte (id: 1); - C:ubyte (id: 2); - D:int16 (id: 3); - E:uint16 (id: 4); - F:int32 (id: 5); - G:uint32 (id: 6); - H:int64 (id: 7); - I:uint64 (id: 8); - - IntVector_List:[int] ({MetadataKeys.VectorKind}:""IList"", id: 9); - IntVector_RoList:[int] ({MetadataKeys.VectorKind}:""IReadOnlyList"", id: 10); - IntVector_Array:[int] ({MetadataKeys.VectorKind}:""IList"", id: 11); - IntVector_NativeArray:[int] ({MetadataKeys.VectorKind}:""UnityNativeArray"", id: 26); - - TableVector_List:[InnerTable] ({MetadataKeys.VectorKind}:""IList"", id: 12); - TableVector_RoList:[InnerTable] ({MetadataKeys.VectorKind}:""IReadOnlyList"", id: 13); - TableVector_Indexed:[InnerTable] ({MetadataKeys.VectorKind}:""IIndexedVector"", id: 14); - TableVector_Array:[InnerTable] ({MetadataKeys.VectorKind}:""IList"", id: 15); - - ByteVector:[ubyte] ({MetadataKeys.VectorKind}:""Memory"", id: 16); - ByteVector_RO:[ubyte] ({MetadataKeys.VectorKind}:""ReadOnlyMemory"", id: 17); - UnionVal : Union (id: 19); - - VectorOfUnion : [Union] (id: 21); - VectorOfUnion_RoList : [Union] (id: 23, {MetadataKeys.VectorKind}:""IReadOnlyList""); - VectorOfUnion_Array : [Union] (id: 25, {MetadataKeys.VectorKind}:""IList""); -}} - -struct InnerStruct {{ - LongValue:int64; -}} - -struct OuterStruct {{ - Value:int; - InnerStructVal:InnerStruct; -}} - -table InnerTable {{ - Name:string ({MetadataKeys.Key}); - OuterStructVal:OuterStruct; -}} - -"; - OuterTable original = new OuterTable - { - A = "string", - B = 1, - C = 2, - D = 3, - E = 4, - F = 5, - G = 6, - H = 7, - I = 8, - - ByteVector = new byte[] { 1, 2, 3, }.AsMemory(), - ByteVector_RO = new byte[] { 4, 5, 6, }.AsMemory(), - - IntVector_Array = new[] { 7, 8, 9, }, - IntVector_List = new[] { 10, 11, 12, }.ToList(), - IntVector_RoList = new[] { 13, 14, 15 }.ToList(), - IntVector_NativeArray = new NativeArray(new[] { 16, 17, 18, }, Allocator.Persistent), - - TableVector_Array = CreateInner("Rocket", "Molly", "Clementine"), - TableVector_Indexed = new IndexedVector(CreateInner("Pudge", "Sunshine", "Gypsy"), false), - TableVector_List = CreateInner("Finnegan", "Daisy"), - TableVector_RoList = CreateInner("Gordita", "Lunchbox"), - - UnionVal = new FlatBufferUnion(new OuterStruct()), - VectorOfUnion = new List> - { - new(new OuterTable()), - new(new InnerTable()), - new(new OuterStruct()), - new(new InnerStruct()), - }, - VectorOfUnion_RoList = new List> - { - new(new OuterTable()), - new(new InnerTable()), - new(new OuterStruct()), - new(new InnerStruct()), - }, - VectorOfUnion_Array = new FlatBufferUnion[] - { - new(new OuterTable()), - new(new InnerTable()), - new(new OuterStruct()), - new(new InnerStruct()), - } - }; - - byte[] data = new byte[FlatBufferSerializer.DefaultWithUnitySupport.GetMaxSize(original)]; - int bytesWritten = FlatBufferSerializer.DefaultWithUnitySupport.Serialize(original, data); - - Assembly asm = FlatSharpCompiler.CompileAndLoadAssembly(schema, new() { NormalizeFieldNames = false, UnityAssemblyPath = typeof(NativeArray<>).Assembly.Location}); - - Type outerTableType = asm.GetType("CopyConstructorTest.OuterTable"); - dynamic serializer = outerTableType.GetProperty("Serializer", BindingFlags.Public | BindingFlags.Static).GetValue(null); - object parsedObj = serializer.Parse(new ArrayInputBuffer(data)); - dynamic parsed = parsedObj; - dynamic copied = Activator.CreateInstance(outerTableType, (object)parsed); - //dynamic copied = new CopyConstructorTest.OuterTable((CopyConstructorTest.OuterTable)parsedObj); - - // Strings can be copied by reference since they are immutable. - Assert.Equal(original.A, copied.A); - Assert.Equal(original.A, parsed.A); - - Assert.Equal(original.B, copied.B); - Assert.Equal(original.C, copied.C); - Assert.Equal(original.D, copied.D); - Assert.Equal(original.E, copied.E); - Assert.Equal(original.F, copied.F); - Assert.Equal(original.G, copied.G); - Assert.Equal(original.H, copied.H); - Assert.Equal(original.I, copied.I); - - DeepCompareIntVector(original.IntVector_Array, parsed.IntVector_Array, copied.IntVector_Array); - DeepCompareIntVector(original.IntVector_List, parsed.IntVector_List, copied.IntVector_List); - DeepCompareIntVector(original.IntVector_RoList, parsed.IntVector_RoList, copied.IntVector_RoList); - DeepCompareIntVector(original.IntVector_NativeArray, parsed.IntVector_NativeArray, copied.IntVector_NativeArray); - - - Assert.Equal((byte)3, original.UnionVal.Value.Discriminator); - Assert.Equal((byte)3, parsed.UnionVal.Discriminator); - Assert.Equal((byte)3, copied.UnionVal.Discriminator); - Assert.Equal("CopyConstructorTest.OuterStruct", copied.UnionVal.Item3.GetType().FullName); - Assert.NotEqual("CopyConstructorTest.OuterStruct", parsed.UnionVal.Item3.GetType().FullName); - Assert.NotSame(parsed.UnionVal, copied.UnionVal); - Assert.NotSame(parsed.UnionVal.Item3, copied.UnionVal.Item3); - - for (int i = 1; i <= 4; ++i) - { - Assert.Equal((byte)i, original.VectorOfUnion[i - 1].Discriminator); - Assert.Equal((byte)i, (byte)parsed.VectorOfUnion[i - 1].Discriminator); - Assert.Equal((byte)i, (byte)copied.VectorOfUnion[i - 1].Discriminator); - } - - Assert.NotSame(parsed.VectorOfUnion[0].Item1, copied.VectorOfUnion[0].Item1); - Assert.NotSame(parsed.VectorOfUnion[1].Item2, copied.VectorOfUnion[1].Item2); - Assert.NotSame(parsed.VectorOfUnion[2].Item3, copied.VectorOfUnion[2].Item3); - Assert.NotSame(parsed.VectorOfUnion[3].Item4, copied.VectorOfUnion[3].Item4); - - for (int i = 1; i <= 4; ++i) - { - Assert.Equal((byte)i, original.VectorOfUnion_RoList[i - 1].Discriminator); - Assert.Equal((byte)i, (byte)parsed.VectorOfUnion_RoList[i - 1].Discriminator); - Assert.Equal((byte)i, (byte)copied.VectorOfUnion_RoList[i - 1].Discriminator); - } - - Assert.NotSame(parsed.VectorOfUnion_RoList[0].Item1, copied.VectorOfUnion_RoList[0].Item1); - Assert.NotSame(parsed.VectorOfUnion_RoList[1].Item2, copied.VectorOfUnion_RoList[1].Item2); - Assert.NotSame(parsed.VectorOfUnion_RoList[2].Item3, copied.VectorOfUnion_RoList[2].Item3); - Assert.NotSame(parsed.VectorOfUnion_RoList[3].Item4, copied.VectorOfUnion_RoList[3].Item4); - - for (int i = 1; i <= 4; ++i) - { - Assert.Equal((byte)i, original.VectorOfUnion_Array[i - 1].Discriminator); - Assert.Equal((byte)i, (byte)parsed.VectorOfUnion_Array[i - 1].Discriminator); - Assert.Equal((byte)i, (byte)copied.VectorOfUnion_Array[i - 1].Discriminator); - } - - Assert.NotSame(parsed.VectorOfUnion_Array[0].Item1, copied.VectorOfUnion_Array[0].Item1); - Assert.NotSame(parsed.VectorOfUnion_Array[1].Item2, copied.VectorOfUnion_Array[1].Item2); - Assert.NotSame(parsed.VectorOfUnion_Array[2].Item3, copied.VectorOfUnion_Array[2].Item3); - Assert.NotSame(parsed.VectorOfUnion_Array[3].Item4, copied.VectorOfUnion_Array[3].Item4); - - Memory? mem = copied.ByteVector; - Memory? pMem = parsed.ByteVector; - Assert.True(original.ByteVector.Value.Span.SequenceEqual(mem.Value.Span)); - Assert.False(mem.Value.Span.Overlaps(pMem.Value.Span)); - - ReadOnlyMemory? roMem = copied.ByteVector_RO; - ReadOnlyMemory? pRoMem = parsed.ByteVector_RO; - Assert.True(original.ByteVector_RO.Value.Span.SequenceEqual(roMem.Value.Span)); - Assert.False(roMem.Value.Span.Overlaps(pRoMem.Value.Span)); - - // array of table - { - int count = original.TableVector_Array.Count; - Assert.NotSame(parsed.TableVector_Array, copied.TableVector_Array); - for (int i = 0; i < count; ++i) - { - var p = parsed.TableVector_Array[i]; - var c = copied.TableVector_Array[i]; - DeepCompareInnerTable(original.TableVector_Array[i], p, c); - } - } - - // list of table. - { - Assert.False(object.ReferenceEquals(parsed.TableVector_List, copied.TableVector_List)); - - IEnumerable parsedEnum = AsObjectEnumerable(parsed.TableVector_List); - IEnumerable copiedEnum = AsObjectEnumerable(copied.TableVector_List); - - foreach (var ((p, c), o) in parsedEnum.Zip(copiedEnum).Zip(original.TableVector_List)) - { - DeepCompareInnerTable(o, p, c); - } - } - - // read only list of table. - { - Assert.False(object.ReferenceEquals(parsed.TableVector_RoList, copied.TableVector_RoList)); - - IEnumerable parsedEnum = AsObjectEnumerable(parsed.TableVector_RoList); - IEnumerable copiedEnum = AsObjectEnumerable(copied.TableVector_RoList); - - foreach (var ((p, c), o) in parsedEnum.Zip(copiedEnum).Zip(original.TableVector_RoList)) - { - DeepCompareInnerTable(o, p, c); - } - } - - // indexed vector of table. - { - Assert.False(object.ReferenceEquals(parsed.TableVector_Indexed, copied.TableVector_Indexed)); - foreach (var kvp in original.TableVector_Indexed) - { - string key = kvp.Key; - InnerTable? value = kvp.Value; - - var parsedValue = parsed.TableVector_Indexed[key]; - var copiedValue = copied.TableVector_Indexed[key]; - - Assert.NotNull(parsedValue); - Assert.NotNull(copiedValue); - - DeepCompareInnerTable(value, parsedValue, copiedValue); - } - } - } - - private void DeepCompareIntVector(IEnumerable a, IEnumerable b, IEnumerable c) - { - foreach (var pair in a.Zip(b).Zip(c)) - { - int i = pair.First.First; - int ii = pair.First.Second; - int iii = pair.Second; - - Assert.Equal(i, ii); - Assert.Equal(ii, iii); - } - } - - private InnerTable[] CreateInner(params string[] names) - { - InnerTable[] table = new InnerTable[names.Length]; - for (int i = 0; i < names.Length; ++i) - { - table[i] = new InnerTable - { - Name = names[i], - OuterStruct = new OuterStruct - { - Value = 1, - InnerStruct = new InnerStruct - { - LongValue = 2, - }, - } - }; - } - - return table; - } - - private static void DeepCompareInnerTable(InnerTable a, dynamic p, dynamic c) - { - Assert.NotSame(p, c); - - Assert.NotEqual("CopyConstructorTest.InnerTable", (string)p.GetType().FullName); - Assert.Equal("CopyConstructorTest.InnerTable", (string)c.GetType().FullName); - - Assert.Equal(a.Name, p.Name); - Assert.Equal(a.Name, c.Name); - - var pOuter = p.OuterStructVal; - var cOuter = c.OuterStructVal; - - Assert.NotSame(pOuter, cOuter); - Assert.NotEqual("CopyConstructorTest.OuterStruct", (string)pOuter.GetType().FullName); - Assert.Equal("CopyConstructorTest.OuterStruct", (string)cOuter.GetType().FullName); - - Assert.Equal(a.OuterStruct.Value, pOuter.Value); - Assert.Equal(a.OuterStruct.Value, cOuter.Value); - - var pInner = pOuter.InnerStructVal; - var cInner = cOuter.InnerStructVal; - - Assert.NotSame(pInner, cInner); - Assert.NotEqual("CopyConstructorTest.InnerStruct", (string)pInner.GetType().FullName); - Assert.Equal("CopyConstructorTest.InnerStruct", (string)cInner.GetType().FullName); - - Assert.Equal(a.OuterStruct.InnerStruct.LongValue, pInner.LongValue); - Assert.Equal(a.OuterStruct.InnerStruct.LongValue, cInner.LongValue); - } - - [FlatBufferTable] - public class OuterTable - { - [FlatBufferItem(0)] - public virtual string? A { get; set; } - - [FlatBufferItem(1)] - public virtual sbyte B { get; set; } - - [FlatBufferItem(2)] - public virtual byte C { get; set; } - - [FlatBufferItem(3)] - public virtual short D { get; set; } - - [FlatBufferItem(4)] - public virtual ushort E { get; set; } - - [FlatBufferItem(5)] - public virtual int F { get; set; } - - [FlatBufferItem(6)] - public virtual uint G { get; set; } - - [FlatBufferItem(7)] - public virtual long H { get; set; } - - [FlatBufferItem(8)] - public virtual ulong I { get; set; } - - [FlatBufferItem(9)] - public virtual IList? IntVector_List { get; set; } - - [FlatBufferItem(10)] - public virtual IReadOnlyList? IntVector_RoList { get; set; } - - [FlatBufferItem(11)] - public virtual IList? IntVector_Array { get; set; } - - [FlatBufferItem(26)] - public virtual NativeArray? IntVector_NativeArray { get; set; } - - [FlatBufferItem(12)] - public virtual IList? TableVector_List { get; set; } - - [FlatBufferItem(13)] - public virtual IReadOnlyList? TableVector_RoList { get; set; } - - [FlatBufferItem(14)] - public virtual IIndexedVector? TableVector_Indexed { get; set; } - - [FlatBufferItem(15)] - public virtual IList? TableVector_Array { get; set; } - - [FlatBufferItem(16)] - public virtual Memory? ByteVector { get; set; } - - [FlatBufferItem(17)] - public virtual ReadOnlyMemory? ByteVector_RO { get; set; } - - [FlatBufferItem(18)] - public virtual FlatBufferUnion? UnionVal { get; set; } - - [FlatBufferItem(20)] - public virtual IList>? VectorOfUnion { get; set; } - - [FlatBufferItem(22)] - public virtual IReadOnlyList>? VectorOfUnion_RoList { get; set; } - - [FlatBufferItem(24)] - public virtual IList>? VectorOfUnion_Array { get; set; } - } - - [FlatBufferTable] - public class InnerTable : ISortableTable - { - static InnerTable() => SortedVectorHelpers.RegisterKeyLookup(it => it.Name, 0); - - [FlatBufferItem(0, Key = true, Required = true)] - public virtual string Name { get; set; } = "Foo"; - - [FlatBufferItem(1)] - public virtual OuterStruct? OuterStruct { get; set; } - } - - [FlatBufferStruct] - public class OuterStruct - { - [FlatBufferItem(0)] - public virtual int Value { get; set; } - - [FlatBufferItem(1)] - public virtual InnerStruct InnerStruct { get; set; } - } - - [FlatBufferStruct] - public class InnerStruct - { - [FlatBufferItem(0)] - public virtual long LongValue { get; set; } - } - - private static IEnumerable AsObjectEnumerable(dynamic d) - { - IEnumerable enumerator = d; - foreach (var item in enumerator) - { - yield return item; - } - } -} - -#endif diff --git a/src/Tests/FlatSharpEndToEndTests/ClassLib/ImmutableListTests.cs b/src/Tests/FlatSharpEndToEndTests/ClassLib/ImmutableListTests.cs deleted file mode 100644 index 25928b15..00000000 --- a/src/Tests/FlatSharpEndToEndTests/ClassLib/ImmutableListTests.cs +++ /dev/null @@ -1,119 +0,0 @@ -/* - * Copyright 2022 James Courtney - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -using FlatSharp.Internal; - -namespace FlatSharpEndToEndTests.ImmutableList; - -/// -/// Tests for the FlatBufferVector class that implements IList. -/// - -public class ImmutableListTests -{ - private readonly ImmutableList items = new ImmutableList(new[] { 0, 1, 2, 3, 4, 5, }); - - [Fact] - public void Clear_NotSupported() - { - Assert.Throws(this.items.Clear); - } - - [Fact] - public void RemoveAt_NotSupported() - { - Assert.Throws(() => this.items.RemoveAt(0)); - } - - [Fact] - public void Remove_NotSupported() - { - Assert.Throws(() => this.items.Remove(0)); - } - - [Fact] - public void Setter_NotSupported() - { - Assert.Throws(() => this.items[0] = 5); - } - - [Fact] - public void Add_NotSupported() - { - Assert.Throws(() => this.items.Add(6)); - } - - [Fact] - public void Insert_NotSupported() - { - Assert.Throws(() => this.items.Insert(6, 6)); - } - - [Fact] - public void Get() - { - for (int i = 0; i < this.items.Count; ++i) - { - Assert.Equal(i, this.items[i]); - } - } - - [Fact] - public void Contains() - { - for (int i = 0; i < this.items.Count; ++i) - { -#pragma warning disable xUnit2017 // Do not use Contains() to check if a value exists in a collection - // Justification: want to ensure correct method is invoked. - - Assert.True(this.items.Contains(i)); - -#pragma warning restore xUnit2017 // Do not use Contains() to check if a value exists in a collection - - Assert.Equal(i, this.items.IndexOf(i)); - } - } - - [Fact] - public void GetEnumerator() - { - int i = 0; - foreach (var item in this.items) - { - Assert.Equal(i++, item); - } - - Assert.Equal(i, this.items.Count); - } - - [Fact] - public void CopyTo() - { - int[] temp = new int[20]; - this.items.CopyTo(temp, 10); - - for (int i = 0; i < this.items.Count; ++i) - { - Assert.Equal(temp[i + 10], this.items[i]); - } - } - - [Fact] - public void ReadOnly() - { - Assert.True(this.items.IsReadOnly); - } -} diff --git a/src/Tests/FlatSharpEndToEndTests/ClassLib/PoolableListTests.cs b/src/Tests/FlatSharpEndToEndTests/ClassLib/PoolableListTests.cs deleted file mode 100644 index 826883b2..00000000 --- a/src/Tests/FlatSharpEndToEndTests/ClassLib/PoolableListTests.cs +++ /dev/null @@ -1,148 +0,0 @@ -/* - * Copyright 2022 James Courtney - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -using FlatSharp.Internal; - -namespace FlatSharpEndToEndTests.PoolableList; - -/// -/// Tests for the FlatBufferVector class that implements IList. -/// - -public class PoolableListTests -{ - private PoolableList Items => new PoolableList(new[] { 0, 1, 2, 3, 4, 5, }); - - [Fact] - public void Clear() - { - var items = this.Items; - Assert.NotEmpty(items); - items.Clear(); - Assert.Empty(items); - } - - [Fact] - public void RemoveAt() - { - var items = this.Items; - Assert.Equal(2, items[2]); - Assert.Equal(6, items.Count); - items.RemoveAt(2); - Assert.Equal(3, items[2]); - Assert.Equal(5, items.Count); - } - - [Fact] - public void Remove() - { - var items = this.Items; - Assert.Equal(6, items.Count); - items.Remove(4); - Assert.Equal(5, items.Count); - Assert.Equal(5, items[4]); - } - - [Fact] - public void Setter() - { - var items = this.Items; - Assert.Equal(2, items[2]); - items[2] = 10; - Assert.Equal(10, items[2]); - } - - [Fact] - public void Add() - { - var items = this.Items; - Assert.Equal(6, items.Count); - items.Add(6); - Assert.Equal(7, items.Count); - Assert.Equal(6, items[6]); - } - - [Fact] - public void Insert() - { - var items = this.Items; - Assert.Equal(6, items.Count); - items.Insert(1, 10); - Assert.Equal(7, items.Count); - Assert.Equal(10, items[1]); - Assert.Equal(1, items[2]); - } - - [Fact] - public void Get() - { - var items = this.Items; - for (int i = 0; i < items.Count; ++i) - { - Assert.Equal(i, items[i]); - } - } - - [Fact] - public void Contains() - { - var items = this.Items; - for (int i = 0; i < items.Count; ++i) - { -#pragma warning disable xUnit2017 // Do not use Contains() to check if a value exists in a collection - // Justification: want to ensure correct method is invoked. - - Assert.True(items.Contains(i)); - -#pragma warning restore xUnit2017 // Do not use Contains() to check if a value exists in a collection - - Assert.Equal(i, items.IndexOf(i)); - } - } - - [Fact] - public void GetEnumerator() - { - var items = this.Items; - int i = 0; - foreach (var item in items) - { - Assert.Equal(i++, item); - } - - Assert.Equal(i, items.Count); - } - - [Fact] - public void CopyTo() - { - var items = this.Items; - int[] temp = new int[20]; - items.CopyTo(temp, 10); - - for (int i = 0; i < items.Count; ++i) - { - Assert.Equal(temp[i + 10], items[i]); - } - } - - [Fact] - public void ReadOnly() - { - var items = this.Items; - Assert.False(items.IsReadOnly); - } -} diff --git a/src/Tests/FlatSharpEndToEndTests/Helpers.cs b/src/Tests/FlatSharpEndToEndTests/Helpers.cs index 2e557643..6de92522 100644 --- a/src/Tests/FlatSharpEndToEndTests/Helpers.cs +++ b/src/Tests/FlatSharpEndToEndTests/Helpers.cs @@ -15,6 +15,7 @@ */ using FlatSharp.Internal; +using System; using System.Linq.Expressions; using System.Reflection; using System.Threading; @@ -23,6 +24,14 @@ namespace FlatSharpEndToEndTests; public static class Helpers { + public static void Repeat(Action action, int times = 5) + { + for (int i = 0; i < times; ++i) + { + action(); + } + } + public static byte[] AllocateAndSerialize(this T item) where T : class, IFlatBufferSerializable { return item.AllocateAndSerialize(item.Serializer); @@ -154,25 +163,72 @@ public static void AssertMutationWorks( } } - public static void AssertMutationWorks( + public static void ValidateListVector( FlatBufferDeserializationOption option, bool isWriteThrough, IList items, T newValue) { - if (option != FlatBufferDeserializationOption.Lazy) + // This can be lots of things: NotMutable, ArgumentOfRange, IndexOutOfRange, etc. + Assert.ThrowsAny(() => items[-1]); + Assert.ThrowsAny(() => items[items.Count]); + Assert.ThrowsAny(() => items[-1] = default); + Assert.ThrowsAny(() => items[items.Count] = default); + + if (items is IFlatBufferDeserializedVector vec) + { + Assert.ThrowsAny(() => vec.OffsetOf(-1)); + Assert.ThrowsAny(() => vec.OffsetOf(items.Count)); + + for (int i = 0; i < vec.Count; ++i) + { + Assert.Equal(vec.OffsetOf(i), vec.OffsetBase + (i * vec.ItemSize)); + } + + Assert.ThrowsAny(() => vec.ItemAt(-1)); + Assert.ThrowsAny(() => vec.ItemAt(items.Count)); + } + { T[] target = new T[items.Count]; items.CopyTo(target, 0); - for (int i = 0; i < items.Count; ++i) + Assert.Equal(items.Count, target.Length); + + if (option != FlatBufferDeserializationOption.Lazy || typeof(T).IsPrimitive || typeof(T) == typeof(string)) { - Assert.Equal(i, items.IndexOf(items[i])); - Assert.True(items.Contains(items[i])); - Assert.Equal(items[i], target[i]); + for (int i = 0; i < items.Count; ++i) + { + if (typeof(T).IsValueType || option == FlatBufferDeserializationOption.Lazy) + { + Assert.Equal(items[i], target[i]); + } + else + { +#pragma warning disable xUnit2005 // Do not use identity check on value type + Assert.Same(items[i], items[i]); +#pragma warning restore xUnit2005 // Do not use identity check on value type + } + + Assert.Equal(i, items.IndexOf(items[i])); + Assert.True(items.Contains(items[i])); + } + } + else if (!typeof(T).IsValueType) + { + for (int i = 0; i < items.Count; ++i) + { + Assert.NotEqual(i, items.IndexOf(items[i])); + Assert.False(items.Contains(items[i])); + Assert.NotEqual(items[i], target[i]); + } } } + Assert.Equal( + items.IsReadOnly, + option != FlatBufferDeserializationOption.GreedyMutable); + for (int i = 0; i < items.Count; ++i) { switch (option) @@ -209,13 +265,22 @@ public static void AssertMutationWorks( } } - if (option == FlatBufferDeserializationOption.GreedyMutable) + if (option == FlatBufferDeserializationOption.GreedyMutable && !isWriteThrough) { items.Clear(); + Assert.Empty(items); + items.Add(default); + Assert.Single(items); + items.Remove(items[0]); + Assert.Empty(items); + items.Insert(0, default); + Assert.Single(items); + items.RemoveAt(0); + Assert.Empty(items); } else { diff --git a/src/Tests/FlatSharpEndToEndTests/Vectors/Standard/StandardVectorTests.cs b/src/Tests/FlatSharpEndToEndTests/Vectors/Standard/StandardVectorTests.cs index 54fd3bda..c929f0ca 100644 --- a/src/Tests/FlatSharpEndToEndTests/Vectors/Standard/StandardVectorTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/Vectors/Standard/StandardVectorTests.cs @@ -34,7 +34,7 @@ public void Lazy_String_IList_Implicit() Assert.NotNull(obj.InputBuffer); IList list = table.ImplicitStringList; - Assert.Contains("FlatBufferVectorBase", list.GetType().FullName); + //Assert.Contains("FlatBufferVectorBase", list.GetType().FullName); // lazy returns unique instances. Assert.False(object.ReferenceEquals(table.ImplicitStringList, table.ImplicitStringList)); @@ -58,7 +58,7 @@ public void Lazy_String_IList_Explicit() Assert.NotNull(obj.InputBuffer); IList list = table.ExplicitStringList; - Assert.Contains("FlatBufferVectorBase", list.GetType().FullName); + //Assert.Contains("FlatBufferVectorBase", list.GetType().FullName); // lazy returns unique instances. Assert.False(object.ReferenceEquals(table.ExplicitStringList, table.ExplicitStringList)); @@ -81,7 +81,7 @@ public void Lazy_String_IReadOnlyList_Explicit() Assert.NotNull(obj.InputBuffer); IReadOnlyList list = table.ReadOnlyStringList; - Assert.Contains("FlatBufferVectorBase", list.GetType().FullName); + //Assert.Contains("FlatBufferVectorBase", list.GetType().FullName); // lazy returns unique instances. Assert.False(object.ReferenceEquals(table.ReadOnlyStringList, table.ReadOnlyStringList)); @@ -166,7 +166,7 @@ public void Progressive_String_IList_Implicit() Assert.NotNull(obj.InputBuffer); IList list = table.ImplicitStringList; - Assert.Contains("FlatBufferProgressiveVector", list.GetType().FullName); + //Assert.Contains("FlatBufferProgressiveVector", list.GetType().FullName); Assert.True(object.ReferenceEquals(table.ImplicitStringList, table.ImplicitStringList)); Assert.True(object.ReferenceEquals(list[5], list[5])); @@ -189,7 +189,7 @@ public void Progressive_String_IList_Explicit() Assert.NotNull(obj.InputBuffer); IList list = table.ExplicitStringList; - Assert.Contains("FlatBufferProgressiveVector", list.GetType().FullName); + //Assert.Contains("FlatBufferProgressiveVector", list.GetType().FullName); // Progressive returns the same instance. Assert.True(object.ReferenceEquals(table.ExplicitStringList, table.ExplicitStringList)); @@ -212,7 +212,7 @@ public void Progressive_String_IReadOnlyList_Explicit() Assert.NotNull(obj.InputBuffer); IReadOnlyList list = table.ReadOnlyStringList; - Assert.Contains("FlatBufferProgressiveVector", list.GetType().FullName); + //Assert.Contains("FlatBufferProgressiveVector", list.GetType().FullName); Assert.True(object.ReferenceEquals(table.ReadOnlyStringList, table.ReadOnlyStringList)); Assert.True(object.ReferenceEquals(list[5], list[5])); @@ -296,7 +296,7 @@ public void Greedy_String_IList_Implicit() Assert.Null(obj.InputBuffer); IList list = table.ImplicitStringList; - Assert.Contains("ImmutableList", list.GetType().FullName); + //Assert.Contains("ImmutableList", list.GetType().FullName); Assert.True(object.ReferenceEquals(table.ImplicitStringList, table.ImplicitStringList)); Assert.True(object.ReferenceEquals(list[5], list[5])); @@ -319,7 +319,7 @@ public void Greedy_String_IList_Explicit() Assert.Null(obj.InputBuffer); IList list = table.ExplicitStringList; - Assert.Contains("ImmutableList", list.GetType().FullName); + //Assert.Contains("ImmutableList", list.GetType().FullName); // Progressive returns the same instance. Assert.True(object.ReferenceEquals(table.ExplicitStringList, table.ExplicitStringList)); @@ -342,7 +342,7 @@ public void Greedy_String_IReadOnlyList_Explicit() Assert.Null(obj.InputBuffer); IReadOnlyList list = table.ReadOnlyStringList; - Assert.Contains("ImmutableList", list.GetType().FullName); + //Assert.Contains("ImmutableList", list.GetType().FullName); Assert.True(object.ReferenceEquals(table.ReadOnlyStringList, table.ReadOnlyStringList)); Assert.True(object.ReferenceEquals(list[5], list[5])); @@ -427,7 +427,7 @@ public void GreedyMutable_String_IList_Implicit() Assert.Null(obj.InputBuffer); IList list = table.ImplicitStringList; - Assert.Contains("PoolableList", list.GetType().FullName); + //Assert.Contains("PoolableList", list.GetType().FullName); Assert.True(object.ReferenceEquals(table.ImplicitStringList, table.ImplicitStringList)); Assert.True(object.ReferenceEquals(list[5], list[5])); @@ -450,7 +450,7 @@ public void GreedyMutable_String_IList_Explicit() Assert.Null(obj.InputBuffer); IList list = table.ExplicitStringList; - Assert.Contains("PoolableList", list.GetType().FullName); + //Assert.Contains("PoolableList", list.GetType().FullName); // Progressive returns the same instance. Assert.True(object.ReferenceEquals(table.ExplicitStringList, table.ExplicitStringList)); @@ -473,7 +473,7 @@ public void GreedyMutable_String_IReadOnlyList_Explicit() Assert.Null(obj.InputBuffer); IReadOnlyList list = table.ReadOnlyStringList; - Assert.Contains("PoolableList", list.GetType().FullName); + //Assert.Contains("PoolableList", list.GetType().FullName); Assert.True(object.ReferenceEquals(table.ReadOnlyStringList, table.ReadOnlyStringList)); Assert.True(object.ReferenceEquals(list[5], list[5])); diff --git a/src/Tests/FlatSharpTests/ModuleInitializer.cs b/src/Tests/FlatSharpTests/ModuleInitializer.cs index cca91208..1d2d4833 100644 --- a/src/Tests/FlatSharpTests/ModuleInitializer.cs +++ b/src/Tests/FlatSharpTests/ModuleInitializer.cs @@ -24,7 +24,9 @@ public partial class ModuleInitializer [ModuleInitializer] public static void AssemblyInitialize() { +#if NETCOREAPP RoslynSerializerGenerator.EnableStrictValidation = true; +#endif } } } diff --git a/src/Tests/FlatSharpTests/SerializationTests/TableSerializationTests.cs b/src/Tests/FlatSharpTests/SerializationTests/TableSerializationTests.cs index 2d56c666..8929cd08 100644 --- a/src/Tests/FlatSharpTests/SerializationTests/TableSerializationTests.cs +++ b/src/Tests/FlatSharpTests/SerializationTests/TableSerializationTests.cs @@ -41,7 +41,7 @@ public void TableParse_NotMutable() Assert.Throws(() => table.StructVector = new List()); Assert.Throws(() => table.StructVector.Add(null)); - Assert.Contains("FlatBufferVectorBase", table.StructVector.GetType().FullName); + //Assert.Contains("FlatBufferVectorBase", table.StructVector.GetType().FullName); } [Fact] @@ -53,7 +53,7 @@ public void TableParse_Progressive() Assert.Throws(() => table.Struct.Long = 0); Assert.Throws(() => table.Struct = new()); - Assert.Contains("FlatBufferProgressiveVector", table.StructVector.GetType().FullName); + //Assert.Contains("FlatBufferProgressiveVector", table.StructVector.GetType().FullName); } [Fact] diff --git a/src/Tests/FlatSharpTests/SerializationTests/VectorDeserializationTests.cs b/src/Tests/FlatSharpTests/SerializationTests/VectorDeserializationTests.cs index 9d8412d6..86952243 100644 --- a/src/Tests/FlatSharpTests/SerializationTests/VectorDeserializationTests.cs +++ b/src/Tests/FlatSharpTests/SerializationTests/VectorDeserializationTests.cs @@ -341,7 +341,7 @@ public void StringVector_GreedyDeserialize_Mutable() var parsed = serializer.Parse>>(buffer); - Assert.Equal(typeof(PoolableList), parsed.Vector.GetType()); + // Assert.Equal(typeof(PoolableList), parsed.Vector.GetType()); Assert.False(parsed.Vector.IsReadOnly); // Shouldn't throw. @@ -363,7 +363,7 @@ public void StringVector_GreedyDeserialize_NotMutable() var parsed = serializer.Parse>>(buffer); - Assert.Equal(typeof(ImmutableList), parsed.Vector.GetType()); + //Assert.Equal(typeof(ImmutableList), parsed.Vector.GetType()); Assert.True(parsed.Vector.IsReadOnly); Assert.Throws(() => parsed.Vector.Add("four")); diff --git a/src/Tests/FlatSharpTests/SerializationTests/WriteThroughTests.cs b/src/Tests/FlatSharpTests/SerializationTests/WriteThroughTests.cs index f4796663..6c54dd99 100644 --- a/src/Tests/FlatSharpTests/SerializationTests/WriteThroughTests.cs +++ b/src/Tests/FlatSharpTests/SerializationTests/WriteThroughTests.cs @@ -431,7 +431,7 @@ public void Failures_IList_AtRuntime(FlatBufferDeserializationOption option) serializer.Write(buffer, item); var parsed = serializer.Parse>>(buffer); - Assert.IsType>(parsed.Item); + //Assert.IsType>(parsed.Item); Assert.Throws(() => parsed.Item[0] = new ValueStruct { Value = 4 }); } } diff --git a/src/Tests/Stryker/CodeGen/Schema.fbs b/src/Tests/Stryker/CodeGen/Schema.fbs index 96d33f75..51196a4b 100644 --- a/src/Tests/Stryker/CodeGen/Schema.fbs +++ b/src/Tests/Stryker/CodeGen/Schema.fbs @@ -8,7 +8,7 @@ attribute "fs_sharedString"; namespace FlatSharpStrykerTests; -enum Fruit : uint +enum Fruit : int { Apple, Banana, @@ -74,7 +74,7 @@ table Fields ref_struct : RefStruct; /// Field 1 - value_struct : ValueStruct; + value_struct : ValueStruct; // TODO: writethrough /// Field 2 memory : ubyte; @@ -95,7 +95,7 @@ table Vectors ref_struct : [ RefStruct ]; /// Field 1 - value_struct : [ ValueStruct ]; + value_struct : [ ValueStruct ] (fs_writeThrough); /// Field 2 memory : [ ubyte ]; @@ -108,4 +108,7 @@ table Vectors /// Field 6 indexed : [ Key ] (fs_vector:"IIndexedVector"); + + /// Field 7 + table : [ Key ]; } \ No newline at end of file diff --git a/src/Tests/Stryker/Tests/FullTreeTests.cs b/src/Tests/Stryker/Tests/FullTreeTests.cs index 861d4c06..6f707d85 100644 --- a/src/Tests/Stryker/Tests/FullTreeTests.cs +++ b/src/Tests/Stryker/Tests/FullTreeTests.cs @@ -8,13 +8,38 @@ namespace FlatSharpStrykerTests; public class FullTreeTests { + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void RootMutations(FlatBufferDeserializationOption option) + { + Root root = this.CreateRoot().SerializeAndParse(option); + + Helpers.AssertMutationWorks(option, root, false, r => r.Fields, new Fields()); + Helpers.AssertMutationWorks(option, root, false, r => r.Vectors, new Vectors()); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void VectorFieldMutations(FlatBufferDeserializationOption option) + { + Vectors vectors = this.CreateRoot().SerializeAndParse(option).Vectors; + + Helpers.AssertMutationWorks(option, vectors, false, r => r.Indexed, null); + Helpers.AssertMutationWorks(option, vectors, false, r => r.Memory, null); + Helpers.AssertMutationWorks(option, vectors, false, r => r.RefStruct, null); + Helpers.AssertMutationWorks(option, vectors, false, r => r.Str, null); + Helpers.AssertMutationWorks(option, vectors, false, r => r.Table, null); + Helpers.AssertMutationWorks(option, vectors, false, r => r.Union, null); + Helpers.AssertMutationWorks(option, vectors, false, r => r.ValueStruct, null); + } + [Fact] public void GetMaxSize() { Root root = this.CreateRoot(); int maxSize = Root.Serializer.GetMaxSize(root); - Assert.Equal(730, maxSize); + Assert.Equal(898, maxSize); } [Theory] @@ -22,9 +47,11 @@ public void GetMaxSize() public void Clone(FlatBufferDeserializationOption option) { Root root = this.CreateRoot().SerializeAndParse(option); - Root copy = new Root(root); + Assert.True(root.IsInitialized); + Assert.True(copy.IsInitialized); + Assert.NotSame(root, copy); Assert.Equal(typeof(Root), copy.GetType()); Assert.NotEqual(typeof(Root), root.GetType()); @@ -36,12 +63,16 @@ public void Clone(FlatBufferDeserializationOption option) Assert.NotSame(rv, cv); Assert.NotSame(rv.GetType(), cv.GetType()); Assert.Equal(typeof(Vectors), cv.GetType()); + Assert.True(rv.IsInitialized); + Assert.True(cv.IsInitialized); Verify(rv.RefStruct, cv.RefStruct, Verify); Verify(rv.ValueStruct, cv.ValueStruct, Verify); Verify(rv.Str, cv.Str, Assert.Equal); - Verify(rv.Union, cv.Union, Assert.Equal); + Verify(rv.Union, cv.Union, Verify); Verify(rv.Indexed, cv.Indexed, Verify); + Verify(rv.Memory, cv.Memory, Verify); + Verify(rv.Table, cv.Table, Verify); } { @@ -49,6 +80,8 @@ public void Clone(FlatBufferDeserializationOption option) Fields cf = copy.Fields; Assert.NotSame(rf, cf); + Assert.True(rf.IsInitialized); + Assert.True(cf.IsInitialized); Assert.NotSame(rf.GetType(), cf.GetType()); Assert.Equal(typeof(Fields), cf.GetType()); @@ -98,6 +131,11 @@ private static void Verify(T? a, T? b, Action action) where T : struct } } + private static void Verify(Memory a, Memory b) + { + Assert.True(a.Span.SequenceEqual(b.Span)); + } + private static void Verify(ValueStruct a, ValueStruct b) { Assert.Equal(a.A, b.A); @@ -137,6 +175,8 @@ private static void Verify(FunUnion a, FunUnion b) private static void Verify(Key a, Key b) { Assert.NotSame(a, b); + Assert.True(a.IsInitialized); + Assert.True(b.IsInitialized); Assert.Equal(a.Name, b.Name); Assert.Equal(a.Value, b.Value); } @@ -144,12 +184,18 @@ private static void Verify(Key a, Key b) private static void Verify(RefStruct a, RefStruct b) { Assert.NotSame(a, b); + Assert.True(a.IsInitialized); + Assert.True(b.IsInitialized); Assert.Equal(a.A, b.A); Assert.Equal(a.B, b.B); Assert.Equal(a.C[0], b.C[0]); Assert.Equal(a.C[1], b.C[1]); Assert.Equal(a.D[0], b.D[0]); Assert.Equal(a.D[1], b.D[1]); + + Assert.Equal(new[] { a.C[0], a.C[1] }, b.C); + Assert.Equal(new[] { a.D[0], a.D[1] }, b.D); + Verify(a.E, b.E); } @@ -198,8 +244,9 @@ static RefStruct CreateRefStruct() Memory = new byte[] { 1, 2, 3, 4, }, RefStruct = Helpers.CreateList(CreateRefStruct(), CreateRefStruct()), Str = Helpers.CreateList("abc", "def"), - Union = Helpers.CreateList(new FunUnion("hi"), new FunUnion(new ValueStruct())), + Union = Helpers.CreateList(new FunUnion("hi"), new FunUnion(new ValueStruct()), new FunUnion(new RefStruct())), ValueStruct = Helpers.CreateList(CreateRefStruct().E, CreateRefStruct().E), + Table = Helpers.CreateList(new Key() { Name = "bar" }, new Key() { Name = "foo" }), }, }; } diff --git a/src/Tests/Stryker/Tests/IndexedVectorTests.cs b/src/Tests/Stryker/Tests/IndexedVectorTests.cs index 0d3f14fa..5a76c37a 100644 --- a/src/Tests/Stryker/Tests/IndexedVectorTests.cs +++ b/src/Tests/Stryker/Tests/IndexedVectorTests.cs @@ -20,6 +20,8 @@ public void Present(FlatBufferDeserializationOption option) IIndexedVector vector = vectors.Indexed; + Assert.Equal(option != FlatBufferDeserializationOption.GreedyMutable, vector.IsReadOnly); + var expected = root.Vectors.Indexed.ToArray(); foreach (var pair in expected) @@ -40,6 +42,7 @@ public void Present(FlatBufferDeserializationOption option) Assert.False(vector.ContainsKey("z")); Assert.False(vector.TryGetValue("z", out _)); + Helpers.AssertMutationWorks(option, vectors, false, v => v.Indexed, new IndexedVector()); Helpers.AssertSequenceEqual(expectedData, buffer); } @@ -81,6 +84,28 @@ public void KeyNotSet_Serialize(FlatBufferDeserializationOption option) Assert.Equal("Table property 'FlatSharpStrykerTests.Key.Name' is marked as required, but was not set.", ex.Message); } + [Fact] + public void NullItem_Serialize() + { + Root root = new() + { + Vectors = new() + { + Indexed = new IndexedVector() + } + }; + + // shoudln't be possible, but let's test our defensiveness. + var backingDictionary = (Dictionary)typeof(IndexedVector).GetField("backingDictionary", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(root.Vectors.Indexed); + backingDictionary["foo"] = null; + + var ex = Assert.Throws(() => Root.Serializer.GetMaxSize(root)); + Assert.Equal("FlatSharp encountered a null reference in an invalid context, such as a vector. Vectors are not permitted to have null objects.", ex.Message); + + ex = Assert.Throws(() => Root.Serializer.Write(new byte[1024], root)); + Assert.Equal("FlatSharp encountered a null reference in an invalid context, such as a vector. Vectors are not permitted to have null objects.", ex.Message); + } + [Theory] [ClassData(typeof(DeserializationOptionClassData))] public void KeyNotSet_Parse(FlatBufferDeserializationOption option) diff --git a/src/Tests/Stryker/Tests/RefStructVectorTests.cs b/src/Tests/Stryker/Tests/RefStructVectorTests.cs index bf287feb..2d3aec2b 100644 --- a/src/Tests/Stryker/Tests/RefStructVectorTests.cs +++ b/src/Tests/Stryker/Tests/RefStructVectorTests.cs @@ -1,4 +1,5 @@ using FlatSharp.Internal; +using System.IO; using System.Linq.Expressions; using System.Threading; @@ -8,7 +9,7 @@ public class RefStructVectorTests { [Theory] [ClassData(typeof(DeserializationOptionClassData))] - public void Present(FlatBufferDeserializationOption option) + public void Present(FlatBufferDeserializationOption option) => Helpers.Repeat(() => { Root root = CreateRoot(out byte[] expectedData); Root parsed = root.SerializeAndParse(option, out byte[] actualData); @@ -31,10 +32,18 @@ public void Present(FlatBufferDeserializationOption option) Assert.Equal(r.C[1], p.C[1]); Assert.Equal(r.D[0], p.D[0]); Assert.Equal(r.D[1], p.D[1]); + + Assert.Equal(r.C.ToArray()[0], p.C.ToArray()[0]); + Assert.Equal(r.D.ToArray()[0], p.D.ToArray()[0]); + + Assert.Same(p.D, p.D); + Assert.Same(p.C, p.C); } Helpers.AssertSequenceEqual(expectedData, actualData); - } + Helpers.AssertMutationWorks(option, parsed.Vectors, false, v => v.RefStruct, new List()); + Helpers.ValidateListVector(option, false, vsp, new RefStruct()); + }); [Theory] [ClassData(typeof(DeserializationOptionClassData))] @@ -47,11 +56,29 @@ public void Missing(FlatBufferDeserializationOption option) Helpers.AssertSequenceEqual(expectedData, actualData); } + [Fact] + public void WithNull() => Helpers.Repeat(() => + { + Root root = new() + { + Vectors = new() + { + RefStruct = Helpers.CreateList((RefStruct)null), + } + }; + + var ex = Assert.Throws(() => Root.Serializer.Write(new byte[1024], root)); + Assert.Equal("FlatSharp encountered a null reference in an invalid context, such as a vector. Vectors are not permitted to have null objects.", ex.Message); + + // no exception here. Reason is that structs are constant size, so we don't traverse the vector to figure out the max size. + int maxSize = Root.Serializer.GetMaxSize(root); + }); + private Root CreateRoot(out byte[] expectedData) { var rs1 = new RefStruct { A = 1, B = Fruit.Banana }; - rs1.C.CopyFrom(new sbyte[] { 3, 4 }.AsSpan()); - rs1.D.CopyFrom(new List { 5, 6, }); + rs1.C.CopyFrom(new sbyte[] { 3, 4 }.ToList()); + rs1.D.CopyFrom(new sbyte[] { 5, 6, }.AsSpan()); var rs2 = new RefStruct { A = 7, B = Fruit.Pear }; rs2.C.CopyFrom(new sbyte[] { 9, 10 }.AsSpan()); diff --git a/src/Tests/Stryker/Tests/RootObjectTests.cs b/src/Tests/Stryker/Tests/RootObjectTests.cs new file mode 100644 index 00000000..ada5ebf9 --- /dev/null +++ b/src/Tests/Stryker/Tests/RootObjectTests.cs @@ -0,0 +1,13 @@ +namespace FlatSharpStrykerTests; + +public class RootObjectTests +{ + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void InvalidConstructors(FlatBufferDeserializationOption option) + { + Assert.Throws(() => new FunUnion((string)null)); + Assert.Throws(() => new FunUnion((RefStruct)null)); + Assert.Throws(() => new FunUnion((Key)null)); + } +} diff --git a/src/Tests/Stryker/Tests/StringVectorTests.cs b/src/Tests/Stryker/Tests/StringVectorTests.cs index 8fb23636..031463a4 100644 --- a/src/Tests/Stryker/Tests/StringVectorTests.cs +++ b/src/Tests/Stryker/Tests/StringVectorTests.cs @@ -1,6 +1,9 @@ using FlatSharp.Internal; +using Microsoft.VisualStudio.TestPlatform.Utilities; +using System.IO; using System.Linq.Expressions; using System.Threading; +using Xunit.Sdk; namespace FlatSharpStrykerTests; @@ -8,7 +11,7 @@ public class StringVectorTests { [Theory] [ClassData(typeof(DeserializationOptionClassData))] - public void StringTableField(FlatBufferDeserializationOption option) + public void StringTableField(FlatBufferDeserializationOption option) => Helpers.Repeat(() => { Root root = CreateRoot(out byte[] expectedData); Root parsed = root.SerializeAndParse(option, out byte[] buffer); @@ -24,9 +27,55 @@ public void StringTableField(FlatBufferDeserializationOption option) Assert.Equal("frenchie", theBoys[2]); Helpers.AssertMutationWorks(option, vectors, false, s => s.Str, new string[0]); - Helpers.AssertMutationWorks(option, false, theBoys, string.Empty); + Helpers.ValidateListVector(option, false, theBoys, string.Empty); Helpers.AssertSequenceEqual(expectedData, buffer); - } + }); + + [Fact] + public void WithNull() => Helpers.Repeat(() => + { + Root root = new() + { + Vectors = new() + { + Str = Helpers.CreateList((string)null), + } + }; + + var ex = Assert.Throws(() => Root.Serializer.Write(new byte[1024], root)); + Assert.Equal("FlatSharp encountered a null reference in an invalid context, such as a vector. Vectors are not permitted to have null objects.", ex.Message); + + ex = Assert.Throws(() => Root.Serializer.GetMaxSize(root)); + Assert.Equal("FlatSharp encountered a null reference in an invalid context, such as a vector. Vectors are not permitted to have null objects.", ex.Message); + }); + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void Big(FlatBufferDeserializationOption option) => Helpers.Repeat(() => + { + Root root = new Root { Vectors = new() { Str = new List() } }; + + for (int i = 0; i < 1000; ++i) + { + root.Vectors.Str.Add(i.ToString()); + } + + Root parsed = root.SerializeAndParse(option, out byte[] actualData); + IList parsedList = parsed.Vectors.Str; + + for (int i = 0; i < 1000; ++i) + { + Assert.Equal(root.Vectors.Str[i], parsedList[i]); + + Action assert = option switch + { + FlatBufferDeserializationOption.Lazy => Assert.NotSame, + _ => Assert.Same, + }; + + assert(parsedList[i], parsedList[i]); + } + }); private Root CreateRoot(out byte[] expectedData) { diff --git a/src/Tests/Stryker/Tests/StructFieldTests.cs b/src/Tests/Stryker/Tests/StructFieldTests.cs index 82798787..25b2d7a8 100644 --- a/src/Tests/Stryker/Tests/StructFieldTests.cs +++ b/src/Tests/Stryker/Tests/StructFieldTests.cs @@ -139,6 +139,28 @@ public void ReferenceStructWriteThrough(FlatBufferDeserializationOption option) Assert.Equal(rsp.C[1], parsed2.Fields.RefStruct.C[1]); } + [Fact] + public void ReferenceStructWriteThrough_Progressive() + { + Root root = CreateRootReferenceStruct(out RefStruct rs, out ValueStruct vs, out byte[] expectedBytes); + Root parsed = root.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out byte[] buffer); + + RefStruct rsp = parsed.Fields.RefStruct; + + // write first. + rsp.A = 4; + rsp.C[0] = 6; + rsp.C[1] = 7; + + // clear buffer + buffer.AsSpan().Clear(); + + // now read. Expect the same values back. + Assert.Equal(4, rsp.A); + Assert.Equal(6, rsp.C[0]); + Assert.Equal(7, rsp.C[1]); + } + [Theory] [ClassData(typeof(DeserializationOptionClassData))] public void ReferenceStructOnDeserialized(FlatBufferDeserializationOption option) diff --git a/src/Tests/Stryker/Tests/TableVectorTests.cs b/src/Tests/Stryker/Tests/TableVectorTests.cs new file mode 100644 index 00000000..613b47a1 --- /dev/null +++ b/src/Tests/Stryker/Tests/TableVectorTests.cs @@ -0,0 +1,200 @@ +using FlatSharp.Internal; +using System.IO; +using System.Linq.Expressions; +using System.Threading; + +namespace FlatSharpStrykerTests; + +public class TableVectorTests +{ + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void Present(FlatBufferDeserializationOption option) => Helpers.Repeat(() => + { + Root root = CreateRoot(out byte[] expectedData); + Root parsed = root.SerializeAndParse(option, out byte[] buffer); + + Vectors vectors = parsed.Vectors; + Assert.True(vectors.IsInitialized); + Assert.True(Vectors.IsStaticInitialized); + + IList vector = vectors.Table; + IList expected = root.Vectors.Table; + + Assert.Equal(expected.Count, vector.Count); + + for (int i = 0; i < expected.Count; ++i) + { + var item = vector[i]; + var e = expected[i]; + + Assert.Equal(e.Name, item.Name); + Assert.Equal(e.Value, item.Value); + } + + Helpers.AssertSequenceEqual(expectedData, buffer); + Helpers.ValidateListVector(option, false, vector, new Key { Name = "johnny" }); + }); + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void Missing(FlatBufferDeserializationOption option) + { + Root root = CreateRoot_Missing(out byte[] expectedData); + Root parsed = root.SerializeAndParse(option, out byte[] buffer); + + Vectors vectors = parsed.Vectors; + Assert.True(vectors.IsInitialized); + Assert.True(Vectors.IsStaticInitialized); + + Assert.Null(vectors.Table); + Helpers.AssertSequenceEqual(expectedData, buffer); + } + + [Fact] + public void WithNull() => Helpers.Repeat(() => + { + var ex = Assert.Throws(() => Root.Serializer.Write(new byte[1024], CreateRoot_WithNullItem())); + Assert.Equal("FlatSharp encountered a null reference in an invalid context, such as a vector. Vectors are not permitted to have null objects.", ex.Message); + + ex = Assert.Throws(() => Root.Serializer.GetMaxSize(CreateRoot_WithNullItem())); + Assert.Equal("FlatSharp encountered a null reference in an invalid context, such as a vector. Vectors are not permitted to have null objects.", ex.Message); + }); + + [Fact] + public void ProgressiveSingleRead() => Helpers.Repeat(() => + { + Root root = new() { Vectors = new() { Table = new[] { new Key() { Name = "foo", Value = Fruit.Strawberry } } } }; + Root parsed = root.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out byte[] buffer); + + Key item = parsed.Vectors.Table[0]; + + Assert.Equal("foo", item.Name); + Assert.Same(item.Name, item.Name); + Assert.Equal(Fruit.Strawberry, item.Value); + + buffer.AsSpan().Clear(); + + Assert.Equal(Fruit.Strawberry, item.Value); + }); + + private Root CreateRoot(out byte[] expectedData) + { + static byte B(char c) => (byte)c; + + Root root = new() + { + Vectors = new() + { + Table = Helpers.CreateList( + new Key { Name = "a", Value = Fruit.Apple }, + new Key { Name = "b", Value = Fruit.Banana }, + new Key { Name = "p", Value = Fruit.Pear }, + new Key { Name = "s", Value = Fruit.Strawberry }), + } + }; + + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Vectors subtable. + + // Vtable for Root + 8, 0, 8, 0, + 0, 0, 4, 0, + + 248, 255, 255, 255, // soffset to vtable + 24, 0, 0, 0, // uoffset to vector + + 20, 0, // vtable length + 8, 0, // table length + 0, 0, // field 0 + 0, 0, // field 1 + 0, 0, // field 2 (scalar) + 0, 0, // field 3 (str) + 0, 0, // field 4, 5 (union) + 0, 0, + 0, 0, // field 6 (indexed) + 4, 0, // field 7 (table) + + 4, 0, 0, 0, // vector length + 16, 0, 0, 0, + 40, 0, 0, 0, + 60, 0, 0, 0, + 76, 0, 0, 0, + + 244, 255, 255, 255, // soffset to vtable. + 0, 0, 0, 0, // apple + 12, 0, 0, 0, // offset to 'a' + + 8, 0, 12, 0, // vtable + 8, 0, 4, 0, + + 1, 0, 0, 0, + B('a'), 0, 0, 0, + + 248, 255, 255, 255, // non-shared vtable. (banana is default) + 12, 0, 0, 0, + + 6, 0, 8, 0, // vtable + 4, 0, 0, 0, + + 1, 0, 0, 0, + B('b'), 0, 0, 0, + + 40, 0, 0, 0, // shares vtable + 3, 0, 0, 0, // pear + 4, 0, 0, 0, + + 1, 0, 0, 0, + B('p'), 0, 0, 0, + + 60, 0, 0, 0, // shares vtable + 2, 0, 0, 0, // strawberry + 4, 0, 0, 0, + + 1, 0, 0, 0, + B('s'), 0, + }; + + return root; + } + + private Root CreateRoot_Missing(out byte[] expectedData) + { + Root root = new() + { + Vectors = new() + }; + + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Vectors subtable. + + // Vtable for Root + 8, 0, 8, 0, + 0, 0, 4, 0, + + 252, 255, 255, 255, // soffset to vtable + + 4, 0, // vtable length + 4, 0, // table length + }; + + return root; + } + + private Root CreateRoot_WithNullItem() + { + return new() + { + Vectors = new() + { + Table = Helpers.CreateList((Key)null), + } + }; + } +} diff --git a/src/Tests/Stryker/Tests/UnionFieldTests.cs b/src/Tests/Stryker/Tests/UnionFieldTests.cs index 71e18561..91720d1b 100644 --- a/src/Tests/Stryker/Tests/UnionFieldTests.cs +++ b/src/Tests/Stryker/Tests/UnionFieldTests.cs @@ -47,6 +47,32 @@ public void StringMember(FlatBufferDeserializationOption option) Helpers.AssertMutationWorks(option, parsed.Fields, false, f => f.Union, default); } + [Fact] + public void BrokenUnion() + { + Root root = new() { Fields = new() { Union = new FunUnion() } }; + + var ex = Assert.Throws(() => Root.Serializer.GetMaxSize(root)); + Assert.Equal("Exception determining type of union. Discriminator = 0", ex.Message); + + ex = Assert.Throws(() => Root.Serializer.Write(new byte[1024], root)); + Assert.Equal("Unexpected discriminator. Unions must be initialized.", ex.Message); + + ex = Assert.Throws(() => new FunUnion().Accept(new Visitor())); + Assert.Equal("Unexpected discriminator: 0", ex.Message); + + ex = Assert.Throws(() => new Root(root)); + Assert.Equal("Unexpected union discriminator", ex.Message); + } + + private struct Visitor : FunUnion.Visitor + { + public bool Visit(RefStruct item) => true; + public bool Visit(ValueStruct item) => true; + public bool Visit(string item) => true; + public bool Visit(Key item) => true; + } + [Theory] [ClassData(typeof(DeserializationOptionClassData))] public void ValueStructMember(FlatBufferDeserializationOption option) diff --git a/src/Tests/Stryker/Tests/UnionVectorTests.cs b/src/Tests/Stryker/Tests/UnionVectorTests.cs index 8745a127..f1caa5f0 100644 --- a/src/Tests/Stryker/Tests/UnionVectorTests.cs +++ b/src/Tests/Stryker/Tests/UnionVectorTests.cs @@ -9,7 +9,7 @@ public class UnionVectorTests { [Theory] [ClassData(typeof(DeserializationOptionClassData))] - public void UnionVector(FlatBufferDeserializationOption option) + public void UnionVector(FlatBufferDeserializationOption option) => Helpers.Repeat(() => { Root root = CreateRoot(out byte[] expectedData); Root parsed = root.SerializeAndParse(option, out byte[] buffer); @@ -90,7 +90,8 @@ public void UnionVector(FlatBufferDeserializationOption option) } Helpers.AssertSequenceEqual(expectedData, buffer); - } + Helpers.ValidateListVector(option, false, unions, new FunUnion("foo")); + }); [Theory] [ClassData(typeof(DeserializationOptionClassData))] @@ -135,6 +136,36 @@ public void UnionVector_Invalid_MismatchedCounts(FlatBufferDeserializationOption Assert.Equal("Union vector had mismatched number of discriminators and offsets.", ex.Message); } + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void UnionVector_Invalid_NoOffsetVector(FlatBufferDeserializationOption option) + { + CreateInvalid_NoOffsetVector(out byte[] buffer); + + var ex = Assert.Throws(() => + { + var item = Root.Serializer.Parse(buffer, option); + var x = item.Vectors.Union[0]; + }); + + Assert.Equal("FlatBuffer table property 'FlatSharpStrykerTests.Vectors.Union' was only partially included in the buffer.", ex.Message); + } + + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void UnionVector_Invalid_NoDiscriminatorVector(FlatBufferDeserializationOption option) + { + CreateInvalid_NoOffsetVector(out byte[] buffer); + + var ex = Assert.Throws(() => + { + var item = Root.Serializer.Parse(buffer, option); + var x = item.Vectors.Union[0]; + }); + + Assert.Equal("FlatBuffer table property 'FlatSharpStrykerTests.Vectors.Union' was only partially included in the buffer.", ex.Message); + } + [Theory] [ClassData(typeof(DeserializationOptionClassData))] public void NotPresent(FlatBufferDeserializationOption option) @@ -333,4 +364,70 @@ private void CreateInvalid_MismatchedCounts(out byte[] expectedData) 0, 0, 0, 0, }; } + + private void CreateInvalid_NoOffsetVector(out byte[] expectedData) + { + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Vectors subtable. + + // Vtable for Root + 8, 0, 8, 0, + 0, 0, 4, 0, + + 244, 255, 255, 255, // soffset to vtable + 24, 0, 0, 0, // uoffset to union discriminators + 28, 0, 0, 0, // uoffset to union offsets + + 16, 0, // vtable length + 12, 0, // table length + 0, 0, // field 0 + 0, 0, // field 1 + 0, 0, // field 2 (memory) + 0, 0, // field 3 (stirng) + 4, 0, // field 4 (union vector discriminators) + 0, 0, // field 5 (union vector offsets) + + 3, 0, 0, 0, + 1, 2, 3, 0, // discriminators + + 1, 0, 0, 0, // union offsets + 0, 0, 0, 0, + }; + } + + private void CreateInvalid_NoDiscriminatorVector(out byte[] expectedData) + { + expectedData = new byte[] + { + 4, 0, 0, 0, + 248, 255, 255, 255, // soffset to vtable + 12, 0, 0, 0, // uoffset to Vectors subtable. + + // Vtable for Root + 8, 0, 8, 0, + 0, 0, 4, 0, + + 244, 255, 255, 255, // soffset to vtable + 24, 0, 0, 0, // uoffset to union discriminators + 28, 0, 0, 0, // uoffset to union offsets + + 16, 0, // vtable length + 12, 0, // table length + 0, 0, // field 0 + 0, 0, // field 1 + 0, 0, // field 2 (memory) + 0, 0, // field 3 (stirng) + 0, 0, // field 4 (union vector discriminators) + 8, 0, // field 5 (union vector offsets) + + 3, 0, 0, 0, + 1, 2, 3, 0, // discriminators + + 1, 0, 0, 0, // union offsets + 0, 0, 0, 0, + }; + } } diff --git a/src/Tests/Stryker/Tests/ValueStructVectorTests.cs b/src/Tests/Stryker/Tests/ValueStructVectorTests.cs index 3e09fc49..1a3ae3cd 100644 --- a/src/Tests/Stryker/Tests/ValueStructVectorTests.cs +++ b/src/Tests/Stryker/Tests/ValueStructVectorTests.cs @@ -8,7 +8,7 @@ public class ValueStructVectorTests { [Theory] [ClassData(typeof(DeserializationOptionClassData))] - public void Present(FlatBufferDeserializationOption option) + public void Present(FlatBufferDeserializationOption option) => Helpers.Repeat(() => { Root root = CreateRoot(out byte[] expectedData); Root parsed = root.SerializeAndParse(option, out byte[] actualData); @@ -32,7 +32,9 @@ public void Present(FlatBufferDeserializationOption option) } Helpers.AssertSequenceEqual(expectedData, actualData); - } + Helpers.AssertMutationWorks(option, parsed.Vectors, false, v => v.ValueStruct, new List()); + Helpers.ValidateListVector(option, true, vsp, new ValueStruct()); + }); [Theory] [ClassData(typeof(DeserializationOptionClassData))] @@ -45,6 +47,71 @@ public void Missing(FlatBufferDeserializationOption option) Helpers.AssertSequenceEqual(expectedData, actualData); } + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void Big(FlatBufferDeserializationOption option) => Helpers.Repeat(() => + { + Root root = new Root { Vectors = new() { ValueStruct = new List() } }; + + for (int i = 0; i < 1000; ++i) + { + root.Vectors.ValueStruct.Add(new ValueStruct { A = i }); + } + + Root parsed = root.SerializeAndParse(option, out byte[] actualData); + IList parsedList = parsed.Vectors.ValueStruct; + + for (int i = 0; i < 1000; ++i) + { + Assert.Equal(root.Vectors.ValueStruct[i].A, parsedList[i].A); + } + }); + + [Theory] + [InlineData(FlatBufferDeserializationOption.Lazy)] + [InlineData(FlatBufferDeserializationOption.Progressive)] + public void WriteThroughValidation(FlatBufferDeserializationOption option) => Helpers.Repeat(() => + { + Root root = new Root { Vectors = new() { ValueStruct = new List { new ValueStruct { A = 1 }, new ValueStruct { A = 2 } } } }; + Root parsed1 = root.SerializeAndParse(option, out byte[] rawData); + + Assert.Equal(1, parsed1.Vectors.ValueStruct[0].A); + Assert.Equal(2, parsed1.Vectors.ValueStruct[1].A); + + parsed1.Vectors.ValueStruct[0] = new() { A = 5 }; + parsed1.Vectors.ValueStruct[1] = new() { A = 10 }; + + Assert.Throws(() => parsed1.Vectors.ValueStruct[-1] = default); + + Assert.Equal(5, parsed1.Vectors.ValueStruct[0].A); + Assert.Equal(10, parsed1.Vectors.ValueStruct[1].A); + + Root parsed2 = Root.Serializer.Parse(rawData, option); + Assert.Equal(5, parsed2.Vectors.ValueStruct[0].A); + Assert.Equal(10, parsed2.Vectors.ValueStruct[1].A); + }); + + [Fact] + public void ProgressiveClear() + { + Root root = new Root { Vectors = new() { ValueStruct = new[] { new ValueStruct { A = 1, B = 2 } } } }; + + Root parsed = root.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out var buffer); + + var vectors = parsed.Vectors.ValueStruct; + + // Load item 0 into memory. + Assert.Equal(1, vectors[0].A); + Assert.Equal(2, vectors[0].B); + + // Clear the span. + buffer.AsSpan().Clear(); + + // Verify item 0 is still cached. + Assert.Equal(1, vectors[0].A); + Assert.Equal(2, vectors[0].B); + } + private Root CreateRoot(out byte[] expectedData) { var vs1 = new ValueStruct { A = 1, B = 2 }; diff --git a/src/Tests/Stryker/Tests/stryker-config.json b/src/Tests/Stryker/Tests/stryker-config.json index b7de38b4..c32c6543 100644 --- a/src/Tests/Stryker/Tests/stryker-config.json +++ b/src/Tests/Stryker/Tests/stryker-config.json @@ -4,10 +4,15 @@ "ignore-methods": [ - "FlatSharp.Internal.FlatSharpInternal.AssertSizeOf" // Ignore assertions. + "TableFieldContext.ctor" + ], + + "ignore-mutations": [ + "checked" ], "reporters": [ "html", "cleartext" ], - "thresholds": { "high": 90, "low": 80, "break": 80 } + "thresholds": { "high": 100, "low": 95, "break": 95 }, + "additional-timeout": 10000 } } From c237644f50a57b0602f72eba93e1a032be0cae50 Mon Sep 17 00:00:00 2001 From: James Courtney Date: Mon, 30 Jan 2023 18:56:00 -0800 Subject: [PATCH 05/66] Improve Stryker Coverage (#365) --- .../Vectors/VectorsCommon.cs | 6 ++ src/FlatSharp/FlatBufferVectorHelpers.cs | 4 +- .../FlatBufferVectorHelpers_LazyUnion.cs | 6 +- ...latBufferVectorHelpers_ProgressiveUnion.cs | 3 + src/Tests/FlatSharpEndToEndTests/Helpers.cs | 86 ++++++++++++++----- src/Tests/Stryker/Tests/FullTreeTests.cs | 24 +++++- src/Tests/Stryker/Tests/ScalarFieldTests.cs | 51 +++++++++++ src/Tests/Stryker/Tests/StructFieldTests.cs | 40 ++++++++- src/Tests/Stryker/Tests/UnionFieldTests.cs | 21 ++++- src/Tests/Stryker/Tests/UnionVectorTests.cs | 40 +++++++++ .../Stryker/Tests/ValueStructVectorTests.cs | 26 ++++++ 11 files changed, 278 insertions(+), 29 deletions(-) create mode 100644 src/Tests/Stryker/Tests/ScalarFieldTests.cs diff --git a/src/FlatSharp.Runtime/Vectors/VectorsCommon.cs b/src/FlatSharp.Runtime/Vectors/VectorsCommon.cs index 4734b615..c9de6867 100644 --- a/src/FlatSharp.Runtime/Vectors/VectorsCommon.cs +++ b/src/FlatSharp.Runtime/Vectors/VectorsCommon.cs @@ -21,6 +21,12 @@ namespace FlatSharp.Internal; /// public static class VectorsCommon { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool Contains(IList vector, T? item) + { + return IndexOf(vector, item) >= 0; + } + [MethodImpl(MethodImplOptions.AggressiveInlining)] public static int IndexOf(IList vector, T? item) { diff --git a/src/FlatSharp/FlatBufferVectorHelpers.cs b/src/FlatSharp/FlatBufferVectorHelpers.cs index 56030433..930a3859 100644 --- a/src/FlatSharp/FlatBufferVectorHelpers.cs +++ b/src/FlatSharp/FlatBufferVectorHelpers.cs @@ -64,7 +64,8 @@ public static string CreateCommonReadOnlyVectorMethods( string nullableReference = GetNullableReferenceAnnotation(itemTypeModel); return $$""" - public bool Contains({{baseTypeName}}{{nullableReference}} item) => this.IndexOf(item) >= 0; + public bool Contains({{baseTypeName}}{{nullableReference}} item) + => {{typeof(VectorsCommon).GetGlobalCompilableTypeName()}}.Contains(this, item); public int IndexOf({{baseTypeName}}{{nullableReference}} item) => {{typeof(VectorsCommon).GetGlobalCompilableTypeName()}}.IndexOf(this, item); @@ -84,6 +85,7 @@ private static string GetEfficientMultiply( string indexVariableName) { FlatSharpInternal.Assert(inlineSize != 0, "invalid inline size"); + bool isPowerOf2 = (inlineSize & (inlineSize - 1)) == 0; if (!isPowerOf2) { diff --git a/src/FlatSharp/FlatBufferVectorHelpers_LazyUnion.cs b/src/FlatSharp/FlatBufferVectorHelpers_LazyUnion.cs index fbdeb9af..64516528 100644 --- a/src/FlatSharp/FlatBufferVectorHelpers_LazyUnion.cs +++ b/src/FlatSharp/FlatBufferVectorHelpers_LazyUnion.cs @@ -92,7 +92,11 @@ internal sealed class {{className}} public {{baseTypeName}} this[int index] { get => this.SafeParseItem(index); - set => this.WriteThrough(index, value); + set + { + {{nameof(VectorUtilities)}}.{{nameof(VectorUtilities.CheckIndex)}}(index, this.count); + this.WriteThrough(index, value); + } } public int Count => this.count; diff --git a/src/FlatSharp/FlatBufferVectorHelpers_ProgressiveUnion.cs b/src/FlatSharp/FlatBufferVectorHelpers_ProgressiveUnion.cs index e442920a..639a0c1e 100644 --- a/src/FlatSharp/FlatBufferVectorHelpers_ProgressiveUnion.cs +++ b/src/FlatSharp/FlatBufferVectorHelpers_ProgressiveUnion.cs @@ -192,6 +192,8 @@ private static void GetAddress(uint index, out uint rowIndex, out uint colIndex) int absoluteStartIndex = (int)({{GetEfficientMultiply(chunkSize, "rowIndex")}}); int copyCount = {{chunkSize}}; int remainingItems = this.count - absoluteStartIndex; + + {{StrykerSuppressor.SuppressNextLine("equality")}} if (remainingItems < {{chunkSize}}) { copyCount = remainingItems; @@ -235,6 +237,7 @@ private static void GetAddress(uint index, out uint rowIndex, out uint colIndex) private void ProgressiveSet(int index, {{baseTypeName}} value) { + {{nameof(VectorUtilities)}}.{{nameof(VectorUtilities.CheckIndex)}}(index, this.count); {{nameof(VectorUtilities)}}.{{nameof(VectorUtilities.ThrowInlineNotMutableException)}}(); } diff --git a/src/Tests/FlatSharpEndToEndTests/Helpers.cs b/src/Tests/FlatSharpEndToEndTests/Helpers.cs index 6de92522..ea2cac83 100644 --- a/src/Tests/FlatSharpEndToEndTests/Helpers.cs +++ b/src/Tests/FlatSharpEndToEndTests/Helpers.cs @@ -16,9 +16,11 @@ using FlatSharp.Internal; using System; +using System.Collections.Generic; using System.Linq.Expressions; using System.Reflection; using System.Threading; +using Xunit.Abstractions; namespace FlatSharpEndToEndTests; @@ -97,7 +99,8 @@ public static void AssertMutationWorks( TSource parent, bool isWriteThrough, Expression> propertyLambda, - TProperty newValue) + TProperty newValue, + Action? assertEqual = null) { Assert.True(parent is IFlatBufferDeserializedObject); @@ -124,33 +127,26 @@ public static void AssertMutationWorks( MemberExpression member = propertyLambda.Body as MemberExpression; PropertyInfo propInfo = member.Member as PropertyInfo; - Action action = () => propInfo.SetMethod.Invoke(parent, new object[] { newValue }); + + Func get = () => (TProperty)propInfo.GetMethod.Invoke(parent, null); + Action set = () => propInfo.SetMethod.Invoke(parent, new object[] { newValue }); + + // should be equal to itself to start with. + AssertEquality(option, get(), get(), assertEqual); switch (option) { case FlatBufferDeserializationOption.Lazy when isWriteThrough: case FlatBufferDeserializationOption.Progressive when isWriteThrough: case FlatBufferDeserializationOption.GreedyMutable when isWriteThrough is false: - action(); - - // For value types, validate that they are the same. - if (typeof(TProperty).IsValueType) - { - TProperty readValue = (TProperty)propInfo.GetMethod.Invoke(parent, null); - Assert.Equal(newValue, readValue); - } - else if (option != FlatBufferDeserializationOption.Lazy) - { - TProperty readValue = (TProperty)propInfo.GetMethod.Invoke(parent, null); - Assert.True(object.ReferenceEquals(newValue, readValue)); - } - + set(); + AssertEquality(option, newValue, get(), assertEqual); return; default: var ex = Assert.Throws(new Action(() => { - var ex = Assert.Throws(action).InnerException; + var ex = Assert.Throws(set).InnerException; throw ex; })); @@ -169,12 +165,8 @@ public static void ValidateListVector( IList items, T newValue) { - // This can be lots of things: NotMutable, ArgumentOfRange, IndexOutOfRange, etc. - Assert.ThrowsAny(() => items[-1]); - Assert.ThrowsAny(() => items[items.Count]); - Assert.ThrowsAny(() => items[-1] = default); - Assert.ThrowsAny(() => items[items.Count] = default); - + CheckRangeExceptions(option, isWriteThrough, items); + if (items is IFlatBufferDeserializedVector vec) { Assert.ThrowsAny(() => vec.OffsetOf(-1)); @@ -419,4 +411,52 @@ IEnumerator IEnumerable.GetEnumerator() return ((IEnumerable)list).GetEnumerator(); } } + + private static void AssertEquality(FlatBufferDeserializationOption option, T a, T b, Action? assertEqual) + { + if (assertEqual is null) + { + if (typeof(T).IsValueType && (typeof(T).IsPrimitive || typeof(T).IsEnum)) + { + assertEqual = (a, b) => Assert.Equal(a, b); + } + else if (typeof(T) == typeof(string)) + { + assertEqual = (a, b) => Assert.Equal(a, b); + } + } + + if (!typeof(T).IsValueType && option != FlatBufferDeserializationOption.Lazy) + { + Assert.True(object.ReferenceEquals(a, b)); + } + + assertEqual?.Invoke(a, b); + } + + private static void CheckRangeExceptions(FlatBufferDeserializationOption option, bool isWriteThrough, IList list) + { + if (option == FlatBufferDeserializationOption.Lazy || option == FlatBufferDeserializationOption.Progressive) + { + Assert.Throws(() => list[-1]); + Assert.Throws(() => list[list.Count]); + Assert.Throws(() => list[-1] = default); + Assert.Throws(() => list[list.Count] = default); + } + else if (option == FlatBufferDeserializationOption.Greedy + || (isWriteThrough && option == FlatBufferDeserializationOption.GreedyMutable)) + { + Assert.Throws(() => list[-1]); + Assert.Throws(() => list[list.Count]); + Assert.Throws(() => list[-1] = default); + Assert.Throws(() => list[list.Count] = default); + } + else + { + Assert.Throws(() => list[-1]); + Assert.Throws(() => list[list.Count]); + Assert.Throws(() => list[-1] = default); + Assert.Throws(() => list[list.Count] = default); + } + } } \ No newline at end of file diff --git a/src/Tests/Stryker/Tests/FullTreeTests.cs b/src/Tests/Stryker/Tests/FullTreeTests.cs index 6f707d85..3ebece4a 100644 --- a/src/Tests/Stryker/Tests/FullTreeTests.cs +++ b/src/Tests/Stryker/Tests/FullTreeTests.cs @@ -22,10 +22,21 @@ public void RootMutations(FlatBufferDeserializationOption option) [ClassData(typeof(DeserializationOptionClassData))] public void VectorFieldMutations(FlatBufferDeserializationOption option) { + static void AssertMemoryEqual(Memory? a, Memory? b) + { + Assert.Equal(a is null, b is null); + if (a is null) + { + return; + } + + Helpers.AssertSequenceEqual(a.Value.Span, b.Value.Span); + } + Vectors vectors = this.CreateRoot().SerializeAndParse(option).Vectors; Helpers.AssertMutationWorks(option, vectors, false, r => r.Indexed, null); - Helpers.AssertMutationWorks(option, vectors, false, r => r.Memory, null); + Helpers.AssertMutationWorks(option, vectors, false, r => r.Memory, null, AssertMemoryEqual); Helpers.AssertMutationWorks(option, vectors, false, r => r.RefStruct, null); Helpers.AssertMutationWorks(option, vectors, false, r => r.Str, null); Helpers.AssertMutationWorks(option, vectors, false, r => r.Table, null); @@ -33,6 +44,17 @@ public void VectorFieldMutations(FlatBufferDeserializationOption option) Helpers.AssertMutationWorks(option, vectors, false, r => r.ValueStruct, null); } + [Fact] + public void VectorFieldTests_ProgressiveClear() + { + Vectors vectors = this.CreateRoot().SerializeAndParse(FlatBufferDeserializationOption.Progressive, out byte[] data).Vectors; + Helpers.AssertSequenceEqual(new byte[] { 1, 2, 3, 4, }, vectors.Memory.Value.Span); + + data.AsSpan().Clear(); + + Helpers.AssertSequenceEqual(new byte[] { 0, 0, 0, 0, }, vectors.Memory.Value.Span); + } + [Fact] public void GetMaxSize() { diff --git a/src/Tests/Stryker/Tests/ScalarFieldTests.cs b/src/Tests/Stryker/Tests/ScalarFieldTests.cs new file mode 100644 index 00000000..ccb5bb1e --- /dev/null +++ b/src/Tests/Stryker/Tests/ScalarFieldTests.cs @@ -0,0 +1,51 @@ +using FlatSharp.Internal; +using System.Linq.Expressions; + +namespace FlatSharpStrykerTests; + +public class ScalarFieldTests +{ + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void ValueStructTableField(FlatBufferDeserializationOption option) + { + Root r = CreateTableWithScalarField(out byte[] buffer); + Root parsed = r.SerializeAndParse(option, out byte[] actual); + + Assert.Equal(r.Fields.Memory, parsed.Fields.Memory); + Helpers.AssertSequenceEqual(buffer, actual); + } + + private static Root CreateTableWithScalarField(out byte[] expectedBuffer) + { + Root root = new Root + { + Fields = new() + { + Memory = 3, + } + }; + + expectedBuffer = new byte[] + { + 4, 0, 0, 0, // offset to table start + 248, 255, 255, 255, // soffset to vtable. + 12, 0, 0, 0, // uoffset to field 0 (fields table) + 6, 0, // vtable length + 8, 0, // table length + 4, 0, // offset of field 0 + 0, 0, // padding + + 250, 255, 255, 255, // soffset to vtable + 3, 0, + + 10, 0, + 5, 0, + 0, 0, + 0, 0, + 4, 0, + }; + + return root; + } +} diff --git a/src/Tests/Stryker/Tests/StructFieldTests.cs b/src/Tests/Stryker/Tests/StructFieldTests.cs index 25b2d7a8..0bf5c01d 100644 --- a/src/Tests/Stryker/Tests/StructFieldTests.cs +++ b/src/Tests/Stryker/Tests/StructFieldTests.cs @@ -73,7 +73,16 @@ public void ValueStructTableField(FlatBufferDeserializationOption option) }; Helpers.AssertSequenceEqual(expectedBytes, buffer); - Helpers.AssertMutationWorks(option, fields, false, p => p.ValueStruct, default); + Helpers.AssertMutationWorks(option, fields, false, p => p.ValueStruct, new ValueStruct(), (a, b) => + { + var av = a.Value; + var bv = b.Value; + + Assert.Equal(av.A, bv.A); + Assert.Equal(av.B, bv.B); + Assert.Equal(av.C(0), bv.C(0)); + Assert.Equal(av.C(1), bv.C(1)); + }); } } finally @@ -82,6 +91,27 @@ public void ValueStructTableField(FlatBufferDeserializationOption option) } } + [Fact] + public void ValueStructTableField_ProgressiveClear() + { + Root root = new Root() { Fields = new() { ValueStruct = new ValueStruct { A = 5 } } }.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out byte[] buffer); + + var fields = root.Fields; + Assert.Equal(5, fields.ValueStruct.Value.A); + buffer.AsSpan().Clear(); + Assert.Equal(5, fields.ValueStruct.Value.A); + } + + [Fact] + public void ValueStructStructField_ProgressiveClear() + { + Root root = new Root() { Fields = new() { RefStruct = new() { E = new ValueStruct { A = 5 } } } }.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out byte[] buffer); + + var fields = root.Fields.RefStruct; + Assert.Equal(5, fields.E.A); + buffer.AsSpan().Clear(); + Assert.Equal(5, fields.E.A); + } [Theory] [ClassData(typeof(DeserializationOptionClassData))] @@ -130,7 +160,13 @@ public void ReferenceStructWriteThrough(FlatBufferDeserializationOption option) Helpers.AssertMutationWorks(option, rsp, true, rsp => rsp.__flatsharp__C_1, (sbyte)6); Helpers.AssertMutationWorks(option, rsp, false, rsp => rsp.__flatsharp__D_0, (sbyte)3); Helpers.AssertMutationWorks(option, rsp, false, rsp => rsp.__flatsharp__D_1, (sbyte)6); - Helpers.AssertMutationWorks(option, rsp, false, rsp => rsp.E, new ValueStruct()); + Helpers.AssertMutationWorks(option, rsp, false, rsp => rsp.E, new ValueStruct(), (a, b) => + { + Assert.Equal(a.A, b.A); + Assert.Equal(a.B, b.B); + Assert.Equal(a.C(0), b.C(0)); + Assert.Equal(a.C(1), b.C(1)); + }); var parsed2 = Root.Serializer.Parse(buffer, option); diff --git a/src/Tests/Stryker/Tests/UnionFieldTests.cs b/src/Tests/Stryker/Tests/UnionFieldTests.cs index 91720d1b..e53e3905 100644 --- a/src/Tests/Stryker/Tests/UnionFieldTests.cs +++ b/src/Tests/Stryker/Tests/UnionFieldTests.cs @@ -27,6 +27,19 @@ public void InvalidGetters() Assert.Throws(() => a.RefStruct); } + [Fact] + public void ProgressiveClear() + { + Root parsed = new Root { Fields = new() { Union = new FunUnion("hi") } }.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out byte[] buffer); + + Fields f = parsed.Fields; + Assert.Equal("hi", f.Union.Value.str); + + buffer.AsSpan().Clear(); + + Assert.Equal("hi", f.Union.Value.str); + } + [Theory] [ClassData(typeof(DeserializationOptionClassData))] public void StringMember(FlatBufferDeserializationOption option) @@ -44,7 +57,13 @@ public void StringMember(FlatBufferDeserializationOption option) Assert.True(union.TryGet(out string str)); Assert.Equal("hello", str); - Helpers.AssertMutationWorks(option, parsed.Fields, false, f => f.Union, default); + Helpers.AssertMutationWorks(option, parsed.Fields, false, f => f.Union, new FunUnion(string.Empty), (a, b) => + { + var av = a.Value; + var bv = b.Value; + Assert.Equal(av.Discriminator, bv.Discriminator); + Assert.Equal(av.str, bv.str); + }); } [Fact] diff --git a/src/Tests/Stryker/Tests/UnionVectorTests.cs b/src/Tests/Stryker/Tests/UnionVectorTests.cs index f1caa5f0..dba9cd87 100644 --- a/src/Tests/Stryker/Tests/UnionVectorTests.cs +++ b/src/Tests/Stryker/Tests/UnionVectorTests.cs @@ -93,6 +93,46 @@ public void UnionVector(FlatBufferDeserializationOption option) => Helpers.Repea Helpers.ValidateListVector(option, false, unions, new FunUnion("foo")); }); + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void Big(FlatBufferDeserializationOption option) + { + const int ChunkSize = 8; // this test needs to exercise some edge scenarios that require knowing the chunk size of the union vectors. + + Random r = new Random(); + + for (int test = 1; test < 10; ++test) + { + List expected = new(); + + for (int i = 0; i < (ChunkSize * test) + 1; ++i) + { + FunUnion union = (r.Next() % 4) switch + { + 0 => new(new Key { Name = i.ToString() }), + 1 => new(new RefStruct { A = i }), + 2 => new(new ValueStruct { A = i }), + 3 => new(i.ToString()), + _ => throw new Exception(), + }; + + expected.Add(union); + } + + Root root = new Root { Vectors = new() { Union = expected } }.SerializeAndParse(option); + IList parsed = root.Vectors.Union; + + Assert.Equal(expected.Count, parsed.Count); + for (int i = 0; i < expected.Count; ++i) + { + FunUnion e = expected[i]; + FunUnion p = parsed[i]; + + Assert.Equal(e.Discriminator, p.Discriminator); + } + } + } + [Theory] [ClassData(typeof(DeserializationOptionClassData))] public void UnionVector_Invalid_MissingOffset(FlatBufferDeserializationOption option) diff --git a/src/Tests/Stryker/Tests/ValueStructVectorTests.cs b/src/Tests/Stryker/Tests/ValueStructVectorTests.cs index 1a3ae3cd..24b8674a 100644 --- a/src/Tests/Stryker/Tests/ValueStructVectorTests.cs +++ b/src/Tests/Stryker/Tests/ValueStructVectorTests.cs @@ -1,5 +1,6 @@ using FlatSharp.Internal; using System.Linq.Expressions; +using System.Reflection.Metadata.Ecma335; using System.Threading; namespace FlatSharpStrykerTests; @@ -36,6 +37,31 @@ public void Present(FlatBufferDeserializationOption option) => Helpers.Repeat(() Helpers.ValidateListVector(option, true, vsp, new ValueStruct()); }); + [Theory] + [ClassData(typeof(DeserializationOptionClassData))] + public void WriteThroughDisabled(FlatBufferDeserializationOption option) + { + if (option == FlatBufferDeserializationOption.Greedy) + { + // Greedy is special because writethrough has no bearing on it, so it does not store an + // internal field context. + return; + } + + Root root = CreateRoot(out _); + Root parsed = root.SerializeAndParse(option); + + IList list = parsed.Vectors.ValueStruct; + FieldInfo field = list.GetType().GetField("fieldContext", BindingFlags.NonPublic | BindingFlags.Instance); + TableFieldContext context = (TableFieldContext)field.GetValue(list); + + Assert.True(context.WriteThrough); + context = new TableFieldContext(context.FullName, context.SharedString, writeThrough: false); + field.SetValue(list, context); + + Helpers.ValidateListVector(option, false, list, new ValueStruct()); + } + [Theory] [ClassData(typeof(DeserializationOptionClassData))] public void Missing(FlatBufferDeserializationOption option) From 1d98829c8a1a8ed0664ee4f3161c32226b8f0cea Mon Sep 17 00:00:00 2001 From: James Courtney Date: Tue, 31 Jan 2023 22:17:13 -0800 Subject: [PATCH 06/66] 7.1 Readme and Samples Updates (#366) * Update Readme * Update samples for 7.1 * Add unit to readme --- README.md | 27 ++++++++++--------- samples/Example02-Vectors/VectorsSample.cs | 19 ------------- .../IndexedVectorExample.cs | 2 +- .../Example12-WriteThrough/WriteThrough.cs | 7 +++-- samples/Samples.csproj | 4 +-- 5 files changed, 20 insertions(+), 39 deletions(-) diff --git a/README.md b/README.md index 624eb80e..6a931de8 100644 --- a/README.md +++ b/README.md @@ -98,10 +98,10 @@ Serializers are a common vector for security issues. FlatSharp takes the followi FlatSharp *does* use some techniques such as `MemoryMarshal.Read` on certain hot paths, but these usages are narrowly scoped and well tested. ### Performance & Benchmarks -FlatSharp is really, really fast. The FlatSharp benchmarks were run on .NET 7.0, using a C# approximation of [Google's FlatBuffer benchmark](https://github.com/google/flatbuffers/tree/benchmarks/benchmarks/cpp/FB), which can be found [here](src/Benchmark). +FlatSharp is really, really fast. The FlatSharp benchmarks were run on .NET 7.0 with PGO disabled, using a C# approximation of [Google's FlatBuffer benchmark](https://github.com/google/flatbuffers/tree/benchmarks/benchmarks/cpp/FB), which can be found [here](src/Benchmark). The benchmarks test 4 different serialization frameworks, all using default settings: -- FlatSharp -- 7.0.0 +- FlatSharp -- 7.1.0 - Protobuf.NET -- 3.1.22 - Google's C# Flatbuffers -- 22.10.26 - Message Pack C# -- 2.4.35 @@ -116,22 +116,23 @@ This data shows the mean time it takes to serialize a typical message containing | Library | Time | Relative Performance | Data Size | |---------------------------------|----------|----------------------|-----------| -| FlatSharp | 1,212 | 100% | 3085 | -| Message Pack C# | 2,506 | 207% | 2497 | -| Google Flatbuffers | 5,262 | 434% | 3312 | -| Google Flatbuffers (Object API) | 5,675 | 468% | 3312 | -| Protobuf.NET | 8,212 | 678% | 2646 | +| FlatSharp | 981 ns | 100% | 3085 | +| Message Pack C# | 2,021 | 205% | 2497 | +| Google Flatbuffers | 4,299 | 433% | 3312 | +| Google Flatbuffers (Object API) | 4,498 | 453% | 3312 | +| Protobuf.NET | 5,695 | 574% | 2646 | #### Deserialization How much time does it take to parse and then fully enumerate the message from the serialization benchmark? | Library | Time | Relative Performance | |---------------------------------|----------|----------------------| -| FlatSharp (Optimized) | 1,681 ns | 89% | -| FlatSharp (Default) | 1,896 | 100% | -| Message Pack C# | 4,877 | 257% | -| Google Flatbuffers | 4,587 | 242% | -| Google Flatbuffers (Object API) | 7,394 | 390% | -| Protobuf.NET | 8,466 | 447% | +| FlatSharp | 1,404 ns | 100% | +| Message Pack C# | 3,363 | 240% | +| Google Flatbuffers | 3,820 | 272% | +| Google Flatbuffers (Object API) | 5,585 | 419% | +| Protobuf.NET | 6,169 | 439% | + +Finally, FlatSharp scales quite well when used with [PGO](https://devblogs.microsoft.com/dotnet/announcing-net-6-preview-1/#dynamic-pgo). Both serialization and parse performance improve by ~20% with this feature enabled. ### License FlatSharp is licensed under Apache 2.0. diff --git a/samples/Example02-Vectors/VectorsSample.cs b/samples/Example02-Vectors/VectorsSample.cs index dc390ef7..f63a890e 100644 --- a/samples/Example02-Vectors/VectorsSample.cs +++ b/samples/Example02-Vectors/VectorsSample.cs @@ -79,11 +79,6 @@ private void UseLazy(Memory serialized) Type actualType = vectorOfTable.GetType(); - /// Lazy Vectors are . - Assert.True( - actualType.GetGenericTypeDefinition() == typeof(FlatSharp.Internal.FlatBufferVectorBase<,,>), - "LazyVectors are of type FlatBufferVectorBase<>"); - // Lazy Vectors return a different instance each time: SimpleTable? first = vectorOfTable[0]; SimpleTable? second = vectorOfTable[0]; @@ -109,11 +104,6 @@ private void UseProgressive(Memory serialized) Type actualType = vectorOfTable.GetType(); - /// Lazy Vectors are . - Assert.True( - actualType.GetGenericTypeDefinition() == typeof(FlatSharp.Internal.FlatBufferProgressiveVector<,,>), - "Progressive Vectors are of type FlatBufferProgressiveVector<>"); - // Progressive vectors return the same instance each time. SimpleTable? first = vectorOfTable[0]; SimpleTable? second = vectorOfTable[0]; @@ -140,11 +130,6 @@ private void UseGreedy(Memory serialized) Type actualType = vectorOfTable.GetType(); - /// Greedy Vectors are . - Assert.True( - actualType == typeof(FlatSharp.Internal.ImmutableList), - "Greedy vectors are implemented as ImmutableList."); - // Greedy Vectors return a different instance each time: SimpleTable? first = vectorOfTable[0]; SimpleTable? second = vectorOfTable[0]; @@ -171,10 +156,6 @@ private void UseGreedyMutable(Memory serialized) Type actualType = vectorOfTable.GetType(); - Assert.True( - actualType == typeof(FlatSharp.Internal.PoolableList), - "GreedyMutable vectors are 'Poolable' lists"); - // GreedyMutable Vectors return the same instance each time: SimpleTable? first = vectorOfTable[0]; SimpleTable? second = vectorOfTable[0]; diff --git a/samples/Example08-IndexedVectors/IndexedVectorExample.cs b/samples/Example08-IndexedVectors/IndexedVectorExample.cs index 69a2bcbe..aa9d556b 100644 --- a/samples/Example08-IndexedVectors/IndexedVectorExample.cs +++ b/samples/Example08-IndexedVectors/IndexedVectorExample.cs @@ -69,7 +69,7 @@ public void Run() // Note that Progressive, Lazy, and Greedy will all parse IndexedVectors to different // concrete types. Assert.True( - parsedTable.Users!.GetType().GetGenericTypeDefinition() == typeof(FlatSharp.Internal.FlatBufferIndexedVector<,,,>).GetGenericTypeDefinition(), + parsedTable.Users!.GetType().GetGenericTypeDefinition() == typeof(FlatSharp.Internal.FlatBufferIndexedVector<,>).GetGenericTypeDefinition(), "Parsed indexed vectors have a different implementation"); foreach (string key in new[] { "1", "2", "3", "4", "5" }) diff --git a/samples/Example12-WriteThrough/WriteThrough.cs b/samples/Example12-WriteThrough/WriteThrough.cs index 49c62b12..d50b72a0 100644 --- a/samples/Example12-WriteThrough/WriteThrough.cs +++ b/samples/Example12-WriteThrough/WriteThrough.cs @@ -15,6 +15,7 @@ */ using System.Buffers.Binary; +using System.Diagnostics.CodeAnalysis; using System.Runtime.Intrinsics.Arm; using System.Security.Cryptography; using System.Text; @@ -59,10 +60,7 @@ public static void ReferenceStructWriteThrough() { // Each block is 128 bytes. For a 1MB filter, we need 8192 blocks. - BloomFilter filter = new BloomFilter(1024 * 1024 / 128) - { - Blocks = new List() - }; + BloomFilter filter = new BloomFilter(1024 * 1024 / 128); // Write our bloom filter out to an array. It should be about 1MB in size. rawData = new byte[BloomFilter.Serializer.GetMaxSize(filter)]; @@ -180,6 +178,7 @@ public partial class BloomFilter // use murmur3 or something appropriate for this use case :) private readonly HashAlgorithm[] hashAlgorithms = new HashAlgorithm[] { SHA256.Create(), SHA1.Create(), MD5.Create() }; + [SetsRequiredMembers] public BloomFilter(int blockCount) { this.Blocks = new List(blockCount); diff --git a/samples/Samples.csproj b/samples/Samples.csproj index ef7a7d29..8b7666a9 100644 --- a/samples/Samples.csproj +++ b/samples/Samples.csproj @@ -31,11 +31,11 @@ - + all runtime; build; native; contentfiles; analyzers; buildtransitive - + From 43eaca80a73be701f7c964b8c3e51f3cb091e193 Mon Sep 17 00:00:00 2001 From: James Courtney Date: Fri, 17 Mar 2023 12:42:48 -0700 Subject: [PATCH 07/66] Negative defaults (#373) * Support negative defaults * Rev version * Add extra test --- .../SchemaModel/EnumSchemaModel.cs | 11 +++- .../SchemaModel/PropertyFieldModel.cs | 2 +- .../DefaultValues/DefaultValues.fbs | 26 ++++++++++ .../DefaultValues/DefaultValuesTests.cs | 52 +++++++++++++++++++ src/common.props | 4 +- 5 files changed, 91 insertions(+), 4 deletions(-) create mode 100644 src/Tests/FlatSharpEndToEndTests/DefaultValues/DefaultValues.fbs create mode 100644 src/Tests/FlatSharpEndToEndTests/DefaultValues/DefaultValuesTests.cs diff --git a/src/FlatSharp.Compiler/SchemaModel/EnumSchemaModel.cs b/src/FlatSharp.Compiler/SchemaModel/EnumSchemaModel.cs index 47e7079e..940d1395 100644 --- a/src/FlatSharp.Compiler/SchemaModel/EnumSchemaModel.cs +++ b/src/FlatSharp.Compiler/SchemaModel/EnumSchemaModel.cs @@ -25,6 +25,7 @@ public class EnumSchemaModel : BaseSchemaModel private readonly Dictionary nameValueMap; private readonly string underlyingType; private readonly IEnumerable? documentation; + private readonly FlatBufferEnum @enum; private EnumSchemaModel(Schema.Schema schema, FlatBufferEnum @enum) : base(schema, @enum.Name, new FlatSharpAttributes(@enum.Attributes)) { @@ -37,6 +38,7 @@ public class EnumSchemaModel : BaseSchemaModel this.documentation = @enum.Documentation; this.DeclaringFile = @enum.DeclarationFile; this.FriendlyName = @enum.OriginalName ?? @enum.Name; + this.@enum = @enum; this.AttributeValidator.ExternValidator = _ => AttributeValidationResult.Valid; } @@ -79,7 +81,14 @@ protected override void OnWriteCode(CodeWriter writer, CompileContext context) writer.AppendSummaryComment(item.Value.Documentation); } - writer.AppendLine($"{item.Key} = {item.Value.Value},"); + if (this.@enum.UnderlyingType.BaseType == BaseType.ULong) + { + writer.AppendLine($"{item.Key} = {(ulong)item.Value.Value},"); + } + else + { + writer.AppendLine($"{item.Key} = {item.Value.Value},"); + } } } } diff --git a/src/FlatSharp.Compiler/SchemaModel/PropertyFieldModel.cs b/src/FlatSharp.Compiler/SchemaModel/PropertyFieldModel.cs index 6574cae4..63ece6c1 100644 --- a/src/FlatSharp.Compiler/SchemaModel/PropertyFieldModel.cs +++ b/src/FlatSharp.Compiler/SchemaModel/PropertyFieldModel.cs @@ -206,7 +206,7 @@ public string GetDefaultValue() return "true"; } - return $"({typeName}){defaultInt}"; + return $"({typeName})({defaultInt})"; } } diff --git a/src/Tests/FlatSharpEndToEndTests/DefaultValues/DefaultValues.fbs b/src/Tests/FlatSharpEndToEndTests/DefaultValues/DefaultValues.fbs new file mode 100644 index 00000000..d3a16918 --- /dev/null +++ b/src/Tests/FlatSharpEndToEndTests/DefaultValues/DefaultValues.fbs @@ -0,0 +1,26 @@ +namespace FlatSharpEndToEndTests.DefaultValues; + +enum Int64Enum : long { + NegOne = -1, + LongMax = 9223372036854775807 +} + +enum UInt64Enum : ulong { + Zero = 0, + Max = 18446744073709551615 +} + +table Defaults +{ + EnumLongNegOne : Int64Enum = NegOne; + EnumLongMax : Int64Enum = LongMax; + + EnumULongZero : UInt64Enum = Zero; + EnumULongMax : UInt64Enum = Max; + + LongNegOne : long = -1; + LongMax : long = 9223372036854775807; + + ULongZero : ulong = 0; + ULongMax : ulong = 18446744073709551615; +} \ No newline at end of file diff --git a/src/Tests/FlatSharpEndToEndTests/DefaultValues/DefaultValuesTests.cs b/src/Tests/FlatSharpEndToEndTests/DefaultValues/DefaultValuesTests.cs new file mode 100644 index 00000000..3b1e6c00 --- /dev/null +++ b/src/Tests/FlatSharpEndToEndTests/DefaultValues/DefaultValuesTests.cs @@ -0,0 +1,52 @@ +/* + * Copyright 2023 James Courtney + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +namespace FlatSharpEndToEndTests.DefaultValues; + +public class DefaultValuesTests +{ + [Fact] + public void DefaultValue_Enum_Negative() + { + Defaults defaults = new(); + + Assert.Equal(long.MaxValue, (long)defaults.EnumLongMax); + Assert.Equal((long)-1, (long)defaults.EnumLongNegOne); + + Assert.Equal(long.MaxValue, defaults.LongMax); + Assert.Equal(-1, defaults.LongNegOne); + + Assert.Equal(0ul, defaults.ULongZero); + + // FlatC bug: ulong values over 2^63 are not supported. + Assert.Equal(0ul, defaults.ULongMax); + + Assert.Equal(0ul, (ulong)defaults.EnumULongZero); + + // FlatC bug: ulong values over 2^63 are not supported. + Assert.Equal(0ul, (ulong)defaults.EnumULongMax); + } + + [Fact] + public void Enum_Values() + { + Assert.Equal(-1L, (long)Int64Enum.NegOne); + Assert.Equal(long.MaxValue, (long)Int64Enum.LongMax); + + Assert.Equal(0UL, (ulong)UInt64Enum.Zero); + Assert.Equal(ulong.MaxValue, (ulong)UInt64Enum.Max); + } +} diff --git a/src/common.props b/src/common.props index 5061822e..fc80a93f 100644 --- a/src/common.props +++ b/src/common.props @@ -13,8 +13,8 @@ true - 7.1.0 - 7.1.0 + 7.1.1 + 7.1.1 $(Version) James Courtney FlatSharp is a fast, idiomatic implementation of the FlatBuffer binary format. From e6bc6f4144790f0e700f5231423f5f60e5ba7a23 Mon Sep 17 00:00:00 2001 From: Sam G Date: Thu, 1 Jun 2023 04:18:31 -0400 Subject: [PATCH 08/66] quoted $(CompilerPath) in command (#377) --- src/FlatSharp.Compiler/FlatSharp.Compiler.targets | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/FlatSharp.Compiler/FlatSharp.Compiler.targets b/src/FlatSharp.Compiler/FlatSharp.Compiler.targets index ea430c75..24647c1d 100644 --- a/src/FlatSharp.Compiler/FlatSharp.Compiler.targets +++ b/src/FlatSharp.Compiler/FlatSharp.Compiler.targets @@ -121,7 +121,7 @@ Importance="high" /> From 5f74de9f6a168cc5eb65e5964a5242870b63eb90 Mon Sep 17 00:00:00 2001 From: James Courtney Date: Tue, 1 Aug 2023 13:03:58 -0700 Subject: [PATCH 09/66] Allow custom deserializers to reduce file size (#386) * Allow custom deserializers to reduce file size * case-insensitive enum parsing --- src/FlatSharp.Compiler/CompilerOptions.cs | 29 +++++++- .../FlatSharp.Compiler.csproj | 2 +- .../FlatSharp.Compiler.targets | 11 ++- src/FlatSharp.Compiler/FlatSharpCompiler.cs | 18 +++-- .../SchemaModel/RootModel.cs | 2 +- .../FlatSharp.Runtime.csproj | 2 +- src/FlatSharp/FlatSharp.csproj | 2 +- .../RoslynSerializerGenerator.cs | 32 ++++++--- .../DeserializationModesTests.cs | 72 +++++++++++++++++++ src/common.props | 5 +- 10 files changed, 150 insertions(+), 25 deletions(-) create mode 100644 src/Tests/FlatSharpCompilerTests/DeserializationModesTests.cs diff --git a/src/FlatSharp.Compiler/CompilerOptions.cs b/src/FlatSharp.Compiler/CompilerOptions.cs index 62609437..6dcd3250 100644 --- a/src/FlatSharp.Compiler/CompilerOptions.cs +++ b/src/FlatSharp.Compiler/CompilerOptions.cs @@ -15,11 +15,14 @@ */ using CommandLine; +using System.Linq; namespace FlatSharp.Compiler; public record CompilerOptions { + private IList? deserializers; + [Option('i', "input", HelpText = "FBS input file", Required = true, Separator = ';')] public IEnumerable InputFiles { get; set; } = Array.Empty(); @@ -38,14 +41,34 @@ public record CompilerOptions [Option("gen-poolable", Hidden = false, Default = false, HelpText = "EXPERIMENTAL: Generate extra code to enable object pooling for allocation reductions.")] public bool? GeneratePoolableObjects { get; set; } + [Option("deserializers", Hidden = false, HelpText = "Specifies deserializers for FlatSharp to generate. Can help to reduce size of generated code.", Separator = ';')] + public IList Deserializers + { + get + { + if (this.deserializers == null || this.deserializers.Count == 0) + { + return Enum.GetValues().Distinct().ToList(); + } + + return this.deserializers; + } + set + { + this.deserializers = value; + } + } + + [Option("unity-assembly-path", HelpText = "Path to assembly (e.g. UnityEngine.dll) which enables Unity support.")] + public string? UnityAssemblyPath { get; set; } + + // Hidden options for tests / debugging + [Option("flatc-path", Hidden = true)] public string? FlatcPath { get; set; } [Option("debug", Hidden = true, Default = false)] public bool Debug { get; set; } - - [Option("unity-assembly-path", HelpText = "Path to assembly (e.g. UnityEngine.dll) which enables Unity support.")] - public string? UnityAssemblyPath { get; set; } [Option("instrument", Hidden = true, Default = false)] public bool Instrument { get; set; } diff --git a/src/FlatSharp.Compiler/FlatSharp.Compiler.csproj b/src/FlatSharp.Compiler/FlatSharp.Compiler.csproj index f2640e31..f6cc8ac8 100644 --- a/src/FlatSharp.Compiler/FlatSharp.Compiler.csproj +++ b/src/FlatSharp.Compiler/FlatSharp.Compiler.csproj @@ -12,7 +12,7 @@ annotations - CS3021;3021;NU5127 + $(NoWarn);CS3021;3021;NU5127 diff --git a/src/FlatSharp.Compiler/FlatSharp.Compiler.targets b/src/FlatSharp.Compiler/FlatSharp.Compiler.targets index 24647c1d..4dbdc310 100644 --- a/src/FlatSharp.Compiler/FlatSharp.Compiler.targets +++ b/src/FlatSharp.Compiler/FlatSharp.Compiler.targets @@ -99,6 +99,9 @@ false + + --deserializers "$(FlatSharpDeserializers)" + true @@ -116,12 +119,16 @@ + + dotnet "$(CompilerPath)" --nullable-warnings $(FlatSharpNullable) --normalize-field-names $(FlatSharpNameNormalization) --gen-poolable $(FlatSharpPoolable) --input "@(FlatSharpSchema)" --includes "$(Includes)" $(FlatSharpDeserializers) --output $(IntermediateOutputPath) + + diff --git a/src/FlatSharp.Compiler/FlatSharpCompiler.cs b/src/FlatSharp.Compiler/FlatSharpCompiler.cs index cdfdf5d6..76c95328 100644 --- a/src/FlatSharp.Compiler/FlatSharpCompiler.cs +++ b/src/FlatSharp.Compiler/FlatSharpCompiler.cs @@ -44,12 +44,18 @@ static int Main(string[] args) try { - CommandLine.Parser.Default.ParseArguments(args) - .WithParsed(x => - { - CommandLineOptions = x; - exitCode = RunCompiler(x); - }); + Parser parser = new(with => + { + with.HelpWriter = Console.Error; + with.CaseInsensitiveEnumValues = true; + }); + + parser.ParseArguments(args) + .WithParsed(x => + { + CommandLineOptions = x; + exitCode = RunCompiler(x); + }); } catch (Exception ex) { diff --git a/src/FlatSharp.Compiler/SchemaModel/RootModel.cs b/src/FlatSharp.Compiler/SchemaModel/RootModel.cs index a4723153..4243124a 100644 --- a/src/FlatSharp.Compiler/SchemaModel/RootModel.cs +++ b/src/FlatSharp.Compiler/SchemaModel/RootModel.cs @@ -148,7 +148,7 @@ private static void WriteHelperClass(Type type, CompileContext context, CodeWrit { var options = new FlatBufferSerializerOptions(); var generator = new RoslynSerializerGenerator(options, context.TypeModelContainer); - string helper = generator.ImplementHelperClass(context.TypeModelContainer.CreateTypeModel(type), new DefaultMethodNameResolver()); + string helper = generator.ImplementHelperClass(context.TypeModelContainer.CreateTypeModel(type), new DefaultMethodNameResolver(), context.Options.Deserializers); writer.AppendLine(helper); } diff --git a/src/FlatSharp.Runtime/FlatSharp.Runtime.csproj b/src/FlatSharp.Runtime/FlatSharp.Runtime.csproj index 5d346d0b..c7c18cfa 100644 --- a/src/FlatSharp.Runtime/FlatSharp.Runtime.csproj +++ b/src/FlatSharp.Runtime/FlatSharp.Runtime.csproj @@ -9,7 +9,7 @@ annotations embedded true - CS1591 + $(NoWarn);CS1591 diff --git a/src/FlatSharp/FlatSharp.csproj b/src/FlatSharp/FlatSharp.csproj index 2bf65683..6a09bbe7 100644 --- a/src/FlatSharp/FlatSharp.csproj +++ b/src/FlatSharp/FlatSharp.csproj @@ -9,7 +9,7 @@ annotations - NETSDK1023;NU5104 + $(NoWarn);NETSDK1023;NU5104 diff --git a/src/FlatSharp/Serialization/RoslynSerializerGenerator.cs b/src/FlatSharp/Serialization/RoslynSerializerGenerator.cs index 07dfa87e..90236e87 100644 --- a/src/FlatSharp/Serialization/RoslynSerializerGenerator.cs +++ b/src/FlatSharp/Serialization/RoslynSerializerGenerator.cs @@ -36,7 +36,11 @@ namespace FlatSharp.CodeGen; /// internal class RoslynSerializerGenerator { - private static IReadOnlyList DistinctDeserializationOptions = Enum.GetValues(typeof(FlatBufferDeserializationOption)).Cast().Distinct().ToList(); + private static IReadOnlyList DistinctDeserializationOptions = + Enum.GetValues(typeof(FlatBufferDeserializationOption)) + .Cast() + .Distinct() + .ToList(); #if NET7_0_OR_GREATER private static readonly CSharpParseOptions ParseOptions = new CSharpParseOptions( @@ -164,7 +168,7 @@ public ISerializer Compile() where TRoot : class List parts = new(); foreach (Type type in dependencies) { - parts.Add(this.ImplementHelperClass(this.typeModelContainer.CreateTypeModel(type), resolver)); + parts.Add(this.ImplementHelperClass(this.typeModelContainer.CreateTypeModel(type), resolver, DistinctDeserializationOptions)); } var serializerParts = resolver.ResolveGeneratedSerializerClassName(this.typeModelContainer.CreateTypeModel(typeof(TRoot))); @@ -397,9 +401,9 @@ private HashSet TraverseAssemblyReferenceGraph() return seenAssemblies; } - private (string body, string fullName) ImplementInterfaceMethod(Type rootType, IMethodNameResolver resolver) + private (string body, string fullName) ImplementInterfaceMethod(TableTypeModel typeModel, IMethodNameResolver resolver, IEnumerable deserializationOptions) { - ITypeModel typeModel = this.typeModelContainer.CreateTypeModel(rootType); + Type rootType = typeModel.ClrType; List bodyParts = new(); { @@ -464,12 +468,24 @@ public int GetMaxSize({CSharpHelpers.GetGlobalCompilableTypeName(rootType)} root foreach (var pair in pairs) { var parts = resolver.ResolveParse(pair.Item2, typeModel); + + string body; + + if (deserializationOptions.Contains(pair.Item2)) + { + body = $"return {parts.@namespace}.{parts.className}.{parts.methodName}(buffer, args.{nameof(GeneratedSerializerParseArguments.Offset)}, args.{nameof(GeneratedSerializerParseArguments.DepthLimit)});"; + } + else + { + body = $"throw new NotImplementedException(\"Deserializer type '{pair.Item2}' was excluded from generation at compile time.\");"; + } + string methodText = $@" public {CSharpHelpers.GetGlobalCompilableTypeName(rootType)} {pair.Item1}(TInputBuffer buffer, in {typeof(GeneratedSerializerParseArguments).GetGlobalCompilableTypeName()} args) where TInputBuffer : IInputBuffer {{ - return {parts.@namespace}.{parts.className}.{parts.methodName}(buffer, args.{nameof(GeneratedSerializerParseArguments.Offset)}, args.{nameof(GeneratedSerializerParseArguments.DepthLimit)}); + {body} }} "; bodyParts.Add(methodText); @@ -547,7 +563,7 @@ public void __AotHelper() /// Implements methods for a single type. /// /// The c# code - internal string ImplementHelperClass(ITypeModel typeModel, IMethodNameResolver resolver) + internal string ImplementHelperClass(ITypeModel typeModel, IMethodNameResolver resolver, IEnumerable deserializationOptions) { bool requiresDepthTracking = typeModel.IsDeepEnoughToRequireDepthTracking(); @@ -609,7 +625,7 @@ internal string ImplementHelperClass(ITypeModel typeModel, IMethodNameResolver r } else { - foreach (var option in DistinctDeserializationOptions) + foreach (var option in DistinctDeserializationOptions.Intersect(deserializationOptions)) { parseContext = parseContext with { Options = this.options with { DeserializationOption = option } }; var parseMethod = typeModel.CreateParseMethodBody(parseContext); @@ -631,7 +647,7 @@ internal string ImplementHelperClass(ITypeModel typeModel, IMethodNameResolver r if (tableModel.ShouldBuildISerializer) { // Generate a serializer as well. - (serializerBody, _) = ImplementInterfaceMethod(typeModel.ClrType, resolver); + (serializerBody, _) = ImplementInterfaceMethod(tableModel, resolver, deserializationOptions); } } diff --git a/src/Tests/FlatSharpCompilerTests/DeserializationModesTests.cs b/src/Tests/FlatSharpCompilerTests/DeserializationModesTests.cs new file mode 100644 index 00000000..29e01655 --- /dev/null +++ b/src/Tests/FlatSharpCompilerTests/DeserializationModesTests.cs @@ -0,0 +1,72 @@ +/* + * Copyright 2023 James Courtney + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +namespace FlatSharpTests.Compiler; + +public class DeserializationModesTests +{ + [Theory] + [InlineData(FlatBufferDeserializationOption.Lazy)] + [InlineData(FlatBufferDeserializationOption.Progressive)] + [InlineData(FlatBufferDeserializationOption.Greedy)] + [InlineData(FlatBufferDeserializationOption.GreedyMutable)] + public void Only_Single_Mode(FlatBufferDeserializationOption singleOption) + { + string fbs = $@" + {MetadataHelpers.AllAttributes} + namespace Foo.Bar; + table Blah ({MetadataKeys.SerializerKind}) {{ foo : string; }} + "; + + Assembly asm = FlatSharpCompiler.CompileAndLoadAssembly(fbs, new() { Deserializers = new[] { singleOption } }); + Type t = asm.GetTypes().Single(x => x.FullName == "Foo.Bar.Blah"); + Assert.NotNull(t); + + var item = Activator.CreateInstance(t); + ISerializer serializer = (ISerializer)t.GetProperty("Serializer", BindingFlags.Public | BindingFlags.Static).GetValue(null); + byte[] buffer = new byte[100]; + + serializer.Write(buffer, item); + + foreach (FlatBufferDeserializationOption option in Enum.GetValues()) + { + if (option == singleOption) + { + serializer.Parse(buffer, option); + } + else + { + var ex = Assert.Throws(() => serializer.Parse(buffer, option)); + Assert.Equal($"Deserializer type '{option}' was excluded from generation at compile time.", ex.Message); + } + } + } + + [Fact] + public void Code_Is_Smaller() + { + string fbs = $@" + {MetadataHelpers.AllAttributes} + namespace Foo.Bar; + table Blah ({MetadataKeys.SerializerKind}) {{ foo : string; }} + "; + + (_, string singleOption) = FlatSharpCompiler.CompileAndLoadAssemblyWithCode(fbs, new() { Deserializers = new[] { FlatBufferDeserializationOption.Lazy } }); + (_, string allOptions) = FlatSharpCompiler.CompileAndLoadAssemblyWithCode(fbs, new() { Deserializers = Enum.GetValues().Distinct().ToList() }); + + Assert.True(singleOption.Length < allOptions.Length); + } +} diff --git a/src/common.props b/src/common.props index fc80a93f..72b56e66 100644 --- a/src/common.props +++ b/src/common.props @@ -5,6 +5,7 @@ $(MSBuildThisFileDirectory)\..\misc\strongname.snk 11.0 true + $(NoWarn);CS8032 @@ -13,8 +14,8 @@ true - 7.1.1 - 7.1.1 + 7.2.0 + 7.2.0 $(Version) James Courtney FlatSharp is a fast, idiomatic implementation of the FlatBuffer binary format. From 4456849d9e671d23603b515a8385534fe00db2da Mon Sep 17 00:00:00 2001 From: James Courtney Date: Tue, 1 Aug 2023 14:39:13 -0700 Subject: [PATCH 10/66] Add command line options as part of input hash (#387) --- .../FlatSharp.Compiler.csproj | 1 + src/FlatSharp.Compiler/FlatSharpCompiler.cs | 23 +++++++++++++------ 2 files changed, 17 insertions(+), 7 deletions(-) diff --git a/src/FlatSharp.Compiler/FlatSharp.Compiler.csproj b/src/FlatSharp.Compiler/FlatSharp.Compiler.csproj index f6cc8ac8..bdf00684 100644 --- a/src/FlatSharp.Compiler/FlatSharp.Compiler.csproj +++ b/src/FlatSharp.Compiler/FlatSharp.Compiler.csproj @@ -21,6 +21,7 @@ + diff --git a/src/FlatSharp.Compiler/FlatSharpCompiler.cs b/src/FlatSharp.Compiler/FlatSharpCompiler.cs index 76c95328..ba67acf0 100644 --- a/src/FlatSharp.Compiler/FlatSharpCompiler.cs +++ b/src/FlatSharp.Compiler/FlatSharpCompiler.cs @@ -110,7 +110,7 @@ private static int RunCompiler(CompilerOptions options) { List bfbs = GetBfbs(options); - string inputHash = ComputeInputHash(bfbs); + string inputHash = ComputeInputHash(bfbs, options); if (IsInputUnchanged(outputFullPath, inputHash)) { @@ -230,21 +230,30 @@ private static bool IsInputUnchanged(string outputFullPath, string inputHash) } [ExcludeFromCodeCoverage] - private static string ComputeInputHash(List bfbs) + private static string ComputeInputHash(List bfbs, CompilerOptions options) { + static void MergeHashes(byte[] hash, byte[] temp) + { + for (int i = 0; i < temp.Length; ++i) + { + hash[i] ^= temp[i]; + } + } + string inputHash = AssemblyVersion; + using (var hash = SHA256.Create()) { // Use the assembly hash as the base; this means each build will change the hash for the same schema. byte[] hashBytes = hash.ComputeHash(File.ReadAllBytes(typeof(FlatSharpCompiler).Assembly.Location)); + // Supplement with command line options. + MergeHashes(hashBytes, hash.ComputeHash(Encoding.UTF8.GetBytes(Newtonsoft.Json.JsonConvert.SerializeObject(options)))); + + // Merge each of the schema files. foreach (var schema in bfbs) { - var tempHash = hash.ComputeHash(schema); - for (int i = 0; i < 32; ++i) - { - hashBytes[i] ^= tempHash[i]; - } + MergeHashes(hashBytes, hash.ComputeHash(schema)); } inputHash += "." + Convert.ToBase64String(hashBytes); From 2c53aa0ba4ad757695c50cc15758790749fa9477 Mon Sep 17 00:00:00 2001 From: James Courtney Date: Thu, 3 Aug 2023 02:02:34 -0700 Subject: [PATCH 11/66] FlatSharp compiler enhancements (#389) * FlatSharp compiler enhancements * Fix build break * Ensure temp directory is on the same drive as the compiler * Basic Debugger Display stuff. --- src/FlatSharp.Compiler/CompilerOptions.cs | 8 +- .../FlatSharp.Compiler.targets | 50 ++--- src/FlatSharp.Compiler/FlatSharpCompiler.cs | 173 ++++++++++-------- src/FlatSharp.Compiler/PathHelpers.cs | 39 ++++ src/FlatSharp.Compiler/Schema/Schema.cs | 8 +- .../BaseReferenceTypeSchemaModel.cs | 2 +- .../SchemaModel/ReferenceStructSchemaModel.cs | 2 +- .../SchemaModel/RootModel.cs | 41 ++++- .../SchemaModel/TableSchemaModel.cs | 2 +- .../SchemaModel/ValueUnionSchemaModel.cs | 2 +- .../AbsolutePathSchemaMutator.cs | 88 +++++++++ .../ExternalTypeSchemaMutator.cs | 2 +- .../FlatBufferVectorHelpers_Greedy.cs | 1 + .../FlatBufferVectorHelpers_GreedyMutable.cs | 1 + ...tBufferVectorHelpers_GreedyMutableUnion.cs | 1 + .../FlatBufferVectorHelpers_GreedyUnion.cs | 1 + src/FlatSharp/FlatBufferVectorHelpers_Lazy.cs | 1 + .../FlatBufferVectorHelpers_LazyUnion.cs | 1 + .../FlatBufferVectorHelpers_Progressive.cs | 1 + ...latBufferVectorHelpers_ProgressiveUnion.cs | 1 + .../DeserializeClassDefinition.cs | 1 + 21 files changed, 304 insertions(+), 122 deletions(-) create mode 100644 src/FlatSharp.Compiler/PathHelpers.cs create mode 100644 src/FlatSharp.Compiler/SchemaMutators/AbsolutePathSchemaMutator.cs diff --git a/src/FlatSharp.Compiler/CompilerOptions.cs b/src/FlatSharp.Compiler/CompilerOptions.cs index 6dcd3250..d57e277b 100644 --- a/src/FlatSharp.Compiler/CompilerOptions.cs +++ b/src/FlatSharp.Compiler/CompilerOptions.cs @@ -39,7 +39,7 @@ public record CompilerOptions public bool? NullableWarnings { get; set; } [Option("gen-poolable", Hidden = false, Default = false, HelpText = "EXPERIMENTAL: Generate extra code to enable object pooling for allocation reductions.")] - public bool? GeneratePoolableObjects { get; set; } + public bool GeneratePoolableObjects { get; set; } [Option("deserializers", Hidden = false, HelpText = "Specifies deserializers for FlatSharp to generate. Can help to reduce size of generated code.", Separator = ';')] public IList Deserializers @@ -59,6 +59,12 @@ public IList Deserializers } } + [Option("class-definitions-only", Hidden = false, HelpText = "Emits only class and data definitions. No serializers.")] + public bool ClassDefinitionsOnly { get; set; } + + [Option("input-files-only", Hidden = false, HelpText = "Only outputs type definitions for expicitely passed input files. Does not process any included files.")] + public bool SpecifiedFilesOnly { get; set; } + [Option("unity-assembly-path", HelpText = "Path to assembly (e.g. UnityEngine.dll) which enables Unity support.")] public string? UnityAssemblyPath { get; set; } diff --git a/src/FlatSharp.Compiler/FlatSharp.Compiler.targets b/src/FlatSharp.Compiler/FlatSharp.Compiler.targets index 4dbdc310..edc3cb8b 100644 --- a/src/FlatSharp.Compiler/FlatSharp.Compiler.targets +++ b/src/FlatSharp.Compiler/FlatSharp.Compiler.targets @@ -90,46 +90,50 @@ + + + + + + + $([System.IO.Path]::GetFullPath('$(MSBuildThisFileDirectory)\..\tools\net6.0\FlatSharp.Compiler.dll')) + $(FlatSharpCompilerPath) + dotnet "$(CompilerPath)" --input "@(FlatSharpSchema)" --includes "$(Includes)" --output $(IntermediateOutputPath) + + + false true - - false + + + $(CompilerCommand) --nullable-warnings $(FlatSharpNullable) - - --deserializers "$(FlatSharpDeserializers)" + + $(CompilerCommand) --gen-poolable - - true + + $(CompilerCommand) --deserializers "$(FlatSharpDeserializers)" - - $([System.IO.Path]::GetFullPath('$(MSBuildThisFileDirectory)\..\tools\net6.0\FlatSharp.Compiler.dll')) + + $(CompilerCommand) --normalize-field-names $(FlatSharpNameNormalization) - - $(FlatSharpCompilerPath) + + $(CompilerCommand) --class-definitions-only - - - - - - dotnet "$(CompilerPath)" --nullable-warnings $(FlatSharpNullable) --normalize-field-names $(FlatSharpNameNormalization) --gen-poolable $(FlatSharpPoolable) --input "@(FlatSharpSchema)" --includes "$(Includes)" $(FlatSharpDeserializers) --output $(IntermediateOutputPath) + + $(CompilerCommand) --input-files-only - - - + + diff --git a/src/FlatSharp.Compiler/FlatSharpCompiler.cs b/src/FlatSharp.Compiler/FlatSharpCompiler.cs index ba67acf0..03ee3a0f 100644 --- a/src/FlatSharp.Compiler/FlatSharpCompiler.cs +++ b/src/FlatSharp.Compiler/FlatSharpCompiler.cs @@ -35,6 +35,8 @@ public class FlatSharpCompiler internal static CompilerOptions? CommandLineOptions { get; private set; } + private static readonly string RootDirectory = Path.GetDirectoryName(typeof(FlatSharpCompiler).Assembly.Location)!; + private static string AssemblyVersion => typeof(ISchemaMutator).Assembly.GetCustomAttribute()?.Version ?? "unknown"; [ExcludeFromCodeCoverage] @@ -108,7 +110,7 @@ private static int RunCompiler(CompilerOptions options) { try { - List bfbs = GetBfbs(options); + var bfbs = GetBfbs(options); string inputHash = ComputeInputHash(bfbs, options); @@ -230,7 +232,7 @@ private static bool IsInputUnchanged(string outputFullPath, string inputHash) } [ExcludeFromCodeCoverage] - private static string ComputeInputHash(List bfbs, CompilerOptions options) + private static string ComputeInputHash(List<(byte[] bfbs, string _)> bfbs, CompilerOptions options) { static void MergeHashes(byte[] hash, byte[] temp) { @@ -253,7 +255,7 @@ static void MergeHashes(byte[] hash, byte[] temp) // Merge each of the schema files. foreach (var schema in bfbs) { - MergeHashes(hashBytes, hash.ComputeHash(schema)); + MergeHashes(hashBytes, hash.ComputeHash(schema.bfbs)); } inputHash += "." + Convert.ToBase64String(hashBytes); @@ -268,7 +270,10 @@ internal static (Assembly, string) CompileAndLoadAssemblyWithCode( CompilerOptions options, IEnumerable? additionalReferences = null) { - string temp = Path.GetTempFileName() + ".fbs"; + string tempDirectory = Path.Combine(Path.GetPathRoot(RootDirectory)!, "flatsharptemp", Guid.NewGuid().ToString("n")); + Directory.CreateDirectory(tempDirectory); + + string temp = Path.Combine(tempDirectory, "schema.fbs"); File.WriteAllText(temp, fbsSchema); try @@ -278,6 +283,7 @@ internal static (Assembly, string) CompileAndLoadAssemblyWithCode( finally { File.Delete(temp); + Directory.Delete(tempDirectory, true); } } @@ -349,7 +355,7 @@ private static (Assembly, string) CompileAndLoadAssemblyWithCode( options.InputFiles = fbsFiles.Select(x => x.FullName); - List bfbs = GetBfbs(options); + List<(byte[], string)> bfbs = GetBfbs(options); string cSharp = CreateCSharp(bfbs, "hash", options); var (assembly, formattedText, _) = RoslynSerializerGenerator.CompileAssembly(cSharp, true, additionalRefs); @@ -362,7 +368,7 @@ private static (Assembly, string) CompileAndLoadAssemblyWithCode( } } - private static List GetBfbs(CompilerOptions options) + private static List<(byte[] bfbs, string fbsPath)> GetBfbs(CompilerOptions options) { string flatcPath; @@ -378,107 +384,107 @@ private static List GetBfbs(CompilerOptions options) flatcPath = options.FlatcPath; } + List<(byte[] bfbs, string fbsPath)> results = new(); string temp = Path.GetTempPath(); string dirName = $"flatsharpcompiler_temp_{Guid.NewGuid():n}"; string outputDir = Path.Combine(temp, dirName); - Directory.CreateDirectory(outputDir); - using var p = new Process + try { - StartInfo = new ProcessStartInfo + foreach (var inputFile in options.InputFiles) { - CreateNoWindow = true, - RedirectStandardError = true, - RedirectStandardOutput = true, - UseShellExecute = false, - FileName = flatcPath, - } - }; + string inputFullPath = PathHelpers.NormalizePathName(inputFile); - var args = new List - { - "-b", - "--schema", - "--bfbs-comments", - "--bfbs-builtins", - "--bfbs-filenames", - Path.GetDirectoryName(typeof(ISchemaMutator).Assembly.Location!)!, - "--no-warnings", - "-o", - outputDir, - }; + using var p = new Process + { + StartInfo = new ProcessStartInfo + { + CreateNoWindow = true, + RedirectStandardError = true, + RedirectStandardOutput = true, + UseShellExecute = false, + FileName = flatcPath, + } + }; - if (!string.IsNullOrEmpty(options.IncludesDirectory)) - { - // One or more includes directory has been specified - foreach (var includePath in options.IncludesDirectory.Split(';', StringSplitOptions.RemoveEmptyEntries)) - { - args.AddRange(new[] + var args = new List { - "-I", - new DirectoryInfo(includePath).FullName, - }); - } - } + "-b", + "--schema", + "--bfbs-comments", + "--bfbs-builtins", + "--bfbs-filenames", + RootDirectory, + "--no-warnings", + "-o", + outputDir, + }; + + if (!string.IsNullOrEmpty(options.IncludesDirectory)) + { + // One or more includes directory has been specified + foreach (var includePath in options.IncludesDirectory.Split(';', StringSplitOptions.RemoveEmptyEntries)) + { + args.AddRange(new[] + { + "-I", + new DirectoryInfo(includePath).FullName, + }); + } + } - foreach (var item in options.InputFiles) - { - args.Add(new FileInfo(item).FullName); - } + foreach (var arg in args) + { + p.StartInfo.ArgumentList.Add(arg); + } - foreach (var arg in args) - { - p.StartInfo.ArgumentList.Add(arg); - } + p.StartInfo.ArgumentList.Add(inputFullPath); - try - { - p.EnableRaisingEvents = true; + p.EnableRaisingEvents = true; - var lines = new List(); + var lines = new List(); - void OnDataReceived(object sender, DataReceivedEventArgs args) - { - if (!string.IsNullOrEmpty(args.Data)) + void OnDataReceived(object sender, DataReceivedEventArgs args) { - lines.Add(args.Data); + if (!string.IsNullOrEmpty(args.Data)) + { + lines.Add(args.Data); + } } - } - p.OutputDataReceived += OnDataReceived; - p.ErrorDataReceived += OnDataReceived; + p.OutputDataReceived += OnDataReceived; + p.ErrorDataReceived += OnDataReceived; - p.Start(); - p.BeginOutputReadLine(); - p.BeginErrorReadLine(); - p.WaitForExit(); + p.Start(); + p.BeginOutputReadLine(); + p.BeginErrorReadLine(); + p.WaitForExit(); - if (p.ExitCode == 0) - { - List bfbs = new(); - foreach (string output in Directory.GetFiles(outputDir, "*.bfbs")) + if (p.ExitCode == 0) { - bfbs.Add(File.ReadAllBytes(output)); + results.Add(( + File.ReadAllBytes(Path.Combine(outputDir, Path.GetFileNameWithoutExtension(inputFullPath) + ".bfbs")), + inputFullPath)); } - - return bfbs; - } - else - { - foreach (var line in lines) + else { - ErrorContext.Current.RegisterError(line); - } + foreach (var line in lines) + { + ErrorContext.Current.RegisterError(line); + } - ErrorContext.Current.ThrowIfHasErrors(); - throw new InvalidFbsFileException("Unknown error when invoking flatc. Process exited with error, but didn't write any errors."); + ErrorContext.Current.ThrowIfHasErrors(); + throw new InvalidFbsFileException("Unknown error when invoking flatc. Process exited with error, but didn't write any errors."); + } } } finally { Directory.Delete(outputDir, recursive: true); } + + return results; } [ExcludeFromCodeCoverage] @@ -519,7 +525,7 @@ private static (string os, string name) GetFlatcPath() } private static string CreateCSharp( - List bfbs, + List<(byte[] bfbs, string inputPath)> bfbs, string inputHash, CompilerOptions options) { @@ -548,14 +554,15 @@ private static string CreateCSharp( { new FieldNameNormalizerSchemaMutator(), new ExternalTypeSchemaMutator(), + new AbsolutePathSchemaMutator(RootDirectory), }; Stopwatch sw = Stopwatch.StartNew(); ISerializer mutableSerializer = Instrument("CompileReflectionFbs", options, FlatBufferSerializer.Default.Compile); - foreach (var s in bfbs) + foreach ((byte[] s, string fbsPath) in bfbs) { - rootModel.UnionWith(ParseSchema(mutableSerializer, s, options, postProcessTransforms, mutators).ToRootModel(options)); + rootModel.UnionWith(ParseSchema(mutableSerializer, s, options, postProcessTransforms, mutators).ToRootModel(options, fbsPath)); } ErrorContext.Current.ThrowIfHasErrors(); @@ -666,10 +673,16 @@ private static T Instrument(string step, CompilerOptions opts, Func callba private static Assembly[] BuildAdditionalReferences(CompilerOptions options, IEnumerable? additionalReferences = null) { var references = new List(); + if (additionalReferences is not null) + { references.AddRange(additionalReferences); + } + if (options.UnityAssemblyPath is not null) + { references.Add(Assembly.LoadFrom(options.UnityAssemblyPath)); + } return references.ToArray(); } diff --git a/src/FlatSharp.Compiler/PathHelpers.cs b/src/FlatSharp.Compiler/PathHelpers.cs new file mode 100644 index 00000000..05324468 --- /dev/null +++ b/src/FlatSharp.Compiler/PathHelpers.cs @@ -0,0 +1,39 @@ +/* + * Copyright 2023 James Courtney + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +using System.IO; +using System.Runtime.InteropServices; + +namespace FlatSharp.Compiler; + +public static class PathHelpers +{ + public static string NormalizePathName(string path) + { + FileInfo info = new FileInfo(path); + FlatSharpInternal.Assert(info.Exists, "expect path to exist: " + path); + + path = info.FullName; + + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) + { + // case-insensitive! + path = path.ToLowerInvariant(); + } + + return path; + } +} \ No newline at end of file diff --git a/src/FlatSharp.Compiler/Schema/Schema.cs b/src/FlatSharp.Compiler/Schema/Schema.cs index a58d5111..0d2415f5 100644 --- a/src/FlatSharp.Compiler/Schema/Schema.cs +++ b/src/FlatSharp.Compiler/Schema/Schema.cs @@ -60,12 +60,12 @@ public class Schema [FlatBufferItem(6)] public virtual AdvancedFeatures AdvancedFeatures { get; set; } - [FlatBufferItem(7)] - public virtual IIndexedVector? FbsFiles { get; set; } + [FlatBufferItem(7, Required = true)] + public virtual IIndexedVector FbsFiles { get; set; } = new IndexedVector(); - public RootModel ToRootModel(CompilerOptions options) + public RootModel ToRootModel(CompilerOptions options, string fbsPath) { - RootModel model = new RootModel(this.AdvancedFeatures); + RootModel model = new RootModel(this.AdvancedFeatures, fbsPath); foreach (var @enum in this.Enums) { diff --git a/src/FlatSharp.Compiler/SchemaModel/BaseReferenceTypeSchemaModel.cs b/src/FlatSharp.Compiler/SchemaModel/BaseReferenceTypeSchemaModel.cs index a9b642b2..b0b6e24f 100644 --- a/src/FlatSharp.Compiler/SchemaModel/BaseReferenceTypeSchemaModel.cs +++ b/src/FlatSharp.Compiler/SchemaModel/BaseReferenceTypeSchemaModel.cs @@ -179,7 +179,7 @@ private void EmitDeserializationConstructor(CodeWriter writer) private void EmitPoolableObject(CodeWriter writer, CompileContext context) { - if (context.Options.GeneratePoolableObjects == true) + if (context.Options.GeneratePoolableObjects) { writer.AppendLine("/// "); writer.AppendLine("public virtual void ReturnToPool(bool unsafeForce = false)"); diff --git a/src/FlatSharp.Compiler/SchemaModel/ReferenceStructSchemaModel.cs b/src/FlatSharp.Compiler/SchemaModel/ReferenceStructSchemaModel.cs index 9c8fdce5..a076940b 100644 --- a/src/FlatSharp.Compiler/SchemaModel/ReferenceStructSchemaModel.cs +++ b/src/FlatSharp.Compiler/SchemaModel/ReferenceStructSchemaModel.cs @@ -78,7 +78,7 @@ protected override void EmitClassDefinition(CodeWriter writer, CompileContext co writer.AppendLine($"public partial class {this.Name}"); writer.AppendLine($" : object"); - if (context.Options.GeneratePoolableObjects == true) + if (context.Options.GeneratePoolableObjects) { writer.AppendLine($" , IPoolableObject"); } diff --git a/src/FlatSharp.Compiler/SchemaModel/RootModel.cs b/src/FlatSharp.Compiler/SchemaModel/RootModel.cs index 4243124a..bac297b4 100644 --- a/src/FlatSharp.Compiler/SchemaModel/RootModel.cs +++ b/src/FlatSharp.Compiler/SchemaModel/RootModel.cs @@ -16,6 +16,8 @@ using FlatSharp.CodeGen; using FlatSharp.Compiler.Schema; +using Microsoft.CodeAnalysis.FlowAnalysis; +using System.Linq; namespace FlatSharp.Compiler.SchemaModel; @@ -28,13 +30,20 @@ public class RootModel private readonly Dictionary elements = new(); - public RootModel(AdvancedFeatures advancedFeatures) + private readonly HashSet inputFiles = new(); + + public RootModel(AdvancedFeatures advancedFeatures, string? inputFile = null) { if ((advancedFeatures & ~SupportedAdvancedFeatures) != AdvancedFeatures.None) { // bail immediately. We can't make any progress. throw new InvalidFbsFileException($"FBS schema contains advanced features that FlatSharp does not yet support."); } + + if (inputFile is not null) + { + this.inputFiles.Add(inputFile); + } } public void UnionWith(RootModel other) @@ -54,6 +63,8 @@ public void UnionWith(RootModel other) this.elements[kvp.Key] = kvp.Value; } } + + this.inputFiles.UnionWith(other.inputFiles); } public void AddElement(BaseSchemaModel model) @@ -118,6 +129,7 @@ internal void WriteCode(CodeWriter writer, CompileContext context) writer.AppendLine("#nullable enable annotations"); } + if (context.CompilePass > CodeWritingPass.PropertyModeling && context.PreviousAssembly is not null) { context.FullyQualifiedCloneMethodName = CloneMethodsGenerator.GenerateCloneMethodsForAssembly( @@ -126,21 +138,32 @@ internal void WriteCode(CodeWriter writer, CompileContext context) context.PreviousAssembly, context.TypeModelContainer); - HashSet seenTypes = new(); - foreach (var item in this.elements.Values) + if (!context.Options.ClassDefinitionsOnly) { - item.TraverseTypeModel(context, seenTypes); - } + HashSet seenTypes = new(); - foreach (Type t in seenTypes) - { - WriteHelperClass(t, context, writer); + foreach (var item in this.elements.Values) + { + item.TraverseTypeModel(context, seenTypes); + } + + foreach (Type t in seenTypes) + { + WriteHelperClass(t, context, writer); + } } } foreach (var item in this.elements.Values) { - item.WriteCode(writer, context); + bool emit = context.Options.SpecifiedFilesOnly == false + || this.inputFiles.Contains(item.DeclaringFile) + || context.CompilePass < CodeWritingPass.LastPass; + + if (emit) + { + item.WriteCode(writer, context); + } } } diff --git a/src/FlatSharp.Compiler/SchemaModel/TableSchemaModel.cs b/src/FlatSharp.Compiler/SchemaModel/TableSchemaModel.cs index 564488aa..b20f3a89 100644 --- a/src/FlatSharp.Compiler/SchemaModel/TableSchemaModel.cs +++ b/src/FlatSharp.Compiler/SchemaModel/TableSchemaModel.cs @@ -102,7 +102,7 @@ protected override void EmitClassDefinition(CodeWriter writer, CompileContext co { writer.AppendLine(": object"); - if (context.Options.GeneratePoolableObjects == true) + if (context.Options.GeneratePoolableObjects) { writer.AppendLine(", IPoolableObject"); } diff --git a/src/FlatSharp.Compiler/SchemaModel/ValueUnionSchemaModel.cs b/src/FlatSharp.Compiler/SchemaModel/ValueUnionSchemaModel.cs index 207a3803..ebdb5db3 100644 --- a/src/FlatSharp.Compiler/SchemaModel/ValueUnionSchemaModel.cs +++ b/src/FlatSharp.Compiler/SchemaModel/ValueUnionSchemaModel.cs @@ -49,7 +49,7 @@ public static bool TryCreate( return false; } - if (context.GeneratePoolableObjects == true) + if (context.GeneratePoolableObjects) { model = new ReferenceUnionSchemaModel(schema, union); } diff --git a/src/FlatSharp.Compiler/SchemaMutators/AbsolutePathSchemaMutator.cs b/src/FlatSharp.Compiler/SchemaMutators/AbsolutePathSchemaMutator.cs new file mode 100644 index 00000000..97689bf5 --- /dev/null +++ b/src/FlatSharp.Compiler/SchemaMutators/AbsolutePathSchemaMutator.cs @@ -0,0 +1,88 @@ +/* + * Copyright 2022 James Courtney + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +using FlatSharp.Compiler; +using FlatSharp.Compiler.Schema; +using FlatSharp.Compiler.SchemaModel; +using System.IO; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; + +/// +/// +internal class AbsolutePathSchemaMutator : ISchemaMutator +{ + private readonly string rootDirectory; + + public AbsolutePathSchemaMutator(string rootDirectory) + { + this.rootDirectory = rootDirectory; + } + + public void Mutate( + Schema schema, + CompilerOptions options, + List> postProcessors) + { + foreach (var fbsFile in schema.FbsFiles.Select(x => x.Value)) + { + fbsFile.FileName = this.NormalizePath(fbsFile.FileName); + } + + foreach (var @object in schema.Objects) + { + @object.DeclarationFile = this.NormalizePath(@object.DeclarationFile); + } + + foreach (var @enum in schema.Enums) + { + @enum.DeclarationFile = this.NormalizePath(@enum.DeclarationFile); + } + + if (schema.Services is not null) + { + foreach (var service in schema.Services) + { + service.DeclaringFile = this.NormalizePath(service.DeclaringFile); + } + } + + if (schema.RootTable is not null) + { + schema.RootTable.DeclarationFile = this.NormalizePath(schema.RootTable.DeclarationFile); + } + } + + private string NormalizePath(string fbsPath) + { + string[] parts = fbsPath.Split('/', StringSplitOptions.RemoveEmptyEntries); + string path = this.rootDirectory; + + foreach (string part in parts) + { + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && part == ":") + { + // flatc bug that seems to include the ':' as part of a windows path. + continue; + } + + path = Path.Combine(path, part); + } + + return PathHelpers.NormalizePathName(path); + } +} \ No newline at end of file diff --git a/src/FlatSharp.Compiler/SchemaMutators/ExternalTypeSchemaMutator.cs b/src/FlatSharp.Compiler/SchemaMutators/ExternalTypeSchemaMutator.cs index 4a2613a0..a0a546fa 100644 --- a/src/FlatSharp.Compiler/SchemaMutators/ExternalTypeSchemaMutator.cs +++ b/src/FlatSharp.Compiler/SchemaMutators/ExternalTypeSchemaMutator.cs @@ -23,7 +23,7 @@ /// Renames external types to have unique, random names, then replaces those in the output with real names. /// /// -/// This class is slightly. The idea for external types is that they are defined in assemblies that FlatSharp doesn't know about. +/// This class is slightly odd. The idea for external types is that they are defined in assemblies that FlatSharp doesn't know about. /// However, the FlatSharp type model needs full knowledge of these types in order to build serializers. So, we emit "temporary" types /// to take the place of these external types while we build our serializer. Then, at the end, we do a big find/replace to swap /// the temporary types for the real types. diff --git a/src/FlatSharp/FlatBufferVectorHelpers_Greedy.cs b/src/FlatSharp/FlatBufferVectorHelpers_Greedy.cs index b57ba7ec..8e831149 100644 --- a/src/FlatSharp/FlatBufferVectorHelpers_Greedy.cs +++ b/src/FlatSharp/FlatBufferVectorHelpers_Greedy.cs @@ -35,6 +35,7 @@ public static (string classDef, string className) CreateGreedyVector( string classDef = $$"""" + [System.Diagnostics.DebuggerDisplay("Greedy [ {{itemTypeModel.ClrType.Name}} ], Count = {Count}")] internal sealed class {{className}} : object , IList<{{baseTypeName}}> diff --git a/src/FlatSharp/FlatBufferVectorHelpers_GreedyMutable.cs b/src/FlatSharp/FlatBufferVectorHelpers_GreedyMutable.cs index 0b7482d3..40a3f751 100644 --- a/src/FlatSharp/FlatBufferVectorHelpers_GreedyMutable.cs +++ b/src/FlatSharp/FlatBufferVectorHelpers_GreedyMutable.cs @@ -50,6 +50,7 @@ string IfMutable(string str) string classDef = $$"""" + [System.Diagnostics.DebuggerDisplay("GreedyMutable [ {{itemTypeModel.ClrType.Name}} ], Count = {Count}")] internal sealed class {{className}} : object , IList<{{baseTypeName}}> diff --git a/src/FlatSharp/FlatBufferVectorHelpers_GreedyMutableUnion.cs b/src/FlatSharp/FlatBufferVectorHelpers_GreedyMutableUnion.cs index ee493c06..fd296788 100644 --- a/src/FlatSharp/FlatBufferVectorHelpers_GreedyMutableUnion.cs +++ b/src/FlatSharp/FlatBufferVectorHelpers_GreedyMutableUnion.cs @@ -33,6 +33,7 @@ public static (string classDef, string className) CreateGreedyMutableUnionVector string classDef = $$"""" + [System.Diagnostics.DebuggerDisplay("GreedyMutable [ {{itemTypeModel.ClrType.Name}} ], Count = {Count}")] internal sealed class {{className}} : object , IList<{{baseTypeName}}> diff --git a/src/FlatSharp/FlatBufferVectorHelpers_GreedyUnion.cs b/src/FlatSharp/FlatBufferVectorHelpers_GreedyUnion.cs index 78eff0c4..df3cb2ce 100644 --- a/src/FlatSharp/FlatBufferVectorHelpers_GreedyUnion.cs +++ b/src/FlatSharp/FlatBufferVectorHelpers_GreedyUnion.cs @@ -35,6 +35,7 @@ public static (string classDef, string className) CreateGreedyUnionVector( string classDef = $$"""" + [System.Diagnostics.DebuggerDisplay("Greedy [ {{itemTypeModel.ClrType.Name}} ], Count = {Count}")] internal sealed class {{className}} : object , IList<{{baseTypeName}}> diff --git a/src/FlatSharp/FlatBufferVectorHelpers_Lazy.cs b/src/FlatSharp/FlatBufferVectorHelpers_Lazy.cs index b2d6090f..32452829 100644 --- a/src/FlatSharp/FlatBufferVectorHelpers_Lazy.cs +++ b/src/FlatSharp/FlatBufferVectorHelpers_Lazy.cs @@ -36,6 +36,7 @@ public static (string classDef, string className) CreateLazyVector( string classDef = $$"""" + [System.Diagnostics.DebuggerDisplay("Lazy [ {{itemTypeModel.ClrType.Name}} ], Count = {Count}")] internal sealed class {{className}} : object , IList<{{baseTypeName}}> diff --git a/src/FlatSharp/FlatBufferVectorHelpers_LazyUnion.cs b/src/FlatSharp/FlatBufferVectorHelpers_LazyUnion.cs index 64516528..53bb8382 100644 --- a/src/FlatSharp/FlatBufferVectorHelpers_LazyUnion.cs +++ b/src/FlatSharp/FlatBufferVectorHelpers_LazyUnion.cs @@ -36,6 +36,7 @@ public static (string classDef, string className) CreateLazyUnionVector( string classDef = $$"""" + [System.Diagnostics.DebuggerDisplay("Lazy [ {{itemTypeModel.ClrType.Name}} ], Count = {Count}")] internal sealed class {{className}} : object , IList<{{baseTypeName}}> diff --git a/src/FlatSharp/FlatBufferVectorHelpers_Progressive.cs b/src/FlatSharp/FlatBufferVectorHelpers_Progressive.cs index 0c1cb7c0..dffda683 100644 --- a/src/FlatSharp/FlatBufferVectorHelpers_Progressive.cs +++ b/src/FlatSharp/FlatBufferVectorHelpers_Progressive.cs @@ -38,6 +38,7 @@ public static (string classDef, string className) CreateProgressiveVector( string classDef = $$"""" + [System.Diagnostics.DebuggerDisplay("Progressive [ {{itemTypeModel.ClrType.Name}} ], Count = {Count}")] internal sealed class {{className}} : object , IList<{{baseTypeName}}> diff --git a/src/FlatSharp/FlatBufferVectorHelpers_ProgressiveUnion.cs b/src/FlatSharp/FlatBufferVectorHelpers_ProgressiveUnion.cs index 639a0c1e..d5a68b5f 100644 --- a/src/FlatSharp/FlatBufferVectorHelpers_ProgressiveUnion.cs +++ b/src/FlatSharp/FlatBufferVectorHelpers_ProgressiveUnion.cs @@ -35,6 +35,7 @@ public static (string classDef, string className) CreateProgressiveUnionVector( string classDef = $$"""" + [System.Diagnostics.DebuggerDisplay("Progressive [ {{itemTypeModel.ClrType.Name}} ], Count = {Count}")] internal sealed class {{className}} : object , IList<{{baseTypeName}}> diff --git a/src/FlatSharp/Serialization/DeserializeClassDefinition.cs b/src/FlatSharp/Serialization/DeserializeClassDefinition.cs index a456ac68..0cb6a429 100644 --- a/src/FlatSharp/Serialization/DeserializeClassDefinition.cs +++ b/src/FlatSharp/Serialization/DeserializeClassDefinition.cs @@ -284,6 +284,7 @@ public override string ToString() return $@" + [System.Diagnostics.DebuggerDisplay(""{this.options.DeserializationOption} {this.typeModel.ClrType.Name}"")] internal sealed class {this.ClassName} : {typeModel.GetGlobalCompilableTypeName()} , {interfaceGlobalName} From 3599660d84715eb28ca66750e8906cd2edfb855a Mon Sep 17 00:00:00 2001 From: James Courtney Date: Fri, 4 Aug 2023 02:36:49 -0700 Subject: [PATCH 12/66] Absolute paths flatc (#391) * Update flatc to custom version * Update flatc again * Fix error messages --- src/FlatSharp.Compiler/FlatSharpCompiler.cs | 13 +-- .../AbsolutePathSchemaMutator.cs | 88 ------------------ .../PathNormalizerSchemaMutator.cs | 58 ++++++++++++ src/Tests/FlatSharpCompilerTests/EnumTests.cs | 10 +- .../FlatSharpCompilerTests/SortedVectors.cs | 2 +- .../StructVectorTests.cs | 2 +- src/common.props | 4 +- src/ext/flatc/flatc.version.txt | 3 +- src/ext/flatc/linux/flatc | Bin 3882408 -> 7148088 bytes src/ext/flatc/macos_arm/flatc | Bin 6281776 -> 6896448 bytes src/ext/flatc/macos_intel/flatc | Bin 3241744 -> 3563696 bytes src/ext/flatc/windows/flatc.exe | Bin 3254272 -> 3486720 bytes 12 files changed, 72 insertions(+), 108 deletions(-) delete mode 100644 src/FlatSharp.Compiler/SchemaMutators/AbsolutePathSchemaMutator.cs create mode 100644 src/FlatSharp.Compiler/SchemaMutators/PathNormalizerSchemaMutator.cs diff --git a/src/FlatSharp.Compiler/FlatSharpCompiler.cs b/src/FlatSharp.Compiler/FlatSharpCompiler.cs index 03ee3a0f..57c79587 100644 --- a/src/FlatSharp.Compiler/FlatSharpCompiler.cs +++ b/src/FlatSharp.Compiler/FlatSharpCompiler.cs @@ -35,8 +35,6 @@ public class FlatSharpCompiler internal static CompilerOptions? CommandLineOptions { get; private set; } - private static readonly string RootDirectory = Path.GetDirectoryName(typeof(FlatSharpCompiler).Assembly.Location)!; - private static string AssemblyVersion => typeof(ISchemaMutator).Assembly.GetCustomAttribute()?.Version ?? "unknown"; [ExcludeFromCodeCoverage] @@ -270,10 +268,7 @@ internal static (Assembly, string) CompileAndLoadAssemblyWithCode( CompilerOptions options, IEnumerable? additionalReferences = null) { - string tempDirectory = Path.Combine(Path.GetPathRoot(RootDirectory)!, "flatsharptemp", Guid.NewGuid().ToString("n")); - Directory.CreateDirectory(tempDirectory); - - string temp = Path.Combine(tempDirectory, "schema.fbs"); + string temp = Path.GetTempFileName() + ".fbs"; File.WriteAllText(temp, fbsSchema); try @@ -283,7 +278,6 @@ internal static (Assembly, string) CompileAndLoadAssemblyWithCode( finally { File.Delete(temp); - Directory.Delete(tempDirectory, true); } } @@ -415,7 +409,8 @@ private static (Assembly, string) CompileAndLoadAssemblyWithCode( "--bfbs-comments", "--bfbs-builtins", "--bfbs-filenames", - RootDirectory, + Environment.CurrentDirectory, + "--bfbs-absolute-paths", "--no-warnings", "-o", outputDir, @@ -554,7 +549,7 @@ private static string CreateCSharp( { new FieldNameNormalizerSchemaMutator(), new ExternalTypeSchemaMutator(), - new AbsolutePathSchemaMutator(RootDirectory), + new PathNormalizerSchemaMutator(), }; Stopwatch sw = Stopwatch.StartNew(); diff --git a/src/FlatSharp.Compiler/SchemaMutators/AbsolutePathSchemaMutator.cs b/src/FlatSharp.Compiler/SchemaMutators/AbsolutePathSchemaMutator.cs deleted file mode 100644 index 97689bf5..00000000 --- a/src/FlatSharp.Compiler/SchemaMutators/AbsolutePathSchemaMutator.cs +++ /dev/null @@ -1,88 +0,0 @@ -/* - * Copyright 2022 James Courtney - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -using FlatSharp.Compiler; -using FlatSharp.Compiler.Schema; -using FlatSharp.Compiler.SchemaModel; -using System.IO; -using System.Linq; -using System.Runtime.InteropServices; -using System.Text; - -/// -/// -internal class AbsolutePathSchemaMutator : ISchemaMutator -{ - private readonly string rootDirectory; - - public AbsolutePathSchemaMutator(string rootDirectory) - { - this.rootDirectory = rootDirectory; - } - - public void Mutate( - Schema schema, - CompilerOptions options, - List> postProcessors) - { - foreach (var fbsFile in schema.FbsFiles.Select(x => x.Value)) - { - fbsFile.FileName = this.NormalizePath(fbsFile.FileName); - } - - foreach (var @object in schema.Objects) - { - @object.DeclarationFile = this.NormalizePath(@object.DeclarationFile); - } - - foreach (var @enum in schema.Enums) - { - @enum.DeclarationFile = this.NormalizePath(@enum.DeclarationFile); - } - - if (schema.Services is not null) - { - foreach (var service in schema.Services) - { - service.DeclaringFile = this.NormalizePath(service.DeclaringFile); - } - } - - if (schema.RootTable is not null) - { - schema.RootTable.DeclarationFile = this.NormalizePath(schema.RootTable.DeclarationFile); - } - } - - private string NormalizePath(string fbsPath) - { - string[] parts = fbsPath.Split('/', StringSplitOptions.RemoveEmptyEntries); - string path = this.rootDirectory; - - foreach (string part in parts) - { - if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && part == ":") - { - // flatc bug that seems to include the ':' as part of a windows path. - continue; - } - - path = Path.Combine(path, part); - } - - return PathHelpers.NormalizePathName(path); - } -} \ No newline at end of file diff --git a/src/FlatSharp.Compiler/SchemaMutators/PathNormalizerSchemaMutator.cs b/src/FlatSharp.Compiler/SchemaMutators/PathNormalizerSchemaMutator.cs new file mode 100644 index 00000000..d15673ad --- /dev/null +++ b/src/FlatSharp.Compiler/SchemaMutators/PathNormalizerSchemaMutator.cs @@ -0,0 +1,58 @@ +/* + * Copyright 2022 James Courtney + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +using FlatSharp.Compiler; +using FlatSharp.Compiler.Schema; +using System.Linq; + +/// +/// +internal class PathNormalizerSchemaMutator : ISchemaMutator +{ + public void Mutate( + Schema schema, + CompilerOptions options, + List> postProcessors) + { + foreach (var fbsFile in schema.FbsFiles.Select(x => x.Value)) + { + fbsFile.FileName = PathHelpers.NormalizePathName(fbsFile.FileName); + } + + foreach (var @object in schema.Objects) + { + @object.DeclarationFile = PathHelpers.NormalizePathName(@object.DeclarationFile); + } + + foreach (var @enum in schema.Enums) + { + @enum.DeclarationFile = PathHelpers.NormalizePathName(@enum.DeclarationFile); + } + + if (schema.Services is not null) + { + foreach (var service in schema.Services) + { + service.DeclaringFile = PathHelpers.NormalizePathName(service.DeclaringFile); + } + } + + if (schema.RootTable is not null) + { + schema.RootTable.DeclarationFile = PathHelpers.NormalizePathName(schema.RootTable.DeclarationFile); + } + } +} \ No newline at end of file diff --git a/src/Tests/FlatSharpCompilerTests/EnumTests.cs b/src/Tests/FlatSharpCompilerTests/EnumTests.cs index a6c51f0a..8f88c555 100644 --- a/src/Tests/FlatSharpCompilerTests/EnumTests.cs +++ b/src/Tests/FlatSharpCompilerTests/EnumTests.cs @@ -115,21 +115,21 @@ public void FlagsTest_TooMany() public void InvalidEnumTest_WrongUnderlyingType_Bool() { var ex = Assert.Throws(() => this.EnumTest("bool")); - Assert.Contains("error: underlying enum type must be integral", ex.Message); + Assert.Contains("error: underlying enumtype must be integral", ex.Message); } [Fact] public void InvalidEnumTest_WrongUnderlyingType_Double() { var ex = Assert.Throws(() => this.EnumTest("double")); - Assert.Contains("error: underlying enum type must be integral", ex.Message); + Assert.Contains("error: underlying enumtype must be integral", ex.Message); } [Fact] public void InvalidEnumTest_WrongUnderlyingType_Float() { var ex = Assert.Throws(() => this.EnumTest("float")); - Assert.Contains("error: underlying enum type must be integral", ex.Message); + Assert.Contains("error: underlying enumtype must be integral", ex.Message); } [Fact] @@ -199,7 +199,7 @@ public void InvalidEnumTest_UnknownType() { string fbs = $"{MetadataHelpers.AllAttributes}namespace Foo.Bar; enum MyEnum : foobar {{ Red = 0x0, Blue = 255, Yellow = 256 }}"; var ex = Assert.Throws(() => FlatSharpCompiler.CompileAndLoadAssembly(fbs, new())); - Assert.Contains("error: underlying enum type must be integral", ex.Message); + Assert.Contains("error: underlying enumtype must be integral", ex.Message); } [Fact] @@ -207,7 +207,7 @@ public void InvalidEnumTest_String() { string fbs = $"{MetadataHelpers.AllAttributes}namespace Foo.Bar; enum MyEnum : string {{ Red, Blue, Yellow }}"; var ex = Assert.Throws(() => FlatSharpCompiler.CompileAndLoadAssembly(fbs, new())); - Assert.Contains("error: underlying enum type must be integral", ex.Message); + Assert.Contains("error: underlying enumtype must be integral", ex.Message); } [Fact] diff --git a/src/Tests/FlatSharpCompilerTests/SortedVectors.cs b/src/Tests/FlatSharpCompilerTests/SortedVectors.cs index 525bccea..51226d8a 100644 --- a/src/Tests/FlatSharpCompilerTests/SortedVectors.cs +++ b/src/Tests/FlatSharpCompilerTests/SortedVectors.cs @@ -221,7 +221,7 @@ table VectorMember {{ var ex = Assert.Throws(() => FlatSharpCompiler.CompileAndLoadAssembly(schema, new())); Assert.Contains( - "error: 'key' field must be string or scalar type", + "error: 'key' field must be string, scalar type or fixed size array of scalars", ex.Message); } diff --git a/src/Tests/FlatSharpCompilerTests/StructVectorTests.cs b/src/Tests/FlatSharpCompilerTests/StructVectorTests.cs index aa29228d..6916b0cb 100644 --- a/src/Tests/FlatSharpCompilerTests/StructVectorTests.cs +++ b/src/Tests/FlatSharpCompilerTests/StructVectorTests.cs @@ -81,7 +81,7 @@ struct Foo {{ schema, new())); - Assert.Contains("error: structs may contain only scalar or struct fields", ex.Message); + Assert.Contains("error: Incomplete type in struct is not allowed, type name: Bar", ex.Message); } [Fact] diff --git a/src/common.props b/src/common.props index 72b56e66..59aa6bc9 100644 --- a/src/common.props +++ b/src/common.props @@ -14,8 +14,8 @@ true - 7.2.0 - 7.2.0 + 7.2.1 + 7.2.1 $(Version) James Courtney FlatSharp is a fast, idiomatic implementation of the FlatBuffer binary format. diff --git a/src/ext/flatc/flatc.version.txt b/src/ext/flatc/flatc.version.txt index bb9ebbc2..be0cfd5e 100644 --- a/src/ext/flatc/flatc.version.txt +++ b/src/ext/flatc/flatc.version.txt @@ -1,6 +1,5 @@ Flatc binaries are copyright Google Inc, and are distributed in accordance with the Apache 2 License, which is included adjacent to this file. The executables included are sourced from the following release of FlatBuffers: -https://github.com/google/flatbuffers/releases/tag/v22.10.26 +https://github.com/jamescourtney/flatbuffers/commit/56c0288c7b122bc14a981162d248e7d3523eeea7 -You are encouraged to verify the hashes of the files included in this package with those from the linked CI run. \ No newline at end of file diff --git a/src/ext/flatc/linux/flatc b/src/ext/flatc/linux/flatc index f828215c5f57b823825e0116d3653240bf6a7c24..4636a671a03a9a17e17cd48a98d4382b3917e21b 100755 GIT binary patch literal 7148088 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 z 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%0An{5l%0qMxYes;njsslxOc>^2J{E#om_P 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

#DQ1pe$Fz9cOp@{r@-74(QJ3AY4`9X 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≀tM0Wyr%AbvwN0aTP-4 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

f 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%0DdO{-p({O1ZEoF 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 k2mfHd{kG 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

mzV%1*b)?lfe(AcL-16AHT6E$^w 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�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