public static EnumTemplate AddEnum(this NamespaceTemplate namespaceTemplate, string name, TypeTemplate basedOn = null) { EnumTemplate enumTemplate = new EnumTemplate(namespaceTemplate, name, basedOn); namespaceTemplate.Children.Add(enumTemplate); return(enumTemplate); }
public virtual void Write(ICodeFragment fragment, IOutputCache output) { BaseLanguage language = this.options.Language.CastTo <BaseLanguage>(); EnumTemplate template = (EnumTemplate)fragment; output.Add(template.Attributes) .Add(language.ClassScope) .Add(" enum ") .Add(template.Name); if (template.BasedOn != null) { output.Add(" : ").Add(template.BasedOn); } output.StartBlock(); EnumValueTemplate last = template.Values.LastOrDefault(); foreach (EnumValueTemplate enumTemplateValue in template.Values) { output.Add($"{enumTemplateValue.FormattedName} = ") .Add(enumTemplateValue.Value) .Add(last == enumTemplateValue ? string.Empty : ",") .BreakLine(); } output.EndBlock(); }
/// <summary> /// Generates C# code for service client. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(ServiceClient serviceClient) { var serviceClientTemplateModel = new ServiceClientTemplateModel(serviceClient); // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = serviceClientTemplateModel, }; await Write(serviceClientTemplate, serviceClient.Name.ToPascalCase() + "Impl.java"); var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate { Model = serviceClientTemplateModel, }; await Write(serviceClientInterfaceTemplate, serviceClient.Name.ToPascalCase() + ".java"); //Models if (serviceClient.ModelTypes.Any()) { foreach (var modelType in serviceClientTemplateModel.ModelTemplateModels) { var modelTemplate = new ModelTemplate { Model = modelType }; await Write(modelTemplate, Path.Combine("models", modelType.Name.ToPascalCase() + ".java")); } } //MethodGroups if (serviceClientTemplateModel.MethodGroupModels.Any()) { foreach (var methodGroupModel in serviceClientTemplateModel.MethodGroupModels) { var methodGroupTemplate = new MethodGroupTemplate { Model = methodGroupModel }; await Write(methodGroupTemplate, methodGroupModel.MethodGroupType.ToPascalCase() + "Impl.java"); var methodGroupInterfaceTemplate = new MethodGroupInterfaceTemplate { Model = methodGroupModel }; await Write(methodGroupInterfaceTemplate, methodGroupModel.MethodGroupType.ToPascalCase() + ".java"); } } //Enums foreach (var enumType in serviceClient.EnumTypes) { var enumTemplate = new EnumTemplate { Model = new EnumTemplateModel(enumType), }; await Write(enumTemplate, Path.Combine("models", enumTemplate.Model.Name.ToPascalCase() + ".java")); } }
private void GenerateEnum(XmlEnumItem item) { var template = new EnumTemplate(item); var data = template.TransformText(); _codeWriter.Write(Utils.EnumsNamespace, item.name, data); }
public void Run(Options options) { _grammar = Utils.LoadGrammar(options.Grammar); Directory.CreateDirectory(options.Output); foreach (var instruction in _grammar.OperandKinds) { switch (instruction.Value.Category) { case SpirvOperandCategory.BitEnum: { var text = new FlagTemplate(instruction.Value).TransformText(); Utils.SaveText(Path.Combine(options.Output, instruction.Value.Name + ".cs"), text); break; } case SpirvOperandCategory.ValueEnum: { var text = new EnumTemplate(instruction.Value).TransformText(); Utils.SaveText(Path.Combine(options.Output, instruction.Value.Name + ".cs"), text); break; } } } { var text = new NestedInstruction(_grammar.Instructions.Select(_ => _.Value).Where(_ => _nestedInstructions.Contains(_.Name))).TransformText(); Utils.SaveText(Path.Combine(options.Output, "NestedInstruction.cs"), text); } }
/// <summary> /// Generates C# code for service client. /// </summary> /// <param name="serviceClient">The service client.</param> /// <returns>Async tasks which generates SDK files.</returns> public override async Task Generate(ServiceClient serviceClient) { // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = new AzureServiceClientTemplateModel(serviceClient), }; await Write(serviceClientTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(serviceClient.Name) + ImplementationFileExtension)); // Operations foreach (var group in serviceClient.MethodGroups) { // Operation var operationsTemplate = new AzureMethodGroupTemplate { Model = new AzureMethodGroupTemplateModel(serviceClient, group), }; await Write(operationsTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(operationsTemplate.Model.MethodGroupName) + ImplementationFileExtension)); } // Models foreach (var model in serviceClient.ModelTypes) { if (model.Extensions.ContainsKey(AzureExtensions.ExternalExtension) || model.Extensions.ContainsKey(AzureExtensions.AzureResourceExtension)) { continue; } var modelTemplate = new ModelTemplate { Model = new AzureModelTemplateModel(model, serviceClient.ModelTypes), }; await Write(modelTemplate, Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(model.Name) + ImplementationFileExtension)); } // Enums foreach (var enumType in serviceClient.EnumTypes) { var enumTemplate = new EnumTemplate { Model = new EnumTemplateModel(enumType), }; await Write(enumTemplate, Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(enumTemplate.Model.TypeDefinitionName) + ImplementationFileExtension)); } // Requirements var requirementsTemplate = new RequirementsTemplate { Model = new AzureRequirementsTemplateModel(serviceClient, sdkName, this.ImplementationFileExtension), }; await Write(requirementsTemplate, RubyCodeNamer.UnderscoreCase(sdkName) + ImplementationFileExtension); }
public void EnumWriter() { EnumTemplate template = new EnumTemplate((NamespaceTemplate)null, "test"); template.Values.Add(new EnumValueTemplate("value", Code.Number(0))); EnumWriter writer = new EnumWriter(); writer.Write(template, this.output); Assert.AreEqual("public enum test\r\n{\r\n value = 0\r\n}", this.output.ToString()); }
private void TransformEnums(SmartAppInfo manifest) { var enums = manifest.DataModel.Entities.Where(e => e.IsEnum).AsEnumerable(); foreach (var model in enums) { var template = new EnumTemplate(model, manifest.Id, Constants.DataNamespace); _writingService.WriteFile(Path.Combine(_context.BasePath, template.OutputPath, $"{model.Id}.g.cs"), template.TransformText()); } }
private void GenerateEnum(CodeGenerateDto dto) { foreach (var enumModel in dto.Enums) { var enumTemplate = new EnumTemplate(); enumTemplate.Model = enumModel; Directory.CreateDirectory($@"{dto.BasePath}\ApplicationCore\Enums"); System.IO.File.WriteAllText($@"{dto.BasePath}\ApplicationCore\Enums\{enumModel.Name}.cs", enumTemplate.TransformText()); } }
/// <summary> /// Generates C# code for service client. /// </summary> /// <param name="cm"></param> /// <returns></returns> public override async Task Generate(CodeModel cm) { // get c# specific codeModel var codeModel = cm as CodeModelCs; if (codeModel == null) { throw new InvalidCastException("CodeModel is not a c# CodeModel"); } // Service client var serviceClientTemplate = new ServiceClientTemplate{ Model = codeModel }; await Write(serviceClientTemplate, $"{codeModel.Name}{ImplementationFileExtension}" ); // Service client interface var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate { Model = codeModel }; await Write(serviceClientInterfaceTemplate, $"I{codeModel.Name}{ImplementationFileExtension}"); // operations foreach (MethodGroupCs methodGroup in codeModel.Operations) { if(!methodGroup.Name.IsNullOrEmpty()) { // Operation var operationsTemplate = new MethodGroupTemplate { Model = methodGroup }; await Write(operationsTemplate, $"{operationsTemplate.Model.TypeName}{ImplementationFileExtension}"); // Operation interface var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate { Model = methodGroup }; await Write(operationsInterfaceTemplate, $"I{operationsInterfaceTemplate.Model.TypeName}{ImplementationFileExtension}"); } var operationExtensionsTemplate = new ExtensionsTemplate { Model = methodGroup }; await Write(operationExtensionsTemplate, $"{methodGroup.ExtensionTypeName}Extensions{ImplementationFileExtension}"); } // Models foreach (CompositeTypeCs model in codeModel.ModelTypes.Union(codeModel.HeaderTypes)) { var modelTemplate = new ModelTemplate{ Model = model }; await Write(modelTemplate, Path.Combine(Settings.Instance.ModelsName, $"{model.Name}{ImplementationFileExtension}")); } // Enums foreach (EnumTypeCs enumType in codeModel.EnumTypes) { var enumTemplate = new EnumTemplate { Model = enumType }; await Write(enumTemplate, Path.Combine(Settings.Instance.ModelsName, $"{enumTemplate.Model.Name}{ImplementationFileExtension}")); } // Exceptions foreach (CompositeTypeCs exceptionType in codeModel.ErrorTypes) { var exceptionTemplate = new ExceptionTemplate { Model = exceptionType, }; await Write(exceptionTemplate, Path.Combine(Settings.Instance.ModelsName, $"{exceptionTemplate.Model.ExceptionTypeDefinitionName}{ImplementationFileExtension}")); } }
private TypeGeneratorResult GenerateEnum(string typeName) { var template = new EnumTemplate() as ITemplate; template.Initialize(new EnumTemplateModel(typeName, _schema)); return(new TypeGeneratorResult { TypeName = typeName, Code = template.Render() }); }
/// <summary> /// Generates C# code for service client. /// </summary> /// <param name="serviceClient">The service client.</param> /// <returns>Async task for generating SDK files.</returns> public override async Task Generate(ServiceClient serviceClient) { // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = new ServiceClientTemplateModel(serviceClient), }; await Write(serviceClientTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(serviceClient.Name) + ImplementationFileExtension)); // Method groups foreach (var group in serviceClient.MethodGroups) { var groupTemplate = new MethodGroupTemplate { Model = new MethodGroupTemplateModel(serviceClient, group), }; await Write(groupTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(group) + ImplementationFileExtension)); } // Models foreach (var model in serviceClient.ModelTypes) { var modelTemplate = new ModelTemplate { Model = new ModelTemplateModel(model, serviceClient.ModelTypes) }; await Write(modelTemplate, Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(model.Name) + ImplementationFileExtension)); } // Enums foreach (var enumType in serviceClient.EnumTypes) { var enumTemplate = new EnumTemplate { Model = new EnumTemplateModel(enumType), }; await Write(enumTemplate, Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(enumTemplate.Model.TypeDefinitionName) + ImplementationFileExtension)); } // Requirements var requirementsTemplate = new RequirementsTemplate { Model = new RequirementsTemplateModel(serviceClient, sdkName, this.ImplementationFileExtension), }; await Write(requirementsTemplate, RubyCodeNamer.UnderscoreCase(sdkName) + ImplementationFileExtension); }
public void ProtocolTest() { var versions = MetaDb.Protocol.SelectToken("VersionDummy.Protocol").ToObject <Dictionary <string, object> >(); var tmpl = new EnumTemplate { EnumName = "Protocol", Enums = versions }; Console.WriteLine(tmpl.TransformText()); }
public void RenderEnumFile(List <EnumModel> models) { if (!Directory.Exists(_outputPath + "Entity\\" + NormalizeTableName + "\\")) { Directory.CreateDirectory(_outputPath + "Entity\\" + NormalizeTableName + "\\"); } var enumTemplate = new EnumTemplate(models, _projectName); var output = enumTemplate.TransformText(); var outputPath = _outputPath + "Entity\\" + NormalizeTableName + "\\" + "Enum" + NormalizeTableName + ".cs"; File.WriteAllText(outputPath, output); }
/// <summary>Generates the type.</summary> /// <param name="fallbackTypeName">The fallback type name.</param> /// <returns>The code.</returns> public override TypeGeneratorResult GenerateType(string fallbackTypeName) { var typeName = _schema.GetTypeName(Settings.TypeNameGenerator); if (string.IsNullOrEmpty(typeName)) { typeName = fallbackTypeName; } if (_schema.IsEnumeration) { if (_schema.Type == JsonObjectType.Integer) { typeName = typeName + "AsInteger"; } var template = new EnumTemplate() as ITemplate; template.Initialize(new EnumTemplateModel(typeName, _schema)); return(new TypeGeneratorResult { TypeName = typeName, Code = template.Render() }); } else { var properties = _schema.Properties.Values.Select(property => new PropertyModel(property, typeName, _resolver, Settings)).ToList(); var hasInheritance = _schema.AllOf.Count == 1; var baseClass = hasInheritance ? _resolver.Resolve(_schema.AllOf.First(), true, string.Empty) : null; var template = Settings.CreateTemplate(typeName); template.Initialize(new // TODO: Create model class { Class = Settings.ExtendedClasses?.Contains(typeName) == true ? typeName + "Base" : typeName, RealClass = typeName, HasDescription = !(_schema is JsonProperty) && !string.IsNullOrEmpty(_schema.Description), Description = ConversionUtilities.RemoveLineBreaks(_schema.Description), HasInheritance = hasInheritance, Inheritance = hasInheritance ? " extends " + baseClass : string.Empty, Properties = properties }); return(new TypeGeneratorResult { TypeName = typeName, BaseTypeName = baseClass, Code = template.Render() }); } }
private static void GenerateEnumsInScope(string outputDir, EngineApi engineApi, List <EngineEnum> enums, string scope) { scope = string.IsNullOrEmpty(scope) ? "Global" : scope; string output = EnumTemplate.Render(enums, scope); Console.WriteLine(scope + "_enums.cs"); Directory.CreateDirectory($"{outputDir}/Enums"); using (StreamWriter SW = new StreamWriter($"{outputDir}/Enums/{scope}.cs")) { SW.Write(output); } }
protected virtual EnumTemplate WriteEnum(IModelConfiguration configuration, ModelTransferObject model, string nameSpace, List <FileTemplate> files) { if (model.EnumValues == null) { throw new InvalidOperationException("Can not write enum without values"); } EnumTemplate enumTemplate = files.AddFile(configuration.RelativePath, configuration.AddHeader) .AddNamespace(nameSpace) .AddEnum(model.Name); foreach (KeyValuePair <string, int> pair in model.EnumValues) { string formattedName = Formatter.FormatProperty(pair.Key, configuration); enumTemplate.Values.Add(new EnumValueTemplate(pair.Key, Code.Number(pair.Value), formattedName)); } return(enumTemplate); }
protected virtual EnumTemplate WriteEnum(ModelTransferObject model, string relativePath) { if (model.EnumValues == null) { throw new InvalidOperationException("Can not write enum without values"); } IOptions modelOptions = this.Options.Get(model); EnumTemplate enumTemplate = this.files.AddFile(relativePath, modelOptions) .WithName(model.FileName) .AddNamespace(modelOptions.SkipNamespace ? string.Empty : model.Namespace) .AddEnum(model.Name); foreach (KeyValuePair <string, int> pair in model.EnumValues) { string formattedName = Formatter.FormatProperty(pair.Key, modelOptions); enumTemplate.Values.Add(new EnumValueTemplate(pair.Key, Code.Number(pair.Value), formattedName)); } return(enumTemplate); }
private Task GenerateMultipleFileAsync(string output, string resolverName, ObjectSerializationInfo[] objectInfo, EnumSerializationInfo[] enumInfo, UnionSerializationInfo[] unionInfo, string namespaceDot, string multioutSymbol, GenericSerializationInfo[] genericInfo) { string GetNamespace(INamespaceInfo x) { if (x.Namespace == null) { return(namespaceDot + "Formatters"); } return(namespaceDot + "Formatters." + x.Namespace); } var waitingTasks = new Task[objectInfo.Length + enumInfo.Length + unionInfo.Length + 1]; var waitingIndex = 0; foreach (var x in objectInfo) { var ns = namespaceDot + "Formatters" + (x.Namespace is null ? string.Empty : "." + x.Namespace); var template = x.IsStringKey ? new StringKeyFormatterTemplate(ns, new[] { x }) : (IFormatterTemplate) new FormatterTemplate(ns, new[] { x }); var text = template.TransformText(); waitingTasks[waitingIndex++] = OutputToDirAsync(output, template.Namespace, x.Name + "Formatter", multioutSymbol, text); } foreach (var x in enumInfo) { var template = new EnumTemplate(GetNamespace(x), new[] { x }); var text = template.TransformText(); waitingTasks[waitingIndex++] = OutputToDirAsync(output, template.Namespace, x.Name + "Formatter", multioutSymbol, text); } foreach (var x in unionInfo) { var template = new UnionTemplate(GetNamespace(x), new[] { x }); var text = template.TransformText(); waitingTasks[waitingIndex++] = OutputToDirAsync(output, template.Namespace, x.Name + "Formatter", multioutSymbol, text); } var resolverTemplate = new ResolverTemplate(namespaceDot + "Resolvers", namespaceDot + "Formatters", resolverName, genericInfo.Where(x => !x.IsOpenGenericType).Cast <IResolverRegisterInfo>().Concat(enumInfo).Concat(unionInfo).Concat(objectInfo.Where(x => !x.IsOpenGenericType)).ToArray()); waitingTasks[waitingIndex] = OutputToDirAsync(output, resolverTemplate.Namespace, resolverTemplate.ResolverName, multioutSymbol, resolverTemplate.TransformText()); return(Task.WhenAll(waitingTasks)); }
public override void Write(ICodeFragment fragment, IOutputCache output) { EnumTemplate template = (EnumTemplate)fragment; template.BasedOn = null; base.Write(fragment, output); output.BreakLine() .Add($"export const {template.Name}Values = [").Add(template.Values.Select(x => x.Value), ", ").Add("]").CloseLine() .Add($"export const {template.Name}Names = [").Add(template.Values.Select(x => Code.String(x.Name)), ", ").Add("]").CloseLine() .Add($"export const {template.Name}ValueMapping: {{ [key: number]: string }} = {{ "); bool isFirst = true; foreach (EnumValueTemplate value in template.Values) { if (isFirst) { isFirst = false; } else { output.Add(", "); } output.Add(value.Value).Add(": ").Add(Code.String(value.Name)); } output.Add(" }").CloseLine() .Add($"export const {template.Name}NameMapping: {{ [key: string]: number }} = {{ "); isFirst = true; foreach (EnumValueTemplate value in template.Values) { if (isFirst) { isFirst = false; } else { output.Add(", "); } output.Add(Code.String(value.Name)).Add(": ").Add(value.Value); } output.Add(" }").CloseLine(); }
/// <summary> /// Generate Python client code for given ServiceClient. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(CodeModel cm) { var codeModel = cm as CodeModelPy; if (codeModel == null) { throw new Exception("Code model is not a Python Code Model"); } // Service client var setupTemplate = new SetupTemplate { Model = codeModel }; await Write(setupTemplate, "setup.py"); var serviceClientInitTemplate = new ServiceClientInitTemplate { Model = codeModel }; await Write(serviceClientInitTemplate, Path.Combine(codeModel.PackageName, "__init__.py")); var serviceClientTemplate = new ServiceClientTemplate { Model = codeModel }; await Write(serviceClientTemplate, Path.Combine(codeModel.PackageName, codeModel.Name.ToPythonCase() + ".py")); var versionTemplate = new VersionTemplate { Model = codeModel }; await Write(versionTemplate, Path.Combine(codeModel.PackageName, "version.py")); var exceptionTemplate = new ExceptionTemplate { Model = codeModel }; await Write(exceptionTemplate, Path.Combine(codeModel.PackageName, "exceptions.py")); var credentialTemplate = new CredentialTemplate { Model = codeModel }; await Write(credentialTemplate, Path.Combine(codeModel.PackageName, "credentials.py")); //Models if (codeModel.ModelTypes.Any()) { var modelInitTemplate = new ModelInitTemplate { Model = codeModel }; await Write(modelInitTemplate, Path.Combine(codeModel.PackageName, "models", "__init__.py")); foreach (var modelType in codeModel.ModelTemplateModels) { var modelTemplate = new ModelTemplate { Model = modelType }; await Write(modelTemplate, Path.Combine(codeModel.PackageName, "models", ((string)modelType.Name).ToPythonCase() + ".py")); } } //MethodGroups if (codeModel.MethodGroupModels.Any()) { var methodGroupIndexTemplate = new MethodGroupInitTemplate { Model = codeModel }; await Write(methodGroupIndexTemplate, Path.Combine(codeModel.PackageName, "operations", "__init__.py")); foreach (var methodGroupModel in codeModel.MethodGroupModels) { var methodGroupTemplate = new MethodGroupTemplate { Model = methodGroupModel }; await Write(methodGroupTemplate, Path.Combine(codeModel.PackageName, "operations", ((string) methodGroupModel.TypeName).ToPythonCase() + ".py")); } } // Enums if (codeModel.EnumTypes.Any()) { var enumTemplate = new EnumTemplate { Model = codeModel.EnumTypes }; await Write(enumTemplate, Path.Combine(codeModel.PackageName, "models", codeModel.Name.ToPythonCase() + "_enums.py")); } }
/// <summary> /// Generate Java client code for given ServiceClient. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(ServiceClient serviceClient) { var serviceClientTemplateModel = new ServiceClientTemplateModel(serviceClient); // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = serviceClientTemplateModel, }; await Write(serviceClientTemplate, serviceClient.Name.ToPascalCase() + "Impl.java"); var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate { Model = serviceClientTemplateModel, }; await Write(serviceClientInterfaceTemplate, serviceClient.Name.ToPascalCase() + ".java"); //Models foreach (var modelType in serviceClient.ModelTypes.Concat(serviceClient.HeaderTypes)) { var modelTemplate = new ModelTemplate { Model = new ModelTemplateModel(modelType, serviceClient) }; await Write(modelTemplate, Path.Combine("models", modelType.Name.ToPascalCase() + ".java")); } //MethodGroups if (serviceClientTemplateModel.MethodGroupModels.Any()) { foreach (var methodGroupModel in serviceClientTemplateModel.MethodGroupModels) { var methodGroupTemplate = new MethodGroupTemplate { Model = methodGroupModel }; await Write(methodGroupTemplate, methodGroupModel.MethodGroupType.ToPascalCase() + "Impl.java"); var methodGroupInterfaceTemplate = new MethodGroupInterfaceTemplate { Model = methodGroupModel }; await Write(methodGroupInterfaceTemplate, methodGroupModel.MethodGroupType.ToPascalCase() + ".java"); } } //Enums foreach (var enumType in serviceClient.EnumTypes) { var enumTemplate = new EnumTemplate { Model = new EnumTemplateModel(enumType), }; await Write(enumTemplate, Path.Combine("models", enumTemplate.Model.Name.ToPascalCase() + ".java")); } // Exception foreach (var exceptionType in serviceClient.ErrorTypes) { var exceptionTemplate = new ExceptionTemplate { Model = new ModelTemplateModel(exceptionType, serviceClient), }; await Write(exceptionTemplate, Path.Combine("models", exceptionTemplate.Model.ExceptionTypeDefinitionName.ToPascalCase() + ".java")); } // package-info.java await Write(new PackageInfoTemplate { Model = new PackageInfoTemplateModel(serviceClient, serviceClient.Name) }, _packageInfoFileName); await Write(new PackageInfoTemplate { Model = new PackageInfoTemplateModel(serviceClient, serviceClient.Name, true) }, Path.Combine("models", _packageInfoFileName)); }
/// <summary> /// Generate Python client code for given ServiceClient. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(ServiceClient serviceClient) { var serviceClientTemplateModel = new ServiceClientTemplateModel(serviceClient); if (!string.IsNullOrWhiteSpace(Version)) { serviceClientTemplateModel.Version = Version; } // Service client var setupTemplate = new SetupTemplate { Model = serviceClientTemplateModel }; await Write(setupTemplate, "setup.py"); var serviceClientInitTemplate = new ServiceClientInitTemplate { Model = serviceClientTemplateModel }; await Write(serviceClientInitTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "__init__.py")); var serviceClientTemplate = new ServiceClientTemplate { Model = serviceClientTemplateModel, }; await Write(serviceClientTemplate, Path.Combine(serviceClientTemplateModel.PackageName, serviceClientTemplateModel.Name.ToPythonCase() + ".py")); var versionTemplate = new VersionTemplate { Model = serviceClientTemplateModel, }; await Write(versionTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "version.py")); var exceptionTemplate = new ExceptionTemplate { Model = serviceClientTemplateModel, }; await Write(exceptionTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "exceptions.py")); var credentialTemplate = new CredentialTemplate { Model = serviceClientTemplateModel, }; await Write(credentialTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "credentials.py")); //Models if (serviceClient.ModelTypes.Any()) { var modelInitTemplate = new ModelInitTemplate { Model = new ModelInitTemplateModel(serviceClient) }; await Write(modelInitTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "models", "__init__.py")); foreach (var modelType in serviceClientTemplateModel.ModelTemplateModels) { var modelTemplate = new ModelTemplate { Model = modelType }; await Write(modelTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "models", modelType.Name.ToPythonCase() + ".py")); } } //MethodGroups if (serviceClientTemplateModel.MethodGroupModels.Any()) { var methodGroupIndexTemplate = new MethodGroupInitTemplate { Model = serviceClientTemplateModel }; await Write(methodGroupIndexTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "operations", "__init__.py")); foreach (var methodGroupModel in serviceClientTemplateModel.MethodGroupModels) { var methodGroupTemplate = new MethodGroupTemplate { Model = methodGroupModel }; await Write(methodGroupTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "operations", methodGroupModel.MethodGroupType.ToPythonCase() + ".py")); } } // Enums if (serviceClient.EnumTypes.Any()) { var enumTemplate = new EnumTemplate { Model = new EnumTemplateModel(serviceClient.EnumTypes), }; await Write(enumTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "models", serviceClientTemplateModel.Name.ToPythonCase() + "_enums.py")); } }
/// <summary> /// Generates C# code for service client. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(ServiceClient serviceClient) { var serviceClientTemplateModel = new AzureServiceClientTemplateModel(serviceClient); // Service client var serviceClientTemplate = new AzureServiceClientTemplate { Model = serviceClientTemplateModel, }; await Write(serviceClientTemplate, Path.Combine("implementation", serviceClient.Name.ToPascalCase() + "Impl.java")); var serviceClientInterfaceTemplate = new AzureServiceClientInterfaceTemplate { Model = serviceClientTemplateModel, }; await Write(serviceClientInterfaceTemplate, serviceClient.Name.ToPascalCase() + ".java"); //Models foreach (var modelType in serviceClient.ModelTypes.Concat(serviceClient.HeaderTypes)) { if (modelType.Extensions.ContainsKey(AzureExtensions.ExternalExtension) && (bool)modelType.Extensions[AzureExtensions.ExternalExtension]) { continue; } if (modelType.IsResource()) { continue; } var modelTemplate = new ModelTemplate { Model = new AzureModelTemplateModel(modelType, serviceClient) }; await Write(modelTemplate, Path.Combine("models", modelType.Name.ToPascalCase() + ".java")); } //MethodGroups if (serviceClientTemplateModel.MethodGroupModels.Any()) { foreach (var methodGroupModel in serviceClientTemplateModel.MethodGroupModels) { var methodGroupTemplate = new AzureMethodGroupTemplate { Model = (AzureMethodGroupTemplateModel)methodGroupModel }; await Write(methodGroupTemplate, Path.Combine("implementation", methodGroupModel.MethodGroupType.ToPascalCase() + "Impl.java")); var methodGroupInterfaceTemplate = new AzureMethodGroupInterfaceTemplate { Model = (AzureMethodGroupTemplateModel)methodGroupModel }; await Write(methodGroupInterfaceTemplate, methodGroupModel.MethodGroupType.ToPascalCase() + ".java"); } } //Enums foreach (var enumType in serviceClient.EnumTypes) { var enumTemplate = new EnumTemplate { Model = new EnumTemplateModel(enumType), }; await Write(enumTemplate, Path.Combine("models", enumTemplate.Model.Name.ToPascalCase() + ".java")); } // Page class foreach (var pageClass in pageClasses) { var pageTemplate = new PageTemplate { Model = new PageTemplateModel(pageClass.Value, pageClass.Key.Key, pageClass.Key.Value), }; await Write(pageTemplate, Path.Combine("models", pageTemplate.Model.TypeDefinitionName + ".java")); } // Exceptions foreach (var exceptionType in serviceClient.ErrorTypes) { if (exceptionType.Name == "CloudError") { continue; } var exceptionTemplate = new ExceptionTemplate { Model = new ModelTemplateModel(exceptionType, serviceClient), }; await Write(exceptionTemplate, Path.Combine("models", exceptionTemplate.Model.ExceptionTypeDefinitionName + ".java")); } // package-info.java await Write(new PackageInfoTemplate { Model = new PackageInfoTemplateModel(serviceClient, serviceClient.Name) }, _packageInfoFileName); await Write(new PackageInfoTemplate { Model = new PackageInfoTemplateModel(serviceClient, serviceClient.Name, "implementation") }, Path.Combine("implementation", _packageInfoFileName)); await Write(new PackageInfoTemplate { Model = new PackageInfoTemplateModel(serviceClient, serviceClient.Name, "models") }, Path.Combine("models", _packageInfoFileName)); }
/// <summary> /// Generates C# code for service client. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(ServiceClient serviceClient) { // Service client var serviceClientTemplate = new AzureServiceClientTemplate { Model = new AzureServiceClientTemplateModel(serviceClient), }; await Write(serviceClientTemplate, serviceClient.Name + ".cs"); // Service client extensions var extensionsTemplate = new ExtensionsTemplate { Model = new AzureExtensionsTemplateModel(serviceClient, null), }; await Write(extensionsTemplate, serviceClient.Name + "Extensions.cs"); // Service client interface var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate { Model = new AzureServiceClientTemplateModel(serviceClient), }; await Write(serviceClientInterfaceTemplate, "I" + serviceClient.Name + ".cs"); // Operations foreach (var group in serviceClient.MethodGroups) { // Operation var operationsTemplate = new AzureMethodGroupTemplate { Model = new AzureMethodGroupTemplateModel(serviceClient, group), }; await Write(operationsTemplate, operationsTemplate.Model.MethodGroupType + ".cs"); // Service client extensions var operationExtensionsTemplate = new ExtensionsTemplate { Model = new AzureExtensionsTemplateModel(serviceClient, group), }; await Write(operationExtensionsTemplate, operationExtensionsTemplate.Model.ExtensionName + "Extensions.cs"); // Operation interface var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate { Model = new AzureMethodGroupTemplateModel(serviceClient, group), }; await Write(operationsInterfaceTemplate, "I" + operationsInterfaceTemplate.Model.MethodGroupType + ".cs"); } // Models foreach (var model in serviceClient.ModelTypes) { if (model.Extensions.ContainsKey(ExternalExtension) && (bool) model.Extensions[ExternalExtension]) { continue; } var modelTemplate = new ModelTemplate { Model = new AzureModelTemplateModel(model), }; await Write(modelTemplate, Path.Combine("Models", model.Name + ".cs")); } // Enums foreach (var enumType in serviceClient.EnumTypes) { var enumTemplate = new EnumTemplate { Model = new EnumTemplateModel(enumType), }; await Write(enumTemplate, Path.Combine("Models", enumTemplate.Model.TypeDefinitionName + ".cs")); } }
public static TypeTemplate ToType(this EnumTemplate enumTemplate) { return(Code.Instance.Type(enumTemplate.Name)); }
public static EnumTemplate FormatName(this EnumTemplate enumTemplate, IOptions options, bool force = false) { enumTemplate.Name = Formatter.FormatClass(enumTemplate.Name, options, force); return(enumTemplate); }
/// <summary> /// Generates C# code for service client. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(ServiceClient serviceClient) { var serviceClientTemplateModel = new AzureServiceClientTemplateModel(serviceClient); // Service client var serviceClientTemplate = new AzureServiceClientTemplate { Model = serviceClientTemplateModel, }; await Write(serviceClientTemplate, serviceClient.Name.ToPascalCase() + "Impl.java"); var serviceClientInterfaceTemplate = new AzureServiceClientInterfaceTemplate { Model = serviceClientTemplateModel, }; await Write(serviceClientInterfaceTemplate, serviceClient.Name.ToPascalCase() + ".java"); //Models foreach (var modelType in serviceClient.ModelTypes.Concat(serviceClient.HeaderTypes)) { if (modelType.Extensions.ContainsKey(AzureExtensions.ExternalExtension) && (bool)modelType.Extensions[AzureExtensions.ExternalExtension]) { continue; } var modelTemplate = new ModelTemplate { Model = new AzureModelTemplateModel(modelType, serviceClient) }; await Write(modelTemplate, Path.Combine("models", modelType.Name.ToPascalCase() + ".java")); } //MethodGroups if (serviceClientTemplateModel.MethodGroupModels.Any()) { foreach (var methodGroupModel in serviceClientTemplateModel.MethodGroupModels) { var methodGroupTemplate = new AzureMethodGroupTemplate { Model = (AzureMethodGroupTemplateModel)methodGroupModel }; await Write(methodGroupTemplate, methodGroupModel.MethodGroupType.ToPascalCase() + "Impl.java"); var methodGroupInterfaceTemplate = new AzureMethodGroupInterfaceTemplate { Model = (AzureMethodGroupTemplateModel)methodGroupModel }; await Write(methodGroupInterfaceTemplate, methodGroupModel.MethodGroupType.ToPascalCase() + ".java"); } } //Enums foreach (var enumType in serviceClient.EnumTypes) { var enumTemplate = new EnumTemplate { Model = new EnumTemplateModel(enumType), }; await Write(enumTemplate, Path.Combine("models", enumTemplate.Model.Name.ToPascalCase() + ".java")); } // Page class foreach (var pageClass in pageClasses) { var pageTemplate = new PageTemplate { Model = new PageTemplateModel(pageClass.Value, pageClass.Key.Key, pageClass.Key.Value), }; await Write(pageTemplate, Path.Combine("models", pageTemplate.Model.TypeDefinitionName + ".java")); } // Exceptions foreach (var exceptionType in serviceClient.ErrorTypes) { if (exceptionType.Name == "CloudError") { continue; } var exceptionTemplate = new ExceptionTemplate { Model = new ModelTemplateModel(exceptionType, serviceClient), }; await Write(exceptionTemplate, Path.Combine("models", exceptionTemplate.Model.ExceptionTypeDefinitionName + ".java")); } // package-info.java await Write(new PackageInfoTemplate { Model = new PackageInfoTemplateModel(serviceClient, serviceClient.Name) }, _packageInfoFileName); await Write(new PackageInfoTemplate { Model = new PackageInfoTemplateModel(serviceClient, serviceClient.Name, true) }, Path.Combine("models", _packageInfoFileName)); }
/// <summary> /// Generates Ruby code for service client. /// </summary> /// <param name="cm">The code model.</param> /// <returns>Async task for generating SDK files.</returns> public override async Task Generate(CodeModel cm) { var codeModel = cm as CodeModelRb; if (codeModel == null) { throw new InvalidCastException("CodeModel is not a Ruby code model."); } // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = codeModel }; await Write(serviceClientTemplate, Path.Combine(GeneratorSettingsRb.Instance.sdkPath, CodeNamer.UnderscoreCase(codeModel.Name) + ImplementationFileExtension)); // Method groups foreach (MethodGroupRb group in codeModel.Operations.Where(each => !each.IsCodeModelMethodGroup)) { var groupTemplate = new MethodGroupTemplate { Model = group }; await Write(groupTemplate, Path.Combine(GeneratorSettingsRb.Instance.sdkPath, CodeNamer.UnderscoreCase(@group.TypeName) + ImplementationFileExtension)); } // Models foreach (CompositeTypeRb model in codeModel.ModelTypes) { var modelTemplate = new ModelTemplate { Model = model }; await Write(modelTemplate, Path.Combine(GeneratorSettingsRb.Instance.modelsPath, CodeNamer.UnderscoreCase(model.Name) + ImplementationFileExtension)); } // Enums foreach (EnumTypeRb enumType in codeModel.EnumTypes) { var enumTemplate = new EnumTemplate { Model = enumType }; await Write(enumTemplate, Path.Combine(GeneratorSettingsRb.Instance.modelsPath, CodeNamer.UnderscoreCase(enumTemplate.Model.Name) + ImplementationFileExtension)); } // Requirements var requirementsTemplate = new RequirementsTemplate { Model = new RequirementsRb(codeModel, this) }; await Write(requirementsTemplate, CodeNamer.UnderscoreCase(GeneratorSettingsRb.Instance.packageName ?? GeneratorSettingsRb.Instance.sdkName) + ImplementationFileExtension); // Version File if (!string.IsNullOrEmpty(GeneratorSettingsRb.Instance.packageVersion)) { var versionTemplate = new VersionTemplate { Model = GeneratorSettingsRb.Instance.packageVersion }; await Write(versionTemplate, Path.Combine(GeneratorSettingsRb.Instance.sdkPath, "version" + ImplementationFileExtension)); } // Module Definition File if (!string.IsNullOrEmpty(Settings.Instance.Namespace)) { var modTemplate = new ModuleDefinitionTemplate { Model = GeneratorSettingsRb.Instance.ModuleDeclarations }; await Write(modTemplate, Path.Combine(GeneratorSettingsRb.Instance.sdkPath, "module_definition" + ImplementationFileExtension)); } }
/// <summary> /// Generates C# code for service client. /// </summary> /// <param name="serviceClient">The service client.</param> /// <returns>Async tasks which generates SDK files.</returns> public override async Task Generate(ServiceClient serviceClient) { // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = new AzureServiceClientTemplateModel(serviceClient), }; await Write(serviceClientTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(serviceClient.Name) + ImplementationFileExtension)); // Operations foreach (var group in serviceClient.MethodGroups) { // Operation var operationsTemplate = new AzureMethodGroupTemplate { Model = new AzureMethodGroupTemplateModel(serviceClient, group), }; await Write(operationsTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(operationsTemplate.Model.MethodGroupName) + ImplementationFileExtension)); } // Models foreach (var model in serviceClient.ModelTypes) { if ((model.Extensions.ContainsKey(AzureExtensions.ExternalExtension) && (bool) model.Extensions[AzureExtensions.ExternalExtension]) || model.Name == "Resource" || model.Name == "SubResource") { continue; } var modelTemplate = new ModelTemplate { Model = new AzureModelTemplateModel(model, serviceClient.ModelTypes), }; await Write(modelTemplate, Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(model.Name) + ImplementationFileExtension)); } // Enums foreach (var enumType in serviceClient.EnumTypes) { var enumTemplate = new EnumTemplate { Model = new EnumTemplateModel(enumType), }; await Write(enumTemplate, Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(enumTemplate.Model.TypeDefinitionName) + ImplementationFileExtension)); } // Requirements var requirementsTemplate = new RequirementsTemplate { Model = new AzureRequirementsTemplateModel(serviceClient, this.packageName ?? this.sdkName, this.ImplementationFileExtension, this.Settings.Namespace), }; await Write(requirementsTemplate, RubyCodeNamer.UnderscoreCase(this.packageName ?? this.sdkName) + ImplementationFileExtension); // Version File if(this.packageVersion != null) { var versionTemplate = new VersionTemplate { Model = new VersionTemplateModel(packageVersion), }; await Write(versionTemplate, Path.Combine(sdkPath, "version" + ImplementationFileExtension)); } // Module Definition File if(Settings.Namespace != null) { var modTemplate = new ModuleDefinitionTemplate { Model = new ModuleDefinitionTemplateModel(Settings.Namespace), }; await Write(modTemplate, Path.Combine(sdkPath, "module_definition" + ImplementationFileExtension)); } }
/// <summary> /// Generates C# code for service client. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(ServiceClient serviceClient) { // Service client var serviceClientTemplate = new AzureServiceClientTemplate { Model = new AzureServiceClientTemplateModel(serviceClient, InternalConstructors), }; await Write(serviceClientTemplate, serviceClient.Name + ".cs"); // Service client extensions if (serviceClient.Methods.Any(m => m.Group == null)) { var extensionsTemplate = new ExtensionsTemplate { Model = new AzureExtensionsTemplateModel(serviceClient, null, SyncMethods), }; await Write(extensionsTemplate, serviceClient.Name + "Extensions.cs"); } // Service client interface var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate { Model = new AzureServiceClientTemplateModel(serviceClient, InternalConstructors), }; await Write(serviceClientInterfaceTemplate, "I" + serviceClient.Name + ".cs"); // Operations foreach (var group in serviceClient.MethodGroups) { // Operation var operationsTemplate = new AzureMethodGroupTemplate { Model = new AzureMethodGroupTemplateModel(serviceClient, group), }; await Write(operationsTemplate, operationsTemplate.Model.MethodGroupType + ".cs"); // Service client extensions var operationExtensionsTemplate = new ExtensionsTemplate { Model = new AzureExtensionsTemplateModel(serviceClient, group, SyncMethods), }; await Write(operationExtensionsTemplate, operationExtensionsTemplate.Model.ExtensionName + "Extensions.cs"); // Operation interface var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate { Model = new AzureMethodGroupTemplateModel(serviceClient, group), }; await Write(operationsInterfaceTemplate, "I" + operationsInterfaceTemplate.Model.MethodGroupType + ".cs"); } // Models foreach (var model in serviceClient.ModelTypes.Concat(serviceClient.HeaderTypes)) { if (model.Extensions.ContainsKey(AzureExtensions.ExternalExtension) && (bool) model.Extensions[AzureExtensions.ExternalExtension]) { continue; } var modelTemplate = new ModelTemplate { Model = new AzureModelTemplateModel(model), }; await Write(modelTemplate, Path.Combine(Settings.ModelsName, model.Name + ".cs")); } // Enums foreach (var enumType in serviceClient.EnumTypes) { var enumTemplate = new EnumTemplate { Model = new EnumTemplateModel(enumType), }; await Write(enumTemplate, Path.Combine(Settings.ModelsName, enumTemplate.Model.TypeDefinitionName + ".cs")); } // Page class foreach (var pageClass in pageClasses) { var pageTemplate = new PageTemplate { Model = new PageTemplateModel(pageClass.Value, pageClass.Key.Key, pageClass.Key.Value), }; await Write(pageTemplate, Path.Combine(Settings.ModelsName, pageTemplate.Model.TypeDefinitionName + ".cs")); } // Exceptions foreach (var exceptionType in serviceClient.ErrorTypes) { if (exceptionType.Name == "CloudError") { continue; } var exceptionTemplate = new ExceptionTemplate { Model = new ModelTemplateModel(exceptionType), }; await Write(exceptionTemplate, Path.Combine(Settings.ModelsName, exceptionTemplate.Model.ExceptionTypeDefinitionName + ".cs")); } }
/// <summary> /// Generates C# code for service client. /// </summary> /// <param name="serviceClient">The service client.</param> /// <returns>Async tasks which generates SDK files.</returns> public override async Task Generate(ServiceClient serviceClient) { // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = new AzureServiceClientTemplateModel(serviceClient), }; await Write(serviceClientTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(serviceClient.Name) + ImplementationFileExtension)); // Operations foreach (var group in serviceClient.MethodGroups) { // Operation var operationsTemplate = new AzureMethodGroupTemplate { Model = new AzureMethodGroupTemplateModel(serviceClient, group), }; await Write(operationsTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(operationsTemplate.Model.MethodGroupName) + ImplementationFileExtension)); } // Models foreach (var model in serviceClient.ModelTypes) { if (model.Extensions.ContainsKey(AzureCodeGenerator.ExternalExtension) || model.Extensions.ContainsKey(AzureCodeGenerator.AzureResourceExtension)) { continue; } var modelTemplate = new ModelTemplate { Model = new AzureModelTemplateModel(model), }; await Write(modelTemplate, Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(model.Name) + ImplementationFileExtension)); } // Enums foreach (var enumType in serviceClient.EnumTypes) { var enumTemplate = new EnumTemplate { Model = new EnumTemplateModel(enumType), }; await Write(enumTemplate, Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(enumTemplate.Model.TypeDefinitionName) + ImplementationFileExtension)); } // Requirements var requirementsTemplate = new RequirementsTemplate { Model = new AzureRequirementsTemplateModel(serviceClient, sdkName, this.ImplementationFileExtension), }; await Write(requirementsTemplate, RubyCodeNamer.UnderscoreCase(sdkName) + ImplementationFileExtension); }
/// <summary> /// Generates C# code for service client. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(ServiceClient serviceClient) { // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = new ServiceClientTemplateModel(serviceClient, InternalConstructors), }; await Write(serviceClientTemplate, serviceClient.Name + ".cs"); // Service client extensions if (serviceClient.Methods.Any(m => m.Group == null)) { var extensionsTemplate = new ExtensionsTemplate { Model = new ExtensionsTemplateModel(serviceClient, null, SyncMethods), }; await Write(extensionsTemplate, serviceClient.Name + "Extensions.cs"); } // Service client interface var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate { Model = new ServiceClientTemplateModel(serviceClient, InternalConstructors), }; await Write(serviceClientInterfaceTemplate, "I" + serviceClient.Name + ".cs"); // Operations foreach (var group in serviceClient.MethodGroups) { // Operation var operationsTemplate = new MethodGroupTemplate { Model = new MethodGroupTemplateModel(serviceClient, group), }; await Write(operationsTemplate, operationsTemplate.Model.MethodGroupType + ".cs"); // Service client extensions var operationExtensionsTemplate = new ExtensionsTemplate { Model = new ExtensionsTemplateModel(serviceClient, group, SyncMethods), }; await Write(operationExtensionsTemplate, group + "Extensions.cs"); // Operation interface var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate { Model = new MethodGroupTemplateModel(serviceClient, group), }; await Write(operationsInterfaceTemplate, "I" + operationsInterfaceTemplate.Model.MethodGroupType + ".cs"); } // Models foreach (var model in serviceClient.ModelTypes.Concat(serviceClient.HeaderTypes)) { var modelTemplate = new ModelTemplate { Model = new ModelTemplateModel(model), }; await Write(modelTemplate, Path.Combine(Settings.ModelsName, model.Name + ".cs")); } // Enums foreach (var enumType in serviceClient.EnumTypes) { var enumTemplate = new EnumTemplate { Model = new EnumTemplateModel(enumType), }; await Write(enumTemplate, Path.Combine(Settings.ModelsName, enumTemplate.Model.TypeDefinitionName + ".cs")); } // Exception foreach (var exceptionType in serviceClient.ErrorTypes) { var exceptionTemplate = new ExceptionTemplate { Model = new ModelTemplateModel(exceptionType), }; await Write(exceptionTemplate, Path.Combine(Settings.ModelsName, exceptionTemplate.Model.ExceptionTypeDefinitionName + ".cs")); } }
/// <summary> /// Generate Python client code for given ServiceClient. /// </summary> /// <param name="cm"></param> /// <returns></returns> public override async Task Generate(CodeModel cm) { var codeModel = cm as CodeModelPya; if (codeModel == null) { throw new Exception("CodeModel is not a Python Azure Code Model"); } // Service client var setupTemplate = new SetupTemplate { Model = codeModel }; await Write(setupTemplate, "setup.py"); var serviceClientInitTemplate = new ServiceClientInitTemplate { Model = codeModel }; await Write(serviceClientInitTemplate, Path.Combine(codeModel.PackageName, "__init__.py")); var serviceClientTemplate = new AzureServiceClientTemplate { Model = codeModel, }; await Write(serviceClientTemplate, Path.Combine(codeModel.PackageName, codeModel.Name.ToPythonCase() + ".py")); var versionTemplate = new VersionTemplate { Model = codeModel, }; await Write(versionTemplate, Path.Combine(codeModel.PackageName, "version.py")); var exceptionTemplate = new ExceptionTemplate { Model = codeModel, }; await Write(exceptionTemplate, Path.Combine(codeModel.PackageName, "exceptions.py")); var credentialTemplate = new CredentialTemplate { Model = codeModel, }; await Write(credentialTemplate, Path.Combine(codeModel.PackageName, "credentials.py")); //Models var models = codeModel.ModelTemplateModels.Where(each => !each.Extensions.ContainsKey(AzureExtensions.ExternalExtension)); if (models.Any()) { var modelInitTemplate = new AzureModelInitTemplate { Model = codeModel }; await Write(modelInitTemplate, Path.Combine(codeModel.PackageName, "models", "__init__.py")); foreach (var modelType in models) { var modelTemplate = new ModelTemplate { Model = modelType }; await Write(modelTemplate, Path.Combine(codeModel.PackageName, "models", modelType.Name.ToPythonCase() + ".py")); } } //MethodGroups if (codeModel.MethodGroupModels.Any()) { var methodGroupIndexTemplate = new MethodGroupInitTemplate { Model = codeModel }; await Write(methodGroupIndexTemplate, Path.Combine(codeModel.PackageName, "operations", "__init__.py")); foreach (var methodGroupModel in codeModel.MethodGroupModels) { var methodGroupTemplate = new AzureMethodGroupTemplate { Model = methodGroupModel as MethodGroupPya }; await Write(methodGroupTemplate, Path.Combine(codeModel.PackageName, "operations", ((string) methodGroupModel.TypeName).ToPythonCase() + ".py")); } } // Enums if (codeModel.EnumTypes.Any()) { var enumTemplate = new EnumTemplate { Model = codeModel.EnumTypes }; await Write(enumTemplate, Path.Combine(codeModel.PackageName, "models", codeModel.Name.ToPythonCase() + "_enums.py")); } // Page class foreach (var pageModel in codeModel.PageModels) { var pageTemplate = new PageTemplate { Model = pageModel }; await Write(pageTemplate, Path.Combine(codeModel.PackageName, "models", pageModel.TypeDefinitionName.ToPythonCase() + ".py")); } }
/// <summary> /// Generates C# code for service client. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(ServiceClient serviceClient) { // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = new ServiceClientTemplateModel(serviceClient), }; await Write(serviceClientTemplate, serviceClient.Name + ".cs"); // Service client extensions var extensionsTemplate = new ExtensionsTemplate { Model = new ExtensionsTemplateModel(serviceClient, null), }; await Write(extensionsTemplate, serviceClient.Name + "Extensions.cs"); // Service client interface var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate { Model = new ServiceClientTemplateModel(serviceClient), }; await Write(serviceClientInterfaceTemplate, "I" + serviceClient.Name + ".cs"); // Operations foreach (var group in serviceClient.MethodGroups) { // Operation var operationsTemplate = new MethodGroupTemplate { Model = new MethodGroupTemplateModel(serviceClient, group), }; await Write(operationsTemplate, operationsTemplate.Model.MethodGroupType + ".cs"); // Service client extensions var operationExtensionsTemplate = new ExtensionsTemplate { Model = new ExtensionsTemplateModel(serviceClient, group), }; await Write(operationExtensionsTemplate, group + "Extensions.cs"); // Operation interface var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate { Model = new MethodGroupTemplateModel(serviceClient, group), }; await Write(operationsInterfaceTemplate, "I" + operationsInterfaceTemplate.Model.MethodGroupType + ".cs"); } // Models foreach (var model in serviceClient.ModelTypes) { var modelTemplate = new ModelTemplate { Model = new ModelTemplateModel(model), }; await Write(modelTemplate, "Models\\" + model.Name + ".cs"); } // Enums foreach (var enumType in serviceClient.EnumTypes) { var enumTemplate = new EnumTemplate { Model = new EnumTemplateModel(enumType), }; await Write(enumTemplate, "Models\\" + enumTemplate.Model.TypeDefinitionName + ".cs"); } }
/// <summary> /// Generate Python client code for given ServiceClient. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(ServiceClient serviceClient) { var serviceClientTemplateModel = new AzureServiceClientTemplateModel(serviceClient); if (!string.IsNullOrWhiteSpace(Version)) { serviceClientTemplateModel.Version = Version; } // Service client var setupTemplate = new SetupTemplate { Model = serviceClientTemplateModel }; await Write(setupTemplate, "setup.py"); var serviceClientInitTemplate = new ServiceClientInitTemplate { Model = serviceClientTemplateModel }; await Write(serviceClientInitTemplate, Path.Combine(serviceClient.Name.ToPythonCase(), "__init__.py")); var serviceClientTemplate = new AzureServiceClientTemplate { Model = serviceClientTemplateModel, }; await Write(serviceClientTemplate, Path.Combine(serviceClient.Name.ToPythonCase(), "api_client.py")); //Models if (serviceClientTemplateModel.ModelTemplateModels.Any()) { var modelInitTemplate = new AzureModelInitTemplate { Model = new AzureModelInitTemplateModel(serviceClient, pageModels.Select(t => t.TypeDefinitionName)) }; await Write(modelInitTemplate, Path.Combine(serviceClient.Name.ToPythonCase(), "models", "__init__.py")); foreach (var modelType in serviceClientTemplateModel.ModelTemplateModels) { var modelTemplate = new ModelTemplate { Model = modelType }; await Write(modelTemplate, Path.Combine(serviceClient.Name.ToPythonCase(), "models", modelType.Name.ToPythonCase() + ".py")); } } //MethodGroups if (serviceClientTemplateModel.MethodGroupModels.Any()) { var methodGroupIndexTemplate = new MethodGroupInitTemplate { Model = serviceClientTemplateModel }; await Write(methodGroupIndexTemplate, Path.Combine(serviceClient.Name.ToPythonCase(), "operations", "__init__.py")); foreach (var methodGroupModel in serviceClientTemplateModel.MethodGroupModels) { var methodGroupTemplate = new AzureMethodGroupTemplate { Model = methodGroupModel as AzureMethodGroupTemplateModel }; await Write(methodGroupTemplate, Path.Combine(serviceClient.Name.ToPythonCase(), "operations", methodGroupModel.MethodGroupType.ToPythonCase() + ".py")); } } // Enums if (serviceClient.EnumTypes.Any()) { var enumTemplate = new EnumTemplate { Model = new EnumTemplateModel(serviceClient.EnumTypes), }; await Write(enumTemplate, Path.Combine(serviceClient.Name.ToPythonCase(), "models", "enums.py")); } // Page class foreach (var pageModel in pageModels) { var pageTemplate = new PageTemplate { Model = pageModel }; await Write(pageTemplate, Path.Combine(serviceClient.Name.ToPythonCase(), "models", pageModel.TypeDefinitionName.ToPythonCase() + ".py")); } }
public static EnumTemplate AddValue(this EnumTemplate enumTemplate, string name, int?value = null) { enumTemplate.Values.Add(new EnumValueTemplate(name, Code.Instance.Number(value ?? enumTemplate.Values.Count))); return(enumTemplate); }
/// <summary> /// Generates Ruby code for service client. /// </summary> /// <param name="serviceClient">The service client.</param> /// <returns>Async task for generating SDK files.</returns> public override async Task Generate(ServiceClient serviceClient) { // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = new ServiceClientTemplateModel(serviceClient), }; await Write(serviceClientTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(serviceClient.Name) + ImplementationFileExtension)); // Method groups foreach (var group in serviceClient.MethodGroups) { var groupTemplate = new MethodGroupTemplate { Model = new MethodGroupTemplateModel(serviceClient, group), }; await Write(groupTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(group) + ImplementationFileExtension)); } // Models foreach (var model in serviceClient.ModelTypes) { var modelTemplate = new ModelTemplate { Model = new ModelTemplateModel(model, serviceClient.ModelTypes) }; await Write(modelTemplate, Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(model.Name) + ImplementationFileExtension)); } // Enums foreach (var enumType in serviceClient.EnumTypes) { var enumTemplate = new EnumTemplate { Model = new EnumTemplateModel(enumType), }; await Write(enumTemplate, Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(enumTemplate.Model.TypeDefinitionName) + ImplementationFileExtension)); } // Requirements var requirementsTemplate = new RequirementsTemplate { Model = new RequirementsTemplateModel(serviceClient, this.packageName ?? this.sdkName, this.ImplementationFileExtension, this.Settings.Namespace, this.packageVersion), }; await Write(requirementsTemplate, RubyCodeNamer.UnderscoreCase(this.packageName ?? this.sdkName) + ImplementationFileExtension); // Version File if (!string.IsNullOrEmpty(this.packageVersion)) { var versionTemplate = new VersionTemplate { Model = new VersionTemplateModel(packageVersion), }; await Write(versionTemplate, Path.Combine(sdkPath, "version" + ImplementationFileExtension)); } // Module Definition File if (!string.IsNullOrEmpty(Settings.Namespace)) { var modTemplate = new ModuleDefinitionTemplate { Model = new ModuleDefinitionTemplateModel(Settings.Namespace), }; await Write(modTemplate, Path.Combine(sdkPath, "module_definition" + ImplementationFileExtension)); } }
public static UsingTemplate ToUsing(this EnumTemplate enumTemplate) { return(new UsingTemplate(enumTemplate.Namespace.Name, enumTemplate.Name, enumTemplate.Namespace.File.RelativePath)); }
public async Task GenerateFileAsync( string input, string output, bool unuseUnityAttr, string @namespace, string conditionalSymbol) { // Prepare args var namespaceDot = string.IsNullOrWhiteSpace(@namespace) ? string.Empty : @namespace + "."; var conditionalSymbols = conditionalSymbol?.Split(',') ?? Array.Empty <string>(); // Generator Start... var sw = Stopwatch.StartNew(); logger("Project Compilation Start:" + input); var collector = new MethodCollector(input, conditionalSymbols, logger); logger("Project Compilation Complete:" + sw.Elapsed.ToString()); sw.Restart(); logger("Method Collect Start"); var definitions = collector.CollectServiceInterface(); var hubDefinitions = collector.CollectHubInterface(); GenericSerializationInfo[] genericInfos; EnumSerializationInfo[] enumInfos; ExtractResolverInfo(definitions, out genericInfos, out enumInfos); ExtractResolverInfo(hubDefinitions.Select(x => x.hubDefinition).ToArray(), out var genericInfos2, out var enumInfos2); ExtractResolverInfo(hubDefinitions.Select(x => x.receiverDefintion).ToArray(), out var genericInfos3, out var enumInfos3); enumInfos = enumInfos.Concat(enumInfos2).Concat(enumInfos3).Distinct().OrderBy(x => x.FullName).ToArray(); genericInfos = genericInfos.Concat(genericInfos2).Concat(genericInfos3).Distinct().OrderBy(x => x.FullName).ToArray(); logger("Method Collect Complete:" + sw.Elapsed.ToString()); logger("Output Generation Start"); sw.Restart(); var resolverTemplate = new ResolverTemplate() { Namespace = namespaceDot + "Resolvers", FormatterNamespace = namespaceDot + "Formatters", ResolverName = "MagicOnionResolver", registerInfos = genericInfos.OrderBy(x => x.FullName).Cast <IResolverRegisterInfo>().Concat(enumInfos.OrderBy(x => x.FullName)).ToArray() }; var registerTemplate = new RegisterTemplate { Namespace = @namespace, Interfaces = definitions.Where(x => x.IsServiceDefinition).ToArray(), HubInterfaces = hubDefinitions, UnuseUnityAttribute = unuseUnityAttr }; if (Path.GetExtension(output) == ".cs") { var enumTemplates = enumInfos.GroupBy(x => x.Namespace) .OrderBy(x => x.Key) .Select(x => new EnumTemplate() { Namespace = namespaceDot + "Formatters", enumSerializationInfos = x.ToArray() }) .ToArray(); var texts = definitions .GroupBy(x => x.Namespace) .OrderBy(x => x.Key) .Select(x => new CodeTemplate() { Namespace = x.Key, Interfaces = x.ToArray() }) .ToArray(); var hubTexts = hubDefinitions .GroupBy(x => x.hubDefinition.Namespace) .OrderBy(x => x.Key) .Select(x => new HubTemplate() { Namespace = x.Key, Interfaces = x.ToArray() }) .ToArray(); var sb = new StringBuilder(); sb.AppendLine("// <auto-generated />"); sb.AppendLine(registerTemplate.TransformText()); sb.AppendLine(resolverTemplate.TransformText()); foreach (var item in enumTemplates) { sb.AppendLine(item.TransformText()); } foreach (var item in texts) { sb.AppendLine(item.TransformText()); } foreach (var item in hubTexts) { sb.AppendLine(item.TransformText()); } Output(output, sb.ToString()); } else { Output(NormalizePath(output, registerTemplate.Namespace, "MagicOnionInitializer"), WithAutoGenerated(registerTemplate.TransformText())); Output(NormalizePath(output, resolverTemplate.Namespace, resolverTemplate.ResolverName), WithAutoGenerated(resolverTemplate.TransformText())); foreach (var enumTemplate in enumInfos) { var x = new EnumTemplate() { Namespace = namespaceDot + "Formatters", enumSerializationInfos = new[] { enumTemplate } }; Output(NormalizePath(output, x.Namespace, enumTemplate.Name + "Formatter"), WithAutoGenerated(x.TransformText())); } foreach (var serviceClient in definitions) { var x = new CodeTemplate() { Namespace = serviceClient.Namespace, Interfaces = new[] { serviceClient } }; Output(NormalizePath(output, serviceClient.Namespace, serviceClient.ClientName), WithAutoGenerated(x.TransformText())); } foreach (var hub in hubDefinitions) { var x = new HubTemplate() { Namespace = hub.hubDefinition.Namespace, Interfaces = new[] { hub } }; Output(NormalizePath(output, hub.hubDefinition.Namespace, hub.hubDefinition.ClientName), WithAutoGenerated(x.TransformText())); } } if (definitions.Length == 0 && hubDefinitions.Length == 0) { logger("Generated result is empty, unexpected result?"); } logger("Output Generation Complete:" + sw.Elapsed.ToString()); }
/// <summary> /// Generates Ruby code for Azure service client. /// </summary> /// <param name="cm">The code model.</param> /// <returns>Async tasks which generates SDK files.</returns> public override async Task Generate(CodeModel cm) { var codeModel = cm as CodeModelRba; if (codeModel == null) { throw new InvalidCastException("CodeModel is not a Azure Ruby code model."); } // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = codeModel }; await Write(serviceClientTemplate, Path.Combine(GeneratorSettingsRba.Instance.sdkPath, CodeNamer.UnderscoreCase(codeModel.Name) + ImplementationFileExtension)); // Operations foreach (MethodGroupRba group in codeModel.Operations.Where(each => !each.IsCodeModelMethodGroup)) { // Operation var operationsTemplate = new AzureMethodGroupTemplate { Model = group }; await Write(operationsTemplate, Path.Combine(GeneratorSettingsRba.Instance.sdkPath, CodeNamer.UnderscoreCase(operationsTemplate.Model.TypeName) + ImplementationFileExtension)); } // Models foreach (CompositeTypeRba model in codeModel.ModelTypes) { if ((model.Extensions.ContainsKey(AzureExtensions.ExternalExtension) && (bool)model.Extensions[AzureExtensions.ExternalExtension]) || model.Name == "Resource" || model.Name == "SubResource") { continue; } if( codeModel.pageModels.Any( each => each.Name.EqualsIgnoreCase(model.Name ) ) ) { // Skip, handled in the .pageModels section below. continue; } var modelTemplate = new ModelTemplate { Model = model }; await Write(modelTemplate, Path.Combine(GeneratorSettingsRb.Instance.modelsPath, CodeNamer.UnderscoreCase(model.Name) + ImplementationFileExtension)); } // Paged Models foreach (var pageModel in codeModel.pageModels) { var pageTemplate = new PageModelTemplate { Model = pageModel }; await Write(pageTemplate, Path.Combine(GeneratorSettingsRb.Instance.modelsPath, CodeNamer.UnderscoreCase(pageModel.Name) + ImplementationFileExtension)); } // Enums foreach (EnumTypeRb enumType in codeModel.EnumTypes) { var enumTemplate = new EnumTemplate { Model = enumType }; await Write(enumTemplate, Path.Combine(GeneratorSettingsRb.Instance.modelsPath, CodeNamer.UnderscoreCase(enumTemplate.Model.Name) + ImplementationFileExtension)); } // Requirements var requirementsTemplate = new RequirementsTemplate{Model = new RequirementsRba(codeModel, this)}; await Write(requirementsTemplate, CodeNamer.UnderscoreCase(GeneratorSettingsRb.Instance.packageName ?? GeneratorSettingsRb.Instance.sdkName) + ImplementationFileExtension); // Version File if (GeneratorSettingsRb.Instance.packageVersion != null) { var versionTemplate = new VersionTemplate { Model = GeneratorSettingsRb.Instance.packageVersion }; await Write(versionTemplate, Path.Combine(GeneratorSettingsRb.Instance.sdkPath, "version" + ImplementationFileExtension)); } // Module Definition File if (Settings.Instance.Namespace != null) { var modTemplate = new ModuleDefinitionTemplate { Model = GeneratorSettingsRb.Instance.ModuleDeclarations }; await Write(modTemplate, Path.Combine(GeneratorSettingsRb.Instance.sdkPath, "module_definition" + ImplementationFileExtension)); } }
/// <summary> /// Generates C# code for service client. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(ServiceClient serviceClient) { // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = new ServiceClientTemplateModel(serviceClient), }; await Write(serviceClientTemplate, RubyCodeNamer.UnderscoreCase(serviceClient.Name) + ImplementationFileExtension); // Method groups foreach (var group in serviceClient.MethodGroups) { var groupTemplate = new MethodGroupTemplate { Model = new MethodGroupTemplateModel(serviceClient, group), }; await Write(groupTemplate, RubyCodeNamer.UnderscoreCase(group) + ImplementationFileExtension); } // Models foreach (var model in serviceClient.ModelTypes) { var modelTemplate = new ModelTemplate { Model = new ModelTemplateModel(model, serviceClient), }; await Write(modelTemplate, Path.Combine("models", RubyCodeNamer.UnderscoreCase(model.Name) + ImplementationFileExtension)); } // Enums foreach (var enumType in serviceClient.EnumTypes) { var enumTemplate = new EnumTemplate { Model = new EnumTemplateModel(enumType), }; await Write(enumTemplate, Path.Combine("models", RubyCodeNamer.UnderscoreCase(enumTemplate.Model.TypeDefinitionName) + ImplementationFileExtension)); } // Requirements var requirementsTemplate = new RequirementsTemplate { Model = new RequirementsTemplateModel(serviceClient), }; await Write(requirementsTemplate, RubyCodeNamer.UnderscoreCase("sdk_requirements") + ImplementationFileExtension); }
/// <summary> /// Generates C# code for service client. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(CodeModel cm) { var packagePath = $"src/main/java/{Settings.Instance.Namespace.ToLower().Replace('.', '/')}"; // get Azure Java specific codeModel var codeModel = cm as CodeModelJvaf; if (codeModel == null) { throw new InvalidCastException("CodeModel is not a Azure Java Fluent CodeModel"); } SegmentFluentMethodGroups innerMGroupToFluentMGroup = null; if (true == AutoRest.Core.Settings.Instance.Host?.GetValue <bool?>("generate-interface").Result) { var idParsingUtilsTemplate = new IdParsingUtilsTemplate { Model = codeModel }; await Write(idParsingUtilsTemplate, $"{packagePath}/implementation/IdParsingUtils{ImplementationFileExtension}"); innerMGroupToFluentMGroup = SegmentFluentMethodGroups.InnerMethodGroupToSegmentFluentMethodGroups(codeModel); #region Produce all method group interfaces // foreach (IFluentMethodGroup group in innerMGroupToFluentMGroup.Select(m => m.Value.PrunedMethodGroup)) { var methodGroupInterfaceTemplate = new FluentMethodGroupInterfaceTemplate { Model = new ClientFluentMethodGroupInterface(group) }; await Write(methodGroupInterfaceTemplate, $"{packagePath}/{group.JavaInterfaceName.ToPascalCase()}{ImplementationFileExtension}"); } // #endregion #region Produce all method group implementation // innerMGroupToFluentMGroup.Select(m => m.Value).ForEach(async list => { var prunedGroup = list.PrunedMethodGroup; if (prunedGroup.Type == MethodGroupType.GroupableTopLevel) { ClientFluentGroupableMethodGroupImpl groupImplModel = new ClientFluentGroupableMethodGroupImpl(prunedGroup); var groupImplTemplate = new GroupableMethodGroupImplTemplate { Model = groupImplModel }; await Write(groupImplTemplate, $"{packagePath}/implementation/{groupImplModel.JavaClassName.ToPascalCase()}{ImplementationFileExtension}"); } else if (prunedGroup.Type == MethodGroupType.NonGroupableTopLevel) { ClientFluentNonGroupableTopLevelMethodGroupImpl groupImplModel = new ClientFluentNonGroupableTopLevelMethodGroupImpl(prunedGroup); var groupImplTemplate = new NonGroupableTopLevelMethodGroupImplTemplate { Model = groupImplModel }; await Write(groupImplTemplate, $"{packagePath}/implementation/{groupImplModel.JavaClassName.ToPascalCase()}{ImplementationFileExtension}"); } else if (prunedGroup.Type == MethodGroupType.Nested) { ClientFluentNestedMethodGroupImpl groupImplModel = new ClientFluentNestedMethodGroupImpl(prunedGroup); var groupImplTemplate = new NestedMethodGroupImplTemplate { Model = groupImplModel }; await Write(groupImplTemplate, $"{packagePath}/implementation/{groupImplModel.JavaClassName.ToPascalCase()}{ImplementationFileExtension}"); } else if (prunedGroup.Type == MethodGroupType.ActionsOnly) { var groupImplModel = new ClientFluentActionsOnlyMethodGroupImpl(prunedGroup); var groupImplTemplate = new ActionsOnlyMethodGroupImplTemplate { Model = groupImplModel }; await Write(groupImplTemplate, $"{packagePath}/implementation/{groupImplModel.JavaClassName.ToPascalCase()}{ImplementationFileExtension}"); } }); // #endregion #region Produce readonly model interface & impl // foreach (ClientFluentReadOnlyModelInterface fluentModel in innerMGroupToFluentMGroup.ReadonlyFluentModels) { var modelInterfaceTemplate = new ReadOnlyModelInterfaceTemplate { Model = fluentModel }; await Write(modelInterfaceTemplate, $"{packagePath}/{fluentModel.JavaInterfaceName.ToPascalCase()}{ImplementationFileExtension}"); // var modelImplTemplate = new ReadOnlyModelImplTemplate { Model = fluentModel.Impl }; await Write(modelImplTemplate, $"{packagePath}/implementation/{fluentModel.Impl.JavaClassName.ToPascalCase()}{ImplementationFileExtension}"); // No specific method group for readonly models these models are shared between other type of method groups [Groupable, no-Groupable-top-level and nested] } #endregion #region Produce nested model interface & impl // foreach (ClientFluentNestedModelInterface fluentModel in innerMGroupToFluentMGroup.NestedFluentModels) { var modelInterfaceTemplate = new NestedModelInterfaceTemplate { Model = fluentModel }; await Write(modelInterfaceTemplate, $"{packagePath}/{fluentModel.JavaInterfaceName.ToPascalCase()}{ImplementationFileExtension}"); // var modelImplTemplate = new NestedModelImplTemplate { Model = fluentModel.Impl }; await Write(modelImplTemplate, $"{packagePath}/implementation/{fluentModel.Impl.JavaClassName.ToPascalCase()}{ImplementationFileExtension}"); } #endregion #region Produce groupable model interface & impl // foreach (ClientFluentGroupableModelInterface fluentModel in innerMGroupToFluentMGroup.GroupableFluentModels) { var modelInterfaceTemplate = new GroupableModelInterfaceTemplate { Model = fluentModel }; await Write(modelInterfaceTemplate, $"{packagePath}/{fluentModel.JavaInterfaceName.ToPascalCase()}{ImplementationFileExtension}"); var modelImplTemplate = new GroupableModelImplTemplate { Model = fluentModel.Impl }; await Write(modelImplTemplate, $"{packagePath}/implementation/{fluentModel.Impl.JavaClassName.ToPascalCase()}{ImplementationFileExtension}"); } #endregion #region Produce non-groupable top-level model interface & impl foreach (ClientFluentNonGroupableTopLevelModelInterface fluentModel in innerMGroupToFluentMGroup.NonGroupableTopLevelFluentModels) { var modelInterfaceTemplate = new NonGroupableTopLevelModelInterfaceTemplate { Model = fluentModel }; await Write(modelInterfaceTemplate, $"{packagePath}/{fluentModel.JavaInterfaceName.ToPascalCase()}{ImplementationFileExtension}"); var modelImplTemplate = new NonGroupableTopLevelModelImplTemplate { Model = fluentModel.Impl }; await Write(modelImplTemplate, $"{packagePath}/implementation/{fluentModel.Impl.JavaClassName.ToPascalCase()}{ImplementationFileExtension}"); } #endregion if (true == AutoRest.Core.Settings.Instance.Host?.GetValue <bool?>("generate-test").Result) { var packageTestPath = $"src/test/java/{Settings.Instance.Namespace.ToLower().Replace('.', '/')}"; var testModel = new TestModel(codeModel); await Write(new TestTemplate { Model = testModel }, $"{packageTestPath}/{testModel.ClassName}Test{ImplementationFileExtension}"); } } // Service client var serviceClientTemplate = new AzureServiceClientTemplate { Model = codeModel }; await Write(serviceClientTemplate, $"{packagePath}/implementation/{codeModel.Name.ToPascalCase()}Impl{ImplementationFileExtension}"); // operations foreach (MethodGroupJvaf methodGroup in codeModel.AllOperations) { // Operation var operationsTemplate = new AzureMethodGroupTemplate { Model = methodGroup }; await Write(operationsTemplate, $"{packagePath}/implementation/{methodGroup.TypeName.ToPascalCase()}Inner{ImplementationFileExtension}"); } //Models foreach (CompositeTypeJvaf modelType in cm.ModelTypes.Concat(codeModel.HeaderTypes)) { if (modelType.Extensions.ContainsKey(AzureExtensions.ExternalExtension) && (bool)modelType.Extensions[AzureExtensions.ExternalExtension]) { continue; } if (modelType.IsResource) { continue; } var modelTemplate = new ModelTemplate { Model = modelType }; await Write(modelTemplate, $"{packagePath}/{modelType.ModelsPackage.Trim('.')}/{modelType.Name.ToPascalCase()}{ImplementationFileExtension}"); } //Enums foreach (EnumTypeJvaf enumType in cm.EnumTypes) { var enumTemplate = new EnumTemplate { Model = enumType }; await Write(enumTemplate, $"{packagePath}/{enumType.ModelsPackage.Trim('.')}/{enumTemplate.Model.Name.ToPascalCase()}{ImplementationFileExtension}"); } // Page class foreach (var pageClass in codeModel.pageClasses) { var pageTemplate = new PageTemplate { Model = new PageJvaf(pageClass.Value, pageClass.Key.Key, pageClass.Key.Value), }; await Write(pageTemplate, $"{packagePath}/implementation/{pageTemplate.Model.TypeDefinitionName.ToPascalCase()}{ImplementationFileExtension}"); } // Exceptions foreach (CompositeTypeJv exceptionType in codeModel.ErrorTypes) { if (exceptionType.Name == "CloudError") { continue; } var exceptionTemplate = new ExceptionTemplate { Model = exceptionType }; await Write(exceptionTemplate, $"{packagePath}/{exceptionType.ModelsPackage.Trim('.')}/{exceptionTemplate.Model.ExceptionTypeDefinitionName}{ImplementationFileExtension}"); } // package-info.java await Write(new PackageInfoTemplate { Model = new PackageInfoTemplateModel(cm) }, $"{packagePath}/{_packageInfoFileName}"); await Write(new PackageInfoTemplate { Model = new PackageInfoTemplateModel(cm, "implementation") }, $"{packagePath}/implementation/{_packageInfoFileName}"); if (true == AutoRest.Core.Settings.Instance.Host?.GetValue <bool?>("regenerate-manager").Result) { ServiceManagerModel serviceManagerModel = new ServiceManagerModel(codeModel, innerMGroupToFluentMGroup); // Manager await Write( new AzureFluentServiceManagerTemplate { Model = serviceManagerModel }, $"{packagePath}/implementation/{serviceManagerModel.ManagerName}{ImplementationFileExtension}"); // POM await Write(new AzureFluentPomTemplate { Model = codeModel }, "pom.xml"); } }
public async Task GenerateFileAsync( string input, string output, string conditionalSymbol, string resolverName, string @namespace, bool useMapMode, string multipleIfDirectiveOutputSymbols) { var namespaceDot = string.IsNullOrWhiteSpace(@namespace) ? string.Empty : @namespace + "."; var conditionalSymbols = conditionalSymbol?.Split(',') ?? Array.Empty <string>(); var multipleOutputSymbols = multipleIfDirectiveOutputSymbols?.Split(',') ?? Array.Empty <string>(); var sw = Stopwatch.StartNew(); foreach (var multioutSymbol in multipleOutputSymbols.Length == 0 ? new[] { string.Empty } : multipleOutputSymbols) { logger("Project Compilation Start:" + input); var compilation = (Path.GetExtension(input) == ".csproj") ? await MessagePackCompilation.CreateFromProjectAsync(input.Split(','), conditionalSymbols.Concat(new[] { multioutSymbol }).ToArray(), cancellationToken) .ConfigureAwait(false) : await MessagePackCompilation.CreateFromDirectoryAsync(input, conditionalSymbols.Concat(new[] { multioutSymbol }).ToArray(), cancellationToken).ConfigureAwait(false); var collector = new TypeCollector(compilation, true, useMapMode, x => Console.WriteLine(x)); logger("Project Compilation Complete:" + sw.Elapsed.ToString()); sw.Restart(); logger("Method Collect Start"); var(objectInfo, enumInfo, genericInfo, unionInfo) = collector.Collect(); logger("Method Collect Complete:" + sw.Elapsed.ToString()); logger("Output Generation Start"); sw.Restart(); if (Path.GetExtension(output) == ".cs") { // SingleFile Output var objectFormatterTemplates = objectInfo .GroupBy(x => x.Namespace) .Select(x => new FormatterTemplate() { Namespace = namespaceDot + "Formatters" + ((x.Key == null) ? string.Empty : "." + x.Key), ObjectSerializationInfos = x.ToArray(), }) .ToArray(); var enumFormatterTemplates = enumInfo .GroupBy(x => x.Namespace) .Select(x => new EnumTemplate() { Namespace = namespaceDot + "Formatters" + ((x.Key == null) ? string.Empty : "." + x.Key), EnumSerializationInfos = x.ToArray(), }) .ToArray(); var unionFormatterTemplates = unionInfo .GroupBy(x => x.Namespace) .Select(x => new UnionTemplate() { Namespace = namespaceDot + "Formatters" + ((x.Key == null) ? string.Empty : "." + x.Key), UnionSerializationInfos = x.ToArray(), }) .ToArray(); var resolverTemplate = new ResolverTemplate() { Namespace = namespaceDot + "Resolvers", FormatterNamespace = namespaceDot + "Formatters", ResolverName = resolverName, RegisterInfos = genericInfo.Cast <IResolverRegisterInfo>().Concat(enumInfo).Concat(unionInfo).Concat(objectInfo).ToArray(), }; var sb = new StringBuilder(); sb.AppendLine(resolverTemplate.TransformText()); sb.AppendLine(); foreach (var item in enumFormatterTemplates) { var text = item.TransformText(); sb.AppendLine(text); } sb.AppendLine(); foreach (var item in unionFormatterTemplates) { var text = item.TransformText(); sb.AppendLine(text); } sb.AppendLine(); foreach (var item in objectFormatterTemplates) { var text = item.TransformText(); sb.AppendLine(text); } if (multioutSymbol == string.Empty) { await OutputAsync(output, sb.ToString(), cancellationToken).ConfigureAwait(false); } else { var fname = Path.GetFileNameWithoutExtension(output) + "." + MultiSymbolToSafeFilePath(multioutSymbol) + ".cs"; var text = $"#if {multioutSymbol}" + Environment.NewLine + sb.ToString() + Environment.NewLine + "#endif"; await OutputAsync(Path.Combine(Path.GetDirectoryName(output), fname), text, cancellationToken).ConfigureAwait(false); } } else { // Multiple File output foreach (var x in objectInfo) { var template = new FormatterTemplate() { Namespace = namespaceDot + "Formatters" + ((x.Namespace == null) ? string.Empty : "." + x.Namespace), ObjectSerializationInfos = new[] { x }, }; var text = template.TransformText(); await OutputToDirAsync(output, template.Namespace, x.Name + "Formatter", multioutSymbol, text, cancellationToken).ConfigureAwait(false); } foreach (var x in enumInfo) { var template = new EnumTemplate() { Namespace = namespaceDot + "Formatters" + ((x.Namespace == null) ? string.Empty : "." + x.Namespace), EnumSerializationInfos = new[] { x }, }; var text = template.TransformText(); await OutputToDirAsync(output, template.Namespace, x.Name + "Formatter", multioutSymbol, text, cancellationToken).ConfigureAwait(false); } foreach (var x in unionInfo) { var template = new UnionTemplate() { Namespace = namespaceDot + "Formatters" + ((x.Namespace == null) ? string.Empty : "." + x.Namespace), UnionSerializationInfos = new[] { x }, }; var text = template.TransformText(); await OutputToDirAsync(output, template.Namespace, x.Name + "Formatter", multioutSymbol, text, cancellationToken).ConfigureAwait(false); } var resolverTemplate = new ResolverTemplate() { Namespace = namespaceDot + "Resolvers", FormatterNamespace = namespaceDot + "Formatters", ResolverName = resolverName, RegisterInfos = genericInfo.Cast <IResolverRegisterInfo>().Concat(enumInfo).Concat(unionInfo).Concat(objectInfo).ToArray(), }; await OutputToDirAsync(output, resolverTemplate.Namespace, resolverTemplate.ResolverName, multioutSymbol, resolverTemplate.TransformText(), cancellationToken).ConfigureAwait(false); } } logger("Output Generation Complete:" + sw.Elapsed.ToString()); }
/// <summary> /// Generates C# code for service client. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(CodeModel cm) { // get Azure Java specific codeModel var codeModel = cm as CodeModelJvaf; if (codeModel == null) { throw new InvalidCastException("CodeModel is not a Azure Java Fluent CodeModel"); } // Service client var serviceClientTemplate = new AzureServiceClientTemplate { Model = codeModel }; await Write(serviceClientTemplate, $"{Path.Combine("implementation", codeModel.Name.ToPascalCase() + "Impl")}{ImplementationFileExtension}"); // operations foreach (MethodGroupJvaf methodGroup in codeModel.AllOperations) { // Operation var operationsTemplate = new AzureMethodGroupTemplate { Model = methodGroup }; await Write(operationsTemplate, $"{Path.Combine("implementation", methodGroup.TypeName.ToPascalCase())}Inner{ImplementationFileExtension}"); } //Models foreach (CompositeTypeJvaf modelType in cm.ModelTypes.Concat(codeModel.HeaderTypes)) { if (modelType.Extensions.ContainsKey(AzureExtensions.ExternalExtension) && (bool)modelType.Extensions[AzureExtensions.ExternalExtension]) { continue; } if (modelType.IsResource) { continue; } var modelTemplate = new ModelTemplate { Model = modelType }; await Write(modelTemplate, Path.Combine(modelType.ModelsPackage.Trim('.'), $"{modelType.Name.ToPascalCase()}{ImplementationFileExtension}")); } //Enums foreach (EnumTypeJvaf enumType in cm.EnumTypes) { var enumTemplate = new EnumTemplate { Model = enumType }; await Write(enumTemplate, Path.Combine(enumType.ModelsPackage.Trim('.'), $"{enumTemplate.Model.Name.ToPascalCase()}{ImplementationFileExtension}")); } // Page class foreach (var pageClass in codeModel.pageClasses) { var pageTemplate = new PageTemplate { Model = new PageJvaf(pageClass.Value, pageClass.Key.Key, pageClass.Key.Value), }; await Write(pageTemplate, Path.Combine("implementation", $"{pageTemplate.Model.TypeDefinitionName.ToPascalCase()}{ImplementationFileExtension}")); } // Exceptions foreach (CompositeTypeJv exceptionType in codeModel.ErrorTypes) { if (exceptionType.Name == "CloudError") { continue; } var exceptionTemplate = new ExceptionTemplate { Model = exceptionType }; await Write(exceptionTemplate, Path.Combine(exceptionType.ModelsPackage.Trim('.'), $"{exceptionTemplate.Model.ExceptionTypeDefinitionName}{ImplementationFileExtension}")); } // package-info.java await Write(new PackageInfoTemplate { Model = new PackageInfoTemplateModel(cm) }, _packageInfoFileName); await Write(new PackageInfoTemplate { Model = new PackageInfoTemplateModel(cm, "implementation") }, Path.Combine("implementation", _packageInfoFileName)); }
/// <summary> /// Generates C# code for service client. /// </summary> /// <param name="cm"></param> /// <returns></returns> public override async Task Generate(CodeModel cm) { var codeModel = cm as CodeModelCsa; if (codeModel == null) { throw new InvalidCastException("CodeModel is not a Azure c# CodeModel"); } // Service client var serviceClientTemplate = new AzureServiceClientTemplate { Model = codeModel }; await Write(serviceClientTemplate, $"{codeModel.Name}{ImplementationFileExtension}"); // Service client interface var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate { Model = codeModel }; await Write(serviceClientInterfaceTemplate, "I" + codeModel.Name + ImplementationFileExtension); // Operations foreach (MethodGroupCs group in codeModel.Operations) { if (!group.IsCodeModelMethodGroup) { // Operation var operationsTemplate = new AzureMethodGroupTemplate { Model = group }; await Write(operationsTemplate, operationsTemplate.Model.TypeName + ImplementationFileExtension); // Operation interface var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate { Model = group }; await Write(operationsInterfaceTemplate, $"I{operationsInterfaceTemplate.Model.TypeName}{ImplementationFileExtension}"); } var operationExtensionsTemplate = new ExtensionsTemplate { Model = group }; await Write(operationExtensionsTemplate, $"{group.ExtensionTypeName}Extensions{ImplementationFileExtension}"); } // Models foreach (CompositeTypeCs model in codeModel.ModelTypes.Concat(codeModel.HeaderTypes)) { if (model.Extensions.ContainsKey(AzureExtensions.ExternalExtension) && (bool)model.Extensions[AzureExtensions.ExternalExtension]) { continue; } if (model.IsResource()) { continue; } var modelTemplate = new ModelTemplate { Model = model }; await Write(modelTemplate, Path.Combine(Settings.Instance.ModelsName, $"{model.Name}{ImplementationFileExtension}")); } // Enums foreach (EnumTypeCs enumType in codeModel.EnumTypes) { var enumTemplate = new EnumTemplate { Model = enumType }; await Write(enumTemplate, Path.Combine(Settings.Instance.ModelsName, $"{enumTemplate.Model.Name}{ImplementationFileExtension}")); } // Page class foreach (var pageClass in codeModel.pageClasses) { var pageTemplate = new PageTemplate { Model = new Page(pageClass.Value, pageClass.Key.Key, pageClass.Key.Value) }; await Write(pageTemplate, Path.Combine(Settings.Instance.ModelsName, $"{pageTemplate.Model.TypeDefinitionName}{ImplementationFileExtension}")); } // Exceptions foreach (CompositeTypeCs exceptionType in codeModel.ErrorTypes) { if (exceptionType.Name == "CloudError") { continue; } var exceptionTemplate = new ExceptionTemplate { Model = exceptionType }; await Write(exceptionTemplate, Path.Combine(Settings.Instance.ModelsName, $"{exceptionTemplate.Model.ExceptionTypeDefinitionName}{ImplementationFileExtension}")); } }