/// <summary> /// Main code generator method. This method should write corresponding TypeScript code for element (1st argument) to /// WriterWrapper (3rd argument) using TypeResolver if necessary /// </summary> /// <param name="element">Element code to be generated to output</param> /// <param name="result">Resulting node</param> /// <param name="resolver">Type resolver</param> public override RtFuncion GenerateNode(MethodInfo element, RtFuncion result, TypeResolver resolver) { if (element.IsIgnored()) { return(null); } string name; RtTypeName type; GetFunctionNameAndReturnType(element, resolver, out name, out type); result.Identifier = new RtIdentifier(name); result.ReturnType = type; var doc = Context.Documentation.GetDocumentationMember(element); if (doc != null) { RtJsdocNode jsdoc = new RtJsdocNode { Description = doc.Summary.Text }; if (doc.Parameters != null) { foreach (var documentationParameter in doc.Parameters) { jsdoc.TagToDescription.Add(new Tuple <DocTag, string>(DocTag.Param, documentationParameter.Name + " " + documentationParameter.Description)); } } if (doc.HasReturns()) { jsdoc.TagToDescription.Add(new Tuple <DocTag, string>(DocTag.Returns, doc.Returns.Text)); } result.Documentation = jsdoc; } result.AccessModifier = element.GetModifier(); if (Context.SpecialCase) { result.AccessModifier = AccessModifier.Public; } result.Identifier = new RtIdentifier(name); result.IsStatic = element.IsStatic; var p = element.GetParameters(); foreach (var param in p) { if (param.IsIgnored()) { continue; } var generator = resolver.GeneratorFor(param, Context); var argument = generator.Generate(param, resolver); result.Arguments.Add((RtArgument)argument); } return(result); }
public override RtInterface GenerateNode(Type element, RtInterface node, TypeResolver resolver) { var n = node; if (n == null) { return(null); } else { n = new RtInterface { Name = new RtSimpleTypeName ( $"I{(element.IsGenericType ? element.Name.Substring(0, element.Name.IndexOf("`")) : element.Name)}", element.IsGenericType ? element.GetGenericArguments().Select(_garg => new RtSimpleTypeName(_garg.Name)).ToArray() : new RtSimpleTypeName[0] ) } }; foreach (var m in element.GetProperties().Where(_p => _p.DeclaringType == element || element == typeof(BaseModel <>))) { var generator = resolver.GeneratorFor(m, Context); var member = generator.Generate(m, resolver); if (m.PropertyType == typeof(DateTime) || m.PropertyType == typeof(DateTime?)) { member.As <RtField>().Type = new RtSimpleTypeName("Apollo.Models.JsonDateTime"); if (m.PropertyType == typeof(DateTime?)) { member.As <RtField>().Identifier.IsNullable = true; } } else if (m.PropertyType == typeof(TimeSpan) || m.PropertyType == typeof(TimeSpan?)) { member.As <RtField>().Type = new RtSimpleTypeName(new RtTypeName[0], "Apollo.Models", "JsonDateTime"); if (m.PropertyType == typeof(TimeSpan?)) { member.As <RtField>().Identifier.IsNullable = true; } } else if (typeof(IEnumerable <byte>).IsAssignableFrom(m.PropertyType)) { member.As <RtField>().Type = new RtSimpleTypeName("string"); } n.Members.Add(member); } if (!element.IsGenericType) { n.Implementees.Add(new RtSimpleTypeName("IBaseModel", new[] { new RtSimpleTypeName(ReinforcedTypings.ToTypeScriptType(element.BaseType.GetGenericArguments()[0])) })); } return(n); } }
/// <summary> /// Exports list of type members /// </summary> /// <typeparam name="T">Type member type</typeparam> /// <param name="element">Exporting class</param> /// <param name="resolver">Type resolver</param> /// <param name="sw">Output writer</param> /// <param name="members">Type members to export</param> protected virtual void GenerateMembers <T>(Type element, TypeResolver resolver, WriterWrapper sw, IEnumerable <T> members) where T : MemberInfo { foreach (var m in members) { var generator = resolver.GeneratorFor(m, Settings); generator.Generate(m, resolver, sw); } }
/// <summary> /// Exports list of type members /// </summary> /// <typeparam name="T">Type member type</typeparam> /// <param name="element">Exporting class</param> /// <param name="resolver">Type resolver</param> /// <param name="typeMember">Output writer</param> /// <param name="members">Type members to export</param> protected virtual void GenerateMembers <T>(Type element, TypeResolver resolver, ITypeMember typeMember, IEnumerable <T> members) where T : MemberInfo { foreach (var m in members) { var generator = resolver.GeneratorFor <T>(m, Context); var member = generator.Generate(m, resolver); typeMember.Members.Add(member); } }
/// <summary> /// Generates namespace source code /// </summary> /// <param name="types">Types list</param> /// <param name="namespaceName">Namespace name</param> /// <param name="resolver">Type resolver</param> /// <param name="sw">Output writer</param> public virtual void Generate(IEnumerable <Type> types, string namespaceName, TypeResolver resolver, WriterWrapper sw) { WriteNamespaceBegin(namespaceName, sw); Settings.CurrentNamespace = namespaceName; foreach (var type in types) { var converter = resolver.GeneratorFor(type, Settings); converter.Generate(type, resolver, sw); Console.WriteLine("Exported {0}", type); } WriteNamespaceEnd(namespaceName, sw); }
/// <summary> /// Writes all method's parameters to output writer. /// </summary> /// <param name="element">Method info</param> /// <param name="resolver">Type resolver</param> /// <param name="sw">Output writer</param> protected virtual void WriteMethodParameters(MethodBase element, TypeResolver resolver, WriterWrapper sw) { var p = element.GetParameters(); for (var index = 0; index < p.Length; index++) { var param = p[index]; if (param.IsIgnored()) { continue; } var generator = resolver.GeneratorFor(param, Settings); generator.Generate(param, resolver, sw); if (index != p.Length - 1 && !p[index + 1].IsIgnored()) { sw.Write(", "); } } }
/// <summary> /// Generates namespace source code /// </summary> /// <param name="types">Types list</param> /// <param name="namespaceName">Namespace name</param> /// <param name="resolver">Type resolver</param> public virtual RtModule Generate(IEnumerable<Type> types, string namespaceName, TypeResolver resolver) { RtModule module = new RtModule(); if (string.IsNullOrEmpty(namespaceName)) module.IsAbstractModule = true; module.ModuleName = namespaceName; Context.CurrentNamespace = namespaceName; Context.Location.SetLocation(module); foreach (var type in types) { var converter = resolver.GeneratorFor(type, Context); var member = converter.Generate(type, resolver); module.CompilationUnits.Add(member); Console.WriteLine("Exported {0}", type); } Context.CurrentNamespace = null; Context.Location.ResetLocation(module); return module; }
/// <summary> /// Main code generator method. This method should write corresponding TypeScript code for element (1st argument) to /// WriterWrapper (3rd argument) using TypeResolver if necessary /// </summary> /// <param name="element">Element code to be generated to output</param> /// <param name="result">Resulting node</param> /// <param name="resolver">Type resolver</param> public override RtConstructor GenerateNode(ConstructorInfo element, RtConstructor result, TypeResolver resolver) { if (element.IsIgnored()) { return(null); } if (element.GetParameters().Length == 0) { return(null); } var doc = Context.Documentation.GetDocumentationMember(element); if (doc != null) { RtJsdocNode jsdoc = new RtJsdocNode { Description = doc.Summary.Text }; foreach (var documentationParameter in doc.Parameters) { jsdoc.TagToDescription.Add(new Tuple <DocTag, string>(DocTag.Param, documentationParameter.Name + " " + documentationParameter.Description)); } result.Documentation = jsdoc; } var p = element.GetParameters(); foreach (var param in p) { if (param.IsIgnored()) { continue; } var generator = resolver.GeneratorFor(param, Context); var argument = generator.Generate(param, resolver); result.Arguments.Add((RtArgument)argument); } SetupSuperCall(result, element); return(result); }
/// <summary> /// Generates namespace source code /// </summary> /// <param name="types">Types list</param> /// <param name="namespaceName">Namespace name</param> /// <param name="resolver">Type resolver</param> public virtual RtModule Generate(IEnumerable <Type> types, string namespaceName, TypeResolver resolver) { RtModule module = new RtModule(); if (string.IsNullOrEmpty(namespaceName)) { module.IsAbstractModule = true; } module.ModuleName = namespaceName; Context.CurrentNamespace = namespaceName; Context.Location.SetLocation(module); foreach (var type in types) { var converter = resolver.GeneratorFor(type, Context); var member = converter.Generate(type, resolver); module.CompilationUnits.Add(member); Console.WriteLine("Exported {0}", type); } Context.CurrentNamespace = null; Context.Location.ResetLocation(module); return(module); }