Rx (rxjava2 2.0.0 API)

grails.rx.web.Rx

Methods usable with RxJava observable transformations in order to control the final controller response
Authors:
Graeme Rocher
Since:
1.0

Methods Summary

Methods
Type	Name and description
`static java.util.Observable`	`bindData(java.lang.Object object, java.lang.Object bindingSource, java.util.Map arguments = Collections.emptyMap(, java.lang.String filter = null)` Implements the bind data method for Rx responses
`static NewObservableResult<T>`	`create(groovy.lang.Closure<T> callable)` Create a new observable result for the given closure.
`static NewObservableResult<T>`	`create(java.lang.Long timeout, java.util.concurrent.TimeUnit unit, groovy.lang.Closure<T> callable)` Create a new observable result for the given closure.
`static NewObservableResult<T>`	`create(java.lang.Long timeout, groovy.lang.Closure<T> callable)` Create a new observable result for the given closure.
`static SseResult`	`event(java.util.Map sseOptions, groovy.lang.Writable writable)` Creates a Server Sent Events event for the given groovy.lang.Writable.
`static SseResult`	`event(java.util.Map sseOptions, groovy.lang.GString gString)` Creates a Server Sent Events event for the given groovy.lang.GString.
`static SseResult`	`event(java.util.Map sseOptions, java.lang.CharSequence charSequence)` Creates a Server Sent Events event for the given java.lang.CharSequence.
`static SseResult`	`event(java.util.Map sseOptions, groovy.lang.Closure closure)` Creates a Server Sent Events event using the given groovy.lang.Closure to generate the data.
`static RxResult<java.util.Map>`	`forward(java.util.Map argMap)` Executes a forward
`static java.util.Observable<java.io.InputStream>`	`fromBody(javax.servlet.http.HttpServletRequest request)` Creates an observable from the request body
`static void`	`redirect(java.util.Map argMap)` @throws CannotRedirectException Redirects are not possible in asynchronous requests
`static void`	`redirect(java.lang.Object arg)` @throws CannotRedirectException Redirects are not possible in asynchronous requests
`static RxResult<java.lang.Object>`	`render(java.lang.Object object)` Render the given object using asynchronous request processing
`static RxResult<java.lang.CharSequence>`	`render(java.lang.CharSequence text)` Render the given text using asynchronous request processing
`static RxResult<java.lang.CharSequence>`	`render(java.util.Map arguments, java.lang.CharSequence text)` Render the given text using asynchronous request processing
`static RxResult<groovy.lang.Closure>`	`render(groovy.lang.Closure callable)` Render the given closure using asynchronous request processing
`static RxResult<java.util.Map>`	`render(java.util.Map arguments)` Execute render for the given named arguments
`static RxResult<groovy.lang.Closure>`	`render(java.util.Map arguments, groovy.lang.Closure callable)` Execute render for the given named arguments and closure
`static RxResult<groovy.lang.Writable>`	`render(java.util.Map arguments, groovy.lang.Writable writable)` Executes render for the given arguments and writable
`static RxResult<java.lang.Object>`	`respond(java.util.Map args, java.lang.Object value)`
`static RxResult<java.lang.Object>`	`respond(java.util.Map value)` The respond method will attempt to delivery an appropriate response for the requested response format and Map value.
`static RxResult<java.lang.Object>`	`respond(java.util.Map namedArgs, java.util.Map value)` Same as respond(java.util.Map), but here to support Groovy named arguments
`static RxResult<java.lang.Object>`	`respond(java.lang.Object value, java.util.Map args = [:])` The respond method will attempt to delivery an appropriate response for the requested response format and value.
`static StreamingObservableResult<T>`	`stream(java.util.Observable<T> observable, java.lang.Long timeout = -1, java.util.concurrent.TimeUnit unit = TimeUnit.MILLISECONDS)` Start a streaming Server-Send event response for the given observable
`static StreamingObservableResult<T>`	`stream(java.lang.String eventName, java.util.Observable<T> observable, java.lang.Long timeout = -1, java.util.concurrent.TimeUnit unit = TimeUnit.MILLISECONDS)` Start a streaming Server-Send event response for the given observable
`static StreamingNewObservableResult<T>`	`stream(java.lang.Long timeout, java.util.concurrent.TimeUnit unit, groovy.lang.Closure callable)` Start a streaming Server-Send event response for the given closure which is converted to an asynchronous task
`static StreamingNewObservableResult<T>`	`stream(java.lang.Long timeout, groovy.lang.Closure callable)` Start a streaming Server-Send event response for the given closure which is converted to an asynchronous task
`static StreamingNewObservableResult<T>`	`stream(groovy.lang.Closure callable)` Start a streaming Server-Send event response for the given closure which is converted to an asynchronous task
`static ObservableResult<T>`	`withTimeout(java.util.Observable<T> observable, java.lang.Long timeout, java.util.concurrent.TimeUnit unit = TimeUnit.MILLISECONDS)` Return an observable with the given timeout to be used with the container.

