Struct xpcom::interfaces::nsITransaction

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

interface nsITransaction : nsISupports

Methods

impl nsITransaction

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

Cast this nsITransaction to one of its base interfaces.

impl nsITransaction

pub unsafe fn DoTransaction(&self) -> nsresult

/**
   * Executes the transaction.
   */

void doTransaction ();

pub unsafe fn UndoTransaction(&self) -> nsresult

/**
   * Restores the state to what it was before the transaction was executed.
   */

void undoTransaction ();

pub unsafe fn RedoTransaction(&self) -> nsresult

/**
   * Executes the transaction again. Can only be called on a transaction that
   * was previously undone.
   * <P>
   * In most cases, the redoTransaction() method will actually call the
   * doTransaction() method to execute the transaction again.
   */

void redoTransaction ();

pub unsafe fn GetIsTransient(&self, aIsTransient: *mut bool) -> nsresult

/**
   * The transaction's transient state. This attribute is checked by
   * the transaction manager after the transaction's Execute() method is called.
   * If the transient state is false, a reference to the transaction is
   * held by the transaction manager so that the transactions' undoTransaction()
   * and redoTransaction() methods can be called. If the transient state is
   * true, the transaction manager returns immediately after the transaction's
   * doTransaction() method is called, no references to the transaction are
   * maintained. Transient transactions cannot be undone or redone by the
   * transaction manager.
   */

readonly attribute boolean isTransient;

pub unsafe fn Merge(
    &self,
    aTransaction: *const nsITransaction,
    _retval: *mut bool
) -> nsresult

/**
   * Attempts to merge a transaction into "this" transaction. Both transactions
   * must be in their undo state, doTransaction() methods already called. The
   * transaction manager calls this method to coalesce a new transaction with
   * the transaction on the top of the undo stack.
   * This method returns a boolean value that indicates the merge result.
   * A true value indicates that the transactions were merged successfully,
   * a false value if the merge was not possible or failed. If true,
   * the transaction manager will Release() the new transacton instead of
   * pushing it on the undo stack.
   * @param aTransaction the previously executed transaction to merge.
   */

boolean merge (in nsITransaction aTransaction);

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 nsITransaction

const IID: nsIID

IID: nsIID = nsID(1491284161, 31560, 4562, [152, 185, 0, 128, 95, 41, 125, 137])

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 nsITransaction

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsITransaction

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.