Docs / API / Stdlib / Dataview

DataView

Functions for interacting with DataView.

See DataView on MDN.

t

RESCRIPT

type t

Type representing a DataView.

fromBuffer

RESCRIPT

let fromBuffer: (ArrayBuffer.t, ~byteOffset: int=?, ~length: int=?) => t

fromBuffer(buffer) creates a DataView for the entire ArrayBuffer.

See DataView on MDN.

Examples

RESCRIPT
DataView.fromBuffer(ArrayBuffer.make(16))
DataView.fromBuffer(ArrayBuffer.make(16), ~byteOffset=4)
DataView.fromBuffer(ArrayBuffer.make(16), ~byteOffset=4, ~length=8)

fromBufferToEnd

Deprecated

RESCRIPT

let fromBufferToEnd: (ArrayBuffer.t, ~byteOffset: int) => t

fromBufferToEnd(buffer, ~byteOffset) creates a DataView starting at a given byte offset. See DataView on MDN.

Note: This is a potentially unsafe operation. Ensure the buffer is large enough and only accessed within its bounds.

Examples

RESCRIPT
DataView.fromBufferToEnd(buffer, ~byteOffset=4)

fromBufferWithRange

Deprecated

RESCRIPT

let fromBufferWithRange: (ArrayBuffer.t, ~byteOffset: int, ~length: int) => t

fromBufferWithRange(buffer, ~byteOffset, ~length) creates a DataView for a specific byte range.

See DataView on MDN.

Note: This is a potentially unsafe operation. Ensure the buffer is large enough and only accessed within its bounds.

Examples

RESCRIPT
DataView.fromBufferWithRange(ArrayBuffer.make(16), ~byteOffset=2, ~length=8)

buffer

RESCRIPT

let buffer: t => ArrayBuffer.t

buffer(dataView) returns the underlying ArrayBuffer referenced by this DataView.

See DataView.buffer on MDN.

Examples

RESCRIPT
let array_buffer = ArrayBuffer.make(16)
let dv = DataView.fromBuffer(array_buffer)
DataView.buffer(dv) == array_buffer

byteLength

RESCRIPT

let byteLength: t => int

byteLength(dataView) returns the length (in bytes) of this DataView.

See DataView.byteLength on MDN.

Examples

RESCRIPT
let array_buffer = ArrayBuffer.make(16)
let dv = DataView.fromBuffer(array_buffer)
DataView.byteLength(dv) == 16

byteOffset

RESCRIPT

let byteOffset: t => int

byteOffset(dataView) returns the byte offset of this DataView from the start of its ArrayBuffer.

See DataView.byteOffset on MDN.

Examples

RESCRIPT
let array_buffer = ArrayBuffer.make(16)
let dv = DataView.fromBuffer(array_buffer, ~byteOffset=4)
DataView.byteOffset(dv) == 4

getInt8

RESCRIPT

let getInt8: (t, int) => int

getInt8(dataView, offset) reads an 8-bit signed integer at the specified byte offset.

See DataView.getInt8 on MDN.

Examples

RESCRIPT
let dv = DataView.fromBuffer(ArrayBuffer.make(16))
dv->DataView.setInt8(0, -12)
DataView.getInt8(dv, 0) == -12

getUint8

RESCRIPT

let getUint8: (t, int) => int

getUint8(dataView, offset) reads an 8-bit unsigned integer at the specified byte offset.

See DataView.getUint8 on MDN.

Examples

RESCRIPT
let dv = DataView.fromBuffer(ArrayBuffer.make(16))
dv->DataView.setUint8(1, 255)
DataView.getUint8(dv, 1) == 255

getInt16

RESCRIPT

let getInt16: (t, int, ~littleEndian: bool=?) => int

getInt16(dataView, offset, ~littleEndian=?) reads a 16-bit signed integer at the specified byte offset, with optional endianness.

See DataView.getInt16 on MDN.

Examples

RESCRIPT
let dv = DataView.fromBuffer(ArrayBuffer.make(16))
dv->DataView.setInt16(0, -1234)
dv->DataView.setInt16(2, -1234, ~littleEndian=true)
DataView.getInt16(dv, 0) == -1234
DataView.getInt16(dv, 2, ~littleEndian=true) == -1234

