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


/// `interface nsIRDFService : nsISupports`
///

/// ```text
/// /**
///  * The RDF service interface. This is a singleton object which should be
///  * obtained from the <code>nsServiceManager</code>.
///  */
/// ```
///

// 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 nsIRDFService {
    vtable: *const nsIRDFServiceVTable,

    /// 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 nsIRDFService.
unsafe impl XpCom for nsIRDFService {
    const IID: nsIID = nsID(0xbfd05261, 0x834c, 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 nsIRDFService {
    #[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 nsIRDFService.
// 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 nsIRDFServiceCoerce {
    /// Cheaply cast a value of this type from a `nsIRDFService`.
    fn coerce_from(v: &nsIRDFService) -> &Self;
}

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

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

    /* nsIRDFResource GetResource (in AUTF8String aURI); */
    pub GetResource: unsafe extern "system" fn (this: *const nsIRDFService, aURI: &::nsstring::nsACString, _retval: *mut *const nsIRDFResource) -> nsresult,

    /* nsIRDFResource GetUnicodeResource (in AString aURI); */
    pub GetUnicodeResource: unsafe extern "system" fn (this: *const nsIRDFService, aURI: &::nsstring::nsAString, _retval: *mut *const nsIRDFResource) -> nsresult,

    /* nsIRDFResource GetAnonymousResource (); */
    pub GetAnonymousResource: unsafe extern "system" fn (this: *const nsIRDFService, _retval: *mut *const nsIRDFResource) -> nsresult,

    /* nsIRDFLiteral GetLiteral (in wstring aValue); */
    pub GetLiteral: unsafe extern "system" fn (this: *const nsIRDFService, aValue: *const libc::int16_t, _retval: *mut *const nsIRDFLiteral) -> nsresult,

    /* nsIRDFDate GetDateLiteral (in PRTime aValue); */
    pub GetDateLiteral: unsafe extern "system" fn (this: *const nsIRDFService, aValue: PRTime, _retval: *mut *const nsIRDFDate) -> nsresult,

    /* nsIRDFInt GetIntLiteral (in long aValue); */
    pub GetIntLiteral: unsafe extern "system" fn (this: *const nsIRDFService, aValue: libc::int32_t, _retval: *mut *const nsIRDFInt) -> nsresult,

    /* [noscript] nsIRDFBlob getBlobLiteral (in const_octet_ptr aValue, in long aLength); */
    /// Unable to generate binding because `native type const uint8_t is unsupported`
    pub GetBlobLiteral: *const ::libc::c_void,

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

    /* void RegisterResource (in nsIRDFResource aResource, in boolean aReplace); */
    pub RegisterResource: unsafe extern "system" fn (this: *const nsIRDFService, aResource: *const nsIRDFResource, aReplace: bool) -> nsresult,

    /* void UnregisterResource (in nsIRDFResource aResource); */
    pub UnregisterResource: unsafe extern "system" fn (this: *const nsIRDFService, aResource: *const nsIRDFResource) -> nsresult,

    /* void RegisterDataSource (in nsIRDFDataSource aDataSource, in boolean aReplace); */
    pub RegisterDataSource: unsafe extern "system" fn (this: *const nsIRDFService, aDataSource: *const nsIRDFDataSource, aReplace: bool) -> nsresult,

    /* void UnregisterDataSource (in nsIRDFDataSource aDataSource); */
    pub UnregisterDataSource: unsafe extern "system" fn (this: *const nsIRDFService, aDataSource: *const nsIRDFDataSource) -> nsresult,

    /* nsIRDFDataSource GetDataSource (in string aURI); */
    pub GetDataSource: unsafe extern "system" fn (this: *const nsIRDFService, aURI: *const libc::c_char, _retval: *mut *const nsIRDFDataSource) -> nsresult,

    /* nsIRDFDataSource GetDataSourceBlocking (in string aURI); */
    pub GetDataSourceBlocking: unsafe extern "system" fn (this: *const nsIRDFService, aURI: *const libc::c_char, _retval: *mut *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 nsIRDFService {

    /// ```text
    /// /**
    ///      * Construct an RDF resource from a single-byte URI. <code>nsIRDFService</code>
    ///      * caches resources that are in-use, so multiple calls to <code>GetResource()</code>
    ///      * for the same <code>uri</code> will return identical pointers. FindResource
    ///      * is used to find out whether there already exists a resource corresponding to that url.
    ///      */
    /// ```
    ///

    /// `nsIRDFResource GetResource (in AUTF8String aURI);`
    #[inline]
    pub unsafe fn GetResource(&self, aURI: &::nsstring::nsACString, _retval: *mut *const nsIRDFResource) -> nsresult {
        ((*self.vtable).GetResource)(self, aURI, _retval)
    }


    /// ```text
    /// /**
    ///      * Construct an RDF resource from a Unicode URI. This is provided
    ///      * as a convenience method, allowing automatic, in-line C++
    ///      * conversion from <code>nsString</code> objects. The <code>uri</code> will
    ///      * be converted to a single-byte representation internally.
    ///      */
    /// ```
    ///

    /// `nsIRDFResource GetUnicodeResource (in AString aURI);`
    #[inline]
    pub unsafe fn GetUnicodeResource(&self, aURI: &::nsstring::nsAString, _retval: *mut *const nsIRDFResource) -> nsresult {
        ((*self.vtable).GetUnicodeResource)(self, aURI, _retval)
    }



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


    /// ```text
    /// /**
    ///      * Construct an RDF literal from a Unicode string.
    ///      */
    /// ```
    ///

    /// `nsIRDFLiteral GetLiteral (in wstring aValue);`
    #[inline]
    pub unsafe fn GetLiteral(&self, aValue: *const libc::int16_t, _retval: *mut *const nsIRDFLiteral) -> nsresult {
        ((*self.vtable).GetLiteral)(self, aValue, _retval)
    }


    /// ```text
    /// /**
    ///      * Construct an RDF literal from a PRTime.
    ///      */
    /// ```
    ///

    /// `nsIRDFDate GetDateLiteral (in PRTime aValue);`
    #[inline]
    pub unsafe fn GetDateLiteral(&self, aValue: PRTime, _retval: *mut *const nsIRDFDate) -> nsresult {
        ((*self.vtable).GetDateLiteral)(self, aValue, _retval)
    }


    /// ```text
    /// /**
    ///      * Construct an RDF literal from an int.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Construct an RDF literal from a data blob
    ///      */
    /// ```
    ///

    /// `[noscript] nsIRDFBlob getBlobLiteral (in const_octet_ptr aValue, in long aLength);`
    const _GetBlobLiteral: () = ();


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


    /// ```text
    /// /**
    ///      * Registers a resource with the RDF system, making it unique w.r.t.
    ///      * GetResource.
    ///      *
    ///      * An implementation of nsIRDFResource should call this in its
    ///      * Init() method if it wishes the resource to be globally unique
    ///      * (which is usually the case).
    ///      *
    ///      * @note that the resource will <i>not</i> be ref-counted by the
    ///      * RDF service: the assumption is that the resource implementation
    ///      * will call nsIRDFService::UnregisterResource() when the last
    ///      * reference to the resource is released.
    ///      *
    ///      * @note that the nsIRDFService implementation may choose to
    ///      * maintain a reference to the resource's URI; therefore, the
    ///      * resource implementation should ensure that the resource's URI
    ///      * (accessible via nsIRDFResource::GetValue(const char* *aURI)) is
    ///      * valid before calling RegisterResource(). Furthermore, the
    ///      * resource implementation should ensure that this pointer
    ///      * <i>remains</i> valid for the lifetime of the resource. (The
        ///      * implementation of the resource cache in nsIRDFService uses the
        ///      * URI maintained "internally" in the resource as a key into the
        ///      * cache rather than copying the resource URI itself.)
    ///      */
    /// ```
    ///

    /// `void RegisterResource (in nsIRDFResource aResource, in boolean aReplace);`
    #[inline]
    pub unsafe fn RegisterResource(&self, aResource: *const nsIRDFResource, aReplace: bool) -> nsresult {
        ((*self.vtable).RegisterResource)(self, aResource, aReplace)
    }


    /// ```text
    /// /**
    ///      * Called to notify the resource manager that a resource is no
    ///      * longer in use. This method should only be called from the
    ///      * destructor of a "custom" resource implementation to notify the
    ///      * RDF service that the last reference to the resource has been
    ///      * released, so the resource is no longer valid.
    ///      *
    ///      * @note As mentioned in nsIRDFResourceFactory::CreateResource(),
    ///      * the RDF service will use the result of
    ///      * nsIRDFResource::GetValue() as a key into its cache. For this
    ///      * reason, you must always un-cache the resource <b>before</b>
    ///      * releasing the storage for the <code>const char*</code> URI.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Register a <i>named data source</i>. The RDF service will call
    ///      * <code>nsIRDFDataSource::GetURI()</code> to determine the URI under
    ///      * which to register the data source.
    ///      *
    ///      * @note that the data source will <i>not</i> be refcounted by the
    ///      * RDF service! The assumption is that an RDF data source
    ///      * registers with the service once it is initialized (via
        ///      * <code>nsIRDFDataSource::Init()</code>), and unregisters when the
    ///      * last reference to the data source is released.
    ///      */
    /// ```
    ///

    /// `void RegisterDataSource (in nsIRDFDataSource aDataSource, in boolean aReplace);`
    #[inline]
    pub unsafe fn RegisterDataSource(&self, aDataSource: *const nsIRDFDataSource, aReplace: bool) -> nsresult {
        ((*self.vtable).RegisterDataSource)(self, aDataSource, aReplace)
    }


    /// ```text
    /// /**
    ///      * Unregister a <i>named data source</i>. The RDF service will call
    ///      * <code>nsIRDFDataSource::GetURI()</code> to determine the URI under which the
    ///      * data source was registered.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Get the <i>named data source</i> corresponding to the URI. If a data
    ///      * source has been registered via <code>RegisterDataSource()</code>, that
    ///      * data source will be returned.
    ///      *
    ///      * If no data source is currently
    ///      * registered for the specified URI, and a data source <i>constructor</i>
    ///      * function has been registered via <code>RegisterDatasourceConstructor()</code>,
    ///      * the RDF service will call the constructor to attempt to construct a
    ///      * new data source. If construction is successful, the data source will
    ///      * be initialized via <code>nsIRDFDataSource::Init()</code>.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Same as GetDataSource, but if a remote/XML data source needs to be
    ///      * constructed, then this method will issue a <b>blocking</b> Refresh
    ///      * call on that data source.
    ///      */
    /// ```
    ///

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


}