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


/// `interface nsIRDFResource : nsIRDFNode`
///

/// ```text
/// /**
///  * An nsIRDFResource is an object that has unique identity in the
///  * RDF data model. The object's identity is determined by its 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 nsIRDFResource {
    vtable: *const nsIRDFResourceVTable,

    /// 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 nsIRDFResource.
unsafe impl XpCom for nsIRDFResource {
    const IID: nsIID = nsID(0xfb9686a7, 0x719a, 0x49dc,
        [0x91, 0x07, 0x10, 0xde, 0xa5, 0x73, 0x93, 0x41]);
}

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

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

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

    /* readonly attribute string Value; */
    pub GetValue: unsafe extern "system" fn (this: *const nsIRDFResource, aValue: *mut *const libc::c_char) -> nsresult,

    /* readonly attribute AUTF8String ValueUTF8; */
    pub GetValueUTF8: unsafe extern "system" fn (this: *const nsIRDFResource, aValueUTF8: &mut ::nsstring::nsACString) -> nsresult,

    /* [noscript] void GetValueConst ([shared] out string aConstValue); */
    pub GetValueConst: unsafe extern "system" fn (this: *const nsIRDFResource, aConstValue: *mut *const libc::c_char) -> nsresult,

    /* void Init (in string uri); */
    pub Init: unsafe extern "system" fn (this: *const nsIRDFResource, uri: *const libc::c_char) -> nsresult,

    /* boolean EqualsString (in string aURI); */
    pub EqualsString: unsafe extern "system" fn (this: *const nsIRDFResource, aURI: *const libc::c_char, _retval: *mut bool) -> nsresult,

    /* void GetDelegate (in string aKey, in nsIIDRef aIID, [iid_is (aIID), retval] out nsQIResult aResult); */
    pub GetDelegate: unsafe extern "system" fn (this: *const nsIRDFResource, aKey: *const libc::c_char, aIID: &nsIID, aResult: *mut *mut libc::c_void) -> nsresult,

    /* void ReleaseDelegate (in string aKey); */
    pub ReleaseDelegate: unsafe extern "system" fn (this: *const nsIRDFResource, aKey: *const libc::c_char) -> 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 nsIRDFResource {

    /// ```text
    /// /**
    ///      * The single-byte string value of the resource.
    ///      * @note THIS IS OBSOLETE. C++ should use GetValueConst and script
    ///      *       should use .valueUTF8
    ///      */
    /// ```
    ///

    /// `readonly attribute string Value;`
    #[inline]
    pub unsafe fn GetValue(&self, aValue: *mut *const libc::c_char) -> nsresult {
        ((*self.vtable).GetValue)(self, aValue)
    }


    /// ```text
    /// /**
    ///      * The UTF-8 URI of the resource.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * An unscriptable version used to avoid a string copy. Meant
    ///      * for use as a performance optimization. The string is encoded
    ///      * in UTF-8.
    ///      */
    /// ```
    ///

    /// `[noscript] void GetValueConst ([shared] out string aConstValue);`
    #[inline]
    pub unsafe fn GetValueConst(&self, aConstValue: *mut *const libc::c_char) -> nsresult {
        ((*self.vtable).GetValueConst)(self, aConstValue)
    }


    /// ```text
    /// /**
    ///      * This method is called by the nsIRDFService after constructing
    ///      * a resource object to initialize its URI. You would not normally
    ///      * call this method directly
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Determine if the resource has the given URI.
    ///      */
    /// ```
    ///

    /// `boolean EqualsString (in string aURI);`
    #[inline]
    pub unsafe fn EqualsString(&self, aURI: *const libc::c_char, _retval: *mut bool) -> nsresult {
        ((*self.vtable).EqualsString)(self, aURI, _retval)
    }


    /// ```text
    /// /**
    ///      * Retrieve the "delegate" object for this resource. A resource
    ///      * may have several delegate objects, each of whose lifetimes is
    ///      * bound to the life of the resource object.
    ///      *
    ///      * This method will return the delegate for the given key after
    ///      * QueryInterface()-ing it to the requested IID.
    ///      *
    ///      * If no delegate exists for the specified key, this method will
    ///      * attempt to create one using the component manager. Specifically,
    ///      * it will combine aKey with the resource's URI scheme to produce
    ///      * a ContractID as follows:
    ///      *
    ///      *   component:/rdf/delegate-factory/[key]/[scheme]
    ///      *
    ///      * This ContractID will be used to locate a factory using the
    ///      * FindFactory() method of nsIComponentManager. If the nsIFactory
    ///      * exists, it will be used to create a "delegate factory"; that
    ///      * is, an object that supports nsIRDFDelegateFactory. The delegate
    ///      * factory will be used to construct the delegate object.
    ///      */
    /// ```
    ///

    /// `void GetDelegate (in string aKey, in nsIIDRef aIID, [iid_is (aIID), retval] out nsQIResult aResult);`
    #[inline]
    pub unsafe fn GetDelegate(&self, aKey: *const libc::c_char, aIID: &nsIID, aResult: *mut *mut libc::c_void) -> nsresult {
        ((*self.vtable).GetDelegate)(self, aKey, aIID, aResult)
    }


    /// ```text
    /// /**
    ///      * Force a delegate to be "unbound" from the resource.
    ///      *
    ///      * Normally, a delegate object's lifetime will be identical to
    ///      * that of the resource to which it is bound; this method allows a
    ///      * delegate to unlink itself from an RDF resource prematurely.
    ///      */
    /// ```
    ///

    /// `void ReleaseDelegate (in string aKey);`
    #[inline]
    pub unsafe fn ReleaseDelegate(&self, aKey: *const libc::c_char) -> nsresult {
        ((*self.vtable).ReleaseDelegate)(self, aKey)
    }


}