public string GetRead(string target, ITypeSymbol targetType, IValueSerializationGeneratorContext context) { if (_enums.IsResolvable(targetType)) { var value = VariableHelper.GetName(targetType); if (targetType.IsNullable()) { return($@" string {value}; {context.Read<string>(value)} if (!string.IsNullOrEmpty({value})) {{ {target} = {Enums.GetConverterName(targetType)}.FromString({value}); }}" ); } else { return($@" string {value}; {context.Read<string>(value)} {target} = {Enums.GetConverterName(targetType)}.FromString({value});" ); } } return(null); }
private string GetRead(string target, ITypeSymbol targetType, string formatValue, string stylesValue, IValueSerializationGeneratorContext context) { if (_supportedTypes.Contains(targetType.GetDeclarationGenericFullName())) { var value = VariableHelper.GetName <string>(); return($@" string {value}; {context.Read<string>(value)} {GetParseMethod(value, target, targetType, formatValue, stylesValue, context)}" ); } else if (targetType.IsNullable(out targetType) && _supportedTypes.Contains(targetType.GetDeclarationGenericFullName())) { var value = VariableHelper.GetName <string>(); return($@" string {value}; {context.Read<string>(value)} if (!string.IsNullOrWhiteSpace({value})) {{ {GetParseMethod(value, target, targetType, formatValue, stylesValue, context)} }}" ); } else { return(null); } }
public string GetWrite(string sourceName, string source, IPropertySymbol sourceProperty, IValueSerializationGeneratorContext context) { if (sourceProperty.FindAttributeByShortName("MicrosoftDateTimeFormatAttribute") != null) { var type = sourceProperty.Type; if (_supportedTypes.Contains(type.GetDeclarationGenericFullName())) { return(context.Write <string>(sourceName, $"GeneratedSerializers.MicrosoftDateTimeHelper.ToString({source}.{sourceProperty.Name})")); } else if (type.IsNullable(out type) && _supportedTypes.Contains(type.GetDeclarationGenericFullName())) { var value = VariableHelper.GetName(sourceProperty.Type); return($@" var {value} = {source}.{sourceProperty.Name}; if ({value}.HasValue) {{ {context.Write<string>(sourceName, $"GeneratedSerializers.MicrosoftDateTimeHelper.ToString({value}.Value)")} }}" ); } else { return($"\r\n #error {_nonSupportedTypeError}"); } } else { return(null); } }
private string GetWrite(string sourceName, string sourceCode, ITypeSymbol sourceType, string format, IValueSerializationGeneratorContext context) { var formatParameter = format.IsNullOrWhiteSpace() ? string.Empty : $"\"{format}\", "; var cultureParameter = sourceType.GetDeclarationGenericFullName().Contains("TimeSpan") && formatParameter.IsNullOrEmpty() ? string.Empty : "System.Globalization.CultureInfo.InvariantCulture"; if (_supportedTypes.Contains(sourceType.GetDeclarationGenericFullName())) { return(context.Write <string>(sourceName, $"{sourceCode}.ToString({formatParameter} {cultureParameter})")); } else if (sourceType.IsNullable(out sourceType) && _supportedTypes.Contains(sourceType.GetDeclarationGenericFullName())) { var value = VariableHelper.GetName(sourceType); return($@" {sourceType.GetDeclarationGenericFullName()}? {value} = {sourceCode}; if ({value}.HasValue) {{ {context.Write<string>(sourceName, $"{value}.Value.ToString({formatParameter} {cultureParameter})")} }}" ); } return(null); }
public string GetRead(string target, IPropertySymbol targetProperty, IValueSerializationGeneratorContext context) { if (targetProperty.FindAttributeByShortName("MicrosoftDateTimeFormatAttribute") != null) { var value = VariableHelper.GetName("dateTime"); var targetName = $"{target}.{targetProperty.Name}"; var type = targetProperty.Type; if (_supportedTypes.Contains(type.GetDeclarationGenericFullName())) { return($@" string {value}; {context.Read<string>(value)} {GetParseMethod(value, targetName, type)}" ); } else if (type.IsNullable(out type) && _supportedTypes.Contains(type.GetDeclarationGenericFullName())) { return($@" string {value}; {context.Read<string>(value)} if (!string.IsNullOrWhiteSpace({value})) {{ {GetParseMethod(value, targetName, type)} }}" ); } else { return($"\r\n #error {_nonSupportedTypeError}"); } } else { return(null); } }
public static string WriteDictionary(string sourceName, string sourceCode, ITypeSymbol itemType, IValueSerializationGeneratorContext context) { var itemTypeName = $"System.Collections.Generic.KeyValuePair<string, {itemType.GetDeclarationGenericFullName()}>"; var value = VariableHelper.GetName(itemType); var enumerator = VariableHelper.GetName("enumerator"); if (sourceName.IsNullOrWhiteSpace()) { return($@" var {value} = {sourceCode}; if ({value} == null) {{ {context.Write.Writer}.WriteNullValue(); }} else {{ {context.Write.Writer}.Write('{{'); var {enumerator} = {value}.GetEnumerator(); if ({enumerator}.MoveNext()) {{ {context.Write.Writer}.WritePropertyName((({itemTypeName}){enumerator}.Current).Key); {context.GetWrite(null, $"(({itemTypeName}){enumerator}.Current).Value", itemType)}; }} while ({enumerator}.MoveNext()) {{ {context.Write.Writer}.Write(','); {context.Write.Writer}.WritePropertyName((({itemTypeName}){enumerator}.Current).Key); {context.GetWrite(null, $"(({itemTypeName}){enumerator}.Current).Value", itemType)}; }} {context.Write.Writer}.Write('}}'); }}" ); } else { return($@" var {value} = {sourceCode}; if ({value} != null) {{ {context.Write.Object}.WritePropertyName(""{sourceName}""); {context.Write.Writer}.Write('{{'); var {enumerator} = {value}.GetEnumerator(); if ({enumerator}.MoveNext()) {{ {context.Write.Writer}.WritePropertyName((({itemTypeName}){enumerator}.Current).Key); {context.GetWrite(null, $"(({itemTypeName}){enumerator}.Current).Value", itemType)}; }} while ({enumerator}.MoveNext()) {{ {context.Write.Writer}.Write(','); {context.Write.Writer}.WritePropertyName((({itemTypeName}){enumerator}.Current).Key); {context.GetWrite(null, $"(({itemTypeName}){enumerator}.Current).Value", itemType)}; }} {context.Write.Writer}.Write('}}'); }}" ); } }
public override string Read(string target, bool isNullable, IValueSerializationGeneratorContext context) { var guid = VariableHelper.GetName("guid"); return($@" string {guid}; {context.Read<string>(guid)} if (!string.IsNullOrWhiteSpace({guid})) {{ {target} = Guid.Parse({guid}); }}" ); }
public override string Read(string target, bool isNullable, IValueSerializationGeneratorContext context) { var uri = VariableHelper.GetName("uri"); return($@" string {uri}; {context.Read<string>(uri)} if (!string.IsNullOrEmpty({uri})) {{ {target} = new Uri({uri}, UriKind.RelativeOrAbsolute); }}" ); }
private string GetParseMethod(string value, string target, ITypeSymbol targetType, string formatValue, string stylesValue, IValueSerializationGeneratorContext context) { var type = targetType.GetDeclarationGenericFullName(); string exact, format, styles; if (formatValue.IsNullOrWhiteSpace()) { exact = string.Empty; format = string.Empty; } else { exact = "Exact"; format = $", \"{formatValue}\""; } if (type == _timeSpan) { // No DateTimeStyle for TimeSpan parsing styles = string.Empty; } else if (stylesValue == null) { //https://github.com/dotnet/coreclr/blob/master/src/mscorlib/src/System/DateTime.cs //as default value in .net Parse() method styles = ", System.Globalization.DateTimeStyles.None"; } else { styles = $", (System.Globalization.DateTimeStyles){stylesValue}"; } if (_useTryParseOrDefault) { var result = VariableHelper.GetName(targetType); return($@" {type} {result}; {type}.TryParse{exact}({value} {format} {_invariantCulture} {styles}, out {result}); {target} = {result};" ); } else { return($@"{target} = {type}.Parse{exact}({value} {format} {_invariantCulture} {styles});"); } }
private string GetParseMethod(string value, string target, ITypeSymbol type) { if (_useTryParseOrDefault) { var result = VariableHelper.GetName(type); return($@" {type.GetDeclarationGenericFullName()} {result}; if (GeneratedSerializers.MicrosoftDateTimeHelper.TryParse{type.Name}({value}, out {result})) {{ {target} = {result}; }}" ); } else { return($"{target} = GeneratedSerializers.MicrosoftDateTimeHelper.Parse{type.Name}({value});"); } }
public string GetWrite(string sourceName, string source, IPropertySymbol sourceProperty, IValueSerializationGeneratorContext context) { var serializerType = FindCustomSerializerType(sourceProperty); if (serializerType != null) { var value = VariableHelper.GetName(sourceProperty.Type); return($@" var {value} = {source}.{sourceProperty.Name}; if ({value} != null) {{ {context.Write.Object}.WritePropertyName(""{sourceName}""); {StaticJsonCustomDeserializerGenerator.GetClassName(serializerType)}.Instance.Serialize({context.Write.Writer}, {value}); }}" ); } return(null); }
public string GetWrite(string sourceName, string sourceCode, ITypeSymbol sourceType, IValueSerializationGeneratorContext context) { if (_serializer.IsResolvable(sourceType)) { var value = VariableHelper.GetName(sourceType); string result; if (sourceName.IsNullOrWhiteSpace()) { // We are writing an item of a collection or something like that. // We cannot ignore null values, instead we must write the "null" keyword. result = $@"var {value} = {sourceCode}; if ({value} == null) {{ {context.Write.Writer}.WriteNullValue(); }} else {{ {_serializer.GetResolve(sourceType)}.Serialize({context.Write.Writer}, {value}); }}"; } else { result = $@"var {value} = {sourceCode}; if ({value} != null) {{ {context.Write.Object}.WritePropertyName(""{sourceName}""); {_serializer.GetResolve(sourceType)}.Serialize({context.Write.Writer}, {value}); }}"; } return(result); } return(null); }
public string ReadCollection(string target, ITypeSymbol collectionType, ITypeSymbol itemType, IValueSerializationGeneratorContext context) { var itemTypeName = itemType.GetDeclarationGenericFullName(); var implementation = _collectionResolver.FindImplementation(collectionType); var collection = VariableHelper.GetName(implementation.Implementation); var item = VariableHelper.GetName(itemType); var collectionKind = VariableHelper.GetName("collectionType"); return($@" var {collectionKind} = {context.Read.Reader}.OpenCollection({context.Read.FirstChar}, out {context.Read.OverChar}); if({collectionKind} == JsonReaderExtension.CollectionType.SingleValue) {{ {implementation.CreateInstance(collection)} var {item} = default({itemTypeName}); {context.UsingOverAsFirstChar(overHasValue: true).GetRead(item, itemType)} {implementation.AddItemToInstance(collection, item)} {implementation.InstanceToContract(collection, target)} }} else if({collectionKind} == JsonReaderExtension.CollectionType.Collection) {{ // If collection type is Collection, then the overChar returned by OpenCollection is null. {implementation.CreateInstance(collection)} var {item} = default({itemTypeName}); while ({context.Read.Reader}.MoveToNextCollectionItem(ref {context.Read.OverChar})) {{ {context.UsingOverAsFirstChar().GetRead(item, itemType)} {implementation.AddItemToInstance(collection, item)} }} {implementation.InstanceToContract(collection, target)} }}" ); }
public string ReadDictionary(string target, ITypeSymbol dictionaryType, ITypeSymbol itemType, IValueSerializationGeneratorContext context) { var implementation = _collectionResolver.FindImplementation(dictionaryType); var dictionary = VariableHelper.GetName(implementation.Implementation); var key = VariableHelper.GetName <string>(); // Note: the {context.Read.OverChar} is always null after the MoveToNextProperty so we don't need to propagate it as FirstChar // This means that we don't need to specify the .UsingOverAsFirstChar() on the context for context.GetRead($"{dictionary}[{key}]", itemType). return($@" if ({context.Read.Reader}.OpenObject({context.Read.FirstChar}, out {context.Read.OverChar})) {{ {implementation.CreateInstance(dictionary)} var {key} = default(string); while ({context.Read.Reader}.MoveToNextProperty(ref {context.Read.OverChar}, ref {key}, toUpper: false)) {{ {context.IgnoringCurrentFirstChar().GetRead($"{dictionary}[{key}]", itemType)} }} {implementation.InstanceToContract(dictionary, target)} }}" ); }
public string GetWrite(string sourceName, string sourceCode, ITypeSymbol sourceType, IValueSerializationGeneratorContext context) { string mappedType; if (sourceName.HasValueTrimmed()) { // We are writing a property value, if the source is null, we can just ignore the whole property. if (_stringType.Equals(sourceType.GetDeclarationGenericFullName(), StringComparison.OrdinalIgnoreCase)) { var value = VariableHelper.GetName(sourceType); return($@" var {value} = {sourceCode}; if ({value} != null) {{ {context.Write.Object}.WritePropertyName(""{sourceName}""); {context.Write.Writer}.WriteStringValue({value}); }}" ); } else if (_supportedTypes.TryGetValue(sourceType.GetDeclarationGenericFullName(), out mappedType)) { return($@" {context.Write.Object}.WritePropertyName(""{sourceName}""); {context.Write.Writer}.Write(({mappedType}){sourceCode});" ); } else if (sourceType.IsNullable(out sourceType) && _supportedTypes.TryGetValue(sourceType.GetDeclarationGenericFullName(), out mappedType)) { var value = VariableHelper.GetName(sourceType); return($@" var {value} = {sourceCode}; if ({value}.HasValue) {{ {context.Write.Object}.WritePropertyName(""{sourceName}""); {context.Write.Writer}.Write(({mappedType}){value}.Value); }}" ); } } else { // We are writing an item of a collection or something like that. // We cannot ignore null values, instead we must write the "null" keyword. if (_stringType.Equals(sourceType.GetDeclarationGenericFullName(), StringComparison.OrdinalIgnoreCase)) { // WriteStringValue handles the "null" itself. return($@"{context.Write.Writer}.WriteStringValue({sourceCode});"); } else if (_supportedTypes.TryGetValue(sourceType.GetDeclarationGenericFullName(), out mappedType)) { return($@"{context.Write.Writer}.Write(({mappedType}){sourceCode});"); } else if (sourceType.IsNullable(out sourceType) && _supportedTypes.TryGetValue(sourceType.GetDeclarationGenericFullName(), out mappedType)) { var value = VariableHelper.GetName(sourceType); return($@" var {value} = {sourceCode}; if ({value}.HasValue) {{ {context.Write.Writer}.Write(({mappedType}){value}.Value); }} else {{ {context.Write.Writer}.WriteNullValue(); }}" ); } } return(null); }