Skip to content

Commit 5019b7f

Browse files
Links2004Links2004
committed
Merge pull request #1484 from Links2004/master
move function code of cbuf to cbuf.cpp
2 parents d5d0d73 + bac5ce0 commit 5019b7f

File tree

2 files changed

+148
-61
lines changed

2 files changed

+148
-61
lines changed

‎cores/esp8266/cbuf.cpp

+135-5
Original file line numberDiff line numberDiff line change
@@ -21,25 +21,155 @@
2121
#include "cbuf.h"
2222
#include "c_types.h"
2323

24+
cbuf::cbuf(size_t size) :
25+
_size(size), _buf(new char[size]), _bufend(_buf + size), _begin(_buf), _end(_begin) {
26+
}
27+
28+
cbuf::~cbuf() {
29+
delete[] _buf;
30+
}
31+
32+
size_t cbuf::resizeAdd(size_t addSize) {
33+
return resize(_size + addSize);
34+
}
35+
36+
size_t cbuf::resize(size_t newSize) {
37+
38+
size_t available = getSize();
39+
40+
// not lose any data
41+
// if data can be lost use remove or flush before resize
42+
if((newSize < available) || (newSize == _size)) {
43+
return _size;
44+
}
45+
46+
char *newbuf = new char[newSize];
47+
char *oldbuf = _buf;
48+
49+
if(!newbuf) {
50+
return _size;
51+
}
52+
53+
if(_buf) {
54+
read(newbuf, available);
55+
memset((newbuf + available), 0x00, (newSize - available));
56+
}
57+
58+
_begin = newbuf;
59+
_end = newbuf + available;
60+
_bufend = newbuf + newSize;
61+
_size = newSize;
62+
63+
_buf = newbuf;
64+
delete[] oldbuf;
65+
66+
return _size;
67+
}
68+
2469
size_t ICACHE_RAM_ATTR cbuf::getSize() const {
2570
if(_end >= _begin) {
2671
return _end - _begin;
2772
}
2873
return _size - (_begin - _end);
2974
}
3075

76+
size_t cbuf::room() const {
77+
if(_end >= _begin) {
78+
return _size - (_end - _begin) - 1;
79+
}
80+
return _begin - _end - 1;
81+
}
82+
83+
int cbuf::peek() {
84+
if(empty())
85+
return -1;
86+
87+
return static_cast<int>(*_begin);
88+
}
89+
90+
size_t cbuf::peek(char *dst, size_t size) {
91+
size_t bytes_available = getSize();
92+
size_t size_to_read = (size < bytes_available) ? size : bytes_available;
93+
size_t size_read = size_to_read;
94+
char * begin = _begin;
95+
if(_end < _begin && size_to_read > (size_t) (_bufend - _begin)) {
96+
size_t top_size = _bufend - _begin;
97+
memcpy(dst, _begin, top_size);
98+
begin = _buf;
99+
size_to_read -= top_size;
100+
dst += top_size;
101+
}
102+
memcpy(dst, begin, size_to_read);
103+
return size_read;
104+
}
105+
31106
int ICACHE_RAM_ATTR cbuf::read() {
32-
if(empty()) return -1;
107+
if(empty())
108+
return -1;
33109

34110
char result = *_begin;
35111
_begin = wrap_if_bufend(_begin + 1);
36112
return static_cast<int>(result);
37113
}
38114

115+
size_t cbuf::read(char* dst, size_t size) {
116+
size_t bytes_available = getSize();
117+
size_t size_to_read = (size < bytes_available) ? size : bytes_available;
118+
size_t size_read = size_to_read;
119+
if(_end < _begin && size_to_read > (size_t) (_bufend - _begin)) {
120+
size_t top_size = _bufend - _begin;
121+
memcpy(dst, _begin, top_size);
122+
_begin = _buf;
123+
size_to_read -= top_size;
124+
dst += top_size;
125+
}
126+
memcpy(dst, _begin, size_to_read);
127+
_begin = wrap_if_bufend(_begin + size_to_read);
128+
return size_read;
129+
}
130+
39131
size_t ICACHE_RAM_ATTR cbuf::write(char c) {
40-
if(full()) return 0;
132+
if(full())
133+
return 0;
134+
135+
*_end = c;
136+
_end = wrap_if_bufend(_end + 1);
137+
return 1;
138+
}
139+
140+
size_t cbuf::write(const char* src, size_t size) {
141+
size_t bytes_available = room();
142+
size_t size_to_write = (size < bytes_available) ? size : bytes_available;
143+
size_t size_written = size_to_write;
144+
if(_end >= _begin && size_to_write > (size_t) (_bufend - _end)) {
145+
size_t top_size = _bufend - _end;
146+
memcpy(_end, src, top_size);
147+
_end = _buf;
148+
size_to_write -= top_size;
149+
src += top_size;
150+
}
151+
memcpy(_end, src, size_to_write);
152+
_end = wrap_if_bufend(_end + size_to_write);
153+
return size_written;
154+
}
155+
156+
void cbuf::flush() {
157+
_begin = _buf;
158+
_end = _buf;
159+
}
41160

