RxHelper (rxjava2 2.0.0 API)

grails.rx.web.helper.RxHelper

Helper methods for creating Rx responses
Authors:
Graeme Rocher
Since:
1.0

Methods Summary

Methods
Type	Name and description
`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
`NewObservableResult<T>`	`create(groovy.lang.Closure<T> callable)` Create a new observable result for the given closure.
`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.
`NewObservableResult<T>`	`create(java.lang.Long timeout, groovy.lang.Closure<T> callable)` Create a new observable result for the given closure.
`SseResult`	`event(java.util.Map sseOptions)` Create a Server Sent Event without data
`SseResult`	`event(java.util.Map sseOptions, groovy.lang.Writable writable)` Use a writable to create a Server Sent Event
`SseResult`	`event(groovy.lang.Writable writable)` Use a writable to create a Server Sent Event
`SseResult`	`event(java.util.Map sseOptions, groovy.lang.GString gString)` Use a GString to create a Server Sent Event
`SseResult`	`event(groovy.lang.GString gString)` Use a GString to create a Server Sent Event
`SseResult`	`event(java.util.Map sseOptions, org.codehaus.groovy.runtime.GStringImpl gString)` Use a GString to create a Server Sent Event
`SseResult`	`event(org.codehaus.groovy.runtime.GStringImpl gString)` Use a GString to create a Server Sent Event
`SseResult`	`event(java.util.Map sseOptions, java.lang.CharSequence charSequence)` Use a CharSequence to create a Server Sent Event
`SseResult`	`event(java.lang.CharSequence charSequence)` Use a CharSequence to create a Server Sent Event
`SseResult`	`event(java.util.Map sseOptions, groovy.lang.Closure closure)` Use a Closure to create a Server Sent Event.
`SseResult`	`event(groovy.lang.Closure closure)` Use a Closure to create a Server Sent Event.
`RxResult<java.util.Map>`	`forward(java.util.Map argMap)` Executes a forward
`java.util.Observable<java.io.InputStream>`	`fromBody(javax.servlet.http.HttpServletRequest request)` Creates an observable from the request body
`RxResult<java.lang.Object>`	`render(java.lang.Object object)` Render the given object using asynchronous request processing
`RxResult<java.lang.CharSequence>`	`render(java.lang.CharSequence text)` Render the given text using asynchronous request processing
`RxResult<java.lang.CharSequence>`	`render(java.util.Map arguments, java.lang.CharSequence text)` Render the given text using asynchronous request processing
`RxResult<groovy.lang.Closure>`	`render(groovy.lang.Closure callable)` Render the given closure using asynchronous request processing
`RxResult<java.util.Map>`	`render(java.util.Map arguments)` Execute render for the given named arguments
`RxResult<groovy.lang.Closure>`	`render(java.util.Map arguments, groovy.lang.Closure callable)` Execute render for the given named arguments and closure
`RxResult<groovy.lang.Writable>`	`render(java.util.Map arguments, groovy.lang.Writable writable)` Executes render for the given arguments and writable
`RxResult<java.lang.Object>`	`respond(java.util.Map args, java.lang.Object value)` The respond method will attempt to delivery an appropriate response for the requested response format and Map value.
`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.
`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
`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.
`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
`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
`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
`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
`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
`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 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
  - 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
  - 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
  - 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
  - SseResult event(java.util.Map sseOptions)
    
    Create a Server Sent Event without data
    Parameters:
    sseOptions - optional Server Sent Event arguments (comment, id, event, retry)
    Returns:
    The SSE Event
  - SseResult event(java.util.Map sseOptions, groovy.lang.Writable writable)
    
    Use a writable to create a Server Sent Event
    Parameters:
    sseOptions - optional Server Sent Event arguments (comment, id, event, retry)
    writable - The writable
    Returns:
    The SSE Event
  - SseResult event(groovy.lang.Writable writable)
    
    Use a writable to create a Server Sent Event
    Parameters:
    writable - The writable
    Returns:
    The SSE Event
  - SseResult event(java.util.Map sseOptions, groovy.lang.GString gString)
    
    Use a GString to create a Server Sent Event
    Parameters:
    sseOptions - optional Server Sent Event arguments (comment, id, event, retry)
    gString - The GString
    Returns:
    The SSE Event
  - SseResult event(groovy.lang.GString gString)
    
    Use a GString to create a Server Sent Event
    Parameters:
    gString - The GString
    Returns:
    The SSE Event
  - SseResult event(java.util.Map sseOptions, org.codehaus.groovy.runtime.GStringImpl gString)
    
    Use a GString to create a Server Sent Event
    Parameters:
    sseOptions - optional Server Sent Event arguments (comment, id, event, retry)
    gString - The GString
    Returns:
    The SSE Event
  - SseResult event(org.codehaus.groovy.runtime.GStringImpl gString)
    
    Use a GString to create a Server Sent Event
    Parameters:
    gString - The GString
    Returns:
    The SSE Event
  - SseResult event(java.util.Map sseOptions, java.lang.CharSequence charSequence)
    
    Use a CharSequence to create a Server Sent Event
    Parameters:
    sseOptions - optional Server Sent Event arguments (comment, id, event, retry)
    charSequence - The CharSequence
    Returns:
    The SSE Event
  - SseResult event(java.lang.CharSequence charSequence)
    
    Use a CharSequence to create a Server Sent Event
    Parameters:
    charSequence - The CharSequence
    Returns:
    The SSE Event
  - SseResult event(java.util.Map sseOptions, @groovy.transform.stc.ClosureParams(value = SimpleType, options = ['java.io.Writer']) groovy.lang.Closure closure)
    
    Use a Closure to create a Server Sent Event. The closure will be passed a java.io.Writer as the only argument which it can use to write the data for the event to.
    Parameters:
    sseOptions - optional Server Sent Event arguments (comment, id, event, retry)
    closure - The closure
    Returns:
    The SSE Event
  - SseResult event(@groovy.transform.stc.ClosureParams(value = SimpleType, options = ['java.io.Writer']) groovy.lang.Closure closure)
    
    Use a Closure to create a Server Sent Event. The closure will be passed a java.io.Writer as the only argument which it can use to write the data for the event to.
    Parameters:
    closure - The closure
    Returns:
    The SSE Event
  - RxResult<java.util.Map> forward(java.util.Map argMap)
    
    Executes a forward
    Parameters:
    argMap - The forward arguments
  - 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
  - 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)
  - 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)
  - 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)
  - 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)
  - 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)
  - 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)
  - 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
  - RxResult<java.lang.Object> respond(java.util.Map args, java.lang.Object 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:
    args - the arguments
    value - The value
    Returns:
    The rx result
  - 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:
  - 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
  - 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:
  - 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
  - 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
  - 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
  - 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
  - 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
  - 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 RxHelper

Methods Summary

Inherited Methods Summary

Method Detail

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

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

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

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

SseResult event(java.util.Map sseOptions)

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

SseResult event(groovy.lang.Writable writable)

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

SseResult event(groovy.lang.GString gString)

SseResult event(java.util.Map sseOptions, org.codehaus.groovy.runtime.GStringImpl gString)

SseResult event(org.codehaus.groovy.runtime.GStringImpl gString)

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

SseResult event(java.lang.CharSequence charSequence)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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