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


/// `interface nsIRDFDataSource : 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 nsIRDFDataSource {
    vtable: *const nsIRDFDataSourceVTable,

    /// 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 nsIRDFDataSource.
unsafe impl XpCom for nsIRDFDataSource {
    const IID: nsIID = nsID(0x0f78da58, 0x8321, 0x11d2,
        [0x8e, 0xac, 0x00, 0x80, 0x5f, 0x29, 0xf3, 0x70]);
}

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

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

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

    /* readonly attribute ACString URI; */
    pub GetURI: unsafe extern "system" fn (this: *const nsIRDFDataSource, aURI: &mut ::nsstring::nsACString) -> nsresult,

    /* nsIRDFResource GetSource (in nsIRDFResource aProperty, in nsIRDFNode aTarget, in boolean aTruthValue); */
    pub GetSource: unsafe extern "system" fn (this: *const nsIRDFDataSource, aProperty: *const nsIRDFResource, aTarget: *const nsIRDFNode, aTruthValue: bool, _retval: *mut *const nsIRDFResource) -> nsresult,

    /* nsISimpleEnumerator GetSources (in nsIRDFResource aProperty, in nsIRDFNode aTarget, in boolean aTruthValue); */
    pub GetSources: unsafe extern "system" fn (this: *const nsIRDFDataSource, aProperty: *const nsIRDFResource, aTarget: *const nsIRDFNode, aTruthValue: bool, _retval: *mut *const nsISimpleEnumerator) -> nsresult,

    /* nsIRDFNode GetTarget (in nsIRDFResource aSource, in nsIRDFResource aProperty, in boolean aTruthValue); */
    pub GetTarget: unsafe extern "system" fn (this: *const nsIRDFDataSource, aSource: *const nsIRDFResource, aProperty: *const nsIRDFResource, aTruthValue: bool, _retval: *mut *const nsIRDFNode) -> nsresult,

    /* nsISimpleEnumerator GetTargets (in nsIRDFResource aSource, in nsIRDFResource aProperty, in boolean aTruthValue); */
    pub GetTargets: unsafe extern "system" fn (this: *const nsIRDFDataSource, aSource: *const nsIRDFResource, aProperty: *const nsIRDFResource, aTruthValue: bool, _retval: *mut *const nsISimpleEnumerator) -> nsresult,

    /* void Assert (in nsIRDFResource aSource, in nsIRDFResource aProperty, in nsIRDFNode aTarget, in boolean aTruthValue); */
    pub Assert: unsafe extern "system" fn (this: *const nsIRDFDataSource, aSource: *const nsIRDFResource, aProperty: *const nsIRDFResource, aTarget: *const nsIRDFNode, aTruthValue: bool) -> nsresult,

    /* void Unassert (in nsIRDFResource aSource, in nsIRDFResource aProperty, in nsIRDFNode aTarget); */
    pub Unassert: unsafe extern "system" fn (this: *const nsIRDFDataSource, aSource: *const nsIRDFResource, aProperty: *const nsIRDFResource, aTarget: *const nsIRDFNode) -> nsresult,

    /* void Change (in nsIRDFResource aSource, in nsIRDFResource aProperty, in nsIRDFNode aOldTarget, in nsIRDFNode aNewTarget); */
    pub Change: unsafe extern "system" fn (this: *const nsIRDFDataSource, aSource: *const nsIRDFResource, aProperty: *const nsIRDFResource, aOldTarget: *const nsIRDFNode, aNewTarget: *const nsIRDFNode) -> nsresult,

    /* void Move (in nsIRDFResource aOldSource, in nsIRDFResource aNewSource, in nsIRDFResource aProperty, in nsIRDFNode aTarget); */
    pub Move: unsafe extern "system" fn (this: *const nsIRDFDataSource, aOldSource: *const nsIRDFResource, aNewSource: *const nsIRDFResource, aProperty: *const nsIRDFResource, aTarget: *const nsIRDFNode) -> nsresult,

    /* boolean HasAssertion (in nsIRDFResource aSource, in nsIRDFResource aProperty, in nsIRDFNode aTarget, in boolean aTruthValue); */
    pub HasAssertion: unsafe extern "system" fn (this: *const nsIRDFDataSource, aSource: *const nsIRDFResource, aProperty: *const nsIRDFResource, aTarget: *const nsIRDFNode, aTruthValue: bool, _retval: *mut bool) -> nsresult,

    /* void AddObserver (in nsIRDFObserver aObserver); */
    pub AddObserver: unsafe extern "system" fn (this: *const nsIRDFDataSource, aObserver: *const nsIRDFObserver) -> nsresult,

    /* void RemoveObserver (in nsIRDFObserver aObserver); */
    pub RemoveObserver: unsafe extern "system" fn (this: *const nsIRDFDataSource, aObserver: *const nsIRDFObserver) -> nsresult,

    /* nsISimpleEnumerator ArcLabelsIn (in nsIRDFNode aNode); */
    pub ArcLabelsIn: unsafe extern "system" fn (this: *const nsIRDFDataSource, aNode: *const nsIRDFNode, _retval: *mut *const nsISimpleEnumerator) -> nsresult,

    /* nsISimpleEnumerator ArcLabelsOut (in nsIRDFResource aSource); */
    pub ArcLabelsOut: unsafe extern "system" fn (this: *const nsIRDFDataSource, aSource: *const nsIRDFResource, _retval: *mut *const nsISimpleEnumerator) -> nsresult,

    /* nsISimpleEnumerator GetAllResources (); */
    pub GetAllResources: unsafe extern "system" fn (this: *const nsIRDFDataSource, _retval: *mut *const nsISimpleEnumerator) -> nsresult,

    /* boolean IsCommandEnabled (in nsISupports aSources, in nsIRDFResource aCommand, in nsISupports aArguments); */
    pub IsCommandEnabled: unsafe extern "system" fn (this: *const nsIRDFDataSource, aSources: *const nsISupports, aCommand: *const nsIRDFResource, aArguments: *const nsISupports, _retval: *mut bool) -> nsresult,

    /* void DoCommand (in nsISupports aSources, in nsIRDFResource aCommand, in nsISupports aArguments); */
    pub DoCommand: unsafe extern "system" fn (this: *const nsIRDFDataSource, aSources: *const nsISupports, aCommand: *const nsIRDFResource, aArguments: *const nsISupports) -> nsresult,

    /* nsISimpleEnumerator GetAllCmds (in nsIRDFResource aSource); */
    pub GetAllCmds: unsafe extern "system" fn (this: *const nsIRDFDataSource, aSource: *const nsIRDFResource, _retval: *mut *const nsISimpleEnumerator) -> nsresult,

    /* boolean hasArcIn (in nsIRDFNode aNode, in nsIRDFResource aArc); */
    pub HasArcIn: unsafe extern "system" fn (this: *const nsIRDFDataSource, aNode: *const nsIRDFNode, aArc: *const nsIRDFResource, _retval: *mut bool) -> nsresult,

    /* boolean hasArcOut (in nsIRDFResource aSource, in nsIRDFResource aArc); */
    pub HasArcOut: unsafe extern "system" fn (this: *const nsIRDFDataSource, aSource: *const nsIRDFResource, aArc: *const nsIRDFResource, _retval: *mut bool) -> nsresult,

    /* void beginUpdateBatch (); */
    pub BeginUpdateBatch: unsafe extern "system" fn (this: *const nsIRDFDataSource) -> nsresult,

    /* void endUpdateBatch (); */
    pub EndUpdateBatch: unsafe extern "system" fn (this: *const nsIRDFDataSource) -> 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 nsIRDFDataSource {

    /// ```text
    /// /** The "URI" of the data source. This used by the RDF service's
    ///      * |GetDataSource()| method to cache datasources.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /** Find an RDF resource that points to a given node over the
    ///      * specified arc & truth value
    ///      *
    ///      * @throws NS_RDF_NO_VALUE if there is no source that leads
    ///      * to the target with the specified property.
    ///      */
    /// ```
    ///

    /// `nsIRDFResource GetSource (in nsIRDFResource aProperty, in nsIRDFNode aTarget, in boolean aTruthValue);`
    #[inline]
    pub unsafe fn GetSource(&self, aProperty: *const nsIRDFResource, aTarget: *const nsIRDFNode, aTruthValue: bool, _retval: *mut *const nsIRDFResource) -> nsresult {
        ((*self.vtable).GetSource)(self, aProperty, aTarget, aTruthValue, _retval)
    }


    /// ```text
    /// /**
    ///      * Find all RDF resources that point to a given node over the
    ///      * specified arc & truth value
    ///      */
    /// ```
    ///

    /// `nsISimpleEnumerator GetSources (in nsIRDFResource aProperty, in nsIRDFNode aTarget, in boolean aTruthValue);`
    #[inline]
    pub unsafe fn GetSources(&self, aProperty: *const nsIRDFResource, aTarget: *const nsIRDFNode, aTruthValue: bool, _retval: *mut *const nsISimpleEnumerator) -> nsresult {
        ((*self.vtable).GetSources)(self, aProperty, aTarget, aTruthValue, _retval)
    }


    /// ```text
    /// /**
    ///      * Find a child of that is related to the source by the given arc
    ///      * arc and truth value
    ///      *
    ///      * @throws NS_RDF_NO_VALUE if there is no target accessible from the
    ///      * source via the specified property.
    ///      */
    /// ```
    ///

    /// `nsIRDFNode GetTarget (in nsIRDFResource aSource, in nsIRDFResource aProperty, in boolean aTruthValue);`
    #[inline]
    pub unsafe fn GetTarget(&self, aSource: *const nsIRDFResource, aProperty: *const nsIRDFResource, aTruthValue: bool, _retval: *mut *const nsIRDFNode) -> nsresult {
        ((*self.vtable).GetTarget)(self, aSource, aProperty, aTruthValue, _retval)
    }


    /// ```text
    /// /**
    ///      * Find all children of that are related to the source by the given arc
    ///      * arc and truth value.
    ///      */
    /// ```
    ///

    /// `nsISimpleEnumerator GetTargets (in nsIRDFResource aSource, in nsIRDFResource aProperty, in boolean aTruthValue);`
    #[inline]
    pub unsafe fn GetTargets(&self, aSource: *const nsIRDFResource, aProperty: *const nsIRDFResource, aTruthValue: bool, _retval: *mut *const nsISimpleEnumerator) -> nsresult {
        ((*self.vtable).GetTargets)(self, aSource, aProperty, aTruthValue, _retval)
    }


    /// ```text
    /// /**
    ///      * Add an assertion to the graph.
    ///      */
    /// ```
    ///

    /// `void Assert (in nsIRDFResource aSource, in nsIRDFResource aProperty, in nsIRDFNode aTarget, in boolean aTruthValue);`
    #[inline]
    pub unsafe fn Assert(&self, aSource: *const nsIRDFResource, aProperty: *const nsIRDFResource, aTarget: *const nsIRDFNode, aTruthValue: bool) -> nsresult {
        ((*self.vtable).Assert)(self, aSource, aProperty, aTarget, aTruthValue)
    }


    /// ```text
    /// /**
    ///      * Remove an assertion from the graph.
    ///      */
    /// ```
    ///

    /// `void Unassert (in nsIRDFResource aSource, in nsIRDFResource aProperty, in nsIRDFNode aTarget);`
    #[inline]
    pub unsafe fn Unassert(&self, aSource: *const nsIRDFResource, aProperty: *const nsIRDFResource, aTarget: *const nsIRDFNode) -> nsresult {
        ((*self.vtable).Unassert)(self, aSource, aProperty, aTarget)
    }


    /// ```text
    /// /**
    ///      * Change an assertion from
    ///      *
    ///      *   [aSource]--[aProperty]-->[aOldTarget]
    ///      *
    ///      * to
    ///      *
    ///      *   [aSource]--[aProperty]-->[aNewTarget]
    ///      */
    /// ```
    ///

    /// `void Change (in nsIRDFResource aSource, in nsIRDFResource aProperty, in nsIRDFNode aOldTarget, in nsIRDFNode aNewTarget);`
    #[inline]
    pub unsafe fn Change(&self, aSource: *const nsIRDFResource, aProperty: *const nsIRDFResource, aOldTarget: *const nsIRDFNode, aNewTarget: *const nsIRDFNode) -> nsresult {
        ((*self.vtable).Change)(self, aSource, aProperty, aOldTarget, aNewTarget)
    }


    /// ```text
    /// /**
    ///      * 'Move' an assertion from
    ///      *
    ///      *   [aOldSource]--[aProperty]-->[aTarget]
    ///      *
    ///      * to
    ///      *
    ///      *   [aNewSource]--[aProperty]-->[aTarget]
    ///      */
    /// ```
    ///

    /// `void Move (in nsIRDFResource aOldSource, in nsIRDFResource aNewSource, in nsIRDFResource aProperty, in nsIRDFNode aTarget);`
    #[inline]
    pub unsafe fn Move(&self, aOldSource: *const nsIRDFResource, aNewSource: *const nsIRDFResource, aProperty: *const nsIRDFResource, aTarget: *const nsIRDFNode) -> nsresult {
        ((*self.vtable).Move)(self, aOldSource, aNewSource, aProperty, aTarget)
    }


    /// ```text
    /// /**
    ///      * Query whether an assertion exists in this graph.
    ///      */
    /// ```
    ///

    /// `boolean HasAssertion (in nsIRDFResource aSource, in nsIRDFResource aProperty, in nsIRDFNode aTarget, in boolean aTruthValue);`
    #[inline]
    pub unsafe fn HasAssertion(&self, aSource: *const nsIRDFResource, aProperty: *const nsIRDFResource, aTarget: *const nsIRDFNode, aTruthValue: bool, _retval: *mut bool) -> nsresult {
        ((*self.vtable).HasAssertion)(self, aSource, aProperty, aTarget, aTruthValue, _retval)
    }


    /// ```text
    /// /**
    ///      * Add an observer to this data source. If the datasource
    ///      * supports observers, the datasource source should hold a strong
    ///      * reference to the observer.
    ///      */
    /// ```
    ///

    /// `void AddObserver (in nsIRDFObserver aObserver);`
    #[inline]
    pub unsafe fn AddObserver(&self, aObserver: *const nsIRDFObserver) -> nsresult {
        ((*self.vtable).AddObserver)(self, aObserver)
    }


    /// ```text
    /// /**
    ///      * Remove an observer from this data source.
    ///      */
    /// ```
    ///

    /// `void RemoveObserver (in nsIRDFObserver aObserver);`
    #[inline]
    pub unsafe fn RemoveObserver(&self, aObserver: *const nsIRDFObserver) -> nsresult {
        ((*self.vtable).RemoveObserver)(self, aObserver)
    }


    /// ```text
    /// /**
    ///      * Get a cursor to iterate over all the arcs that point into a node.
    ///      */
    /// ```
    ///

    /// `nsISimpleEnumerator ArcLabelsIn (in nsIRDFNode aNode);`
    #[inline]
    pub unsafe fn ArcLabelsIn(&self, aNode: *const nsIRDFNode, _retval: *mut *const nsISimpleEnumerator) -> nsresult {
        ((*self.vtable).ArcLabelsIn)(self, aNode, _retval)
    }


    /// ```text
    /// /**
    ///      * Get a cursor to iterate over all the arcs that originate in
    ///      * a resource.
    ///      */
    /// ```
    ///

    /// `nsISimpleEnumerator ArcLabelsOut (in nsIRDFResource aSource);`
    #[inline]
    pub unsafe fn ArcLabelsOut(&self, aSource: *const nsIRDFResource, _retval: *mut *const nsISimpleEnumerator) -> nsresult {
        ((*self.vtable).ArcLabelsOut)(self, aSource, _retval)
    }


    /// ```text
    /// /**
    ///      * Retrieve all of the resources that the data source currently
    ///      * refers to.
    ///      */
    /// ```
    ///

    /// `nsISimpleEnumerator GetAllResources ();`
    #[inline]
    pub unsafe fn GetAllResources(&self, _retval: *mut *const nsISimpleEnumerator) -> nsresult {
        ((*self.vtable).GetAllResources)(self, _retval)
    }


    /// ```text
    /// /**
    ///      * Returns whether a given command is enabled for a set of sources.
    ///      */
    /// ```
    ///

    /// `boolean IsCommandEnabled (in nsISupports aSources, in nsIRDFResource aCommand, in nsISupports aArguments);`
    #[inline]
    pub unsafe fn IsCommandEnabled(&self, aSources: *const nsISupports, aCommand: *const nsIRDFResource, aArguments: *const nsISupports, _retval: *mut bool) -> nsresult {
        ((*self.vtable).IsCommandEnabled)(self, aSources, aCommand, aArguments, _retval)
    }


    /// ```text
    /// /**
    ///      * Perform the specified command on set of sources.
    ///      */
    /// ```
    ///

    /// `void DoCommand (in nsISupports aSources, in nsIRDFResource aCommand, in nsISupports aArguments);`
    #[inline]
    pub unsafe fn DoCommand(&self, aSources: *const nsISupports, aCommand: *const nsIRDFResource, aArguments: *const nsISupports) -> nsresult {
        ((*self.vtable).DoCommand)(self, aSources, aCommand, aArguments)
    }


    /// ```text
    /// /**
    ///      * Returns the set of all commands defined for a given source.
    ///      */
    /// ```
    ///

    /// `nsISimpleEnumerator GetAllCmds (in nsIRDFResource aSource);`
    #[inline]
    pub unsafe fn GetAllCmds(&self, aSource: *const nsIRDFResource, _retval: *mut *const nsISimpleEnumerator) -> nsresult {
        ((*self.vtable).GetAllCmds)(self, aSource, _retval)
    }


    /// ```text
    /// /**
    ///      * Returns true if the specified node is pointed to by the specified arc.
    ///      * Equivalent to enumerating ArcLabelsIn and comparing for the specified arc.
    ///      */
    /// ```
    ///

    /// `boolean hasArcIn (in nsIRDFNode aNode, in nsIRDFResource aArc);`
    #[inline]
    pub unsafe fn HasArcIn(&self, aNode: *const nsIRDFNode, aArc: *const nsIRDFResource, _retval: *mut bool) -> nsresult {
        ((*self.vtable).HasArcIn)(self, aNode, aArc, _retval)
    }


    /// ```text
    /// /**
    ///      * Returns true if the specified node has the specified outward arc.
    ///      * Equivalent to enumerating ArcLabelsOut and comparing for the specified arc.
    ///      */
    /// ```
    ///

    /// `boolean hasArcOut (in nsIRDFResource aSource, in nsIRDFResource aArc);`
    #[inline]
    pub unsafe fn HasArcOut(&self, aSource: *const nsIRDFResource, aArc: *const nsIRDFResource, _retval: *mut bool) -> nsresult {
        ((*self.vtable).HasArcOut)(self, aSource, aArc, _retval)
    }


    /// ```text
    /// /**
    ///      * Notify observers that the datasource is about to send several
    ///      * notifications at once.
    ///      * This must be followed by calling endUpdateBatch(), otherwise
    ///      * viewers will get out of sync.
    ///      */
    /// ```
    ///

    /// `void beginUpdateBatch ();`
    #[inline]
    pub unsafe fn BeginUpdateBatch(&self, ) -> nsresult {
        ((*self.vtable).BeginUpdateBatch)(self, )
    }


    /// ```text
    /// /**
    ///      * Notify observers that the datasource has completed issuing
    ///      * a notification group.
    ///      */
    /// ```
    ///

    /// `void endUpdateBatch ();`
    #[inline]
    pub unsafe fn EndUpdateBatch(&self, ) -> nsresult {
        ((*self.vtable).EndUpdateBatch)(self, )
    }


}