Struct xpcom::interfaces::nsIURI

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

interface nsIURI : nsISupports

/**
 * nsIURI - interface for an uniform resource identifier w/ i18n support.
 *
 * AUTF8String attributes may contain unescaped UTF-8 characters.
 * Consumers should be careful to escape the UTF-8 strings as necessary, but
 * should always try to "display" the UTF-8 version as provided by this
 * interface.
 *
 * AUTF8String attributes may also contain escaped characters.
 *
 * Unescaping URI segments is unadvised unless there is intimate
 * knowledge of the underlying charset or there is no plan to display (or
 * otherwise enforce a charset on) the resulting URI substring.
 *
 * The correct way to create an nsIURI from a string is via
 * nsIIOService.newURI.
 *
 * NOTE: nsBinaryInputStream::ReadObject contains a hackaround to intercept the
 * old (pre-gecko6) nsIURI IID and swap in the current IID instead, in order
 * for sessionstore to work after an upgrade.  If this IID is revved further,
 * we will need to add additional checks there for all intermediate IIDs, until
 * ContentPrincipal is fixed to serialize its URIs as nsISupports (bug 662693).
 */

Methods

impl nsIURI

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

Cast this nsIURI to one of its base interfaces.

impl nsIURI

pub unsafe fn GetSpec(&self, aSpec: &mut nsACString) -> nsresult

/************************************************************************
     * The URI is broken down into the following principal components:
     */
/**
     * Returns a string representation of the URI. Setting the spec causes
     * the new spec to be parsed per the rules for the scheme the URI
     * currently has.  In particular, setting the spec to a URI string with a
     * different scheme will generally produce incorrect results; no one
     * outside of a protocol handler implementation should be doing that.  If
     * the URI stores information from the nsIIOService.newURI call used to
     * create it other than just the parsed string, then behavior of this
     * information on setting the spec attribute is undefined.
     *
     * Some characters may be escaped.
     */

attribute AUTF8String spec;

pub unsafe fn SetSpec(&self, aSpec: &nsACString) -> nsresult

/************************************************************************
     * The URI is broken down into the following principal components:
     */
/**
     * Returns a string representation of the URI. Setting the spec causes
     * the new spec to be parsed per the rules for the scheme the URI
     * currently has.  In particular, setting the spec to a URI string with a
     * different scheme will generally produce incorrect results; no one
     * outside of a protocol handler implementation should be doing that.  If
     * the URI stores information from the nsIIOService.newURI call used to
     * create it other than just the parsed string, then behavior of this
     * information on setting the spec attribute is undefined.
     *
     * Some characters may be escaped.
     */

attribute AUTF8String spec;

pub unsafe fn GetPrePath(&self, aPrePath: &mut nsACString) -> nsresult

/**
     * The prePath (eg. scheme://user:password@host:port) returns the string
     * before the path.  This is useful for authentication or managing sessions.
     *
     * Some characters may be escaped.
     */

readonly attribute AUTF8String prePath;

pub unsafe fn GetScheme(&self, aScheme: &mut nsACString) -> nsresult

/**
     * The Scheme is the protocol to which this URI refers.  The scheme is
     * restricted to the US-ASCII charset per RFC3986.  Setting this is
     * highly discouraged outside of a protocol handler implementation, since
     * that will generally lead to incorrect results.
     */

attribute ACString scheme;

pub unsafe fn SetScheme(&self, aScheme: &nsACString) -> nsresult

/**
     * The Scheme is the protocol to which this URI refers.  The scheme is
     * restricted to the US-ASCII charset per RFC3986.  Setting this is
     * highly discouraged outside of a protocol handler implementation, since
     * that will generally lead to incorrect results.
     */

attribute ACString scheme;

pub unsafe fn GetUserPass(&self, aUserPass: &mut nsACString) -> nsresult

/**
     * The username:password (or username only if value doesn't contain a ':')
     *
     * Some characters may be escaped.
     */

