Struct xpcom::interfaces::nsIInputStreamPump

#[repr(C)]
pub struct nsIInputStreamPump { /* fields omitted */ }

interface nsIInputStreamPump : nsIRequest

/**
 * nsIInputStreamPump
 *
 * This interface provides a means to configure and use a input stream pump
 * instance.  The input stream pump will asynchronously read from an input
 * stream, and push data to an nsIStreamListener instance.  It utilizes the
 * current thread's nsIEventTarget in order to make reading from the stream
 * asynchronous. A different thread can be used if the pump also implements
 * nsIThreadRetargetableRequest.
 *
 * If the given stream supports nsIAsyncInputStream, then the stream pump will
 * call the stream's AsyncWait method to drive the stream listener.  Otherwise,
 * the stream will be read on a background thread utilizing the stream
 * transport service.  More details are provided below.
 */

Methods

impl nsIInputStreamPump

pub fn coerce<T: nsIInputStreamPumpCoerce>(&self) -> &T

Cast this nsIInputStreamPump to one of its base interfaces.

impl nsIInputStreamPump

pub unsafe fn Init(
    &self,
    aStream: *const nsIInputStream,
    aSegmentSize: uint32_t,
    aSegmentCount: uint32_t,
    aCloseWhenDone: bool,
    aMainThreadTarget: *const nsIEventTarget
) -> nsresult

/**
     * Initialize the input stream pump.
     *
     * @param aStream
     *        contains the data to be read.  if the input stream is non-blocking,
     *        then it will be QI'd to nsIAsyncInputStream.  if the QI succeeds
     *        then the stream will be read directly.  otherwise, it will be read
     *        on a background thread using the stream transport service.
     * @param aSegmentSize
     *        if the stream transport service is used, then this parameter
     *        specifies the segment size for the stream transport's buffer.
     *        pass 0 to specify the default value.
     * @param aSegmentCount
     *        if the stream transport service is used, then this parameter
     *        specifies the segment count for the stream transport's buffer.
     *        pass 0 to specify the default value.
     * @param aCloseWhenDone
     *        if true, the input stream will be closed after it has been read.
     * @param aMainThreadTarget
     *        a labeled main therad event target.
     */

void init (in nsIInputStream aStream, in unsigned long aSegmentSize, in unsigned long aSegmentCount, in boolean aCloseWhenDone, [optional] in nsIEventTarget aMainThreadTarget);

pub unsafe fn AsyncRead(
    &self,
    aListener: *const nsIStreamListener,
    aListenerContext: *const nsISupports
) -> nsresult

/**
     * asyncRead causes the input stream to be read in chunks and delivered
     * asynchronously to the listener via OnDataAvailable.
     *
     * @param aListener
     *        receives notifications.
     * @param aListenerContext
     *        passed to listener methods.
     */

void asyncRead (in nsIStreamListener aListener, in nsISupports aListenerContext);

Methods from Deref<Target = nsIRequest>

pub fn coerce<T: nsIRequestCoerce>(&self) -> &T

Cast this nsIRequest to one of its base interfaces.

pub const LOAD_REQUESTMASK: i64

pub const LOAD_NORMAL: i64

pub const LOAD_BACKGROUND: i64

pub const LOAD_HTML_OBJECT_DATA: i64

pub const LOAD_DOCUMENT_NEEDS_COOKIE: i64

pub const INHIBIT_CACHING: i64

pub const INHIBIT_PERSISTENT_CACHING: i64

pub const LOAD_BYPASS_CACHE: i64

pub const LOAD_FROM_CACHE: i64

pub const VALIDATE_ALWAYS: i64

pub const VALIDATE_NEVER: i64

pub const VALIDATE_ONCE_PER_SESSION: i64

pub const LOAD_ANONYMOUS: i64

pub const LOAD_FRESH_CONNECTION: i64

pub unsafe fn GetName(&self, aName: &mut nsACString) -> nsresult

/**
     * The name of the request.  Often this is the URI of the request.
     */

readonly attribute AUTF8String name;

pub unsafe fn IsPending(&self, _retval: *mut bool) -> nsresult

