Source code
Revision control
Copy as Markdown
Other Tools
// This file was autogenerated by the `uniffi-bindgen-gecko-js` crate.
// Trust me, you don't want to mess with it!
import { UniFFITypeError } from "moz-src:///toolkit/components/uniffi-js/js/UniFFI.sys.mjs";
// Objects intended to be used in the unit tests
export var UnitTestObjs = {};
let lazy = {};
ChromeUtils.defineLazyGetter(lazy, "decoder", () => new TextDecoder());
ChromeUtils.defineLazyGetter(lazy, "encoder", () => new TextEncoder());
// Write/Read data to/from an ArrayBuffer
class ArrayBufferDataStream {
constructor(arrayBuffer) {
this.dataView = new DataView(arrayBuffer);
this.pos = 0;
}
readUint8() {
let rv = this.dataView.getUint8(this.pos);
this.pos += 1;
return rv;
}
writeUint8(value) {
this.dataView.setUint8(this.pos, value);
this.pos += 1;
}
readUint16() {
let rv = this.dataView.getUint16(this.pos);
this.pos += 2;
return rv;
}
writeUint16(value) {
this.dataView.setUint16(this.pos, value);
this.pos += 2;
}
readUint32() {
let rv = this.dataView.getUint32(this.pos);
this.pos += 4;
return rv;
}
writeUint32(value) {
this.dataView.setUint32(this.pos, value);
this.pos += 4;
}
readUint64() {
let rv = this.dataView.getBigUint64(this.pos);
this.pos += 8;
return Number(rv);
}
writeUint64(value) {
this.dataView.setBigUint64(this.pos, BigInt(value));
this.pos += 8;
}
readInt8() {
let rv = this.dataView.getInt8(this.pos);
this.pos += 1;
return rv;
}
writeInt8(value) {
this.dataView.setInt8(this.pos, value);
this.pos += 1;
}
readInt16() {
let rv = this.dataView.getInt16(this.pos);
this.pos += 2;
return rv;
}
writeInt16(value) {
this.dataView.setInt16(this.pos, value);
this.pos += 2;
}
readInt32() {
let rv = this.dataView.getInt32(this.pos);
this.pos += 4;
return rv;
}
writeInt32(value) {
this.dataView.setInt32(this.pos, value);
this.pos += 4;
}
readInt64() {
let rv = this.dataView.getBigInt64(this.pos);
this.pos += 8;
return Number(rv);
}
writeInt64(value) {
this.dataView.setBigInt64(this.pos, BigInt(value));
this.pos += 8;
}
readFloat32() {
let rv = this.dataView.getFloat32(this.pos);
this.pos += 4;
return rv;
}
writeFloat32(value) {
this.dataView.setFloat32(this.pos, value);
this.pos += 4;
}
readFloat64() {
let rv = this.dataView.getFloat64(this.pos);
this.pos += 8;
return rv;
}
writeFloat64(value) {
this.dataView.setFloat64(this.pos, value);
this.pos += 8;
}
writeString(value) {
// Note: in order to efficiently write this data, we first write the
// string data, reserving 4 bytes for the size.
const dest = new Uint8Array(this.dataView.buffer, this.pos + 4);
const encodeResult = lazy.encoder.encodeInto(value, dest);
if (encodeResult.read != value.length) {
throw new UniFFIError(
"writeString: out of space when writing to ArrayBuffer. Did the computeSize() method returned the wrong result?"
);
}
const size = encodeResult.written;
// Next, go back and write the size before the string data
this.dataView.setUint32(this.pos, size);
// Finally, advance our position past both the size and string data
this.pos += size + 4;
}
readString() {
const size = this.readUint32();
const source = new Uint8Array(this.dataView.buffer, this.pos, size)
const value = lazy.decoder.decode(source);
this.pos += size;
return value;
}
readBytes() {
const size = this.readInt32();
const bytes = new Uint8Array(this.dataView.buffer, this.pos, size);
this.pos += size;
return bytes
}
writeBytes(value) {
this.writeUint32(value.length);
value.forEach((elt) => {
this.writeUint8(elt);
})
}
// Reads a pointer from the data stream
// UniFFI Pointers are **always** 8 bytes long. That is enforced
// by the C++ and Rust Scaffolding code.
readPointer(pointerId) {
const res = UniFFIScaffolding.readPointer(pointerId, this.dataView.buffer, this.pos);
this.pos += 8;
return res;
}
// Writes a pointer into the data stream
// UniFFI Pointers are **always** 8 bytes long. That is enforced
// by the C++ and Rust Scaffolding code.
writePointer(pointerId, value) {
UniFFIScaffolding.writePointer(pointerId, value, this.dataView.buffer, this.pos);
this.pos += 8;
}
}
function handleRustResult(result, liftCallback, liftErrCallback) {
switch (result.code) {
case "success":
return liftCallback(result.data);
case "error":
throw liftErrCallback(result.data);
case "internal-error":
if (result.data) {
throw new UniFFIInternalError(FfiConverterString.lift(result.data));
} else {
throw new UniFFIInternalError("Unknown error");
}
default:
throw new UniFFIError(`Unexpected status code: ${result.code}`);
}
}
class UniFFIError {
constructor(message) {
this.message = message;
}
toString() {
return `UniFFIError: ${this.message}`
}
}
class UniFFIInternalError extends UniFFIError {}
// Base class for FFI converters
class FfiConverter {
// throw `UniFFITypeError` if a value to be converted has an invalid type
static checkType(value) {
if (value === undefined ) {
throw new UniFFITypeError(`undefined`);
}
if (value === null ) {
throw new UniFFITypeError(`null`);
}
}
}
// Base class for FFI converters that lift/lower by reading/writing to an ArrayBuffer
class FfiConverterArrayBuffer extends FfiConverter {
static lift(buf) {
return this.read(new ArrayBufferDataStream(buf));
}
static lower(value) {
const buf = new ArrayBuffer(this.computeSize(value));
const dataStream = new ArrayBufferDataStream(buf);
this.write(dataStream, value);
return buf;
}
/**
* Computes the size of the value.
*
* @param {*} _value
* @return {number}
*/
static computeSize(_value) {
throw new UniFFIInternalError("computeSize() should be declared in the derived class");
}
/**
* Reads the type from a data stream.
*
* @param {ArrayBufferDataStream} _dataStream
* @returns {any}
*/
static read(_dataStream) {
throw new UniFFIInternalError("read() should be declared in the derived class");
}
/**
* Writes the type to a data stream.
*
* @param {ArrayBufferDataStream} _dataStream
* @param {any} _value
*/
static write(_dataStream, _value) {
throw new UniFFIInternalError("write() should be declared in the derived class");
}
}
// Symbols that are used to ensure that Object constructors
// can only be used with a proper UniFFI pointer
const uniffiObjectPtr = Symbol("uniffiObjectPtr");
const constructUniffiObject = Symbol("constructUniffiObject");
UnitTestObjs.uniffiObjectPtr = uniffiObjectPtr;
/**
* roundtripExtCustomType
* @param {Handle} custom
* @returns {Handle}
*/
export function roundtripExtCustomType(
custom) {
if (custom instanceof UniffiSkipJsTypeCheck) {
custom = custom.value;
} else {
FfiConverterTypeHandle.checkType(custom);
}
const result = UniFFIScaffolding.callSync(
195, // uniffi_uniffi_bindings_tests_external_types_fn_func_roundtrip_ext_custom_type
FfiConverterTypeHandle.lower(custom),
)
return handleRustResult(
result,
FfiConverterTypeHandle.lift.bind(FfiConverterTypeHandle),
null,
)
}
/**
* roundtripExtEnum
* @param {EnumWithData} en
* @returns {EnumWithData}
*/
export function roundtripExtEnum(
en) {
if (en instanceof UniffiSkipJsTypeCheck) {
en = en.value;
} else {
FfiConverterTypeEnumWithData.checkType(en);
}
const result = UniFFIScaffolding.callSync(
196, // uniffi_uniffi_bindings_tests_external_types_fn_func_roundtrip_ext_enum
FfiConverterTypeEnumWithData.lower(en),
)
return handleRustResult(
result,
FfiConverterTypeEnumWithData.lift.bind(FfiConverterTypeEnumWithData),
null,
)
}
/**
* roundtripExtInterface
* @param {TestInterface} int
* @returns {TestInterface}
*/
export function roundtripExtInterface(
int) {
if (int instanceof UniffiSkipJsTypeCheck) {
int = int.value;
} else {
FfiConverterTypeTestInterface.checkType(int);
}
const result = UniFFIScaffolding.callSync(
197, // uniffi_uniffi_bindings_tests_external_types_fn_func_roundtrip_ext_interface
FfiConverterTypeTestInterface.lower(int),
)
return handleRustResult(
result,
FfiConverterTypeTestInterface.lift.bind(FfiConverterTypeTestInterface),
null,
)
}
/**
* roundtripExtRecord
* @param {SimpleRec} rec
* @returns {SimpleRec}
*/
export function roundtripExtRecord(
rec) {
if (rec instanceof UniffiSkipJsTypeCheck) {
rec = rec.value;
} else {
FfiConverterTypeSimpleRec.checkType(rec);
}
const result = UniFFIScaffolding.callSync(
198, // uniffi_uniffi_bindings_tests_external_types_fn_func_roundtrip_ext_record
FfiConverterTypeSimpleRec.lower(rec),
)
return handleRustResult(
result,
FfiConverterTypeSimpleRec.lift.bind(FfiConverterTypeSimpleRec),
null,
)
}
import {
FfiConverterTypeHandle,
} from "./RustUniffiBindingsTests.sys.mjs";
// Export the FFIConverter object to make external types work.
export { FfiConverterTypeHandle };
// Export the FFIConverter object to make external types work.
export class FfiConverterUInt64 extends FfiConverter {
static checkType(value) {
super.checkType(value);
if (!Number.isSafeInteger(value)) {
throw new UniFFITypeError(`${value} exceeds the safe integer bounds`);
}
if (value < 0) {
throw new UniFFITypeError(`${value} exceeds the U64 bounds`);
}
}
static computeSize(_value) {
return 8;
}
static lift(value) {
return value;
}
static lower(value) {
return value;
}
static write(dataStream, value) {
dataStream.writeUint64(value)
}
static read(dataStream) {
return dataStream.readUint64()
}
}
import {
FfiConverterTypeEnumWithData,
} from "./RustUniffiBindingsTests.sys.mjs";
// Export the FFIConverter object to make external types work.
export { FfiConverterTypeEnumWithData };
import {
FfiConverterTypeTestInterface,
} from "./RustUniffiBindingsTests.sys.mjs";
// Export the FFIConverter object to make external types work.
export { FfiConverterTypeTestInterface };
import {
FfiConverterTypeSimpleRec,
} from "./RustUniffiBindingsTests.sys.mjs";
// Export the FFIConverter object to make external types work.
export { FfiConverterTypeSimpleRec };
// Export the FFIConverter object to make external types work.
export class FfiConverterUInt8 extends FfiConverter {
static checkType(value) {
super.checkType(value);
if (!Number.isInteger(value)) {
throw new UniFFITypeError(`${value} is not an integer`);
}
if (value < 0 || value > 256) {
throw new UniFFITypeError(`${value} exceeds the U8 bounds`);
}
}
static computeSize(_value) {
return 1;
}
static lift(value) {
return value;
}
static lower(value) {
return value;
}
static write(dataStream, value) {
dataStream.writeUint8(value)
}
static read(dataStream) {
return dataStream.readUint8()
}
}
// Wrapper to skip type checking for function arguments
//
// This is only defined and used on test fixtures. The goal is to skip the JS type checking so that
// we can test the lower-level C++ type checking.
export class UniffiSkipJsTypeCheck {
constructor(value) {
this.value = value;
}
}