bluelib/core-mm/stream.cpp

#include <blue/core/stream.h>
#include <blue/core/stream.hpp>

namespace blue::core
{
type stream::get_type(void)
{
	return b_stream_get_type();
}

stream &stream::in(void)
{
	static stream s;
	s.ptr_ = b_stdin;
	return s;
}

stream &stream::out(void)
{
	static stream s;
	s.ptr_ = b_stdout;
	return s;
}

stream &stream::err(void)
{
	static stream s;
	s.ptr_ = b_stderr;
	return s;
}

stream::stream(std::FILE *fp)
{
	ptr_ = b_stream_open_fp(fp);
}

status stream::reserve(std::size_t len)
{
	return b_stream_reserve(ptr_, len);
}

status stream::seek(long long offset, seek_origin origin)
{
	return b_stream_seek(
		ptr_, offset, static_cast<b_stream_seek_origin>(origin));
}

std::size_t stream::cursor(void) const
{
	return b_stream_cursor(ptr_);
}

status stream::push_indent(int indent)
{
	return b_stream_push_indent(ptr_, indent);
}

status stream::pop_indent(void)
{
	return b_stream_pop_indent(ptr_);
}

status stream::read_char(wchar &c)
{
	b_wchar tmp;
	status s = b_stream_read_char(ptr_, &tmp);
	c = tmp;
	return s;
}

status stream::read_bytes(void *buf, std::size_t count, std::size_t &nr_read)
{
	std::size_t r;
	status s = b_stream_read_bytes(ptr_, buf, count, &r);
	nr_read = r;
	return s;
}

status stream::read_line(char *s, std::size_t max)
{
	return b_stream_read_line(ptr_, s, max);
}

status stream::read_line(std::string &out)
{
	while (1) {
		wchar c = wchar::INVALID;
		status s = read_char(c);
		if (!s) {
			return s;
		}

		if (c == '\n') {
			break;
		}

		char str[5] = {0};
		c.encode_utf8(str);
		out.append(str);
	}

	return status::SUCCESS;
}

status stream::read_line(stream &dest)
{
	return b_stream_read_line_s(ptr_, dest.ptr_);
}

status stream::read_all_bytes(void *p, std::size_t max, std::size_t &nr_read)
{
	std::size_t tmp;
	status s = b_stream_read_all_bytes(ptr_, p, max, &tmp);
	nr_read = tmp;
	return s;
}

status stream::read_all_bytes(stream &dest, stream_buffer &buf, std::size_t &nr_read)
{
	std::size_t tmp;
	status s = b_stream_read_all_bytes_s(ptr_, dest.ptr_, buf.ptr(), &tmp);
	nr_read = tmp;
	return s;
}

status stream::write_char(wchar c)
{
	return b_stream_write_char(ptr_, c);
}

status stream::write_string(const char *str, std::size_t &nr_written)
{
	std::size_t tmp;
	status s = b_stream_write_string(ptr_, str, &tmp);
	nr_written = tmp;
	return s;
}

status stream::write_bytes(
	const void *buf, std::size_t count, std::size_t &nr_written)
{
	std::size_t tmp;
	status s = b_stream_write_bytes(ptr_, buf, count, &tmp);
	nr_written = tmp;
	return s;
}

status stream::write_fmt(std::size_t &nr_written, const char *format, ...)
{
	size_t tmp;
	std::va_list arg;
	va_start(arg, format);
	status s = b_stream_write_vfmt(ptr_, &tmp, format, arg);
	va_end(arg);

	nr_written = tmp;
	return s;
}

status stream::write_vfmt(std::size_t &nr_written, const char *format, va_list arg)
{
	size_t tmp;
	status s = b_stream_write_vfmt(ptr_, &tmp, format, arg);

	nr_written = tmp;
	return s;
}

}