Inherited Methods Summary

Inherited Methods
Methods inherited from class	Name
`class java.lang.Object`	`java.lang.Object#wait(long, int), java.lang.Object#wait(long), java.lang.Object#wait(), java.lang.Object#equals(java.lang.Object), java.lang.Object#toString(), java.lang.Object#hashCode(), java.lang.Object#getClass(), java.lang.Object#notify(), java.lang.Object#notifyAll()`

- Method Detail
  - @groovy.transform.CompileDynamic static java.util.Observable bindData(java.lang.Object object, java.lang.Object bindingSource, java.util.Map arguments = Collections.emptyMap(, java.lang.String filter = null)
    
    Implements the bind data method for Rx responses
    Parameters:
    object - The object to bind to
    bindingSource - The binding source
    Returns:
    An observable
  - static NewObservableResult<T> create(@groovy.lang.DelegatesTo(Emitter) groovy.lang.Closure<T> callable)
    
    Create a new observable result for the given closure. The closure should accept an argument of type rx.Subscriber
    Parameters:
    callable - The closure
    Returns:
    The observable result
  - static NewObservableResult<T> create(java.lang.Long timeout, java.util.concurrent.TimeUnit unit, @groovy.lang.DelegatesTo(Emitter) groovy.lang.Closure<T> callable)
    
    Create a new observable result for the given closure. The closure should accept an argument of type rx.Subscriber
    Parameters:
    callable - The closure
    Returns:
    The observable result
  - static NewObservableResult<T> create(java.lang.Long timeout, @groovy.lang.DelegatesTo(Emitter) groovy.lang.Closure<T> callable)
    
    Create a new observable result for the given closure. The closure should accept an argument of type rx.Subscriber
    Parameters:
    callable - The closure
    Returns:
    The observable result
  - static SseResult event(java.util.Map sseOptions, groovy.lang.Writable writable)
    
    Creates a Server Sent Events event for the given groovy.lang.Writable. Optional named params can be used to set a `comment`, `id` and `event` for the SSE event.
    Parameters:
    sseOptions - Optional named parameters
    writable - The writable to write as the event data
    Returns:
    The SSE event
  - static SseResult event(java.util.Map sseOptions, groovy.lang.GString gString)
    
    Creates a Server Sent Events event for the given groovy.lang.GString.
    Parameters:
    sseOptions - Optional named parameters
    gString - The String
    Returns:
    The SSE event
  - static SseResult event(java.util.Map sseOptions, java.lang.CharSequence charSequence)
    
    Creates a Server Sent Events event for the given java.lang.CharSequence.
    Parameters:
    sseOptions - Optional named parameters
    charSequence - The String
    Returns:
    The SSE event
  - static SseResult event(java.util.Map sseOptions, @groovy.transform.stc.ClosureParams(value=SimpleType,options=['java.io.Writer']) groovy.lang.Closure closure)
    
    Creates a Server Sent Events event using the given groovy.lang.Closure to generate the data. The closure will receive a writer as the only parameter.
    Parameters:
    sseOptions - Optional named parameters
    closure - The closure
    Returns:
    The SSE event
  - static RxResult<java.util.Map> forward(java.util.Map argMap)
    
    Executes a forward
    Parameters:
    argMap - The forward arguments
  - static java.util.Observable<java.io.InputStream> fromBody(javax.servlet.http.HttpServletRequest request)
    
    Creates an observable from the request body
    Parameters:
    The - request
    Returns:
    An observable
  - static void redirect(java.util.Map argMap)
    
    throws:
    CannotRedirectException Redirects are not possible in asynchronous requests
  - static void redirect(java.lang.Object arg)
    
    throws:
    CannotRedirectException Redirects are not possible in asynchronous requests
  - static RxResult<java.lang.Object> render(java.lang.Object object)
    
    Render the given object using asynchronous request processing
    Parameters:
    object - The text to render
    Returns:
    The rx result
    See Also:
    grails.artefact.Controller#render(java.lang.Object)
  - static RxResult<java.lang.CharSequence> render(java.lang.CharSequence text)
    
    Render the given text using asynchronous request processing
    Parameters:
    text - The text to render
    Returns:
    The rx result
    See Also:
    grails.artefact.Controller#render(java.lang.CharSequence)
  - static RxResult<java.lang.CharSequence> render(java.util.Map arguments, java.lang.CharSequence text)
    
    Render the given text using asynchronous request processing
    Parameters:
    arguments - The arguments
    text - The text to render
    Returns:
    The rx result
    See Also:
    grails.artefact.Controller#render(java.lang.CharSequence)
  - static RxResult<groovy.lang.Closure> render(groovy.lang.Closure callable)
    
    Render the given closure using asynchronous request processing
    Parameters:
    callable - The closure
    Returns:
    The rx result
    See Also:
    grails.artefact.Controller#render(groovy.lang.Closure)
  - static RxResult<java.util.Map> render(java.util.Map arguments)
    
    Execute render for the given named arguments
    Parameters:
    arguments - The named arguments
    Returns:
    The rx result
    See Also:
    grails.artefact.Controller#render(java.util.Map)
  - static RxResult<groovy.lang.Closure> render(java.util.Map arguments, groovy.lang.Closure callable)
    
    Execute render for the given named arguments and closure
    Parameters:
    arguments - The named arguments
    callable - The closure
    Returns:
    The rx result
    See Also:
    grails.artefact.Controller#render(java.util.Map, groovy.lang.Closure)
  - static RxResult<groovy.lang.Writable> render(java.util.Map arguments, groovy.lang.Writable writable)
    
    Executes render for the given arguments and writable
    Parameters:
    arguments - The arguments
    writable - The writable
    Returns:
    The rx result
  - static RxResult<java.lang.Object> respond(java.util.Map args, java.lang.Object value)
  - static RxResult<java.lang.Object> respond(java.util.Map value)
    
    The respond method will attempt to delivery an appropriate response for the requested response format and Map value. If the value is null then a 404 will be returned. Otherwise the grails.rest.render.RendererRegistry will be consulted for an appropriate response renderer for the requested response format.
    Parameters:
    value - The value
    Returns:
  - static RxResult<java.lang.Object> respond(java.util.Map namedArgs, java.util.Map value)
    
    Same as respond(java.util.Map), but here to support Groovy named arguments
  - static RxResult<java.lang.Object> respond(java.lang.Object value, java.util.Map args = [:])
    
    The respond method will attempt to delivery an appropriate response for the requested response format and value. If the value is null then a 404 will be returned. Otherwise the grails.rest.render.RendererRegistry will be consulted for an appropriate response renderer for the requested response format.
    Parameters:
    value - The value
    args - The arguments
    Returns:
  - static StreamingObservableResult<T> stream(java.util.Observable<T> observable, java.lang.Long timeout = -1, java.util.concurrent.TimeUnit unit = TimeUnit.MILLISECONDS)
    
    Start a streaming Server-Send event response for the given observable
    Parameters:
    observable - The observable
    timeout - The timeout
    unit - The timeout unit
    Returns:
    An observable result
  - static StreamingObservableResult<T> stream(java.lang.String eventName, java.util.Observable<T> observable, java.lang.Long timeout = -1, java.util.concurrent.TimeUnit unit = TimeUnit.MILLISECONDS)
    
    Start a streaming Server-Send event response for the given observable
    Parameters:
    eventName - The event name
    observable - The observable
    timeout - The timeout
    unit - The timeout unit
    Returns:
    An observable result
  - static StreamingNewObservableResult<T> stream(java.lang.Long timeout, java.util.concurrent.TimeUnit unit, @groovy.lang.DelegatesTo(Emitter) groovy.lang.Closure callable)
    
    Start a streaming Server-Send event response for the given closure which is converted to an asynchronous task
    Parameters:
    timeout - The timeout
    unit - The timeout unit
    callable - The closure, it should accept a single argument which is the rx.Subscriber instance
    Returns:
    An observable result
  - static StreamingNewObservableResult<T> stream(java.lang.Long timeout, @groovy.lang.DelegatesTo(Emitter) groovy.lang.Closure callable)
    
    Start a streaming Server-Send event response for the given closure which is converted to an asynchronous task
    Parameters:
    timeout - The timeout in milliseconds
    callable - The closure, it should accept a single argument which is the rx.Subscriber instance
    Returns:
    An observable result
  - static StreamingNewObservableResult<T> stream(@groovy.lang.DelegatesTo(Emitter) groovy.lang.Closure callable)
    
    Start a streaming Server-Send event response for the given closure which is converted to an asynchronous task
    Parameters:
    callable - The closure, it should accept a single argument which is the rx.Subscriber instance
    Returns:
    An observable result
  - static ObservableResult<T> withTimeout(java.util.Observable<T> observable, java.lang.Long timeout, java.util.concurrent.TimeUnit unit = TimeUnit.MILLISECONDS)
    
    Return an observable with the given timeout to be used with the container. In the event the timeout is reached the containers onTimeout event handler will be invoked and an error response returned
    Parameters:
    observable - The observable
    timeout - The timeout
    unit - The timeout unit
    Returns:
    An observable result

Summary:
Method

| Detail:
Method

Groovy Documentation

[Groovy] Class Rx

Methods Summary

Inherited Methods Summary

Method Detail

@groovy.transform.CompileDynamic static java.util.Observable bindData(java.lang.Object object, java.lang.Object bindingSource, java.util.Map arguments = Collections.emptyMap(, java.lang.String filter = null)

static NewObservableResult<T> create(@groovy.lang.DelegatesTo(Emitter) groovy.lang.Closure<T> callable)

static NewObservableResult<T> create(java.lang.Long timeout, java.util.concurrent.TimeUnit unit, @groovy.lang.DelegatesTo(Emitter) groovy.lang.Closure<T> callable)

static NewObservableResult<T> create(java.lang.Long timeout, @groovy.lang.DelegatesTo(Emitter) groovy.lang.Closure<T> callable)

static SseResult event(java.util.Map sseOptions, groovy.lang.Writable writable)

static SseResult event(java.util.Map sseOptions, groovy.lang.GString gString)

static SseResult event(java.util.Map sseOptions, java.lang.CharSequence charSequence)

static SseResult event(java.util.Map sseOptions, @groovy.transform.stc.ClosureParams(value=SimpleType,options=['java.io.Writer']) groovy.lang.Closure closure)

static RxResult<java.util.Map> forward(java.util.Map argMap)

static java.util.Observable<java.io.InputStream> fromBody(javax.servlet.http.HttpServletRequest request)

static void redirect(java.util.Map argMap)

static void redirect(java.lang.Object arg)

static RxResult<java.lang.Object> render(java.lang.Object object)

static RxResult<java.lang.CharSequence> render(java.lang.CharSequence text)

static RxResult<java.lang.CharSequence> render(java.util.Map arguments, java.lang.CharSequence text)

static RxResult<groovy.lang.Closure> render(groovy.lang.Closure callable)

static RxResult<java.util.Map> render(java.util.Map arguments)

static RxResult<groovy.lang.Closure> render(java.util.Map arguments, groovy.lang.Closure callable)

static RxResult<groovy.lang.Writable> render(java.util.Map arguments, groovy.lang.Writable writable)

static RxResult<java.lang.Object> respond(java.util.Map args, java.lang.Object value)

static RxResult<java.lang.Object> respond(java.util.Map value)

static RxResult<java.lang.Object> respond(java.util.Map namedArgs, java.util.Map value)

static RxResult<java.lang.Object> respond(java.lang.Object value, java.util.Map args = [:])

static StreamingObservableResult<T> stream(java.util.Observable<T> observable, java.lang.Long timeout = -1, java.util.concurrent.TimeUnit unit = TimeUnit.MILLISECONDS)

static StreamingObservableResult<T> stream(java.lang.String eventName, java.util.Observable<T> observable, java.lang.Long timeout = -1, java.util.concurrent.TimeUnit unit = TimeUnit.MILLISECONDS)

static StreamingNewObservableResult<T> stream(java.lang.Long timeout, java.util.concurrent.TimeUnit unit, @groovy.lang.DelegatesTo(Emitter) groovy.lang.Closure callable)

static StreamingNewObservableResult<T> stream(java.lang.Long timeout, @groovy.lang.DelegatesTo(Emitter) groovy.lang.Closure callable)

static StreamingNewObservableResult<T> stream(@groovy.lang.DelegatesTo(Emitter) groovy.lang.Closure callable)

static ObservableResult<T> withTimeout(java.util.Observable<T> observable, java.lang.Long timeout, java.util.concurrent.TimeUnit unit = TimeUnit.MILLISECONDS)