Struct xpcom::interfaces::nsIAnnotationService

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

interface nsIAnnotationService : nsISupports

Methods

impl nsIAnnotationService

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

Cast this nsIAnnotationService to one of its base interfaces.

impl nsIAnnotationService

pub const EXPIRE_SESSION: i64

EXPIRE_SESSION: i64 = 0

/**
     * Valid values for aExpiration, which sets the expiration policy for your
     * annotation. The times for the days, weeks and months policies are
     * measured since the last visit date of the page in question. These
     * will not expire so long as the user keeps visiting the page from time
     * to time.
     */

pub const EXPIRE_WEEKS: i64

EXPIRE_WEEKS: i64 = 2

pub const EXPIRE_MONTHS: i64

EXPIRE_MONTHS: i64 = 3

pub const EXPIRE_NEVER: i64

EXPIRE_NEVER: i64 = 4

pub const EXPIRE_WITH_HISTORY: i64

EXPIRE_WITH_HISTORY: i64 = 5

pub const EXPIRE_DAYS: i64

EXPIRE_DAYS: i64 = 6

pub const TYPE_INT32: i64

TYPE_INT32: i64 = 1

pub const TYPE_DOUBLE: i64

TYPE_DOUBLE: i64 = 2

pub const TYPE_STRING: i64

TYPE_STRING: i64 = 3

pub const TYPE_INT64: i64

TYPE_INT64: i64 = 5

pub unsafe fn SetPageAnnotation(
    &self,
    aURI: *const nsIURI,
    aName: &nsACString,
    aValue: *const nsIVariant,
    aFlags: int32_t,
    aExpiration: uint16_t
) -> nsresult

/**
     * Sets an annotation, overwriting any previous annotation with the same
     * URL/name. IT IS YOUR JOB TO NAMESPACE YOUR ANNOTATION NAMES.
     * Use the form "namespace/value", so your name would be like
     * "bills_extension/page_state" or "history/thumbnail".
     *
     * Do not use characters that are not valid in URLs such as spaces, ":",
     * commas, or most other symbols. You should stick to ASCII letters and
     * numbers plus "_", "-", and "/".
     *
     * aExpiration is one of EXPIRE_* above. aFlags should be 0 for now, some
     * flags will be defined in the future.
     *
     * NOTE: ALL PAGE ANNOTATIONS WILL GET DELETED WHEN THE PAGE IS REMOVED FROM
     * HISTORY IF THE PAGE IS NOT BOOKMARKED. This means that if you create an
     * annotation on an unvisited URI, it will get deleted when the browser
     * shuts down. Otherwise, URIs can exist in history as annotations but the
     * user has no way of knowing it, potentially violating their privacy
     * expectations about actions such as "Clear history".
     * If there is an important annotation that the user or extension wants to
     * keep, you should add a bookmark for the page and use an EXPIRE_NEVER
     * annotation.  This will ensure the annotation exists until the item is
     * removed by the user.
     * See EXPIRE_* constants above for further information.
     *
     * For item annotations, aSource should be a change source constant from
     * nsINavBookmarksService::SOURCE_*, and defaults to SOURCE_DEFAULT if
     * omitted. Setting an item annotation also notifies
     * `nsINavBookmarkObserver::onItemChanged` for the affected item.
     *
     * The annotation "favicon" is special. Favicons are stored in the favicon
     * service, but are special cased in the protocol handler so they look like
     * annotations. Do not set favicons using this service, it will not work.
     *
     * Only C++ consumers may use the type-specific methods.
     *
     * @throws NS_ERROR_ILLEGAL_VALUE if the page or the bookmark doesn't exist.
     */

void setPageAnnotation (in nsIURI aURI, in AUTF8String aName, in nsIVariant aValue, in long aFlags, in unsigned short aExpiration);

pub unsafe fn SetItemAnnotation(
    &self,
    aItemId: int64_t,
    aName: &nsACString,
    aValue: *const nsIVariant,
    aFlags: int32_t,
    aExpiration: uint16_t,
    aSource: uint16_t,
    aDontUpdateLastModified: bool
) -> nsresult

