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