//
// DO NOT EDIT.  THIS FILE IS GENERATED FROM ../../../dist/idl/nsIURIFixup.idl
//


/// `interface nsIURIFixupInfo : nsISupports`
///

/// ```text
/// /**
///  * Interface indicating what we found/corrected when fixing up a URI
///  */
/// ```
///

// The actual type definition for the interface. This struct has methods
// declared on it which will call through its vtable. You never want to pass
// this type around by value, always pass it behind a reference.

#[repr(C)]
pub struct nsIURIFixupInfo {
    vtable: *const nsIURIFixupInfoVTable,

    /// This field is a phantomdata to ensure that the VTable type and any
    /// struct containing it is not safe to send across threads, as XPCOM is
    /// generally not threadsafe.
    ///
    /// XPCOM interfaces in general are not safe to send across threads.
    __nosync: ::std::marker::PhantomData<::std::rc::Rc<u8>>,
}

// Implementing XpCom for an interface exposes its IID, which allows for easy
// use of the `.query_interface<T>` helper method. This also defines that
// method for nsIURIFixupInfo.
unsafe impl XpCom for nsIURIFixupInfo {
    const IID: nsIID = nsID(0x4819f183, 0xb532, 0x4932,
        [0xac, 0x09, 0xb3, 0x09, 0xcd, 0x85, 0x3b, 0xe7]);
}

// We need to implement the RefCounted trait so we can be used with `RefPtr`.
// This trait teaches `RefPtr` how to manage our memory.
unsafe impl RefCounted for nsIURIFixupInfo {
    #[inline]
    unsafe fn addref(&self) {
        self.AddRef();
    }
    #[inline]
    unsafe fn release(&self) {
        self.Release();
    }
}

// This trait is implemented on all types which can be coerced to from nsIURIFixupInfo.
// It is used in the implementation of `fn coerce<T>`. We hide it from the
// documentation, because it clutters it up a lot.
#[doc(hidden)]
pub trait nsIURIFixupInfoCoerce {
    /// Cheaply cast a value of this type from a `nsIURIFixupInfo`.
    fn coerce_from(v: &nsIURIFixupInfo) -> &Self;
}

// The trivial implementation: We can obviously coerce ourselves to ourselves.
impl nsIURIFixupInfoCoerce for nsIURIFixupInfo {
    #[inline]
    fn coerce_from(v: &nsIURIFixupInfo) -> &Self {
        v
    }
}

impl nsIURIFixupInfo {
    /// Cast this `nsIURIFixupInfo` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIURIFixupInfoCoerce>(&self) -> &T {
        T::coerce_from(self)
    }
}

// Every interface struct type implements `Deref` to its base interface. This
// causes methods on the base interfaces to be directly avaliable on the
// object. For example, you can call `.AddRef` or `.QueryInterface` directly
// on any interface which inherits from `nsISupports`.
impl ::std::ops::Deref for nsIURIFixupInfo {
    type Target = nsISupports;
    #[inline]
    fn deref(&self) -> &nsISupports {
        unsafe {
            ::std::mem::transmute(self)
        }
    }
}

// Ensure we can use .coerce() to cast to our base types as well. Any type which
// our base interface can coerce from should be coercable from us as well.
impl<T: nsISupportsCoerce> nsIURIFixupInfoCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIURIFixupInfo) -> &Self {
        T::coerce_from(v)
    }
}