getUint16

RESCRIPT

let getUint16: (t, int, ~littleEndian: bool=?) => int

getUint16(dataView, offset, ~littleEndian=?) reads a 16-bit unsigned integer at the specified byte offset, with optional endianness.

See DataView.getUint16 on MDN.

Examples

RESCRIPT
let dv = DataView.fromBuffer(ArrayBuffer.make(16))
dv->DataView.setUint16(0, 1234)
dv->DataView.setUint16(2, 1234, ~littleEndian=true)
DataView.getUint16(dv, 0) == 1234
DataView.getUint16(dv, 2, ~littleEndian=true) == 1234

getInt32

RESCRIPT

let getInt32: (t, int, ~littleEndian: bool=?) => int

getInt32(dataView, offset, ~littleEndian=?) reads a 32-bit signed integer at the specified byte offset, with optional endianness.

See DataView.getInt32 on MDN.

Examples

RESCRIPT
let dv = DataView.fromBuffer(ArrayBuffer.make(16))
dv->DataView.setInt32(0, -123456)
dv->DataView.setInt32(4, -123456, ~littleEndian=true)
DataView.getInt32(dv, 0) == -123456
DataView.getInt32(dv, 4, ~littleEndian=true) == -123456

getUint32

RESCRIPT

let getUint32: (t, int, ~littleEndian: bool=?) => int

getUint32(dataView, offset, ~littleEndian=?) reads a 32-bit unsigned integer at the specified byte offset, with optional endianness.

See DataView.getUint32 on MDN.

Examples

RESCRIPT
let dv = DataView.fromBuffer(ArrayBuffer.make(16))
dv->DataView.setUint32(0, 123456)
dv->DataView.setUint32(4, 123456, ~littleEndian=true)
DataView.getUint32(dv, 0) == 123456
DataView.getUint32(dv, 4, ~littleEndian=true) == 123456

getFloat16

RESCRIPT

let getFloat16: (t, int, ~littleEndian: bool=?) => float

getFloat16(dataView, offset, ~littleEndian=?) reads a 16-bit floating point number (if supported) at the specified byte offset, with optional endianness.

See DataView.getFloat16 on MDN.

Examples

RESCRIPT
let dv = DataView.fromBuffer(ArrayBuffer.make(16))
dv->DataView.setFloat16(0, 1.5)
dv->DataView.setFloat16(2, 1.5, ~littleEndian=true)
DataView.getFloat16(dv, 0) == 1.5
DataView.getFloat16(dv, 2, ~littleEndian=true) == 1.5

getFloat32

RESCRIPT

let getFloat32: (t, int, ~littleEndian: bool=?) => float

getFloat32(dataView, offset, ~littleEndian=?) reads a 32-bit floating point number at the specified byte offset, with optional endianness.

See DataView.getFloat32 on MDN.

Examples

RESCRIPT
let dv = DataView.fromBuffer(ArrayBuffer.make(16))
dv->DataView.setFloat32(0, 3.14)
dv->DataView.setFloat32(4, 3.14, ~littleEndian=true)
// DataView.getFloat32(dv, 0) == 3.14
// DataView.getFloat32(dv, 4, ~littleEndian=true) == 3.14

getFloat64

RESCRIPT

let getFloat64: (t, int, ~littleEndian: bool=?) => float

getFloat64(dataView, offset, ~littleEndian=?) reads a 64-bit floating point number at the specified byte offset, with optional endianness.

See DataView.getFloat64 on MDN.

Examples

RESCRIPT
let dv = DataView.fromBuffer(ArrayBuffer.make(16))
dv->DataView.setFloat64(0, 6.28)
dv->DataView.setFloat64(8, 6.28, ~littleEndian=true)
DataView.getFloat64(dv, 0) == 6.28
DataView.getFloat64(dv, 8, ~littleEndian=true) == 6.28

getBigInt64

RESCRIPT

let getBigInt64: (t, int, ~littleEndian: bool=?) => bigint

