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