// This struct represents the interface's VTable. A pointer to a statically
// allocated version of this struct is at the beginning of every nsIURIFixupInfo
// object. It contains one pointer field for each method in the interface. In
// the case where we can't generate a binding for a method, we include a void
// pointer.
#[doc(hidden)]
#[repr(C)]
pub struct nsIURIFixupInfoVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISupportsVTable,

    /* attribute nsISupports consumer; */
    pub GetConsumer: unsafe extern "system" fn (this: *const nsIURIFixupInfo, aConsumer: *mut *const nsISupports) -> nsresult,

    /* attribute nsISupports consumer; */
    pub SetConsumer: unsafe extern "system" fn (this: *const nsIURIFixupInfo, aConsumer: *const nsISupports) -> nsresult,

    /* readonly attribute nsIURI preferredURI; */
    pub GetPreferredURI: unsafe extern "system" fn (this: *const nsIURIFixupInfo, aPreferredURI: *mut *const nsIURI) -> nsresult,

    /* readonly attribute nsIURI fixedURI; */
    pub GetFixedURI: unsafe extern "system" fn (this: *const nsIURIFixupInfo, aFixedURI: *mut *const nsIURI) -> nsresult,

    /* readonly attribute AString keywordProviderName; */
    pub GetKeywordProviderName: unsafe extern "system" fn (this: *const nsIURIFixupInfo, aKeywordProviderName: &mut ::nsstring::nsAString) -> nsresult,

    /* readonly attribute AString keywordAsSent; */
    pub GetKeywordAsSent: unsafe extern "system" fn (this: *const nsIURIFixupInfo, aKeywordAsSent: &mut ::nsstring::nsAString) -> nsresult,

    /* readonly attribute boolean fixupChangedProtocol; */
    pub GetFixupChangedProtocol: unsafe extern "system" fn (this: *const nsIURIFixupInfo, aFixupChangedProtocol: *mut bool) -> nsresult,

    /* readonly attribute boolean fixupCreatedAlternateURI; */
    pub GetFixupCreatedAlternateURI: unsafe extern "system" fn (this: *const nsIURIFixupInfo, aFixupCreatedAlternateURI: *mut bool) -> nsresult,

    /* readonly attribute AUTF8String originalInput; */
    pub GetOriginalInput: unsafe extern "system" fn (this: *const nsIURIFixupInfo, aOriginalInput: &mut ::nsstring::nsACString) -> nsresult,
}


// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsIURIFixupInfo {

    /// ```text
    /// /**
    ///    * Consumer that asked for fixed up URI.
    ///    */
    /// ```
    ///

    /// `attribute nsISupports consumer;`
    #[inline]
    pub unsafe fn GetConsumer(&self, aConsumer: *mut *const nsISupports) -> nsresult {
        ((*self.vtable).GetConsumer)(self, aConsumer)
    }


    /// ```text
    /// /**
    ///    * Consumer that asked for fixed up URI.
    ///    */
    /// ```
    ///

    /// `attribute nsISupports consumer;`
    #[inline]
    pub unsafe fn SetConsumer(&self, aConsumer: *const nsISupports) -> nsresult {
        ((*self.vtable).SetConsumer)(self, aConsumer)
    }


    /// ```text
    /// /**
    ///    * Our best guess as to what URI the consumer will want. Might
    ///    * be null if we couldn't salvage anything (for instance, because
        ///    * the input was invalid as a URI and FIXUP_FLAG_ALLOW_KEYWORD_LOOKUP
        ///    * was not passed)
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIURI preferredURI;`
    #[inline]
    pub unsafe fn GetPreferredURI(&self, aPreferredURI: *mut *const nsIURI) -> nsresult {
        ((*self.vtable).GetPreferredURI)(self, aPreferredURI)
    }


    /// ```text
    /// /**
    ///    * The fixed-up original input, *never* using a keyword search.
    ///    * (might be null if the original input was not recoverable as
        ///    * a URL, e.g. "foo bar"!)
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIURI fixedURI;`
    #[inline]
    pub unsafe fn GetFixedURI(&self, aFixedURI: *mut *const nsIURI) -> nsresult {
        ((*self.vtable).GetFixedURI)(self, aFixedURI)
    }


    /// ```text
    /// /**
    ///    * The name of the keyword search provider used to provide a keyword search;
    ///    * empty string if no keyword search was done.
    ///    */
    /// ```
    ///

    /// `readonly attribute AString keywordProviderName;`
    #[inline]
    pub unsafe fn GetKeywordProviderName(&self, aKeywordProviderName: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetKeywordProviderName)(self, aKeywordProviderName)
    }


    /// ```text
    /// /**
    ///    * The keyword as used for the search (post trimming etc.)
    ///    * empty string if no keyword search was done.
    ///    */
    /// ```
    ///

    /// `readonly attribute AString keywordAsSent;`
    #[inline]
    pub unsafe fn GetKeywordAsSent(&self, aKeywordAsSent: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetKeywordAsSent)(self, aKeywordAsSent)
    }


    /// ```text
    /// /**
    ///    * Whether we changed the protocol instead of using one from the input as-is.
    ///    */
    /// ```
    ///

    /// `readonly attribute boolean fixupChangedProtocol;`
    #[inline]
    pub unsafe fn GetFixupChangedProtocol(&self, aFixupChangedProtocol: *mut bool) -> nsresult {
        ((*self.vtable).GetFixupChangedProtocol)(self, aFixupChangedProtocol)
    }


    /// ```text
    /// /**
    ///    * Whether we created an alternative URI. We might have added a prefix and/or
    ///    * suffix, the contents of which are controlled by the
    ///    * browser.fixup.alternate.prefix and .suffix prefs, with the defaults being
    ///    * "www." and ".com", respectively.
    ///    */
    /// ```
    ///

    /// `readonly attribute boolean fixupCreatedAlternateURI;`
    #[inline]
    pub unsafe fn GetFixupCreatedAlternateURI(&self, aFixupCreatedAlternateURI: *mut bool) -> nsresult {
        ((*self.vtable).GetFixupCreatedAlternateURI)(self, aFixupCreatedAlternateURI)
    }


    /// ```text
    /// /**
    ///    * The original input
    ///    */
    /// ```
    ///

    /// `readonly attribute AUTF8String originalInput;`
    #[inline]
    pub unsafe fn GetOriginalInput(&self, aOriginalInput: &mut ::nsstring::nsACString) -> nsresult {
        ((*self.vtable).GetOriginalInput)(self, aOriginalInput)
    }


}


