cpplib/include/lib/data/stream.hpp at master · vslavski/cpplib · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
/* File: /lib/data/stream.hpp
 *
 * This file is a part of cpplib project which is distributed under MIT License.
 * See file LICENSE for full license details.
 *
 * Copyright (c) 2020-present Nikita Zuev (V.Slavski!) <[email protected]>
 */
#ifndef CPPLIB__lib__data__stream__hpp
#define CPPLIB__lib__data__stream__hpp

#include <system_error>

#include "../../lib/tl/result.hpp"
#include "../../lib/types.hpp"
#include "../../lib/system/error.hpp"

#include "./buffer.hpp"

/// @todo noexcept?

namespace lib::data {

// DECLARATION lib::data::result_t

using result_t = tl::result_numeric_t<usize>;

// DECLARATION lib::data::rstream_t

class rstream_t {
public:
	virtual ~rstream_t() = default;

	virtual result_t read( const buffer_t & buffer ) = 0;
	virtual result_t peek( const buffer_t &/* buffer*/ ) { return make_error_not_implemented(); }
	virtual bool read_flush() { return false; }

	virtual result_t read_size() = 0;
	virtual result_t read_pos( usize/* position*/ ) { return make_error_not_implemented(); }
	virtual result_t read_pos() { return make_error_not_implemented(); }
	virtual buffer_t read_buffer( bool/* flush*/ ) { return {}; }
	virtual cbuffer_t read_cbuffer( bool/* flush*/ ) { return {}; }
	buffer_t read_buffer() { return read_buffer( false ); }
	cbuffer_t read_cbuffer() { return read_cbuffer( false ); }

	virtual ::std::error_condition read_error() const = 0;
};

// DECLARATION lib::data::wstream_t

class wstream_t {
public:
	virtual ~wstream_t() = default;

	virtual result_t write( const cbuffer_t & buffer ) = 0;
	/// @todo Add rewrite(pos, buffer) ?
	virtual bool write_flush() { return false; }

	virtual result_t write_size() = 0;
	virtual result_t write_pos( usize/* position*/ ) { return make_error_not_implemented(); }
	virtual result_t write_pos() { return make_error_not_implemented(); }
	virtual buffer_t write_buffer( bool/* flush*/ ) { return {}; }
	virtual cbuffer_t write_cbuffer( bool/* flush*/ ) { return {}; }
	buffer_t write_buffer() { return write_buffer( false ); }
	cbuffer_t write_cbuffer() { return write_cbuffer( false ); }

	virtual ::std::error_condition write_error() const = 0;
};

// DECLARATION lib::data::rwstream_t

class rwstream_t
	: public rstream_t
	, public wstream_t
{
public:
	virtual ~rwstream_t() = default;

	virtual bool flush() { return false; }

	virtual result_t size() { return make_error_not_implemented(); }
	virtual result_t pos( usize/* position*/ ) { return make_error_not_implemented(); }
	virtual result_t pos() { return make_error_not_implemented(); }

	virtual ::std::error_condition error() const = 0;
};

// DECLARATION lib::data::unistream_t

class unistream_t
	: public rwstream_t
{
public:
	virtual ~unistream_t() = default;

	// IMPLEMENTATION lib::data::rwstream_t

	bool flush() override = 0;
	result_t size() override = 0;
	using rwstream_t::pos;
	using rwstream_t::error;

	// IMPLEMENTATION lib::data::rstream_t

	bool read_flush() override { return flush(); }
	result_t read_size() override { return size(); }
	result_t read_pos( usize position ) override { return pos( position ); }
	result_t read_pos() override { return pos(); }
	::std::error_condition read_error() const override { return error(); }

	// IMPLEMENTATION lib::data::wstream_t

	bool write_flush() override { return flush(); }
	result_t write_size() override { return size(); }
	result_t write_pos( usize position ) override { return pos( position ); }
	result_t write_pos() override { return pos(); }
	::std::error_condition write_error() const override { return error(); }
};

} // namespace lib::data

#endif // CPPLIB__lib__data__stream__hpp