Struct xpcom::interfaces::nsINavHistoryQuery

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

interface nsINavHistoryQuery : nsISupports

Methods

impl nsINavHistoryQuery

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

Cast this nsINavHistoryQuery to one of its base interfaces.

impl nsINavHistoryQuery

pub const TIME_RELATIVE_EPOCH: i64

TIME_RELATIVE_EPOCH: i64 = 0

/**
 * This object encapsulates all the query parameters you're likely to need
 * when building up history UI. All parameters are ANDed together.
 *
 * This is not intended to be a super-general query mechanism. This was designed
 * so that most queries can be done in only one SQL query. This is important
 * because, if the user has their profile on a networked drive, query latency
 * can be non-negligible.
 */
/**
   * Time range for results (INCLUSIVE). The *TimeReference is one of the
   * constants TIME_RELATIVE_* which indicates how to interpret the
   * corresponding time value.
   *   TIME_RELATIVE_EPOCH (default):
   *     The time is relative to Jan 1 1970 GMT, (this is a normal PRTime)
   *   TIME_RELATIVE_TODAY:
   *     The time is relative to this morning at midnight. Normally used for
   *     queries relative to today. For example, a "past week" query would be
   *     today-6 days -> today+1 day
   *   TIME_RELATIVE_NOW:
   *     The time is relative to right now.
   *
   * Note: PRTime is in MICROseconds since 1 Jan 1970. Javascript date objects
   * are expressed in MILLIseconds since 1 Jan 1970.
   *
   * As a special case, a 0 time relative to TIME_RELATIVE_EPOCH indicates that
   * the time is not part of the query. This is the default, so an empty query
   * will match any time. The has* functions return whether the corresponding
   * time is considered.
   *
   * You can read absolute*Time to get the time value that the currently loaded
   * reference points + offset resolve to.
   */

pub const TIME_RELATIVE_TODAY: i64

TIME_RELATIVE_TODAY: i64 = 1

pub const TIME_RELATIVE_NOW: i64

TIME_RELATIVE_NOW: i64 = 2

pub unsafe fn GetBeginTime(&self, aBeginTime: *mut PRTime) -> nsresult

attribute PRTime beginTime;

pub unsafe fn SetBeginTime(&self, aBeginTime: PRTime) -> nsresult

attribute PRTime beginTime;

pub unsafe fn GetBeginTimeReference(
    &self,
    aBeginTimeReference: *mut uint32_t
) -> nsresult

attribute unsigned long beginTimeReference;

pub unsafe fn SetBeginTimeReference(
    &self,
    aBeginTimeReference: uint32_t
) -> nsresult

attribute unsigned long beginTimeReference;

pub unsafe fn GetHasBeginTime(&self, aHasBeginTime: *mut bool) -> nsresult

readonly attribute boolean hasBeginTime;

pub unsafe fn GetAbsoluteBeginTime(
    &self,
    aAbsoluteBeginTime: *mut PRTime
) -> nsresult

readonly attribute PRTime absoluteBeginTime;

pub unsafe fn GetEndTime(&self, aEndTime: *mut PRTime) -> nsresult

attribute PRTime endTime;

pub unsafe fn SetEndTime(&self, aEndTime: PRTime) -> nsresult

attribute PRTime endTime;

pub unsafe fn GetEndTimeReference(
    &self,
    aEndTimeReference: *mut uint32_t
) -> nsresult

attribute unsigned long endTimeReference;

pub unsafe fn SetEndTimeReference(
    &self,
    aEndTimeReference: uint32_t
) -> nsresult

attribute unsigned long endTimeReference;

pub unsafe fn GetHasEndTime(&self, aHasEndTime: *mut bool) -> nsresult

readonly attribute boolean hasEndTime;

pub unsafe fn GetAbsoluteEndTime(
    &self,
    aAbsoluteEndTime: *mut PRTime
) -> nsresult

readonly attribute PRTime absoluteEndTime;

pub unsafe fn GetSearchTerms(&self, aSearchTerms: &mut nsAString) -> nsresult

/**
   * Text search terms.
   */

attribute AString searchTerms;

pub unsafe fn SetSearchTerms(&self, aSearchTerms: &nsAString) -> nsresult

/**
   * Text search terms.
   */

attribute AString searchTerms;

pub unsafe fn GetHasSearchTerms(&self, aHasSearchTerms: *mut bool) -> nsresult

readonly attribute boolean hasSearchTerms;

pub unsafe fn GetMinVisits(&self, aMinVisits: *mut int32_t) -> nsresult

/**
   * Set lower or upper limits for how many times an item has been
   * visited.  The default is -1, and in that case all items are
   * matched regardless of their visit count.
   */

attribute long minVisits;