/// `interface nsIURIFixup : nsISupports`
///

/// ```text
/// /**
///  * Interface implemented by objects capable of fixing up strings into URIs
///  */
/// ```
///

// The actual type definition for the interface. This struct has methods
// declared on it which will call through its vtable. You never want to pass
// this type around by value, always pass it behind a reference.

#[repr(C)]
pub struct nsIURIFixup {
    vtable: *const nsIURIFixupVTable,

    /// This field is a phantomdata to ensure that the VTable type and any
    /// struct containing it is not safe to send across threads, as XPCOM is
    /// generally not threadsafe.
    ///
    /// XPCOM interfaces in general are not safe to send across threads.
    __nosync: ::std::marker::PhantomData<::std::rc::Rc<u8>>,
}

// Implementing XpCom for an interface exposes its IID, which allows for easy
// use of the `.query_interface<T>` helper method. This also defines that
// method for nsIURIFixup.
unsafe impl XpCom for nsIURIFixup {
    const IID: nsIID = nsID(0x1da7e9d4, 0x620b, 0x4949,
        [0x84, 0x9a, 0x1c, 0xd6, 0x07, 0x7b, 0x1b, 0x2d]);
}

// We need to implement the RefCounted trait so we can be used with `RefPtr`.
// This trait teaches `RefPtr` how to manage our memory.
unsafe impl RefCounted for nsIURIFixup {
    #[inline]
    unsafe fn addref(&self) {
        self.AddRef();
    }
    #[inline]
    unsafe fn release(&self) {
        self.Release();
    }
}

// This trait is implemented on all types which can be coerced to from nsIURIFixup.
// It is used in the implementation of `fn coerce<T>`. We hide it from the
// documentation, because it clutters it up a lot.
#[doc(hidden)]
pub trait nsIURIFixupCoerce {
    /// Cheaply cast a value of this type from a `nsIURIFixup`.
    fn coerce_from(v: &nsIURIFixup) -> &Self;
}

// The trivial implementation: We can obviously coerce ourselves to ourselves.
impl nsIURIFixupCoerce for nsIURIFixup {
    #[inline]
    fn coerce_from(v: &nsIURIFixup) -> &Self {
        v
    }
}

impl nsIURIFixup {
    /// Cast this `nsIURIFixup` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIURIFixupCoerce>(&self) -> &T {
        T::coerce_from(self)
    }
}

// Every interface struct type implements `Deref` to its base interface. This
// causes methods on the base interfaces to be directly avaliable on the
// object. For example, you can call `.AddRef` or `.QueryInterface` directly
// on any interface which inherits from `nsISupports`.
impl ::std::ops::Deref for nsIURIFixup {
    type Target = nsISupports;
    #[inline]
    fn deref(&self) -> &nsISupports {
        unsafe {
            ::std::mem::transmute(self)
        }
    }
}