getBigInt64(dataView, offset, ~littleEndian=?) reads a 64-bit signed integer (BigInt) at the specified byte offset, with optional endianness.

See DataView.getBigInt64 on MDN.

Examples

RESCRIPT
let dv = DataView.fromBuffer(ArrayBuffer.make(16))
dv->DataView.setBigInt64(0, -123456789n)
dv->DataView.setBigInt64(8, -123456789n, ~littleEndian=true)
DataView.getBigInt64(dv, 0) == -123456789n
DataView.getBigInt64(dv, 8, ~littleEndian=true) == -123456789n

getBigUint64

RESCRIPT

let getBigUint64: (t, int, ~littleEndian: bool=?) => bigint

getBigUint64(dataView, offset, ~littleEndian=?) reads a 64-bit unsigned integer (BigInt) at the specified byte offset, with optional endianness.

See DataView.getBigUint64 on MDN.

Examples

RESCRIPT
let dv = DataView.fromBuffer(ArrayBuffer.make(16))
dv->DataView.setBigUint64(0, 123456789n)
dv->DataView.setBigUint64(8, 123456789n, ~littleEndian=true)
DataView.getBigUint64(dv, 0) == 123456789n
DataView.getBigUint64(dv, 8, ~littleEndian=true) == 123456789n

setInt8

RESCRIPT

let setInt8: (t, int, int) => unit

setInt8(dataView, offset, value) writes an 8-bit signed integer at the specified byte offset.

See DataView.setInt8 on MDN.

Examples

RESCRIPT
let dv = DataView.fromBuffer(ArrayBuffer.make(16))
DataView.setInt8(dv, 0, -12)
dv->DataView.getInt8(0) == -12

setUint8

RESCRIPT

let setUint8: (t, int, int) => unit

setUint8(dataView, offset, value) writes an 8-bit unsigned integer at the specified byte offset.

See DataView.setUint8 on MDN.

Examples

RESCRIPT
let dv = DataView.fromBuffer(ArrayBuffer.make(16))
DataView.setUint8(dv, 0, 255)
dv->DataView.getUint8(0) == 255

setInt16

RESCRIPT

let setInt16: (t, int, int, ~littleEndian: bool=?) => unit

setInt16(dataView, offset, value, ~littleEndian=?) writes a 16-bit signed integer at the specified byte offset, with optional endianness.

See DataView.setInt16 on MDN.

Examples

RESCRIPT
let dv = DataView.fromBuffer(ArrayBuffer.make(16))
DataView.setInt16(dv, 0, -1234)
DataView.setInt16(dv, 2, -1234, ~littleEndian=true)
dv->DataView.getInt16(0) == -1234
dv->DataView.getInt16(2, ~littleEndian=true) == -1234

setUint16

RESCRIPT

let setUint16: (t, int, int, ~littleEndian: bool=?) => unit

setUint16(dataView, offset, value, ~littleEndian=?) writes a 16-bit unsigned integer at the specified byte offset, with optional endianness.

See DataView.setUint16 on MDN.

Examples

RESCRIPT
let dv = DataView.fromBuffer(ArrayBuffer.make(16))
DataView.setUint16(dv, 0, 1234)
DataView.setUint16(dv, 2, 1234, ~littleEndian=true)
dv->DataView.getUint16(0) == 1234
dv->DataView.getUint16(2, ~littleEndian=true) == 1234

setInt32

RESCRIPT

let setInt32: (t, int, int, ~littleEndian: bool=?) => unit

setInt32(dataView, offset, value, ~littleEndian=?) writes a 32-bit signed integer at the specified byte offset, with optional endianness.

See DataView.setInt32 on MDN.

Examples

RESCRIPT
let dv = DataView.fromBuffer(ArrayBuffer.make(16))
DataView.setInt32(dv, 0, -123456)
DataView.setInt32(dv, 4, -123456, ~littleEndian=true)
dv->DataView.getInt32(0) == -123456
dv->DataView.getInt32(4, ~littleEndian=true) == -123456

setUint32

RESCRIPT

let setUint32: (t, int, int, ~littleEndian: bool=?) => unit

