cpplib/include/lib/impl/stream/buffer.cpp 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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
/* File: /lib/impl/stream/buffer.cpp
 *
 * 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]>
 */

#include <cstring>

#include <algorithm>
#include <utility>

#include <cpp/lib_debug>

#include "../../../lib/system/error.hpp"

#include "./buffer.hpp"

namespace lib::stream::impl {

// IMPLEMENTATION lib::stream::impl::buffer

buffer::buffer( usize size )
	: stream {nullptr}
	, read_pos_ {0}
{
	read_buff.reserve( size );
	write_buff.reserve( size );
}

void buffer::reset( data::rwstream_t * stream_/* = nullptr*/ ) {
	stream = stream_;
	read_pos_ = 0;
	read_buff.clear();
	write_buff.clear();
}

bool buffer::empty() const {
	return stream == nullptr;
}

// IMPLEMENTATION lib::stream::impl::buffer: lib::data::rstream_t

data::result_t buffer::read( const data::buffer_t & buffer )/* override*/ {
	const auto & peek_count = peek( buffer );
	if ( peek_count.success() )
		read_pos_ += peek_count;
	return peek_count;
}

data::result_t buffer::peek( const data::buffer_t & buffer )/* override*/ {
	const auto & read_size_ = read_size();
	CPP_ASSERT( read_size_.success() );
	const auto count = ::std::min( buffer.size(), read_size_.value() );
	::memcpy( buffer.data(), &read_buff[read_pos_], count );
	return count;
}

bool buffer::read_flush()/* override*/ {
	if ( empty() )
		return true;
	read_buff.erase( read_buff.begin(), read_buff.begin() + (isize) read_pos_ );
	read_pos_ = 0;
	const auto current_size = read_buff.size();
	const auto available_size = read_buff.capacity() - current_size;
	auto read_size_ = stream->read_size();
	if ( read_size_.failed() )
		return false;
	const auto count = ::std::min( read_size_.value(), available_size );
	if ( count == 0 )
		return true;
	read_buff.resize( read_buff.capacity() );
	read_size_ = stream->read({ &read_buff[current_size], count });
	if ( read_size_.failed() )
		return false;
	read_buff.resize( current_size + read_size_.value() );
	return true;
}

data::result_t buffer::read_size()/* override*/ {
	return read_buff.size() - read_pos_;
}

data::result_t buffer::read_pos( usize position )/* override*/ {
	return read_pos_ = ::std::min( position, read_buff.size() );
}

data::result_t buffer::read_pos()/* override*/ {
	return read_pos_;
}

data::cbuffer_t buffer::read_cbuffer( bool flush )/* override*/ {
	if ( flush and not read_flush() )
		return {};
	const auto & read_size_ = read_size();
	CPP_ASSERT( read_size_.success() );
	return {&read_buff[read_pos_], read_size_.value()};
}

// IMPLEMENTATION lib::stream::impl::buffer: lib::data::wstream_t

data::result_t buffer::write( const data::cbuffer_t & buffer )/* override*/ {
	const auto & write_size_ = write_size();
	CPP_ASSERT( write_size_.success() );
	const auto count = ::std::min( buffer.size(), write_size_.value() );
	const auto write_pos_ = write_buff.size();
	write_buff.resize( write_buff.size() + count );
	::memcpy( &write_buff[write_pos_], buffer.data(), count );
	return count;
}

bool buffer::write_flush()/* override*/ {
	if ( empty() or write_buff.empty() )
		return true;
	const auto & write_size_ = stream->write( write_buff );
	if ( write_size_.failed() )
		return false;
	write_buff.erase( write_buff.begin(), write_buff.begin() + (isize) write_size_.value() );
	return true;
}

data::result_t buffer::write_size()/* override*/ {
	return write_buff.capacity() - write_buff.size();
}

data::result_t buffer::write_pos( usize position ) {
	if ( empty() )
		return make_error_not_configured();
	write_buff.resize( position );
	return position;
}

data::result_t buffer::write_pos() {
	return write_buff.size();
}

data::buffer_t buffer::write_buffer( bool flush ) {
	if ( flush and not write_flush() )
		return {};
	return write_buff;
}

// IMPLEMENTATION lib::stream::impl::buffer: lib::data::rwstream_t

::std::error_condition buffer::error() const/* override*/ {
	return empty() ? make_error_no_error() : stream->error();
}

} // namespace lib::stream::impl