Struct xpcom::interfaces::nsIAsyncStreamCopier2

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

interface nsIAsyncStreamCopier2 : nsIRequest

Methods

impl nsIAsyncStreamCopier2

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

Cast this nsIAsyncStreamCopier2 to one of its base interfaces.

impl nsIAsyncStreamCopier2

pub unsafe fn Init(
    &self,
    aSource: *const nsIInputStream,
    aSink: *const nsIOutputStream,
    aTarget: *const nsIEventTarget,
    aChunkSize: uint32_t,
    aCloseSource: bool,
    aCloseSink: bool
) -> nsresult

/**
     * Initialize the stream copier.
     *
     * If neither the source nor the sink are buffered, buffering will
     * be automatically added to the sink.
     *
     *
     * @param aSource
     *        contains the data to be copied.
     * @param aSink
     *        specifies the destination for the data.
     * @param aTarget
     *        specifies the thread on which the copy will occur.  a null value
     *        is permitted and will cause the copy to occur on an unspecified
     *        background thread.
     * @param aChunkSize
     *        specifies how many bytes to read/write at a time.  this controls
     *        the granularity of the copying.  it should match the segment size
     *        of the "buffered" streams involved.
     * @param aCloseSource
     *        true if aSource should be closed after copying (this is generally
     *        the desired behavior).
     * @param aCloseSink
     *        true if aSink should be closed after copying (this is generally
     *        the desired behavior).
     */

void init (in nsIInputStream aSource, in nsIOutputStream aSink, in nsIEventTarget aTarget, in unsigned long aChunkSize, in boolean aCloseSource, in boolean aCloseSink);

pub unsafe fn AsyncCopy(
    &self,
    aObserver: *const nsIRequestObserver,
    aObserverContext: *const nsISupports
) -> nsresult

/**
   * asyncCopy triggers the start of the copy.  The observer will be notified
   * when the copy completes.
   *
   * @param aObserver
   *        receives notifications.
   * @param aObserverContext
   *        passed to observer methods.
   */

void asyncCopy (in nsIRequestObserver aObserver, in nsISupports aObserverContext);

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 nsIAsyncStreamCopier2

const IID: nsIID

IID: nsIID = nsID(2779963087, 20190, 18433, [139, 56, 229, 254, 93, 180, 107, 242])

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 nsIAsyncStreamCopier2

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIAsyncStreamCopier2

type Target = nsIRequest

The resulting type after dereferencing.

fn deref(&self) -> &nsIRequest

Dereferences the value.