void setItemAnnotation (in long long aItemId, in AUTF8String aName, in nsIVariant aValue, in long aFlags, in unsigned short aExpiration, [optional] in unsigned short aSource, [optional] in bool aDontUpdateLastModified);

pub unsafe fn SetPageAnnotationString(
    &self,
    aURI: *const nsIURI,
    aName: &nsACString,
    aValue: &nsAString,
    aFlags: int32_t,
    aExpiration: uint16_t
) -> nsresult

/**
     * @throws NS_ERROR_ILLEGAL_VALUE if the page or the bookmark doesn't exist.
     */

[noscript] void setPageAnnotationString (in nsIURI aURI, in AUTF8String aName, in AString aValue, in long aFlags, in unsigned short aExpiration);

pub unsafe fn SetItemAnnotationString(
    &self,
    aItemId: int64_t,
    aName: &nsACString,
    aValue: &nsAString,
    aFlags: int32_t,
    aExpiration: uint16_t,
    aSource: uint16_t,
    aDontUpdateLastModified: bool
) -> nsresult

[noscript] void setItemAnnotationString (in long long aItemId, in AUTF8String aName, in AString aValue, in long aFlags, in unsigned short aExpiration, [optional] in unsigned short aSource, [optional] in bool aDontUpdateLastModified);

pub unsafe fn SetPageAnnotationInt32(
    &self,
    aURI: *const nsIURI,
    aName: &nsACString,
    aValue: int32_t,
    aFlags: int32_t,
    aExpiration: uint16_t
) -> nsresult

/**
     * Sets an annotation just like setAnnotationString, but takes an Int32 as
     * input.
     *
     * @throws NS_ERROR_ILLEGAL_VALUE if the page or the bookmark doesn't exist.
     */

[noscript] void setPageAnnotationInt32 (in nsIURI aURI, in AUTF8String aName, in long aValue, in long aFlags, in unsigned short aExpiration);

pub unsafe fn SetItemAnnotationInt32(
    &self,
    aItemId: int64_t,
    aName: &nsACString,
    aValue: int32_t,
    aFlags: int32_t,
    aExpiration: uint16_t,
    aSource: uint16_t,
    aDontUpdateLastModified: bool
) -> nsresult

[noscript] void setItemAnnotationInt32 (in long long aItemId, in AUTF8String aName, in long aValue, in long aFlags, in unsigned short aExpiration, [optional] in unsigned short aSource, [optional] in bool aDontUpdateLastModified);

pub unsafe fn SetPageAnnotationInt64(
    &self,
    aURI: *const nsIURI,
    aName: &nsACString,
    aValue: int64_t,
    aFlags: int32_t,
    aExpiration: uint16_t
) -> nsresult

/**
     * Sets an annotation just like setAnnotationString, but takes an Int64 as
     * input.
     *
     * @throws NS_ERROR_ILLEGAL_VALUE if the page or the bookmark doesn't exist.
     */

[noscript] void setPageAnnotationInt64 (in nsIURI aURI, in AUTF8String aName, in long long aValue, in long aFlags, in unsigned short aExpiration);

pub unsafe fn SetItemAnnotationInt64(
    &self,
    aItemId: int64_t,
    aName: &nsACString,
    aValue: int64_t,
    aFlags: int32_t,
    aExpiration: uint16_t,
    aSource: uint16_t,
    aDontUpdateLastModified: bool
) -> nsresult

[noscript] void setItemAnnotationInt64 (in long long aItemId, in AUTF8String aName, in long long aValue, in long aFlags, in unsigned short aExpiration, [optional] in unsigned short aSource, [optional] in bool aDontUpdateLastModified);

pub unsafe fn SetPageAnnotationDouble(
    &self,
    aURI: *const nsIURI,
    aName: &nsACString,
    aValue: c_double,
    aFlags: int32_t,
    aExpiration: uint16_t
) -> nsresult

/**
     * Sets an annotation just like setAnnotationString, but takes a double as
     * input.
     *
     * @throws NS_ERROR_ILLEGAL_VALUE if the page or the bookmark doesn't exist.
     */

