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


/// `interface mozIAsyncLivemarks : nsISupports`
///


// 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 mozIAsyncLivemarks {
    vtable: *const mozIAsyncLivemarksVTable,

    /// 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 mozIAsyncLivemarks.
unsafe impl XpCom for mozIAsyncLivemarks {
    const IID: nsIID = nsID(0x672387b7, 0xa75d, 0x4e8f,
        [0x9b, 0x49, 0x5c, 0x1d, 0xcb, 0xff, 0xf4, 0x6b]);
}

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

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

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

    /* jsval addLivemark (in jsval aLivemarkInfo); */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub AddLivemark: *const ::libc::c_void,

    /* jsval removeLivemark (in jsval aLivemarkInfo); */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub RemoveLivemark: *const ::libc::c_void,

    /* jsval getLivemark (in jsval aLivemarkInfo); */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub GetLivemark: *const ::libc::c_void,

    /* void reloadLivemarks ([optional] in boolean aForceUpdate); */
    pub ReloadLivemarks: unsafe extern "system" fn (this: *const mozIAsyncLivemarks, aForceUpdate: bool) -> nsresult,

    /* jsval invalidateCachedLivemarks (); */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub InvalidateCachedLivemarks: *const ::libc::c_void,
}


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

    /// ```text
    /// /**
    ///    * Creates a new livemark
    ///    *
    ///    * @param aLivemarkInfo
    ///    *        mozILivemarkInfo object containing at least title, parentId,
    ///    *        index and feedURI of the livemark to create.
    ///    *
    ///    * @return {Promise}
    ///    * @throws NS_ERROR_INVALID_ARG if the supplied information is insufficient
    ///    *         for the creation.
    ///    */
    /// ```
    ///

    /// `jsval addLivemark (in jsval aLivemarkInfo);`
    const _AddLivemark: () = ();

    /// ```text
    /// /**
    ///    * Removes an existing livemark.
    ///    *
    ///    * @param aLivemarkInfo
    ///    *        mozILivemarkInfo object containing either an id or a guid of the
    ///    *        livemark to remove.
    ///    *
    ///    * @return {Promise}
    ///    * @throws NS_ERROR_INVALID_ARG if the id/guid is invalid.
    ///    */
    /// ```
    ///

    /// `jsval removeLivemark (in jsval aLivemarkInfo);`
    const _RemoveLivemark: () = ();

    /// ```text
    /// /**
    ///    * Gets an existing livemark.
    ///    *
    ///    * @param aLivemarkInfo
    ///    *        mozILivemarkInfo object containing either an id or a guid of the
    ///    *        livemark to retrieve.
    ///    *
    ///    * @return {Promise}
    ///    * @throws NS_ERROR_INVALID_ARG if the id/guid is invalid or an invalid
    ///    *         callback is provided.
    ///    */
    /// ```
    ///

    /// `jsval getLivemark (in jsval aLivemarkInfo);`
    const _GetLivemark: () = ();

    /// ```text
    /// /**
    ///    * Reloads all livemarks if they are expired or if forced to do so.
    ///    *
    ///    * @param [optional]aForceUpdate
    ///    *        If set to true forces a reload even if contents are still valid.
    ///    *
    ///    * @note The update process is asynchronous, observers registered through
    ///    *       registerForUpdates will be notified of updated contents.
    ///    */
    /// ```
    ///

    /// `void reloadLivemarks ([optional] in boolean aForceUpdate);`
    #[inline]
    pub unsafe fn ReloadLivemarks(&self, aForceUpdate: bool) -> nsresult {
        ((*self.vtable).ReloadLivemarks)(self, aForceUpdate)
    }



    /// `jsval invalidateCachedLivemarks ();`
    const _InvalidateCachedLivemarks: () = ();

}


/// `interface mozILivemarkInfo : nsISupports`
///


// 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 mozILivemarkInfo {
    vtable: *const mozILivemarkInfoVTable,

    /// 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 mozILivemarkInfo.