attribute AUTF8String userPass;

pub unsafe fn SetUserPass(&self, aUserPass: &nsACString) -> nsresult

/**
     * The username:password (or username only if value doesn't contain a ':')
     *
     * Some characters may be escaped.
     */

attribute AUTF8String userPass;

pub unsafe fn GetUsername(&self, aUsername: &mut nsACString) -> nsresult

/**
     * The optional username and password, assuming the preHost consists of
     * username:password.
     *
     * Some characters may be escaped.
     */

attribute AUTF8String username;

pub unsafe fn SetUsername(&self, aUsername: &nsACString) -> nsresult

/**
     * The optional username and password, assuming the preHost consists of
     * username:password.
     *
     * Some characters may be escaped.
     */

attribute AUTF8String username;

pub unsafe fn GetPassword(&self, aPassword: &mut nsACString) -> nsresult

attribute AUTF8String password;

pub unsafe fn SetPassword(&self, aPassword: &nsACString) -> nsresult

attribute AUTF8String password;

pub unsafe fn GetHostPort(&self, aHostPort: &mut nsACString) -> nsresult

/**
     * The host:port (or simply the host, if port == -1).
     *
     * If this attribute is set to a value that only has a host part, the port
     * will not be reset. To reset the port as well use setHostAndPort.
     */

attribute AUTF8String hostPort;

pub unsafe fn SetHostPort(&self, aHostPort: &nsACString) -> nsresult

/**
     * The host:port (or simply the host, if port == -1).
     *
     * If this attribute is set to a value that only has a host part, the port
     * will not be reset. To reset the port as well use setHostAndPort.
     */

attribute AUTF8String hostPort;

pub unsafe fn SetHostAndPort(&self, hostport: &nsACString) -> nsresult

/**
     * This function will always set a host and a port. If the port part is
     * empty, the value of the port will be set to the default value.
     */

void setHostAndPort (in AUTF8String hostport);

pub unsafe fn GetHost(&self, aHost: &mut nsACString) -> nsresult

/**
     * The host is the internet domain name to which this URI refers.  It could
     * be an IPv4 (or IPv6) address literal. Otherwise it is an ASCII or punycode
     * encoded string.
     */

attribute AUTF8String host;

pub unsafe fn SetHost(&self, aHost: &nsACString) -> nsresult

/**
     * The host is the internet domain name to which this URI refers.  It could
     * be an IPv4 (or IPv6) address literal. Otherwise it is an ASCII or punycode
     * encoded string.
     */

attribute AUTF8String host;

pub unsafe fn GetPort(&self, aPort: *mut int32_t) -> nsresult

/**
     * A port value of -1 corresponds to the protocol's default port (eg. -1
     * implies port 80 for http URIs).
     */

attribute long port;

pub unsafe fn SetPort(&self, aPort: int32_t) -> nsresult

/**
     * A port value of -1 corresponds to the protocol's default port (eg. -1
     * implies port 80 for http URIs).
     */

attribute long port;

pub unsafe fn GetPathQueryRef(&self, aPathQueryRef: &mut nsACString) -> nsresult

/**
     * The path, typically including at least a leading '/' (but may also be
     * empty, depending on the protocol).
     *
     * Some characters may be escaped.
     *
     * This attribute contains query and ref parts for historical reasons.
     * Use the 'filePath' attribute if you do not want those parts included.
     */

attribute AUTF8String pathQueryRef;

pub unsafe fn SetPathQueryRef(&self, aPathQueryRef: &nsACString) -> nsresult

/**
     * The path, typically including at least a leading '/' (but may also be
     * empty, depending on the protocol).
     *
     * Some characters may be escaped.
     *
     * This attribute contains query and ref parts for historical reasons.
     * Use the 'filePath' attribute if you do not want those parts included.
     */

attribute AUTF8String pathQueryRef;

pub unsafe fn Equals(
    &self,
    other: *const nsIURI,
    _retval: *mut bool
) -> nsresult

