IRSOL
C++ code implementing socket server for interacting with Baumer camera.
test_variants.cpp
Go to the documentation of this file.
1#include "irsol/protocol/message/assignment.hpp"
2#include "irsol/protocol/message/binary.hpp"
3#include "irsol/protocol/message/command.hpp"
4#include "irsol/protocol/message/error.hpp"
5#include "irsol/protocol/message/inquiry.hpp"
6#include "irsol/protocol/message/success.hpp"
7#include "irsol/protocol/message/variants.hpp"
8
9#include <catch2/catch_all.hpp>
10#include <memory>
11#include <string>
12#include <string_view>
13#include <utility>
14
15constexpr bool
16strings_equal(char const* a, char const* b)
17{
18 return std::string_view(a) == b;
19}
20
21TEST_CASE("InMessageKindToString()", "[Protocol][Protocol::Message]")
22{
23 {
24 auto [messageKind, expected] = GENERATE(
25 std::make_pair(irsol::protocol::InMessageKind::ASSIGNMENT, "ASSIGNMENT"),
26 std::make_pair(irsol::protocol::InMessageKind::INQUIRY, "INQUIRY"),
27 std::make_pair(irsol::protocol::InMessageKind::COMMAND, "COMMAND"));
28 CHECK(strings_equal(irsol::protocol::InMessageKindToString(messageKind), expected));
29 }
30 {
31 {
32 constexpr auto messageKind = irsol::protocol::InMessageKind::COMMAND;
33 STATIC_CHECK(strings_equal(irsol::protocol::InMessageKindToString(messageKind), "COMMAND"));
34 }
35 {
36 constexpr auto messageKind = irsol::protocol::InMessageKind::INQUIRY;
37 STATIC_CHECK(strings_equal(irsol::protocol::InMessageKindToString(messageKind), "INQUIRY"));
38 }
39 {
40 constexpr auto messageKind = irsol::protocol::InMessageKind::ASSIGNMENT;
41 STATIC_CHECK(
42 strings_equal(irsol::protocol::InMessageKindToString(messageKind), "ASSIGNMENT"));
43 }
44 }
45}
46
47TEST_CASE("OutMessageKindToString()", "[Protocol][Protocol::Message]")
48{
49 {
50 auto [messageKind, expected] = GENERATE(
51 std::make_pair(irsol::protocol::OutMessageKind::SUCCESS, "SUCCESS"),
52 std::make_pair(irsol::protocol::OutMessageKind::BINARY_BUFFER, "BINARY_BUFFER"),
53 std::make_pair(irsol::protocol::OutMessageKind::BW_IMAGE, "BW_IMAGE"),
54 std::make_pair(irsol::protocol::OutMessageKind::COLOR_IMAGE, "COLOR_IMAGE"),
55 std::make_pair(irsol::protocol::OutMessageKind::ERROR, "ERROR"));
56 CHECK(strings_equal(irsol::protocol::OutMessageKindToString(messageKind), expected));
57 }
58 {
59 {
60 constexpr auto messageKind = irsol::protocol::OutMessageKind::SUCCESS;
61 STATIC_CHECK(strings_equal(irsol::protocol::OutMessageKindToString(messageKind), "SUCCESS"));
62 }
63 {
64 constexpr auto messageKind = irsol::protocol::OutMessageKind::BINARY_BUFFER;
65 STATIC_CHECK(
66 strings_equal(irsol::protocol::OutMessageKindToString(messageKind), "BINARY_BUFFER"));
67 }
68 {
69 constexpr auto messageKind = irsol::protocol::OutMessageKind::BW_IMAGE;
70 STATIC_CHECK(strings_equal(irsol::protocol::OutMessageKindToString(messageKind), "BW_IMAGE"));
71 }
72 {
73 constexpr auto messageKind = irsol::protocol::OutMessageKind::COLOR_IMAGE;
74 STATIC_CHECK(
75 strings_equal(irsol::protocol::OutMessageKindToString(messageKind), "COLOR_IMAGE"));
76 }
77 {
78 constexpr auto messageKind = irsol::protocol::OutMessageKind::ERROR;
79 STATIC_CHECK(strings_equal(irsol::protocol::OutMessageKindToString(messageKind), "ERROR"));
80 }
81 }
82}
83
84TEST_CASE("getInMessageKind<direct>()", "[Protocol][Protocol::Message]")
85{
86 {
87 auto m = irsol::protocol::Assignment{"x", 42};
88 STATIC_CHECK(
89 irsol::protocol::getInMessageKind(m) == irsol::protocol::InMessageKind::ASSIGNMENT);
90 }
91 {
92 auto m = irsol::protocol::Inquiry{"x"};
93 STATIC_CHECK(irsol::protocol::getInMessageKind(m) == irsol::protocol::InMessageKind::INQUIRY);
94 }
95 {
96 auto m = irsol::protocol::Command{"x"};
97 STATIC_CHECK(irsol::protocol::getInMessageKind(m) == irsol::protocol::InMessageKind::COMMAND);
98 }
99}
100
101TEST_CASE("getInMessageKind<variant>()", "[Protocol][Protocol::Message]")
102{
103 {
104 auto m = irsol::protocol::InMessage(irsol::protocol::Assignment{"x", 42});
105 CHECK(irsol::protocol::getInMessageKind(m) == irsol::protocol::InMessageKind::ASSIGNMENT);
106 }
107 {
108 auto m = irsol::protocol::InMessage(irsol::protocol::Inquiry{"x"});
109 CHECK(irsol::protocol::getInMessageKind(m) == irsol::protocol::InMessageKind::INQUIRY);
110 }
111 {
112 auto m = irsol::protocol::InMessage(irsol::protocol::Command{"x"});
113 CHECK(irsol::protocol::getInMessageKind(m) == irsol::protocol::InMessageKind::COMMAND);
114 }
115}
116
117TEST_CASE("isAssignment<direct>()", "[Protocol][Protocol::Message]")
118{
119 {
120 auto m = irsol::protocol::Assignment{"x", 42};
121 STATIC_CHECK(irsol::protocol::isAssignment(m));
122 }
123 {
124 auto m = irsol::protocol::Inquiry{"x"};
125 STATIC_CHECK_FALSE(irsol::protocol::isAssignment(m));
126 }
127 {
128 auto m = irsol::protocol::Command{"x"};
129 STATIC_CHECK_FALSE(irsol::protocol::isAssignment(m));
130 }
131}
132
133TEST_CASE("isAssignment<variant>()", "[Protocol][Protocol::Message]")
134{
135 {
136 auto m = irsol::protocol::InMessage(irsol::protocol::Assignment{"x", 42});
137 CHECK(irsol::protocol::isAssignment(m));
138 }
139 {
140 auto m = irsol::protocol::InMessage(irsol::protocol::Inquiry{"x"});
141 CHECK_FALSE(irsol::protocol::isAssignment(m));
142 }
143 {
144 auto m = irsol::protocol::InMessage(irsol::protocol::Command{"x"});
145 CHECK_FALSE(irsol::protocol::isAssignment(m));
146 }
147}
148
149TEST_CASE("isInquiry<direct>()", "[Protocol][Protocol::Message]")
150{
151 {
152 auto m = irsol::protocol::Inquiry{"x"};
153 STATIC_CHECK(irsol::protocol::isInquiry(m));
154 }
155 {
156 auto m = irsol::protocol::Assignment{"x", 42};
157 STATIC_CHECK_FALSE(irsol::protocol::isInquiry(m));
158 }
159 {
160 auto m = irsol::protocol::Command{"x"};
161 STATIC_CHECK_FALSE(irsol::protocol::isInquiry(m));
162 }
163}
164
165TEST_CASE("isInquiry<variant>()", "[Protocol][Protocol::Message]")
166{
167 {
168 auto m = irsol::protocol::InMessage(irsol::protocol::Inquiry{"x"});
169 CHECK(irsol::protocol::isInquiry(m));
170 }
171 {
172 auto m = irsol::protocol::InMessage(irsol::protocol::Assignment{"x", 42});
173 CHECK_FALSE(irsol::protocol::isInquiry(m));
174 }
175 {
176 auto m = irsol::protocol::InMessage(irsol::protocol::Command{"x"});
177 CHECK_FALSE(irsol::protocol::isInquiry(m));
178 }
179}
180
181TEST_CASE("isCommand<direct>()", "[Protocol][Protocol::Message]")
182{
183 {
184 auto m = irsol::protocol::Command{"x"};
185 STATIC_CHECK(irsol::protocol::isCommand(m));
186 }
187 {
188 auto m = irsol::protocol::Inquiry{"x"};
189 STATIC_CHECK_FALSE(irsol::protocol::isCommand(m));
190 }
191 {
192 auto m = irsol::protocol::Assignment{"x", 42};
193 STATIC_CHECK_FALSE(irsol::protocol::isCommand(m));
194 }
195}
196
197TEST_CASE("isCommand<variant>()", "[Protocol][Protocol::Message]")
198{
199 {
200 auto m = irsol::protocol::InMessage(irsol::protocol::Command{"x"});
201 CHECK(irsol::protocol::isCommand(m));
202 }
203 {
204 auto m = irsol::protocol::InMessage(irsol::protocol::Inquiry{"x"});
205 CHECK_FALSE(irsol::protocol::isCommand(m));
206 }
207 {
208 auto m = irsol::protocol::InMessage(irsol::protocol::Assignment{"x", 42});
209 CHECK_FALSE(irsol::protocol::isCommand(m));
210 }
211}
212TEST_CASE("getOutMessageKind<direct>()", "[Protocol][Protocol::Message]")
213{
214 {
215 auto m = irsol::protocol::Success::from(irsol::protocol::Command{"x"});
216 STATIC_CHECK(irsol::protocol::getOutMessageKind(m) == irsol::protocol::OutMessageKind::SUCCESS);
217 }
218 {
219 std::vector<irsol::types::byte_t> data(
220 10 * irsol::protocol::BinaryDataBuffer::BYTES_PER_ELEMENT);
221 auto m = irsol::protocol::BinaryDataBuffer{std::move(data), {10}};
222 STATIC_CHECK(
223 irsol::protocol::getOutMessageKind(m) == irsol::protocol::OutMessageKind::BINARY_BUFFER);
224 }
225 {
226 std::vector<irsol::types::byte_t> data(
227 160 * irsol::protocol::ImageBinaryData::BYTES_PER_ELEMENT);
228 auto m = irsol::protocol::ImageBinaryData{std::move(data), {10, 16}};
229 STATIC_CHECK(
230 irsol::protocol::getOutMessageKind(m) == irsol::protocol::OutMessageKind::BW_IMAGE);
231 }
232 {
233 std::vector<irsol::types::byte_t> data(
234 480 * irsol::protocol::ColorImageBinaryData::BYTES_PER_ELEMENT);
235 auto m = irsol::protocol::ColorImageBinaryData{std::move(data), {10, 16, 3}};
236 STATIC_CHECK(
237 irsol::protocol::getOutMessageKind(m) == irsol::protocol::OutMessageKind::COLOR_IMAGE);
238 }
239 {
240 auto m = irsol::protocol::Error::from(irsol::protocol::Command{"x"}, "error message");
241 STATIC_CHECK(irsol::protocol::getOutMessageKind(m) == irsol::protocol::OutMessageKind::ERROR);
242 }
243}
244TEST_CASE("getOutMessageKind<variant>()", "[Protocol][Protocol::Message]")
245{
246 {
247 auto m = irsol::protocol::Success::from(irsol::protocol::Command{"x"});
248 auto mVariant = irsol::protocol::OutMessage(std::move(m));
249 CHECK(irsol::protocol::getOutMessageKind(mVariant) == irsol::protocol::OutMessageKind::SUCCESS);
250 }
251 {
252 std::vector<irsol::types::byte_t> data(
253 10 * irsol::protocol::BinaryDataBuffer::BYTES_PER_ELEMENT);
254 auto m = irsol::protocol::BinaryDataBuffer{std::move(data), {10}};
255 auto mVariant = irsol::protocol::OutMessage{std::move(m)};
256 CHECK(
257 irsol::protocol::getOutMessageKind(mVariant) ==
258 irsol::protocol::OutMessageKind::BINARY_BUFFER);
259 }
260 {
261 std::vector<irsol::types::byte_t> data(
262 160 * irsol::protocol::ImageBinaryData::BYTES_PER_ELEMENT);
263 auto m = irsol::protocol::ImageBinaryData{std::move(data), {10, 16}};
264 auto mVariant = irsol::protocol::OutMessage{std::move(m)};
265 CHECK(
266 irsol::protocol::getOutMessageKind(mVariant) == irsol::protocol::OutMessageKind::BW_IMAGE);
267 }
268 {
269 std::vector<irsol::types::byte_t> data(
270 480 * irsol::protocol::ColorImageBinaryData::BYTES_PER_ELEMENT);
271 auto m = irsol::protocol::ColorImageBinaryData{std::move(data), {10, 16, 3}};
272 auto mVariant = irsol::protocol::OutMessage{std::move(m)};
273 CHECK(
274 irsol::protocol::getOutMessageKind(mVariant) == irsol::protocol::OutMessageKind::COLOR_IMAGE);
275 }
276 {
277 auto m = irsol::protocol::Error::from(irsol::protocol::Command{"x"}, "error message");
278 auto mVariant = irsol::protocol::OutMessage(std::move(m));
279 CHECK(irsol::protocol::getOutMessageKind(mVariant) == irsol::protocol::OutMessageKind::ERROR);
280 }
281}
282
283TEST_CASE("isSuccess<direct>()", "[Protocol][Protocol::Message]")
284{
285 {
286 auto m = irsol::protocol::Success::from(irsol::protocol::Command{"x"});
287 STATIC_CHECK(irsol::protocol::isSuccess(m));
288 }
289 {
290 auto m = irsol::protocol::BinaryDataBuffer{{}, {}};
291 STATIC_CHECK_FALSE(irsol::protocol::isSuccess(m));
292 }
293 {
294 auto m = irsol::protocol::ImageBinaryData{{}, {}};
295 STATIC_CHECK_FALSE(irsol::protocol::isSuccess(m));
296 }
297 {
298 auto m = irsol::protocol::ColorImageBinaryData{{}, {}};
299 STATIC_CHECK_FALSE(irsol::protocol::isSuccess(m));
300 }
301 {
302 auto m = irsol::protocol::Error::from(irsol::protocol::Command{"x"}, "error message");
303 STATIC_CHECK_FALSE(irsol::protocol::isSuccess(m));
304 }
305}
306TEST_CASE("isSuccess<variant>()", "[Protocol][Protocol::Message]")
307{
308 {
309 auto m =
310 irsol::protocol::OutMessage(irsol::protocol::Success::from(irsol::protocol::Command{"x"}));
311 CHECK(irsol::protocol::isSuccess(m));
312 }
313 {
314 auto m = irsol::protocol::OutMessage(irsol::protocol::BinaryDataBuffer{{}, {}});
315 CHECK_FALSE(irsol::protocol::isSuccess(m));
316 }
317 {
318 auto m = irsol::protocol::OutMessage(irsol::protocol::ImageBinaryData{{}, {}});
319 CHECK_FALSE(irsol::protocol::isSuccess(m));
320 }
321 {
322 auto m = irsol::protocol::OutMessage(irsol::protocol::ColorImageBinaryData{{}, {}});
323 CHECK_FALSE(irsol::protocol::isSuccess(m));
324 }
325 {
326 auto m = irsol::protocol::OutMessage(
327 irsol::protocol::Error::from(irsol::protocol::Command{"x"}, "error message"));
328 CHECK_FALSE(irsol::protocol::isSuccess(m));
329 }
330}
331
332TEST_CASE("isBinaryDataBuffer<direct>()", "[Protocol][Protocol::Message]")
333{
334 {
335 auto m = irsol::protocol::BinaryDataBuffer{{}, {}};
336 STATIC_CHECK(irsol::protocol::isBinaryDataBuffer(m));
337 }
338 {
339 auto m = irsol::protocol::Success::from(irsol::protocol::Command{"x"});
340 STATIC_CHECK_FALSE(irsol::protocol::isBinaryDataBuffer(m));
341 }
342 {
343 auto m = irsol::protocol::ImageBinaryData{{}, {}};
344 STATIC_CHECK_FALSE(irsol::protocol::isBinaryDataBuffer(m));
345 }
346 {
347 auto m = irsol::protocol::ColorImageBinaryData{{}, {}};
348 STATIC_CHECK_FALSE(irsol::protocol::isBinaryDataBuffer(m));
349 }
350 {
351 auto m = irsol::protocol::Error::from(irsol::protocol::Command{"x"}, "error message");
352 STATIC_CHECK_FALSE(irsol::protocol::isBinaryDataBuffer(m));
353 }
354}
355
356TEST_CASE("isBinaryDataBuffer<variant>()", "[Protocol][Protocol::Message]")
357{
358 {
359 auto m = irsol::protocol::OutMessage(irsol::protocol::BinaryDataBuffer{{}, {}});
360 CHECK(irsol::protocol::isBinaryDataBuffer(m));
361 }
362 {
363 auto m =
364 irsol::protocol::OutMessage(irsol::protocol::Success::from(irsol::protocol::Command{"x"}));
365 CHECK_FALSE(irsol::protocol::isBinaryDataBuffer(m));
366 }
367 {
368 auto m = irsol::protocol::OutMessage(irsol::protocol::ImageBinaryData{{}, {}});
369 CHECK_FALSE(irsol::protocol::isBinaryDataBuffer(m));
370 }
371 {
372 auto m = irsol::protocol::OutMessage(irsol::protocol::ColorImageBinaryData{{}, {}});
373 CHECK_FALSE(irsol::protocol::isBinaryDataBuffer(m));
374 }
375 {
376 auto m = irsol::protocol::OutMessage(
377 irsol::protocol::Error::from(irsol::protocol::Command{"x"}, "error message"));
378 CHECK_FALSE(irsol::protocol::isBinaryDataBuffer(m));
379 }
380}
381
382TEST_CASE("isImageBinaryData<direct>()", "[Protocol][Protocol::Message]")
383{
384 {
385 auto m = irsol::protocol::ImageBinaryData{{}, {}};
386 STATIC_CHECK(irsol::protocol::isImageBinaryData(m));
387 }
388 {
389 auto m = irsol::protocol::Success::from(irsol::protocol::Command{"x"});
390 STATIC_CHECK_FALSE(irsol::protocol::isImageBinaryData(m));
391 }
392 {
393 auto m = irsol::protocol::BinaryDataBuffer{{}, {}};
394 STATIC_CHECK_FALSE(irsol::protocol::isImageBinaryData(m));
395 }
396 {
397 auto m = irsol::protocol::ColorImageBinaryData{{}, {}};
398 STATIC_CHECK_FALSE(irsol::protocol::isImageBinaryData(m));
399 }
400 {
401 auto m = irsol::protocol::Error::from(irsol::protocol::Command{"x"}, "error message");
402 STATIC_CHECK_FALSE(irsol::protocol::isImageBinaryData(m));
403 }
404}
405
406TEST_CASE("isImageBinaryData<variant>()", "[Protocol][Protocol::Message]")
407{
408 {
409 auto m = irsol::protocol::OutMessage(irsol::protocol::ImageBinaryData{{}, {}});
410 CHECK(irsol::protocol::isImageBinaryData(m));
411 }
412 {
413 auto m =
414 irsol::protocol::OutMessage(irsol::protocol::Success::from(irsol::protocol::Command{"x"}));
415 CHECK_FALSE(irsol::protocol::isImageBinaryData(m));
416 }
417 {
418 auto m = irsol::protocol::OutMessage(irsol::protocol::BinaryDataBuffer{{}, {}});
419 CHECK_FALSE(irsol::protocol::isImageBinaryData(m));
420 }
421 {
422 auto m = irsol::protocol::OutMessage(irsol::protocol::ColorImageBinaryData{{}, {}});
423 CHECK_FALSE(irsol::protocol::isImageBinaryData(m));
424 }
425 {
426 auto m = irsol::protocol::OutMessage(
427 irsol::protocol::Error::from(irsol::protocol::Command{"x"}, "error message"));
428 CHECK_FALSE(irsol::protocol::isImageBinaryData(m));
429 }
430}
431
432TEST_CASE("isColorImageBinaryData<direct>()", "[Protocol][Protocol::Message]")
433{
434 {
435 auto m = irsol::protocol::ColorImageBinaryData{{}, {}};
436 STATIC_CHECK(irsol::protocol::isColorImageBinaryData(m));
437 }
438 {
439 auto m = irsol::protocol::Success::from(irsol::protocol::Command{"x"});
440 STATIC_CHECK_FALSE(irsol::protocol::isColorImageBinaryData(m));
441 }
442 {
443 auto m = irsol::protocol::BinaryDataBuffer{{}, {}};
444 STATIC_CHECK_FALSE(irsol::protocol::isColorImageBinaryData(m));
445 }
446 {
447 auto m = irsol::protocol::ImageBinaryData{{}, {}};
448 STATIC_CHECK_FALSE(irsol::protocol::isColorImageBinaryData(m));
449 }
450 {
451 auto m = irsol::protocol::Error::from(irsol::protocol::Command{"x"}, "error message");
452 STATIC_CHECK_FALSE(irsol::protocol::isColorImageBinaryData(m));
453 }
454}
455
456TEST_CASE("isColorImageBinaryData<variant>()", "[Protocol][Protocol::Message]")
457{
458 {
459 auto m = irsol::protocol::OutMessage(irsol::protocol::ColorImageBinaryData{{}, {}});
460 CHECK(irsol::protocol::isColorImageBinaryData(m));
461 }
462 {
463 auto m =
464 irsol::protocol::OutMessage(irsol::protocol::Success::from(irsol::protocol::Command{"x"}));
465 CHECK_FALSE(irsol::protocol::isColorImageBinaryData(m));
466 }
467 {
468 auto m = irsol::protocol::OutMessage(irsol::protocol::BinaryDataBuffer{{}, {}});
469 CHECK_FALSE(irsol::protocol::isColorImageBinaryData(m));
470 }
471 {
472 auto m = irsol::protocol::OutMessage(irsol::protocol::ImageBinaryData{{}, {}});
473 CHECK_FALSE(irsol::protocol::isColorImageBinaryData(m));
474 }
475 {
476 auto m = irsol::protocol::OutMessage(
477 irsol::protocol::Error::from(irsol::protocol::Command{"x"}, "error message"));
478 CHECK_FALSE(irsol::protocol::isColorImageBinaryData(m));
479 }
480}
481
482TEST_CASE("isError<direct>()", "[Protocol][Protocol::Message]")
483{
484 {
485 auto m = irsol::protocol::Error::from(irsol::protocol::Command{"x"}, "error message");
486 STATIC_CHECK(irsol::protocol::isError(m));
487 }
488 {
489 auto m = irsol::protocol::Success::from(irsol::protocol::Command{"x"});
490 STATIC_CHECK_FALSE(irsol::protocol::isError(m));
491 }
492 {
493 auto m = irsol::protocol::BinaryDataBuffer{{}, {}};
494 STATIC_CHECK_FALSE(irsol::protocol::isError(m));
495 }
496 {
497 auto m = irsol::protocol::ImageBinaryData{{}, {}};
498 STATIC_CHECK_FALSE(irsol::protocol::isError(m));
499 }
500 {
501 auto m = irsol::protocol::ColorImageBinaryData{{}, {}};
502 STATIC_CHECK_FALSE(irsol::protocol::isError(m));
503 }
504}
505
506TEST_CASE("isError<variant>()", "[Protocol][Protocol::Message]")
507{
508 {
509 auto m = irsol::protocol::OutMessage(
510 irsol::protocol::Error::from(irsol::protocol::Command{"x"}, "error message"));
511 CHECK(irsol::protocol::isError(m));
512 }
513 {
514 auto m =
515 irsol::protocol::OutMessage(irsol::protocol::Success::from(irsol::protocol::Command{"x"}));
516 CHECK_FALSE(irsol::protocol::isError(m));
517 }
518 {
519 auto m = irsol::protocol::OutMessage(irsol::protocol::BinaryDataBuffer{{}, {}});
520 CHECK_FALSE(irsol::protocol::isError(m));
521 }
522 {
523 auto m = irsol::protocol::OutMessage(irsol::protocol::ImageBinaryData{{}, {}});
524 CHECK_FALSE(irsol::protocol::isError(m));
525 }
526 {
527 auto m = irsol::protocol::OutMessage(irsol::protocol::ColorImageBinaryData{{}, {}});
528 CHECK_FALSE(irsol::protocol::isError(m));
529 }
530}
assignment.hpp
Protocol assignment operation representation.
binary.hpp
Protocol binary data types and attributes definitions.
command.hpp
Protocol command representation.
error.hpp
Protocol error message representation.
irsol::protocol::isError
constexpr bool isError(IRSOL_MAYBE_UNUSED T &msg)
Checks if a given outgoing message type is Error.
Definition variants.hpp:347
irsol::protocol::InMessage
std::variant< Assignment, Inquiry, Command > InMessage
Variant type representing any incoming message.
Definition variants.hpp:86
irsol::protocol::getOutMessageKind
constexpr OutMessageKind getOutMessageKind(IRSOL_MAYBE_UNUSED const T &msg)
Returns the OutMessageKind enum value corresponding to a given outgoing message type.
Definition variants.hpp:254
irsol::protocol::isCommand
constexpr bool isCommand(IRSOL_MAYBE_UNUSED T &msg)
Checks if a given incoming message type is a Command.
Definition variants.hpp:237
irsol::protocol::OutMessageKindToString
constexpr const char * OutMessageKindToString(OutMessageKind kind)
Converts an OutMessageKind enum to a human-readable string.
Definition variants.hpp:116
irsol::protocol::isSuccess
constexpr bool isSuccess(IRSOL_MAYBE_UNUSED T &msg)
Checks if a given outgoing message type is Success.
Definition variants.hpp:287
irsol::protocol::isColorImageBinaryData
constexpr bool isColorImageBinaryData(IRSOL_MAYBE_UNUSED T &msg)
Checks if a given outgoing message type is ColorImageBinaryData.
Definition variants.hpp:332
irsol::protocol::isInquiry
constexpr bool isInquiry(IRSOL_MAYBE_UNUSED T &msg)
Checks if a given incoming message type is an Inquiry.
Definition variants.hpp:222
irsol::protocol::isBinaryDataBuffer
constexpr bool isBinaryDataBuffer(IRSOL_MAYBE_UNUSED T &msg)
Checks if a given outgoing message type is BinaryDataBuffer.
Definition variants.hpp:302
irsol::protocol::isAssignment
constexpr bool isAssignment(IRSOL_MAYBE_UNUSED T &msg)
Checks if a given incoming message type is an Assignment.
Definition variants.hpp:207
irsol::protocol::isImageBinaryData
constexpr bool isImageBinaryData(IRSOL_MAYBE_UNUSED T &msg)
Checks if a given outgoing message type is ImageBinaryData (black & white).
Definition variants.hpp:317
irsol::protocol::InMessageKindToString
constexpr const char * InMessageKindToString(InMessageKind kind)
Converts an InMessageKind enum to a human-readable string.
Definition variants.hpp:59
irsol::protocol::OutMessage
std::variant< Success, BinaryDataBuffer, ImageBinaryData, ColorImageBinaryData, Error > OutMessage
Variant type representing any outgoing message.
Definition variants.hpp:149
irsol::protocol::getInMessageKind
constexpr InMessageKind getInMessageKind(IRSOL_MAYBE_UNUSED const T &msg)
Returns the InMessageKind enum value corresponding to a given incoming message type.
Definition variants.hpp:178
irsol::protocol::OutMessageKind::BINARY_BUFFER
@ BINARY_BUFFER
irsol::protocol::OutMessageKind::BW_IMAGE
@ BW_IMAGE
irsol::protocol::OutMessageKind::COLOR_IMAGE
@ COLOR_IMAGE
irsol::protocol::OutMessageKind::ERROR
@ ERROR
irsol::protocol::OutMessageKind::SUCCESS
@ SUCCESS
irsol::protocol::InMessageKind::COMMAND
@ COMMAND
irsol::protocol::InMessageKind::ASSIGNMENT
@ ASSIGNMENT
irsol::protocol::InMessageKind::INQUIRY
@ INQUIRY
inquiry.hpp
Protocol inquiry representation.
irsol::protocol::Assignment
Represents an assignment operation in the protocol.
Definition assignment.hpp:32
irsol::protocol::Command
Represents a command invocation in the protocol.
Definition command.hpp:33
irsol::protocol::Error::from
static Error from(const T &msg, const std::string &description)
Creates an error from a specific incoming message type.
Definition error.hpp:63
irsol::protocol::Inquiry
Represents a value inquiry in the protocol.
Definition inquiry.hpp:32
irsol::protocol::Success::from
static Success from(const Assignment &msg, std::optional< irsol::types::protocol_value_t > overrideValue=std::nullopt)
Creates a success message from an Assignment.
Definition success.hpp:75
irsol::protocol::internal::BinaryData
Represents a binary data object within the protocol.
Definition binary.hpp:107
irsol::protocol::internal::BinaryData::BYTES_PER_ELEMENT
static constexpr uint8_t BYTES_PER_ELEMENT
Number of bytes per element.
Definition binary.hpp:112
success.hpp
Protocol success message representation.
CHECK
CHECK(m.identifier==identifier)
CHECK_FALSE
CHECK_FALSE(m.hasDouble())
m
irsol::protocol::Assignment m(identifier, value)
Definition test_assignment.cpp:33
STATIC_CHECK
STATIC_CHECK(m.DIM==1)
TEST_CASE
TEST_CASE("Pixel<T>::max())", "[PixelFormat]")
Definition test_pixel_format.cpp:6
expected
std::vector< std::string > expected
Definition test_utils.cpp:44
strings_equal
constexpr bool strings_equal(char const *a, char const *b)
Definition test_variants.cpp:16
variants.hpp
Definitions and utilities for incoming and outgoing protocol messages.