unsafe impl XpCom for mozILivemarkInfo {
    const IID: nsIID = nsID(0x3a3c5e8f, 0xec4a, 0x4086,
        [0xae, 0x0a, 0xd1, 0x64, 0x20, 0xd3, 0x0c, 0x9f]);
}

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

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

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

    /* readonly attribute long long id; */
    pub GetId: unsafe extern "system" fn (this: *const mozILivemarkInfo, aId: *mut libc::int64_t) -> nsresult,

    /* readonly attribute ACString guid; */
    pub GetGuid: unsafe extern "system" fn (this: *const mozILivemarkInfo, aGuid: &mut ::nsstring::nsACString) -> nsresult,

    /* readonly attribute AString title; */
    pub GetTitle: unsafe extern "system" fn (this: *const mozILivemarkInfo, aTitle: &mut ::nsstring::nsAString) -> nsresult,

    /* readonly attribute long long parentId; */
    pub GetParentId: unsafe extern "system" fn (this: *const mozILivemarkInfo, aParentId: *mut libc::int64_t) -> nsresult,

    /* readonly attribute long long parentGuid; */
    pub GetParentGuid: unsafe extern "system" fn (this: *const mozILivemarkInfo, aParentGuid: *mut libc::int64_t) -> nsresult,

    /* readonly attribute long index; */
    pub GetIndex: unsafe extern "system" fn (this: *const mozILivemarkInfo, aIndex: *mut libc::int32_t) -> nsresult,

    /* readonly attribute PRTime dateAdded; */
    pub GetDateAdded: unsafe extern "system" fn (this: *const mozILivemarkInfo, aDateAdded: *mut PRTime) -> nsresult,

    /* readonly attribute PRTime lastModified; */
    pub GetLastModified: unsafe extern "system" fn (this: *const mozILivemarkInfo, aLastModified: *mut PRTime) -> nsresult,

    /* readonly attribute nsIURI feedURI; */
    pub GetFeedURI: unsafe extern "system" fn (this: *const mozILivemarkInfo, aFeedURI: *mut *const nsIURI) -> nsresult,

    /* readonly attribute nsIURI siteURI; */
    pub GetSiteURI: unsafe extern "system" fn (this: *const mozILivemarkInfo, aSiteURI: *mut *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 mozILivemarkInfo {

    /// ```text
    /// /**
    ///    * Id of the bookmarks folder representing this livemark.
    ///    *
    ///    * @deprecated Use guid instead.
    ///    */
    /// ```
    ///

    /// `readonly attribute long long id;`
    #[inline]
    pub unsafe fn GetId(&self, aId: *mut libc::int64_t) -> nsresult {
        ((*self.vtable).GetId)(self, aId)
    }


    /// ```text
    /// /**
    ///    * The globally unique identifier of this livemark.
    ///    */
    /// ```
    ///

    /// `readonly attribute ACString guid;`
    #[inline]
    pub unsafe fn GetGuid(&self, aGuid: &mut ::nsstring::nsACString) -> nsresult {
        ((*self.vtable).GetGuid)(self, aGuid)
    }


    /// ```text
    /// /**
    ///    * Title of this livemark.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Id of the bookmarks parent folder containing this livemark.
    ///    *
    ///    * @deprecated Use parentGuid instead.
    ///    */
    /// ```
    ///

    /// `readonly attribute long long parentId;`
    #[inline]
    pub unsafe fn GetParentId(&self, aParentId: *mut libc::int64_t) -> nsresult {
        ((*self.vtable).GetParentId)(self, aParentId)
    }


    /// ```text
    /// /**
    ///    * Guid of the bookmarks parent folder containing this livemark.
    ///    */
    /// ```
    ///

    /// `readonly attribute long long parentGuid;`
    #[inline]
    pub unsafe fn GetParentGuid(&self, aParentGuid: *mut libc::int64_t) -> nsresult {
        ((*self.vtable).GetParentGuid)(self, aParentGuid)
    }


    /// ```text
    /// /**
    ///    * The position of this livemark in the bookmarks parent folder.
    ///    */
    /// ```
    ///

    /// `readonly attribute long index;`
    #[inline]
    pub unsafe fn GetIndex(&self, aIndex: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).GetIndex)(self, aIndex)
    }


    /// ```text
    /// /**
    ///    * Time this livemark was created.
    ///    */
    /// ```
    ///

    /// `readonly attribute PRTime dateAdded;`
    #[inline]
    pub unsafe fn GetDateAdded(&self, aDateAdded: *mut PRTime) -> nsresult {
        ((*self.vtable).GetDateAdded)(self, aDateAdded)
    }


    /// ```text
    /// /**
    ///    * Time this livemark's details were last modified.  Doesn't track changes to
    ///    * the livemark contents.
    ///    */
    /// ```
    ///

    /// `readonly attribute PRTime lastModified;`
    #[inline]
    pub unsafe fn GetLastModified(&self, aLastModified: *mut PRTime) -> nsresult {
        ((*self.vtable).GetLastModified)(self, aLastModified)
    }


    /// ```text
    /// /**
    ///    * The URI of the syndication feed associated with this livemark.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * The URI of the website associated with this livemark.
    ///    */
    /// ```
    ///

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


}


/// `interface mozILivemark : mozILivemarkInfo`
///


// 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 mozILivemark {
    vtable: *const mozILivemarkVTable,

    /// 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 mozILivemark.
