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