protected override Expression VisitTypeDefinitionExpression(TypeDefinitionExpression expression) { var includeExpressions = new List <Expression> { FickleExpression.Include(expression.Type.Name + ".h") }; var comment = new CommentExpression("This file is AUTO GENERATED"); var referencedTypes = ReferencedTypesCollector.CollectReferencedTypes(expression); referencedTypes.Sort((x, y) => String.Compare(x.Name, y.Name, StringComparison.InvariantCultureIgnoreCase)); foreach (var referencedType in referencedTypes.Where(ObjectiveBinderHelpers.TypeIsServiceClass)) { includeExpressions.Add(FickleExpression.Include(referencedType.Name + ".h")); } var headerGroup = includeExpressions.ToStatementisedGroupedExpression(); var header = new Expression[] { comment, headerGroup }.ToStatementisedGroupedExpression(GroupedExpressionsExpressionStyle.Wide); var methods = new List <Expression> { this.CreateInitMethod(expression), this.CreateAllPropertiesAsDictionaryMethod(expression), this.CreateScalarPropertiesAsFormEncodedStringMethod(expression), this.CreateCopyWithZoneMethod(expression), }; var body = methods.ToStatementisedGroupedExpression(GroupedExpressionsExpressionStyle.Wide); return(new TypeDefinitionExpression(expression.Type, header, body, false, expression.Attributes, expression.InterfaceTypes)); }
protected override Expression VisitTypeDefinitionExpression(TypeDefinitionExpression expression) { try { currentTypeDefinition = expression; var body = this.Visit(expression.Body); var include = FickleExpression.Include("Foundation/Foundation.h"); var comment = new CommentExpression("This file is AUTO GENERATED"); var header = new Expression[] { comment, include }.ToStatementisedGroupedExpression(GroupedExpressionsExpressionStyle.Wide); return(FickleExpression.GroupedWide ( new TypeDefinitionExpression(expression.Type, header, body, false, expression.Attributes, expression.InterfaceTypes), this.CreateTryParseMethod(), this.CreateToStringMethod() )); } finally { currentTypeDefinition = null; } }
private Expression CreateScalarPropertiesAsFormEncodedStringMethod(TypeDefinitionExpression expression) { var self = Expression.Parameter(expression.Type, "self"); var properties = ExpressionGatherer.Gather(expression, ServiceExpressionType.PropertyDefinition).Where(c => !(c.Type is FickleListType)).ToList(); var parameters = properties.OfType <PropertyDefinitionExpression>().ToDictionary(c => c.PropertyName, c => Expression.Property(self, c.PropertyName)); var path = string.Join("", properties.OfType <PropertyDefinitionExpression>().Select(c => c.PropertyName + "={" + c.PropertyName + "}")); var formatInfo = ObjectiveStringFormatInfo.GetObjectiveStringFormatInfo ( path, c => parameters[c], (s, t) => t == typeof(string) ? s : s + "&", c => FickleExpression.Call(c, typeof(string), "stringByAppendingString", Expression.Constant("&")) ); var parameterInfos = new List <ParameterInfo> { new FickleParameterInfo(typeof(string), "format") }; parameterInfos.AddRange(formatInfo.ParameterExpressions.Select(c => new ObjectiveParameterInfo(c.Type, c.Name, true))); var args = new List <Expression> { Expression.Constant(formatInfo.Format) }; args.AddRange(formatInfo.ValueExpressions); var methodInfo = new FickleMethodInfo(typeof(string), typeof(string), "stringWithFormat", parameterInfos.ToArray(), true); var methodBody = Expression.Block(FickleExpression.Return(Expression.Call(null, methodInfo, args)).ToStatement()); return(new MethodDefinitionExpression("scalarPropertiesAsFormEncodedString", new List <Expression>().ToReadOnlyCollection(), typeof(string), methodBody, false, null)); }
protected override Expression VisitTypeDefinitionExpression(TypeDefinitionExpression expression) { currentTypeDefinition = expression; currentType = expression.Type; var referencedTypes = ReferencedTypesCollector.CollectReferencedTypes(expression); referencedTypes.Sort((x, y) => string.Compare(x.Name, y.Name, StringComparison.InvariantCultureIgnoreCase)); var includeExpressions = new List <IncludeExpression>(); var lookup = new HashSet <Type>(referencedTypes.Where(TypeSystem.IsPrimitiveType)); if (lookup.Contains(typeof(Guid)) || lookup.Contains(typeof(Guid?))) { includeExpressions.Add(FickleExpression.Include("java.util.UUID")); } if (lookup.Contains(typeof(TimeSpan)) || lookup.Contains(typeof(TimeSpan?))) { includeExpressions.Add(FickleExpression.Include("java.util.Date")); } var comment = new CommentExpression("This file is AUTO GENERATED"); var namespaceExpression = new NamespaceExpression(codeGenerationContext.Options.Namespace); var members = new List <Expression>() { this.Visit(expression.Body) }; if (((FickleType)currentTypeDefinition.Type).ServiceClass.Properties.Count > 0) { includeExpressions.Add(FickleExpression.Include("android.util.JsonReader")); includeExpressions.Add(FickleExpression.Include("android.util.JsonToken")); includeExpressions.Add(FickleExpression.Include("com.jaigo.androiddevkit.*")); includeExpressions.Add(FickleExpression.Include("com.jaigo.androiddevkit.utils.*")); includeExpressions.Add(FickleExpression.Include("java.lang.Exception")); includeExpressions.Add(FickleExpression.Include("java.io.InputStream")); includeExpressions.Add(FickleExpression.Include("java.io.InputStreamReader")); includeExpressions.Add(FickleExpression.Include("java.util.ArrayList")); members.Add(CreateDeserializeStreamMethod()); members.Add(CreateDeserializeReaderMethod()); members.Add(CreateDeserializeElementMethod()); members.Add(CreateSerializeMethod()); } if (CurrentTypeIsResponseType()) { members.Add(CreateCreateErrorResponseMethod()); } var headerGroup = includeExpressions.ToStatementisedGroupedExpression(); var header = new Expression[] { comment, namespaceExpression, headerGroup }.ToStatementisedGroupedExpression(GroupedExpressionsExpressionStyle.Wide); var body = fieldDefinitionsForProperties.Concat(members).ToStatementisedGroupedExpression(GroupedExpressionsExpressionStyle.Wide); return(new TypeDefinitionExpression(expression.Type, header, body, false, expression.Attributes, expression.InterfaceTypes)); }
public static Expression Build(TypeDefinitionExpression expression, CodeGenerationContext context) { var builder = new PropertiesToDictionaryExpressionBinder(expression.Type, context); builder.Visit(expression); return(builder.propertySetterExpressions.ToStatementisedGroupedExpression(GroupedExpressionsExpressionStyle.Wide)); }
public static Expression Bind(CodeGenerationContext codeGenerationContext, TypeDefinitionExpression expression, ParameterExpression zone, ParameterExpression theCopy) { var builder = new PropertiesToCopyExpressionBinder(codeGenerationContext, expression.Type, zone, theCopy); builder.Visit(expression); return(builder.statements.ToStatementisedGroupedExpression()); }
protected override Expression VisitTypeDefinitionExpression(TypeDefinitionExpression expression) { var comment = new CommentExpression("This file is AUTO GENERATED"); var header = new Expression[] { comment }.ToStatementisedGroupedExpression(GroupedExpressionsExpressionStyle.Wide); var typeDefinitionExpression = new TypeDefinitionExpression(expression.Type, null, expression.Body, false, expression.Attributes, expression.InterfaceTypes); return(new NamespaceExpression(this.codeGenerationContext.Options.Namespace, header, typeDefinitionExpression)); }
protected override Expression VisitTypeDefinitionExpression(TypeDefinitionExpression expression) { currentTypeDefinitionExpression = expression; currentReturnTypes = new HashSet <Type>(ReturnTypesCollector.CollectReturnTypes(expression)); var includeExpressions = new List <IncludeExpression> { FickleExpression.Include("java.util.ArrayList"), FickleExpression.Include("com.jaigo.androiddevkit.DefaultJsonBuilder"), FickleExpression.Include("com.jaigo.androiddevkit.RequestCallback"), FickleExpression.Include("com.jaigo.androiddevkit.utils.ConvertUtils"), FickleExpression.Include("com.jaigo.androiddevkit.WebServiceClient") }; var comment = new CommentExpression("This file is AUTO GENERATED"); var client = new FieldDefinitionExpression("webServiceClient", webServiceClientType, AccessModifiers.Private | AccessModifiers.Constant); var body = GroupedExpressionsExpression.FlatConcat ( GroupedExpressionsExpressionStyle.Wide, client, CreateDefaultConstructor(), CreateParameterisedConstructor(), this.Visit(expression.Body) ); var singleValueResponseTypes = currentReturnTypes.Where(c => c.GetUnwrappedNullableType().IsPrimitive).Select(c => FickleType.Define(JavaBinderHelpers.GetValueResponseWrapperTypeName(c))).ToList(); var referencedTypes = ReferencedTypesCollector.CollectReferencedTypes(body).Concat(singleValueResponseTypes).Distinct().ToList(); referencedTypes.Sort((x, y) => String.Compare(x.Name, y.Name, StringComparison.InvariantCultureIgnoreCase)); var lookup = new HashSet <Type>(referencedTypes.Where(TypeSystem.IsPrimitiveType)); if (lookup.Contains(typeof(FickleListType))) { includeExpressions.Add(FickleExpression.Include("java.util.ArrayList")); } if (lookup.Contains(typeof(Guid)) || lookup.Contains(typeof(Guid?))) { includeExpressions.Add(FickleExpression.Include("java.util.UUID")); } if (lookup.Contains(typeof(DateTime)) || lookup.Contains(typeof(DateTime?))) { includeExpressions.Add(FickleExpression.Include("java.util.Date")); } var headerGroup = includeExpressions.Sorted(IncludeExpression.Compare).ToGroupedExpression(); var namespaceExpression = new NamespaceExpression(CodeGenerationContext.Options.Namespace); var header = new Expression[] { comment, namespaceExpression, headerGroup }.ToGroupedExpression(GroupedExpressionsExpressionStyle.Wide); return(new TypeDefinitionExpression(expression.Type, header, body, false, expression.Attributes, expression.InterfaceTypes)); }
protected override Expression VisitTypeDefinitionExpression(TypeDefinitionExpression expression) { if (expression.Header != null) { this.Visit(expression.Header); this.WriteLine(); this.WriteLine(); } var fickleType = expression.Type as FickleType; if (fickleType != null && fickleType.IsClass) { this.Write("public class "); this.Write(expression.Type.Name, true); if (expression.Type.BaseType != null && expression.Type.BaseType != typeof(Object)) { this.Write(" : "); this.Write(expression.Type.BaseType, true); } this.WriteLine(); using (this.AcquireIndentationContext(BraceLanguageStyleIndentationOptions.IncludeBracesNewLineAfter)) { this.Visit(expression.Body); this.WriteLine(); } } else if (fickleType != null && fickleType.BaseType == typeof(Enum)) { this.WriteLine("public enum " + expression.Type.Name); using (this.AcquireIndentationContext(BraceLanguageStyleIndentationOptions.IncludeBracesNewLineAfter)) { var expressions = ((GroupedExpressionsExpression)expression.Body).Expressions; var i = 0; foreach (Expression rootExpression in expressions) { i++; this.Visit(rootExpression); if (i < expressions.Count) { this.Write(','); } this.WriteLine(); } } } return(expression); }
public static Expression Bind(TypeDefinitionExpression expression, out int count) { var builder = new PropertiesFromDictionaryExpressonBinder(expression.Type); builder.Visit(expression); count = builder.propertyGetterExpressions.Count; return(builder.propertyGetterExpressions.ToStatementisedGroupedExpression(GroupedExpressionsExpressionStyle.Wide)); }
protected override Expression VisitTypeDefinitionExpression(TypeDefinitionExpression expression) { try { currentTypeDefinition = expression; currentType = expression.Type; enumValueField = new FieldDefinitionExpression("value", typeof(int), AccessModifiers.Private | AccessModifiers.Constant); var includeExpressions = new List <Expression>() { FickleExpression.Include("android.util.JsonReader"), FickleExpression.Include("com.jaigo.androiddevkit.DefaultJsonBuilder"), FickleExpression.Include("java.util.ArrayList") }; var referencedTypes = ReferencedTypesCollector.CollectReferencedTypes(expression); referencedTypes.Sort((x, y) => String.Compare(x.Name, y.Name, StringComparison.InvariantCultureIgnoreCase)); if (!codeGenerationContext.Options.SerializeEnumsAsStrings) { includeExpressions.Add(FickleExpression.Include("com.jaigo.androiddevkit.utils.ConvertUtils")); } var includeStatements = includeExpressions.ToStatementisedGroupedExpression(); var comment = new CommentExpression("This file is AUTO GENERATED"); var namespaceExpression = new NamespaceExpression(codeGenerationContext.Options.Namespace); var header = new Expression[] { comment, namespaceExpression, includeStatements }.ToStatementisedGroupedExpression(GroupedExpressionsExpressionStyle.Wide); var bodyExpressions = new List <Expression>() { expression.Body, enumValueField, CreateConstructor(), CreateDeserializeMethod(), CreateDeserializeArrayMethod(), CreateSerializeMethod(), JavaBinderHelpers.CreateSerializeArrayMethod(currentType) }; var body = new GroupedExpressionsExpression(bodyExpressions); return(new TypeDefinitionExpression(expression.Type, header, body, false, expression.Attributes, expression.InterfaceTypes)); } finally { currentTypeDefinition = null; } }
private Expression CreateAllPropertiesAsDictionaryMethod(TypeDefinitionExpression expression) { var dictionaryType = new FickleType("NSMutableDictionary"); var retvalExpression = Expression.Parameter(dictionaryType, "retval"); IEnumerable <ParameterExpression> variables = new[] { retvalExpression }; var newDictionaryExpression = Expression.Assign(retvalExpression, FickleExpression.New("NSMutableDictionary", "initWithCapacity", ExpressionTypeCounter.Count(expression, (ExpressionType)ServiceExpressionType.PropertyDefinition) * 2)).ToStatement(); var makeDictionaryExpression = PropertiesToDictionaryExpressionBinder.Build(expression, this.codeGenerationContext); var returnDictionaryExpression = Expression.Return(Expression.Label(), Expression.Parameter(dictionaryType, "retval")).ToStatement(); var methodBody = Expression.Block(variables, GroupedExpressionsExpression.FlatConcat(GroupedExpressionsExpressionStyle.Wide, newDictionaryExpression, makeDictionaryExpression, returnDictionaryExpression)); return(new MethodDefinitionExpression("allPropertiesAsDictionary", new List <Expression>().ToReadOnlyCollection(), dictionaryType, methodBody, false, null)); }
private MethodDefinitionExpression CreateInitMethod(TypeDefinitionExpression expression) { var type = expression.Type; Expression superInitExpression; var parameters = new List <Expression> { Expression.Parameter(new FickleType("NSDictionary"), "properties") }; var methodBodyExpressions = new List <Expression>(); if (type.BaseType.IsServiceType()) { superInitExpression = Expression.Call(Expression.Parameter(type.BaseType, "super"), new FickleMethodInfo(type.BaseType, type, "initWithPropertyDictionary", new [] { new FickleParameterInfo(parameters[0].Type, "dictionary") }), parameters[0]); } else { superInitExpression = Expression.Call(Expression.Parameter(type.BaseType, "super"), new FickleMethodInfo(type.BaseType, type, "init", new ParameterInfo[0])); } var assignExpression = Expression.Assign(Expression.Parameter(type, "self"), superInitExpression); var compareToNullExpression = Expression.ReferenceEqual(assignExpression, Expression.Constant(null, type)); int count; methodBodyExpressions.Add(Expression.IfThen(compareToNullExpression, Expression.Block(Expression.Return(Expression.Label(), Expression.Constant(null)).ToStatement()))); methodBodyExpressions.Add(PropertiesFromDictionaryExpressonBinder.Bind(expression, out count)); methodBodyExpressions.Add(Expression.Return(Expression.Label(), Expression.Parameter(type, "self")).ToStatement()); IEnumerable <ParameterExpression> variables; if (count > 0) { variables = new[] { Expression.Parameter(FickleType.Define("id"), "currentValueFromDictionary") }; } else { variables = new ParameterExpression[0]; } var methodBody = Expression.Block(variables, (Expression)methodBodyExpressions.ToStatementisedGroupedExpression(GroupedExpressionsExpressionStyle.Wide)); return(new MethodDefinitionExpression("initWithPropertyDictionary", parameters.ToReadOnlyCollection(), typeof(object), methodBody, false, null)); }
protected virtual Expression VisitTypeDefinitionExpression(TypeDefinitionExpression expression) { Expression header = null, body = null; if (expression.Header != null) { header = this.Visit(expression.Header); } if (expression.Body != null) { body = this.Visit(expression.Body); } if (header != expression.Header || body != expression.Body) { return(new TypeDefinitionExpression(expression.Type, header, body, expression.IsPredeclaration, expression.Attributes, expression.InterfaceTypes)); } return(expression); }
protected override Expression VisitTypeDefinitionExpression(TypeDefinitionExpression expression) { currentTypeDefinitionExpression = expression; var comment = new CommentExpression("This file is AUTO GENERATED"); var client = new FieldDefinitionExpression("webServiceClient", webServiceClientType, AccessModifiers.Private | AccessModifiers.Constant); var body = GroupedExpressionsExpression.FlatConcat ( GroupedExpressionsExpressionStyle.Wide, client, CreateDefaultConstructor(), CreateParameterisedConstructor(), this.Visit(expression.Body) ); var header = new Expression[] { comment }.ToGroupedExpression(GroupedExpressionsExpressionStyle.Wide); return(new TypeDefinitionExpression(expression.Type, header, body, false, expression.Attributes, expression.InterfaceTypes)); }
protected override Expression VisitTypeDefinitionExpression(TypeDefinitionExpression expression) { var comment = new CommentExpression("This file is AUTO GENERATED"); var includeExpressions = new List <IncludeExpression> { FickleExpression.Include("System"), FickleExpression.Include("System.Collections.Generic") }; foreach (var include in this.codeGenerationContext.Options.Includes) { includeExpressions.Add(FickleExpression.Include(include)); } var headerGroup = includeExpressions.ToStatementisedGroupedExpression(); var header = new Expression[] { comment, headerGroup }.ToStatementisedGroupedExpression(GroupedExpressionsExpressionStyle.Wide); var typeDefinitionExpression = new TypeDefinitionExpression(expression.Type, null, expression.Body, false, expression.Attributes, expression.InterfaceTypes); return(new NamespaceExpression(this.codeGenerationContext.Options.Namespace, header, typeDefinitionExpression)); }
protected override Expression VisitTypeDefinitionExpression(TypeDefinitionExpression expression) { this.currentTypeDefinitionExpression = expression; var includeExpressions = new List <IncludeExpression> { FickleExpression.Include("System"), FickleExpression.Include("System.Collections.Generic"), FickleExpression.Include("System.Threading.Tasks") }; foreach (var include in this.CodeGenerationContext.Options.Includes) { includeExpressions.Add(FickleExpression.Include(include)); } var comment = new CommentExpression("This file is AUTO GENERATED"); var hostname = new FieldDefinitionExpression(HostnameFieldName, typeof(string), AccessModifiers.Public | AccessModifiers.Static | AccessModifiers.ReadOnly); var client = new FieldDefinitionExpression(FickleApiClientFieldName, this.fickleApiClientType, AccessModifiers.Private | AccessModifiers.ReadOnly); var body = GroupedExpressionsExpression.FlatConcat ( GroupedExpressionsExpressionStyle.Wide, hostname, client, this.CreateStaticConstructor(), this.CreateParameterisedConstructor(), this.Visit(expression.Body) ); var headerGroup = includeExpressions.Sorted(IncludeExpression.Compare).ToGroupedExpression(); var header = new Expression[] { comment, headerGroup }.ToGroupedExpression(GroupedExpressionsExpressionStyle.Wide); var typeDefinitionExpression = new TypeDefinitionExpression(expression.Type, null, body, false, expression.Attributes, expression.InterfaceTypes); return(new NamespaceExpression(this.CodeGenerationContext.Options.Namespace, header, typeDefinitionExpression)); }
private Expression CreateCopyWithZoneMethod(TypeDefinitionExpression expression) { var currentType = (FickleType)expression.Type; var zone = FickleExpression.Parameter("NSZone", "zone"); var self = Expression.Parameter(currentType, "self"); var theCopy = Expression.Variable(expression.Type, "theCopy"); Expression newExpression; if (expression.Type.BaseType == typeof(object)) { newExpression = FickleExpression.Call(FickleExpression.Call(FickleExpression.Call(self, "Class", "class", null), "allocWithZone", zone), expression.Type, "init", null); } else { var super = FickleExpression.Variable(expression.Type.BaseType.Name, "super"); newExpression = FickleExpression.Call(super, FickleType.Define("id"), "copyWithZone", zone); } var initTheCopy = Expression.Assign(theCopy, newExpression).ToStatement(); var returnStatement = Expression.Return(Expression.Label(), theCopy).ToStatement(); var copyStatements = PropertiesToCopyExpressionBinder.Bind(codeGenerationContext, expression, zone, theCopy); Expression methodBody = Expression.Block ( new[] { theCopy }, initTheCopy, FickleExpression.GroupedWide ( copyStatements, returnStatement ) ); return(new MethodDefinitionExpression("copyWithZone", new Expression[] { zone }.ToReadOnlyCollection(), typeof(object), methodBody, false, null)); }
protected abstract void GenerateGateway(CodeGenerationContext codeGenerationContext, TypeDefinitionExpression expression);
protected override void GenerateGateway(CodeGenerationContext codeGenerationContext, TypeDefinitionExpression expression) { using (var writer = this.GetTextWriterForFile(expression.Type.Name + ".js")) { var classFileExpression = GatewayExpressionBinder.Bind(codeGenerationContext, expression); var codeGenerator = new JavascriptCodeGenerator(writer); codeGenerator.Generate(classFileExpression); } }
protected override void GenerateEnum(CodeGenerationContext codeGenerationContext, TypeDefinitionExpression expression) { }
protected override Expression VisitTypeDefinitionExpression(TypeDefinitionExpression expression) { if (expression.Header != null) { this.Visit(expression.Header); this.WriteLine(); this.WriteLine(); } var fickleType = expression.Type as FickleType; if (fickleType != null && fickleType.IsClass) { this.Write("public class "); this.Write(expression.Type.Name, true); if (expression.Type.BaseType != null && expression.Type.BaseType != typeof(Object)) { this.Write(" extends "); this.Write(expression.Type.BaseType, true); } this.WriteLine(); using (this.AcquireIndentationContext(BraceLanguageStyleIndentationOptions.IncludeBracesNewLineAfter)) { this.Visit(expression.Body); this.WriteLine(); } } else if (fickleType != null && fickleType.BaseType == typeof(Enum)) { this.WriteLine("public enum " + expression.Type.Name); using (this.AcquireIndentationContext(BraceLanguageStyleIndentationOptions.IncludeBracesNewLineAfter)) { var expressions = ((GroupedExpressionsExpression)expression.Body).Expressions; var i = 0; foreach (Expression rootExpression in expressions) { if (rootExpression is GroupedExpressionsExpression) { var binaryExpressions = ((GroupedExpressionsExpression)rootExpression).Expressions; foreach (Expression binaryExpression in binaryExpressions) { var assignment = (BinaryExpression)binaryExpression; this.Write(((ParameterExpression)assignment.Left).Name); this.Write("("); this.Visit(assignment.Right); this.Write(")"); if (i++ != binaryExpressions.Count - 1) { this.WriteLine(','); } else { this.WriteLine(';'); } } } else { this.Visit(rootExpression); } this.WriteLine(); } } } return(expression); }
protected override Expression VisitTypeDefinitionExpression(TypeDefinitionExpression expression) { this.currentType = expression.Type; this.currentTypeDefinitionExpression = expression; this.currentReturnTypes = new HashSet <Type>(ReturnTypesCollector.CollectReturnTypes(expression)); var includeExpressions = new List <IncludeExpression> { FickleExpression.Include(expression.Type.Name + ".h"), FickleExpression.Include("PKWebServiceClient.h"), FickleExpression.Include("NSArray+PKExtensions.h"), FickleExpression.Include(this.CodeGenerationContext.Options.ResponseStatusTypeName + ".h") }; var comment = new CommentExpression("This file is AUTO GENERATED"); var expressions = new List <Expression> { CreateCreateClientMethod(), CreateInitMethod(), CreateInitWithOptionsMethod() }; var rawParameterTypes = ParameterTypesCollector .Collect(expression, c => c.Attributes["Method"].EqualsIgnoreCase("post") && c.Attributes.ContainsKey("Content")) .Select(c => new Tuple <Type, string>(c.Item1.GetFickleListElementType() ?? c.Item1, c.Item2)) .Select(c => new Tuple <Type, string>(c.Item1.GetUnwrappedNullableType(), c.Item2)) .Distinct(); foreach (var value in rawParameterTypes .Select(c => new { Type = c.Item1, Name = this.GetNormalizeRequestMethodName(c.Item1, c.Item2), Format = c.Item2 }) .GroupBy(c => c.Name) .Select(c => c.First())) { var type = value.Type; var format = value.Format; expressions.Add(this.CreateNormalizeRequestObjectMethod(type, format)); } expressions.Add(this.Visit(expression.Body)); if (methodCount > 0) { expressions.Add(this.CreateCreateErrorResponseWithErrorCodeMethod()); expressions.Add(this.CreateParseResultMethod()); } expressions.Add(this.CreateSerializeRequestMethod()); var body = GroupedExpressionsExpression.FlatConcat ( GroupedExpressionsExpressionStyle.Wide, expressions.ToArray() ); var singleValueResponseTypes = currentReturnTypes.Where(c => c.GetUnwrappedNullableType().IsPrimitive).Select(c => FickleType.Define(ObjectiveBinderHelpers.GetValueResponseWrapperTypeName(c))).ToList(); var referencedTypes = ReferencedTypesCollector.CollectReferencedTypes(body).Concat(singleValueResponseTypes).Distinct().ToList(); referencedTypes.Sort((x, y) => string.Compare(x.Name, y.Name, StringComparison.InvariantCultureIgnoreCase)); foreach (var referencedType in referencedTypes.Where(c => (c as FickleType)?.ServiceClass != null)) { includeExpressions.Add(FickleExpression.Include(referencedType.Name + ".h")); } var headerGroup = includeExpressions.Sorted(IncludeExpression.Compare).ToGroupedExpression(); var header = new Expression[] { comment, headerGroup }.ToGroupedExpression(GroupedExpressionsExpressionStyle.Wide); this.currentType = null; return(new TypeDefinitionExpression(expression.Type, header, body, false, expression.Attributes)); }
protected override void GenerateGateway(CodeGenerationContext codeGenerationContext, TypeDefinitionExpression expression) { List <Expression> methods; using (var writer = this.GetTextWriterForFile(expression.Type.Name + ".m")) { var classFileExpression = GatewaySourceExpressionBinder.Bind(codeGenerationContext, expression); var codeGenerator = new ObjectiveCodeGenerator(writer); methods = ExpressionGatherer.Gather(classFileExpression, ServiceExpressionType.MethodDefinition); codeGenerator.Generate(classFileExpression); } using (var writer = this.GetTextWriterForFile(expression.Type.Name + ".h")) { var headerFileExpression = GatewayHeaderExpressionBinder.Bind(codeGenerationContext, expression, methods.Cast <MethodDefinitionExpression>().ToList()); var codeGenerator = new ObjectiveCodeGenerator(writer); codeGenerator.Generate(headerFileExpression); } }
protected override void GenerateClass(CodeGenerationContext codeGenerationContext, TypeDefinitionExpression expression) { using (var writer = this.GetTextWriterForFile(expression.Type.Name + ".h")) { var headerFileExpression = ClassHeaderExpressionBinder.Bind(codeGenerationContext, expression); var codeGenerator = new ObjectiveCodeGenerator(writer); codeGenerator.Generate(headerFileExpression); } using (var writer = this.GetTextWriterForFile(expression.Type.Name + ".m")) { var classFileExpression = ClassSourceExpressionBinder.Bind(codeGenerationContext, expression); var codeGenerator = new ObjectiveCodeGenerator(writer); codeGenerator.Generate(classFileExpression); } }
protected override Expression VisitTypeDefinitionExpression(TypeDefinitionExpression expression) { var includeExpressions = new List <IncludeExpression>(); var importExpressions = new List <Expression>(); var referencedTypes = ReferencedTypesCollector.CollectReferencedTypes(expression); referencedTypes.Sort((x, y) => String.Compare(x.Name, y.Name, StringComparison.InvariantCultureIgnoreCase)); var lookup = new HashSet <Type>(referencedTypes.Where(TypeSystem.IsPrimitiveType)); if (!this.codeGenerationContext.Options.ImportDependenciesAsFramework) { if (lookup.Contains(typeof(Guid)) || lookup.Contains(typeof(Guid?))) { includeExpressions.Add(FickleExpression.Include("PKUUID.h")); } if (lookup.Contains(typeof(TimeSpan)) || lookup.Contains(typeof(TimeSpan?))) { includeExpressions.Add(FickleExpression.Include("PKTimeSpan.h")); } includeExpressions.Add(FickleExpression.Include("PKDictionarySerializable.h")); includeExpressions.Add(FickleExpression.Include("PKFormEncodingSerializable.h")); } else { importExpressions.Add(new CodeLiteralExpression(c => c.WriteLine("@import PlatformKit;"))); } if (ObjectiveBinderHelpers.TypeIsServiceClass(expression.Type.BaseType)) { includeExpressions.Add(FickleExpression.Include(expression.Type.BaseType.Name + ".h")); } includeExpressions.AddRange(referencedTypes.Where(c => c.IsEnum).Select(c => FickleExpression.Include(c.Name + ".h"))); includeExpressions.Sort(IncludeExpression.Compare); var comment = new CommentExpression("This file is AUTO GENERATED"); var headerExpressions = new List <Expression>() { new[] { comment }.ToStatementisedGroupedExpression(), importExpressions.Count == 0 ? null : importExpressions.ToStatementisedGroupedExpression(), includeExpressions.ToStatementisedGroupedExpression() }; var referencedTypeExpressions = referencedTypes .Where(ObjectiveBinderHelpers.TypeIsServiceClass) .Where(c => c != expression.Type.BaseType) .OrderBy(x => x.Name.Length) .ThenBy(x => x.Name) .Select(c => (Expression) new ReferencedTypeExpression(c)).ToList(); if (referencedTypeExpressions.Count > 0) { headerExpressions.Add(referencedTypeExpressions.ToStatementisedGroupedExpression()); } var header = headerExpressions.ToStatementisedGroupedExpression(GroupedExpressionsExpressionStyle.Wide); var propertyBody = this.Visit(expression.Body); var interfaceTypes = new List <Type> { FickleType.Define("NSCopying"), FickleType.Define("PKDictionarySerializable"), FickleType.Define("PKFormEncodingSerializable") }; return(new TypeDefinitionExpression(expression.Type, header, propertyBody, true, expression.Attributes, interfaceTypes.ToReadOnlyCollection())); }
protected override Expression VisitTypeDefinitionExpression(TypeDefinitionExpression expression) { this.AddType(expression.Type.BaseType); return(base.VisitTypeDefinitionExpression(expression)); }
protected override Expression VisitTypeDefinitionExpression(TypeDefinitionExpression expression) { if (expression.Header != null) { this.Visit(expression.Header); this.WriteLine(); } var type = expression.Type as FickleType; if (type != null && type.IsClass) { if (!expression.IsPredeclaration) { this.WriteLine("#pragma clang diagnostic push"); this.WriteLine("#pragma clang diagnostic ignored \"-Wparentheses\""); this.WriteLine("#pragma clang diagnostic ignored \"-Wdeprecated-declarations\""); this.WriteLine(); } if (expression.IsPredeclaration) { this.Write("@interface "); this.Write(expression.Type, true); this.Write(" : "); this.Write(expression.Type.BaseType, true); if (expression.InterfaceTypes != null && expression.InterfaceTypes.Count > 0) { this.Write("<"); this.Write(expression.InterfaceTypes.Select(c => c.Name).ToList().JoinToString(", ")); this.Write(">"); } } else { this.Write("@implementation "); this.Write(expression.Type, true); } this.WriteLine(); this.Visit(expression.Body); this.WriteLine("@end"); this.WriteLine(); if (!expression.IsPredeclaration) { this.WriteLine("#pragma clang diagnostic pop"); } } else if (type != null && type.BaseType == typeof(Enum)) { this.Write($"typedef {(expression.Attributes.ContainsKey("flags") ? "NS_OPTIONS" : "NS_ENUM")}(NSInteger, "); this.Write(expression.Type); this.WriteLine(@")"); using (this.AcquireIndentationContext(BraceLanguageStyleIndentationOptions.IncludeBraces)) { var expressions = ((GroupedExpressionsExpression)expression.Body).Expressions; var i = 0; foreach (var assignment in expressions.Cast <BinaryExpression>()) { this.Write(((ParameterExpression)assignment.Left).Name); this.Write(" = "); this.Visit(assignment.Right); if (i++ != expressions.Count - 1) { this.Write(','); } this.WriteLine(); } } this.WriteLine(";"); } return(expression); }
protected override Expression VisitTypeDefinitionExpression(TypeDefinitionExpression expression) { var includeExpressions = new List <IncludeExpression>(); var importExpressions = new List <Expression>(); var optionsProperty = new PropertyDefinitionExpression("options", FickleType.Define("NSDictionary"), true); var responseFilterProperty = new PropertyDefinitionExpression("responseFilter", FickleType.Define("FKGatewayResponseFilter", isInterface: true), true, new[] { "weak" }); var body = FickleExpression.GroupedWide ( optionsProperty, responseFilterProperty, new GroupedExpressionsExpression(methods.Select(c => c.ChangePredeclaration(true))) ); var referencedTypes = ReferencedTypesCollector.CollectReferencedTypes(body); referencedTypes.Sort((x, y) => String.Compare(x.Name, y.Name, StringComparison.InvariantCultureIgnoreCase)); var lookup = new HashSet <Type>(referencedTypes.Where(TypeSystem.IsPrimitiveType)); if (!this.CodeGenerationContext.Options.ImportDependenciesAsFramework) { if (lookup.Contains(typeof(Guid)) || lookup.Contains(typeof(Guid?))) { includeExpressions.Add(FickleExpression.Include("PKUUID.h")); } if (lookup.Contains(typeof(TimeSpan)) || lookup.Contains(typeof(TimeSpan?))) { includeExpressions.Add(FickleExpression.Include("PKTimeSpan.h")); } includeExpressions.Add(FickleExpression.Include("PKWebServiceClient.h")); includeExpressions.Add(FickleExpression.Include("PKDictionarySerializable.h")); } else { importExpressions.Add(new CodeLiteralExpression(c => c.WriteLine("@import PlatformKit;"))); } includeExpressions.Add(FickleExpression.Include("FKGatewayResponseFilter.h")); var referencedUserTypes = referencedTypes .Where(c => (c is FickleType && ((FickleType)c).ServiceClass != null) || c is FickleType && ((FickleType)c).ServiceEnum != null) .Sorted((x, y) => x.Name.Length == y.Name.Length ? String.CompareOrdinal(x.Name, y.Name) : x.Name.Length - y.Name.Length); includeExpressions.AddRange(referencedUserTypes.Select(c => FickleExpression.Include(c.Name + ".h"))); var comment = new CommentExpression("This file is AUTO GENERATED"); var header = new Expression[] { comment, importExpressions.Count == 0 ? null : importExpressions.ToStatementisedGroupedExpression(), includeExpressions.Sorted(IncludeExpression.Compare).ToStatementisedGroupedExpression() }.ToStatementisedGroupedExpression(GroupedExpressionsExpressionStyle.Wide); var interfaceTypes = new List <Type>(); if (expression.InterfaceTypes != null) { interfaceTypes.AddRange(expression.InterfaceTypes); } interfaceTypes.Add(FickleType.Define("PKWebServiceClientDelegate")); return(new TypeDefinitionExpression(expression.Type, header, body, true, expression.Attributes, interfaceTypes.ToReadOnlyCollection())); }
protected override void GenerateEnum(CodeGenerationContext codeGenerationContext, TypeDefinitionExpression expression) { using (var writer = this.GetTextWriterForFile(expression.Type.Name + ".java")) { var enumFileExpression = EnumExpressionBinder.Bind(codeGenerationContext, expression); var codeGenerator = new JavaCodeGenerator(writer); codeGenerator.Generate(enumFileExpression); } }