unsafe impl XpCom for mozILivemark {
    const IID: nsIID = nsID(0x9f6fdfae, 0xdb9a, 0x4bd8,
        [0xbd, 0xe1, 0x14, 0x87, 0x58, 0xcf, 0x1b, 0x18]);
}

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

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

impl mozILivemark {
    /// Cast this `mozILivemark` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: mozILivemarkCoerce>(&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 mozILivemark {
    type Target = mozILivemarkInfo;
    #[inline]
    fn deref(&self) -> &mozILivemarkInfo {
        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: mozILivemarkInfoCoerce> mozILivemarkCoerce for T {
    #[inline]
    fn coerce_from(v: &mozILivemark) -> &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 mozILivemark
// 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 mozILivemarkVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: mozILivemarkInfoVTable,

    /* readonly attribute unsigned short status; */
    pub GetStatus: unsafe extern "system" fn (this: *const mozILivemark, aStatus: *mut libc::uint16_t) -> nsresult,

    /* void reload ([optional] in boolean aForceUpdate); */
    pub Reload: unsafe extern "system" fn (this: *const mozILivemark, aForceUpdate: bool) -> nsresult,

    /* jsval getNodesForContainer (in jsval aContainerNode); */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub GetNodesForContainer: *const ::libc::c_void,

    /* void registerForUpdates (in jsval aContainerNode, in nsINavHistoryResultObserver aResultObserver); */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub RegisterForUpdates: *const ::libc::c_void,

    /* void unregisterForUpdates (in jsval aContainerNode); */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub UnregisterForUpdates: *const ::libc::c_void,
}


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

    pub const STATUS_READY: i64 = 0;


    pub const STATUS_LOADING: i64 = 1;


    pub const STATUS_FAILED: i64 = 2;

    /// ```text
    /// /**
    ///    * Status of this livemark.  One of the STATUS_* constants above.
    ///    */
    /// ```
    ///

    /// `readonly attribute unsigned short status;`
    #[inline]
    pub unsafe fn GetStatus(&self, aStatus: *mut libc::uint16_t) -> nsresult {
        ((*self.vtable).GetStatus)(self, aStatus)
    }


    /// ```text
    /// /**
    ///    * Reload livemark contents if they are expired or if forced to do so.
    ///    *
    ///    * @param [optional]aForceUpdate
    ///    *        If set to true forces a reload even if contents are still valid.
    ///    *
    ///    * @note The update process is asynchronous, it's possible to register a
    ///    *       result observer to be notified of updated contents through
    ///    *       registerForUpdates.
    ///    */
    /// ```
    ///

    /// `void reload ([optional] in boolean aForceUpdate);`
    #[inline]
    pub unsafe fn Reload(&self, aForceUpdate: bool) -> nsresult {
        ((*self.vtable).Reload)(self, aForceUpdate)
    }


    /// ```text
    /// /**
    ///    * Returns an array of nsINavHistoryResultNode objects, representing children
    ///    * of this livemark.  The nodes will have aContainerNode as parent.
    ///    *
    ///    * @param aContainerNode
    ///    *        Object implementing nsINavHistoryContainerResultNode, to be used as
    ///    *        parent of the livemark nodes.
    ///    */
    /// ```
    ///

    /// `jsval getNodesForContainer (in jsval aContainerNode);`
    const _GetNodesForContainer: () = ();

    /// ```text
    /// /**
    ///    * Registers a container node for updates on this livemark.
    ///    * When the livemark contents change, an invalidateContainer(aContainerNode)
    ///    * request is sent to aResultObserver.
    ///    *
    ///    * @param aContainerNode
    ///    *        Object implementing nsINavHistoryContainerResultNode, representing
    ///    *        this livemark.
    ///    * @param aResultObserver
    ///    *        The nsINavHistoryResultObserver that should be notified of changes
    ///    *        to the livemark contents.
    ///    */
    /// ```
    ///

    /// `void registerForUpdates (in jsval aContainerNode, in nsINavHistoryResultObserver aResultObserver);`
    const _RegisterForUpdates: () = ();

    /// ```text
    /// /**
    ///    * Unregisters a previously registered container node.
    ///    *
    ///    * @param aContainerNode
    ///    *        Object implementing nsINavHistoryContainerResultNode, representing
    ///    *        this livemark.
    ///    *
    ///    * @note it's suggested to always unregister containers that are no more used,
    ///    *       to free up the associated resources.  A good time to do so is when
    ///    *       the container gets closed.
    ///    */
    /// ```
    ///

    /// `void unregisterForUpdates (in jsval aContainerNode);`
    const _UnregisterForUpdates: () = ();

}