Struct xpcom::interfaces::nsIArrayExtensions

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

interface nsIArrayExtensions : nsIArray

/**
 * Helper interface for allowing scripts to treat nsIArray instances as if
 * they were nsISupportsArray instances while iterating.
 *
 * nsISupportsArray is convenient to iterate over in JavaScript:
 *
 * for (let i = 0; i < array.Count(); ++i) {
 *   let elem = array.GetElementAt(i);
 *   ...
 * }
 *
 * but doing the same with nsIArray is somewhat less convenient, since
 * queryElementAt is not nearly so nice to use from JavaScript.  So we provide
 * this extension interface so interfaces that currently return
 * nsISupportsArray can start returning nsIArrayExtensions and all JavaScript
 * should Just Work. Eventually we'll roll this interface into nsIArray
 * itself, possibly getting rid of the Count() method, as it duplicates
 * nsIArray functionality.
 */

Methods

impl nsIArrayExtensions

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

Cast this nsIArrayExtensions to one of its base interfaces.

impl nsIArrayExtensions

pub unsafe fn Count(&self, _retval: *mut uint32_t) -> nsresult

/**
   * Count()
   *
   * Retrieves the length of the array. This is an alias for the
   * |nsIArray.length| attribute.
   */

uint32_t Count ();

pub unsafe fn GetElementAt(
    &self,
    index: uint32_t,
    _retval: *mut *const nsISupports
) -> nsresult

/**
   * GetElementAt()
   *
   * Retrieve a specific element of the array. null is a valid result for
   * this method.
   *
   * Note: If the index is out of bounds null will be returned.
   *       This differs from the behavior of nsIArray.queryElementAt() which
   *       will throw if an invalid index is specified.
   *
   * @param index position of element
   */

nsISupports GetElementAt (in uint32_t index);

Methods from Deref<Target = nsIArray>

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

Cast this nsIArray to one of its base interfaces.

pub unsafe fn GetLength(&self, aLength: *mut uint32_t) -> nsresult

/**
     * length
     *
     * number of elements in the array.
     */

readonly attribute unsigned long length;

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

/**
     * queryElementAt()
     *
     * Retrieve a specific element of the array, and QueryInterface it
     * to the specified interface. null is a valid result for
     * this method, but exceptions are thrown in other circumstances
     *
     * @param index position of element
     * @param uuid the IID of the requested interface
     * @param result the object, QI'd to the requested interface
     *
     * @throws NS_ERROR_NO_INTERFACE when an entry exists at the
     *         specified index, but the requested interface is not
     *         available.
     * @throws NS_ERROR_ILLEGAL_VALUE when index > length-1
     *
     */

void queryElementAt (in unsigned long index, in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result);

pub unsafe fn IndexOf(
    &self,
    startIndex: uint32_t,
    element: *const nsISupports,
    _retval: *mut uint32_t
) -> nsresult

/**
     * indexOf()
     *
     * Get the position of a specific element. Note that since null is
     * a valid input, exceptions are used to indicate that an element
     * is not found.
     *
     * @param startIndex The initial element to search in the array
     *                   To start at the beginning, use 0 as the
     *                   startIndex
     * @param element    The element you are looking for
     * @returns a number >= startIndex which is the position of the
     *          element in the array.
     * @throws NS_ERROR_FAILURE if the element was not in the array.
     */

unsigned long indexOf (in unsigned long startIndex, in nsISupports element);

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

/**
     * enumerate the array
     *
     * @returns a new enumerator positioned at the start of the array
     * @throws NS_ERROR_FAILURE if the array is empty (to make it easy
     *         to detect errors), or NS_ERROR_OUT_OF_MEMORY if out of memory.
     */

nsISimpleEnumerator enumerate ();

Trait Implementations

impl XpCom for nsIArrayExtensions

const IID: nsIID

IID: nsIID = nsID(639452206, 1292, 17725, [138, 170, 179, 242, 59, 204, 82, 139])

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 nsIArrayExtensions

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIArrayExtensions

type Target = nsIArray

The resulting type after dereferencing.

fn deref(&self) -> &nsIArray

Dereferences the value.