/// <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();
}
private void WriteClientHello(ref WriterWrapper writer)
{
writer.WriteBigEndian(RecordVersion);
_secretSchedule.GenerateClientRandom();
writer.Write(_secretSchedule.ClientRandom);
writer.WriteBigEndian <byte>(0);
writer.Write(_cryptoProvider.CipherSuites.GetCipherSuites());
writer.WriteBigEndian <byte>(0);
}
/// <summary>
/// Writes rest of method declaration to output writer (after formal parameters list)
/// </summary>
/// <param name="type">Returning type name</param>
/// <param name="sw">Output writer</param>
protected void WriteRestOfDeclaration(string type, WriterWrapper sw)
{
if (string.IsNullOrEmpty(type))
{
sw.Write(")");
}
else
{
sw.Write("): {0}", type);
}
}
/// <summary>
/// Writes method name, accessor and opening brace to output writer
/// </summary>
/// <param name="isStatic">Is method static or not</param>
/// <param name="accessModifier">Access modifier for method</param>
/// <param name="name">Method name</param>
/// <param name="sw">Output writer</param>
/// <param name="isInterfaceDecl">
/// Is this method interface declaration or not (access modifiers prohibited on interface
/// declaration methods)
/// </param>
protected void WriteFunctionName(bool isStatic, AccessModifier accessModifier, string name, WriterWrapper sw,
bool isInterfaceDecl = false)
{
if (!isInterfaceDecl)
{
sw.Write("{0} ", accessModifier.ToModifierText());
if (isStatic)
{
sw.Write("static ");
}
}
sw.Write("{0}(", name);
}
public void ClientSendKey(ref WriterWrapper writer)
{
writer.WriteBigEndian((byte)ClientSendSize);
Span <byte> span = stackalloc byte[ClientSendSize];
PublicKeySpan(span);
writer.Write(span);
}
/// <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>
/// Exports entire class to specified writer
/// </summary>
/// <param name="declType">
/// Declaration type. Used in "export $gt;class< ... " line. This parameter allows switch it to
/// "interface"
/// </param>
/// <param name="type">Exporting class type</param>
/// <param name="resolver">Type resolver</param>
/// <param name="sw">Output writer</param>
/// <param name="swtch">Pass here type attribute inherited from IAutoexportSwitchAttribute</param>
protected virtual void Export(string declType, Type type, TypeResolver resolver, WriterWrapper sw,
IAutoexportSwitchAttribute swtch)
{
var name = type.GetName();
Settings.Documentation.WriteDocumentation(type, sw);
sw.Indent();
sw.Write(Settings.GetDeclarationFormat(type), declType);
sw.Write(name);
var ifaces = type.GetInterfaces();
var bs = type.BaseType;
var baseClassIsExportedAsInterface = false;
if (bs != null && bs != typeof(object))
{
if (ConfigurationRepository.Instance.ForType <TsDeclarationAttributeBase>(bs) != null)
{
if (bs.IsExportingAsInterface())
{
baseClassIsExportedAsInterface = true;
}
else
{
sw.Write(" extends {0} ", resolver.ResolveTypeName(bs));
}
}
}
var ifacesStrings =
ifaces.Where(c => ConfigurationRepository.Instance.ForType <TsInterfaceAttribute>(c) != null)
.Select(resolver.ResolveTypeName).ToList();
if (baseClassIsExportedAsInterface)
{
ifacesStrings.Add(resolver.ResolveTypeName(bs));
}
if (ifacesStrings.Any())
{
var implemets = string.Join(", ", ifacesStrings);
if (type.IsExportingAsInterface())
{
sw.Write(" extends {0}", implemets);
}
else
{
sw.Write(" implements {0}", implemets);
}
}
sw.Write(" {{");
sw.WriteLine();
ExportMembers(type, resolver, sw, swtch);
sw.WriteLine("}");
}
/// <summary>
/// Writes method body to output writer
/// </summary>
/// <param name="returnType">Method return type</param>
/// <param name="resolver">Type resolver</param>
/// <param name="sw">Output writer</param>
/// <param name="content">Content for non-void body</param>
protected virtual void GenerateBody(string returnType, TypeResolver resolver, WriterWrapper sw,
string content = "return null;")
{
if (Settings.ExportPureTypings) //Ambient class declarations cannot have a body
{
sw.Write(";");
sw.Br();
}
else
{
if (returnType != "void")
{
sw.WriteLine();
sw.WriteIndented(@"{{
{0}
}}", content);
}
else
{
sw.Write(" {{ }}");
sw.Br();
}
}
}
/// <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>
/// 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();
}
private void WriteServerVerify(ref WriterWrapper writer) => writer.Write(_serverVerify.Span);
private void WriteClientVerify(ref WriterWrapper writer)
{
var cverify = _secretSchedule.GenerateClientVerify();
writer.Write(cverify);
}
private static void WriteCertificate(ref WriterWrapper writer, Span <byte> certData)
{
writer.WriteBigEndian((UInt24)certData.Length);
writer.Write(certData);
}
/// <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(ParameterInfo element, TypeResolver resolver, WriterWrapper sw)
{
if (element.IsIgnored())
{
return;
}
var name = element.Name;
string type;
var isNullable = false;
var fa = ConfigurationRepository.Instance.ForMember(element);
var defaultValue = GetDefaultValue(element, fa);
if (fa != null)
{
if (!string.IsNullOrEmpty(fa.Name))
{
name = fa.Name;
}
if (!string.IsNullOrEmpty(fa.Type))
{
type = fa.Type;
}
else if (fa.StrongType != null)
{
type = resolver.ResolveTypeName(fa.StrongType);
isNullable = element.IsOptional;
}
else
{
type = resolver.ResolveTypeName(element.ParameterType);
}
}
else
{
type = resolver.ResolveTypeName(element.ParameterType);
isNullable = element.IsOptional;
}
if (element.GetCustomAttribute <ParamArrayAttribute>() != null)
{
sw.Write("...");
}
sw.Write(name);
if (!Settings.ExportPureTypings)
{
if (isNullable && defaultValue == null)
{
sw.Write("?");
}
sw.Write(": {0}", type);
if (defaultValue != null)
{
sw.Write(" = {0}", defaultValue);
}
}
else
{
//there are slightly different rules for .d.ts
if (isNullable || defaultValue != null)
{
sw.Write("?");
}
sw.Write(": {0}", type);
}
}