[noscript] void setPageAnnotationDouble (in nsIURI aURI, in AUTF8String aName, in double aValue, in long aFlags, in unsigned short aExpiration);

pub unsafe fn SetItemAnnotationDouble(
    &self,
    aItemId: int64_t,
    aName: &nsACString,
    aValue: c_double,
    aFlags: int32_t,
    aExpiration: uint16_t,
    aSource: uint16_t,
    aDontUpdateLastModified: bool
) -> nsresult

[noscript] void setItemAnnotationDouble (in long long aItemId, in AUTF8String aName, in double aValue, in long aFlags, in unsigned short aExpiration, [optional] in unsigned short aSource, [optional] in boolean aDontUpdateLastModified);

pub unsafe fn GetPageAnnotation(
    &self,
    aURI: *const nsIURI,
    aName: &nsACString,
    _retval: *mut *const nsIVariant
) -> nsresult

/**
     * Retrieves the value of a given annotation. Throws an error if the
     * annotation does not exist. C++ consumers may use the type-specific
     * methods.
     *
     * The type-specific methods throw if the given annotation is set in
     * a different type.
     */

nsIVariant getPageAnnotation (in nsIURI aURI, in AUTF8String aName);

pub unsafe fn GetItemAnnotation(
    &self,
    aItemId: int64_t,
    aName: &nsACString,
    _retval: *mut *const nsIVariant
) -> nsresult

nsIVariant getItemAnnotation (in long long aItemId, in AUTF8String aName);

pub unsafe fn GetPageAnnotationString(
    &self,
    aURI: *const nsIURI,
    aName: &nsACString,
    _retval: &mut nsAString
) -> nsresult

/**
     * @see getPageAnnotation
     */

[noscript] AString getPageAnnotationString (in nsIURI aURI, in AUTF8String aName);

pub unsafe fn GetItemAnnotationString(
    &self,
    aItemId: int64_t,
    aName: &nsACString,
    _retval: &mut nsAString
) -> nsresult

[noscript] AString getItemAnnotationString (in long long aItemId, in AUTF8String aName);

pub unsafe fn GetPageAnnotationInt32(
    &self,
    aURI: *const nsIURI,
    aName: &nsACString,
    _retval: *mut int32_t
) -> nsresult

/**
     * @see getPageAnnotation
     */

[noscript] long getPageAnnotationInt32 (in nsIURI aURI, in AUTF8String aName);

pub unsafe fn GetItemAnnotationInt32(
    &self,
    aItemId: int64_t,
    aName: &nsACString,
    _retval: *mut int32_t
) -> nsresult

[noscript] long getItemAnnotationInt32 (in long long aItemId, in AUTF8String aName);

pub unsafe fn GetPageAnnotationInt64(
    &self,
    aURI: *const nsIURI,
    aName: &nsACString,
    _retval: *mut int64_t
) -> nsresult

/**
     * @see getPageAnnotation
     */

[noscript] long long getPageAnnotationInt64 (in nsIURI aURI, in AUTF8String aName);

pub unsafe fn GetItemAnnotationInt64(
    &self,
    aItemId: int64_t,
    aName: &nsACString,
    _retval: *mut int64_t
) -> nsresult

[noscript] long long getItemAnnotationInt64 (in long long aItemId, in AUTF8String aName);

pub unsafe fn GetPageAnnotationDouble(
    &self,
    aURI: *const nsIURI,
    aName: &nsACString,
    _retval: *mut c_double
) -> nsresult

/**
     * @see getPageAnnotation
     */

[noscript] double getPageAnnotationDouble (in nsIURI aURI, in AUTF8String aName);

pub unsafe fn GetItemAnnotationDouble(
    &self,
    aItemId: int64_t,
    aName: &nsACString,
    _retval: *mut c_double
) -> nsresult

[noscript] double getItemAnnotationDouble (in long long aItemId, in AUTF8String aName);

pub unsafe fn GetPageAnnotationInfo(
    &self,
    aURI: *const nsIURI,
    aName: &nsACString,
    aFlags: *mut int32_t,
    aExpiration: *mut uint16_t,
    aType: *mut uint16_t
) -> nsresult