setUint32(dataView, offset, value, ~littleEndian=?) writes a 32-bit unsigned integer at the specified byte offset, with optional endianness.

See DataView.setUint32 on MDN.

Examples

RESCRIPT
let dv = DataView.fromBuffer(ArrayBuffer.make(16))
DataView.setUint32(dv, 0, 123456)
DataView.setUint32(dv, 4, 123456, ~littleEndian=true)
dv->DataView.getUint32(0) == 123456
dv->DataView.getUint32(4, ~littleEndian=true) == 123456

setFloat16

RESCRIPT

let setFloat16: (t, int, float, ~littleEndian: bool=?) => unit

setFloat16(dataView, offset, value, ~littleEndian=?) writes a 16-bit floating point number (if supported) at the specified byte offset, with optional endianness.

See DataView.setFloat16 on MDN.

Examples

RESCRIPT
let dv = DataView.fromBuffer(ArrayBuffer.make(16))
DataView.setFloat16(dv, 0, 1.5)
DataView.setFloat16(dv, 2, 1.5, ~littleEndian=true)
dv->DataView.getFloat16(0) == 1.5
dv->DataView.getFloat16(2, ~littleEndian=true) == 1.5

setFloat32

RESCRIPT

let setFloat32: (t, int, float, ~littleEndian: bool=?) => unit

setFloat32(dataView, offset, value, ~littleEndian=?) writes a 32-bit floating point number at the specified byte offset, with optional endianness.

See DataView.setFloat32 on MDN.

Examples

RESCRIPT
let dv = DataView.fromBuffer(ArrayBuffer.make(16))
DataView.setFloat32(dv, 0, 3.14)
DataView.setFloat32(dv, 4, 3.14, ~littleEndian=true)
// dv->DataView.getFloat32(0) == 3.14
// dv->DataView.getFloat32(4, ~littleEndian=true) == 3.14

setFloat64

RESCRIPT

let setFloat64: (t, int, float, ~littleEndian: bool=?) => unit

setFloat64(dataView, offset, value, ~littleEndian=?) writes a 64-bit floating point number at the specified byte offset, with optional endianness.

See DataView.setFloat64 on MDN.

Examples

RESCRIPT
let dv = DataView.fromBuffer(ArrayBuffer.make(16))
DataView.setFloat64(dv, 0, 6.28)
DataView.setFloat64(dv, 8, 6.28, ~littleEndian=true)
dv->DataView.getFloat64(0) == 6.28
dv->DataView.getFloat64(8, ~littleEndian=true) == 6.28

setBigInt64

RESCRIPT

let setBigInt64: (t, int, bigint, ~littleEndian: bool=?) => unit

setBigInt64(dataView, offset, value, ~littleEndian=?) writes a 64-bit signed integer (BigInt) at the specified byte offset, with optional endianness.

See DataView.setBigInt64 on MDN.

Examples

RESCRIPT
let dv = DataView.fromBuffer(ArrayBuffer.make(16))
DataView.setBigInt64(dv, 0, -123456789n)
DataView.setBigInt64(dv, 8, -123456789n, ~littleEndian=true)
dv->DataView.getBigInt64(0) == -123456789n
dv->DataView.getBigInt64(8, ~littleEndian=true) == -123456789n

setBigUint64

RESCRIPT

let setBigUint64: (t, int, bigint, ~littleEndian: bool=?) => unit

setBigUint64(dataView, offset, value, ~littleEndian=?) writes a 64-bit unsigned integer (BigInt) at the specified byte offset, with optional endianness.

See DataView.setBigUint64 on MDN.

Examples

RESCRIPT
let dv = DataView.fromBuffer(ArrayBuffer.make(16))
DataView.setBigUint64(dv, 0, 123456789n)
DataView.setBigUint64(dv, 8, 123456789n, ~littleEndian=true)
dv->DataView.getBigUint64(0) == 123456789n
dv->DataView.getBigUint64(8, ~littleEndian=true) == 123456789n

ignore

RESCRIPT

let ignore: t => unit

ignore(dataView) ignores the provided DataView and returns unit.

This helper is useful when you want to discard a value (for example, the result of an operation with side effects) without having to store or process it further.