/// <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="resolver">Type resolver</param>
/// <param name="sw">Output writer</param>
public virtual void Generate(MemberInfo element, TypeResolver resolver, WriterWrapper sw)
{
if (element.IsIgnored())
{
return;
}
var t = GetType(element);
string typeName = null;
var propName = element.Name;
var tp = ConfigurationRepository.Instance.ForMember <TsPropertyAttribute>(element);
if (tp != null)
{
if (tp.StrongType != null)
{
typeName = resolver.ResolveTypeName(tp.StrongType);
}
else if (!string.IsNullOrEmpty(tp.Type))
{
typeName = tp.Type;
}
if (!string.IsNullOrEmpty(tp.Name))
{
propName = tp.Name;
}
if (tp.ForceNullable && element.DeclaringType.IsExportingAsInterface() && !Settings.SpecialCase)
{
propName = propName + "?";
}
}
if (string.IsNullOrEmpty(typeName))
{
typeName = resolver.ResolveTypeName(t);
}
if (!propName.EndsWith("?") && t.IsNullable() && element.DeclaringType.IsExportingAsInterface() &&
!Settings.SpecialCase)
{
propName = propName + "?";
}
if (element is PropertyInfo)
{
propName = Settings.ConditionallyConvertPropertyNameToCamelCase(propName);
}
propName = element.CamelCaseFromAttribute(propName);
sw.Tab();
Settings.Documentation.WriteDocumentation(element, sw);
sw.Indent();
if (!element.DeclaringType.IsExportingAsInterface() || Settings.SpecialCase)
{
var modifier = Settings.SpecialCase ? AccessModifier.Public : element.GetModifier();
sw.Write("{0} ", modifier.ToModifierText());
}
sw.Write("{0}: {1};", propName, typeName);
sw.Br();
sw.UnTab();
}
/// <summary>
/// Writes to ouput file namespace closing
/// </summary>
/// <param name="namespaceName">Namespace name</param>
/// <param name="sw">Output writer</param>
public virtual void WriteNamespaceEnd(string namespaceName, WriterWrapper sw)
{
if (string.IsNullOrEmpty(namespaceName))
{
return;
}
sw.UnTab();
sw.Indent();
sw.WriteLine("}");
sw.Br();
}
/// <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="resolver">Type resolver</param>
/// <param name="sw">Output writer</param>
public virtual void Generate(ConstructorInfo element, TypeResolver resolver, WriterWrapper sw)
{
if (element.IsIgnored())
{
return;
}
var isInterfaceMethod = element.DeclaringType.IsExportingAsInterface();
if (element.GetParameters().Length == 0)
{
return;
}
sw.Tab();
Settings.Documentation.WriteDocumentation(element, sw);
sw.Indent();
WriteFunctionName(false, element.GetModifier(), "constructor", sw, isInterfaceMethod);
WriteMethodParameters(element, resolver, sw);
WriteRestOfDeclaration(string.Empty, sw);
WriteConstructorBody(element, resolver, sw);
sw.UnTab();
}
/// <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="resolver">Type resolver</param>
/// <param name="sw">Output writer</param>
public virtual void Generate(Type element, TypeResolver resolver, WriterWrapper sw)
{
var values = Enum.GetValues(element);
var name = element.GetName();
var fmt = Settings.GetDeclarationFormat(element);
var fields = element.GetFields().Where(c => !c.IsSpecialName).ToDictionary(c => c.Name, c => c);
Settings.Documentation.WriteDocumentation(element, sw);
sw.Indent();
sw.Write(string.Format(fmt, "enum {0} {{ "), name);
sw.Br();
sw.Tab();
for (var index = 0; index < values.Length; index++)
{
var v = values.GetValue(index);
var n = Enum.GetName(element, v);
if (fields.ContainsKey(n))
{
var fieldItself = fields[n];
Settings.Documentation.WriteDocumentation(fieldItself, sw);
var attr = ConfigurationRepository.Instance.ForEnumValue(fieldItself);
if (attr != null)
{
n = attr.Name;
}
sw.Indent();
sw.Write("{0} = {1}", n, Convert.ToInt64(v));
if (index < values.Length - 1)
{
sw.Write(",");
}
sw.Br();
}
}
sw.UnTab();
sw.WriteLine("}");
}
/// <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="resolver">Type resolver</param>
/// <param name="sw">Output writer</param>
public virtual void Generate(MethodInfo element, TypeResolver resolver, WriterWrapper sw)
{
if (element.IsIgnored())
{
return;
}
var isInterfaceMethod = element.DeclaringType.IsExportingAsInterface() && !Settings.SpecialCase;
string name, type;
GetFunctionNameAndReturnType(element, resolver, out name, out type);
sw.Tab();
Settings.Documentation.WriteDocumentation(element, sw);
sw.Indent();
var modifier = element.GetModifier();
if (Settings.SpecialCase)
{
modifier = AccessModifier.Public;
}
WriteFunctionName(element.IsStatic, modifier, name, sw, isInterfaceMethod);
WriteMethodParameters(element, resolver, sw);
WriteRestOfDeclaration(type, sw);
if (isInterfaceMethod)
{
sw.Write(";");
sw.Br();
}
else
{
GenerateBody(type, resolver, sw);
}
sw.UnTab();
}