/**
     * Retrieves info about an existing annotation.
     *
     * aType will be one of TYPE_* constansts above
     *
     * example JS:
     *   var flags = {}, exp = {}, type = {};
     *   annotator.getAnnotationInfo(myURI, "foo", flags, exp, type);
     *   // now you can use 'exp.value' and 'flags.value'
     */

void getPageAnnotationInfo (in nsIURI aURI, in AUTF8String aName, out int32_t aFlags, out unsigned short aExpiration, out unsigned short aType);

pub unsafe fn GetItemAnnotationInfo(
    &self,
    aItemId: int64_t,
    aName: &nsACString,
    aFlags: *mut int32_t,
    aExpiration: *mut uint16_t,
    aType: *mut uint16_t
) -> nsresult

void getItemAnnotationInfo (in long long aItemId, in AUTF8String aName, out long aFlags, out unsigned short aExpiration, out unsigned short aType);

pub unsafe fn GetPageAnnotationType(
    &self,
    aURI: *const nsIURI,
    aName: &nsACString,
    _retval: *mut uint16_t
) -> nsresult

/**
     * Retrieves the type of an existing annotation
     * Use getAnnotationInfo if you need this along with the mime-type etc.
     *
     * @param aURI
     *        the uri on which the annotation is set
     * @param aName
     *        the annotation name
     * @return one of the TYPE_* constants above
     * @throws if the annotation is not set
     */

uint16_t getPageAnnotationType (in nsIURI aURI, in AUTF8String aName);

pub unsafe fn GetItemAnnotationType(
    &self,
    aItemId: int64_t,
    aName: &nsACString,
    _retval: *mut uint16_t
) -> nsresult

uint16_t getItemAnnotationType (in long long aItemId, in AUTF8String aName);

pub unsafe fn GetPagesWithAnnotation(
    &self,
    name: &nsACString,
    resultCount: *mut uint32_t,
    results: *mut *mut *const nsIURI
) -> nsresult

/**
     * Returns a list of all URIs having a given annotation.
     */

void getPagesWithAnnotation (in AUTF8String name, [optional] out unsigned long resultCount, [array, size_is (resultCount), retval] out nsIURI results);

pub unsafe fn GetItemsWithAnnotation(
    &self,
    name: &nsACString,
    resultCount: *mut uint32_t,
    results: *mut *mut int64_t
) -> nsresult

void getItemsWithAnnotation (in AUTF8String name, [optional] out unsigned long resultCount, [array, size_is (resultCount), retval] out long long results);

pub unsafe fn GetAnnotationsWithName(
    &self,
    name: &nsACString,
    count: *mut uint32_t,
    results: *mut *mut *const mozIAnnotatedResult
) -> nsresult

/**
     * Returns a list of mozIAnnotation(s), having a given annotation name.
     *
     * @param name
     *        The annotation to search for.
     * @return list of mozIAnnotation objects.
     */

void getAnnotationsWithName (in AUTF8String name, [optional] out unsigned long count, [array, size_is (count), retval] out mozIAnnotatedResult results);

pub unsafe fn GetPageAnnotationNames(
    &self,
    aURI: *const nsIURI,
    count: *mut uint32_t,
    result: *mut *mut *const nsIVariant
) -> nsresult

/**
     * Get the names of all annotations for this URI.
     *
     * example JS:
     *   var annotations = annotator.getPageAnnotations(myURI, {});
     */

void getPageAnnotationNames (in nsIURI aURI, [optional] out unsigned long count, [array, size_is (count), retval] out nsIVariant result);

pub unsafe fn GetItemAnnotationNames(
    &self,
    aItemId: int64_t,
    count: *mut uint32_t,
    result: *mut *mut *const nsIVariant
) -> nsresult

void getItemAnnotationNames (in long long aItemId, [optional] out unsigned long count, [array, size_is (count), retval] out nsIVariant result);

