private void AddComplexDataHandler(
CSharpSyntaxGeneratorSettings settings,
ClassBuilder classBuilder,
ConstructorBuilder constructorBuilder,
MethodBuilder method,
ComplexTypeDescriptor complexTypeDescriptor,
HashSet <string> processed,
bool isNonNullable)
{
if (complexTypeDescriptor.ParentRuntimeType is null)
{
throw new InvalidOperationException();
}
method
.AddParameter(_dataParameterName)
.SetType(complexTypeDescriptor.ParentRuntimeType
.ToString()
.MakeNullable(!isNonNullable))
.SetName(_dataParameterName);
if (settings.IsStoreEnabled())
{
method
.AddParameter(_snapshot)
.SetType(TypeNames.IEntityStoreSnapshot);
}
if (!isNonNullable)
{
method.AddCode(EnsureProperNullability(_dataParameterName, isNonNullable));
}
const string returnValue = nameof(returnValue);
method.AddCode($"{complexTypeDescriptor.RuntimeType.Name}? {returnValue};");
method.AddEmptyLine();
GenerateIfForEachImplementedBy(
method,
complexTypeDescriptor,
o => GenerateComplexDataInterfaceIfClause(settings, o, returnValue));
method.AddCode($"return {returnValue};");
AddRequiredMapMethods(
settings,
_dataParameterName,
complexTypeDescriptor,
classBuilder,
constructorBuilder,
processed);
}
private void AddUpdateEntityMethod(
ClassBuilder classBuilder,
MethodBuilder methodBuilder,
INamedTypeDescriptor namedTypeDescriptor,
HashSet <string> processed)
{
methodBuilder.AddCode(
AssignmentBuilder
.New()
.SetLefthandSide($"{TypeNames.EntityId} {_entityId}")
.SetRighthandSide(
MethodCallBuilder
.Inline()
.SetMethodName(_idSerializer, "Parse")
.AddArgument($"{_obj}.Value")));
methodBuilder.AddCode(
MethodCallBuilder
.New()
.SetMethodName(_entityIds, nameof(List <object> .Add))
.AddArgument(_entityId));
methodBuilder.AddEmptyLine();
if (namedTypeDescriptor is InterfaceTypeDescriptor interfaceTypeDescriptor)
{
// If the type is an interface
foreach (ObjectTypeDescriptor concreteType in interfaceTypeDescriptor.ImplementedBy)
{
methodBuilder
.AddEmptyLine()
.AddCode(CreateUpdateEntityStatement(concreteType)
.AddCode($"return {_entityId};"));
}
methodBuilder.AddEmptyLine();
methodBuilder.AddCode(ExceptionBuilder.New(TypeNames.NotSupportedException));
}
else if (namedTypeDescriptor is ObjectTypeDescriptor objectTypeDescriptor)
{
BuildTryGetEntityIf(
CreateEntityType(
objectTypeDescriptor.Name,
objectTypeDescriptor.RuntimeType.NamespaceWithoutGlobal))
.AddCode(CreateEntityConstructorCall(objectTypeDescriptor, false))
.AddElse(CreateEntityConstructorCall(objectTypeDescriptor, true));
methodBuilder.AddEmptyLine();
methodBuilder.AddCode($"return {_entityId};");
}
AddRequiredDeserializeMethods(namedTypeDescriptor, classBuilder, processed);
}
private void AddEntityHandler(
ClassBuilder classBuilder,
ConstructorBuilder constructorBuilder,
MethodBuilder method,
ComplexTypeDescriptor complexTypeDescriptor,
HashSet <string> processed,
bool isNonNullable)
{
method
.AddParameter(_entityId)
.SetType(TypeNames.EntityId.MakeNullable(!isNonNullable));
method
.AddParameter(_snapshot)
.SetType(TypeNames.IEntityStoreSnapshot);
if (!isNonNullable)
{
method.AddCode(EnsureProperNullability(_entityId, isNonNullable));
}
if (complexTypeDescriptor is InterfaceTypeDescriptor interfaceTypeDescriptor)
{
foreach (ObjectTypeDescriptor implementee in interfaceTypeDescriptor.ImplementedBy
.Where(x => x.IsEntity()))
{
NameString dataMapperName =
CreateEntityMapperName(implementee.RuntimeType.Name, implementee.Name);
if (processed.Add(dataMapperName))
{
var dataMapperType =
TypeNames.IEntityMapper.WithGeneric(
CreateEntityType(
implementee.Name,
implementee.RuntimeType.NamespaceWithoutGlobal)
.ToString(),
implementee.RuntimeType.Name);
AddConstructorAssignedField(
dataMapperType,
GetFieldName(dataMapperName),
GetParameterName(dataMapperName),
classBuilder,
constructorBuilder);
}
method.AddCode(GenerateEntityHandlerIfClause(implementee, isNonNullable));
}
}
method.AddCode(ExceptionBuilder.New(TypeNames.NotSupportedException));
}
private void GenerateIfForEachImplementedBy(
MethodBuilder method,
ComplexTypeDescriptor complexTypeDescriptor,
Func<ObjectTypeDescriptor, IfBuilder> generator)
{
if (!(complexTypeDescriptor is InterfaceTypeDescriptor interfaceTypeDescriptor) ||
!interfaceTypeDescriptor.ImplementedBy.Any())
{
return;
}
IEnumerable<ObjectTypeDescriptor> dataTypes =
interfaceTypeDescriptor.ImplementedBy.Where(x => x.IsData());
IfBuilder ifChain = generator(dataTypes.First());
foreach (ObjectTypeDescriptor objectTypeDescriptor in dataTypes.Skip(1))
{
ifChain.AddIfElse(generator(objectTypeDescriptor).SkipIndents());
}
ifChain.AddElse(ExceptionBuilder.New(TypeNames.NotSupportedException));
method.AddCode(ifChain);
}
private void AddDataTypeDeserializerMethod(
ClassBuilder classBuilder,
MethodBuilder methodBuilder,
ComplexTypeDescriptor complexTypeDescriptor,
HashSet <string> processed)
{
if (complexTypeDescriptor is InterfaceTypeDescriptor interfaceTypeDescriptor)
{
AddInterfaceDataTypeDeserializerToMethod(methodBuilder, interfaceTypeDescriptor);
}
else
{
MethodCallBuilder returnStatement = MethodCallBuilder
.New()
.SetReturn()
.SetNew()
.SetMethodName(complexTypeDescriptor.Name);
foreach (PropertyDescriptor property in complexTypeDescriptor.Properties)
{
returnStatement.AddArgument(BuildUpdateMethodCall(property));
}
methodBuilder.AddCode(returnStatement);
}
AddRequiredDeserializeMethods(complexTypeDescriptor, classBuilder, processed);
}
private void AddInterfaceDataTypeDeserializerToMethod(
MethodBuilder methodBuilder,
InterfaceTypeDescriptor interfaceTypeDescriptor)
{
methodBuilder.AddCode(
AssignmentBuilder
.New()
.SetLefthandSide($"var {_typename}")
.SetRighthandSide(MethodCallBuilder
.Inline()
.SetMethodName(
_obj,
"Value",
nameof(JsonElement.GetProperty))
.AddArgument(WellKnownNames.TypeName.AsStringToken())
.Chain(x => x.SetMethodName(nameof(JsonElement.GetString)))));
// If the type is an interface
foreach (ObjectTypeDescriptor concreteType in interfaceTypeDescriptor.ImplementedBy)
{
MethodCallBuilder returnStatement = MethodCallBuilder
.New()
.SetReturn()
.SetNew()
.SetMethodName(
$"{concreteType.RuntimeType.Namespace}.State." +
CreateDataTypeName(concreteType.Name))
.AddArgument("typename");
foreach (PropertyDescriptor property in concreteType.Properties)
{
if (property.Name.Value.EqualsOrdinal(WellKnownNames.TypeName))
{
continue;
}
returnStatement.AddArgument(
CodeBlockBuilder
.New()
.AddCode($"{GetParameterName(property.Name)}: ")
.AddCode(BuildUpdateMethodCall(property)));
}
IfBuilder ifStatement = IfBuilder
.New()
.SetCondition(
$"typename?.Equals(\"{concreteType.Name}\", " +
$"{TypeNames.OrdinalStringComparison}) ?? false")
.AddCode(returnStatement);
methodBuilder
.AddEmptyLine()
.AddCode(ifStatement);
}
methodBuilder
.AddEmptyLine()
.AddCode(ExceptionBuilder.New(TypeNames.NotSupportedException));
}
private void AddDataHandler(
ClassBuilder classBuilder,
ConstructorBuilder constructorBuilder,
MethodBuilder method,
ComplexTypeDescriptor namedTypeDescriptor,
HashSet <string> processed,
bool isNonNullable)
{
method
.AddParameter(_dataParameterName)
.SetType(namedTypeDescriptor.ParentRuntimeType !
.ToString()
.MakeNullable(!isNonNullable));
method
.AddParameter(_snapshot)
.SetType(TypeNames.IEntityStoreSnapshot);
if (!isNonNullable)
{
method.AddCode(EnsureProperNullability(_dataParameterName, isNonNullable));
}
const string returnValue = nameof(returnValue);
method.AddCode($"{namedTypeDescriptor.RuntimeType.Name} {returnValue} = default!;");
method.AddEmptyLine();
GenerateIfForEachImplementedBy(
method,
namedTypeDescriptor,
o => GenerateDataInterfaceIfClause(o, isNonNullable, returnValue));
method.AddCode($"return {returnValue};");
AddRequiredMapMethods(
_dataParameterName,
namedTypeDescriptor,
classBuilder,
constructorBuilder,
processed);
}
private void AddScalarTypeDeserializerMethod(
MethodBuilder methodBuilder,
ILeafTypeDescriptor namedType)
{
string deserializeMethod = JsonUtils.GetParseMethod(namedType.SerializationType);
methodBuilder.AddCode(
MethodCallBuilder
.New()
.SetReturn()
.SetMethodName(GetFieldName(namedType.Name) + "Parser", "Parse")
.AddArgument(MethodCallBuilder
.Inline()
.SetMethodName(_obj, nameof(Nullable <JsonElement> .Value), deserializeMethod)
.SetNullForgiving()));
}
private void AddDeserializeMethod(
ITypeDescriptor typeReference,
ClassBuilder classBuilder,
HashSet <string> processed)
{
string methodName = DeserializerMethodNameFromTypeName(typeReference);
if (processed.Add(methodName))
{
MethodBuilder methodBuilder = classBuilder
.AddMethod()
.SetPrivate()
.SetReturnType(typeReference.ToStateTypeReference())
.SetName(methodName);
if (typeReference.IsOrContainsEntityType())
{
methodBuilder
.AddParameter(_session, x => x.SetType(TypeNames.IEntityStoreUpdateSession))
.AddParameter(_obj, x => x.SetType(TypeNames.JsonElement.MakeNullable()))
.AddParameter(
_entityIds,
x => x.SetType(TypeNames.ISet.WithGeneric(TypeNames.EntityId)));
}
else
{
methodBuilder
.AddParameter(_obj)
.SetType(TypeNames.JsonElement.MakeNullable());
}
IfBuilder jsonElementNullCheck = IfBuilder
.New()
.SetCondition($"!{_obj}.HasValue")
.AddCode(
typeReference.IsNonNullableType()
? ExceptionBuilder.New(TypeNames.ArgumentNullException)
: CodeLineBuilder.From("return null;"));
methodBuilder
.AddCode(jsonElementNullCheck)
.AddEmptyLine();
AddDeserializeMethodBody(classBuilder, methodBuilder, typeReference, processed);
}
}
private void AddArrayHandler(
ClassBuilder classBuilder,
MethodBuilder methodBuilder,
ListTypeDescriptor listTypeDescriptor,
HashSet <string> processed)
{
var listVarName = GetParameterName(listTypeDescriptor.Name) + "s";
methodBuilder
.AddCode(
AssignmentBuilder
.New()
.SetLefthandSide($"var {listVarName}")
.SetRighthandSide(
CodeBlockBuilder
.New()
.AddCode("new ")
.AddCode(TypeNames.List)
.AddCode("<")
.AddCode(
listTypeDescriptor.InnerType
.ToStateTypeReference()
.SkipTrailingSpace())
.AddCode(">")
.AddCode("()")))
.AddEmptyLine()
.AddCode(
ForEachBuilder
.New()
.SetLoopHeader(
$"{TypeNames.JsonElement} {_child} in {_obj}.Value.EnumerateArray()")
.AddCode(
MethodCallBuilder
.New()
.SetMethodName(listVarName, nameof(List <object> .Add))
.AddArgument(
BuildUpdateMethodCall(
listTypeDescriptor.InnerType,
CodeInlineBuilder.From(_child)))))
.AddEmptyLine()
.AddCode($"return {listVarName};");
AddDeserializeMethod(listTypeDescriptor.InnerType, classBuilder, processed);
}
private void AddInterfaceDataTypeDeserializerToMethod(
MethodBuilder methodBuilder,
InterfaceTypeDescriptor interfaceTypeDescriptor)
{
methodBuilder.AddCode(
AssignmentBuilder
.New()
.SetLefthandSide($"var {_typename}")
.SetRighthandSide(MethodCallBuilder
.Inline()
.SetMethodName(
_obj,
"Value",
nameof(JsonElement.GetProperty))
.AddArgument(WellKnownNames.TypeName.AsStringToken())
.Chain(x => x.SetMethodName(nameof(JsonElement.GetString)))));
// If the type is an interface
foreach (ObjectTypeDescriptor concreteType in interfaceTypeDescriptor.ImplementedBy)
{
MethodCallBuilder returnStatement = CreateBuildDataStatement(concreteType)
.SetReturn();
IfBuilder ifStatement = IfBuilder
.New()
.SetCondition(
$"typename?.Equals(\"{concreteType.Name}\", " +
$"{TypeNames.OrdinalStringComparison}) ?? false")
.AddCode(returnStatement);
methodBuilder
.AddEmptyLine()
.AddCode(ifStatement);
}
methodBuilder
.AddEmptyLine()
.AddCode(ExceptionBuilder.New(TypeNames.NotSupportedException));
}
private void AddScalarTypeDeserializerMethod(
MethodBuilder methodBuilder,
ILeafTypeDescriptor namedType)
{
MethodCallBuilder methodCall = MethodCallBuilder
.New()
.SetReturn()
.SetMethodName(GetFieldName(namedType.Name) + "Parser", "Parse");
if (namedType.SerializationType.ToString() == TypeNames.JsonElement)
{
methodCall.AddArgument($"{_obj}.{nameof(Nullable<JsonElement>.Value)}!");
}
else
{
var deserializeMethod = JsonUtils.GetParseMethod(namedType.SerializationType);
methodCall.AddArgument(MethodCallBuilder
.Inline()
.SetMethodName(_obj, nameof(Nullable <JsonElement> .Value), deserializeMethod)
.SetNullForgiving());
}
methodBuilder.AddCode(methodCall);
}
private void AddArrayHandler(
CSharpSyntaxGeneratorSettings settings,
ClassBuilder classBuilder,
ConstructorBuilder constructorBuilder,
MethodBuilder methodBuilder,
ListTypeDescriptor listTypeDescriptor,
HashSet <string> processed,
bool isNonNullable)
{
methodBuilder
.AddParameter(_list)
.SetType(listTypeDescriptor.ToStateTypeReference());
if (settings.IsStoreEnabled())
{
methodBuilder
.AddParameter(_snapshot)
.SetType(TypeNames.IEntityStoreSnapshot);
}
var listVarName = GetParameterName(listTypeDescriptor.Name) + "s";
methodBuilder.AddCode(EnsureProperNullability(_list, isNonNullable));
methodBuilder.AddCode(
AssignmentBuilder
.New()
.SetLefthandSide($"var {listVarName}")
.SetRighthandSide(
CodeBlockBuilder
.New()
.AddCode("new ")
.AddCode(TypeNames.List)
.AddCode("<")
.AddCode(
listTypeDescriptor.InnerType.ToTypeReference().SkipTrailingSpace())
.AddCode(">")
.AddCode("()")));
methodBuilder.AddEmptyLine();
ForEachBuilder forEachBuilder = ForEachBuilder
.New()
.SetLoopHeader(
CodeBlockBuilder
.New()
.AddCode(listTypeDescriptor.InnerType.ToStateTypeReference())
.AddCode($"{_child} in {_list}"))
.AddCode(
MethodCallBuilder
.New()
.SetMethodName(listVarName, nameof(List <object> .Add))
.AddArgument(MethodCallBuilder
.Inline()
.SetMethodName(MapMethodNameFromTypeName(listTypeDescriptor.InnerType))
.AddArgument(_child)
.If(settings.IsStoreEnabled(), x => x.AddArgument(_snapshot))));
methodBuilder
.AddCode(forEachBuilder)
.AddEmptyLine()
.AddCode($"return {listVarName};");
AddMapMethod(
settings,
listVarName,
listTypeDescriptor.InnerType,
classBuilder,
constructorBuilder,
processed);
}
private void AddEntityDataTypeDeserializerToMethod(
MethodBuilder methodBuilder,
InterfaceTypeDescriptor interfaceTypeDescriptor)
{
methodBuilder.AddCode(
AssignmentBuilder
.New()
.SetLefthandSide($"var {_typename}")
.SetRighthandSide(MethodCallBuilder
.Inline()
.SetMethodName(
_obj,
"Value",
nameof(JsonElement.GetProperty))
.AddArgument(WellKnownNames.TypeName.AsStringToken())
.Chain(x => x.SetMethodName(nameof(JsonElement.GetString)))));
foreach (ObjectTypeDescriptor concreteType in interfaceTypeDescriptor.ImplementedBy)
{
ICode builder;
if (concreteType.IsEntity())
{
builder = CodeBlockBuilder
.New()
.AddCode(
AssignmentBuilder
.New()
.SetLefthandSide($"{TypeNames.EntityId} {_entityId}")
.SetRighthandSide(
MethodCallBuilder
.Inline()
.SetMethodName(_idSerializer, "Parse")
.AddArgument($"{_obj}.Value")))
.AddCode(CreateUpdateEntityStatement(concreteType)
.AddCode(MethodCallBuilder
.New()
.SetReturn()
.SetNew()
.SetMethodName(TypeNames.EntityIdOrData)
.AddArgument(_entityId)));
}
else
{
builder =
MethodCallBuilder
.New()
.SetNew()
.SetReturn()
.SetMethodName(TypeNames.EntityIdOrData)
.AddArgument(CreateBuildDataStatement(concreteType)
.SetDetermineStatement(false)
.SetNew());
}
methodBuilder
.AddEmptyLine()
.AddCode(IfBuilder
.New()
.SetCondition(
$"typename?.Equals(\"{concreteType.Name}\", " +
$"{TypeNames.OrdinalStringComparison}) ?? false")
.AddCode(builder));
}
methodBuilder
.AddEmptyLine()
.AddCode(ExceptionBuilder.New(TypeNames.NotSupportedException));
}
protected override void Generate(ITypeDescriptor typeDescriptor,
CSharpSyntaxGeneratorSettings settings,
CodeWriter writer,
out string fileName,
out string?path,
out string ns)
{
ComplexTypeDescriptor descriptor =
typeDescriptor as ComplexTypeDescriptor ??
throw new InvalidOperationException(
"A result data factory can only be generated for complex types");
fileName = CreateResultFactoryName(descriptor.RuntimeType.Name);
path = State;
ns = CreateStateNamespace(descriptor.RuntimeType.NamespaceWithoutGlobal);
ClassBuilder classBuilder =
ClassBuilder
.New()
.SetName(fileName)
.AddImplements(
TypeNames.IOperationResultDataFactory.WithGeneric(descriptor.RuntimeType));
ConstructorBuilder constructorBuilder = classBuilder
.AddConstructor()
.SetTypeName(descriptor.Name);
if (settings.IsStoreEnabled())
{
AddConstructorAssignedField(
TypeNames.IEntityStore,
_entityStore,
entityStore,
classBuilder,
constructorBuilder);
}
MethodCallBuilder returnStatement = MethodCallBuilder
.New()
.SetReturn()
.SetNew()
.SetMethodName(descriptor.RuntimeType.Name);
foreach (PropertyDescriptor property in descriptor.Properties)
{
returnStatement
.AddArgument(BuildMapMethodCall(settings, _info, property));
}
IfBuilder ifHasCorrectType = IfBuilder
.New()
.SetCondition(
$"{_dataInfo} is {CreateResultInfoName(descriptor.RuntimeType.Name)} {_info}")
.AddCode(returnStatement);
MethodBuilder createMethod = classBuilder
.AddMethod("Create")
.SetAccessModifier(AccessModifier.Public)
.SetReturnType(descriptor.RuntimeType.Name)
.AddParameter(_dataInfo, b => b.SetType(TypeNames.IOperationResultDataInfo))
.AddParameter(
_snapshot,
b => b.SetDefault("null")
.SetType(TypeNames.IEntityStoreSnapshot.MakeNullable()));
if (settings.IsStoreEnabled())
{
createMethod
.AddCode(
IfBuilder.New()
.SetCondition($"{_snapshot} is null")
.AddCode(
AssignmentBuilder
.New()
.SetLefthandSide(_snapshot)
.SetRighthandSide($"{_entityStore}.CurrentSnapshot")))
.AddEmptyLine();
}
createMethod.AddCode(ifHasCorrectType)
.AddEmptyLine()
.AddCode(
ExceptionBuilder
.New(TypeNames.ArgumentException)
.AddArgument(
$"\"{CreateResultInfoName(descriptor.RuntimeType.Name)} expected.\""));
var processed = new HashSet <string>();
AddRequiredMapMethods(
settings,
_info,
descriptor,
classBuilder,
constructorBuilder,
processed,
true);
classBuilder
.AddProperty("ResultType")
.SetType(TypeNames.Type)
.AsLambda($"typeof({descriptor.RuntimeType.Namespace}.{descriptor.Implements[0]})")
.SetInterface(TypeNames.IOperationResultDataFactory);
classBuilder
.AddMethod("Create")
.SetInterface(TypeNames.IOperationResultDataFactory)
.SetReturnType(TypeNames.Object)
.AddParameter(_dataInfo, b => b.SetType(TypeNames.IOperationResultDataInfo))
.AddParameter(
_snapshot,
b => b.SetType(TypeNames.IEntityStoreSnapshot.MakeNullable()))
.AddCode(
MethodCallBuilder
.New()
.SetReturn()
.SetMethodName("Create")
.AddArgument(_dataInfo)
.AddArgument(_snapshot));
classBuilder.Build(writer);
}
private void AddBuildDataMethod(
CSharpSyntaxGeneratorSettings settings,
InterfaceTypeDescriptor resultNamedType,
ClassBuilder classBuilder)
{
var concreteType =
CreateResultInfoName(
resultNamedType.ImplementedBy.First().RuntimeType.Name);
MethodBuilder buildDataMethod = classBuilder
.AddMethod()
.SetPrivate()
.SetName("BuildData")
.SetReturnType($"({resultNamedType.RuntimeType.Name}, {concreteType})")
.AddParameter(_obj, x => x.SetType(TypeNames.JsonElement));
if (settings.IsStoreEnabled())
{
buildDataMethod.AddCode(
AssignmentBuilder
.New()
.SetLefthandSide($"var {_entityIds}")
.SetRighthandSide(MethodCallBuilder
.Inline()
.SetNew()
.SetMethodName(TypeNames.HashSet)
.AddGeneric(TypeNames.EntityId)))
.AddCode(
AssignmentBuilder
.New()
.SetLefthandSide($"{TypeNames.IEntityStoreSnapshot} {_snapshot}")
.SetRighthandSide("default!"));
}
buildDataMethod.AddEmptyLine();
CodeBlockBuilder storeUpdateBody = CodeBlockBuilder.New();
if (settings.IsStoreEnabled())
{
foreach (PropertyDescriptor property in
resultNamedType.Properties.Where(prop => prop.Type.IsOrContainsEntity()))
{
var variableName = $"{GetParameterName(property.Name)}Id";
buildDataMethod
.AddCode(AssignmentBuilder
.New()
.SetLefthandSide(CodeBlockBuilder
.New()
.AddCode(property.Type.ToStateTypeReference())
.AddCode(variableName))
.SetRighthandSide("default!"));
storeUpdateBody
.AddCode(AssignmentBuilder
.New()
.SetLefthandSide(variableName)
.SetRighthandSide(BuildUpdateMethodCall(property)));
}
storeUpdateBody
.AddEmptyLine()
.AddCode(AssignmentBuilder
.New()
.SetLefthandSide(_snapshot)
.SetRighthandSide($"{_session}.CurrentSnapshot"));
buildDataMethod
.AddCode(MethodCallBuilder
.New()
.SetMethodName(_entityStore, "Update")
.AddArgument(LambdaBuilder
.New()
.AddArgument(_session)
.SetBlock(true)
.SetCode(storeUpdateBody)));
}
buildDataMethod
.AddEmptyLine()
.AddCode(
AssignmentBuilder
.New()
.SetLefthandSide($"var {_resultInfo}")
.SetRighthandSide(
CreateResultInfoMethodCall(settings, resultNamedType, concreteType)))
.AddEmptyLine()
.AddCode(
TupleBuilder
.Inline()
.SetDetermineStatement(true)
.SetReturn()
.AddMember(MethodCallBuilder
.Inline()
.SetMethodName(_resultDataFactory, "Create")
.AddArgument(_resultInfo))
.AddMember(_resultInfo));
}
protected override void Generate(ITypeDescriptor typeDescriptor,
CSharpSyntaxGeneratorSettings settings,
CodeWriter writer,
out string fileName,
out string?path,
out string ns)
{
// Setup class
ComplexTypeDescriptor descriptor =
typeDescriptor as ComplexTypeDescriptor ??
throw new InvalidOperationException(
"A result entity mapper can only be generated for complex types");
fileName = descriptor.ExtractMapperName();
path = State;
ns = CreateStateNamespace(descriptor.RuntimeType.NamespaceWithoutGlobal);
ClassBuilder classBuilder = ClassBuilder
.New()
.AddImplements(
TypeNames.IEntityMapper
.WithGeneric(
descriptor.ExtractType().ToString(),
descriptor.RuntimeType.Name))
.SetName(fileName);
ConstructorBuilder constructorBuilder = ConstructorBuilder
.New()
.SetTypeName(descriptor.Name);
AddConstructorAssignedField(
TypeNames.IEntityStore,
_entityStore,
entityStore,
classBuilder,
constructorBuilder);
// Define map method
MethodBuilder mapMethod = MethodBuilder
.New()
.SetName(_map)
.SetAccessModifier(AccessModifier.Public)
.SetReturnType(descriptor.RuntimeType.Name)
.AddParameter(
ParameterBuilder
.New()
.SetType(
descriptor.Kind == TypeKind.Entity
? CreateEntityType(
descriptor.Name,
descriptor.RuntimeType.NamespaceWithoutGlobal)
.ToString()
: descriptor.Name)
.SetName(_entity))
.AddParameter(
_snapshot,
b => b.SetDefault("null")
.SetType(TypeNames.IEntityStoreSnapshot.MakeNullable()));
mapMethod
.AddCode(IfBuilder
.New()
.SetCondition($"{_snapshot} is null")
.AddCode(AssignmentBuilder
.New()
.SetLefthandSide(_snapshot)
.SetRighthandSide($"{_entityStore}.CurrentSnapshot")))
.AddEmptyLine();
MethodCallBuilder constructorCall =
MethodCallBuilder
.New()
.SetReturn()
.SetNew()
.SetMethodName(descriptor.RuntimeType.Name);
if (typeDescriptor is ComplexTypeDescriptor complexTypeDescriptor)
{
foreach (PropertyDescriptor property in complexTypeDescriptor.Properties)
{
constructorCall.AddArgument(BuildMapMethodCall(settings, _entity, property));
}
}
mapMethod.AddCode(constructorCall);
if (constructorBuilder.HasParameters())
{
classBuilder.AddConstructor(constructorBuilder);
}
classBuilder.AddMethod(mapMethod);
AddRequiredMapMethods(
settings,
_entity,
descriptor,
classBuilder,
constructorBuilder,
new HashSet <string>());
classBuilder.Build(writer);
}
private void AddEntityOrUnionDataHandler(
CSharpSyntaxGeneratorSettings settings,
ClassBuilder classBuilder,
ConstructorBuilder constructorBuilder,
MethodBuilder method,
ComplexTypeDescriptor complexTypeDescriptor,
HashSet <string> processed,
bool isNonNullable)
{
method
.AddParameter(_dataParameterName)
.SetType(TypeNames.EntityIdOrData.MakeNullable(!isNonNullable))
.SetName(_dataParameterName);
method
.AddParameter(_snapshot)
.SetType(TypeNames.IEntityStoreSnapshot)
.SetName(_snapshot);
if (!isNonNullable)
{
method.AddCode(EnsureProperNullability(_dataParameterName, isNonNullable));
}
var dataHandlerMethodName =
MapMethodNameFromTypeName(complexTypeDescriptor) + "Entity";
MethodBuilder complexDataHandler = MethodBuilder
.New()
.SetReturnType(
complexTypeDescriptor.RuntimeType.ToString().MakeNullable(!isNonNullable))
.SetName(dataHandlerMethodName);
AddComplexDataHandler(settings,
classBuilder,
constructorBuilder,
complexDataHandler,
complexTypeDescriptor,
processed,
isNonNullable);
classBuilder.AddMethod(complexDataHandler);
var entityDataHandlerMethodName =
MapMethodNameFromTypeName(complexTypeDescriptor) + "Data";
MethodBuilder entityDataHandler = MethodBuilder
.New()
.SetReturnType(
complexTypeDescriptor.RuntimeType.ToString().MakeNullable(!isNonNullable))
.SetName(entityDataHandlerMethodName);
AddEntityHandler(
classBuilder,
constructorBuilder,
entityDataHandler,
complexTypeDescriptor,
processed,
isNonNullable);
classBuilder.AddMethod(entityDataHandler);
method.AddEmptyLine();
var parameterName = isNonNullable ? _dataParameterName : $"{_dataParameterName}.Value";
IfBuilder ifBuilder = IfBuilder
.New()
.SetCondition($"{parameterName}.EntityId is {{ }} id")
.AddCode(MethodCallBuilder
.New()
.SetReturn()
.SetMethodName(entityDataHandlerMethodName)
.AddArgument("id")
.AddArgument(_snapshot))
.AddIfElse(IfBuilder
.New()
.SetCondition(
$"{parameterName}.Data is {complexTypeDescriptor.ParentRuntimeType!} d")
.AddCode(MethodCallBuilder
.New()
.SetReturn()
.SetMethodName(dataHandlerMethodName)
.AddArgument("d")
.AddArgument(_snapshot)))
.AddElse(ExceptionBuilder.New(TypeNames.ArgumentOutOfRangeException));
method.AddCode(ifBuilder);
AddRequiredMapMethods(
settings,
_dataParameterName,
complexTypeDescriptor,
classBuilder,
constructorBuilder,
processed);
}