Struct xpcom::interfaces::nsIXPCTestParams

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

interface nsIXPCTestParams : nsISupports

Methods

impl nsIXPCTestParams

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

Cast this nsIXPCTestParams to one of its base interfaces.

impl nsIXPCTestParams

pub unsafe fn TestBoolean(
    &self,
    a: bool,
    b: *mut bool,
    _retval: *mut bool
) -> nsresult

boolean testBoolean (in boolean a, inout boolean b);

pub unsafe fn TestOctet(
    &self,
    a: uint8_t,
    b: *mut uint8_t,
    _retval: *mut uint8_t
) -> nsresult

octet testOctet (in octet a, inout octet b);

pub unsafe fn TestShort(
    &self,
    a: int16_t,
    b: *mut int16_t,
    _retval: *mut int16_t
) -> nsresult

short testShort (in short a, inout short b);

pub unsafe fn TestLong(
    &self,
    a: int32_t,
    b: *mut int32_t,
    _retval: *mut int32_t
) -> nsresult

long testLong (in long a, inout long b);

pub unsafe fn TestLongLong(
    &self,
    a: int64_t,
    b: *mut int64_t,
    _retval: *mut int64_t
) -> nsresult

long long testLongLong (in long long a, inout long long b);

pub unsafe fn TestUnsignedShort(
    &self,
    a: uint16_t,
    b: *mut uint16_t,
    _retval: *mut uint16_t
) -> nsresult

unsigned short testUnsignedShort (in unsigned short a, inout unsigned short b);

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

unsigned long testUnsignedLong (in unsigned long a, inout unsigned long b);

pub unsafe fn TestUnsignedLongLong(
    &self,
    a: uint64_t,
    b: *mut uint64_t,
    _retval: *mut uint64_t
) -> nsresult

unsigned long long testUnsignedLongLong (in unsigned long long a, inout unsigned long long b);

pub unsafe fn TestFloat(
    &self,
    a: c_float,
    b: *mut c_float,
    _retval: *mut c_float
) -> nsresult

float testFloat (in float a, inout float b);

pub unsafe fn TestDouble(
    &self,
    a: c_double,
    b: *mut c_float,
    _retval: *mut c_double
) -> nsresult

double testDouble (in double a, inout float b);

pub unsafe fn TestChar(
    &self,
    a: c_char,
    b: *mut c_char,
    _retval: *mut c_char
) -> nsresult

char testChar (in char a, inout char b);

pub unsafe fn TestString(
    &self,
    a: *const c_char,
    b: *mut *const c_char,
    _retval: *mut *const c_char
) -> nsresult

string testString (in string a, inout string b);

pub unsafe fn TestWchar(
    &self,
    a: int16_t,
    b: *mut int16_t,
    _retval: *mut int16_t
) -> nsresult

wchar testWchar (in wchar a, inout wchar b);

pub unsafe fn TestWstring(
    &self,
    a: *const int16_t,
    b: *mut *const int16_t,
    _retval: *mut *const int16_t
) -> nsresult

wstring testWstring (in wstring a, inout wstring b);

pub unsafe fn TestDOMString(
    &self,
    a: &nsAString,
    b: &mut nsAString,
    _retval: &mut nsAString
) -> nsresult

DOMString testDOMString (in DOMString a, inout DOMString b);

pub unsafe fn TestAString(
    &self,
    a: &nsAString,
    b: &mut nsAString,
    _retval: &mut nsAString
) -> nsresult

AString testAString (in AString a, inout AString b);

pub unsafe fn TestAUTF8String(
    &self,
    a: &nsACString,
    b: &mut nsACString,
    _retval: &mut nsACString
) -> nsresult

AUTF8String testAUTF8String (in AUTF8String a, inout AUTF8String b);

pub unsafe fn TestACString(
    &self,
    a: &nsACString,
    b: &mut nsACString,
    _retval: &mut nsACString
) -> nsresult

ACString testACString (in ACString a, inout ACString b);

pub unsafe fn TestShortArray(
    &self,
    aLength: uint32_t,
    a: *mut int16_t,
    bLength: *mut uint32_t,
    b: *mut *mut int16_t,
    rvLength: *mut uint32_t,
    rv: *mut *mut int16_t
) -> nsresult

void testShortArray (in unsigned long aLength, [array, size_is (aLength)] in short a, inout unsigned long bLength, [array, size_is (bLength)] inout short b, out unsigned long rvLength, [array, size_is (rvLength), retval] out short rv);

pub unsafe fn TestDoubleArray(
    &self,
    aLength: uint32_t,
    a: *mut c_double,
    bLength: *mut uint32_t,
    b: *mut *mut c_double,
    rvLength: *mut uint32_t,
    rv: *mut *mut c_double
) -> nsresult

void testDoubleArray (in unsigned long aLength, [array, size_is (aLength)] in double a, inout unsigned long bLength, [array, size_is (bLength)] inout double b, out unsigned long rvLength, [array, size_is (rvLength), retval] out double rv);

