Struct xpcom::interfaces::nsIZipReader

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

interface nsIZipReader : nsISupports

Methods

impl nsIZipReader

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

Cast this nsIZipReader to one of its base interfaces.

impl nsIZipReader

pub unsafe fn Open(&self, zipFile: *const nsIFile) -> nsresult

/**
     * Opens a zip file for reading.
     * It is allowed to open with another file,
     * but it needs to be closed first with close().
     */

void open (in nsIFile zipFile);

pub unsafe fn OpenInner(
    &self,
    zipReader: *const nsIZipReader,
    zipEntry: &nsACString
) -> nsresult

/**
     * Opens a zip file inside a zip file for reading.
     */

void openInner (in nsIZipReader zipReader, in AUTF8String zipEntry);

pub unsafe fn OpenMemory(
    &self,
    aData: *mut c_void,
    aLength: uint32_t
) -> nsresult

/**
     * Opens a zip file stored in memory; the file attribute will be null.
     *
     * The ZipReader does not copy or take ownership of this memory; the
     * caller must ensure that it is valid and unmodified until the
     * ZipReader is closed or destroyed, and must free the memory as
     * appropriate afterwards.
     */

void openMemory (in voidPtr aData, in unsigned long aLength);

pub unsafe fn GetFile(&self, aFile: *mut *const nsIFile) -> nsresult

/**
     * The file that represents the zip with which this zip reader was
     * initialized.  This will be null if there is no underlying file.
     */

readonly attribute nsIFile file;

pub unsafe fn Close(&self) -> nsresult

/**
     * Closes a zip reader. Subsequent attempts to extract files or read from
     * its input stream will result in an error.
     *
     * Subsequent attempts to access a nsIZipEntry obtained from this zip
     * reader will cause unspecified behavior.
     */

void close ();

pub unsafe fn Test(&self, aEntryName: &nsACString) -> nsresult

/**
     * Tests the integrity of the archive by performing a CRC check
     * on each item expanded into memory.  If an entry is specified
     * the integrity of only that item is tested.  If null (javascript)
     * or EmptyCString() (c++) is passed in the integrity of all items
     * in the archive are tested.
     */

void test (in AUTF8String aEntryName);

pub unsafe fn Extract(
    &self,
    zipEntry: &nsACString,
    outFile: *const nsIFile
) -> nsresult

/**
     * Extracts a zip entry into a local file specified by outFile.
     * The entry must be stored in the zip in either uncompressed or
     * DEFLATE-compressed format for the extraction to be successful.
     * If the entry is a directory, the directory will be extracted
     * non-recursively.
     */

void extract (in AUTF8String zipEntry, in nsIFile outFile);

pub unsafe fn GetEntry(
    &self,
    zipEntry: &nsACString,
    _retval: *mut *const nsIZipEntry
) -> nsresult

/**
     * Returns a nsIZipEntry describing a specified zip entry.
     */

nsIZipEntry getEntry (in AUTF8String zipEntry);

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

/**
     * Checks whether the zipfile contains an entry specified by entryName.
     */

boolean hasEntry (in AUTF8String zipEntry);

pub unsafe fn FindEntries(
    &self,
    aPattern: &nsACString,
    _retval: *mut *const nsIUTF8StringEnumerator
) -> nsresult

/**
     * Returns a string enumerator containing the matching entry names.
     *
     * @param aPattern
     *   A regular expression used to find matching entries in the zip file.
     *   Set this parameter to null (javascript) or EmptyCString() (c++) or "*"
     *   to get all entries; otherwise, use the
     *   following syntax:
     *
     *   o * matches anything
     *   o ? matches one character
     *   o $ matches the end of the string
     *   o [abc] matches one occurrence of a, b, or c. The only character that
     *           must be escaped inside the brackets is ].  ^ and - must never
     *           appear in the first and second positions within the brackets,
     *           respectively.  (In the former case, the behavior specified for
     *           '[^az]' will happen.)
     *   o [a-z] matches any character between a and z.  The characters a and z
     *           must either both be letters or both be numbers, with the
     *           character represented by 'a' having a lower ASCII value than
     *           the character represented by 'z'.
     *   o [^az] matches any character except a or z.  If ] is to appear inside
     *           the brackets as a character to not match, it must be escaped.
     *   o pat~pat2 returns matches to the pattern 'pat' which do not also match
     *              the pattern 'pat2'.  This may be used to perform filtering
     *              upon the results of one pattern to remove all matches which
     *              also match another pattern.  For example, because '*'
     *              matches any string and '*z*' matches any string containing a
     *              'z', '*~*z*' will match all strings except those containing
     *              a 'z'.  Note that a pattern may not use '~' multiple times,
     *              so a string such as '*~*z*~*y*' is not a valid pattern.
     *   o (foo|bar) will match either the pattern foo or the pattern bar.
     *               Neither of the patterns foo or bar may use the 'pat~pat2'
     *               syntax described immediately above.
     *   o \ will escape a special character.  Escaping is required for all
     *       special characters unless otherwise specified.
     *   o All other characters match case-sensitively.
     *
     *   An aPattern not conforming to this syntax has undefined behavior.
     *
     * @throws NS_ERROR_ILLEGAL_VALUE on many but not all invalid aPattern
     *                                values.
     */

nsIUTF8StringEnumerator findEntries (in AUTF8String aPattern);

pub unsafe fn GetInputStream(
    &self,
    zipEntry: &nsACString,
    _retval: *mut *const nsIInputStream
) -> nsresult

/**
     * Returns an input stream containing the contents of the specified zip
     * entry.
     * @param zipEntry the name of the entry to open the stream from
     */

nsIInputStream getInputStream (in AUTF8String zipEntry);

pub unsafe fn GetInputStreamWithSpec(
    &self,
    aJarSpec: &nsACString,
    zipEntry: &nsACString,
    _retval: *mut *const nsIInputStream
) -> nsresult

/**
     * Returns an input stream containing the contents of the specified zip
     * entry. If the entry refers to a directory (ends with '/'), a directory stream
     * is opened, otherwise the contents of the file entry is returned.
     * @param aJarSpec the Spec of the URI for the JAR (only used for directory streams)
     * @param zipEntry the name of the entry to open the stream from
     */

nsIInputStream getInputStreamWithSpec (in AUTF8String aJarSpec, in AUTF8String zipEntry);

Methods from Deref<Target = nsISupports>

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

Cast this nsISupports to one of its base interfaces.

pub unsafe fn QueryInterface(
    &self,
    uuid: &nsIID,
    result: *mut *mut c_void
) -> nsresult

void QueryInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result);

pub unsafe fn AddRef(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt AddRef ();

pub unsafe fn Release(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt Release ();

Trait Implementations

impl XpCom for nsIZipReader

const IID: nsIID

IID: nsIID = nsID(2611277652, 57504, 20325, [157, 35, 18, 132, 130, 68, 136, 133])

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 nsIZipReader

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIZipReader

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.