pub unsafe fn PageHasAnnotation(
    &self,
    aURI: *const nsIURI,
    aName: &nsACString,
    _retval: *mut bool
) -> nsresult

/**
     * Test for annotation existence.
     */

boolean pageHasAnnotation (in nsIURI aURI, in AUTF8String aName);

pub unsafe fn ItemHasAnnotation(
    &self,
    aItemId: int64_t,
    aName: &nsACString,
    _retval: *mut bool
) -> nsresult

boolean itemHasAnnotation (in long long aItemId, in AUTF8String aName);

pub unsafe fn RemovePageAnnotation(
    &self,
    aURI: *const nsIURI,
    aName: &nsACString
) -> nsresult

/**
     * Removes a specific annotation. Succeeds even if the annotation is
     * not found.
     *
     * Removing an item annotation also notifies
     * `nsINavBookmarkObserver::onItemChanged` for the affected item.
     */

void removePageAnnotation (in nsIURI aURI, in AUTF8String aName);

pub unsafe fn RemoveItemAnnotation(
    &self,
    aItemId: int64_t,
    aName: &nsACString,
    aSource: uint16_t
) -> nsresult

void removeItemAnnotation (in long long aItemId, in AUTF8String aName, [optional] in unsigned short aSource);

pub unsafe fn RemovePageAnnotations(&self, aURI: *const nsIURI) -> nsresult

/**
     * Removes all annotations for the given page/item.
     * We may want some other similar functions to get annotations with given
     * flags (once we have flags defined).
     *
     * Unlike the other item methods, `removeItemAnnotations` does *not* notify
     * `nsINavBookmarkObserver::onItemChanged` for the affected item.
     */

void removePageAnnotations (in nsIURI aURI);

pub unsafe fn RemoveItemAnnotations(
    &self,
    aItemId: int64_t,
    aSource: uint16_t
) -> nsresult

void removeItemAnnotations (in long long aItemId, [optional] in unsigned short aSource);

pub unsafe fn CopyPageAnnotations(
    &self,
    aSourceURI: *const nsIURI,
    aDestURI: *const nsIURI,
    aOverwriteDest: bool
) -> nsresult

/**
     * Copies all annotations from the source to the destination URI/item. If
     * the destination already has an annotation with the same name as one on
     * the source, it will be overwritten if aOverwriteDest is set. Otherwise,
     * the original annotation will be preferred.
     *
     * All the source annotations will stay as-is. If you don't want them
     * any more, use removePageAnnotations on that URI.
     */

void copyPageAnnotations (in nsIURI aSourceURI, in nsIURI aDestURI, in boolean aOverwriteDest);

pub unsafe fn CopyItemAnnotations(
    &self,
    aSourceItemId: int64_t,
    aDestItemId: int64_t,
    aOverwriteDest: bool,
    aSource: uint16_t
) -> nsresult

void copyItemAnnotations (in long long aSourceItemId, in long long aDestItemId, in boolean aOverwriteDest, [optional] in unsigned short aSource);

pub unsafe fn AddObserver(
    &self,
    aObserver: *const nsIAnnotationObserver
) -> nsresult

/**
     * Adds an annotation observer. The annotation service will keep an owning
     * reference to the observer object.
     */

void addObserver (in nsIAnnotationObserver aObserver);

pub unsafe fn RemoveObserver(
    &self,
    aObserver: *const nsIAnnotationObserver
) -> nsresult

/**
     * Removes an annotaton observer previously registered by addObserver.
     */

void removeObserver (in nsIAnnotationObserver aObserver);

pub unsafe fn GetObservers(
    &self,
    count: *mut uint32_t,
    observers: *mut *mut *const nsIAnnotationObserver
) -> nsresult

/**
     * Gets an array of registered nsIAnnotationObserver objects.
     */

void getObservers ([optional] out unsigned long count, [array, size_is (count), retval] out nsIAnnotationObserver observers);

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 nsIAnnotationService

const IID: nsIID

IID: nsIID = nsID(3570248369, 36588, 18344, [180, 32, 173, 124, 179, 51, 5, 106])

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 nsIAnnotationService

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIAnnotationService

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.