pub unsafe fn TestStringArray(
    &self,
    aLength: uint32_t,
    a: *mut *const c_char,
    bLength: *mut uint32_t,
    b: *mut *mut *const c_char,
    rvLength: *mut uint32_t,
    rv: *mut *mut *const c_char
) -> nsresult

void testStringArray (in unsigned long aLength, [array, size_is (aLength)] in string a, inout unsigned long bLength, [array, size_is (bLength)] inout string b, out unsigned long rvLength, [array, size_is (rvLength), retval] out string rv);

pub unsafe fn TestWstringArray(
    &self,
    aLength: uint32_t,
    a: *mut *const int16_t,
    bLength: *mut uint32_t,
    b: *mut *mut *const int16_t,
    rvLength: *mut uint32_t,
    rv: *mut *mut *const int16_t
) -> nsresult

void testWstringArray (in unsigned long aLength, [array, size_is (aLength)] in wstring a, inout unsigned long bLength, [array, size_is (bLength)] inout wstring b, out unsigned long rvLength, [array, size_is (rvLength), retval] out wstring rv);

pub unsafe fn TestInterfaceArray(
    &self,
    aLength: uint32_t,
    a: *mut *const nsIXPCTestInterfaceA,
    bLength: *mut uint32_t,
    b: *mut *mut *const nsIXPCTestInterfaceA,
    rvLength: *mut uint32_t,
    rv: *mut *mut *const nsIXPCTestInterfaceA
) -> nsresult

void testInterfaceArray (in unsigned long aLength, [array, size_is (aLength)] in nsIXPCTestInterfaceA a, inout unsigned long bLength, [array, size_is (bLength)] inout nsIXPCTestInterfaceA b, out unsigned long rvLength, [array, size_is (rvLength), retval] out nsIXPCTestInterfaceA rv);

pub unsafe fn TestSizedString(
    &self,
    aLength: uint32_t,
    a: *const c_char,
    bLength: *mut uint32_t,
    b: *mut *const c_char,
    rvLength: *mut uint32_t,
    rv: *mut *const c_char
) -> nsresult

void testSizedString (in unsigned long aLength, [size_is (aLength)] in string a, inout unsigned long bLength, [size_is (bLength)] inout string b, out unsigned long rvLength, [size_is (rvLength), retval] out string rv);

pub unsafe fn TestSizedWstring(
    &self,
    aLength: uint32_t,
    a: *const int16_t,
    bLength: *mut uint32_t,
    b: *mut *const int16_t,
    rvLength: *mut uint32_t,
    rv: *mut *const int16_t
) -> nsresult

void testSizedWstring (in unsigned long aLength, [size_is (aLength)] in wstring a, inout unsigned long bLength, [size_is (bLength)] inout wstring b, out unsigned long rvLength, [size_is (rvLength), retval] out wstring rv);

pub unsafe fn TestInterfaceIs(
    &self,
    aIID: *const nsIID,
    a: *mut c_void,
    bIID: *mut *mut nsIID,
    b: *mut *mut c_void,
    rvIID: *mut *mut nsIID,
    rv: *mut *mut c_void
) -> nsresult

void testInterfaceIs (in nsIIDPtr aIID, [iid_is (aIID)] in nsQIResult a, inout nsIIDPtr bIID, [iid_is (bIID)] inout nsQIResult b, out nsIIDPtr rvIID, [iid_is (rvIID), retval] out nsQIResult rv);

pub unsafe fn TestInterfaceIsArray(
    &self,
    aLength: uint32_t,
    aIID: *const nsIID,
    a: *mut *mut c_void,
    bLength: *mut uint32_t,
    bIID: *mut *mut nsIID,
    b: *mut *mut *mut c_void,
    rvLength: *mut uint32_t,
    rvIID: *mut *mut nsIID,
    rv: *mut *mut *mut c_void
) -> nsresult

void testInterfaceIsArray (in unsigned long aLength, in nsIIDPtr aIID, [array, size_is (aLength), iid_is (aIID)] in nsQIResult a, inout unsigned long bLength, inout nsIIDPtr bIID, [array, size_is (bLength), iid_is (bIID)] inout nsQIResult b, out unsigned long rvLength, out nsIIDPtr rvIID, [retval, array, size_is (rvLength), iid_is (rvIID)] out nsQIResult rv);

pub unsafe fn TestOutAString(&self, o: &mut nsAString) -> nsresult

void testOutAString (out AString o);

pub unsafe fn TestStringArrayOptionalSize(
    &self,
    a: *mut *const c_char,
    aLength: uint32_t,
    _retval: &mut nsACString
) -> nsresult

ACString testStringArrayOptionalSize ([array, size_is (aLength)] in string a, [optional] in unsigned long aLength);

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 nsIXPCTestParams

const IID: nsIID

IID: nsIID = nsID(2166441415, 40908, 16990, [168, 120, 54, 173, 27, 119, 48, 183])

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 nsIXPCTestParams

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIXPCTestParams

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.