Struct xpcom::interfaces::nsIRDFService

#[repr(C)]
pub struct nsIRDFService { /* fields omitted */ }

interface nsIRDFService : nsISupports

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

Methods

impl nsIRDFService

pub fn coerce<T: nsIRDFServiceCoerce>(&self) -> &T

Cast this nsIRDFService to one of its base interfaces.

impl nsIRDFService

pub unsafe fn GetResource(
    &self,
    aURI: &nsACString,
    _retval: *mut *const nsIRDFResource
) -> nsresult

/**
     * 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);

pub unsafe fn GetUnicodeResource(
    &self,
    aURI: &nsAString,
    _retval: *mut *const nsIRDFResource
) -> nsresult

/**
     * 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);

pub unsafe fn GetAnonymousResource(
    &self,
    _retval: *mut *const nsIRDFResource
) -> nsresult

nsIRDFResource GetAnonymousResource ();

pub unsafe fn GetLiteral(
    &self,
    aValue: *const int16_t,
    _retval: *mut *const nsIRDFLiteral
) -> nsresult

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

nsIRDFLiteral GetLiteral (in wstring aValue);

pub unsafe fn GetDateLiteral(
    &self,
    aValue: PRTime,
    _retval: *mut *const nsIRDFDate
) -> nsresult

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

nsIRDFDate GetDateLiteral (in PRTime aValue);

pub unsafe fn GetIntLiteral(
    &self,
    aValue: int32_t,
    _retval: *mut *const nsIRDFInt
) -> nsresult

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

nsIRDFInt GetIntLiteral (in long aValue);

pub unsafe fn IsAnonymousResource(
    &self,
    aResource: *const nsIRDFResource,
    _retval: *mut bool
) -> nsresult

boolean IsAnonymousResource (in nsIRDFResource aResource);

pub unsafe fn RegisterResource(
    &self,
    aResource: *const nsIRDFResource,
    aReplace: bool
) -> nsresult

/**
     * 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);

pub unsafe fn UnregisterResource(
    &self,
    aResource: *const nsIRDFResource
) -> nsresult

/**
     * 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);

pub unsafe fn RegisterDataSource(
    &self,
    aDataSource: *const nsIRDFDataSource,
    aReplace: bool
) -> nsresult

/**
     * 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);

pub unsafe fn UnregisterDataSource(
    &self,
    aDataSource: *const nsIRDFDataSource
) -> nsresult

/**
     * 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);

pub unsafe fn GetDataSource(
    &self,
    aURI: *const c_char,
    _retval: *mut *const nsIRDFDataSource
) -> nsresult

/**
     * 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);

pub unsafe fn GetDataSourceBlocking(
    &self,
    aURI: *const c_char,
    _retval: *mut *const nsIRDFDataSource
) -> nsresult

/**
     * 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);

Methods from Deref<Target = nsISupports>

pub fn coerce<T: nsISupportsCoerce>(&self) -> &T

Cast this nsISupports to one of its base interfaces.

pub unsafe fn QueryInterface(
    &self,
    uuid: &nsIID,
    result: *mut *mut c_void
) -> nsresult

void QueryInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result);

pub unsafe fn AddRef(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt AddRef ();

pub unsafe fn Release(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt Release ();

Trait Implementations

impl XpCom for nsIRDFService

const IID: nsIID

IID: nsIID = nsID(3218100833, 33612, 4562, [142, 172, 0, 128, 95, 41, 243, 112])

fn query_interface<T: XpCom>(&self) -> Option<RefPtr<T>>

Perform a QueryInterface call on this object, attempting to dynamically cast it to the requested interface type. Returns Some(RefPtr) if the cast succeeded, and None otherwise.

impl RefCounted for nsIRDFService

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIRDFService

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.