/************************************************************************
     * An URI supports the following methods:
     */
/**
     * URI equivalence test (not a strict string comparison).
     *
     * eg. http://foo.com:80/ == http://foo.com/
     */

boolean equals (in nsIURI other);

pub unsafe fn SchemeIs(
    &self,
    scheme: *const c_char,
    _retval: *mut bool
) -> nsresult

/**
     * An optimization to do scheme checks without requiring the users of nsIURI
     * to GetScheme, thereby saving extra allocating and freeing. Returns true if
     * the schemes match (case ignored).
     */

boolean schemeIs (in string scheme);

pub unsafe fn Clone(&self, _retval: *mut *const nsIURI) -> nsresult

/**
     * Clones the current URI.
     */

nsIURI clone ();

pub unsafe fn Resolve(
    &self,
    relativePath: &nsACString,
    _retval: &mut nsACString
) -> nsresult

/**
     * This method resolves a relative string into an absolute URI string,
     * using this URI as the base.
     *
     * NOTE: some implementations may have no concept of a relative URI.
     */

AUTF8String resolve (in AUTF8String relativePath);

pub unsafe fn GetAsciiSpec(&self, aAsciiSpec: &mut nsACString) -> nsresult

/************************************************************************
     * Additional attributes:
     */
/**
     * The URI spec with an ASCII compatible encoding.  Host portion follows
     * the IDNA draft spec.  Other parts are URL-escaped per the rules of
     * RFC2396.  The result is strictly ASCII.
     */

readonly attribute ACString asciiSpec;

pub unsafe fn GetAsciiHostPort(
    &self,
    aAsciiHostPort: &mut nsACString
) -> nsresult

/**
     * The host:port (or simply the host, if port == -1), with an ASCII compatible
     * encoding.  Host portion follows the IDNA draft spec.  The result is strictly
     * ASCII.
     */

readonly attribute ACString asciiHostPort;

pub unsafe fn GetAsciiHost(&self, aAsciiHost: &mut nsACString) -> nsresult

/**
     * The URI host with an ASCII compatible encoding.  Follows the IDNA
     * draft spec for converting internationalized domain names (UTF-8) to
     * ASCII for compatibility with existing internet infrasture.
     */

readonly attribute ACString asciiHost;

pub unsafe fn GetRef(&self, aRef: &mut nsACString) -> nsresult

/************************************************************************
     * Additional attribute & methods added for .ref support:
     */
/**
     * Returns the reference portion (the part after the "#") of the URI.
     * If there isn't one, an empty string is returned.
     *
     * Some characters may be escaped.
     */

attribute AUTF8String ref;

pub unsafe fn SetRef(&self, aRef: &nsACString) -> nsresult

/************************************************************************
     * Additional attribute & methods added for .ref support:
     */
/**
     * Returns the reference portion (the part after the "#") of the URI.
     * If there isn't one, an empty string is returned.
     *
     * Some characters may be escaped.
     */

attribute AUTF8String ref;

pub unsafe fn EqualsExceptRef(
    &self,
    other: *const nsIURI,
    _retval: *mut bool
) -> nsresult

/**
     * URI equivalence test (not a strict string comparison), ignoring
     * the value of the .ref member.
     *
     * eg. http://foo.com/# == http://foo.com/
     *     http://foo.com/#aaa == http://foo.com/#bbb
     */

boolean equalsExceptRef (in nsIURI other);

pub unsafe fn CloneIgnoringRef(&self, _retval: *mut *const nsIURI) -> nsresult

/**
     * Clones the current URI, clearing the 'ref' attribute in the clone.
     */

nsIURI cloneIgnoringRef ();

pub unsafe fn CloneWithNewRef(
    &self,
    newRef: &nsACString,
    _retval: *mut *const nsIURI
) -> nsresult

/**
     * Clones the current URI, replacing the 'ref' attribute in the clone with
     * the ref supplied.
     */