// Ensure we can use .coerce() to cast to our base types as well. Any type which
// our base interface can coerce from should be coercable from us as well.
impl<T: nsISupportsCoerce> nsIURIFixupCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIURIFixup) -> &Self {
        T::coerce_from(v)
    }
}

// This struct represents the interface's VTable. A pointer to a statically
// allocated version of this struct is at the beginning of every nsIURIFixup
// object. It contains one pointer field for each method in the interface. In
// the case where we can't generate a binding for a method, we include a void
// pointer.
#[doc(hidden)]
#[repr(C)]
pub struct nsIURIFixupVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISupportsVTable,

    /* nsIURI createExposableURI (in nsIURI aURI); */
    pub CreateExposableURI: unsafe extern "system" fn (this: *const nsIURIFixup, aURI: *const nsIURI, _retval: *mut *const nsIURI) -> nsresult,

    /* nsIURI createFixupURI (in AUTF8String aURIText, in unsigned long aFixupFlags, [optional] out nsIInputStream aPostData); */
    pub CreateFixupURI: unsafe extern "system" fn (this: *const nsIURIFixup, aURIText: &::nsstring::nsACString, aFixupFlags: libc::uint32_t, aPostData: *mut *const nsIInputStream, _retval: *mut *const nsIURI) -> nsresult,

    /* nsIURIFixupInfo getFixupURIInfo (in AUTF8String aURIText, in unsigned long aFixupFlags, [optional] out nsIInputStream aPostData); */
    pub GetFixupURIInfo: unsafe extern "system" fn (this: *const nsIURIFixup, aURIText: &::nsstring::nsACString, aFixupFlags: libc::uint32_t, aPostData: *mut *const nsIInputStream, _retval: *mut *const nsIURIFixupInfo) -> nsresult,

    /* nsIURIFixupInfo keywordToURI (in AUTF8String aKeyword, [optional] out nsIInputStream aPostData); */
    pub KeywordToURI: unsafe extern "system" fn (this: *const nsIURIFixup, aKeyword: &::nsstring::nsACString, aPostData: *mut *const nsIInputStream, _retval: *mut *const nsIURIFixupInfo) -> nsresult,

    /* bool isDomainWhitelisted (in AUTF8String aDomain, in uint32_t aDotPos); */
    pub IsDomainWhitelisted: unsafe extern "system" fn (this: *const nsIURIFixup, aDomain: &::nsstring::nsACString, aDotPos: uint32_t, _retval: *mut bool) -> nsresult,
}


// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsIURIFixup {
    /// ```text
    /// /** No fixup flags. */
    /// ```
    ///

    pub const FIXUP_FLAG_NONE: i64 = 0;

    /// ```text
    /// /**
    ///      * Allow the fixup to use a keyword lookup service to complete the URI.
    ///      * The fixup object implementer should honour this flag and only perform
    ///      * any lengthy keyword (or search) operation if it is set.
    ///      */
    /// ```
    ///

    pub const FIXUP_FLAG_ALLOW_KEYWORD_LOOKUP: i64 = 1;

    /// ```text
    /// /**
    ///      * Tell the fixup to make an alternate URI from the input URI, for example
    ///      * to turn foo into www.foo.com.
    ///      */
    /// ```
    ///

    pub const FIXUP_FLAGS_MAKE_ALTERNATE_URI: i64 = 2;


    pub const FIXUP_FLAG_FIX_SCHEME_TYPOS: i64 = 8;

    /// ```text
    /// /**
    ///      * Converts an internal URI (e.g. a wyciwyg URI) into one which we can
    ///      * expose to the user, for example on the URL bar.
    ///      *
    ///      * @param  aURI       The URI to be converted
    ///      * @return nsIURI     The converted, exposable URI
    ///      * @throws NS_ERROR_MALFORMED_URI when the exposable portion of aURI is malformed
    ///      * @throws NS_ERROR_UNKNOWN_PROTOCOL when we can't get a protocol handler service
    ///      *         for the URI scheme.
    ///      */
    /// ```
    ///

    /// `nsIURI createExposableURI (in nsIURI aURI);`
    #[inline]
    pub unsafe fn CreateExposableURI(&self, aURI: *const nsIURI, _retval: *mut *const nsIURI) -> nsresult {
        ((*self.vtable).CreateExposableURI)(self, aURI, _retval)
    }


    /// ```text
    /// /**
    ///      * Converts the specified string into a URI, first attempting
    ///      * to correct any errors in the syntax or other vagaries. Returns
    ///      * a wellformed URI or nullptr if it can't.
    ///      *
    ///      * @param aURIText    Candidate URI.
    ///      * @param aFixupFlags Flags that govern ways the URI may be fixed up.
    ///      * @param aPostData   The POST data to submit with the returned
    ///      *                    URI (see nsISearchSubmission).
    ///      */
    /// ```
    ///

    /// `nsIURI createFixupURI (in AUTF8String aURIText, in unsigned long aFixupFlags, [optional] out nsIInputStream aPostData);`
    #[inline]
    pub unsafe fn CreateFixupURI(&self, aURIText: &::nsstring::nsACString, aFixupFlags: libc::uint32_t, aPostData: *mut *const nsIInputStream, _retval: *mut *const nsIURI) -> nsresult {
        ((*self.vtable).CreateFixupURI)(self, aURIText, aFixupFlags, aPostData, _retval)
    }


    /// ```text
    /// /**
    ///      * Same as createFixupURI, but returns information about what it corrected
    ///      * (e.g. whether we could rescue the URI or "just" generated a keyword
        ///      * search URI instead).
    ///      *
    ///      * @param aURIText    Candidate URI.
    ///      * @param aFixupFlags Flags that govern ways the URI may be fixed up.
    ///      * @param aPostData   The POST data to submit with the returned
    ///      *                    URI (see nsISearchSubmission).
    ///      */
    /// ```
    ///

    /// `nsIURIFixupInfo getFixupURIInfo (in AUTF8String aURIText, in unsigned long aFixupFlags, [optional] out nsIInputStream aPostData);`
    #[inline]
    pub unsafe fn GetFixupURIInfo(&self, aURIText: &::nsstring::nsACString, aFixupFlags: libc::uint32_t, aPostData: *mut *const nsIInputStream, _retval: *mut *const nsIURIFixupInfo) -> nsresult {
        ((*self.vtable).GetFixupURIInfo)(self, aURIText, aFixupFlags, aPostData, _retval)
    }


    /// ```text
    /// /**
    ///      * Converts the specified keyword string into a URI.  Note that it's the
    ///      * caller's responsibility to check whether keywords are enabled and
    ///      * whether aKeyword is a sensible keyword.
    ///      *
    ///      * @param aKeyword  The keyword string to convert into a URI
    ///      * @param aPostData The POST data to submit to the returned URI
    ///      *                  (see nsISearchSubmission).
    ///      *
    ///      * @throws NS_ERROR_FAILURE if the resulting URI requires submission of POST
    ///      *         data and aPostData is null.
    ///      */
    /// ```
    ///

    /// `nsIURIFixupInfo keywordToURI (in AUTF8String aKeyword, [optional] out nsIInputStream aPostData);`
    #[inline]
    pub unsafe fn KeywordToURI(&self, aKeyword: &::nsstring::nsACString, aPostData: *mut *const nsIInputStream, _retval: *mut *const nsIURIFixupInfo) -> nsresult {
        ((*self.vtable).KeywordToURI)(self, aKeyword, aPostData, _retval)
    }


    /// ```text
    /// /**
    ///      * Returns true if the specified domain is whitelisted and false otherwise.
    ///      * A whitelisted domain is relevant when we have a single word and can't be
    ///      * sure whether to treat the word as a host name or should instead be
    ///      * treated as a search term.
    ///      *
    ///      * @param aDomain A domain name to query.
    ///      * @param aDotPos The position of the first '.' character in aDomain, or
    ///      *                -1 if no '.' character exists.
    ///      */
    /// ```
    ///

    /// `bool isDomainWhitelisted (in AUTF8String aDomain, in uint32_t aDotPos);`
    #[inline]
    pub unsafe fn IsDomainWhitelisted(&self, aDomain: &::nsstring::nsACString, aDotPos: uint32_t, _retval: *mut bool) -> nsresult {
        ((*self.vtable).IsDomainWhitelisted)(self, aDomain, aDotPos, _retval)
    }


}