/**
     * Indicates whether the request is pending. nsIRequest::isPending is
     * true when there is an outstanding asynchronous event that will make
     * the request no longer be pending.  Requests do not necessarily start
     * out pending; in some cases, requests have to be explicitly initiated
     * (e.g. nsIChannel implementations are only pending once asyncOpen
     * returns successfully).
     *
     * Requests can become pending multiple times during their lifetime.
     *
     * @return TRUE if the request has yet to reach completion.
     * @return FALSE if the request has reached completion (e.g., after
     *   OnStopRequest has fired).
     * @note Suspended requests are still considered pending.
     */

boolean isPending ();

pub unsafe fn GetStatus(&self, aStatus: *mut nsresult) -> nsresult

/**
     * The error status associated with the request.
     */

readonly attribute nsresult status;

pub unsafe fn Cancel(&self, aStatus: nsresult) -> nsresult

/**
     * Cancels the current request.  This will close any open input or
     * output streams and terminate any async requests.  Users should
     * normally pass NS_BINDING_ABORTED, although other errors may also
     * be passed.  The error passed in will become the value of the
     * status attribute.
     *
     * Implementations must not send any notifications (e.g. via
     * nsIRequestObserver) synchronously from this function. Similarly,
     * removal from the load group (if any) must also happen asynchronously.
     *
     * Requests that use nsIStreamListener must not call onDataAvailable
     * anymore after cancel has been called.
     *
     * @param aStatus the reason for canceling this request.
     *
     * NOTE: most nsIRequest implementations expect aStatus to be a
     * failure code; however, some implementations may allow aStatus to
     * be a success code such as NS_OK.  In general, aStatus should be
     * a failure code.
     */

void cancel (in nsresult aStatus);

pub unsafe fn Suspend(&self) -> nsresult

/**
     * Suspends the current request.  This may have the effect of closing
     * any underlying transport (in order to free up resources), although
     * any open streams remain logically opened and will continue delivering
     * data when the transport is resumed.
     *
     * Calling cancel() on a suspended request must not send any
     * notifications (such as onstopRequest) until the request is resumed.
     *
     * NOTE: some implementations are unable to immediately suspend, and
     * may continue to deliver events already posted to an event queue. In
     * general, callers should be capable of handling events even after
     * suspending a request.
     */

void suspend ();

pub unsafe fn Resume(&self) -> nsresult

/**
     * Resumes the current request.  This may have the effect of re-opening
     * any underlying transport and will resume the delivery of data to
     * any open streams.
     */

void resume ();

pub unsafe fn GetLoadGroup(
    &self,
    aLoadGroup: *mut *const nsILoadGroup
) -> nsresult

/**
     * The load group of this request.  While pending, the request is a
     * member of the load group.  It is the responsibility of the request
     * to implement this policy.
     */

attribute nsILoadGroup loadGroup;

pub unsafe fn SetLoadGroup(&self, aLoadGroup: *const nsILoadGroup) -> nsresult

/**
     * The load group of this request.  While pending, the request is a
     * member of the load group.  It is the responsibility of the request
     * to implement this policy.
     */

attribute nsILoadGroup loadGroup;

pub unsafe fn GetLoadFlags(&self, aLoadFlags: *mut nsLoadFlags) -> nsresult

/**
     * The load flags of this request.  Bits 0-15 are reserved.
     *
     * When added to a load group, this request's load flags are merged with
     * the load flags of the load group.
     */

attribute nsLoadFlags loadFlags;

pub unsafe fn SetLoadFlags(&self, aLoadFlags: nsLoadFlags) -> nsresult

/**
     * The load flags of this request.  Bits 0-15 are reserved.
     *
     * When added to a load group, this request's load flags are merged with
     * the load flags of the load group.
     */

attribute nsLoadFlags loadFlags;

Trait Implementations

impl XpCom for nsIInputStreamPump

const IID: nsIID

IID: nsIID = nsID(1074746472, 38887, 19755, [156, 101, 168, 42, 236, 199, 174, 130])

fn query_interface<T: XpCom>(&self) -> Option<RefPtr<T>>

Perform a QueryInterface call on this object, attempting to dynamically cast it to the requested interface type. Returns Some(RefPtr) if the cast succeeded, and None otherwise.

impl RefCounted for nsIInputStreamPump

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIInputStreamPump

type Target = nsIRequest

The resulting type after dereferencing.

fn deref(&self) -> &nsIRequest

Dereferences the value.