42-
*_end = c;
43-
_end = wrap_if_bufend(_end + 1);
44-
return 1;
161+
size_t cbuf::remove(size_t size) {
162+
size_t bytes_available = getSize();
163+
if(size >= bytes_available) {
164+
flush();
165+
return 0;
166+
}
167+
size_t size_to_remove = (size < bytes_available) ? size : bytes_available;
168+
if(_end < _begin && size_to_remove > (size_t) (_bufend - _begin)) {
169+
size_t top_size = _bufend - _begin;
170+
_begin = _buf;
171+
size_to_remove -= top_size;
172+
}
173+
_begin = wrap_if_bufend(_begin + size_to_remove);
174+
return getSize();
45175
}

‎cores/esp8266/cbuf.h

+13-56
Original file line numberDiff line numberDiff line change
@@ -27,22 +27,14 @@
2727

2828
class cbuf {
2929
public:
30-
cbuf(size_t size) :
31-
_size(size), _buf(new char[size]), _bufend(_buf + size), _begin(_buf), _end(_begin) {
32-
}
33-
34-
~cbuf() {
35-
delete[] _buf;
36-
}
30+
cbuf(size_t size);
31+
~cbuf();
3732

33+
size_t resizeAdd(size_t addSize);
34+
size_t resize(size_t newSize);
3835
size_t getSize() const;
3936

40-
size_t room() const {
41-
if(_end >= _begin) {
42-
return _size - (_end - _begin) - 1;
43-
}
44-
return _begin - _end - 1;
45-
}
37+
size_t room() const;
4638

4739
inline bool empty() const {
4840
return _begin == _end;
@@ -52,61 +44,26 @@ class cbuf {
5244
return wrap_if_bufend(_end + 1) == _begin;
5345
}
5446

55-
int peek() {
56-
if(empty()) return -1;
57-
58-
return static_cast<int>(*_begin);
59-
}
47+
int peek();
48+
size_t peek(char *dst, size_t size);
6049

6150
int read();
62-
63-
size_t read(char* dst, size_t size) {
64-
size_t bytes_available = getSize();
65-
size_t size_to_read = (size < bytes_available) ? size : bytes_available;
66-
size_t size_read = size_to_read;
67-
if(_end < _begin && size_to_read > (size_t)(_bufend - _begin)) {
68-
size_t top_size = _bufend - _begin;
69-
memcpy(dst, _begin, top_size);
70-
_begin = _buf;
71-
size_to_read -= top_size;
72-
dst += top_size;
73-
}
74-
memcpy(dst, _begin, size_to_read);
75-
_begin = wrap_if_bufend(_begin + size_to_read);
76-
return size_read;
77-
}
51+
size_t read(char* dst, size_t size);
7852

7953
size_t write(char c);
54+
size_t write(const char* src, size_t size);
8055

81-
size_t write(const char* src, size_t size) {
82-
size_t bytes_available = room();
83-
size_t size_to_write = (size < bytes_available) ? size : bytes_available;
84-
size_t size_written = size_to_write;
85-
if(_end >= _begin && size_to_write > (size_t)(_bufend - _end)) {
86-
size_t top_size = _bufend - _end;
87-
memcpy(_end, src, top_size);
88-
_end = _buf;
89-
size_to_write -= top_size;
90-
src += top_size;
91-
}
92-
memcpy(_end, src, size_to_write);
93-
_end = wrap_if_bufend(_end + size_to_write);
94-
return size_written;
95-
}
96-
97-
void flush() {
98-
_begin = _buf;
99-
_end = _buf;
100-
}
56+
void flush();
57+
size_t remove(size_t size);
10158

10259
private:
10360
inline char* wrap_if_bufend(char* ptr) const {
10461
return (ptr == _bufend) ? _buf : ptr;
10562
}
10663

107-
const size_t _size;
64+
size_t _size;
10865
char* _buf;
109-
const char* const _bufend;
66+
const char* _bufend;
11067
char* _begin;
11168
char* _end;
11269
};

0 commit comments

Comments
 (0)