cubos::core::memory::Stream class

#include <core/memory/stream.hpp>

Motivation

Why do we have our own streams? Well, the standard library streams are hard to use and extend, and very template heavy. Using our own streams allows us to abstract away more easily where the data is coming from, or going to, allowing us, for example, to embed files into the executable and not have to worry about the code that reads them.

Derived classes

template<typename T>

class cubos::core::data::FileStream final

Wrapper around an implementation-specific file stream which keeps the file alive and does some sanity checks.

class BufferStream

Stream implementation which writes to/reads from a buffer.

class StandardStream

Stream implementation which wraps a libc file pointer.

class cubos::core::net::TcpStream

Stream implementation which writes to/reads from a TCP connection.

Public static variables

static Stream& stdIn

Stream wrapper for stdin.

static Stream& stdOut

Stream wrapper for stdout.

static Stream& stdErr

Stream wrapper for stderr.

Constructors, destructors, conversion operators

Stream() defaulted

Constructs.

Stream(Stream&&) defaulted

Move constructs.

template<typename T>

requires(::std::is_integral_v<T> && ::std::is_signed_v<T>) void print(T value

Prints a signed integer to the stream.

template<typename T>

requires(::std::is_integral_v<T> && !::std::is_signed_v<T>) inline void print(T value

Prints a signed integer to the stream.

Public functions

auto read(void* data, std::size_t size) -> std::size_t pure virtual

Reads data from the stream.

auto write(const void* data, std::size_t size) -> std::size_t pure virtual

Writes data to the stream.

auto readExact(void* data, std::size_t size) -> bool

Reads data from the stream with the exact specified size.

auto writeExact(const void* data, std::size_t size) -> bool

Writes data to the stream with the exact specified size.

auto tell() const -> std::size_t pure virtual

Gets the current position in the stream.

void seek(ptrdiff_t offset, SeekOrigin origin) pure virtual

Seeks to a position in the stream.

auto eof() const -> bool pure virtual

Checks if the stream still has content to read.

auto peek() -> char pure virtual

Peeks one byte from the stream.

auto get() -> char

Gets one byte from the stream.

void put(char c)

Puts one byte into the stream.

void print(int64_t value, std::size_t base = 10)

Prints a 64 bit signed integer to the stream.

void print(uint64_t value, std::size_t base = 10)

Prints a 64 bit unsigned integer to the stream.

void print(float value, std::size_t decimalPlaces = 4)

Prints a float to the stream.

void print(double value, std::size_t decimalPlaces = 4)

Prints a double to the stream.

void print(const char* str)

Prints a string to the stream.

void print(const char* str, std::size_t size)

Prints a string to the stream.

void print(const ::std::string& str)

Prints a string to the stream.

template<typename T, typename... TArgs>

void printf(const char* fmt, T arg, TArgs... args)

Prints a formatted string the stream.

void printf(const char* fmt)

Prints a string to the stream.

void parse(int8_t& value, std::size_t base = 10)

Parses a 8 bit signed integer from the stream.

void parse(int16_t& value, std::size_t base = 10)

Parses a 16 bit signed integer from the stream.

void parse(int32_t& value, std::size_t base = 10)

Parses a 32 bit signed integer from the stream.

void parse(int64_t& value, std::size_t base = 10)

Parses a 64 bit signed integer from the stream.

void parse(uint8_t& value, std::size_t base = 10)

Parses a 8 bit unsigned integer from the stream.

void parse(uint16_t& value, std::size_t base = 10)

Parses a 16 bit unsigned integer from the stream.

void parse(uint32_t& value, std::size_t base = 10)

Parses a 32 bit unsigned integer from the stream.

void parse(uint64_t& value, std::size_t base = 10)

Parses a 64 bit unsigned integer from the stream.

void parse(float& value)

Parses a float from the stream.

void parse(double& value)

Parses a double from the stream.

void readUntil(std::string& str, const char* terminator)

Reads a string from the stream until the terminator (or \0) is found.

auto readUntil(char* buffer, std::size_t size, const char* terminator) -> std::size_t

Reads a string from the stream until the terminator (or \0) is found.

void ignore(std::size_t size)

Ignores a number of bytes from the stream.

Function documentation

stream.printf("Hello, {}!\n", "world");
stream.printf("{} + {} = {}\n", 1, 2, 3);
stream.printf("\\{} {}\n", 1, 2); // This will print "{} 2"