/// <summary>
/// Outputs documentation for class member
/// </summary>
/// <param name="member">Class member</param>
/// <param name="sw">Text writer</param>
public void WriteDocumentation(MemberInfo member, WriterWrapper sw)
{
if (member == null)
{
return;
}
if (!_isDocumentationExists)
{
return;
}
var id = GetIdentifierForMember(member);
if (!_documentationCache.ContainsKey(id))
{
return;
}
var info = member as MethodInfo;
if (info != null)
{
WriteDocumentation(info, sw);
return;
}
var doc = _documentationCache[id];
if (!doc.HasSummary())
{
return;
}
Begin(sw);
Summary(sw, doc.Summary.Text);
End(sw);
}
/// <summary>
/// Outputs documentation for type
/// </summary>
/// <param name="type">Type</param>
/// <param name="sw">Text writer</param>
public void WriteDocumentation(Type type, WriterWrapper sw)
{
if (type == null)
{
return;
}
if (!_isDocumentationExists)
{
return;
}
var id = GetIdentifierForType(type);
if (!_documentationCache.ContainsKey(id))
{
return;
}
var typeDoc = _documentationCache[id];
if (!typeDoc.HasSummary())
{
return;
}
Begin(sw);
Summary(sw, typeDoc.Summary.Text);
End(sw);
}
/// <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();
}
public void ClientSendKey(ref WriterWrapper writer)
{
writer.WriteBigEndian((byte)ClientSendSize);
Span <byte> span = stackalloc byte[ClientSendSize];
PublicKeySpan(span);
writer.Write(span);
}
/// <summary>
/// Exports all type members sequentially
/// </summary>
/// <param name="element">Type itself</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 ExportMembers(Type element, TypeResolver resolver, WriterWrapper sw,
IAutoexportSwitchAttribute swtch)
{
ExportFields(element, resolver, sw, swtch);
ExportProperties(element, resolver, sw, swtch);
ExportMethods(element, resolver, sw, swtch);
ExportConstructors(element, resolver, sw, swtch);
HandleBaseClassExportingAsInterface(element, resolver, sw, swtch);
}
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);
}
public void WriteExtension(ref WriterWrapper writer)
{
//While we don't currently support renegotiation if the client does we should
//respond to say we don't want any negotiation to give clarity to our position
//and reduce an attack vector for a MITM attack
writer.WriteBigEndian(ExtensionType.renegotiation_info);
writer.WriteBigEndian <ushort>(1);
writer.WriteBigEndian <byte>(0);
}
/// <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 tc = ConfigurationRepository.Instance.ForType <TsClassAttribute>(element);
if (tc == null)
{
throw new ArgumentException("TsClassAttribute is not present", "element");
}
Export("class", element, resolver, sw, tc);
}
public static void WriteHandshakeFrame(this ConnectionStates.ConnectionState state, int contentSize, BufferExtensions.ContentWriter content, HandshakeType handshakeType)
{
var writer = new WriterWrapper(state.Connection.HandshakeOutput.Writer.Alloc(), state.HandshakeHash);
writer.WriteBigEndian(handshakeType);
writer.WriteBigEndian((UInt24)contentSize);
content(ref writer);
Debug.Assert((writer.BytesWritten - 4) == contentSize);
writer.Commit();
}
/// <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 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();
}
private void Line(WriterWrapper sw, string line = null)
{
if (string.IsNullOrEmpty(line))
{
sw.WriteLine("*");
}
else
{
sw.WriteLine("* {0}", line);
}
}
public static void WriteCertificates(ref WriterWrapper buffer, ICertificate certificate)
{
var size = GetCertificatesSize(certificate);
buffer.WriteBigEndian((UInt24)size);
WriteCertificate(ref buffer, certificate.CertificateData);
foreach (var b in certificate.CertificateChain)
{
WriteCertificate(ref buffer, b);
}
}
private void Summary(WriterWrapper sw, string summary)
{
if (string.IsNullOrEmpty(summary))
{
return;
}
var summaryLines = summary.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var summaryLine in summaryLines)
{
Line(sw, summaryLine);
}
}
/// <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 to output file opening namespace declaration
/// </summary>
/// <param name="namespaceName">Namespace name</param>
/// <param name="sw">Output writer</param>
public virtual void WriteNamespaceBegin(string namespaceName, WriterWrapper sw)
{
if (string.IsNullOrEmpty(namespaceName))
{
return;
}
if (Settings.ExportPureTypings)
{
sw.WriteLine("declare module {0} {{", namespaceName);
}
else
{
sw.WriteLine("module {0} {{", namespaceName);
}
sw.Tab();
}
/// <summary>
/// Outputs documentation for method
/// </summary>
/// <param name="method">Method</param>
/// <param name="sw">Text writer</param>
public void WriteDocumentation(MethodInfo method, WriterWrapper sw)
{
if (method == null)
{
return;
}
if (!_isDocumentationExists)
{
return;
}
var id = GetIdentifierForMethod(method, method.Name);
if (!_documentationCache.ContainsKey(id))
{
return;
}
var doc = _documentationCache[id];
if ((!doc.HasSummary()) && (!doc.HasParameters()) && (!doc.HasReturns()))
{
return;
}
Begin(sw);
if (doc.HasSummary())
{
Summary(sw, doc.Summary.Text);
}
if (doc.HasParameters())
{
if (doc.HasSummary())
{
Line(sw);
}
WriteParametersDoc(method.GetParameters(), doc, sw);
}
if (doc.HasReturns())
{
if (doc.HasSummary() || doc.HasParameters())
{
Line(sw);
}
Line(sw, string.Format("@returns {0}", doc.Returns.Text));
}
End(sw);
}
public async Task Http11CorrectBufferReturned()
{
var provider = new ApplicationLayerProtocolProvider(false, ApplicationLayerProtocolType.Http1_1, ApplicationLayerProtocolType.Http2_Tls);
using (var bufferPool = new MemoryPool())
{
var factory = new PipeOptions(bufferPool);
var channel = new Pipe(factory);
var writer = new WriterWrapper(channel.Writer.Alloc(), null);
provider.WriteExtension(ref writer, ApplicationLayerProtocolType.Http1_1);
await writer.FlushAsync();
var readResult = await channel.Reader.ReadAsync();
var extension = readResult.Buffer.ToArray();
channel.Reader.Advance(readResult.Buffer.End);
Assert.Equal(_http11Only, extension);
}
}
/// <summary>
/// Writes output comment with automatic multiline division
/// </summary>
/// <param name="sw">Output writer</param>
/// <param name="comment">Comment (multiline allowed)</param>
public void WriteComment(WriterWrapper sw, string comment)
{
sw.Br();
sw.Indent();
var lines = comment.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
if (lines.Length == 1)
{
sw.WriteLine("// {0} ", lines[0]);
}
else
{
Begin(sw);
foreach (var line in lines)
{
Line(sw, line);
}
End(sw);
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();
}
/// <summary>
/// Outputs documentation for constructor
/// </summary>
/// <param name="constructor">Constructor</param>
/// <param name="sw">Text writer</param>
public void WriteDocumentation(ConstructorInfo constructor, WriterWrapper sw)
{
if (constructor == null)
{
return;
}
if (!_isDocumentationExists)
{
return;
}
var id = GetIdentifierForConstructor(constructor);
if (!_documentationCache.ContainsKey(id))
{
return;
}
var doc = _documentationCache[id];
if ((!doc.HasSummary()) && (!doc.HasParameters()))
{
return;
}
Begin(sw);
if (doc.HasSummary())
{
Summary(sw, doc.Summary.Text);
Line(sw);
}
Line(sw, "@constructor");
if (doc.HasParameters())
{
WriteParametersDoc(constructor.GetParameters(), doc, sw);
}
End(sw);
}
private void WriteParametersDoc(ParameterInfo[] parameters, DocumentationMember docMember, WriterWrapper sw)
{
foreach (var parameterInfo in parameters)
{
var doc = docMember.Parameters.SingleOrDefault(c => c.Name == parameterInfo.Name);
if (doc == null)
{
continue;
}
var name = parameterInfo.GetName();
Line(sw, string.Format("@param {0} {1}", name, doc.Description));
}
}
/// <summary>
/// Outputs documentation for method
/// </summary>
/// <param name="method">Method</param>
/// <param name="sw">Text writer</param>
public void WriteDocumentation(MethodInfo method, WriterWrapper sw)
{
if (method == null) return;
if (!_isDocumentationExists) return;
var id = GetIdentifierForMethod(method, method.Name);
if (!_documentationCache.ContainsKey(id)) return;
var doc = _documentationCache[id];
if ((!doc.HasSummary()) && (!doc.HasParameters()) && (!doc.HasReturns())) return;
Begin(sw);
if (doc.HasSummary()) Summary(sw, doc.Summary.Text);
if (doc.HasParameters())
{
if (doc.HasSummary()) Line(sw);
WriteParametersDoc(method.GetParameters(), doc, sw);
}
if (doc.HasReturns())
{
if (doc.HasSummary() || doc.HasParameters()) Line(sw);
Line(sw, string.Format("@returns {0}", doc.Returns.Text));
}
End(sw);
}
/// <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 override void Generate(Type element, TypeResolver resolver, WriterWrapper sw)
{
var tc = ConfigurationRepository.Instance.ForType<TsInterfaceAttribute>(element);
if (tc == null) throw new ArgumentException("TsInterfaceAttribute is not present", "element");
Export("interface", element, resolver, sw, tc);
}
/// <summary>
/// Outputs documentation for constructor
/// </summary>
/// <param name="constructor">Constructor</param>
/// <param name="sw">Text writer</param>
public void WriteDocumentation(ConstructorInfo constructor, WriterWrapper sw)
{
if (constructor == null) return;
if (!_isDocumentationExists) return;
var id = GetIdentifierForConstructor(constructor);
if (!_documentationCache.ContainsKey(id)) return;
var doc = _documentationCache[id];
if ((!doc.HasSummary()) && (!doc.HasParameters())) return;
Begin(sw);
if (doc.HasSummary())
{
Summary(sw, doc.Summary.Text);
Line(sw);
}
Line(sw, "@constructor");
if (doc.HasParameters())
{
WriteParametersDoc(constructor.GetParameters(), doc, sw);
}
End(sw);
}
/// <summary>
/// Outputs documentation for class member
/// </summary>
/// <param name="member">Class member</param>
/// <param name="sw">Text writer</param>
public void WriteDocumentation(MemberInfo member, WriterWrapper sw)
{
if (member == null) return;
if (!_isDocumentationExists) return;
var id = GetIdentifierForMember(member);
if (!_documentationCache.ContainsKey(id)) return;
var info = member as MethodInfo;
if (info != null)
{
WriteDocumentation(info, sw);
return;
}
var doc = _documentationCache[id];
if (!doc.HasSummary()) return;
Begin(sw);
Summary(sw, doc.Summary.Text);
End(sw);
}
private void End(WriterWrapper sw)
{
sw.WriteLine("*/");
}
private void WriteClientVerify(ref WriterWrapper writer)
{
var cverify = _secretSchedule.GenerateClientVerify();
writer.Write(cverify);
}
private void Begin(WriterWrapper sw)
{
sw.WriteLine("/**");
}
/// <summary>
/// Writes output comment with automatic multiline division
/// </summary>
/// <param name="sw">Output writer</param>
/// <param name="comment">Comment (multiline allowed)</param>
public void WriteComment(WriterWrapper sw, string comment)
{
sw.Br();
sw.Indent();
var lines = comment.Split(new[] {'\r', '\n'}, StringSplitOptions.RemoveEmptyEntries);
if (lines.Length == 1)
{
sw.WriteLine("// {0} ", lines[0]);
}
else
{
Begin(sw);
foreach (var line in lines)
{
Line(sw, line);
}
End(sw);
sw.Br();
}
}
private void End(WriterWrapper sw)
{
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("}");
}
private void Begin(WriterWrapper sw)
{
sw.WriteLine("/**");
}
public ReaderWriterLockWrapper()
{
lck = new ReaderWriterLockSlim();
reader = new ReaderWrapper(lck);
writer = new WriterWrapper(lck);
}
private void Summary(WriterWrapper sw, string summary)
{
if (string.IsNullOrEmpty(summary)) return;
var summaryLines = summary.Split(new[] {'\r', '\n'}, StringSplitOptions.RemoveEmptyEntries);
foreach (var summaryLine in summaryLines)
{
Line(sw, summaryLine);
}
}
private void WriteServerVerify(ref WriterWrapper writer) => writer.Write(_serverVerify.Span);
/// <summary>
/// Outputs documentation for type
/// </summary>
/// <param name="type">Type</param>
/// <param name="sw">Text writer</param>
public void WriteDocumentation(Type type, WriterWrapper sw)
{
if (type == null) return;
if (!_isDocumentationExists) return;
var id = GetIdentifierForType(type);
if (!_documentationCache.ContainsKey(id)) return;
var typeDoc = _documentationCache[id];
if (!typeDoc.HasSummary()) return;
Begin(sw);
Summary(sw, typeDoc.Summary.Text);
End(sw);
}
private void WriteParametersDoc(ParameterInfo[] parameters, DocumentationMember docMember, WriterWrapper sw)
{
foreach (var parameterInfo in parameters)
{
var doc = docMember.Parameters.SingleOrDefault(c => c.Name == parameterInfo.Name);
if (doc == null) continue;
var name = parameterInfo.GetName();
Line(sw, string.Format("@param {0} {1}", name, doc.Description));
}
}
public ReaderWriterLockWrapper()
{
lck = new ReaderWriterLockSlim();
reader = new ReaderWrapper(lck);
writer = new WriterWrapper(lck);
}
private void Line(WriterWrapper sw, string line = null)
{
if (string.IsNullOrEmpty(line)) sw.WriteLine("*");
else sw.WriteLine("* {0}", line);
}
