/// <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);
}
