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)); }
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 virtual void GenerateMasterHeader(ServiceModel serviceModel) { using (var writer = this.GetTextWriterForFile(this.Options.ServiceModelInfo.Name + ".h")) { var headerWriter = new ObjectiveCodeGenerator(writer); var includeExpressions = serviceModel.Classes .Select(c => FickleExpression.Include(c.Name + ".h")) .Concat(serviceModel.Enums.Select(c => FickleExpression.Include(c.Name + ".h"))) .Concat(serviceModel.Gateways.Select(c => FickleExpression.Include(c.Name + ".h"))); var comment = new CommentExpression("This file is AUTO GENERATED"); var commentGroup = new[] { comment }.ToStatementisedGroupedExpression(); var headerGroup = includeExpressions.ToStatementisedGroupedExpression(); var headerExpressions = new List <Expression> { commentGroup, headerGroup }; headerWriter.Visit(headerExpressions.ToGroupedExpression(GroupedExpressionsExpressionStyle.Wide)); } }
protected virtual MethodDefinitionExpression CreateSerializeRequestMethod() { var error = FickleExpression.Variable("NSError", "error"); var retval = FickleExpression.Variable("NSData", "retval"); var client = Expression.Parameter(FickleType.Define("PKWebServiceClient"), "client"); var requestObject = Expression.Parameter(FickleType.Define("id"), "serializeRequest"); var parameters = new[] { new FickleParameterInfo(FickleType.Define("NSDictionary"), "obj"), new FickleParameterInfo(FickleType.Define("NSJSONWritingOptions", false, true), "options"), new FickleParameterInfo(FickleType.Define("NSError"), "error", true) }; var methodInfo = new FickleMethodInfo(FickleType.Define("NSJSONSerialization"), FickleType.Define("NSData"), "dataWithJSONObject", parameters, true); var nsDataType = FickleType.Define("NSData"); var body = Fx.Block(error, retval) .If(Expression.Equal(requestObject, Expression.Constant(null, requestObject.Type))) .Assign(retval, Expression.New(FickleType.Define("NSData"))) .ElseIf(Expression.TypeIs(requestObject, typeof(string))) .Assign(retval, FickleExpression.Call(requestObject, typeof(string), "dataUsingEncoding", Expression.Variable(typeof(int), "NSUTF8StringEncoding"))) .ElseIf(Expression.TypeIs(requestObject, nsDataType)) .Assign(retval, Expression.Convert(requestObject, nsDataType)) .Else() .Assign(retval, Expression.Call(methodInfo, requestObject, Expression.Convert(Expression.Variable(typeof(int), "NSJSONReadingAllowFragments"), FickleType.Define("NSJSONWritingOptions", false, true)), error)) .EndIf() .Return(retval) .EndBlock(); return(new MethodDefinitionExpression ( "webServiceClient", new [] { client, requestObject }.ToReadOnlyCollection(), retval.Type, body, false, null )); }
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; } }
protected virtual MethodDefinitionExpression CreateCreateErrorResponseWithErrorCodeMethod() { var client = Expression.Parameter(FickleType.Define("PKWebServiceClient"), "client"); var errorCode = Expression.Parameter(typeof(string), "createErrorResponseWithErrorCode"); var message = Expression.Parameter(typeof(string), "andMessage"); var parameters = new Expression[] { client, errorCode, message }; var clientOptions = FickleExpression.Property(client, FickleType.Define("NSDictionary"), "options"); var response = FickleExpression.Variable(FickleType.Define("id"), "response"); var responseClass = FickleExpression.Call(clientOptions, "Class", "objectForKey", "$ResponseClass"); var responseStatus = FickleExpression.Call(response, "ResponseStatus", "responseStatus", null); var newResponseStatus = FickleExpression.New("ResponseStatus", "init", null); var body = FickleExpression.Block ( new [] { response }, Expression.Assign(response, FickleExpression.Call(FickleExpression.Call(responseClass, response.Type, "alloc", null), response.Type, "init", null)), Expression.IfThen(Expression.IsTrue(Expression.Equal(responseStatus, Expression.Constant(null, responseStatus.Type))), FickleExpression.Block(FickleExpression.Call(response, "setResponseStatus", newResponseStatus))), FickleExpression.StatementisedGroupedExpression ( FickleExpression.Call(responseStatus, typeof(string), "setErrorCode", errorCode), FickleExpression.Call(responseStatus, typeof(string), "setMessage", message) ), Expression.Return(Expression.Label(), response) ); return(new MethodDefinitionExpression("webServiceClient", parameters.ToReadOnlyCollection(), FickleType.Define("id"), body, false, null)); }
protected virtual MethodDefinitionExpression CreateCreateClientMethod() { var client = Expression.Variable(FickleType.Define("PKWebServiceClient"), "client"); var self = FickleExpression.Variable(currentType, "self"); var options = FickleExpression.Parameter(FickleType.Define("NSDictionary"), "options"); var url = Expression.Parameter(typeof(string), "urlIn"); var parameters = new Expression[] { url, options }; var operationQueue = FickleExpression.Call(options, "objectForKey", "OperationQueue"); var variables = new [] { client }; var body = FickleExpression.Block ( variables, Expression.Assign(client, FickleExpression.StaticCall("PKWebServiceClient", "PKWebServiceClient", "clientWithURL", new { url = FickleExpression.New("NSURL", "initWithString", url), options = options, operationQueue })), Expression.Return(Expression.Label(), client) ); return(new MethodDefinitionExpression("createClientWithURL", parameters.ToReadOnlyCollection(), FickleType.Define("PKWebServiceClient"), body, false, null)); }
protected override Expression VisitPropertyDefinitionExpression(PropertyDefinitionExpression property) { var self = Expression.Parameter(this.theCopy.Type, "self"); var propertyOnTheCopy = Expression.Property(this.theCopy, property.PropertyName); var propertyOnSelf = (Expression)Expression.Property(self, property.PropertyName); var propertyType = propertyOnTheCopy.Type; if (propertyType.GetFickleListElementType() != null) { propertyOnSelf = FickleExpression.New(propertyType, "initWithArray", new { oldArray = propertyOnSelf, copyItems = true }); } else if (propertyType is FickleType && !propertyType.IsValueType) { propertyOnSelf = Expression.Convert(FickleExpression.Call(propertyOnSelf, typeof(object), "copyWithZone", this.zone), propertyType); } else if (propertyType == typeof(string)) { propertyOnSelf = FickleExpression.Call(propertyOnSelf, typeof(string), "copy", null); } var assignExpression = Expression.Assign(propertyOnTheCopy, propertyOnSelf); this.statements.Add(assignExpression.ToStatement()); return(property); }
protected override Expression VisitPropertyDefinitionExpression(PropertyDefinitionExpression property) { var name = property.PropertyName.Uncapitalize(); fieldDefinitionsForProperties.Add(new FieldDefinitionExpression(name, property.PropertyType, AccessModifiers.Protected)); var thisProperty = FickleExpression.Variable(property.PropertyType, "this." + name); var getterBody = FickleExpression.Block ( new Expression[] { FickleExpression.Return(thisProperty) } ); var setterParam = FickleExpression.Parameter(property.PropertyType, name); var setterBody = FickleExpression.Block ( new Expression[] { Expression.Assign(thisProperty, setterParam) } ); var propertyGetter = new MethodDefinitionExpression("get" + property.PropertyName, new List <Expression>(), AccessModifiers.Public, property.PropertyType, getterBody, false); var propertySetter = new MethodDefinitionExpression("set" + property.PropertyName, new List <Expression> { setterParam }, AccessModifiers.Public, typeof(void), setterBody, false); return(new Expression[] { propertyGetter, propertySetter }.ToStatementisedGroupedExpression()); }
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)); }
protected virtual Expression CreateToStringMethod() { var value = Expression.Parameter(currentTypeDefinition.Type, "value"); var methodName = currentTypeDefinition.Type.Name.Capitalize() + "ToString"; var parameters = new Expression[] { value }; var array = FickleExpression.Variable("NSMutableArray", "array"); var temp = FickleExpression.Variable(currentTypeDefinition.Type, "temp"); var expressions = new List <Expression> { Expression.Assign(array, Expression.New(array.Type)) }; foreach (var enumValue in ((FickleType)currentTypeDefinition.Type).ServiceEnum.Values) { var currentEnumValue = Expression.Constant((int)enumValue.Value); expressions.Add ( Expression.IfThen ( Expression.Equal(Expression.And(currentEnumValue, Expression.Convert(value, typeof(int))), Expression.Convert(currentEnumValue, typeof(int))), FickleExpression.StatementisedGroupedExpression ( GroupedExpressionsExpressionStyle.Wide, FickleExpression.Call(array, typeof(void), "addObject", Expression.Constant(enumValue.Name)), Expression.Assign(temp, Expression.Convert(Expression.Or(Expression.Convert(temp, typeof(int)), currentEnumValue), currentTypeDefinition.Type)) ).ToBlock() ) ); } expressions.Add(Expression.IfThen(Expression.NotEqual(value, temp), FickleExpression.Return(FickleExpression.Call(Expression.Convert(value, typeof(object)), typeof(string), "stringValue", null)).ToStatementBlock())); expressions.Add(FickleExpression.Return(FickleExpression.Call(array, "componentsJoinedByString", Expression.Constant(",")))); var defaultBody = FickleExpression.StatementisedGroupedExpression ( GroupedExpressionsExpressionStyle.Wide, expressions.ToArray() ); var cases = new List <SwitchCase>(); foreach (var enumValue in ((FickleType)currentTypeDefinition.Type).ServiceEnum.Values) { cases.Add(Expression.SwitchCase(Expression.Return(Expression.Label(), Expression.Constant(enumValue.Name)).ToStatement(), Expression.Constant((int)enumValue.Value, currentTypeDefinition.Type))); } var switchStatement = Expression.Switch(value, defaultBody, cases.ToArray()); var body = FickleExpression.Block(new [] { array, temp }, switchStatement); return(new MethodDefinitionExpression(methodName, parameters.ToReadOnlyCollection(), AccessModifiers.Static | AccessModifiers.ClasseslessFunction, typeof(string), body, false, "__unused", null)); }
private Expression CreateDeserialiseStreamMethod() { var inputStream = Expression.Parameter(FickleType.Define("InputStream"), "in"); var jsonReaderType = FickleType.Define("JsonReader"); var jsonReader = Expression.Variable(jsonReaderType, "reader"); var result = Expression.Variable(currentType, "result"); var inputStreamReaderNew = FickleExpression.New(FickleType.Define("InputStreamReader"), "InputStreamReader", inputStream); var jsonReaderNew = FickleExpression.New(jsonReaderType, "JsonReader", inputStreamReaderNew); var jsonReaderNextString = FickleExpression.Call(jsonReader, "nextString", null); var resultCreate = Expression.Assign(result, FickleExpression.StaticCall(currentType, currentType, "deserialize", jsonReaderNextString)).ToStatement(); var jsonReaderClose = FickleExpression.Call(jsonReader, "close", null).ToStatement(); var exception = Expression.Variable(typeof(Exception), "exception");; var errorCodesVariable = Expression.Constant("DeserializationError", typeof(String)); var returnResult = FickleExpression.Return(result); var createErrorArguments = new { errorCode = errorCodesVariable, errorMessage = FickleExpression.Call(exception, "getMessage", null), stackTrace = FickleExpression.StaticCall(FickleType.Define("Log"), typeof(String), "getStackTraceString", exception), }; var resultCreateErrorResponse = Expression.Assign(result, FickleExpression.StaticCall(currentType, currentType, "createErrorResponse", createErrorArguments)).ToStatement(); var tryCatch = Expression.TryCatchFinally( resultCreate, jsonReaderClose, Expression.Catch(typeof(Exception), resultCreateErrorResponse)); var methodVariables = new List <ParameterExpression> { result, jsonReader }; var methodStatements = new List <Expression> { Expression.Assign(jsonReader, jsonReaderNew).ToStatement(), tryCatch, returnResult }; var body = FickleExpression.Block(methodVariables.ToArray(), methodStatements.ToArray()); return(new MethodDefinitionExpression("deserialize", new List <Expression>() { inputStream }, AccessModifiers.Public | AccessModifiers.Static, currentType, body, false, null, null, new List <Exception>() { new Exception() })); }
public static Expression ToUrlEncodedExpression(Expression value) { var cfstring = FickleType.Define("CFStringRef", isPrimitive: true); var charsToEncode = Expression.Convert(Expression.Constant("!*'\\\"();:@&= +$,/?%#[]% "), cfstring); var retval = Expression.Convert(FickleExpression.StaticCall((Type)null, cfstring, "CFURLCreateStringByAddingPercentEscapes", new { arg1 = (object)null, arg2 = Expression.Convert(value, cfstring), arg3 = (object)null, arg4 = charsToEncode, arg5 = Expression.Variable(typeof(int), "kCFStringEncodingUTF8") }), typeof(string)); return(retval); }
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)); }
private Expression CreateStaticConstructor() { var hostname = this.currentTypeDefinitionExpression.Attributes["Hostname"]; var hostnameField = Expression.Variable(typeof(string), HostnameFieldName); var body = FickleExpression.Block(Expression.Assign(hostnameField, Expression.Constant(hostname)).ToStatement()); var parameters = new Expression[0]; return(new MethodDefinitionExpression(this.currentTypeDefinitionExpression.Type.Name, parameters.ToReadOnlyCollection(), AccessModifiers.Static, null, body, false, null, null)); }
private MethodDefinitionExpression CreateInitMethod() { var self = FickleExpression.Variable(currentType, "self"); var method = new MethodDefinitionScope <MethodDefinitionExpression>("init", "id", null) .Return(c => c.Call(self, self.Type, "initWithOptions", FickleExpression.New("NSDictionary"))) .EndMethod(); return(method); }
private Expression CreateDefaultConstructor() { var client = Expression.Variable(webServiceClientType, "webServiceClient"); var valParam = Expression.New(webServiceClientType); var body = FickleExpression.Block(Expression.Assign(client, valParam).ToStatement()); return(new MethodDefinitionExpression(currentTypeDefinitionExpression.Type.Name, new Expression[] { }.ToReadOnlyCollection(), AccessModifiers.Public, null, body, false, null, null)); }
private Expression CreateDeserializeMethod() { var inputString = Expression.Parameter(typeof(String), "value"); var methodVariables = new List <ParameterExpression>(); var methodStatements = new List <Expression>(); if (codeGenerationContext.Options.SerializeEnumsAsStrings) { var returnResult = FickleExpression.Return(FickleExpression.StaticCall(currentType, "valueOf", inputString)); methodStatements.Add(returnResult); } else { var intValue = Expression.Variable(typeof(int), "intValue"); methodVariables.Add(intValue); var convertInt = Expression.Assign(intValue, FickleExpression.StaticCall("ConvertUtils", typeof(int), "toint", inputString)); methodStatements.Add(convertInt); Expression ifThenElseExpression = FickleExpression.Block(FickleExpression.Return(Expression.Constant(null))); foreach (var enumMemberExpression in ((FickleType)currentTypeDefinition.Type).ServiceEnum.Values) { var enumMemberName = enumMemberExpression.Name; var enumMemberValue = Expression.Variable(typeof(int), enumMemberName + ".value"); var enumMemberNameExpression = Expression.Variable(typeof(int), enumMemberName); var condition = Expression.Equal(intValue, enumMemberValue); var action = FickleExpression.Block(FickleExpression.Return(enumMemberNameExpression)); var currentExpression = Expression.IfThenElse(condition, action, ifThenElseExpression); ifThenElseExpression = currentExpression; } methodStatements.Add(ifThenElseExpression); } var body = FickleExpression.Block(methodVariables.ToArray(), methodStatements.ToArray()); return(new MethodDefinitionExpression("deserialize", new List <Expression>() { inputString }, AccessModifiers.Public | AccessModifiers.Static, currentType, body, false, null, null, new List <Exception>() { new Exception() })); }
private MethodDefinitionExpression CreateInitWithOptionsMethod() { var self = FickleExpression.Variable(currentType, "self"); var super = FickleExpression.Variable(currentType, "super"); var options = FickleExpression.Parameter("NSDictionary", "options"); var superinit = FickleExpression.Call(super, currentType, "init", null); var initBlock = FickleExpression.Block(Expression.Assign(FickleExpression.Property(self, "NSDictionary", "options"), options)); var body = FickleExpression.Block(Expression.IfThen(Expression.NotEqual(Expression.Assign(self, superinit), Expression.Constant(null, this.currentType)), initBlock), Expression.Return(Expression.Label(), self)); return(new MethodDefinitionExpression("initWithOptions", new Expression[] { options }.ToReadOnlyCollection(), FickleType.Define("id"), body, false, null)); }
protected virtual MethodDefinitionExpression CreateParseResultMethod() { var client = Expression.Parameter(FickleType.Define("PKWebServiceClient"), "client"); var data = Expression.Parameter(FickleType.Define("NSData"), "parseResult"); var contentType = Expression.Parameter(typeof(string), "withContentType"); var statusCode = Expression.Parameter(typeof(int), "andStatusCode"); var response = FickleExpression.Variable("id", "response"); var options = FickleExpression.Property(client, "NSDictionary", "options"); var parameters = new Expression[] { client, data, contentType, statusCode }; var bodyExpressions = new List <Expression>(); var delegateType = new FickleDelegateType(FickleType.Define("id"), new FickleParameterInfo(client.Type, "client"), new FickleParameterInfo(FickleType.Define("NSData"), "data")); var block = Expression.Variable(delegateType, "block"); bodyExpressions.Add(Expression.Assign(block, FickleExpression.Call(options, FickleType.Define("id"), "objectForKey", Expression.Constant("$ParseResultBlock")))); bodyExpressions.Add(Expression.Assign(response, FickleExpression.Call(block, "id", "Invoke", new { client, data })).ToStatement()); var setResponseStatus = Expression.IfThen ( Expression.Equal(FickleExpression.Call(response, "id", "responseStatus", null), Expression.Constant(null, FickleType.Define("id"))), FickleExpression.Call(response, "setResponseStatus", FickleExpression.New("ResponseStatus", "init", null)).ToStatementBlock() ); var populateResponseStatus = FickleExpression.Call(FickleExpression.Call(response, "id", "responseStatus", null), "setHttpStatus", statusCode); bodyExpressions.Add(setResponseStatus); bodyExpressions.Add(populateResponseStatus); bodyExpressions.Add(FickleExpression.Return(response)); var body = FickleExpression.Block ( new[] { response, block }, bodyExpressions.ToArray() ); return(new MethodDefinitionExpression ( "webServiceClient", parameters.ToReadOnlyCollection(), FickleType.Define("id"), body, false, null )); }
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 CreateParameterisedConstructor() { var fickleApiClientParam = Expression.Parameter(this.fickleApiClientType, FickleApiClientFieldName); var parameters = new Expression[] { fickleApiClientParam }; var clientField = Expression.Variable(this.fickleApiClientType, "this." + FickleApiClientFieldName); var body = FickleExpression.Block(Expression.Assign(clientField, fickleApiClientParam).ToStatement()); return(new MethodDefinitionExpression(this.currentTypeDefinitionExpression.Type.Name, parameters.ToReadOnlyCollection(), AccessModifiers.Public, null, body, false, null, null)); }
protected virtual Expression CreateConstructor() { var valParam = Expression.Parameter(typeof(int), "value"); var parameters = new Expression[] { valParam }; var valueMember = Expression.Variable(enumValueField.PropertyType, "this." + enumValueField.PropertyName); var body = FickleExpression.Block(Expression.Assign(valueMember, valParam).ToStatement()); return(new MethodDefinitionExpression(currentTypeDefinition.Type.Name, parameters.ToReadOnlyCollection(), null, body, false, null)); }
protected override Expression VisitPropertyDefinitionExpression(PropertyDefinitionExpression property) { var self = Expression.Variable(this.type, "self"); var retval = FickleExpression.Variable("NSDictionary", "retval"); var propertyExpression = FickleExpression.Property(self, property.PropertyType, property.PropertyName); var expression = GetSerializeExpression(property.PropertyType, propertyExpression, context.Options, false, c => FickleExpression.Call(retval, "setObject", new { obj = Expression.Convert(c, typeof(object)), forKey = Expression.Constant(property.PropertyName) }).ToStatement()); this.propertySetterExpressions.Add(new [] { FickleExpression.Comment(property.PropertyName), expression }.ToGroupedExpression(GroupedExpressionsExpressionStyle.Wide)); return(property); }
private Expression CreateSerializeMethod() { var self = Expression.Parameter(currentType, "this"); var jsonBuilder = FickleType.Define("DefaultJsonBuilder"); var jsonBuilderInstance = FickleExpression.StaticCall(jsonBuilder, "instance"); var toJsonCall = FickleExpression.Call(jsonBuilderInstance, "toJson", self); var defaultBody = Expression.Return(Expression.Label(), toJsonCall).ToStatement(); var body = FickleExpression.Block(defaultBody); return(new MethodDefinitionExpression("serialize", new List <Expression>(), AccessModifiers.Public, typeof(string), body, false, null)); }
private Expression CreateSerializeMethod() { var methodVariables = new List <ParameterExpression>(); var methodStatements = new List <Expression>(); var value = Expression.Parameter(currentTypeDefinition.Type, currentTypeDefinition.Type.Name.Uncapitalize()); if (codeGenerationContext.Options.SerializeEnumsAsStrings) { var result = FickleExpression.Variable(typeof(String), "result"); var defaultBody = Expression.Assign(result, Expression.Constant(null, typeof(string))).ToStatement(); var cases = new List <SwitchCase>(); foreach (var enumValue in ((FickleType)currentTypeDefinition.Type).ServiceEnum.Values) { var assignExpression = Expression.Assign(result, Expression.Constant(enumValue.Name)).ToStatement(); cases.Add(Expression.SwitchCase(assignExpression, Expression.Constant(enumValue.Name, currentTypeDefinition.Type))); } var switchStatement = Expression.Switch(value, defaultBody, cases.ToArray()); methodVariables.Add(result); methodStatements.Add(switchStatement); methodStatements.Add(Expression.Return(Expression.Label(), result).ToStatement()); } else { var enumValue = FickleExpression.Variable(typeof(int), value.Name + "." + enumValueField.PropertyName); var staticToStringCall = FickleExpression.StaticCall("ConvertUtils", "toString", enumValue); var returnResult = Expression.Return(Expression.Label(), staticToStringCall); methodStatements.Add(returnResult); } var body = FickleExpression.Block(methodVariables.ToArray(), methodStatements.ToArray()); return(new MethodDefinitionExpression("serialize", new List <Expression>() { value }, AccessModifiers.Static | AccessModifiers.Public, typeof(string), body, false, null, null)); }
private Expression CreateDeserializeReaderMethod() { var jsonReader = Expression.Parameter(FickleType.Define("JsonReader"), "reader"); var conditionNull = Expression.MakeBinary(ExpressionType.Equal, FickleExpression.Call(jsonReader, typeof(Enum), "peek", null), FickleExpression.Variable(typeof(Enum), "JsonToken.NULL")); var actionNull = FickleExpression.Block( new Expression[] { FickleExpression.Call(jsonReader, "skipValue", null), Expression.Continue(Expression.Label()) }); var self = FickleExpression.Variable(currentType, "this"); var whileStatements = new List <Expression> { Expression.IfThen(conditionNull, actionNull), FickleExpression.Call(self, "deserializeElement", jsonReader) }; var whileBody = FickleExpression.Block(whileStatements.ToArray()); var whileExpression = FickleExpression.While(FickleExpression.Call(jsonReader, "hasNext", null), whileBody); var methodVariables = new List <ParameterExpression>(); var methodStatements = new List <Expression> { FickleExpression.Call(jsonReader, "beginObject", null), whileExpression, FickleExpression.Call(jsonReader, "endObject", null), }; var body = FickleExpression.Block(methodVariables.ToArray(), methodStatements.ToArray()); return(new MethodDefinitionExpression("deserialize", new List <Expression>() { jsonReader }, AccessModifiers.Public, typeof(void), body, false, null, null, new List <Exception>() { new Exception() })); }
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)); }
protected override Expression VisitPropertyDefinitionExpression(PropertyDefinitionExpression property) { var dictionaryType = new FickleType("NSDictionary"); var currentValueFromDictionary = Expression.Parameter(typeof(object), "currentValueFromDictionary"); var objectForKeyCall = Expression.Call(Expression.Parameter(dictionaryType, "properties"), new FickleMethodInfo(dictionaryType, typeof(object), "objectForKey", new ParameterInfo[] { new FickleParameterInfo(typeof(string), "key") }), Expression.Constant(property.PropertyName)); var propertyExpression = Expression.Property(Expression.Parameter(this.type, "self"), new FicklePropertyInfo(this.type, property.PropertyType, property.PropertyName)); var expressions = new List <Expression> { FickleExpression.Comment(property.PropertyName), Expression.Assign(currentValueFromDictionary, objectForKeyCall).ToStatement(), GetDeserializeExpressionProcessValueDeserializer(property.PropertyType, currentValueFromDictionary, c => Expression.Assign(propertyExpression, c).ToStatement()) }; this.propertyGetterExpressions.Add(expressions.ToStatementisedGroupedExpression(GroupedExpressionsExpressionStyle.Wide)); return(property); }
public static Expression CreateSerializeArrayMethod(Type arrayType) { var array = Expression.Parameter(new FickleListType(arrayType), "array"); var jsonBuilder = FickleType.Define("DefaultJsonBuilder"); var jsonBuilderInstance = FickleExpression.StaticCall(jsonBuilder, "instance"); var toJsonCall = FickleExpression.Call(jsonBuilderInstance, "toJson", array); var defaultBody = Expression.Return(Expression.Label(), toJsonCall).ToStatement(); var body = FickleExpression.Block(defaultBody); return(new MethodDefinitionExpression("serializeArray", new List <Expression>() { array }, AccessModifiers.Public | AccessModifiers.Static, typeof(string), body, false, null)); }