Struct xpcom::interfaces::nsIIncrementalStreamLoader

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

interface nsIIncrementalStreamLoader : nsIStreamListener

Methods

impl nsIIncrementalStreamLoader

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

Cast this nsIIncrementalStreamLoader to one of its base interfaces.

impl nsIIncrementalStreamLoader

pub unsafe fn Init(
    &self,
    aObserver: *const nsIIncrementalStreamLoaderObserver
) -> nsresult

/**
 * Asynchronously loads a channel into a memory buffer.
 *
 * To use this interface, first call init() with a nsIIncrementalStreamLoaderObserver
 * that will be notified when the data has been loaded. Then call asyncOpen()
 * on the channel with the nsIIncrementalStreamLoader as the listener. The context
 * argument in the asyncOpen() call will be passed to the onStreamComplete()
 * callback.
 *
 * XXX define behaviour for sizes >4 GB
 */
/**
     * Initialize this stream loader, and start loading the data.
     *
     * @param aObserver
     *        An observer that will be notified when the data is complete.
     */

void init (in nsIIncrementalStreamLoaderObserver aObserver);

pub unsafe fn GetNumBytesRead(&self, aNumBytesRead: *mut uint32_t) -> nsresult

/**
     * Gets the number of bytes read so far.
     */

readonly attribute unsigned long numBytesRead;

pub unsafe fn GetRequest(&self, aRequest: *mut *const nsIRequest) -> nsresult

/**
     * Gets the request that loaded this file.
     * null after the request has finished loading.
     */

readonly attribute nsIRequest request;

Methods from Deref<Target = nsIStreamListener>

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

Cast this nsIStreamListener to one of its base interfaces.

pub unsafe fn OnDataAvailable(
    &self,
    aRequest: *const nsIRequest,
    aContext: *const nsISupports,
    aInputStream: *const nsIInputStream,
    aOffset: uint64_t,
    aCount: uint32_t
) -> nsresult

/**
     * Called when the next chunk of data (corresponding to the request) may
     * be read without blocking the calling thread.  The onDataAvailable impl
     * must read exactly |aCount| bytes of data before returning.
     *
     * @param aRequest request corresponding to the source of the data
     * @param aContext user defined context
     * @param aInputStream input stream containing the data chunk
     * @param aOffset
     *        Number of bytes that were sent in previous onDataAvailable calls
     *        for this request. In other words, the sum of all previous count
     *        parameters.
     * @param aCount number of bytes available in the stream
     *
     * NOTE: The aInputStream parameter must implement readSegments.
     *
     * An exception thrown from onDataAvailable has the side-effect of
     * causing the request to be canceled.
     */

void onDataAvailable (in nsIRequest aRequest, in nsISupports aContext, in nsIInputStream aInputStream, in unsigned long long aOffset, in unsigned long aCount);

Trait Implementations

impl XpCom for nsIIncrementalStreamLoader

const IID: nsIID

IID: nsIID = nsID(2686693472, 47651, 17178, [180, 73, 45, 214, 62, 34, 5, 84])

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 nsIIncrementalStreamLoader

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIIncrementalStreamLoader

type Target = nsIStreamListener

The resulting type after dereferencing.

fn deref(&self) -> &nsIStreamListener

Dereferences the value.