pub unsafe fn SetMinVisits(&self, aMinVisits: int32_t) -> nsresult

/**
   * Set lower or upper limits for how many times an item has been
   * visited.  The default is -1, and in that case all items are
   * matched regardless of their visit count.
   */

attribute long minVisits;

pub unsafe fn GetMaxVisits(&self, aMaxVisits: *mut int32_t) -> nsresult

attribute long maxVisits;

pub unsafe fn SetMaxVisits(&self, aMaxVisits: int32_t) -> nsresult

attribute long maxVisits;

pub unsafe fn SetTransitions(
    &self,
    transitions: *const uint32_t,
    count: uint32_t
) -> nsresult

/**
   * When the set of transitions is nonempty, results are limited to pages which
   * have at least one visit for each of the transition types.
   * @note: For searching on more than one transition this can be very slow.
   *
   * Limit results to the specified list of transition types.
   */

void setTransitions ([array, size_is (count), const] in unsigned long transitions, in unsigned long count);

pub unsafe fn GetTransitions(
    &self,
    count: *mut uint32_t,
    transitions: *mut *mut uint32_t
) -> nsresult

/**
   * Get the transitions set for this query.
   */

void getTransitions ([optional] out unsigned long count, [array, size_is (count), retval] out unsigned long transitions);

pub unsafe fn GetTransitionCount(
    &self,
    aTransitionCount: *mut uint32_t
) -> nsresult

/**
   * Get the count of the set query transitions.
   */

readonly attribute unsigned long transitionCount;

pub unsafe fn GetOnlyBookmarked(&self, aOnlyBookmarked: *mut bool) -> nsresult

/**
   * When set, returns only bookmarked items, when unset, returns anything. Setting this
   * is equivalent to listing all bookmark folders in the 'folders' parameter.
   */

attribute boolean onlyBookmarked;

pub unsafe fn SetOnlyBookmarked(&self, aOnlyBookmarked: bool) -> nsresult

/**
   * When set, returns only bookmarked items, when unset, returns anything. Setting this
   * is equivalent to listing all bookmark folders in the 'folders' parameter.
   */

attribute boolean onlyBookmarked;

pub unsafe fn GetDomainIsHost(&self, aDomainIsHost: *mut bool) -> nsresult

/**
   * This controls the meaning of 'domain', and whether it is an exact match
   * 'domainIsHost' = true, or hierarchical (= false).
   */

attribute boolean domainIsHost;

pub unsafe fn SetDomainIsHost(&self, aDomainIsHost: bool) -> nsresult

/**
   * This controls the meaning of 'domain', and whether it is an exact match
   * 'domainIsHost' = true, or hierarchical (= false).
   */

attribute boolean domainIsHost;

pub unsafe fn GetDomain(&self, aDomain: &mut nsACString) -> nsresult

/**
   * This is the host or domain name (controlled by domainIsHost). When
   * domainIsHost, domain only does exact matching on host names. Otherwise,
   * it will return anything whose host name ends in 'domain'.
   *
   * This one is a little different than most. Setting it to an empty string
   * is a real query and will match any URI that has no host name (local files
   * and such). Set this to NULL (in C++ use SetIsVoid) if you don't want
   * domain matching.
   */

attribute AUTF8String domain;

pub unsafe fn SetDomain(&self, aDomain: &nsACString) -> nsresult

/**
   * This is the host or domain name (controlled by domainIsHost). When
   * domainIsHost, domain only does exact matching on host names. Otherwise,
   * it will return anything whose host name ends in 'domain'.
   *
   * This one is a little different than most. Setting it to an empty string
   * is a real query and will match any URI that has no host name (local files
   * and such). Set this to NULL (in C++ use SetIsVoid) if you don't want
   * domain matching.
   */

attribute AUTF8String domain;

pub unsafe fn GetHasDomain(&self, aHasDomain: *mut bool) -> nsresult

readonly attribute boolean hasDomain;

pub unsafe fn GetUri(&self, aUri: *mut *const nsIURI) -> nsresult

/**
   * This is a URI to match, to, for example, find out every time you visited
   * a given URI. This is an exact match.
   */

attribute nsIURI uri;

pub unsafe fn SetUri(&self, aUri: *const nsIURI) -> nsresult

/**
   * This is a URI to match, to, for example, find out every time you visited
   * a given URI. This is an exact match.
   */

attribute nsIURI uri;

pub unsafe fn GetHasUri(&self, aHasUri: *mut bool) -> nsresult

readonly attribute boolean hasUri;

pub unsafe fn GetAnnotationIsNot(&self, aAnnotationIsNot: *mut bool) -> nsresult

