/** * Create a new resource method invocable model. * * @param handler resource method handler. * @param definitionMethod method that is defined to be executed on the {@code handler}. * @param handlingMethod specific and concrete method to be actually executed as a resource method. If {@code null} * then the {@code definitionMethod} will be used. * @param encodedParameters {@code true} if the automatic parameter decoding * should be disabled, false otherwise. * @return Invocable. */ public static Invocable create(MethodHandler handler, Method definitionMethod, Method handlingMethod, boolean encodedParameters) { return new Invocable(handler, definitionMethod, handlingMethod, encodedParameters, null); }
/** * Create a new resource method invocable model. * * @param handler resource method handler. * @param definitionMethod method that is defined to be executed on the {@code handler}. * @param handlingMethod specific and concrete method to be actually executed as a resource method. If {@code null} * then the {@code definitionMethod} will be used. * @param encodedParameters {@code true} if the automatic parameter decoding * should be disabled, false otherwise. * @return Invocable. */ public static Invocable create(MethodHandler handler, Method definitionMethod, Method handlingMethod, boolean encodedParameters) { return new Invocable(handler, definitionMethod, handlingMethod, encodedParameters, null); }
/** * Create a new resource method invocable model. * * @param handler resource method handler. * @param definitionMethod method that is defined to be executed on the {@code handler}. * @param handlingMethod specific and concrete method to be actually executed as a resource method. If {@code null} * then the {@code definitionMethod} will be used. * @param encodedParameters {@code true} if the automatic parameter decoding * should be disabled, false otherwise. * @param routingResponseType response type that will be used during the routing for purpose * of selection of the resource method to be executed. If this parameter is * non-{@code null} then it will override the return type of the * {@link #getHandlingMethod() the Java handling method}) for purposes of * resource method selection. This might be useful in cases when resource * method returns a type {@code A} but thanks to registered providers * (eg. {@link javax.ws.rs.ext.WriterInterceptor}) it will be always converted * to type {@code B}. Then the method selecting algorithm would check presence of * {@link javax.ws.rs.ext.MessageBodyWriter} for type {@code A} (which will * never be actually needed) and might result in choosing undesired method. * If the parameter is {@code null} then the default response type will be used. * * @return Invocable. */ public static Invocable create(MethodHandler handler, Method definitionMethod, Method handlingMethod, boolean encodedParameters, Type routingResponseType) { return new Invocable(handler, definitionMethod, handlingMethod, encodedParameters, routingResponseType); }
/** * Create a new resource method invocable model. * * @param handler resource method handler. * @param definitionMethod method that is defined to be executed on the {@code handler}. * @param handlingMethod specific and concrete method to be actually executed as a resource method. If {@code null} * then the {@code definitionMethod} will be used. * @param encodedParameters {@code true} if the automatic parameter decoding * should be disabled, false otherwise. * @param routingResponseType response type that will be used during the routing for purpose * of selection of the resource method to be executed. If this parameter is * non-{@code null} then it will override the return type of the * {@link #getHandlingMethod() the Java handling method}) for purposes of * resource method selection. This might be useful in cases when resource * method returns a type {@code A} but thanks to registered providers * (eg. {@link javax.ws.rs.ext.WriterInterceptor}) it will be always converted * to type {@code B}. Then the method selecting algorithm would check presence of * {@link javax.ws.rs.ext.MessageBodyWriter} for type {@code A} (which will * never be actually needed) and might result in choosing undesired method. * If the parameter is {@code null} then the default response type will be used. * * @return Invocable. */ public static Invocable create(MethodHandler handler, Method definitionMethod, Method handlingMethod, boolean encodedParameters, Type routingResponseType) { return new Invocable(handler, definitionMethod, handlingMethod, encodedParameters, routingResponseType); }
/** * Create a new resource method invocable model. * * @param handler resource method handler. * @param definitionMethod method that is defined to be executed on the {@code handler}. * @param handlingMethod specific and concrete method to be actually executed as a resource method. If {@code null} * then the {@code definitionMethod} will be used. * @param encodedParameters {@code true} if the automatic parameter decoding * should be disabled, false otherwise. * @return Invocable. */ public static Invocable create(MethodHandler handler, Method definitionMethod, Method handlingMethod, boolean encodedParameters) { return new Invocable(handler, definitionMethod, handlingMethod, encodedParameters, null); }
/** * Create a new resource method invocable model. * * @param handler resource method handler. * @param definitionMethod method that is defined to be executed on the {@code handler}. * @param handlingMethod specific and concrete method to be actually executed as a resource method. If {@code null} * then the {@code definitionMethod} will be used. * @param encodedParameters {@code true} if the automatic parameter decoding * should be disabled, false otherwise. * @param routingResponseType response type that will be used during the routing for purpose * of selection of the resource method to be executed. If this parameter is * non-{@code null} then it will override the return type of the * {@link #getHandlingMethod() the Java handling method}) for purposes of * resource method selection. This might be useful in cases when resource * method returns a type {@code A} but thanks to registered providers * (eg. {@link javax.ws.rs.ext.WriterInterceptor}) it will be always converted * to type {@code B}. Then the method selecting algorithm would check presence of * {@link javax.ws.rs.ext.MessageBodyWriter} for type {@code A} (which will * never be actually needed) and might result in choosing undesired method. * If the parameter is {@code null} then the default response type will be used. * * @return Invocable. */ public static Invocable create(MethodHandler handler, Method definitionMethod, Method handlingMethod, boolean encodedParameters, Type routingResponseType) { return new Invocable(handler, definitionMethod, handlingMethod, encodedParameters, routingResponseType); }
/** * Create a new resource method invocable model. * * @param handler resource method handler. * @param definitionMethod method that is defined to be executed on the {@code handler}. * @param handlingMethod specific and concrete method to be actually executed as a resource method. If {@code null} * then the {@code definitionMethod} will be used. * @param encodedParameters {@code true} if the automatic parameter decoding * should be disabled, false otherwise. * @return Invocable. */ public static Invocable create(MethodHandler handler, Method definitionMethod, Method handlingMethod, boolean encodedParameters) { return new Invocable(handler, definitionMethod, handlingMethod, encodedParameters, null); }
/** * Create a new resource method invocable model. * * @param handler resource method handler. * @param definitionMethod method that is defined to be executed on the {@code handler}. * @param handlingMethod specific and concrete method to be actually executed as a resource method. If {@code null} * then the {@code definitionMethod} will be used. * @param encodedParameters {@code true} if the automatic parameter decoding * should be disabled, false otherwise. * @return Invocable. */ public static Invocable create(MethodHandler handler, Method definitionMethod, Method handlingMethod, boolean encodedParameters) { return new Invocable(handler, definitionMethod, handlingMethod, encodedParameters, null); }
/** * Create a new resource method invocable model. * * @param handler resource method handler. * @param definitionMethod method that is defined to be executed on the {@code handler}. * @param handlingMethod specific and concrete method to be actually executed as a resource method. If {@code null} * then the {@code definitionMethod} will be used. * @param encodedParameters {@code true} if the automatic parameter decoding * should be disabled, false otherwise. * @return Invocable. */ public static Invocable create(MethodHandler handler, Method definitionMethod, Method handlingMethod, boolean encodedParameters) { return new Invocable(handler, definitionMethod, handlingMethod, encodedParameters, null); }
/** * Create a new resource method invocable model. * * @param handler resource method handler. * @param definitionMethod method that is defined to be executed on the {@code handler}. * @param handlingMethod specific and concrete method to be actually executed as a resource method. If {@code null} * then the {@code definitionMethod} will be used. * @param encodedParameters {@code true} if the automatic parameter decoding * should be disabled, false otherwise. * @return Invocable. */ public static Invocable create(MethodHandler handler, Method definitionMethod, Method handlingMethod, boolean encodedParameters) { return new Invocable(handler, definitionMethod, handlingMethod, encodedParameters, null); }
/** * Create a new resource method invocable model. * * @param handler resource method handler. * @param definitionMethod method that is defined to be executed on the {@code handler}. * @param handlingMethod specific and concrete method to be actually executed as a resource method. If {@code null} * then the {@code definitionMethod} will be used. * @param encodedParameters {@code true} if the automatic parameter decoding * should be disabled, false otherwise. * @param routingResponseType response type that will be used during the routing for purpose * of selection of the resource method to be executed. If this parameter is * non-{@code null} then it will override the return type of the * {@link #getHandlingMethod() the Java handling method}) for purposes of * resource method selection. This might be useful in cases when resource * method returns a type {@code A} but thanks to registered providers * (eg. {@link javax.ws.rs.ext.WriterInterceptor}) it will be always converted * to type {@code B}. Then the method selecting algorithm would check presence of * {@link javax.ws.rs.ext.MessageBodyWriter} for type {@code A} (which will * never be actually needed) and might result in choosing undesired method. * If the parameter is {@code null} then the default response type will be used. * * @return Invocable. */ public static Invocable create(MethodHandler handler, Method definitionMethod, Method handlingMethod, boolean encodedParameters, Type routingResponseType) { return new Invocable(handler, definitionMethod, handlingMethod, encodedParameters, routingResponseType); }
/** * Create a new resource method invocable model. * * @param handler resource method handler. * @param definitionMethod method that is defined to be executed on the {@code handler}. * @param handlingMethod specific and concrete method to be actually executed as a resource method. If {@code null} * then the {@code definitionMethod} will be used. * @param encodedParameters {@code true} if the automatic parameter decoding * should be disabled, false otherwise. * @param routingResponseType response type that will be used during the routing for purpose * of selection of the resource method to be executed. If this parameter is * non-{@code null} then it will override the return type of the * {@link #getHandlingMethod() the Java handling method}) for purposes of * resource method selection. This might be useful in cases when resource * method returns a type {@code A} but thanks to registered providers * (eg. {@link javax.ws.rs.ext.WriterInterceptor}) it will be always converted * to type {@code B}. Then the method selecting algorithm would check presence of * {@link javax.ws.rs.ext.MessageBodyWriter} for type {@code A} (which will * never be actually needed) and might result in choosing undesired method. * If the parameter is {@code null} then the default response type will be used. * * @return Invocable. */ public static Invocable create(MethodHandler handler, Method definitionMethod, Method handlingMethod, boolean encodedParameters, Type routingResponseType) { return new Invocable(handler, definitionMethod, handlingMethod, encodedParameters, routingResponseType); }
/** * Create a new resource method invocable model. * * @param handler resource method handler. * @param definitionMethod method that is defined to be executed on the {@code handler}. * @param handlingMethod specific and concrete method to be actually executed as a resource method. If {@code null} * then the {@code definitionMethod} will be used. * @param encodedParameters {@code true} if the automatic parameter decoding * should be disabled, false otherwise. * @param routingResponseType response type that will be used during the routing for purpose * of selection of the resource method to be executed. If this parameter is * non-{@code null} then it will override the return type of the * {@link #getHandlingMethod() the Java handling method}) for purposes of * resource method selection. This might be useful in cases when resource * method returns a type {@code A} but thanks to registered providers * (eg. {@link javax.ws.rs.ext.WriterInterceptor}) it will be always converted * to type {@code B}. Then the method selecting algorithm would check presence of * {@link javax.ws.rs.ext.MessageBodyWriter} for type {@code A} (which will * never be actually needed) and might result in choosing undesired method. * If the parameter is {@code null} then the default response type will be used. * * @return Invocable. */ public static Invocable create(MethodHandler handler, Method definitionMethod, Method handlingMethod, boolean encodedParameters, Type routingResponseType) { return new Invocable(handler, definitionMethod, handlingMethod, encodedParameters, routingResponseType); }
/** * Create a new resource method invocable model. * * @param handler resource method handler. * @param definitionMethod method that is defined to be executed on the {@code handler}. * @param handlingMethod specific and concrete method to be actually executed as a resource method. If {@code null} * then the {@code definitionMethod} will be used. * @param encodedParameters {@code true} if the automatic parameter decoding * should be disabled, false otherwise. * @param routingResponseType response type that will be used during the routing for purpose * of selection of the resource method to be executed. If this parameter is * non-{@code null} then it will override the return type of the * {@link #getHandlingMethod() the Java handling method}) for purposes of * resource method selection. This might be useful in cases when resource * method returns a type {@code A} but thanks to registered providers * (eg. {@link javax.ws.rs.ext.WriterInterceptor}) it will be always converted * to type {@code B}. Then the method selecting algorithm would check presence of * {@link javax.ws.rs.ext.MessageBodyWriter} for type {@code A} (which will * never be actually needed) and might result in choosing undesired method. * If the parameter is {@code null} then the default response type will be used. * * @return Invocable. */ public static Invocable create(MethodHandler handler, Method definitionMethod, Method handlingMethod, boolean encodedParameters, Type routingResponseType) { return new Invocable(handler, definitionMethod, handlingMethod, encodedParameters, routingResponseType); }