9872110687

Committed 10 Jul 2024 09:58AM CUT 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

100.0

/src/StreamUtils/Clients/MemoryClient.hpp

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

#pragma once

#include <Client.h>

#include "../Buffers/CircularBuffer.hpp"
#include "../Configuration.hpp"
#include "../Ports/DefaultAllocator.hpp"
#include "../Streams/MemoryStream.hpp"

namespace StreamUtils {

template <typename TAllocator>
class BasicMemoryClient : public Client {
 public:
  BasicMemoryClient(size_t capacity, TAllocator allocator = TAllocator())
      : _stream(capacity, allocator), _connected(false) {}

  BasicMemoryClient(const BasicMemoryClient &src) : _stream(src._stream) {}

  // --- Print ---

  size_t write(uint8_t data) override {
    return _stream.write(data);
  }

  size_t write(const uint8_t *data, size_t size) override {
    return _stream.write(data, size);
  }

#if STREAMUTILS_PRINT_WRITE_VOID_UINT32
  size_t write(const void *data, uint32 size) override {
    return _stream.write(data, size);
  }
#endif

  // --- Stream ---

  int available() override {
    return _stream.available();
  }

  int peek() override {
    return _stream.peek();
  }

  int read() override {
    return _stream.read();
  }

#if STREAMUTILS_STREAM_READBYTES_IS_VIRTUAL
  size_t readBytes(char *data, size_t size) override {
    return _stream.readBytes(data, size);
  }
#endif

  void flush() override {
    _stream.flush();
  }

  // --- Client ---

  int connect(IPAddress, uint16_t) override {
    _connected = true;
    return 1;
  }

  int connect(const char *, uint16_t) override {
    _connected = true;
    return 1;
  }

  uint8_t connected() override {
    return _connected;
  }

  void stop() override {
    _connected = false;
  }

  operator bool() override {
    return true;
  }

  int read(uint8_t *buf, size_t size) override {
    return static_cast<int>(
        _stream.readBytes(reinterpret_cast<char *>(buf), size));
  }

 private:
  BasicMemoryStream<TAllocator> _stream;
  bool _connected;
};
using MemoryClient = BasicMemoryClient<DefaultAllocator>;

}  // namespace StreamUtils

1	// StreamUtils - github.com/bblanchon/ArduinoStreamUtils
2	// Copyright Benoit Blanchon 2019-2024
3	// MIT License
4
5	#pragma once
6
7	#include <Client.h>
8
9	#include "../Buffers/CircularBuffer.hpp"
10	#include "../Configuration.hpp"
11	#include "../Ports/DefaultAllocator.hpp"
12	#include "../Streams/MemoryStream.hpp"
13
14	namespace StreamUtils {
15
16	template <typename TAllocator>
17	class BasicMemoryClient : public Client {
18	public:
19	BasicMemoryClient(size_t capacity, TAllocator allocator = TAllocator())	1,260✔
20	: _stream(capacity, allocator), _connected(false) {}	1,260✔
21
22	BasicMemoryClient(const BasicMemoryClient &src) : _stream(src._stream) {}
23
24	// --- Print ---
25
26	size_t write(uint8_t data) override {	288✔
27	return _stream.write(data);	288✔
28	}
29
30	size_t write(const uint8_t *data, size_t size) override {	720✔
31	return _stream.write(data, size);	720✔
32	}
33
34	#if STREAMUTILS_PRINT_WRITE_VOID_UINT32
35	size_t write(const void *data, uint32 size) override {	144✔
36	return _stream.write(data, size);	144✔
37	}
38	#endif
39
40	// --- Stream ---
41
42	int available() override {	312✔
43	return _stream.available();	312✔
44	}
45
46	int peek() override {	120✔
47	return _stream.peek();	120✔
48	}
49
50	int read() override {	417✔
51	return _stream.read();	417✔
52	}
53
54	#if STREAMUTILS_STREAM_READBYTES_IS_VIRTUAL
55	size_t readBytes(char *data, size_t size) override {	36✔
56	return _stream.readBytes(data, size);	36✔
57	}
58	#endif
59
60	void flush() override {	192✔
61	_stream.flush();	192✔
62	}	192✔
63
64	// --- Client ---
65
66	int connect(IPAddress, uint16_t) override {	48✔
67	_connected = true;	48✔
68	return 1;	48✔
69	}
70
71	int connect(const char *, uint16_t) override {	48✔
72	_connected = true;	48✔
73	return 1;	48✔
74	}
75
76	uint8_t connected() override {	48✔
77	return _connected;	48✔
78	}
79
80	void stop() override {	48✔
81	_connected = false;	48✔
82	}	48✔
83
84	operator bool() override {	48✔
85	return true;	48✔
86	}
87
88	int read(uint8_t *buf, size_t size) override {	684✔
89	return static_cast<int>(
90	_stream.readBytes(reinterpret_cast<char *>(buf), size));	684✔
91	}
92
93	private:
94	BasicMemoryStream<TAllocator> _stream;
95	bool _connected;
96	};
97	using MemoryClient = BasicMemoryClient<DefaultAllocator>;
98
99	} // 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