Struct xpcom::interfaces::nsIMutableArray

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

interface nsIMutableArray : nsIArrayExtensions

/**
 * nsIMutableArray
 * A separate set of methods that will act on the array. Consumers of
 * nsIArray should not QueryInterface to nsIMutableArray unless they
 * own the array.
 *
 * As above, it is legal to add null elements to the array. Note also
 * that null elements can be created as a side effect of
 * insertElementAt(). Conversely, if insertElementAt() is never used,
 * and null elements are never explicitly added to the array, then it
 * is guaranteed that queryElementAt() will never return a null value.
 *
 * Any of these methods may throw NS_ERROR_OUT_OF_MEMORY when the
 * array must grow to complete the call, but the allocation fails.
 */

Methods

impl nsIMutableArray

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

Cast this nsIMutableArray to one of its base interfaces.

impl nsIMutableArray

pub unsafe fn AppendElement(&self, element: *const nsISupports) -> nsresult

/**
     * appendElement()
     *
     * Append an element at the end of the array.
     *
     * @param element The element to append.
     */

void appendElement (in nsISupports element);

pub unsafe fn RemoveElementAt(&self, index: uint32_t) -> nsresult

/**
     * removeElementAt()
     *
     * Remove an element at a specific position, moving all elements
     * stored at a higher position down one.
     * To remove a specific element, use indexOf() to find the index
     * first, then call removeElementAt().
     *
     * @param index the position of the item
     *
     */

void removeElementAt (in unsigned long index);

pub unsafe fn InsertElementAt(
    &self,
    element: *const nsISupports,
    index: uint32_t
) -> nsresult

/**
     * insertElementAt()
     *
     * Insert an element at the given position, moving the element
     * currently located in that position, and all elements in higher
     * position, up by one.
     *
     * @param element The element to insert
     * @param index   The position in the array:
     *                If the position is lower than the current length
     *                of the array, the elements at that position and
     *                onwards are bumped one position up.
     *                If the position is equal to the current length
     *                of the array, the new element is appended.
     *                An index lower than 0 or higher than the current
     *                length of the array is invalid and will be ignored.
     */

void insertElementAt (in nsISupports element, in unsigned long index);

pub unsafe fn ReplaceElementAt(
    &self,
    element: *const nsISupports,
    index: uint32_t
) -> nsresult

/**
     * replaceElementAt()
     *
     * Replace the element at the given position.
     *
     * @param element The new element to insert
     * @param index   The position in the array
     *                If the position is lower than the current length
     *                of the array, an existing element will be replaced.
     *                If the position is equal to the current length
     *                of the array, the new element is appended.
     *                If the position is higher than the current length
     *                of the array, empty elements are appended followed
     *                by the new element at the specified position.
     *                An index lower than 0 is invalid and will be ignored.
     */

void replaceElementAt (in nsISupports element, in unsigned long index);

pub unsafe fn Clear(&self) -> nsresult

/**
     * clear()
     *
     * clear the entire array, releasing all stored objects
     */

void clear ();

Methods from Deref<Target = nsIArrayExtensions>

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

Cast this nsIArrayExtensions to one of its base interfaces.

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

Trait Implementations

impl XpCom for nsIMutableArray

const IID: nsIID

IID: nsIID = nsID(2936380832, 51291, 16620, [175, 7, 174, 75, 253, 193, 146, 204])

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 nsIMutableArray

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIMutableArray

type Target = nsIArrayExtensions

The resulting type after dereferencing.

fn deref(&self) -> &nsIArrayExtensions

Dereferences the value.