protected Expression CreateGatewayCallMethod(MethodDefinitionExpression method, out ParameterExpression optionsParameter)
{
var methodName = method.Name.ToCamelCase();
methodCount++;
var self = Expression.Variable(currentType, "self");
var hostname = Expression.Variable(typeof(string), "hostname");
var port = Expression.Variable(typeof(string), "port");
var protocol = Expression.Variable(typeof(string), "protocol");
var optionsParam = FickleExpression.Parameter("NSDictionary", "options");
var localOptions = FickleExpression.Variable("NSMutableDictionary", "localOptions");
var requestObject = FickleExpression.Variable("NSObject", "requestObject");
var requestObjectValue = (Expression)Expression.Constant(null, typeof(object));
var url = Expression.Variable(typeof(string), "url");
var responseType = ObjectiveBinderHelpers.GetWrappedResponseType(this.CodeGenerationContext, method.ReturnType);
var variables = new [] { url, localOptions, protocol, hostname, requestObject, port };
var declaredHostname = currentTypeDefinitionExpression.Attributes["Hostname"];
var declaredPath = method.Attributes["Path"];
var path = StringUriUtils.Combine("%@://%@%@", declaredPath);
var httpMethod = method.Attributes["Method"];
var declaredProtocol = Convert.ToBoolean(method.Attributes["Secure"]) ? "https" : "http";
var retryBlockVariable = Expression.Variable(new FickleDelegateType(typeof(void), new FickleParameterInfo(FickleType.Define("id"), "block")), "retryBlock");
var retryBlockParameter = Expression.Variable(FickleType.Define("id"), "block");
var parametersByName = method.Parameters.ToDictionary(c => ((ParameterExpression)c).Name, c => (ParameterExpression)c, StringComparer.InvariantCultureIgnoreCase);
var formatInfo = ObjectiveStringFormatInfo.GetObjectiveStringFormatInfo(path, c => parametersByName[c]);
var args = formatInfo.ValueExpressions;
var parameters = formatInfo.ParameterExpressions;
var parameterInfos = new List <FickleParameterInfo>
{
new ObjectiveParameterInfo(typeof(string), "s"),
new ObjectiveParameterInfo(typeof(string), "protocol", true),
new ObjectiveParameterInfo(typeof(string), "hostname", true),
new ObjectiveParameterInfo(typeof(string), "port", true),
};
parameterInfos.AddRange(parameters.Select(c => new ObjectiveParameterInfo(c.Type, c.Name, true)));
var methodInfo = new FickleMethodInfo(typeof(string), typeof(string), "stringWithFormat", parameterInfos.ToArray(), true);
args.InsertRange(0, new Expression[] { Expression.Constant(formatInfo.Format), protocol, hostname, port });
var newParameters = new List <Expression>(method.Parameters)
{
optionsParam
};
var callback = Expression.Parameter(new FickleDelegateType(typeof(void), new FickleParameterInfo(responseType, "response")), "callback");
newParameters.Add(callback);
Expression blockArg = Expression.Parameter(FickleType.Define("id"), "arg1");
var returnType = method.ReturnType;
if (ObjectiveBinderHelpers.NeedsValueResponseWrapper(method.ReturnType))
{
returnType = FickleType.Define(ObjectiveBinderHelpers.GetValueResponseWrapperTypeName(method.ReturnType));
}
var responseFilter = FickleExpression.Property(self, "FKGatewayResponseFilter", "responseFilter");
var conversion = Expression.Convert(blockArg, returnType);
var innerRetryBlockBody = FickleExpression.Block
(
FickleExpression.Call(Expression.Convert(retryBlockParameter, retryBlockVariable.Type), typeof(void), "Invoke", new { block = retryBlockParameter }).ToStatement()
);
var innerRetryBlock = (Expression)FickleExpression.SimpleLambda
(
typeof(void), innerRetryBlockBody, new Expression[0]
);
var body = FickleExpression.GroupedWide
(
Expression.IfThen(Expression.NotEqual(responseFilter, Expression.Constant(null, responseFilter.Type)), Expression.Assign(blockArg, FickleExpression.Call(responseFilter, typeof(object), "gateway", new { value = self, receivedResponse = blockArg, fromRequestURL = url, withRequestObject = requestObject, retryBlock = innerRetryBlock, andOptions = localOptions })).ToStatementBlock()),
Expression.IfThen
(
Expression.AndAlso(Expression.NotEqual(blockArg, Expression.Constant(null, blockArg.Type)), Expression.NotEqual(callback, Expression.Constant(null, callback.Type))),
FickleExpression.Call(callback, "Invoke", conversion).ToStatementBlock()
)
);
var conversionBlock = FickleExpression.SimpleLambda(null, body, new Expression[0], blockArg);
var error = FickleExpression.Variable("NSError", "error");
Expression parseResultBlock;
var nsdataParam = Expression.Parameter(FickleType.Define("NSData"), "data");
var clientParam = Expression.Parameter(FickleType.Define("PKWebServiceClient"), "client");
var jsonObjectWithDataParameters = new[] { new FickleParameterInfo(FickleType.Define("NSDictionary"), "obj"), new FickleParameterInfo(typeof(int), "options"), new FickleParameterInfo(FickleType.Define("NSError", true), "error", true) };
var objectWithDataMethodInfo = new FickleMethodInfo(FickleType.Define("NSJSONSerialization"), FickleType.Define("NSData"), "JSONObjectWithData", jsonObjectWithDataParameters, true);
var deserializedValue = Expression.Parameter(FickleType.Define("id"), "deserializedValue");
var parseErrorResult = FickleExpression.Call(self, "webServiceClient", new
{
clientParam,
createErrorResponseWithErrorCode = "JsonDeserializationError",
andMessage = FickleExpression.Call(error, "localizedDescription", null)
});
if (method.ReturnType == typeof(void))
{
var responseObject = FickleExpression.Variable(responseType, "responseObject");
parseResultBlock = FickleExpression.SimpleLambda
(
FickleType.Define("id"),
FickleExpression.GroupedWide
(
Expression.Assign(responseObject, FickleExpression.New(responseType, "init", null)).ToStatement(),
Expression.Assign(deserializedValue, Expression.Call(objectWithDataMethodInfo, nsdataParam, FickleExpression.Variable(typeof(int), "NSJSONReadingAllowFragments"), error)).ToStatement(),
Expression.IfThen(Expression.Equal(deserializedValue, Expression.Constant(null)), FickleExpression.Return(parseErrorResult).ToStatementBlock()),
FickleExpression.Return(responseObject).ToStatement()
),
new Expression[] { deserializedValue, responseObject, error },
clientParam, nsdataParam
);
}
else if (TypeSystem.IsPrimitiveType(method.ReturnType) || method.ReturnType is FickleListType)
{
var responseObject = FickleExpression.Variable(responseType, "responseObject");
var needToBoxValue = ObjectiveBinderHelpers.ValueResponseValueNeedsBoxing(method.ReturnType);
parseResultBlock = FickleExpression.SimpleLambda
(
FickleType.Define("id"),
FickleExpression.GroupedWide
(
Expression.Assign(responseObject, FickleExpression.New(responseType, "init", null)).ToStatement(),
Expression.Assign(deserializedValue, Expression.Call(objectWithDataMethodInfo, nsdataParam, FickleExpression.Variable(typeof(int), "NSJSONReadingAllowFragments"), error)).ToStatement(),
Expression.IfThen(Expression.Equal(deserializedValue, Expression.Constant(null)), FickleExpression.Return(parseErrorResult).ToStatementBlock()),
PropertiesFromDictionaryExpressonBinder.GetDeserializeExpressionProcessValueDeserializer(method.ReturnType, deserializedValue, c => FickleExpression.Call(responseObject, typeof(void), "setValue", needToBoxValue ? Expression.Convert(c, typeof(object)) : c).ToStatement()),
FickleExpression.Return(responseObject).ToStatement()
),
new Expression[] { deserializedValue, responseObject, error },
clientParam, nsdataParam
);
}
else
{
parseResultBlock = FickleExpression.SimpleLambda
(
FickleType.Define("id"),
FickleExpression.GroupedWide
(
Expression.Assign(deserializedValue, Expression.Call(objectWithDataMethodInfo, nsdataParam, FickleExpression.Variable(typeof(int), "NSJSONReadingAllowFragments"), error)).ToStatement(),
PropertiesFromDictionaryExpressonBinder.GetDeserializeExpressionProcessValueDeserializer(method.ReturnType, deserializedValue, c => FickleExpression.Return(c).ToStatement()),
FickleExpression.Return(parseErrorResult).ToStatement()
),
new Expression[] { deserializedValue, error },
clientParam, nsdataParam
);
}
var uniqueNameMaker = new UniqueNameMaker(c => newParameters.Cast <ParameterExpression>().Any(d => d.Name.EqualsIgnoreCaseInvariant(c)));
var key = FickleExpression.Variable(typeof(string), uniqueNameMaker.Make("key"));
var integrateOptions = FickleExpression.ForEach
(
key,
optionsParam,
FickleExpression.Call(localOptions, typeof(void), "setObject", new { value = FickleExpression.Call(optionsParam, typeof(object), "objectForKey", key), forKey = key }).ToStatementBlock()
);
parseResultBlock = FickleExpression.Call(parseResultBlock, parseResultBlock.Type, "copy", null);
var client = Expression.Variable(FickleType.Define(this.CodeGenerationContext.Options.ServiceClientTypeName ?? "PKWebServiceClient"), "client");
Expression clientCallExpression;
if (httpMethod.Equals("get", StringComparison.InvariantCultureIgnoreCase))
{
clientCallExpression = FickleExpression.Call(client, "getWithCallback", conversionBlock);
}
else
{
var contentParameterName = method.Attributes["Content"];
var contentFormat = method.Attributes["ContentFormat"];
if (string.IsNullOrEmpty(contentParameterName))
{
clientCallExpression = FickleExpression.Call(client, "postWithRequestObject", new
{
requestObject,
andCallback = conversionBlock
});
}
else
{
var content = parametersByName[contentParameterName];
requestObjectValue = content.Type == typeof(byte[]) ? (Expression)content : FickleExpression.Call(self, typeof(object), this.GetNormalizeRequestMethodName(content.Type, contentFormat), new { serializeRequest = Expression.Convert(content, typeof(object)), paramName = Expression.Constant(contentParameterName) });
clientCallExpression = FickleExpression.Call(client, "postWithRequestObject", new
{
requestObject,
andCallback = conversionBlock
});
}
}
var retryBlock = (Expression)FickleExpression.SimpleLambda
(
typeof(void),
FickleExpression.StatementisedGroupedExpression
(
Expression.Assign(client, FickleExpression.Call(Expression.Variable(currentType, "self"), "PKWebServiceClient", "createClientWithURL", new
{
url,
options = localOptions
})),
Expression.Assign(FickleExpression.Property(client, currentType, "delegate"), self),
clientCallExpression
),
new Expression[] { client },
retryBlockParameter
);
retryBlock = FickleExpression.Call(retryBlock, retryBlock.Type, "copy", null);
var block = FickleExpression.Block
(
variables.Concat(retryBlockVariable).ToArray(),
Expression.Assign(requestObject, requestObjectValue),
Expression.Assign(callback, FickleExpression.Call(callback, callback.Type, "copy", null)),
Expression.Assign(localOptions, FickleExpression.Call(FickleExpression.Property(self, FickleType.Define("NSDictionary"), "options"), "NSMutableDictionary", "mutableCopyWithZone", new
{
zone = Expression.Constant(null, FickleType.Define("NSZone"))
})),
Expression.IfThen(Expression.NotEqual(requestObject, Expression.Constant(null)), FickleExpression.Call(localOptions, typeof(void), "setObject", new { value = requestObject, forKey = "$RequestObject" }).ToStatementBlock()),
FickleExpression.Call(localOptions, typeof(void), "setObject", new { value = FickleExpression.StaticCall(responseType, "class", null), forKey = "$ResponseClass" }).ToStatement(),
Expression.Assign(hostname, FickleExpression.Call(localOptions, typeof(string), "objectForKey", Expression.Constant("hostname"))),
Expression.IfThen(Expression.Equal(hostname, Expression.Constant(null)), Expression.Assign(hostname, Expression.Constant(declaredHostname)).ToStatementBlock()),
Expression.Assign(protocol, FickleExpression.Call(localOptions, typeof(string), "objectForKey", Expression.Constant("protocol"))),
Expression.IfThen(Expression.Equal(protocol, Expression.Constant(null)), Expression.Assign(protocol, Expression.Constant(declaredProtocol)).ToStatementBlock()),
Expression.Assign(port, FickleExpression.Call(FickleExpression.Call(localOptions, FickleType.Define("NSNumber"), "objectForKey", Expression.Constant("port")), typeof(string), "stringValue", null)),
Expression.IfThenElse(Expression.Equal(port, Expression.Constant(null)), Expression.Assign(port, Expression.Constant("")).ToStatementBlock(), Expression.Assign(port, FickleExpression.Call(Expression.Constant(":"), typeof(string), "stringByAppendingString", port)).ToStatementBlock()),
FickleExpression.Grouped
(
FickleExpression.Call(localOptions, "setObject", new
{
obj = parseResultBlock,
forKey = "$ParseResultBlock"
}).ToStatement(),
method.ReturnType.GetUnwrappedNullableType() == typeof(bool) ?
FickleExpression.Call(localOptions, "setObject", new
{
obj = Expression.Convert(Expression.Constant(1), typeof(object))
}).ToStatement() : null
),
Expression.Assign(url, Expression.Call(null, methodInfo, args)),
FickleExpression.Call(localOptions, typeof(void), "setObject", new { value = url, forKey = "$RequestURL" }).ToStatement(),
integrateOptions,
Expression.Assign(retryBlockVariable, retryBlock),
FickleExpression.Call(retryBlockVariable, typeof(void), "Invoke", retryBlockVariable).ToStatement()
);
optionsParameter = optionsParam;
return(new MethodDefinitionExpression(methodName, newParameters.ToReadOnlyCollection(), typeof(void), block, false, null));
}
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.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));
}
