### Method

# Rest ProxyCall continuous

#### Declaration [src]

    gboolean
    rest_proxy_call_continuous (
      RestProxyCall* call,
      RestProxyCallContinuousCallback callback,
      GObject* weak_object,
      gpointer userdata,
      GError** error
    )

#### Description [src]

Asynchronously invoke `call` but expect a continuous stream of content. This means that the body data will not be accumulated and thus you cannot use `rest_proxy_call_get_payload()`

When there is data `callback` will be called and when the connection is closed or the stream ends `callback` will also be called.

If `weak_object` is disposed during the call then this call will be cancelled. If the call is cancelled then the callback will be invoked with an error state.

You may unref the call after calling this function since there is an internal reference, or you may unref in the callback.

This method is not directly available to language bindings.

#### Parameters

`callback`

  Type: `RestProxyCallContinuousCallback`

  A `RestProxyCallContinuousCallback` to invoke when data is available.

`weak_object`

  Type: `GObject`

  The `GObject` to weakly reference and tie the lifecycle to.

  The data is owned by the caller of the method.

`userdata`

  Type: `gpointer`

  Data to pass to `callback`.

  The argument can be `NULL`.
  The data is owned by the caller of the method.

`error`

  Type: `GError **`

  The return location for a recoverable error.

  The argument can be `NULL`.
  If the return location is not `NULL`, then you must initialize it to a `NULL` `GError*`.
  The argument will be left initialized to `NULL` by the method if there are no errors.
  In case of error, the argument will be set to a newly allocated `GError`; the caller will take ownership of the data, and be responsible for freeing it.

#### Return value

Type: `gboolean`

`TRUE` on success.