public static string BuildSpecifiedModelName(
this SetterKind setterKind,
string modelNameSuffix)
{
var result = Invariant($"{Settings.ModelBaseName}{setterKind.BuildNameToken()}{modelNameSuffix}");
return(result);
}
public StructVectorDefinition(
string name,
string typeName,
SetterKind setterKind,
List <string> properties)
{
this.PropertyNames = properties;
this.SetterKind = setterKind;
this.FbsTypeName = typeName;
this.Name = name;
}
public static string BuildScriptedModelName(
this DeclaredKeyMethod declaredKeyMethod,
SetterKind setterKind,
HierarchyKind hierarchyKind,
TypeWrapperKind typeWrapperKind,
string childIdentifier)
{
var result = Invariant($"{Settings.ModelBaseName}{declaredKeyMethod.BuildNameToken()}{setterKind.BuildNameToken()}{typeWrapperKind.BuildNameToken()}{hierarchyKind.BuildNameToken()}{childIdentifier}");
return(result);
}
public static string BuildNameToken(
this SetterKind setterKind)
{
switch (setterKind)
{
case SetterKind.PrivateSetters:
return("PrivateSet");
case SetterKind.PublicSetters:
return("PublicSet");
default:
throw new NotSupportedException("this setter kind is not supported: " + setterKind);
}
}
public static bool RequiresConstructor(
this SetterKind setterKind)
{
bool result;
switch (setterKind)
{
////case SetterKind.ReadOnlyAuto:
case SetterKind.PrivateSetters:
result = true;
break;
case SetterKind.PublicSetters:
result = false;
break;
default:
throw new NotSupportedException(Invariant($"This {nameof(SetterKind)} is not supported: {setterKind}"));
}
return(result);
}
public static string GetSpecifiedModelsDirectoryPath(
this SpecifiedModelKind specifiedModelKind,
SetterKind setterKind,
ModelOrTest modelOrTest)
{
string result;
switch (modelOrTest)
{
case ModelOrTest.Model:
result = Settings.SpecifiedModelsPath + specifiedModelKind + "\\" + setterKind.BuildNameToken() + "\\";
break;
case ModelOrTest.Test:
result = Settings.SpecifiedModelsTestPath + specifiedModelKind + "\\" + setterKind.BuildNameToken() + "\\";
break;
default:
throw new NotSupportedException("This kind is not supported: " + modelOrTest);
}
return(result);
}
public static string ToSetterString(
this SetterKind setterKind)
{
string result;
switch (setterKind)
{
////case SetterKind.ReadOnlyAuto:
//// result = string.Empty;
//// break;
case SetterKind.PrivateSetters:
result = "private set; ";
break;
case SetterKind.PublicSetters:
result = "set; ";
break;
default:
throw new NotSupportedException(Invariant($"This {nameof(SetterKind)} is not supported: {setterKind}"));
}
return(result);
}
public static string GetScriptedModelsDirectoryPath(
this ModelOrTest modelOrTest,
DeclaredKeyMethod declaredKeyMethod,
SetterKind setterKind,
TypeWrapperKind typeWrapperKind)
{
string result;
switch (modelOrTest)
{
case ModelOrTest.Model:
result = Settings.ScriptedModelsPath + declaredKeyMethod.BuildNameToken() + "\\" + setterKind.BuildNameToken() + "\\" + typeWrapperKind.BuildNameToken() + "\\";
break;
case ModelOrTest.Test:
result = Settings.ScriptedModelsTestsPath + declaredKeyMethod.BuildNameToken() + "\\" + setterKind.BuildNameToken() + "\\" + typeWrapperKind.BuildNameToken() + "\\";
break;
default:
throw new NotSupportedException("This model or test is not supported: " + modelOrTest);
}
return(result);
}
private void Test(SetterKind setterKind, FlatBufferDeserializationOption option)
{
string schema = $@"
namespace VirtualTests;
table VirtualTable ({MetadataKeys.SerializerKind}:""{option}"") {{
Default:int ({MetadataKeys.Setter}:""{setterKind}"");
ForcedVirtual:int ({MetadataKeys.NonVirtualProperty}:""false"", {MetadataKeys.SetterLegacy}:""{setterKind}"");
ForcedNonVirtual:int ({MetadataKeys.NonVirtualProperty}:""true"", {MetadataKeys.Setter}:""{(setterKind != SetterKind.None ? setterKind : SetterKind.Public)}"");
Struct:VirtualStruct;
}}
struct VirtualStruct {{
Default:int ({MetadataKeys.Setter}:""{setterKind}"");
ForcedVirtual:int ({MetadataKeys.NonVirtualProperty}:""false"", setter:""{setterKind}"");
ForcedNonVirtual:int ({MetadataKeys.NonVirtualProperty}:""true"", setter:""{(setterKind != SetterKind.None ? setterKind : SetterKind.Public)}"");
}}";
Assembly asm = FlatSharpCompiler.CompileAndLoadAssembly(schema, new());
foreach (var typeName in new[] { "VirtualTests.VirtualTable", "VirtualTests.VirtualStruct" })
{
Type type = asm.GetType(typeName);
Assert.IsTrue(type.IsPublic);
var defaultProperty = type.GetProperty("Default");
var forcedVirtualProperty = type.GetProperty("ForcedVirtual");
var forcedNonVirtualProperty = type.GetProperty("ForcedNonVirtual");
Assert.IsNotNull(defaultProperty);
Assert.IsNotNull(forcedVirtualProperty);
Assert.IsNotNull(forcedNonVirtualProperty);
Assert.IsTrue(defaultProperty.GetMethod.IsPublic);
Assert.IsTrue(forcedVirtualProperty.GetMethod.IsPublic);
Assert.IsTrue(forcedNonVirtualProperty.GetMethod.IsPublic);
if (setterKind == SetterKind.PublicInit ||
setterKind == SetterKind.ProtectedInit ||
setterKind == SetterKind.ProtectedInternalInit)
{
Assert.IsNotNull(defaultProperty.SetMethod.ReturnParameter.GetRequiredCustomModifiers().Any(x => x.FullName == "System.Runtime.CompilerServices.IsExternalInit"));
Assert.IsNotNull(forcedVirtualProperty.SetMethod.ReturnParameter.GetRequiredCustomModifiers().Any(x => x.FullName == "System.Runtime.CompilerServices.IsExternalInit"));
Assert.IsNotNull(forcedNonVirtualProperty.SetMethod.ReturnParameter.GetRequiredCustomModifiers().Any(x => x.FullName == "System.Runtime.CompilerServices.IsExternalInit"));
}
if (setterKind == SetterKind.None)
{
Assert.IsNull(defaultProperty.SetMethod);
Assert.IsNull(forcedVirtualProperty.SetMethod);
Assert.IsNotNull(forcedNonVirtualProperty.SetMethod); // non-virtual can't have null setters.
}
else if (setterKind == SetterKind.Protected || setterKind == SetterKind.ProtectedInit)
{
Assert.IsTrue(defaultProperty.SetMethod.IsFamily);
Assert.IsTrue(forcedVirtualProperty.SetMethod.IsFamily);
Assert.IsTrue(forcedNonVirtualProperty.SetMethod.IsFamily);
}
else if (setterKind == SetterKind.ProtectedInternal || setterKind == SetterKind.ProtectedInternalInit)
{
Assert.IsTrue(defaultProperty.SetMethod.IsFamilyOrAssembly);
Assert.IsTrue(forcedVirtualProperty.SetMethod.IsFamilyOrAssembly);
Assert.IsTrue(forcedNonVirtualProperty.SetMethod.IsFamilyOrAssembly);
}
else if (setterKind == SetterKind.Public || setterKind == SetterKind.PublicInit)
{
Assert.IsTrue(defaultProperty.SetMethod.IsPublic);
Assert.IsTrue(forcedVirtualProperty.SetMethod.IsPublic);
Assert.IsTrue(forcedNonVirtualProperty.SetMethod.IsPublic);
}
else
{
Assert.Fail();
}
}
}
private void Test(SetterKind setterKind, FlatBufferDeserializationOption option)
{
string schema = $@"
namespace VirtualTests;
table VirtualTable (PrecompiledSerializer:""{option}"") {{
Default:int (setter:""{setterKind}"");
ForcedVirtual:int (virtual:""true"", setter:""{setterKind}"");
ForcedNonVirtual:int (virtual:""false"", setter:""{(setterKind != SetterKind.None ? setterKind : SetterKind.Public)}"");
Struct:VirtualStruct;
}}
struct VirtualStruct {{
Default:int (setter:""{setterKind}"");
ForcedVirtual:int (virtual:""true"", setter:""{setterKind}"");
ForcedNonVirtual:int (virtual:""false"", setter:""{(setterKind != SetterKind.None ? setterKind : SetterKind.Public)}"");
}}";
Assembly asm = FlatSharpCompiler.CompileAndLoadAssembly(schema);
foreach (var typeName in new[] { "VirtualTests.VirtualTable", "VirtualTests.VirtualStruct" })
{
Type type = asm.GetType(typeName);
Assert.IsTrue(type.IsPublic);
var defaultProperty = type.GetProperty("Default");
var forcedVirtualProperty = type.GetProperty("ForcedVirtual");
var forcedNonVirtualProperty = type.GetProperty("ForcedNonVirtual");
Assert.IsNotNull(defaultProperty);
Assert.IsNotNull(forcedVirtualProperty);
Assert.IsNotNull(forcedNonVirtualProperty);
Assert.IsTrue(defaultProperty.GetMethod.IsPublic);
Assert.IsTrue(forcedVirtualProperty.GetMethod.IsPublic);
Assert.IsTrue(forcedNonVirtualProperty.GetMethod.IsPublic);
if (setterKind == SetterKind.None)
{
Assert.IsNull(defaultProperty.SetMethod);
Assert.IsNull(forcedVirtualProperty.SetMethod);
Assert.IsNotNull(forcedNonVirtualProperty.SetMethod); // non-virtual can't have null setters.
}
else if (setterKind == SetterKind.Protected)
{
Assert.IsTrue(defaultProperty.SetMethod.IsFamily);
Assert.IsTrue(forcedVirtualProperty.SetMethod.IsFamily);
Assert.IsTrue(forcedNonVirtualProperty.SetMethod.IsFamily);
}
else if (setterKind == SetterKind.ProtectedInternal)
{
Assert.IsTrue(defaultProperty.SetMethod.IsFamilyOrAssembly);
Assert.IsTrue(forcedVirtualProperty.SetMethod.IsFamilyOrAssembly);
Assert.IsTrue(forcedNonVirtualProperty.SetMethod.IsFamilyOrAssembly);
}
else if (setterKind == SetterKind.Public)
{
Assert.IsTrue(defaultProperty.SetMethod.IsPublic);
Assert.IsTrue(forcedVirtualProperty.SetMethod.IsPublic);
Assert.IsTrue(forcedNonVirtualProperty.SetMethod.IsPublic);
}
else
{
Assert.Fail();
}
}
}
private static bool ParseSetterKind(string value, out SetterKind setter)
{
return(Enum.TryParse <SetterKind>(value, true, out setter));
}
private void Test(SetterKind setterKind, FlatBufferDeserializationOption option)
{
string schema = $@"
{MetadataHelpers.AllAttributes}
namespace VirtualTests;
table VirtualTable ({MetadataKeys.SerializerKind}:""{option}"") {{
Default:int ({MetadataKeys.Setter}:""{setterKind}"");
ForcedVirtual:int ({MetadataKeys.NonVirtualProperty}:""false"", {MetadataKeys.Setter}:""{setterKind}"");
ForcedNonVirtual:int ({MetadataKeys.NonVirtualProperty}:""true"", {MetadataKeys.Setter}:""{(setterKind != SetterKind.None ? setterKind : SetterKind.Public)}"");
Struct:VirtualStruct;
}}
struct VirtualStruct {{
Default:int ({MetadataKeys.Setter}:""{setterKind}"");
ForcedVirtual:int ({MetadataKeys.NonVirtualProperty}:""false"", {MetadataKeys.Setter}:""{setterKind}"");
ForcedNonVirtual:int ({MetadataKeys.NonVirtualProperty}:""true"", {MetadataKeys.Setter}:""{(setterKind != SetterKind.None ? setterKind : SetterKind.Public)}"");
}}";
bool isInit = setterKind == SetterKind.PublicInit ||
setterKind == SetterKind.ProtectedInit ||
setterKind == SetterKind.ProtectedInternalInit;
Assembly asm;
#if NET5_0_OR_GREATER
asm = FlatSharpCompiler.CompileAndLoadAssembly(schema, new());
#else
try
{
asm = FlatSharpCompiler.CompileAndLoadAssembly(schema, new());
}
catch (InvalidFbsFileException ex) when(isInit)
{
// 3.1 should bail.
Assert.Contains(
$"The attribute '{MetadataKeys.Setter}' value {setterKind} is not supported in the current .NET Runtime. It requires .NET 5 or later.",
ex.Message);
return;
}
#endif
foreach (var typeName in new[] { "VirtualTests.VirtualTable", "VirtualTests.VirtualStruct" })
{
Type type = asm.GetType(typeName);
Assert.True(type.IsPublic);
var defaultProperty = type.GetProperty("Default");
var forcedVirtualProperty = type.GetProperty("ForcedVirtual");
var forcedNonVirtualProperty = type.GetProperty("ForcedNonVirtual");
Assert.NotNull(defaultProperty);
Assert.NotNull(forcedVirtualProperty);
Assert.NotNull(forcedNonVirtualProperty);
Assert.True(defaultProperty.GetMethod.IsPublic);
Assert.True(forcedVirtualProperty.GetMethod.IsPublic);
Assert.True(forcedNonVirtualProperty.GetMethod.IsPublic);
if (isInit)
{
Assert.Contains(defaultProperty.SetMethod.ReturnParameter.GetRequiredCustomModifiers(), x => x.FullName == "System.Runtime.CompilerServices.IsExternalInit");
Assert.Contains(forcedVirtualProperty.SetMethod.ReturnParameter.GetRequiredCustomModifiers(), x => x.FullName == "System.Runtime.CompilerServices.IsExternalInit");
Assert.Contains(forcedNonVirtualProperty.SetMethod.ReturnParameter.GetRequiredCustomModifiers(), x => x.FullName == "System.Runtime.CompilerServices.IsExternalInit");
}
if (setterKind == SetterKind.None)
{
Assert.Null(defaultProperty.SetMethod);
Assert.Null(forcedVirtualProperty.SetMethod);
Assert.NotNull(forcedNonVirtualProperty.SetMethod); // non-virtual can't have null setters.
}
else if (setterKind == SetterKind.Protected || setterKind == SetterKind.ProtectedInit)
{
Assert.True(defaultProperty.SetMethod.IsFamily);
Assert.True(forcedVirtualProperty.SetMethod.IsFamily);
Assert.True(forcedNonVirtualProperty.SetMethod.IsFamily);
}
else if (setterKind == SetterKind.ProtectedInternal || setterKind == SetterKind.ProtectedInternalInit)
{
Assert.True(defaultProperty.SetMethod.IsFamilyOrAssembly);
Assert.True(forcedVirtualProperty.SetMethod.IsFamilyOrAssembly);
Assert.True(forcedNonVirtualProperty.SetMethod.IsFamilyOrAssembly);
}
else if (setterKind == SetterKind.Public || setterKind == SetterKind.PublicInit)
{
Assert.True(defaultProperty.SetMethod.IsPublic);
Assert.True(forcedVirtualProperty.SetMethod.IsPublic);
Assert.True(forcedNonVirtualProperty.SetMethod.IsPublic);
}
else
{
Assert.False(true);
}
}
}
