/** Adds a method to this type. */
public final void addMethod(JMethod method) {
assert method.getEnclosingType() == this;
assert !method.getName().equals("$clinit") || getMethods().size() == 0
: "Attempted adding " + "$clinit method with index != 0";
assert !method.getName().equals("$init") || getMethods().size() == 1
: "Attempted adding $init " + "method with index != 1";
methods = Lists.add(methods, method);
}
public void addMethod(JMethod jMethod) throws IllegalArgumentException {
if (jMethod == null) {
throw new IllegalArgumentException("Class methods cannot be null");
}
// -- check method name and signatures *add later*
// -- keep method list sorted for esthetics when printing
// -- START SORT :-)
boolean added = false;
short modifierVal = 0;
JModifiers modifiers = jMethod.getModifiers();
for (int i = 0; i < methods.size(); i++) {
JMethod tmp = (JMethod) methods.elementAt(i);
// -- first compare modifiers
if (tmp.getModifiers().isPrivate()) {
if (!modifiers.isPrivate()) {
methods.insertElementAt(jMethod, i);
added = true;
break;
}
}
// -- compare names
if (jMethod.getName().compareTo(tmp.getName()) < 0) {
methods.insertElementAt(jMethod, i);
added = true;
break;
}
}
// -- END SORT
if (!added) methods.addElement(jMethod);
// -- check parameter packages to make sure we have them
// -- in our import list
String[] pkgNames = jMethod.getParameterClassNames();
for (int i = 0; i < pkgNames.length; i++) {
addImport(pkgNames[i]);
}
// -- check return type to make sure it's included in the
// -- import list
JType jType = jMethod.getReturnType();
if (jType != null) {
while (jType.isArray()) jType = jType.getComponentType();
if (!jType.isPrimitive()) addImport(((JClass) jType).getName());
}
// -- check exceptions
JClass[] exceptions = jMethod.getExceptions();
for (int i = 0; i < exceptions.length; i++) {
addImport(exceptions[i].getName());
}
} // -- addMethod
public static boolean isInit(JMethod method) {
JDeclaredType enclosingType = method.getEnclosingType();
if (method.isStatic()) {
// Hack, check the name.
return method.getName().equals(GwtAstBuilder.STATIC_INIT_NAME);
}
boolean isInit = enclosingType != null && method == enclosingType.getInitMethod();
assert !isInit || method.getName().equals(GwtAstBuilder.INIT_NAME);
return isInit;
}
private void emitBody(SourceWriter w) throws NotFoundException {
JClassType baseClass =
context_.getTypeOracle().getType("org.rstudio.core.client.js.JsObjectInjector");
JClassType c = baseType_.asParameterizationOf(baseClass.isGenericType());
JType typeToInject = c.isParameterized().getTypeArgs()[0];
w.print("public native final void injectObject(");
w.print(typeToInject.getQualifiedSourceName());
w.println(" value) /*-{");
w.indent();
w.println(baseExpression_ + " = {");
w.indent();
JMethod[] methods = typeToInject.isClassOrInterface().getMethods();
for (int i = 0; i < methods.length; i++) {
JMethod method = methods[i];
final JParameter[] jParameters = method.getParameters();
StringBuilder argString = new StringBuilder();
for (int j = 0; j < jParameters.length; j++) {
argString.append("_").append(j);
if (j < jParameters.length - 1) argString.append(", ");
}
w.println(method.getName() + ": function(" + argString + ") {");
w.indent();
if (!method.getReturnType().getQualifiedSourceName().equals("void")) w.print("return ");
w.print("value.@");
w.print(typeToInject.getQualifiedSourceName());
w.print("::");
w.print(method.getName());
w.print("(");
for (JParameter param : jParameters) w.print(param.getType().getJNISignature());
w.print(")(");
w.print(argString.toString());
w.println(");");
w.outdent();
w.print("}");
w.println((i < methods.length - 1) ? "," : "");
}
w.outdent();
w.println("};");
w.outdent();
w.println("}-*/;");
}
private String getRestMethod(JMethod method) throws UnableToCompleteException {
String restMethod = null;
if (method.getAnnotation(DELETE.class) != null) {
restMethod = METHOD_DELETE;
} else if (method.getAnnotation(GET.class) != null) {
restMethod = METHOD_GET;
} else if (method.getAnnotation(HEAD.class) != null) {
restMethod = METHOD_HEAD;
} else if (method.getAnnotation(OPTIONS.class) != null) {
restMethod = METHOD_OPTIONS;
} else if (method.getAnnotation(POST.class) != null) {
restMethod = METHOD_POST;
} else if (method.getAnnotation(PUT.class) != null) {
restMethod = METHOD_PUT;
} else if (method.getAnnotation(JSONP.class) != null) {
restMethod = METHOD_JSONP;
} else {
restMethod = method.getName();
if (!REST_METHODS.contains(restMethod)) {
getLogger()
.log(
ERROR,
"Invalid rest method. It must either have a lower case rest method name or have a javax rs method annotation: "
+ method.getReadableDeclaration());
throw new UnableToCompleteException();
}
}
return restMethod;
}
public static boolean isClinit(JMethod method) {
JDeclaredType enclosingType = method.getEnclosingType();
boolean isClinit = enclosingType != null && method == enclosingType.getClinitMethod();
assert !isClinit || method.getName().equals(GwtAstBuilder.CLINIT_NAME);
return isClinit;
}
public JMethod getMethod(String name, int startIndex) {
for (int i = startIndex; i < methods.size(); i++) {
JMethod jMethod = (JMethod) methods.elementAt(i);
if (jMethod.getName().equals(name)) return jMethod;
}
return null;
}
/**
* Returns the instance initializer ($init) method. Can only be called after making sure the class
* has an instance initializer method.
*
* @return The instance initializer method.
*/
public final JMethod getInitMethod() {
assert getMethods().size() > 1;
JMethod init = this.getMethods().get(1);
assert init != null;
assert init.getName().equals("$init");
return init;
}
/**
* Returns the class initializer method. Can only be called after making sure the class has a
* class initializer method.
*
* @return The class initializer method.
*/
public final JMethod getClinitMethod() {
assert getMethods().size() != 0;
JMethod clinit = this.getMethods().get(0);
assert clinit != null;
assert clinit.getName().equals("$clinit");
return clinit;
}
public static boolean isClinit(JMethod method) {
JDeclaredType enclosingType = method.getEnclosingType();
if ((enclosingType != null) && (method == enclosingType.getClinitMethod())) {
assert (method.getName().equals("$clinit"));
return true;
} else {
return false;
}
}
public static String getJsniSig(JMethod method, boolean addReturnType) {
StringBuilder sb = new StringBuilder();
sb.append(method.getName());
sb.append("(");
for (int i = 0; i < method.getOriginalParamTypes().size(); ++i) {
JType type = method.getOriginalParamTypes().get(i);
sb.append(type.getJsniSignatureName());
}
sb.append(")");
if (addReturnType) {
sb.append(method.getOriginalReturnType().getJsniSignatureName());
}
return sb.toString();
}
public void addType(JDeclaredType type) {
allTypes.add(type);
String name = type.getName();
putIntoTypeMap(name, type);
if (CODEGEN_TYPES_SET.contains(name)) {
codeGenTypes.add((JClassType) type);
}
if (IMMORTAL_CODEGEN_TYPES_SET.contains(name)) {
immortalCodeGenTypes.add((JClassType) type);
}
if (!typeNamesToIndex.contains(name)) {
return;
}
indexedTypes.put(type.getShortName(), type);
for (JMethod method : type.getMethods()) {
if (!method.isPrivate()) {
indexedMethods.put(type.getShortName() + '.' + method.getName(), method);
}
}
for (JField field : type.getFields()) {
indexedFields.put(type.getShortName() + '.' + field.getName(), field);
}
switch (name) {
case "java.lang.Object":
typeJavaLangObject = (JClassType) type;
break;
case "java.lang.String":
typeString = (JClassType) type;
break;
case "java.lang.Class":
typeClass = (JClassType) type;
break;
case JAVASCRIPTOBJECT:
typeSpecialJavaScriptObject = (JClassType) type;
break;
case CLASS_LITERAL_HOLDER:
typeSpecialClassLiteralHolder = (JClassType) type;
break;
}
}
public void addType(JDeclaredType type) {
allTypes.add(type);
String name = type.getName();
putIntoTypeMap(name, type);
if (CODEGEN_TYPES_SET.contains(name)) {
codeGenTypes.add((JClassType) type);
}
if (IMMORTAL_CODEGEN_TYPES_SET.contains(name)) {
immortalCodeGenTypes.add((JClassType) type);
}
if (typeNamesToIndex.contains(name)) {
indexedTypes.put(type.getShortName(), type);
for (JMethod method : type.getMethods()) {
if (!method.isPrivate()) {
indexedMethods.put(type.getShortName() + '.' + method.getName(), method);
}
}
for (JField field : type.getFields()) {
indexedFields.put(type.getShortName() + '.' + field.getName(), field);
}
if (name.equals("java.lang.Object")) {
typeJavaLangObject = (JClassType) type;
} else if (name.equals("java.lang.String")) {
typeString = (JClassType) type;
} else if (name.equals("java.lang.Enum")) {
typeJavaLangEnum = (JClassType) type;
} else if (name.equals("java.lang.Class")) {
typeClass = (JClassType) type;
} else if (name.equals(JAVASCRIPTOBJECT)) {
typeSpecialJavaScriptObject = (JClassType) type;
} else if (name.equals("com.google.gwt.lang.ClassLiteralHolder")) {
typeSpecialClassLiteralHolder = (JClassType) type;
} else if (name.equals("java.lang.Cloneable")) {
typeJavaLangCloneable = (JInterfaceType) type;
} else if (name.equals("java.io.Serializable")) {
typeJavaIoSerializable = (JInterfaceType) type;
}
}
}
private void writeMethodImpl(JMethod method) throws UnableToCompleteException {
boolean returnRequest = false;
if (method.getReturnType() != JPrimitiveType.VOID) {
if (!method.getReturnType().getQualifiedSourceName().equals(Request.class.getName())
&& !method
.getReturnType()
.getQualifiedSourceName()
.equals(JsonpRequest.class.getName())) {
getLogger()
.log(
ERROR,
"Invalid rest method. Method must have void, Request or JsonpRequest return types: "
+ method.getReadableDeclaration());
throw new UnableToCompleteException();
} else {
returnRequest = true;
}
}
Json jsonAnnotation = source.getAnnotation(Json.class);
final Style classStyle = jsonAnnotation != null ? jsonAnnotation.style() : Style.DEFAULT;
Options classOptions = source.getAnnotation(Options.class);
Options options = method.getAnnotation(Options.class);
p(method.getReadableDeclaration(false, false, false, false, true) + " {").i(1);
{
String restMethod = getRestMethod(method);
LinkedList<JParameter> args =
new LinkedList<JParameter>(Arrays.asList(method.getParameters()));
// the last arg should be the callback.
if (args.isEmpty()) {
getLogger()
.log(
ERROR,
"Invalid rest method. Method must declare at least a callback argument: "
+ method.getReadableDeclaration());
throw new UnableToCompleteException();
}
JParameter callbackArg = args.removeLast();
JClassType callbackType = callbackArg.getType().isClassOrInterface();
JClassType methodCallbackType = METHOD_CALLBACK_TYPE;
if (callbackType == null || !callbackType.isAssignableTo(methodCallbackType)) {
getLogger()
.log(
ERROR,
"Invalid rest method. Last argument must be a "
+ methodCallbackType.getName()
+ " type: "
+ method.getReadableDeclaration());
throw new UnableToCompleteException();
}
JClassType resultType = getCallbackTypeGenericClass(callbackType);
String pathExpression = null;
Path pathAnnotation = method.getAnnotation(Path.class);
if (pathAnnotation != null) {
pathExpression = wrap(pathAnnotation.value());
}
JParameter contentArg = null;
HashMap<String, JParameter> queryParams = new HashMap<String, JParameter>();
HashMap<String, JParameter> formParams = new HashMap<String, JParameter>();
HashMap<String, JParameter> headerParams = new HashMap<String, JParameter>();
for (JParameter arg : args) {
PathParam paramPath = arg.getAnnotation(PathParam.class);
if (paramPath != null) {
if (pathExpression == null) {
getLogger()
.log(
ERROR,
"Invalid rest method. Invalid @PathParam annotation. Method is missing the @Path annotation: "
+ method.getReadableDeclaration());
throw new UnableToCompleteException();
}
pathExpression = pathExpression(pathExpression, arg, paramPath);
// .replaceAll(Pattern.quote("{" + paramPath.value() + "}"),
// "\"+com.google.gwt.http.client.URL.encodePathSegment(" + toStringExpression(arg) +
// ")+\"");
if (arg.getAnnotation(Attribute.class) != null) {
// allow part of the arg-object participate in as PathParam and the object goes over the
// wire
contentArg = arg;
}
continue;
}
QueryParam queryParam = arg.getAnnotation(QueryParam.class);
if (queryParam != null) {
queryParams.put(queryParam.value(), arg);
continue;
}
FormParam formParam = arg.getAnnotation(FormParam.class);
if (formParam != null) {
formParams.put(formParam.value(), arg);
continue;
}
HeaderParam headerParam = arg.getAnnotation(HeaderParam.class);
if (headerParam != null) {
headerParams.put(headerParam.value(), arg);
continue;
}
if (!formParams.isEmpty()) {
getLogger()
.log(
ERROR,
"You can not have both @FormParam parameters and a content parameter: "
+ method.getReadableDeclaration());
throw new UnableToCompleteException();
}
if (contentArg != null) {
getLogger()
.log(
ERROR,
"Invalid rest method. Only one content parameter is supported: "
+ method.getReadableDeclaration());
throw new UnableToCompleteException();
}
contentArg = arg;
}
String acceptTypeBuiltIn = null;
if (callbackType.equals(TEXT_CALLBACK_TYPE)) {
acceptTypeBuiltIn = "CONTENT_TYPE_TEXT";
} else if (callbackType.equals(JSON_CALLBACK_TYPE)) {
acceptTypeBuiltIn = "CONTENT_TYPE_JSON";
} else if (callbackType.isAssignableTo(OVERLAY_CALLBACK_TYPE)) {
acceptTypeBuiltIn = "CONTENT_TYPE_JSON";
} else if (callbackType.equals(XML_CALLBACK_TYPE)) {
acceptTypeBuiltIn = "CONTENT_TYPE_XML";
}
p("final " + METHOD_CLASS + " __method =");
p("getResource()");
if (pathExpression != null) {
p(".resolve(" + pathExpression + ")");
}
for (Map.Entry<String, JParameter> entry : queryParams.entrySet()) {
String expr = entry.getValue().getName();
JClassType type = entry.getValue().getType().isClassOrInterface();
if (type != null && isQueryParamListType(type)) {
p(
".addQueryParams("
+ wrap(entry.getKey())
+ ", "
+ toIteratedStringExpression(entry.getValue())
+ ")");
} else {
p(
".addQueryParam("
+ wrap(entry.getKey())
+ ", "
+ toStringExpression(entry.getValue().getType(), expr)
+ ")");
}
}
// example: .get()
p("." + restMethod + "();");
// Handle JSONP specific configuration...
JSONP jsonpAnnotation = method.getAnnotation(JSONP.class);
final boolean isJsonp = restMethod.equals(METHOD_JSONP) && jsonpAnnotation != null;
if (isJsonp) {
if (returnRequest
&& !method
.getReturnType()
.getQualifiedSourceName()
.equals(JsonpRequest.class.getName())) {
getLogger()
.log(
ERROR,
"Invalid rest method. JSONP method must have void or JsonpRequest return types: "
+ method.getReadableDeclaration());
throw new UnableToCompleteException();
}
if (jsonpAnnotation.callbackParam().length() > 0) {
p(
"(("
+ JSONP_METHOD_CLASS
+ ")__method).callbackParam("
+ wrap(jsonpAnnotation.callbackParam())
+ ");");
}
if (jsonpAnnotation.failureCallbackParam().length() > 0) {
p(
"(("
+ JSONP_METHOD_CLASS
+ ")__method).failureCallbackParam("
+ wrap(jsonpAnnotation.failureCallbackParam())
+ ");");
}
} else {
if (returnRequest
&& !method.getReturnType().getQualifiedSourceName().equals(Request.class.getName())) {
getLogger()
.log(
ERROR,
"Invalid rest method. Non JSONP method must have void or Request return types: "
+ method.getReadableDeclaration());
throw new UnableToCompleteException();
}
}
// configure the dispatcher
if (options != null && options.dispatcher() != Dispatcher.class) {
// use the dispatcher configured for the method.
p("__method.setDispatcher(" + options.dispatcher().getName() + ".INSTANCE);");
} else {
// use the default dispatcher configured for the service..
p("__method.setDispatcher(this.dispatcher);");
}
// configure the expected statuses..
if (options != null && options.expect().length != 0) {
// Using method level defined expected status
p("__method.expect(" + join(options.expect(), ", ") + ");");
} else if (classOptions != null && classOptions.expect().length != 0) {
// Using class level defined expected status
p("__method.expect(" + join(classOptions.expect(), ", ") + ");");
}
// configure the timeout
if (options != null && options.timeout() >= 0) {
// Using method level defined value
p("__method.timeout(" + options.timeout() + ");");
} else if (classOptions != null && classOptions.timeout() >= 0) {
// Using class level defined value
p("__method.timeout(" + classOptions.timeout() + ");");
}
if (jsonpAnnotation == null) {
Produces producesAnnotation = findAnnotationOnMethodOrEnclosingType(method, Produces.class);
if (producesAnnotation != null) {
p(
"__method.header("
+ RESOURCE_CLASS
+ ".HEADER_ACCEPT, "
+ wrap(producesAnnotation.value()[0])
+ ");");
} else {
// set the default accept header....
if (acceptTypeBuiltIn != null) {
p(
"__method.header("
+ RESOURCE_CLASS
+ ".HEADER_ACCEPT, "
+ RESOURCE_CLASS
+ "."
+ acceptTypeBuiltIn
+ ");");
} else {
p(
"__method.header("
+ RESOURCE_CLASS
+ ".HEADER_ACCEPT, "
+ RESOURCE_CLASS
+ ".CONTENT_TYPE_JSON);");
}
}
Consumes consumesAnnotation = findAnnotationOnMethodOrEnclosingType(method, Consumes.class);
if (consumesAnnotation != null) {
p(
"__method.header("
+ RESOURCE_CLASS
+ ".HEADER_CONTENT_TYPE, "
+ wrap(consumesAnnotation.value()[0])
+ ");");
}
// and set the explicit headers now (could override the accept header)
for (Map.Entry<String, JParameter> entry : headerParams.entrySet()) {
String expr = entry.getValue().getName();
p(
"__method.header("
+ wrap(entry.getKey())
+ ", "
+ toStringExpression(entry.getValue().getType(), expr)
+ ");");
}
}
if (!formParams.isEmpty()) {
p(FORM_POST_CONTENT_CLASS + " __formPostContent = new " + FORM_POST_CONTENT_CLASS + "();");
for (Map.Entry<String, JParameter> entry : formParams.entrySet()) {
p(
"__formPostContent.addParameter("
+ wrap(entry.getKey())
+ ", "
+ toFormStringExpression(entry.getValue(), classStyle)
+ ");");
}
p("__method.form(__formPostContent.getTextContent());");
}
if (contentArg != null) {
if (contentArg.getType() == STRING_TYPE) {
p("__method.text(" + contentArg.getName() + ");");
} else if (contentArg.getType() == JSON_VALUE_TYPE) {
p("__method.json(" + contentArg.getName() + ");");
} else if (contentArg.getType().isClass() != null
&& isOverlayArrayType(contentArg.getType().isClass())) {
p("__method.json(new " + JSON_ARRAY_CLASS + "(" + contentArg.getName() + "));");
} else if (contentArg.getType().isClass() != null
&& contentArg.getType().isClass().isAssignableTo(OVERLAY_VALUE_TYPE)) {
p("__method.json(new " + JSON_OBJECT_CLASS + "(" + contentArg.getName() + "));");
} else if (contentArg.getType() == DOCUMENT_TYPE) {
p("__method.xml(" + contentArg.getName() + ");");
} else {
JClassType contentClass = contentArg.getType().isClass();
if (contentClass == null) {
contentClass = contentArg.getType().isClassOrInterface();
if (!locator.isCollectionType(contentClass)) {
getLogger().log(ERROR, "Content argument must be a class.");
throw new UnableToCompleteException();
}
}
jsonAnnotation = contentArg.getAnnotation(Json.class);
Style style = jsonAnnotation != null ? jsonAnnotation.style() : classStyle;
// example:
// .json(Listings$_Generated_JsonEncoder_$.INSTANCE.encode(arg0)
// )
p(
"__method.json("
+ locator.encodeExpression(contentClass, contentArg.getName(), style)
+ ");");
}
}
List<AnnotationResolver> annotationResolvers = getAnnotationResolvers(context, getLogger());
getLogger()
.log(
TreeLogger.DEBUG,
"found " + annotationResolvers.size() + " additional AnnotationResolvers");
for (AnnotationResolver a : annotationResolvers) {
getLogger()
.log(
TreeLogger.DEBUG,
"("
+ a.getClass().getName()
+ ") resolve `"
+ source.getName()
+ "#"
+ method.getName()
+ "´ ...");
final Map<String, String[]> addDataParams =
a.resolveAnnotation(getLogger(), source, method, restMethod);
if (addDataParams != null) {
for (String s : addDataParams.keySet()) {
final StringBuilder sb = new StringBuilder();
final List<String> classList = Arrays.asList(addDataParams.get(s));
sb.append("[");
for (int i = 0; i < classList.size(); ++i) {
sb.append("\\\"").append(classList.get(i)).append("\\\"");
if ((i + 1) < classList.size()) {
sb.append(",");
}
}
sb.append("]");
getLogger()
.log(TreeLogger.DEBUG, "add call with (\"" + s + "\", \"" + sb.toString() + "\")");
p("__method.addData(\"" + s + "\", \"" + sb.toString() + "\");");
}
}
}
if (acceptTypeBuiltIn != null) {
// TODO: shouldn't we also have a cach in here?
p(returnRequest(returnRequest, isJsonp) + "__method.send(" + callbackArg.getName() + ");");
} else if (isJsonp) {
p(returnRequest(returnRequest, isJsonp)
+ "(("
+ JSONP_METHOD_CLASS
+ ")__method).send(new "
+ ABSTRACT_ASYNC_CALLBACK_CLASS
+ "<"
+ resultType.getParameterizedQualifiedSourceName()
+ ">(("
+ JSONP_METHOD_CLASS
+ ")__method, "
+ callbackArg.getName()
+ ") {")
.i(1);
{
p("protected "
+ resultType.getParameterizedQualifiedSourceName()
+ " parseResult("
+ JSON_VALUE_CLASS
+ " result) throws Exception {")
.i(1);
{
if (resultType.getParameterizedQualifiedSourceName().equals("java.lang.Void")) {
p("return (java.lang.Void) null;");
} else {
p("try {").i(1);
{
if (resultType.isAssignableTo(locator.LIST_TYPE)) {
p("result = new " + JSON_ARRAY_CLASS + "(result.getJavaScriptObject());");
}
jsonAnnotation = method.getAnnotation(Json.class);
Style style = jsonAnnotation != null ? jsonAnnotation.style() : classStyle;
p("return " + locator.decodeExpression(resultType, "result", style) + ";");
}
i(-1).p("} catch (Throwable __e) {").i(1);
{
p(
"throw new "
+ RESPONSE_FORMAT_EXCEPTION_CLASS
+ "(\"Response was NOT a valid JSON document\", __e);");
}
i(-1).p("}");
}
}
i(-1).p("}");
}
i(-1).p("});");
} else {
p("try {").i(1);
{
p(returnRequest(returnRequest, isJsonp)
+ "__method.send(new "
+ ABSTRACT_REQUEST_CALLBACK_CLASS
+ "<"
+ resultType.getParameterizedQualifiedSourceName()
+ ">(__method, "
+ callbackArg.getName()
+ ") {")
.i(1);
{
p("protected "
+ resultType.getParameterizedQualifiedSourceName()
+ " parseResult() throws Exception {")
.i(1);
{
if (resultType.getParameterizedQualifiedSourceName().equals("java.lang.Void")) {
p("return (java.lang.Void) null;");
} else {
p("try {").i(1);
{
jsonAnnotation = method.getAnnotation(Json.class);
Style style = jsonAnnotation != null ? jsonAnnotation.style() : classStyle;
p(
"return "
+ locator.decodeExpression(
resultType,
JSON_PARSER_CLASS + ".parse(__method.getResponse().getText())",
style)
+ ";");
}
i(-1).p("} catch (Throwable __e) {").i(1);
{
p(
"throw new "
+ RESPONSE_FORMAT_EXCEPTION_CLASS
+ "(\"Response was NOT a valid JSON document\", __e);");
}
i(-1).p("}");
}
}
i(-1).p("}");
}
i(-1).p("});");
}
i(-1).p("} catch (" + REQUEST_EXCEPTION_CLASS + " __e) {").i(1);
{
p(callbackArg.getName() + ".onFailure(__method,__e);");
if (returnRequest) {
p("return null;");
}
}
i(-1).p("}");
}
}
i(-1).p("}");
}
