private string FormatInternal(Type type, Func <TypeSpec, TypeSpec> rewriter = null) { string runtimeType = null; foreach (var converter in _converters) { if (converter.TryFormat(type, out var value)) { runtimeType = value; break; } } if (string.IsNullOrWhiteSpace(runtimeType)) { runtimeType = _defaultFormatter.Format(type); } var runtimeTypeSpec = RuntimeTypeNameParser.Parse(runtimeType); var displayTypeSpec = RuntimeTypeNameRewriter.Rewrite(runtimeTypeSpec, _convertToDisplayName); if (rewriter is object) { displayTypeSpec = rewriter(displayTypeSpec); } var formatted = displayTypeSpec.Format(); return(formatted); }
/// <summary> /// Returns the type arguments for the provided constructed generic type string. /// </summary> public static Type[] GetArguments(this TypeConverter formatter, string constructed) { var str = constructed; var index = str.IndexOf(StartArgument); if (index <= 0) { return(Array.Empty <Type>()); } var safeString = "safer" + str.Substring(str.IndexOf(GenericTypeIndicator)); var parsed = RuntimeTypeNameParser.Parse(safeString); if (!(parsed is ConstructedGenericTypeSpec spec)) { throw new InvalidOperationException($"Unable to correctly parse grain type {str}"); } var result = new Type[spec.Arguments.Length]; for (var i = 0; i < result.Length; i++) { var arg = spec.Arguments[i]; var formattedArg = arg.Format(); result[i] = formatter.Parse(formattedArg); if (result[i] is null) { throw new InvalidOperationException($"Unable to parse argument \"{formattedArg}\" as a type for grain type \"{str}\""); } } return(result); }
/// <summary> /// Returns the constructed form of the provided generic type. /// </summary> public static string GetConstructed(this TypeConverter formatter, string unconstructed, params Type[] typeArguments) { var typeString = unconstructed; var indicatorIndex = typeString.IndexOf(GenericTypeIndicator); var argumentsIndex = typeString.IndexOf(StartArgument, indicatorIndex); if (argumentsIndex >= 0) { throw new InvalidOperationException("Cannot construct an already-constructed type"); } var arityString = typeString.Substring(indicatorIndex + 1); var arity = int.Parse(arityString); if (typeArguments.Length != arity) { throw new InvalidOperationException($"Insufficient number of type arguments, {typeArguments.Length}, provided while constructing type \"{unconstructed}\" of arity {arity}"); } var typeSpecs = new TypeSpec[typeArguments.Length]; for (var i = 0; i < typeArguments.Length; i++) { typeSpecs[i] = RuntimeTypeNameParser.Parse(formatter.Format(typeArguments[i])); } var constructed = new ConstructedGenericTypeSpec(new NamedTypeSpec(null, typeString, typeArguments.Length), typeSpecs).Format(); return(constructed); }
/// <summary> /// Returns the constructed form of the provided generic type. /// </summary> public static IdSpan GetConstructed(this TypeConverter formatter, IdSpan unconstructed, params Type[] typeArguments) { var typeString = unconstructed.AsSpan(); var indicatorIndex = typeString.IndexOf((byte)GenericTypeIndicator); var arityString = typeString.Slice(indicatorIndex + 1); if (indicatorIndex < 0 || arityString.IndexOf((byte)StartArgument) >= 0) { throw new InvalidOperationException("Cannot construct an already-constructed type"); } if (!Utf8Parser.TryParse(arityString, out int arity, out var len) || len < arityString.Length || typeArguments.Length != arity) { throw new InvalidOperationException($"Insufficient number of type arguments, {typeArguments.Length}, provided while constructing type \"{unconstructed}\""); } var typeSpecs = new TypeSpec[typeArguments.Length]; for (var i = 0; i < typeArguments.Length; i++) { typeSpecs[i] = RuntimeTypeNameParser.Parse(formatter.Format(typeArguments[i])); } var constructed = new ConstructedGenericTypeSpec(new NamedTypeSpec(null, unconstructed.ToStringUtf8(), typeArguments.Length), typeSpecs).Format(); return(IdSpan.Create(constructed)); }
public void ParsedTypeNamesAreIdenticalToFormattedNames() { foreach (var type in types) { var formatted = RuntimeTypeNameFormatter.Format(type); var parsed = RuntimeTypeNameParser.Parse(formatted); this.output.WriteLine($"Type.FullName: {type.FullName}"); this.output.WriteLine($"Formatted : {formatted}"); this.output.WriteLine($"Parsed : {parsed}"); Assert.Equal(formatted, parsed.Format()); var reparsed = RuntimeTypeNameParser.Parse(parsed.Format()); this.output.WriteLine($"Reparsed : {reparsed}"); Assert.Equal(formatted, reparsed.Format()); } }
private Type ParseInternal(string formatted) { var parsed = RuntimeTypeNameParser.Parse(formatted); var runtimeTypeSpec = RuntimeTypeNameRewriter.Rewrite(parsed, _convertFromDisplayName); var runtimeType = runtimeTypeSpec.Format(); foreach (var converter in _converters) { if (converter.TryParse(runtimeType, out var result)) { return(result); } } return(_defaultFormatter.Parse(runtimeType)); }