/**
   * Test for existence or non-existence of a given annotation. We don't
   * currently support >1 annotation name per query. If 'annotationIsNot' is
   * true, we test for the non-existence of the specified annotation.
   *
   * Testing for not annotation will do the same thing as a normal query and
   * remove everything that doesn't have that annotation. Asking for things
   * that DO have a given annotation is a little different. It also includes
   * things that have never been visited. This allows place queries to be
   * returned as well as anything else that may have been tagged with an
   * annotation. This will only work for RESULTS_AS_URI since there will be
   * no visits for these items.
   */

attribute boolean annotationIsNot;

pub unsafe fn SetAnnotationIsNot(&self, aAnnotationIsNot: bool) -> nsresult

/**
   * Test for existence or non-existence of a given annotation. We don't
   * currently support >1 annotation name per query. If 'annotationIsNot' is
   * true, we test for the non-existence of the specified annotation.
   *
   * Testing for not annotation will do the same thing as a normal query and
   * remove everything that doesn't have that annotation. Asking for things
   * that DO have a given annotation is a little different. It also includes
   * things that have never been visited. This allows place queries to be
   * returned as well as anything else that may have been tagged with an
   * annotation. This will only work for RESULTS_AS_URI since there will be
   * no visits for these items.
   */

attribute boolean annotationIsNot;

pub unsafe fn GetAnnotation(&self, aAnnotation: &mut nsACString) -> nsresult

attribute AUTF8String annotation;

pub unsafe fn SetAnnotation(&self, aAnnotation: &nsACString) -> nsresult

attribute AUTF8String annotation;

pub unsafe fn GetHasAnnotation(&self, aHasAnnotation: *mut bool) -> nsresult

readonly attribute boolean hasAnnotation;

pub unsafe fn GetTags(&self, aTags: *mut *const nsIVariant) -> nsresult

/**
   * Limit results to items that are tagged with all of the given tags.  This
   * attribute must be set to an array of strings.  When called as a getter it
   * will return an array of strings sorted ascending in lexicographical order.
   * The array may be empty in either case.  Duplicate tags may be specified
   * when setting the attribute, but the getter returns only unique tags.
   *
   * To search for items that are tagged with any given tags rather than all,
   * multiple queries may be passed to nsINavHistoryService.executeQueries().
   */

attribute nsIVariant tags;

pub unsafe fn SetTags(&self, aTags: *const nsIVariant) -> nsresult

/**
   * Limit results to items that are tagged with all of the given tags.  This
   * attribute must be set to an array of strings.  When called as a getter it
   * will return an array of strings sorted ascending in lexicographical order.
   * The array may be empty in either case.  Duplicate tags may be specified
   * when setting the attribute, but the getter returns only unique tags.
   *
   * To search for items that are tagged with any given tags rather than all,
   * multiple queries may be passed to nsINavHistoryService.executeQueries().
   */

attribute nsIVariant tags;

pub unsafe fn GetTagsAreNot(&self, aTagsAreNot: *mut bool) -> nsresult

/**
   * If 'tagsAreNot' is true, the results are instead limited to items that
   * are not tagged with any of the given tags.  This attribute is used in
   * conjunction with the 'tags' attribute.
   */

attribute boolean tagsAreNot;

pub unsafe fn SetTagsAreNot(&self, aTagsAreNot: bool) -> nsresult

/**
   * If 'tagsAreNot' is true, the results are instead limited to items that
   * are not tagged with any of the given tags.  This attribute is used in
   * conjunction with the 'tags' attribute.
   */

attribute boolean tagsAreNot;

pub unsafe fn GetFolders(
    &self,
    count: *mut uint32_t,
    folders: *mut *mut int64_t
) -> nsresult

/**
   * Limit results to items that are in all of the given folders.
   */

void getFolders ([optional] out unsigned long count, [array, size_is (count), retval] out long long folders);

pub unsafe fn GetFolderCount(&self, aFolderCount: *mut uint32_t) -> nsresult

readonly attribute unsigned long folderCount;

pub unsafe fn SetFolders(
    &self,
    folders: *const int64_t,
    folderCount: uint32_t
) -> nsresult

/**
   * For the special result type RESULTS_AS_TAG_CONTENTS we can define only
   * one folder that must be a tag folder. This is not recursive so results
   * will be returned from the first level of that folder.
   */

void setFolders ([array, size_is (folderCount), const] in long long folders, in unsigned long folderCount);

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

/**
   * Creates a new query item with the same parameters of this one.
   */

nsINavHistoryQuery clone ();

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 nsINavHistoryQuery

const IID: nsIID

IID: nsIID = nsID(3699879545, 8945, 19919, [151, 91, 133, 43, 1, 210, 16, 203])

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 nsINavHistoryQuery

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsINavHistoryQuery

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.