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


/// `interface nsIFeedResultService : nsISupports`
///

/// ```text
/// /**
///  * nsIFeedResultService provides a globally-accessible object for retrieving
///  * the results of feed processing.
///  */
/// ```
///

// 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 nsIFeedResultService {
    vtable: *const nsIFeedResultServiceVTable,

    /// 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 nsIFeedResultService.
unsafe impl XpCom for nsIFeedResultService {
    const IID: nsIID = nsID(0x95309fd2, 0x7b3a, 0x47fb,
        [0x97, 0xf3, 0x5c, 0x46, 0x0d, 0x94, 0x73, 0xcd]);
}

// 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 nsIFeedResultService {
    #[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 nsIFeedResultService.
// 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 nsIFeedResultServiceCoerce {
    /// Cheaply cast a value of this type from a `nsIFeedResultService`.
    fn coerce_from(v: &nsIFeedResultService) -> &Self;
}

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

impl nsIFeedResultService {
    /// Cast this `nsIFeedResultService` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIFeedResultServiceCoerce>(&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 nsIFeedResultService {
    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> nsIFeedResultServiceCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIFeedResultService) -> &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 nsIFeedResultService
// 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 nsIFeedResultServiceVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISupportsVTable,

    /* attribute boolean forcePreviewPage; */
    pub GetForcePreviewPage: unsafe extern "system" fn (this: *const nsIFeedResultService, aForcePreviewPage: *mut bool) -> nsresult,

    /* attribute boolean forcePreviewPage; */
    pub SetForcePreviewPage: unsafe extern "system" fn (this: *const nsIFeedResultService, aForcePreviewPage: bool) -> nsresult,

    /* void addToClientReader (in AUTF8String uri, in AString title, in AString subtitle, in unsigned long feedType, [optional] in AString feedReader); */
    pub AddToClientReader: unsafe extern "system" fn (this: *const nsIFeedResultService, uri: &::nsstring::nsACString, title: &::nsstring::nsAString, subtitle: &::nsstring::nsAString, feedType: libc::uint32_t, feedReader: &::nsstring::nsAString) -> nsresult,

    /* void addFeedResult (in nsIFeedResult feedResult); */
    pub AddFeedResult: unsafe extern "system" fn (this: *const nsIFeedResultService, feedResult: *const nsIFeedResult) -> nsresult,

    /* nsIFeedResult getFeedResult (in nsIURI uri); */
    pub GetFeedResult: unsafe extern "system" fn (this: *const nsIFeedResultService, uri: *const nsIURI, _retval: *mut *const nsIFeedResult) -> nsresult,

    /* void removeFeedResult (in nsIURI uri); */
    pub RemoveFeedResult: unsafe extern "system" fn (this: *const nsIFeedResultService, uri: *const nsIURI) -> 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 nsIFeedResultService {

    /// ```text
    /// /**
    ///    * When set to true, forces the preview page to be displayed, regardless
    ///    * of the user's preferences.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * When set to true, forces the preview page to be displayed, regardless
    ///    * of the user's preferences.
    ///    */
    /// ```
    ///

    /// `attribute boolean forcePreviewPage;`
    #[inline]
    pub unsafe fn SetForcePreviewPage(&self, aForcePreviewPage: bool) -> nsresult {
        ((*self.vtable).SetForcePreviewPage)(self, aForcePreviewPage)
    }


    /// ```text
    /// /**
    ///    * Adds a URI to the user's specified external feed handler, or live
    ///    * bookmarks.
    ///    * @param   uri
    ///    *          The uri of the feed to add.
    ///    * @param   title
    ///    *          The title of the feed to add.
    ///    * @param   subtitle
    ///    *          The subtitle of the feed to add.
    ///    * @param   feedType
    ///    *          The nsIFeed type of the feed.  See nsIFeed.idl
    ///    * @param   feedReader
    ///    *          The type of feed reader we're using (client, bookmarks, default)
    ///    *          If this parameter is null, the type is set to default
    ///    */
    /// ```
    ///

    /// `void addToClientReader (in AUTF8String uri, in AString title, in AString subtitle, in unsigned long feedType, [optional] in AString feedReader);`
    #[inline]
    pub unsafe fn AddToClientReader(&self, uri: &::nsstring::nsACString, title: &::nsstring::nsAString, subtitle: &::nsstring::nsAString, feedType: libc::uint32_t, feedReader: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).AddToClientReader)(self, uri, title, subtitle, feedType, feedReader)
    }


    /// ```text
    /// /**
    ///    * Registers a Feed Result object with a globally accessible service
    ///    * so that it can be accessed by a singleton method outside the usual
    ///    * flow of control in document loading.
    ///    *
    ///    * @param   feedResult
    ///    *          An object implementing nsIFeedResult representing the feed.
    ///    */
    /// ```
    ///

    /// `void addFeedResult (in nsIFeedResult feedResult);`
    #[inline]
    pub unsafe fn AddFeedResult(&self, feedResult: *const nsIFeedResult) -> nsresult {
        ((*self.vtable).AddFeedResult)(self, feedResult)
    }


    /// ```text
    /// /**
    ///    * Gets a Feed Handler object registered using addFeedResult.
    ///    *
    ///    * @param   uri
    ///    *          The URI of the feed a handler is being requested for
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Unregisters a Feed Handler object registered using addFeedResult.
    ///    * @param   uri
    ///    *          The feed URI the handler was registered under. This must be
    ///    *          the same *instance* the feed was registered under.
    ///    */
    /// ```
    ///

    /// `void removeFeedResult (in nsIURI uri);`
    #[inline]
    pub unsafe fn RemoveFeedResult(&self, uri: *const nsIURI) -> nsresult {
        ((*self.vtable).RemoveFeedResult)(self, uri)
    }


}