public void WriteClient(CodeWriter writer, Client client, Configuration configuration)
{
var cs = client.Type;
var @namespace = cs.Namespace;
using (writer.Namespace(@namespace))
{
writer.WriteXmlDocumentationSummary(client.Description);
using (writer.Scope($"{client.Declaration.Accessibility} partial class {cs.Name}"))
{
WriteClientFields(writer, client);
WriteClientCtors(writer, client);
foreach (var clientMethod in client.Methods)
{
WriteClientMethod(writer, clientMethod, true);
WriteClientMethod(writer, clientMethod, false);
}
foreach (var pagingMethod in client.PagingMethods)
{
WritePagingOperation(writer, pagingMethod, true);
WritePagingOperation(writer, pagingMethod, false);
}
foreach (var longRunningOperation in client.LongRunningOperationMethods)
{
WriteStartOperationOperation(writer, longRunningOperation, true);
WriteStartOperationOperation(writer, longRunningOperation, false);
}
}
}
}
private static void WriteConstructor(CodeWriter writer, ObjectType schema)
{
foreach (var constructor in schema.Constructors)
{
writer.WriteXmlDocumentationSummary($"Initializes a new instance of {schema.Declaration.Name}");
foreach (var parameter in constructor.Parameters)
{
writer.WriteXmlDocumentationParameter(parameter.Name, parameter.Description);
}
writer.Append($"{constructor.Declaration.Accessibility} {schema.Declaration.Name}(");
foreach (var parameter in constructor.Parameters)
{
writer.WriteParameter(parameter);
}
writer.RemoveTrailingComma();
writer.Append($")");
if (constructor.BaseConstructor?.Parameters.Length > 0)
{
writer.Append($": base(");
foreach (var baseConstructorParameter in constructor.BaseConstructor.Parameters)
{
writer.Append($"{baseConstructorParameter.Name:I}, ");
}
writer.RemoveTrailingComma();
writer.Append($")");
}
writer.Line();
using (writer.Scope())
{
writer.WriteParameterNullChecks(constructor.Parameters);
foreach (var initializer in constructor.Initializers)
{
writer.Append($"{initializer.Property.Declaration.Name} = ")
.WriteReferenceOrConstant(initializer.Value)
.WriteConversion(initializer.Value.Type, initializer.Property.Declaration.Type);
if (initializer.DefaultValue != null &&
!initializer.Value.Type.IsValueType)
{
writer.Append($"?? ").WriteReferenceOrConstant(initializer.DefaultValue.Value);
}
writer.Line($";");
}
}
writer.Line();
}
}
public static void WriteClientOptions(CodeWriter writer, BuildContext context)
{
var title = context.Configuration.LibraryName;
using (writer.Scope($"namespace {context.Configuration.Namespace}"))
{
writer.WriteXmlDocumentationSummary($"Client options for {title}.");
using (writer.Scope($"public class {title}ManagementClientOptions: {typeof(ClientOptions)}"))
{
}
}
}
private void WriteSealedChoiceSchema(CodeWriter writer, EnumType schema)
{
if (schema.Declaration.IsUserDefined)
{
return;
}
using (writer.Namespace(schema.Declaration.Namespace))
{
writer.WriteXmlDocumentationSummary(schema.Description);
using (writer.Scope($"public enum {schema.Declaration.Name}"))
{
foreach (EnumTypeValue value in schema.Values)
{
writer.WriteXmlDocumentationSummary(value.Description);
writer.Line($"{value.Declaration.Name},");
}
writer.RemoveTrailingComma();
}
}
}
private void WriteStartOperationOperation(CodeWriter writer, LongRunningOperationMethod lroMethod, bool async)
{
RestClientMethod originalMethod = lroMethod.StartMethod;
CSharpType returnType = async ? new CSharpType(typeof(Task <>), lroMethod.Operation.Type) : lroMethod.Operation.Type;
Parameter[] parameters = originalMethod.Parameters;
writer.WriteXmlDocumentationSummary(originalMethod.Description);
foreach (Parameter parameter in parameters)
{
writer.WriteXmlDocumentationParameter(parameter.Name, parameter.Description);
}
writer.WriteXmlDocumentationParameter("cancellationToken", "The cancellation token to use.");
string asyncText = async ? "async " : string.Empty;
writer.Append($"public virtual {asyncText}{returnType} {CreateStartOperationName(lroMethod.Name, async)}(");
foreach (Parameter parameter in parameters)
{
writer.WriteParameter(parameter);
}
writer.Line($"{typeof(CancellationToken)} cancellationToken = default)");
using (writer.Scope())
{
writer.WriteParameterNullChecks(parameters);
WriteDiagnosticScope(writer, lroMethod.Diagnostics, writer =>
{
string awaitText = async ? "await" : string.Empty;
string configureText = async ? ".ConfigureAwait(false)" : string.Empty;
writer.Append($"var originalResponse = {awaitText} RestClient.{CreateMethodName(originalMethod.Name, async)}(");
foreach (Parameter parameter in parameters)
{
writer.Append($"{parameter.Name}, ");
}
writer.Line($"cancellationToken){configureText};");
writer.Append($"return new {lroMethod.Operation.Type}({ClientDiagnosticsField}, {PipelineField}, RestClient.{CreateRequestMethodName(originalMethod.Name)}(");
foreach (Parameter parameter in parameters)
{
writer.Append($"{parameter.Name}, ");
}
writer.RemoveTrailingComma();
writer.Line($").Request, originalResponse);");
});
}
writer.Line();
}
private void WriteClientCtors(CodeWriter writer, Client client)
{
writer.WriteXmlDocumentationSummary($"Initializes a new instance of {client.Type.Name} for mocking.");
using (writer.Scope($"protected {client.Type.Name:D}()"))
{
}
writer.WriteXmlDocumentationSummary($"Initializes a new instance of {client.Type.Name}");
writer.WriteXmlDocumentationParameter(ClientDiagnosticsVariable, "The handler for diagnostic messaging in the client.");
writer.WriteXmlDocumentationParameter(PipelineVariable, "The HTTP pipeline for sending and receiving REST requests and responses.");
foreach (Parameter parameter in client.RestClient.Parameters)
{
writer.WriteXmlDocumentationParameter(parameter.Name, parameter.Description);
}
writer.Append($"internal {client.Type.Name:D}({typeof(ClientDiagnostics)} {ClientDiagnosticsVariable}, {typeof(HttpPipeline)} {PipelineVariable},");
foreach (Parameter parameter in client.RestClient.Parameters)
{
writer.WriteParameter(parameter);
}
writer.RemoveTrailingComma();
writer.Line($")");
using (writer.Scope())
{
writer.Append($"this.RestClient = new {client.RestClient.Type}({ClientDiagnosticsVariable}, {PipelineVariable}, ");
foreach (var parameter in client.RestClient.Parameters)
{
writer.Append($"{parameter.Name}, ");
}
writer.RemoveTrailingComma();
writer.Line($");");
writer.Line($"{ClientDiagnosticsField} = {ClientDiagnosticsVariable};");
writer.Line($"{PipelineField} = {PipelineVariable};");
}
writer.Line();
}
public void WriteClient(CodeWriter writer, RestClient restClient)
{
var cs = restClient.Type;
var @namespace = cs.Namespace;
using (writer.Namespace(@namespace))
{
writer.WriteXmlDocumentationSummary(restClient.Description);
using (writer.Scope($"{restClient.Declaration.Accessibility} partial class {cs.Name}"))
{
WriteClientFields(writer, restClient);
WriteClientCtor(writer, restClient, cs);
foreach (var method in restClient.Methods)
{
WriteRequestCreation(writer, method);
WriteOperation(writer, method, true);
WriteOperation(writer, method, false);
}
}
}
}
private void WriteClientCtor(CodeWriter writer, RestClient restClient, CSharpType cs)
{
writer.WriteXmlDocumentationSummary($"Initializes a new instance of {cs.Name}");
writer.WriteXmlDocumentationParameter(ClientDiagnosticsVariable, "The handler for diagnostic messaging in the client.");
writer.WriteXmlDocumentationParameter(PipelineVariable, "The HTTP pipeline for sending and receiving REST requests and responses.");
foreach (Parameter parameter in restClient.Parameters)
{
writer.WriteXmlDocumentationParameter(parameter.Name, parameter.Description);
}
if (restClient.Parameters.HasAnyNullCheck())
{
writer.WriteXmlDocumentationException(typeof(ArgumentNullException), "This occurs when one of the required arguments is null.");
}
writer.Append($"public {cs.Name:D}({typeof(ClientDiagnostics)} {ClientDiagnosticsVariable}, {typeof(HttpPipeline)} {PipelineVariable},");
foreach (Parameter clientParameter in restClient.Parameters)
{
writer.WriteParameter(clientParameter);
}
writer.RemoveTrailingComma();
writer.Line($")");
using (writer.Scope())
{
writer.WriteParameterNullChecks(restClient.Parameters);
foreach (Parameter clientParameter in restClient.Parameters)
{
writer.Line($"this.{clientParameter.Name} = {clientParameter.Name};");
}
writer.Line($"{ClientDiagnosticsField} = {ClientDiagnosticsVariable};");
writer.Line($"{PipelineField} = {PipelineVariable};");
}
writer.Line();
}
public static void WriteAggregateClient(CodeWriter writer, BuildContext context)
{
var title = context.Configuration.LibraryName;
using (writer.Scope($"namespace {context.Configuration.Namespace}"))
{
Dictionary <string, Parameter> allParameters = new Dictionary <string, Parameter>();
foreach (var parameter in context.Library.Clients.SelectMany(p => p.RestClient.Parameters))
{
if (ManagementClientWriterHelpers.IsApiVersionParameter(parameter))
{
continue;
}
allParameters[parameter.Name] = parameter;
}
writer.WriteXmlDocumentationSummary($"{title} service management client.");
using (writer.Scope($"public class {title}ManagementClient"))
{
writer.Line($"private readonly {typeof(ClientDiagnostics)} {ClientDiagnosticsField};");
writer.Line($"private readonly {typeof(HttpPipeline)} {PipelineField};");
foreach (var parameter in allParameters.Values)
{
writer.Line($"private readonly {parameter.Type} _{parameter.Name};");
}
writer.Line();
writer.WriteXmlDocumentationSummary($"Initializes a new instance of {title}ManagementClient for mocking.");
using (writer.Scope($"protected {title}ManagementClient()"))
{
}
writer.Line();
writer.WriteXmlDocumentationSummary($"Initializes a new instance of {title}ManagementClient");
foreach (Parameter parameter in allParameters.Values)
{
if (ManagementClientWriterHelpers.IsEndpointParameter(parameter))
{
continue;
}
writer.WriteXmlDocumentationParameter(parameter.Name, parameter.Description);
}
writer.WriteXmlDocumentationParameter(TokenCredentialVariable, "The OAuth token for making client requests.");
writer.WriteXmlDocumentationParameter(OptionsVariable, "The options for configuring the client.");
writer.Append($"public {title}ManagementClient(");
foreach (Parameter parameter in allParameters.Values)
{
if (ManagementClientWriterHelpers.IsEndpointParameter(parameter))
{
continue;
}
writer.WriteParameter(parameter);
}
writer.Append($"{typeof(TokenCredential)} {TokenCredentialVariable}, {title}ManagementClientOptions {OptionsVariable} = null) : this(");
foreach (Parameter parameter in allParameters.Values)
{
// Pass the default host
if (ManagementClientWriterHelpers.IsEndpointParameter(parameter))
{
writer.Append($"null, ");
continue;
}
writer.Append($"{parameter.Name},");
}
writer.Line($"{TokenCredentialVariable}, {OptionsVariable})");
using (writer.Scope())
{
}
writer.WriteXmlDocumentationSummary($"Initializes a new instance of {title}ManagementClient");
foreach (Parameter parameter in allParameters.Values)
{
writer.WriteXmlDocumentationParameter(parameter.Name, parameter.Description);
}
writer.WriteXmlDocumentationParameter(TokenCredentialVariable, "The OAuth token for making client requests.");
writer.WriteXmlDocumentationParameter(OptionsVariable, "The options for configuring the client.");
if (allParameters.Values.HasAnyNullCheck())
{
writer.WriteXmlDocumentationException(typeof(ArgumentNullException), "This occurs when one of the required arguments is null.");
}
writer.Append($"public {title}ManagementClient(");
foreach (Parameter parameter in allParameters.Values)
{
writer.WriteParameter(parameter, false);
}
writer.Append($"{typeof(TokenCredential)} {TokenCredentialVariable}, {title}ManagementClientOptions {OptionsVariable} = null)");
using (writer.Scope())
{
writer.WriteParameterNullChecks(allParameters.Values);
writer.Line($"{OptionsVariable} ??= new {title}ManagementClientOptions();");
writer.Line($"{ClientDiagnosticsField} = new {typeof(ClientDiagnostics)}({OptionsVariable});");
writer.Line($"{PipelineField} = {typeof(ManagementPipelineBuilder)}.Build({TokenCredentialVariable}, endpoint, {OptionsVariable});");
foreach (Parameter parameter in allParameters.Values)
{
writer.Line($"_{parameter.Name} = {parameter.Name};");
}
}
writer.Line();
foreach (var client in context.Library.Clients)
{
writer.WriteXmlDocumentationSummary($"Creates a new instance of {client.Type.Name}");
using (writer.Scope($"public virtual {client.Type} Get{client.Type.Name}()"))
{
writer.Append($"return new {client.Type}({ClientDiagnosticsField}, {PipelineField}, ");
foreach (var parameter in client.RestClient.Parameters)
{
if (ManagementClientWriterHelpers.IsApiVersionParameter(parameter))
{
continue;
}
writer.Append($"_{parameter.Name}, ");
}
writer.RemoveTrailingComma();
writer.Line($");");
}
writer.Line();
}
}
}
}
private void WriteClientMethod(CodeWriter writer, ClientMethod clientMethod, bool async)
{
CSharpType?bodyType = clientMethod.RestClientMethod.ReturnType;
CSharpType responseType = bodyType != null ?
new CSharpType(typeof(Response <>), bodyType) :
typeof(Response);
responseType = async ? new CSharpType(typeof(Task <>), responseType) : responseType;
var parameters = clientMethod.RestClientMethod.Parameters;
writer.WriteXmlDocumentationSummary(clientMethod.Description);
foreach (Parameter parameter in parameters)
{
writer.WriteXmlDocumentationParameter(parameter.Name, parameter.Description);
}
writer.WriteXmlDocumentationParameter("cancellationToken", "The cancellation token to use.");
var methodName = CreateMethodName(clientMethod.Name, async);
var asyncText = async ? "async" : string.Empty;
writer.Append($"public virtual {asyncText} {responseType} {methodName}(");
foreach (Parameter parameter in parameters)
{
writer.WriteParameter(parameter);
}
writer.Line($"{typeof(CancellationToken)} cancellationToken = default)");
using (writer.Scope())
{
WriteDiagnosticScope(writer, clientMethod.Diagnostics, writer =>
{
writer.Append($"return (");
if (async)
{
writer.Append($"await ");
}
writer.Append($"RestClient.{CreateMethodName(clientMethod.RestClientMethod.Name, async)}(");
foreach (var parameter in clientMethod.RestClientMethod.Parameters)
{
writer.Append($"{parameter.Name:I}, ");
}
writer.Append($"cancellationToken)");
if (async)
{
writer.Append($".ConfigureAwait(false)");
}
writer.Append($")");
if (bodyType == null && clientMethod.RestClientMethod.HeaderModel != null)
{
writer.Append($".GetRawResponse()");
}
writer.Line($";");
});
}
writer.Line();
}
private void WritePagingOperation(CodeWriter writer, PagingMethod pagingMethod, bool async)
{
var pageType = pagingMethod.ItemType;
CSharpType responseType = async ? new CSharpType(typeof(AsyncPageable <>), pageType) : new CSharpType(typeof(Pageable <>), pageType);
var parameters = pagingMethod.Method.Parameters;
writer.WriteXmlDocumentationSummary(pagingMethod.Method.Description);
foreach (Parameter parameter in parameters)
{
writer.WriteXmlDocumentationParameter(parameter.Name, parameter.Description);
}
writer.WriteXmlDocumentationParameter("cancellationToken", "The cancellation token to use.");
writer.Append($"public virtual {responseType} {CreateMethodName(pagingMethod.Name, async)}(");
foreach (Parameter parameter in parameters)
{
writer.WriteParameter(parameter);
}
writer.Line($"{typeof(CancellationToken)} cancellationToken = default)");
using (writer.Scope())
{
writer.WriteParameterNullChecks(parameters);
var pageWrappedType = new CSharpType(typeof(Page <>), pageType);
var funcType = async ? new CSharpType(typeof(Task <>), pageWrappedType) : pageWrappedType;
var nullableInt = new CSharpType(typeof(int), true);
var continuationTokenText = pagingMethod.NextLinkName != null ? $"response.Value.{pagingMethod.NextLinkName}" : "null";
var asyncText = async ? "async" : string.Empty;
var awaitText = async ? "await" : string.Empty;
var configureAwaitText = async ? ".ConfigureAwait(false)" : string.Empty;
using (writer.Scope($"{asyncText} {funcType} FirstPageFunc({nullableInt} pageSizeHint)"))
{
WriteDiagnosticScope(writer, pagingMethod.Diagnostics, writer =>
{
writer.Append($"var response = {awaitText} RestClient.{CreateMethodName(pagingMethod.Method.Name, async)}(");
foreach (Parameter parameter in parameters)
{
writer.Append($"{parameter.Name}, ");
}
writer.Line($"cancellationToken){configureAwaitText};");
writer.Line($"return {typeof(Page)}.FromValues(response.Value.{pagingMethod.ItemName}, {continuationTokenText}, response.GetRawResponse());");
});
}
var nextPageFunctionName = "null";
if (pagingMethod.NextPageMethod != null)
{
nextPageFunctionName = "NextPageFunc";
var nextPageParameters = pagingMethod.NextPageMethod.Parameters;
using (writer.Scope($"{asyncText} {funcType} {nextPageFunctionName}({typeof(string)} nextLink, {nullableInt} pageSizeHint)"))
{
WriteDiagnosticScope(writer, pagingMethod.Diagnostics, writer =>
{
writer.Append($"var response = {awaitText} RestClient.{CreateMethodName(pagingMethod.NextPageMethod.Name, async)}(");
foreach (Parameter parameter in nextPageParameters)
{
writer.Append($"{parameter.Name}, ");
}
writer.Line($"cancellationToken){configureAwaitText};");
writer.Line($"return {typeof(Page)}.FromValues(response.Value.{pagingMethod.ItemName}, {continuationTokenText}, response.GetRawResponse());");
});
}
}
writer.Line($"return {typeof(PageableHelpers)}.Create{(async ? "Async" : string.Empty)}Enumerable(FirstPageFunc, {nextPageFunctionName});");
}
writer.Line();
}
public static void Write(CodeWriter writer, LongRunningOperation operation)
{
var responseVariable = "response";
void WriteResultFunction(bool async)
{
if (operation.ResultSerialization != null)
{
writer.WriteDeserializationForMethods(
operation.ResultSerialization,
async: async,
(w, v) => w.Line($"return {v};"),
responseVariable);
}
else
{
if (async)
{
writer.Line($"return await new {typeof(ValueTask<Response>)}({responseVariable}).ConfigureAwait(false);");
}
else
{
writer.Line($"return {responseVariable};");
}
}
}
var cs = operation.Type;
var @namespace = cs.Namespace;
using (writer.Namespace(@namespace))
{
writer.WriteXmlDocumentationSummary(operation.Description);
var interfaceType = new CSharpType(typeof(IOperationSource <>), operation.ResultType);
var baseType = new CSharpType(typeof(Operation <>), operation.ResultType);
var waitForCompletionType = new CSharpType(typeof(ValueTask <>), new CSharpType(typeof(Response <>), operation.ResultType));
var helperType = new CSharpType(typeof(ArmOperationHelpers <>), operation.ResultType);
using (writer.Scope($"{operation.Declaration.Accessibility} partial class {cs.Name}: {baseType}, {interfaceType}"))
{
writer.Line($"private readonly {helperType} _operation;");
using (writer.Scope($"internal {cs.Name}({typeof(ClientDiagnostics)} clientDiagnostics, {typeof(HttpPipeline)} pipeline, {typeof(Request)} request, {typeof(Response)} response)"))
{
writer.Line($"_operation = new {helperType}(this, clientDiagnostics, pipeline, request, response, {typeof(OperationFinalStateVia)}.{operation.FinalStateVia}, {operation.Diagnostics.ScopeName:L});");
}
writer.WriteXmlDocumentationInheritDoc();
writer.Line($"public override string Id => _operation.Id;");
writer.Line();
writer.WriteXmlDocumentationInheritDoc();
writer.Line($"public override {operation.ResultType} Value => _operation.Value;");
writer.Line();
writer.WriteXmlDocumentationInheritDoc();
writer.Line($"public override bool HasCompleted => _operation.HasCompleted;");
writer.Line();
writer.WriteXmlDocumentationInheritDoc();
writer.Line($"public override bool HasValue => _operation.HasValue;");
writer.Line();
writer.WriteXmlDocumentationInheritDoc();
writer.Line($"public override {typeof(Response)} GetRawResponse() => _operation.GetRawResponse();");
writer.Line();
writer.WriteXmlDocumentationInheritDoc();
writer.Line($"public override {typeof(Response)} UpdateStatus({typeof(CancellationToken)} cancellationToken = default) => _operation.UpdateStatus(cancellationToken);");
writer.Line();
writer.WriteXmlDocumentationInheritDoc();
writer.Line($"public override {typeof(ValueTask<Response>)} UpdateStatusAsync({typeof(CancellationToken)} cancellationToken = default) => _operation.UpdateStatusAsync(cancellationToken);");
writer.Line();
writer.WriteXmlDocumentationInheritDoc();
writer.Line($"public override {waitForCompletionType} WaitForCompletionAsync({typeof(CancellationToken)} cancellationToken = default) => _operation.WaitForCompletionAsync(cancellationToken);");
writer.Line();
writer.WriteXmlDocumentationInheritDoc();
writer.Line($"public override {waitForCompletionType} WaitForCompletionAsync({typeof(TimeSpan)} pollingInterval, {typeof(CancellationToken)} cancellationToken = default) => _operation.WaitForCompletionAsync(pollingInterval, cancellationToken);");
writer.Line();
using (writer.Scope($"{operation.ResultType} {interfaceType}.CreateResult({typeof(Response)} {responseVariable:D}, {typeof(CancellationToken)} cancellationToken)"))
{
WriteResultFunction(false);
}
writer.Line();
using (writer.Scope($"async {new CSharpType(typeof(ValueTask<>), operation.ResultType)} {interfaceType}.CreateResultAsync({typeof(Response)} {responseVariable:D}, {typeof(CancellationToken)} cancellationToken)"))
{
WriteResultFunction(true);
}
}
}
}
private void WriteObjectSchema(CodeWriter writer, ObjectType schema)
{
using (writer.Namespace(schema.Declaration.Namespace))
{
List <CSharpType> implementsTypes = new List <CSharpType>();
if (schema.Inherits != null)
{
implementsTypes.Add(schema.Inherits);
}
if (schema.ImplementsDictionaryType != null)
{
implementsTypes.Add(schema.ImplementsDictionaryType);
}
writer.WriteXmlDocumentationSummary(schema.Description);
if (schema.IsStruct)
{
writer.Append($"{schema.Declaration.Accessibility} readonly partial struct {schema.Declaration.Name}");
}
else
{
writer.Append($"{schema.Declaration.Accessibility} partial class {schema.Declaration.Name}");
}
if (implementsTypes.Any())
{
writer.AppendRaw(" : ");
foreach (var type in implementsTypes)
{
writer.Append($"{type} ,");
}
writer.RemoveTrailingComma();
}
writer.Line();
using (writer.Scope())
{
WriteConstructor(writer, schema);
foreach (var property in schema.Properties)
{
writer.WriteXmlDocumentationSummary(property.Description);
CSharpType propertyType = property.Declaration.Type;
writer.Append($"{property.Declaration.Accessibility} {propertyType} {property.Declaration.Name:D}");
writer.AppendRaw(property.IsReadOnly ? "{ get; }" : "{ get; set; }");
writer.Line();
}
if (schema.AdditionalPropertiesProperty is ObjectTypeProperty additionalPropertiesProperty)
{
var dictionaryType = schema.ImplementsDictionaryType;
Debug.Assert(dictionaryType != null);
var keyType = typeof(string);
var isReadonly = dictionaryType.FrameworkType == typeof(IReadOnlyDictionary <,>);
var itemType = dictionaryType.Arguments[1];
var keyValuePairType = new CSharpType(typeof(KeyValuePair <,>), keyType, itemType);
var iEnumeratorKeyValuePairType = new CSharpType(typeof(IEnumerator <>), keyValuePairType);
var collectionType = isReadonly ? typeof(IReadOnlyCollection <>) : typeof(ICollection <>);
var iCollectionKeyValuePairType = new CSharpType(collectionType, keyValuePairType);
var keyValueCollectionType = isReadonly ? typeof(IEnumerable <>) : typeof(ICollection <>);
var iCollectionKeyType = new CSharpType(keyValueCollectionType, keyType);
var iCollectionItemType = new CSharpType(keyValueCollectionType, itemType);
var iEnumerator = typeof(IEnumerator);
var iEnumerable = typeof(IEnumerable);
string additionalProperties = additionalPropertiesProperty.Declaration.Name;
writer
.WriteXmlDocumentationInheritDoc()
.Line($"public {iEnumeratorKeyValuePairType} GetEnumerator() => {additionalProperties}.GetEnumerator();")
.WriteXmlDocumentationInheritDoc()
.Line($"{iEnumerator} {iEnumerable}.GetEnumerator() => {additionalProperties}.GetEnumerator();")
.WriteXmlDocumentationInheritDoc()
.Line($"public bool TryGetValue(string key, out {itemType} value) => {additionalProperties}.TryGetValue(key, out value);")
.WriteXmlDocumentationInheritDoc()
.Line($"public bool ContainsKey({keyType} key) => {additionalProperties}.ContainsKey(key);")
.WriteXmlDocumentationInheritDoc()
.Line($"public {iCollectionKeyType} Keys => {additionalProperties}.Keys;")
.WriteXmlDocumentationInheritDoc()
.Line($"public {iCollectionItemType} Values => {additionalProperties}.Values;")
.WriteXmlDocumentationInheritDoc()
.Line($"int {iCollectionKeyValuePairType}.Count => {additionalProperties}.Count;");
if (!isReadonly)
{
writer
.WriteXmlDocumentationInheritDoc()
.Line($"public void Add({keyType} key, {itemType} value) => {additionalProperties}.Add(key, value);")
.WriteXmlDocumentationInheritDoc()
.Line($"public bool Remove({keyType} key) => {additionalProperties}.Remove(key);")
.WriteXmlDocumentationInheritDoc()
.Line($"bool {iCollectionKeyValuePairType}.IsReadOnly => {additionalProperties}.IsReadOnly;")
.WriteXmlDocumentationInheritDoc()
.Line($"void {iCollectionKeyValuePairType}.Add({keyValuePairType} value) => {additionalProperties}.Add(value);")
.WriteXmlDocumentationInheritDoc()
.Line($"bool {iCollectionKeyValuePairType}.Remove({keyValuePairType} value) => {additionalProperties}.Remove(value);")
.WriteXmlDocumentationInheritDoc()
.Line($"bool {iCollectionKeyValuePairType}.Contains({keyValuePairType} value) => {additionalProperties}.Contains(value);")
.WriteXmlDocumentationInheritDoc()
.Line($"void {iCollectionKeyValuePairType}.CopyTo({keyValuePairType}[] destination, int offset) => {additionalProperties}.CopyTo(destination, offset);")
.WriteXmlDocumentationInheritDoc()
.Line($"void {iCollectionKeyValuePairType}.Clear() => {additionalProperties}.Clear();");
}
using (writer
.WriteXmlDocumentationInheritDoc()
.Scope($"public {itemType} this[{keyType} key]"))
{
writer.Line($"get => {additionalProperties}[key];");
if (!isReadonly)
{
writer.Line($"set => {additionalProperties}[key] = value;");
}
}
}
}
}
}
private void WriteChoiceSchema(CodeWriter writer, EnumType schema)
{
var cs = schema.Type;
string name = schema.Declaration.Name;
var isString = schema.BaseType.FrameworkType == typeof(string);
using (writer.Namespace(schema.Declaration.Namespace))
{
writer.WriteXmlDocumentationSummary(schema.Description);
var implementType = new CSharpType(typeof(IEquatable <>), cs);
using (writer.Scope($"{schema.Declaration.Accessibility} readonly partial struct {name}: {implementType}"))
{
writer.Line($"private readonly {schema.BaseType} _value;");
writer.Line();
writer.WriteXmlDocumentationSummary($"Determines if two <see cref=\"{name}\"/> values are the same.");
using (writer.Scope($"public {name}({schema.BaseType} value)"))
{
writer.Append($"_value = value");
if (isString)
{
writer.Append($"?? throw new {typeof(ArgumentNullException)}(nameof(value))");
}
writer.Line($";");
}
writer.Line();
foreach (var choice in schema.Values)
{
writer.Line($"private const {schema.BaseType} {choice.Declaration.Name}Value = {choice.Value.Value:L};");
}
writer.Line();
foreach (var choice in schema.Values)
{
writer.WriteXmlDocumentationSummary(choice.Description);
writer.Append($"public static {cs} {choice.Declaration.Name}").AppendRaw("{ get; }").Append($" = new {cs}({choice.Declaration.Name}Value);").Line();
}
writer.WriteXmlDocumentationSummary($"Determines if two <see cref=\"{name}\"/> values are the same.");
writer.Line($"public static bool operator ==({cs} left, {cs} right) => left.Equals(right);");
writer.WriteXmlDocumentationSummary($"Determines if two <see cref=\"{name}\"/> values are not the same.");
writer.Line($"public static bool operator !=({cs} left, {cs} right) => !left.Equals(right);");
writer.WriteXmlDocumentationSummary($"Converts a string to a <see cref=\"{name}\"/>.");
writer.Line($"public static implicit operator {cs}({schema.BaseType} value) => new {cs}(value);");
writer.Line();
writer.WriteXmlDocumentationInheritDoc();
WriteEditorBrowsableFalse(writer);
writer.Line($"public override bool Equals({typeof(object)} obj) => obj is {cs} other && Equals(other);");
writer.WriteXmlDocumentationInheritDoc();
writer.Append($"public bool Equals({cs} other) => ");
if (isString)
{
writer.Line($"{schema.BaseType}.Equals(_value, other._value, {typeof(StringComparison)}.InvariantCultureIgnoreCase);");
}
else
{
writer.Line($"{schema.BaseType}.Equals(_value, other._value);");
}
writer.Line();
writer.WriteXmlDocumentationInheritDoc();
WriteEditorBrowsableFalse(writer);
writer.Append($"public override int GetHashCode() => ");
if (isString)
{
writer.Line($"_value?.GetHashCode() ?? 0;");
}
else
{
writer.Line($"_value.GetHashCode();");
}
writer.WriteXmlDocumentationInheritDoc();
writer.Append($"public override {typeof(string)} ToString() => ");
if (isString)
{
writer.Line($"_value;");
}
else
{
writer.Line($"_value.ToString({typeof(CultureInfo)}.InvariantCulture);");
}
}
}
}
