protected override void FormatType(string typeName, TypeAttachmentMetadata metadata, StringBuilder builder)
{
builder.Append($@"
readonly partial struct {typeName} : IEquatable<{typeName}>
{{
private readonly string _backingId;
/// <summary>
/// Defines an empty value for <see cref=""{typeName}"" />.
/// </summary>
public static {typeName} Empty {{ get; }} = new {typeName}(string.Empty);
/// <summary>
/// Creates a <see cref=""{typeName}"" /> from a string.
/// </summary>
public static {typeName} FromString(string content) => new {typeName}(content);
private {typeName}(string content)
{{
_backingId = content;
}}
/// <inheritdoc />
public override int GetHashCode() => _backingId.GetHashCode();
/// <inheritdoc />
public override string ToString() => _backingId;
/// <inheritdoc />
public override bool Equals(object obj)
{{
if (obj is {typeName} otherId)
{{
return Equals(otherId);
}}
return false;
}}
/// <inheritdoc />
public bool Equals({typeName} other) => _backingId.Equals(other._backingId, StringComparison.Ordinal);
/// <inheritdoc />
public static bool operator ==({typeName} left, {typeName} right)
{{
return left.Equals(right);
}}
/// <inheritdoc />
public static bool operator !=({typeName} left, {typeName} right)
{{
return !(left == right);
}}
}}
");
}
public void CreateTypeExtension(GeneratorExecutionContext context, INamedTypeSymbol extendingTypeSymbol, GenerationOptions options)
{
var metadata = new TypeAttachmentMetadata();
// We're going to need System regardless.
metadata.AddNamespace("System");
foreach (var converter in _converters)
{
if (converter.ShouldGenerate(context, extendingTypeSymbol, options))
{
converter.AddSource(context, extendingTypeSymbol, metadata, options);
}
}
var code = WrapSourceOutput(extendingTypeSymbol, FormatType(extendingTypeSymbol, metadata));
context.AddSource(GetGeneratedFileName(extendingTypeSymbol, "Generated"), code);
}
private string FormatType(INamedTypeSymbol typeSymbol, TypeAttachmentMetadata metadata)
{
var builder = new StringBuilder();
var name = typeSymbol.Name;
foreach (var usingStatement in metadata.AdditionalNamespaces)
{
builder.Append($@"
using {usingStatement};");
}
foreach (var attr in metadata.AttributeLiterals)
{
builder.Append($@"
[{attr}]");
}
FormatType(name, metadata, builder);
return(builder.ToString());
}
protected override void FormatType(string typeName, TypeAttachmentMetadata metadata, StringBuilder builder)
{
builder.Append($@"
readonly partial struct {typeName} : IEquatable<{typeName}>
{{
private readonly int _backingId;
/// <summary>
/// Get the default zero state of {typeName}.
/// </summary>
public static {typeName} Zero {{ get; }} = new {typeName}(0);
/// <summary>
/// Create a new {typeName} from a 32-bit integer.
/// </summary>
public static {typeName} FromInt(int number) => new {typeName}(number);
/// <summary>
/// Try to parse a {typeName} from its string representation.
/// </summary>
public static bool TryParse(string text, out {typeName} id)
{{
if (int.TryParse(text, out var intId))
{{
id = new {typeName}(intId);
return true;
}}
id = Zero;
return false;
}}
private {typeName}(int number)
{{
_backingId = number;
}}
/// <summary>
/// Get the int value backing this value.
/// </summary>
public int ToInt() => _backingId;
/// <inheritdoc />
public override int GetHashCode() => _backingId.GetHashCode();
/// <inheritdoc />
public override string ToString() => _backingId.ToString();
/// <inheritdoc />
public override bool Equals(object obj)
{{
if (obj is {typeName} otherId)
{{
return Equals(otherId);
}}
return false;
}}
/// <inheritdoc />
public bool Equals({typeName} other) => _backingId.Equals(other._backingId);
/// <inheritdoc />
public static bool operator ==({typeName} left, {typeName} right)
{{
return left.Equals(right);
}}
/// <inheritdoc />
public static bool operator !=({typeName} left, {typeName} right)
{{
return !(left == right);
}}
}}
");
}
public void AddSource(GeneratorExecutionContext context, INamedTypeSymbol generatingForType, TypeAttachmentMetadata metadata, GenerationOptions options)
{
var code = WrapSourceOutput(generatingForType, CreateSource(generatingForType.Name));
context.AddSource(GetGeneratedFileName(generatingForType, "NsJsonConverter"), code);
metadata.AddAttributeLiteral($"Newtonsoft.Json.JsonConverter(typeof({generatingForType.Name}.{generatingForType.Name}NsJsonConverter))");
}
public void AddSource(GeneratorExecutionContext context, INamedTypeSymbol generatingForType, TypeAttachmentMetadata metadata, GenerationOptions options)
{
var code = WrapSourceOutput(generatingForType, CreateSource(generatingForType.Name));
context.AddSource(GetGeneratedFileName(generatingForType, "BsonSerializer"), code);
metadata.AddAttributeLiteral($"BsonSerializer(typeof({generatingForType.Name}.{generatingForType.Name}BsonSerialiser))");
metadata.AddNamespace("MongoDB.Bson.Serialization.Attributes");
}
protected override void FormatType(string typeName, TypeAttachmentMetadata metadata, StringBuilder builder)
{
builder.Append($@"
readonly partial struct {typeName} : IEquatable<{typeName}>
{{
private readonly Guid _backingId;
/// <summary>
/// Get the default empty state of {typeName}.
/// </summary>
public static {typeName} Empty {{ get; }} = new {typeName}(Guid.Empty);
/// <summary>
/// Creates a new {typeName} from a standard Guid.
/// </summary>
public static {typeName} FromGuid(Guid guid) => new {typeName}(guid);
/// <summary>
/// Create a new ID with a random unique value.
/// </summary>
public static {typeName} New() => new {typeName}(Guid.NewGuid());
/// <summary>
/// Attempt to parse a {typeName} from a string.
/// </summary>
public static bool TryParse(string text, out {typeName} id)
{{
if (Guid.TryParseExact(text, ""N"", out var guidId))
{{
id = new {typeName}(guidId);
return true;
}}
id = Empty;
return false;
}}
private {typeName}(Guid guid)
{{
_backingId = guid;
}}
/// <summary>
/// Get the underlying guid from this {typeName}.
/// </summary>
public Guid ToGuid() => _backingId;
/// <inheritdoc />
public override int GetHashCode() => _backingId.GetHashCode();
/// <inheritdoc />
public override string ToString() => _backingId.ToString(""N"");
/// <inheritdoc />
public override bool Equals(object obj)
{{
if (obj is {typeName} otherId)
{{
return Equals(otherId);
}}
return false;
}}
/// <inheritdoc />
public bool Equals({typeName} other) => _backingId.Equals(other._backingId);
/// <inheritdoc />
public static bool operator ==({typeName} left, {typeName} right)
{{
return left.Equals(right);
}}
/// <inheritdoc />
public static bool operator !=({typeName} left, {typeName} right)
{{
return !(left == right);
}}
}}
");
}
protected abstract void FormatType(string typeName, TypeAttachmentMetadata metadata, StringBuilder builder);
public void AddSource(GeneratorExecutionContext context, INamedTypeSymbol generatingForType, TypeAttachmentMetadata metadata, GenerationOptions options)
{
var code = WrapSourceOutput(generatingForType, CreateSource(generatingForType));
context.AddSource(GetGeneratedFileName(generatingForType, "TypeConverter"), code);
metadata.AddAttributeLiteral($"TypeConverter(typeof({generatingForType.Name}.{generatingForType.Name}TypeConverter))");
metadata.AddNamespace("System.ComponentModel");
}