nsIURI cloneWithNewRef (in AUTF8String newRef);

pub unsafe fn GetSpecIgnoringRef(
    &self,
    aSpecIgnoringRef: &mut nsACString
) -> nsresult

/**
     * returns a string for the current URI with the ref element cleared.
     */

readonly attribute AUTF8String specIgnoringRef;

pub unsafe fn GetHasRef(&self, aHasRef: *mut bool) -> nsresult

/**
     * Returns if there is a reference portion (the part after the "#") of the URI.
     */

readonly attribute boolean hasRef;

pub unsafe fn GetFilePath(&self, aFilePath: &mut nsACString) -> nsresult

/************************************************************************
     * Additional attributes added for .query support:
     */
/**
     * Returns a path including the directory and file portions of a
     * URL.  For example, the filePath of "http://host/foo/bar.html#baz"
     * is "/foo/bar.html".
     *
     * Some characters may be escaped.
     */

attribute AUTF8String filePath;

pub unsafe fn SetFilePath(&self, aFilePath: &nsACString) -> nsresult

/************************************************************************
     * Additional attributes added for .query support:
     */
/**
     * Returns a path including the directory and file portions of a
     * URL.  For example, the filePath of "http://host/foo/bar.html#baz"
     * is "/foo/bar.html".
     *
     * Some characters may be escaped.
     */

attribute AUTF8String filePath;

pub unsafe fn GetQuery(&self, aQuery: &mut nsACString) -> nsresult

/**
     * Returns the query portion (the part after the "?") of the URL.
     * If there isn't one, an empty string is returned.
     *
     * Some characters may be escaped.
     */

attribute AUTF8String query;

pub unsafe fn SetQuery(&self, aQuery: &nsACString) -> nsresult

/**
     * Returns the query portion (the part after the "?") of the URL.
     * If there isn't one, an empty string is returned.
     *
     * Some characters may be escaped.
     */

attribute AUTF8String query;

pub unsafe fn GetDisplayHost(&self, aDisplayHost: &mut nsACString) -> nsresult

/**
     * If the URI has a punycode encoded hostname, this will hold the UTF8
     * representation of that hostname (if that representation doesn't contain
     * blacklisted characters, and the network.IDN_show_punycode pref is false)
     * Otherwise, if the hostname is ASCII, it will return the same as .asciiHost
     */

readonly attribute AUTF8String displayHost;

pub unsafe fn GetDisplayHostPort(
    &self,
    aDisplayHostPort: &mut nsACString
) -> nsresult

/**
     * The displayHost:port (or simply the displayHost, if port == -1).
     */

readonly attribute AUTF8String displayHostPort;

pub unsafe fn GetDisplaySpec(&self, aDisplaySpec: &mut nsACString) -> nsresult

/**
     * Returns the same as calling .spec, only with a UTF8 encoded hostname
     * (if that hostname doesn't contain blacklisted characters, and
     * the network.IDN_show_punycode pref is false)
     */

readonly attribute AUTF8String displaySpec;

pub unsafe fn GetDisplayPrePath(
    &self,
    aDisplayPrePath: &mut nsACString
) -> nsresult

/**
     * Returns the same as calling .prePath, only with a UTF8 encoded hostname
     * (if that hostname doesn't contain blacklisted characters, and
     * the network.IDN_show_punycode pref is false)
     */

readonly attribute AUTF8String displayPrePath;

pub unsafe fn Mutate(&self, _retval: *mut *const nsIURIMutator) -> nsresult

/**
     * Returns an nsIURIMutator that can be used to make changes to the URI.
     * After performing the setter operations on the mutator, one may call
     * mutator.finalize() to get a new immutable URI with the desired
     * properties.
     */

nsIURIMutator mutate ();

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 nsIURI

const IID: nsIID

IID: nsIID = nsID(2449947220, 28024, 20272, [145, 58, 184, 113, 129, 50, 8, 198])

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 nsIURI

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIURI

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.