9872110687

Committed 10 Jul 2024 09:58AM UTC coverage: 98.468%. Remained the same

Build # 9872110687

Build Type

push

github

Committed by

bblanchon

Commit Message

Set version to 1.9.0

Run Details

964 of 979 relevant lines covered (98.47%)

2069.74 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.12

/src/StreamUtils/Policies/ReadBufferingPolicy.hpp

// StreamUtils - github.com/bblanchon/ArduinoStreamUtils
// Copyright Benoit Blanchon 2019-2024
// MIT License

#pragma once

#include <Stream.h>

#include "../Buffers/LinearBuffer.hpp"
#include "../Helpers.hpp"

namespace StreamUtils {

template <typename TAllocator>
struct ReadBufferingPolicy {
  ReadBufferingPolicy(size_t capacity, TAllocator allocator = TAllocator())
      : _buffer(capacity, allocator) {}

  ReadBufferingPolicy(const ReadBufferingPolicy &other)
      : _buffer(other._buffer) {}

  int available(Stream &stream) {
    return static_cast<int>(stream.available() + _buffer.available());
  }

  template <typename TTarget>  // Stream or Client
  int read(TTarget &target) {
    if (!_buffer)
      return target.read();

    if (_buffer.available() > 0)
      return _buffer.read();

    size_t avail = static_cast<size_t>(target.available());
    if (avail <= 1)
      return target.read();

    _buffer.reloadFrom(target, avail);
    return _buffer.read();
  }

  int peek(Stream &stream) {
    return isEmpty() ? stream.peek() : _buffer.peek();
  }

  size_t readBytes(Stream &stream, char *buffer, size_t size) {
    return doReadBytes(stream, buffer, size);
  }

  int read(Client &client, uint8_t *buffer, size_t size) {
    return static_cast<int>(
        doReadBytes(client, reinterpret_cast<char *>(buffer), size));
  }

 private:
  bool isEmpty() const {
    return _buffer.available() == 0;
  }

  LinearBuffer<TAllocator> _buffer;

  template <typename TTarget>  // Stream or Client
  size_t doReadBytes(TTarget &target, char *buffer, size_t size) {
    if (!_buffer)
      return readOrReadBytes(target, buffer, size);

    size_t result = 0;

    // can we read from buffer?
    if (_buffer.available() > 0) {
      size_t bytesRead = _buffer.readBytes(buffer, size);
      result += bytesRead;
      buffer += bytesRead;
      size -= bytesRead;
    }

    // still something to read?
    if (size > 0) {
      // (at this point, the buffer is empty)

      size_t avail = static_cast<size_t>(target.available());

      // should we use the buffer?
      if (avail > size && size < _buffer.capacity()) {
        _buffer.reloadFrom(target, avail);
        size_t bytesRead = _buffer.readBytes(buffer, size);
        result += bytesRead;
      } else {
        // we can bypass the buffer
        result += readOrReadBytes(target, buffer, size);
      }
    }

    return result;
  }
};  // namespace StreamUtils

}  // namespace StreamUtils

1	// StreamUtils - github.com/bblanchon/ArduinoStreamUtils
2	// Copyright Benoit Blanchon 2019-2024
3	// MIT License
4
5	#pragma once
6
7	#include <Stream.h>
8
9	#include "../Buffers/LinearBuffer.hpp"
10	#include "../Helpers.hpp"
11
12	namespace StreamUtils {
13
14	template <typename TAllocator>
15	struct ReadBufferingPolicy {
16	ReadBufferingPolicy(size_t capacity, TAllocator allocator = TAllocator())	528✔
17	: _buffer(capacity, allocator) {}	528✔
18
19	ReadBufferingPolicy(const ReadBufferingPolicy &other)	552✔
20	: _buffer(other._buffer) {}	552✔
21
22	int available(Stream &stream) {	120✔
23	return static_cast<int>(stream.available() + _buffer.available());	120✔
24	}
25
26	template <typename TTarget> // Stream or Client
27	int read(TTarget &target) {	822✔
28	if (!_buffer)	822✔
29	return target.read();	78✔
30
31	if (_buffer.available() > 0)	744✔
32	return _buffer.read();	378✔
33
34	size_t avail = static_cast<size_t>(target.available());	366✔
35	if (avail <= 1)	366✔
36	return target.read();	102✔
37
38	_buffer.reloadFrom(target, avail);	264✔
39	return _buffer.read();	264✔
40	}
41
42	int peek(Stream &stream) {	96✔
43	return isEmpty() ? stream.peek() : _buffer.peek();	96✔
44	}
45
46	size_t readBytes(Stream &stream, char *buffer, size_t size) {	72✔
47	return doReadBytes(stream, buffer, size);	72✔
48	}
49
50	int read(Client &client, uint8_t *buffer, size_t size) {	×
51	return static_cast<int>(
52	doReadBytes(client, reinterpret_cast<char *>(buffer), size));	×
53	}
54
55	private:
56	bool isEmpty() const {	96✔
57	return _buffer.available() == 0;	96✔
58	}
59
60	LinearBuffer<TAllocator> _buffer;
61
62	template <typename TTarget> // Stream or Client
63	size_t doReadBytes(TTarget &target, char *buffer, size_t size) {	72✔
64	if (!_buffer)	72✔
65	return readOrReadBytes(target, buffer, size);	6✔
66
67	size_t result = 0;	66✔
68
69	// can we read from buffer?
70	if (_buffer.available() > 0) {	66✔
71	size_t bytesRead = _buffer.readBytes(buffer, size);	36✔
72	result += bytesRead;	36✔
73	buffer += bytesRead;	36✔
74	size -= bytesRead;	36✔
75	}
76
77	// still something to read?
78	if (size > 0) {	66✔
79	// (at this point, the buffer is empty)
80
81	size_t avail = static_cast<size_t>(target.available());	42✔
82
83	// should we use the buffer?
84	if (avail > size && size < _buffer.capacity()) {	42✔
85	_buffer.reloadFrom(target, avail);	18✔
86	size_t bytesRead = _buffer.readBytes(buffer, size);	18✔
87	result += bytesRead;	18✔
88	} else {
89	// we can bypass the buffer
90	result += readOrReadBytes(target, buffer, size);	24✔
91	}
92	}
93
94	return result;	66✔
95	}
96	}; // namespace StreamUtils
97
98	} // namespace StreamUtils

bblanchon / ArduinoStreamUtils / 9872110687

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous