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


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

    /// 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 nsIRDFContainerUtils.
unsafe impl XpCom for nsIRDFContainerUtils {
    const IID: nsIID = nsID(0xd4214e91, 0xfb94, 0x11d2,
        [0xbd, 0xd8, 0x00, 0x10, 0x4b, 0xde, 0x60, 0x48]);
}

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

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

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

    /* boolean IsOrdinalProperty (in nsIRDFResource aProperty); */
    pub IsOrdinalProperty: unsafe extern "system" fn (this: *const nsIRDFContainerUtils, aProperty: *const nsIRDFResource, _retval: *mut bool) -> nsresult,

    /* nsIRDFResource IndexToOrdinalResource (in long aIndex); */
    pub IndexToOrdinalResource: unsafe extern "system" fn (this: *const nsIRDFContainerUtils, aIndex: libc::int32_t, _retval: *mut *const nsIRDFResource) -> nsresult,

    /* long OrdinalResourceToIndex (in nsIRDFResource aOrdinal); */
    pub OrdinalResourceToIndex: unsafe extern "system" fn (this: *const nsIRDFContainerUtils, aOrdinal: *const nsIRDFResource, _retval: *mut libc::int32_t) -> nsresult,

    /* boolean IsContainer (in nsIRDFDataSource aDataSource, in nsIRDFResource aResource); */
    pub IsContainer: unsafe extern "system" fn (this: *const nsIRDFContainerUtils, aDataSource: *const nsIRDFDataSource, aResource: *const nsIRDFResource, _retval: *mut bool) -> nsresult,

    /* boolean IsEmpty (in nsIRDFDataSource aDataSource, in nsIRDFResource aResource); */
    pub IsEmpty: unsafe extern "system" fn (this: *const nsIRDFContainerUtils, aDataSource: *const nsIRDFDataSource, aResource: *const nsIRDFResource, _retval: *mut bool) -> nsresult,

    /* boolean IsBag (in nsIRDFDataSource aDataSource, in nsIRDFResource aResource); */
    pub IsBag: unsafe extern "system" fn (this: *const nsIRDFContainerUtils, aDataSource: *const nsIRDFDataSource, aResource: *const nsIRDFResource, _retval: *mut bool) -> nsresult,

    /* boolean IsSeq (in nsIRDFDataSource aDataSource, in nsIRDFResource aResource); */
    pub IsSeq: unsafe extern "system" fn (this: *const nsIRDFContainerUtils, aDataSource: *const nsIRDFDataSource, aResource: *const nsIRDFResource, _retval: *mut bool) -> nsresult,

    /* boolean IsAlt (in nsIRDFDataSource aDataSource, in nsIRDFResource aResource); */
    pub IsAlt: unsafe extern "system" fn (this: *const nsIRDFContainerUtils, aDataSource: *const nsIRDFDataSource, aResource: *const nsIRDFResource, _retval: *mut bool) -> nsresult,

    /* nsIRDFContainer MakeBag (in nsIRDFDataSource aDataSource, in nsIRDFResource aResource); */
    pub MakeBag: unsafe extern "system" fn (this: *const nsIRDFContainerUtils, aDataSource: *const nsIRDFDataSource, aResource: *const nsIRDFResource, _retval: *mut *const nsIRDFContainer) -> nsresult,

    /* nsIRDFContainer MakeSeq (in nsIRDFDataSource aDataSource, in nsIRDFResource aResource); */
    pub MakeSeq: unsafe extern "system" fn (this: *const nsIRDFContainerUtils, aDataSource: *const nsIRDFDataSource, aResource: *const nsIRDFResource, _retval: *mut *const nsIRDFContainer) -> nsresult,

    /* nsIRDFContainer MakeAlt (in nsIRDFDataSource aDataSource, in nsIRDFResource aResource); */
    pub MakeAlt: unsafe extern "system" fn (this: *const nsIRDFContainerUtils, aDataSource: *const nsIRDFDataSource, aResource: *const nsIRDFResource, _retval: *mut *const nsIRDFContainer) -> nsresult,

    /* long indexOf (in nsIRDFDataSource aDataSource, in nsIRDFResource aContainer, in nsIRDFNode aElement); */
    pub IndexOf: unsafe extern "system" fn (this: *const nsIRDFContainerUtils, aDataSource: *const nsIRDFDataSource, aContainer: *const nsIRDFResource, aElement: *const nsIRDFNode, _retval: *mut libc::int32_t) -> 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 nsIRDFContainerUtils {

    /// ```text
    /// /**
    ///      * Returns 'true' if the property is an RDF ordinal property.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Convert the specified index to an ordinal property.
    ///      */
    /// ```
    ///

    /// `nsIRDFResource IndexToOrdinalResource (in long aIndex);`
    #[inline]
    pub unsafe fn IndexToOrdinalResource(&self, aIndex: libc::int32_t, _retval: *mut *const nsIRDFResource) -> nsresult {
        ((*self.vtable).IndexToOrdinalResource)(self, aIndex, _retval)
    }


    /// ```text
    /// /**
    ///      * Convert the specified ordinal property into an index
    ///      */
    /// ```
    ///

    /// `long OrdinalResourceToIndex (in nsIRDFResource aOrdinal);`
    #[inline]
    pub unsafe fn OrdinalResourceToIndex(&self, aOrdinal: *const nsIRDFResource, _retval: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).OrdinalResourceToIndex)(self, aOrdinal, _retval)
    }


    /// ```text
    /// /**
    ///      * Return 'true' if the specified resource is a container
    ///      */
    /// ```
    ///

    /// `boolean IsContainer (in nsIRDFDataSource aDataSource, in nsIRDFResource aResource);`
    #[inline]
    pub unsafe fn IsContainer(&self, aDataSource: *const nsIRDFDataSource, aResource: *const nsIRDFResource, _retval: *mut bool) -> nsresult {
        ((*self.vtable).IsContainer)(self, aDataSource, aResource, _retval)
    }


    /// ```text
    /// /**
    ///      * Return 'true' if the specified resource is a container and it is empty
    ///      */
    /// ```
    ///

    /// `boolean IsEmpty (in nsIRDFDataSource aDataSource, in nsIRDFResource aResource);`
    #[inline]
    pub unsafe fn IsEmpty(&self, aDataSource: *const nsIRDFDataSource, aResource: *const nsIRDFResource, _retval: *mut bool) -> nsresult {
        ((*self.vtable).IsEmpty)(self, aDataSource, aResource, _retval)
    }


    /// ```text
    /// /**
    ///      * Return 'true' if the specified resource is a bag
    ///      */
    /// ```
    ///

    /// `boolean IsBag (in nsIRDFDataSource aDataSource, in nsIRDFResource aResource);`
    #[inline]
    pub unsafe fn IsBag(&self, aDataSource: *const nsIRDFDataSource, aResource: *const nsIRDFResource, _retval: *mut bool) -> nsresult {
        ((*self.vtable).IsBag)(self, aDataSource, aResource, _retval)
    }


    /// ```text
    /// /**
    ///      * Return 'true' if the specified resource is a sequence
    ///      */
    /// ```
    ///

    /// `boolean IsSeq (in nsIRDFDataSource aDataSource, in nsIRDFResource aResource);`
    #[inline]
    pub unsafe fn IsSeq(&self, aDataSource: *const nsIRDFDataSource, aResource: *const nsIRDFResource, _retval: *mut bool) -> nsresult {
        ((*self.vtable).IsSeq)(self, aDataSource, aResource, _retval)
    }


    /// ```text
    /// /**
    ///      * Return 'true' if the specified resource is an alternation
    ///      */
    /// ```
    ///

    /// `boolean IsAlt (in nsIRDFDataSource aDataSource, in nsIRDFResource aResource);`
    #[inline]
    pub unsafe fn IsAlt(&self, aDataSource: *const nsIRDFDataSource, aResource: *const nsIRDFResource, _retval: *mut bool) -> nsresult {
        ((*self.vtable).IsAlt)(self, aDataSource, aResource, _retval)
    }


    /// ```text
    /// /**
    ///      * Decorates the specified resource appropriately to make it
    ///      * usable as an empty bag in the specified data source.
    ///      */
    /// ```
    ///

    /// `nsIRDFContainer MakeBag (in nsIRDFDataSource aDataSource, in nsIRDFResource aResource);`
    #[inline]
    pub unsafe fn MakeBag(&self, aDataSource: *const nsIRDFDataSource, aResource: *const nsIRDFResource, _retval: *mut *const nsIRDFContainer) -> nsresult {
        ((*self.vtable).MakeBag)(self, aDataSource, aResource, _retval)
    }


    /// ```text
    /// /**
    ///      * Decorates the specified resource appropriately to make it
    ///      * usable as an empty sequence in the specified data source.
    ///      */
    /// ```
    ///

    /// `nsIRDFContainer MakeSeq (in nsIRDFDataSource aDataSource, in nsIRDFResource aResource);`
    #[inline]
    pub unsafe fn MakeSeq(&self, aDataSource: *const nsIRDFDataSource, aResource: *const nsIRDFResource, _retval: *mut *const nsIRDFContainer) -> nsresult {
        ((*self.vtable).MakeSeq)(self, aDataSource, aResource, _retval)
    }


    /// ```text
    /// /**
    ///      * Decorates the specified resource appropriately to make it
    ///      * usable as an empty alternation in the specified data source.
    ///      */
    /// ```
    ///

    /// `nsIRDFContainer MakeAlt (in nsIRDFDataSource aDataSource, in nsIRDFResource aResource);`
    #[inline]
    pub unsafe fn MakeAlt(&self, aDataSource: *const nsIRDFDataSource, aResource: *const nsIRDFResource, _retval: *mut *const nsIRDFContainer) -> nsresult {
        ((*self.vtable).MakeAlt)(self, aDataSource, aResource, _retval)
    }


    /// ```text
    /// /**
    ///      * Retrieve the index of element in the container. Returns -1 if
    ///      * the element is not in the container.
    ///      */
    /// ```
    ///

    /// `long indexOf (in nsIRDFDataSource aDataSource, in nsIRDFResource aContainer, in nsIRDFNode aElement);`
    #[inline]
    pub unsafe fn IndexOf(&self, aDataSource: *const nsIRDFDataSource, aContainer: *const nsIRDFResource, aElement: *const nsIRDFNode, _retval: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).IndexOf)(self, aDataSource, aContainer, aElement, _retval)
    }


}