Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-foundation

Source of release 0.6.1

0.6.1 / src / ak / types_stream.lucb

#==============================================================================================
#
#   types_stream - declarations of AK/Stream.h
#
#   DESCRIPTION:
#       Structs, enums, vtables, class information and cast helpers generated from AK/Stream.h
#       (Ladybird 47c82b38d0) by the skeleton generator (DESIGN.md ยง4.4). Regenerate rather
#       than edit, except to fill a field the generator could not map.
#
#==============================================================================================

# mark: Stream ==================================================================================

## AK::Stream (AK/Stream.h:23).
pub struct Stream: IsStream:
    pub var vtable: const StreamVTable*
    pub var class_id: u16

    pub func stream() -> Stream*: return (Stream*)&self

## Upcast to AK::Stream (implemented by every struct in its hierarchy).
pub interface IsStream:
    func stream() -> Stream*

## Virtual functions introduced by AK::Stream.
pub struct StreamVTable:
    pub let class_info: const ClassInfo*
    pub let read_some: func(Stream*, u8[]) -> u8[]! = stream_read_some_impl
    pub let read_until_filled: func(Stream*, u8[]) -> unit! = stream_read_until_filled_impl
    pub let read_until_eof: func(Stream*, usize) -> ByteBuffer! = stream_read_until_eof_impl
    pub let discard: func(Stream*, usize) -> unit! = stream_discard_impl
    pub let write_some: func(Stream*, const u8[]) -> usize! = stream_write_some_impl
    pub let write_until_depleted_span_u8: func(Stream*, const u8[]) -> unit! = stream_write_until_depleted_span_u8_impl
    pub let is_eof: func(Stream*) -> bool = stream_is_eof_impl
    pub let is_open: func(Stream*) -> bool = stream_is_open_impl
    pub let close: func(Stream*) -> unit = stream_close_impl

## Virtual: AK::Stream::read_some.
pub func stream_read_some(this: Stream*, arg0: u8[]) -> u8[]!:
    return try ((const StreamVTable*)this.vtable).read_some(this, arg0)

## Virtual: AK::Stream::read_until_filled.
pub func stream_read_until_filled(this: Stream*, buffer: u8[]) -> !:
    try ((const StreamVTable*)this.vtable).read_until_filled(this, buffer)

## Virtual: AK::Stream::read_until_eof.
pub func stream_read_until_eof(this: Stream*, block_size_: usize) -> ByteBuffer!:
    return try ((const StreamVTable*)this.vtable).read_until_eof(this, block_size_)

## Virtual: AK::Stream::discard.
pub func stream_discard(this: Stream*, discarded_bytes: usize) -> !:
    try ((const StreamVTable*)this.vtable).discard(this, discarded_bytes)

## Virtual: AK::Stream::write_some.
pub func stream_write_some(this: Stream*, arg0: const u8[]) -> usize!:
    return try ((const StreamVTable*)this.vtable).write_some(this, arg0)

## Virtual: AK::Stream::write_until_depleted.
pub func stream_write_until_depleted_span_u8(this: Stream*, buffer: const u8[]) -> !:
    try ((const StreamVTable*)this.vtable).write_until_depleted_span_u8(this, buffer)

## Virtual: AK::Stream::is_eof.
pub func stream_is_eof(this: Stream*) -> bool:
    return ((const StreamVTable*)this.vtable).is_eof(this)

## Virtual: AK::Stream::is_open.
pub func stream_is_open(this: Stream*) -> bool:
    return ((const StreamVTable*)this.vtable).is_open(this)

## Virtual: AK::Stream::close.
pub func stream_close(this: Stream*):
    ((const StreamVTable*)this.vtable).close(this)

## The vtable of AK::Stream.
pub let stream_vtable: StreamVTable = StreamVTable(class_info = &stream_class)

## Class information of AK::Stream: name, class-id range (pre-order), size, vtable.
pub let stream_class: ClassInfo = ClassInfo(name = "Stream", first_id = 0, last_id = 5, size = memory.size_of(Stream), vtable = (const void*)&stream_vtable)

