public void TestNamespaceGenerationWithManyTypes() { // arrange var blog = new CSharpClass { Name = "Blog" }; var post = new CSharpClass { Name = "Post" }; var csharpNamespace = new CSharpNamespace { Name = "SuperBlogger", Types = new List <CSharpType> { blog, post } }; var output = new StringWriter(); var expectedOutputWriter = new StringWriter(); expectedOutputWriter.WriteLine("namespace SuperBlogger"); expectedOutputWriter.WriteLine("{"); blog.Generate(expectedOutputWriter); expectedOutputWriter.WriteLine(); post.Generate(expectedOutputWriter); expectedOutputWriter.WriteLine("}"); // act csharpNamespace.Generate(output); // assert Assert.Equal(expectedOutputWriter.ToString(), output.ToString()); }
/// <summary> /// Initializes a new instance of the <see cref="ClassGenerator"/> class for the specified <see cref="IndentedStreamWriter"/> /// </summary> /// <param name="class"><see cref="CSharpClass"/> to generate</param> /// <param name="writer"><see cref="IndentedStreamWriter"/> used to write to</param> public ClassGenerator(CSharpClass @class, IndentedStreamWriter writer) : base(writer) { _class = @class; _usingGenerator = new UsingGenerator(_class.Usings, writer); _namespaceGenerator = new NamespaceGenerator(_class.Namespace, writer); _classDefinitionGenerator = new ClassDefinitionGenerator(_class, writer); }
public async Task <CSharpClass> GenerateClassCode(Table table = null) { Table tableToUse = null; try { if ((string.IsNullOrEmpty(SelectedTable?.TableName) && table == null) || StaticElements.DB == null) { return(null); } else if (table != null) { tableToUse = table; } else { tableToUse = SelectedTable; } var columns = await Column.GetAsync(StaticElements.DB, tableToUse.TableSchema, tableToUse.TableName); var classBuilder = new CSharpClass(tableToUse, columns, FullyAsyncReading); ClassCode = classBuilder.ToString(Namespace); return(classBuilder); } catch (Exception ex) { Console.WriteLine(ex); } return(null); }
public void TestGenerateClassWithMembers() { // arrange var idMember = new CSharpClassMember { Name = "Id", Type = "int" }; var descriptionMembers = new CSharpClassMember { Name = "Description", Type = "string" }; var csharpClass = new CSharpClass { Name = "Blog", Members = new List <CSharpClassMember> { idMember, descriptionMembers } }; var output = new StringWriter(); var expectedOutputWriter = new StringWriter(); expectedOutputWriter.Write(" public class Blog" + Environment.NewLine); expectedOutputWriter.Write(" {" + Environment.NewLine); idMember.Generate(expectedOutputWriter); expectedOutputWriter.WriteLine(); descriptionMembers.Generate(expectedOutputWriter); expectedOutputWriter.Write(" }" + Environment.NewLine); // act csharpClass.Generate(output); // assert var generatedOutput = output.GetStringBuilder().ToString(); Assert.Equal(expectedOutputWriter.GetStringBuilder().ToString(), generatedOutput); }
public void ShouldEvaluateDecorationWithAttributesForAllMethodsThatMatchInclusionPattern() { //GIVEN var report = Any.Instance <IAnalysisReportInProgress>(); var methodNameInclusionPattern = Any.Pattern(); var description = Any.Instance <RuleDescription>(); var method1 = Substitute.For <ICSharpMethod>(); var method2 = Substitute.For <ICSharpMethod>(); var method3 = Substitute.For <ICSharpMethod>(); var methods = new [] { method1, method2, method3 }; var declaration = Any.Instance <ClassDeclarationInfo>(); var @class = new CSharpClass(declaration, methods); method1.NameMatches(methodNameInclusionPattern).Returns(true); method2.NameMatches(methodNameInclusionPattern).Returns(false); method3.NameMatches(methodNameInclusionPattern).Returns(true); //WHEN @class.EvaluateDecorationWithAttributes(report, methodNameInclusionPattern, description); //THEN method1.Received(1).EvaluateMethodsHavingCorrectAttributes(report, declaration.Name, description); method2.DidNotReceive().EvaluateMethodsHavingCorrectAttributes( Arg.Any <IAnalysisReportInProgress>(), Arg.Any <string>(), Arg.Any <RuleDescription>()); method3.Received(1).EvaluateMethodsHavingCorrectAttributes(report, declaration.Name, description); }
public void GeneratesCorrectDom() { var generator = new Generator(new NamingConvention("MyNamespace")); var generated = generator.Generate(Sample.Endpoints, Sample.Doc.Components.Schemas); var noteDto = Dto("Note"); var noteEndpoint = ElementEndpoint(noteDto); var contactDto = Dto("Contact"); var contactEndpointInterface = new CSharpInterface(new CSharpIdentifier("MyNamespace", "IContactEndpoint")) { Interfaces = { ElementEndpoint(contactDto).ToInterface() }, Properties = { Property("Note", "./note", noteEndpoint, description: "The note for a specific contact."), Property("Poke", "./poke", ActionEndpoint, description: "Pokes a contact."), Property("Picture", "./picture", BlobEndpoint, description: "A picture of a specific contact.") }, Description = "A specific contact." }; var contactEndpoint = new CSharpClass(new CSharpIdentifier("MyNamespace", "ContactEndpoint")) { BaseClass = new CSharpClassConstruction(ElementEndpoint(contactDto)) { Parameters = { Referrer, new CSharpParameter(CSharpIdentifier.Uri, "relativeUri") } }, Interfaces = { contactEndpointInterface.Identifier }, Description = contactEndpointInterface.Description }; contactEndpoint.Properties.AddRange(contactEndpointInterface.Properties); var collectionEndpoint = CollectionEndpoint(contactDto, contactEndpoint.Identifier); var entryEndpoint = new CSharpClass(new CSharpIdentifier("MyNamespace", "MyEntryEndpoint")) { BaseClass = new CSharpClassConstruction(new CSharpIdentifier("TypedRest.Endpoints", "EntryEndpoint")) { Parameters = { new CSharpParameter(CSharpIdentifier.Uri, "uri") } }, Properties = { Property("Contacts", "./contacts", collectionEndpoint, CollectionEndpoint(contactDto, contactEndpointInterface.Identifier).ToInterface(), description: "Collection of contacts.") } }; generated.Should().BeEquivalentTo( contactDto, noteDto, entryEndpoint, contactEndpointInterface, contactEndpoint); }
private static Member GetForeignKeyMember(CSharpClass type, string otherTypeName) { // give preference to Property over Field var fk = type.Operations.OfType <CSharpProperty>().SingleOrDefault(op => op.Name.ToLowerInvariant() == $"{otherTypeName.ToLowerInvariant()}id") as Member ?? type.Fields.OfType <CSharpField>().SingleOrDefault(field => field.Name.ToLowerInvariant() == $"{otherTypeName.ToLowerInvariant()}id"); return(fk); }
int ParseArguments(String[] args) { bool help = false; var p = new OptionSet { { "h|?|help", "Show this help message", v => help = v != null }, { "o=|out=", "Set the output directory", v => OutputDir = v }, { "ns=|namespace=", "Set the namespace of the generated code", v => Lib.BaseNamespace = v }, { "lib=", "The base name of the C++ library, i.e. 'qt' for libqt.so", v => Lib.BaseName = v }, { "filters=", "A file containing filter directives for filtering classes", v => FilterFile = v }, { "inline=", "Inline methods in lib are: notpresent (default), present, surrogatelib (present in %lib%-inline)", v => Lib.InlinePolicy = (InlineMethods)Enum.Parse(typeof(InlineMethods), v, true) } }; try { args = p.Parse(args).ToArray(); } catch (OptionException) { Console.WriteLine("Try `generator --help' for more information."); return(1); } if (help) { p.WriteOptionDescriptions(Console.Error); return(1); } if (args.Length != 1) { Console.WriteLine("Usage: generator <options> <input xml file>"); return(1); } // Code templates LibsTemplate = new CSharpLibs(); ClassTemplate = new CSharpClass(); EnumTemplate = new CSharpEnum(); InputFileName = args [0]; if (Lib.BaseName == null) { Console.WriteLine("The --lib= option is required."); return(1); } if (Lib.BaseNamespace == null) { Lib.BaseNamespace = Path.GetFileNameWithoutExtension(Lib.BaseName); } if (OutputDir == null) { OutputDir = "output"; } return(0); }
private static void CreatePrimaryKey(StringBuilder sb, CSharpClass type) { var pk = GetPrimaryKeyMember(type); if (pk != null) { sb.AppendLine($"ALTER TABLE {type.Name} ADD CONSTRAINT {GetPrimaryKeyName(type)} PRIMARY KEY({pk.Name});"); } }
private static void DeleteLinkTable(StringBuilder sb, EntityRelationship link) { var linkTable = new CSharpClass { Name = $"{link.First.Name}_{link.Second.Name}" }; DeleteTable(sb, linkTable); }
/// <summary> /// Attach documentation to functions and create new functions from raw functions using Span<T> when possible. /// </summary> /// <param name="monocypher">The Monocypher static class containing all generated raw PInvoke functions.</param> private void ProcessInvokeFunctions(CSharpClass monocypher) { var sizeType = monocypher.Members.OfType <CSharpStruct>().First(x => x.Name == "size_t"); var indexOfSize = monocypher.Members.IndexOf(sizeType); // Embrace size_t only for NETSTANDARD_20, NET5.0 is using nint monocypher.Members.Insert(indexOfSize + 1, new CSharpFreeMember() { Text = "#endif" }); monocypher.Members.Insert(indexOfSize, new CSharpFreeMember() { Text = "#if NETSTANDARD2_0" }); var newMethods = new List <CSharpCustomMethod>(); // Loop on all raw PInvoke functions foreach (var function in monocypher.Members.OfType <CSharpMethod>()) { // Get the documentation _functionDocs.TryGetValue(function.Name, out var funcDoc); var fullComment = new CSharpFullComment(); var textComment = funcDoc?.Summary ?? new CSharpXmlComment("summary") { Children = { new CSharpTextComment($"Function {function.Name}") } }; fullComment.Children.Add(textComment); if (funcDoc != null) { foreach (var paramDesc in funcDoc.Parameters) { fullComment.Children.Add(paramDesc); } } function.Comment = fullComment; // Detect if we need to create a version of the function using Span: // - In case there is a fixed array parameter (e.g unsigned char mac[16]) Span<byte> of size 16 // - In case there is a tuple (void* ptr, intptr_t size) => Span<byte> of size length var extraParameters = new List <ParameterExtra>(); bool processFunction = false; foreach (var parameter in function.Parameters) { var kind = ParameterKind.Default; bool isReadOnly = false; if (parameter.ParameterType is CSharpRefType refType && refType.ElementType is CSharpArrayLikeType) { kind = ParameterKind.FixedBuffer; isReadOnly = refType.Kind == CSharpRefKind.In; processFunction = true; }
private bool CreateClasses(out IDictionary <IClass, ICSharpClass> classTable) { classTable = null; if (!ClassSplitting.Create(Compiler.LoadedRoot.ClassList, ErrorList, out IClassSplitting Splitting)) { return(false); } classTable = new Dictionary <IClass, ICSharpClass>(); ICSharpClass ClassAny = CSharpClass.Create(Class.ClassAny); classTable.Add(Class.ClassAny, ClassAny); ICSharpClass ClassAnyReference = CSharpClass.Create(Class.ClassAnyReference); classTable.Add(Class.ClassAnyReference, ClassAnyReference); ICSharpClass ClassAnyValue = CSharpClass.Create(Class.ClassAnyValue); classTable.Add(Class.ClassAnyValue, ClassAnyValue); foreach (IClass Class in Compiler.LoadedRoot.ClassList) { ICSharpClass NewCSharpClass = CSharpClass.Create(Class); classTable.Add(Class, NewCSharpClass); } foreach (KeyValuePair <IClass, ICSharpClass> Entry in classTable) { ICSharpClass Class = Entry.Value; if (GetBaseClass(Class, Splitting, classTable, out ICSharpClass BaseClass)) { Class.SetBaseClass(BaseClass); } Class.SetAncestorClasses(classTable); } foreach (KeyValuePair <IClass, ICSharpClass> Entry in classTable) { ICSharpClass Class = Entry.Value; CheckRename(Class, ErrorList); } if (!ErrorList.IsEmpty) { return(false); } return(true); }
public void ShouldBeAbleToSayWhetherItsNameMatchesAPattern(string pattern, string className, bool expectedResult) { //GIVEN var declaration = new ClassDeclarationInfo(className, Any.String()); var @class = new CSharpClass(declaration, Any.Array <ICSharpMethod>()); //WHEN var nameMatches = @class.NameMatches(Pattern.WithoutExclusion(pattern)); //THEN nameMatches.Should().Be(expectedResult); }
private CSharpClass GenerateEndpointImplementation(string key, IEndpoint endpoint, TypeList typeList, IList <CSharpProperty> children) { var builder = _builders[endpoint.GetType()]; var endpointImplementation = new CSharpClass(_naming.EndpointType(key, endpoint)) { BaseClass = builder.GetConstruction(endpoint, typeList), Description = endpoint.Description }; endpointImplementation.Properties.AddRange(children); typeList.Add(endpoint, endpointImplementation); return(endpointImplementation); }
private void AddMethods(Document doc, CSharpClass @class) { foreach (var method in @class.Methods) { doc.Add(new Field(Fields.Method, method.MethodName, Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS)); doc.Add(new Field(Fields.Return, method.ReturnType, Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS)); foreach (var parameter in method.Parameters) { doc.Add(new Field(Fields.Parameter, parameter, Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS)); } if (method.Body != null) { doc.Add(new Field(Fields.Code, method.Body, Field.Store.NO, Field.Index.ANALYZED)); } } }
private IEnumerable <CSharpClass> GetClasses(ContractDefinition contract, string implementationName, CSharpAccessModifier accessLevel) { Type baseClass = typeof(Receiver <>); CSharpClass @class = new CSharpClass( name: implementationName, accessModifier: accessLevel, properties: this.GetProperties(contract), constructors: this.GetConstructors(contract, implementationName), methods: this.GetMethods(contract), baseType: $"{baseClass.GetCSharpName(identifierOnly: true)}<{contract.FullName}>", documentationComment: !string.IsNullOrWhiteSpace(contract.Description) ? new CSharpDocumentationComment(summary: null, rawNotes: contract.Description) : null); yield return(@class); }
private IEnumerable <CSharpClass> GetClasses(ContractDefinition contract, string implementationName, CSharpAccessModifier accessLevel) { Type baseClass = typeof(Transmitter); CSharpClass @class = new CSharpClass( name: implementationName, accessModifier: accessLevel, constructors: this.GetConstructors(implementationName), methods: this.GetMethods(contract.Operations), baseType: baseClass.GetCSharpName(), interfaces: contract.FullName.SingleObjectAsEnumerable(), documentationComment: !string.IsNullOrWhiteSpace(contract.Description) ? new CSharpDocumentationComment(summary: null, rawNotes: contract.Description) : null); yield return(@class); }
public void GenerateBean(CSharpBeanConfig beanConfig) { initDefault(); //IRazorEngineCompiledTemplate template = razorEngine.Compile(templateContent);// "Hello @Model.Name"); beanConfig.DDLConfig.Prepare(); string beanRootDir = CodeUtil.PrepareCodeRoot(beanConfig.CodeDiretory, beanConfig.NamespacePath); string result = String.Empty; beanConfig.DDLConfig.Tables.ForEach(t => { result = beanTemplate.Run(instance => { beanConfig.Table = t; t.CreatedClass = CSharpClass.CreateEntityClass(t, beanConfig, true); instance.Model = t.CreatedClass as CSharpClass; }); Console.WriteLine(result); string filePath = beanRootDir + Path.DirectorySeparatorChar + t.CreatedClass.ClassName + ".java"; if (File.Exists(filePath)) { File.Delete(filePath); } File.WriteAllText(filePath, result, new UTF8Encoding(false)); //result = beanTemplate.Run(instance => //{ // instance.Model = t.CreatedClass.JavaVoClass; //}); //Console.WriteLine(result); //filePath = voRootDir + Path.DirectorySeparatorChar + t.CreatedClass.JavaVoClass.ClassName + ".java"; //if (File.Exists(filePath)) //{ // File.Delete(filePath); //} //File.WriteAllText(filePath, result, new UTF8Encoding(false)); }); }
private static CSharpClass ToCSharpClass(this ObjectFactoryCmdlet cmdlet) { if (cmdlet == null) { throw new ArgumentNullException(nameof(cmdlet)); } // Create the result object CSharpClass result = new CSharpClass($"{cmdlet.Name.Verb}_{cmdlet.Name.Noun}") { DocumentationComment = cmdlet.Documentation.ToCSharpDocumentationComment(), AccessModifier = CSharpAccessModifier.Public, BaseType = nameof(ObjectFactoryCmdletBase), Attributes = cmdlet.CreateAttributes(), Properties = cmdlet.CreateProperties(), }; return(result); }
public void TestGenerateClassWithNoMembers() { // arrange var csharpClass = new CSharpClass { Name = "Blog" }; var output = new StringWriter(); var expectedOutput = " public class Blog" + Environment.NewLine + " {" + Environment.NewLine + " }" + Environment.NewLine; // act csharpClass.Generate(output); // assert var generatedOutput = output.GetStringBuilder().ToString(); Assert.Equal(expectedOutput, generatedOutput); }
public void CSharpNamespaceCloneTest() { var parentPackage = new CSharpNamespace("parent"); var childPackage = new CSharpNamespace("child"); var classType1 = new CSharpClass("class1"); var classType2 = new CSharpClass("class2"); childPackage.AddNestedChild(classType1); childPackage.AddNestedChild(classType2); parentPackage.AddNestedChild(childPackage); var otherParent = parentPackage.Clone(true); var otherChild = (CSharpNamespace)parentPackage.NestedChilds.First(); otherParent.NestedChilds.Count().ShouldBe(1); otherParent.Name.ShouldBe(parentPackage.Name); otherChild.NestedChilds.Count().ShouldBe(2); otherChild.Name.ShouldBe(childPackage.Name); otherChild.NestedChilds.First().Name.ShouldBe(classType1.Name); otherChild.NestedChilds.Last().Name.ShouldBe(classType2.Name); }
private static void CreateTable(StringBuilder sb, CSharpClass type) { var pk = GetPrimaryKeyMember(type); sb.AppendLine($"CREATE TABLE {type.Name}"); sb.AppendLine($"("); foreach (var field in type.Fields.OfType <CSharpField>()) { var pkField = field.Name == pk?.Name ? "NOT NULL" : string.Empty; sb.AppendLine($" {field.Name} {NetToSqlTypeMap[field.Type.ToLowerInvariant()]} {pkField},"); } foreach (var op in type.Operations.OfType <CSharpProperty>()) { var pkOp = op.Name == pk?.Name ? "NOT NULL" : string.Empty; sb.AppendLine($" {op.Name} {NetToSqlTypeMap[op.Type.ToLowerInvariant()]} {pkOp},"); } sb.AppendLine($");"); sb.AppendLine(); }
protected override ICSharpType BuildTypeInner() { var type = new CSharpClass(Identifier); foreach ((string propKey, var propSchema) in Schema.Properties) { var property = BuildProperty(propKey, propSchema); if (Schema.Required.Contains(propKey)) { property.Attributes.Add(Attributes.Required); } if (propKey.Equals("id", StringComparison.InvariantCultureIgnoreCase)) { property.Attributes.Add(Attributes.Key); } type.Properties.Add(property); } return(type); }
private static void CreateLinkTable(StringBuilder sb, EntityRelationship link) { var linkTable = new CSharpClass { Name = $"{link.First.Name}_{link.Second.Name}" }; var pk1 = GetPrimaryKeyMember((CSharpClass)link.First); var firstId = linkTable.AddProperty(); firstId.Name = $"{link.First.Name}Id"; firstId.Type = pk1.Type; var pk2 = GetPrimaryKeyMember((CSharpClass)link.Second); var secondId = linkTable.AddProperty(); secondId.Name = $"{link.Second.Name}Id"; secondId.Type = pk2.Type; CreateTable(sb, linkTable); CreateForeignKey(sb, linkTable.Name, link.First, link.Second, firstId.Name, pk1.Name); CreateForeignKey(sb, linkTable.Name, link.Second, link.First, secondId.Name, pk2.Name); }
/// <summary> /// Translates nodes from the compiler to the target language. /// </summary> public override void Translate() { ErrorList.ClearErrors(); if (!CreateClasses(out IDictionary <IClass, ICSharpClass> ClassTable)) { return; } if (!CreateFeatures(ClassTable, out IDictionary <ICompiledFeature, ICSharpFeature> FeatureTable)) { return; } ICSharpContext Context = new CSharpContext(ClassTable, FeatureTable); foreach (KeyValuePair <IClass, ICSharpClass> ClassEntry in ClassTable) { ICSharpClass Class = ClassEntry.Value; IList <ICSharpFeature> ClassFeatureList = new List <ICSharpFeature>(); IList <ICSharpFeature> InheritedFeatureList = new List <ICSharpFeature>(); foreach (KeyValuePair <ICompiledFeature, ICSharpFeature> FeatureEntry in FeatureTable) { ICSharpFeature Feature = FeatureEntry.Value; IFeatureInstance Instance = Feature.Instance; if (Instance.IsDiscontinued) { continue; } if (FeatureEntry.Value.Owner == Class) { ClassFeatureList.Add(Feature); } else if (!IsDirectOrNotMainParentFeature(Instance, Class)) { InheritedFeatureList.Add(Feature); } } Class.SetFeatureList(Context, ClassFeatureList, InheritedFeatureList); } foreach (KeyValuePair <ICompiledFeature, ICSharpFeature> Entry in FeatureTable) { ICSharpFeature Feature = Entry.Value; Feature.InitOverloadsAndBodies(Context); } foreach (KeyValuePair <ICompiledFeature, ICSharpFeature> Entry in FeatureTable) { ICSharpFeature Feature = Entry.Value; Feature.InitHierarchy(Context); } foreach (KeyValuePair <IClass, ICSharpClass> Entry in ClassTable) { ICSharpClass Class = Entry.Value; CheckSharedName(Class, ClassTable); } foreach (KeyValuePair <IClass, ICSharpClass> Entry in ClassTable) { ICSharpClass Class = Entry.Value; Class.CheckOverrides(); } foreach (KeyValuePair <IClass, ICSharpClass> Entry in ClassTable) { ICSharpClass Class = Entry.Value; Class.CheckOverrides(); } bool Continue; do { Continue = false; foreach (KeyValuePair <IClass, ICSharpClass> Entry in ClassTable) { ICSharpClass Class = Entry.Value; Class.CheckForcedReadWrite(FeatureTable, ref Continue); } }while (Continue); foreach (KeyValuePair <IClass, ICSharpClass> Entry in ClassTable) { ICSharpClass Class = Entry.Value; Class.CheckSideBySideAttributes(); } foreach (KeyValuePair <IClass, ICSharpClass> Entry in ClassTable) { ICSharpClass Class = Entry.Value; Class.CheckInheritSideBySideAttributes(FeatureTable); } foreach (KeyValuePair <IClass, ICSharpClass> Entry in ClassTable) { ICSharpClass Class = Entry.Value; Class.CreateDelegates(); } ICSharpFeature SingledClassFeature = null; if (SingledGuid != Guid.Empty || SingledGuid == Guid.Empty) { foreach (KeyValuePair <IClass, ICSharpClass> Entry in ClassTable) { ICSharpClass Class = Entry.Value; if (Class.Source.ClassGuid == SingledGuid || SingledGuid == Guid.Empty || SingledGuid != Guid.Empty) { foreach (ICSharpFeature Feature in Class.FeatureList) { if (Feature is ICSharpFeatureWithName AsWithName && AsWithName.Name == SingledName) { SingledClassFeature = Feature; break; } } } if (SingledClassFeature != null) { break; } } } if (SingledClassFeature == null) { foreach (KeyValuePair <IClass, ICSharpClass> Entry in ClassTable) { ICSharpClass Class = Entry.Value; Class.SetWriteDown(); foreach (ICSharpFeature Feature in Class.FeatureList) { Feature.SetWriteDown(); } foreach (ICSharpAssertion Invariant in Class.InvariantList) { Invariant.SetWriteDown(); } } } else { SingledClassFeature.SetWriteDown(); } if (!Directory.Exists(OutputRootFolder)) { Directory.CreateDirectory(OutputRootFolder); } foreach (KeyValuePair <IClass, ICSharpClass> Entry in ClassTable) { ICSharpClass Class = Entry.Value; if (!CSharpClass.IsLanguageClass(Class.Source) && !IsClassFromLibrary(Class.Source)) { if (Class.WriteDown) { Class.Write(OutputRootFolder, Namespace, SourceFileName, SingledClassFeature); } } } }
private static CSharpIdentifier CollectionEndpoint(CSharpClass dto, CSharpIdentifier elementEndpoint) => new CSharpIdentifier("TypedRest.Endpoints.Generic", "CollectionEndpoint") { TypeArguments = { dto.Identifier, elementEndpoint } };
private static CSharpIdentifier ElementEndpoint(CSharpClass dto) => new CSharpIdentifier("TypedRest.Endpoints.Generic", "ElementEndpoint") { TypeArguments = { dto.Identifier } };
/// <summary> /// Initializes a new instance of the <see cref="ClassDefinitionGenerator"/> class for the specified <see cref="IndentedStreamWriter"/> /// </summary> /// <param name="class"><see cref="CSharpClass"/> to generate definition for</param> /// <param name="writer"><see cref="IndentedStreamWriter"/> used to write to</param> public ClassDefinitionGenerator(CSharpClass @class, IndentedStreamWriter writer) : base(writer) => _class = @class;
public void Add(IEndpoint endpoint, CSharpClass type) { _types.Add(type); _endpointImplementations.Add(endpoint, type.Identifier); }
int ParseArguments (String[] args) { bool help = false; var p = new OptionSet { { "h|?|help", "Show this help message", v => help = v != null }, { "o=|out=", "Set the output directory", v => OutputDir = v }, { "ns=|namespace=", "Set the namespace of the generated code", v => Lib.BaseNamespace = v }, { "lib=", "The base name of the C++ library, i.e. 'qt' for libqt.so", v =>Lib.BaseName = v }, { "filters=", "A file containing filter directives for filtering classes", v => FilterFile = v }, { "inline=", "Inline methods in lib are: notpresent (default), present, surrogatelib (present in %lib%-inline)", v => Lib.InlinePolicy = (InlineMethods)Enum.Parse (typeof (InlineMethods), v, true) } }; try { args = p.Parse (args).ToArray (); } catch (OptionException) { Console.WriteLine ("Try `generator --help' for more information."); return 1; } if (help) { p.WriteOptionDescriptions (Console.Error); return 1; } if (args.Length != 1) { Console.WriteLine ("Usage: generator <options> <input xml file>"); return 1; } // Code templates LibsTemplate = new CSharpLibs (); ClassTemplate = new CSharpClass (); EnumTemplate = new CSharpEnum (); InputFileName = args [0]; if (Lib.BaseName == null) { Console.WriteLine ("The --lib= option is required."); return 1; } if (Lib.BaseNamespace == null) { Lib.BaseNamespace = Path.GetFileNameWithoutExtension (Lib.BaseName); } if (OutputDir == null) OutputDir = "output"; return 0; }
private CSharpInterface GenerateEndpointInterface(IEndpoint endpoint, TypeList typeList, CSharpClass endpointImplementation) { var builder = _builders[endpoint.GetType()]; var endpointInterface = new CSharpInterface(endpointImplementation.Identifier.ToInterface()) { Interfaces = { builder.GetInterface(endpoint, typeList) }, Description = endpoint.Description }; endpointInterface.Properties.AddRange(endpointImplementation.Properties); endpointImplementation.Interfaces.Add(endpointInterface.Identifier); typeList.Add(endpoint, endpointInterface); return(endpointInterface); }