public static string Property(ScrapedProperty property, ScrapedClass parent, bool isInterface) { var output = ""; //TODO: static/private properties shouldn't be here for interfaces output += property.GetTrivia(); if (property.Type.Optional) { output += "[Optional]" + NewLine; } if (property.Type.Unwrapped) { output += "[Unwrapped]" + NewLine; } if (!isInterface) //todo: comment out private/static properties in interfaces { output += property.Public ? "public " : "private "; output += property.Static ? "static " : ""; } if (property.Type.CSharpType == "Self") { property.Type.CSharpType = parent.Name; } output += property.Type.CSharpType + " "; output += property.CSharpName + " { "; output += property.PublicGetter ? "get; " : "private get; "; output += property.PublicSetter ? "set; " : "private set; "; output += "}" + NewLine + NewLine; return(output); }
public static string Notification(ScrapedNotification notification, ScrapedClass parent, bool isInterface) { var output = ""; output += notification.GetTrivia(); output += "public class " + notification.CSharpName + " : NSNotification" + NewLine + "{" + NewLine; output += "public " + notification.CSharpName + "() : base(\"\", null) { }" + NewLine + "}" + NewLine; return(output); }
public static string Typedef(ScrapedTypedef typeAlias, ScrapedClass parent, bool isInterface) { var output = ""; output += typeAlias.GetTrivia(); output += "public struct " + typeAlias.Alias + NewLine + "{" + NewLine; output += "static public implicit operator " + typeAlias.Alias + "(" + typeAlias.RealType.CSharpType + " value)" + NewLine + "{" + NewLine + "return default(" + typeAlias.Alias + ");" + NewLine + "}" + NewLine; output += "static public implicit operator " + typeAlias.RealType.CSharpType + "(" + typeAlias.Alias + " value)" + NewLine + "{" + NewLine + "return default(" + typeAlias.RealType.CSharpType + ");" + NewLine + "}" + NewLine + "}" + NewLine; return(output); }
public static string Struct(ScrapedStruct scrapedEnum, ScrapedClass parent, bool isInterface) { var output = ""; output += scrapedEnum.GetTrivia(); output += "public struct " + scrapedEnum.CSharpName + NewLine + "{" + NewLine; if (scrapedEnum.Members != null) { foreach (var member in scrapedEnum.Members) { output += member.GetTrivia(); if (member.Type.Optional) { output += "[Optional]" + NewLine; } if (member.Type.Unwrapped) { output += "[Unwrapped]" + NewLine; } if (!isInterface) //todo: comment out private/static properties in interfaces { output += member.Public ? "public " : ""; output += member.Static ? "static " : ""; } if (member.Type.CSharpType == "Self") { member.Type.CSharpType = scrapedEnum.CSharpName; } output += member.Type.CSharpType + " "; output += member.CSharpName + " { get; "; output += member.ReadOnly ? "private set; " : "set; "; output += "}" + NewLine + NewLine; } } output += "}" + NewLine; return(output); }
public static string Enum(ScrapedEnum scrapedEnum, ScrapedClass parent, bool isInterface) { var output = ""; output += scrapedEnum.GetTrivia(); output += "public enum " + scrapedEnum.CSharpName + NewLine + "{" + NewLine; if (scrapedEnum.Members != null) { foreach (var member in scrapedEnum.Members) { output += member.GetTrivia(); output += member.CSharpName + "," + NewLine; } } output += "}" + NewLine; return(output); }
public static string Method(ScrapedMethod method, ScrapedClass parent, bool isInterface) { var output = ""; var toOutput = method.GetTrivia(); var toAddAfterSummary = NewLine; foreach (var param in method.Parameters) { if (param.Description == null) { param.Description = ""; } toAddAfterSummary += "/// <param name=\"" + param.Name + "\">" + ParseAsDescription(param.Description) + "</param>" + NewLine; } var differentiator = Differentiate(method); if (differentiator != "") { toAddAfterSummary += "/// <param name=\"NAME_YOUR_PARAMS\">DO NOT USE THIS PARAMETER - Instead make sure to name the parameters you're using.</param>" + NewLine; } if (method.ReturnDescription != null) { toAddAfterSummary += "/// <returns>" + ParseAsDescription(method.ReturnDescription) + "</returns>" + NewLine; } if (method.IsOptional) { toOutput += "[InheritOptional]" + NewLine; } //Deal with optional/unwrapped return values using attributes if (method.ReturnType.Optional) { toOutput += "[return:Optional]" + NewLine; } if (method.ReturnType.Unwrapped) { toOutput += "[return:Unwrapped]" + NewLine; } if (differentiator != "") { toOutput += "[IgnoreParameter(\"NAME_YOUR_PARAMS\")]" + NewLine; } if (isInterface && (method.Static || method.IsConstructor || method.IsOptional)) { //csharp doesn't allow static things in interfaces toOutput = toOutput.Replace("[", "//["); } output += toOutput.Replace("/// </summary>" + NewLine, "/// </summary>" + toAddAfterSummary); if (isInterface && (method.Static || method.IsConstructor || method.IsOptional)) { output += "//"; } if (!method.IsConstructor) { if (!isInterface) //TODO: comment out private/static methods { output += method.Public ? "public " : "private "; output += method.Static ? "static " : "virtual "; } if (method.ReturnType.CSharpType == "Self") { method.ReturnType.CSharpType = parent.CSharpName; } output += method.ReturnType.CSharpType + " "; output += method.CSharpName + "("; output += string.Join(", ", method.Parameters.Select(param => (param.Type.Optional ? "[Optional] " : "") + (param.Type.Unwrapped ? "[Unwrapped] " : "") + (param.Type.CSharpType == "Self" ? parent.CSharpName : param.Type.CSharpType) + " " + param.Name)); output += differentiator + ")"; if (!isInterface) { output += " { "; if (method.ReturnType.CSharpType != "void") { output += "return default(" + method.ReturnType.CSharpType + ");"; } output += " }"; } else { output += ";"; } output += NewLine + NewLine; } else if (method.IsConstructor) { output += "public " + parent.Name + "("; output += string.Join(", ", method.Parameters.Select(param => (param.Type.Optional ? "[Optional] " : "") + (param.Type.Unwrapped ? "[Unwrapped] " : "") + (param.Type.CSharpType == "Self" ? parent.CSharpName : param.Type.CSharpType) + " " + param.Name)); output += differentiator + ") { }" + NewLine + NewLine; } return(output); }
/// <summary> /// /// </summary> /// <param name="url"></param> /// <returns></returns> public static string Class(string url, string defaultNamespace, bool isInterface = false, string[] usings = null) { Signatures = new List <string>(); var parsed = new ScrapedClass(url); if (usings == null) { usings = new[] { "ObjectiveC", "System", "SharpSwift.Attributes", "Foundation", "CoreGraphics", "UIKit" }; } //add all the usings var output = "using " + string.Join(";" + NewLine + "using ", usings) + ";"; //namespace xyz { output += NewLine + NewLine + "namespace " + (!string.IsNullOrWhiteSpace(parsed.Namespace) ? parsed.Namespace : defaultNamespace) + NewLine + "{" + NewLine; //trivia, add the <see cref> tag output += parsed.GetTrivia().Replace("/// </summary>" + NewLine, "/// </summary>" + NewLine + "/// <see cref=\"" + url + "\"/>" + NewLine); //public class Name output += "public " + (isInterface ? "interface" : "class") + " " + parsed.Name; if (isInterface) { var m = 1; } if (!string.IsNullOrEmpty(parsed.Inherits)) { output += " : " + parsed.Inherits + "//, "; } else { output += "//: "; } if (parsed.ConformsTo != null && parsed.ConformsTo.Any()) { //All the interfaces are commented out, since they don't all work right output += string.Join(", ", parsed.ConformsTo); } output = output.TrimEnd(' ', ','); output += NewLine + "{" + NewLine; if (!isInterface) { if ( !parsed.Members.OfType <ScrapedMethod>() .Any(method => method.IsConstructor && method.Parameters.Count == 0)) { //Add a parameterless constructor for everything output += "public " + parsed.Name + "() { }" + NewLine; } } //Remove repeated properties var allProperties = parsed.Members.OfType <ScrapedProperty>().ToList(); for (var i = 0; i < allProperties.Count(); i++) { var currProperty = allProperties[i]; var allWithSame = allProperties.Where( prop => prop != currProperty && prop.RawName == currProperty.RawName && prop.Type.RawSwift == currProperty.Type.RawSwift).ToList(); for (var w = 0; w < allWithSame.Count(); w++) { var withSame = allWithSame[w]; allProperties.Remove(withSame); parsed.Members.Remove(withSame); } } foreach (var method in parsed.Members.OfType <ScrapedMethod>()) { output += Finals.Method(method, parsed, isInterface); } foreach (var property in parsed.Members.OfType <ScrapedProperty>()) { output += Finals.Property(property, parsed, isInterface); } output = output.TrimEnd() + NewLine + "}" + NewLine; //Enums and Typedefs don't need to be in the actual class foreach (var scrapedEnum in parsed.Members.OfType <ScrapedEnum>()) { output += Finals.Enum(scrapedEnum, parsed, isInterface); } foreach (var typeAlias in parsed.Members.OfType <ScrapedTypedef>()) { output += Finals.Typedef(typeAlias, parsed, isInterface); } foreach (var notification in parsed.Members.OfType <ScrapedNotification>()) { output += Finals.Notification(notification, parsed, isInterface); } output = output.TrimEnd() + NewLine + NewLine; foreach (var strct in parsed.Members.OfType <ScrapedStruct>()) { output += Finals.Struct(strct, parsed, isInterface); } return(output.TrimEnd() + NewLine + "}" + NewLine); }