## is<AK::Stream>: the class-id range test.
pub func is_stream[P: IsStream](p: P*) -> bool:
    let id = p.stream().class_id
    return id >= stream_class.first_id and id <= stream_class.last_id

## as_if<AK::Stream>.
pub func as_if_stream[P: IsStream](p: P*) -> Stream*?:
    if is_stream(p): return (Stream*)p
    return none

## as<AK::Stream> (verify_cast).
pub func as_stream[P: IsStream](p: P*) -> Stream*:
    return as_if_stream(p) else trap("as<AK::Stream> failed")

## AK::SeekMode (AK/Stream.h:142).
pub enum SeekMode as i32:
    set_position = 0
    from_current_position = 1
    from_end_position = 2

# mark: SeekableStream ==========================================================================

## AK::SeekableStream (AK/Stream.h:150).
pub struct SeekableStream: IsSeekableStream, IsStream:
    pub var stream_base: Stream  # primary base

    pub func seekable_stream() -> SeekableStream*: return (SeekableStream*)&self

    pub func stream() -> Stream*: return (Stream*)&self

## Upcast to AK::SeekableStream (implemented by every struct in its hierarchy).
pub interface IsSeekableStream:
    func seekable_stream() -> SeekableStream*

## Virtual functions introduced by AK::SeekableStream.
pub struct SeekableStreamVTable:
    pub let stream_vtable: StreamVTable
    pub let seek: func(SeekableStream*, i64, SeekMode) -> usize! = seekable_stream_seek_impl
    pub let tell: func(SeekableStream*) -> usize! = seekable_stream_tell_impl
    pub let size: func(SeekableStream*) -> usize! = seekable_stream_size_impl
    pub let truncate: func(SeekableStream*, usize) -> unit! = seekable_stream_truncate_impl

## Virtual: AK::SeekableStream::seek.
pub func seekable_stream_seek(this: SeekableStream*, offset: i64, arg1: SeekMode) -> usize!:
    return try ((const SeekableStreamVTable*)((Stream*)this).vtable).seek(this, offset, arg1)

## Virtual: AK::SeekableStream::tell.
pub func seekable_stream_tell(this: SeekableStream*) -> usize!:
    return try ((const SeekableStreamVTable*)((Stream*)this).vtable).tell(this)

## Virtual: AK::SeekableStream::size.
pub func seekable_stream_size(this: SeekableStream*) -> usize!:
    return try ((const SeekableStreamVTable*)((Stream*)this).vtable).size(this)

## Virtual: AK::SeekableStream::truncate.
pub func seekable_stream_truncate(this: SeekableStream*, length: usize) -> !:
    try ((const SeekableStreamVTable*)((Stream*)this).vtable).truncate(this, length)

## The vtable of AK::SeekableStream.
pub let seekable_stream_vtable: SeekableStreamVTable = SeekableStreamVTable(stream_vtable = StreamVTable(class_info = &seekable_stream_class, discard = seekable_stream_discard_impl))

## Class information of AK::SeekableStream: name, class-id range (pre-order), size, vtable.
pub let seekable_stream_class: ClassInfo = ClassInfo(name = "SeekableStream", first_id = 2, last_id = 5, size = memory.size_of(SeekableStream), vtable = (const void*)&seekable_stream_vtable)

## is<AK::SeekableStream>: the class-id range test.
pub func is_seekable_stream[P: IsStream](p: P*) -> bool:
    let id = p.stream().class_id
    return id >= seekable_stream_class.first_id and id <= seekable_stream_class.last_id

## as_if<AK::SeekableStream>.
pub func as_if_seekable_stream[P: IsStream](p: P*) -> SeekableStream*?:
    if is_seekable_stream(p): return (SeekableStream*)p
    return none

## as<AK::SeekableStream> (verify_cast).
pub func as_seekable_stream[P: IsStream](p: P*) -> SeekableStream*:
    return as_if_seekable_stream(p) else trap("as<AK::SeekableStream> failed")