YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
FakeTestMsgs.cpp
Go to the documentation of this file.
1/*
2 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
3 * SPDX-License-Identifier: BSD-3-Clause
4 */
5
6// Autogenerated by Thrift Compiler (0.14.1-yarped)
7//
8// This is an automatically generated file.
9// It could get re-generated if the ALLOW_IDL_GENERATION flag is on.
10
11#include <yarp/conf/version.h>
12#include <FakeTestMsgs.h>
14#include <yarp/os/LogStream.h>
15
17
18#include <algorithm>
19
20namespace
21{
22 YARP_LOG_COMPONENT(SERVICE_LOG_COMPONENT, "FakeTestMsgs")
23}
24
25//FakeTestMsgs_getRemoteProtocolVersion_helper declaration
36
38{
39 yarp::os::idl::WireWriter writer(connection);
40 if (!writer.writeListHeader(1)) {
41 return false;
42 }
43 if (!writer.writeString("getRemoteProtocolVersion")) {
44 return false;
45 }
46 return true;
47}
48
49bool FakeTestMsgs_getRemoteProtocolVersion_helper ::read(yarp::os::ConnectionReader & connection)
50 {
51 yarp::os::idl::WireReader reader(connection);
52 if (!reader.readListHeader()) {
53 reader.fail();
54 return false;
55 }
56
57 if (!helper_proto.read(connection)) {
58 reader.fail();
59 return false;
60 }
61 return true;
62}
63
64//ProtocolVersion, client side
66 {
67 if(!yarp().canWrite()) {
68 yError(" Missing server method FakeTestMsgs::getRemoteProtocolVersion");
69 }
71 bool ok = yarp().write(helper, helper);
72 if (ok) {
73 return helper.helper_proto;}
74 else {
76 return failureproto;}
77}
78
79//ProtocolVersion, client side
81 {
82 auto locproto = this->getLocalProtocolVersion();
83 auto remproto = this->getRemoteProtocolVersion();
84 if (remproto.protocol_version != locproto.protocol_version)
85 {
86 yCError(SERVICE_LOG_COMPONENT) << "Invalid communication protocol.";
87 yCError(SERVICE_LOG_COMPONENT) << "Local Protocol Version: " << locproto.toString();
88 yCError(SERVICE_LOG_COMPONENT) << "Remote Protocol Version: " << remproto.toString();
89 return false;
90 }
91 return true;
92}
93
94//ProtocolVersion, server side
104
105// doSomethingRPC helper class declaration
107 public yarp::os::Portable
108{
109public:
111 bool write(yarp::os::ConnectionWriter& connection) const override;
112 bool read(yarp::os::ConnectionReader& connection) override;
113
114 class Command :
116 {
117 public:
118 Command() = default;
119 ~Command() override = default;
120
121 bool write(yarp::os::ConnectionWriter& connection) const override;
122 bool read(yarp::os::ConnectionReader& connection) override;
123
124 bool write(const yarp::os::idl::WireWriter& writer) const override;
125 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
126 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
127
128 bool read(yarp::os::idl::WireReader& reader) override;
131 };
132
133 class Reply :
135 {
136 public:
137 Reply() = default;
138 ~Reply() override = default;
139
140 bool write(yarp::os::ConnectionWriter& connection) const override;
141 bool read(yarp::os::ConnectionReader& connection) override;
142
143 bool write(const yarp::os::idl::WireWriter& writer) const override;
144 bool read(yarp::os::idl::WireReader& reader) override;
145
147 };
148
150 void call(FakeTestMsgs* ptr);
151
154
155 static constexpr const char* s_tag{"doSomethingRPC"};
156 static constexpr size_t s_tag_len{1};
157 static constexpr size_t s_cmd_len{1};
158 static constexpr size_t s_reply_len{1};
159 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FakeTestMsgs::doSomethingRPC()"};
160 static constexpr const char* s_help{""};
161};
162
163// doSomethingUnimplementedRPC helper class declaration
165 public yarp::os::Portable
166{
167public:
169 bool write(yarp::os::ConnectionWriter& connection) const override;
170 bool read(yarp::os::ConnectionReader& connection) override;
171
172 class Command :
174 {
175 public:
176 Command() = default;
177 ~Command() override = default;
178
179 bool write(yarp::os::ConnectionWriter& connection) const override;
180 bool read(yarp::os::ConnectionReader& connection) override;
181
182 bool write(const yarp::os::idl::WireWriter& writer) const override;
183 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
184 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
185
186 bool read(yarp::os::idl::WireReader& reader) override;
189 };
190
191 class Reply :
193 {
194 public:
195 Reply() = default;
196 ~Reply() override = default;
197
198 bool write(yarp::os::ConnectionWriter& connection) const override;
199 bool read(yarp::os::ConnectionReader& connection) override;
200
201 bool write(const yarp::os::idl::WireWriter& writer) const override;
202 bool read(yarp::os::idl::WireReader& reader) override;
203
205 };
206
208 void call(FakeTestMsgs* ptr);
209
212
213 static constexpr const char* s_tag{"doSomethingUnimplementedRPC"};
214 static constexpr size_t s_tag_len{1};
215 static constexpr size_t s_cmd_len{1};
216 static constexpr size_t s_reply_len{1};
217 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FakeTestMsgs::doSomethingUnimplementedRPC()"};
218 static constexpr const char* s_help{""};
219};
220
221// doSomethingRPC helper class implementation
223{
224 return cmd.write(connection);
225}
226
228{
229 return reply.read(connection);
230}
231
233{
234 yarp::os::idl::WireWriter writer(connection);
235 if (!writer.writeListHeader(s_cmd_len)) {
236 return false;
237 }
238 return write(writer);
239}
240
242{
243 yarp::os::idl::WireReader reader(connection);
244 if (!reader.readListHeader()) {
245 reader.fail();
246 return false;
247 }
248 return read(reader);
249}
250
252{
253 if (!writeTag(writer)) {
254 return false;
255 }
256 if (!writeArgs(writer)) {
257 return false;
258 }
259 return true;
260}
261
263{
264 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
265 return false;
266 }
267 return true;
268}
269
271{
272 return true;
273}
274
276{
277 if (!readTag(reader)) {
278 return false;
279 }
280 if (!readArgs(reader)) {
281 return false;
282 }
283 return true;
284}
285
287{
288 std::string tag = reader.readTag(s_tag_len);
289 if (reader.isError()) {
290 return false;
291 }
292 if (tag != s_tag) {
293 reader.fail();
294 return false;
295 }
296 return true;
297}
298
300{
301 if (!reader.noMore()) {
302 reader.fail();
303 return false;
304 }
305 return true;
306}
307
309{
310 yarp::os::idl::WireWriter writer(connection);
311 return write(writer);
312}
313
315{
316 yarp::os::idl::WireReader reader(connection);
317 return read(reader);
318}
319
321{
322 if (!writer.isNull()) {
323 if (!writer.write(return_helper)) {
324 return false;
325 }
326 }
327 return true;
328}
329
331{
332 if (reader.noMore()) {
333 reader.fail();
334 return false;
335 }
336 if (!reader.read(return_helper)) {
337 reader.fail();
338 return false;
339 }
340 return true;
341}
342
347
348// doSomethingUnimplementedRPC helper class implementation
350{
351 return cmd.write(connection);
352}
353
358
360{
361 yarp::os::idl::WireWriter writer(connection);
362 if (!writer.writeListHeader(s_cmd_len)) {
363 return false;
364 }
365 return write(writer);
366}
367
369{
370 yarp::os::idl::WireReader reader(connection);
371 if (!reader.readListHeader()) {
372 reader.fail();
373 return false;
374 }
375 return read(reader);
376}
377
379{
380 if (!writeTag(writer)) {
381 return false;
382 }
383 if (!writeArgs(writer)) {
384 return false;
385 }
386 return true;
387}
388
390{
391 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
392 return false;
393 }
394 return true;
395}
396
398{
399 return true;
400}
401
403{
404 if (!readTag(reader)) {
405 return false;
406 }
407 if (!readArgs(reader)) {
408 return false;
409 }
410 return true;
411}
412
414{
415 std::string tag = reader.readTag(s_tag_len);
416 if (reader.isError()) {
417 return false;
418 }
419 if (tag != s_tag) {
420 reader.fail();
421 return false;
422 }
423 return true;
424}
425
427{
428 if (!reader.noMore()) {
429 reader.fail();
430 return false;
431 }
432 return true;
433}
434
436{
437 yarp::os::idl::WireWriter writer(connection);
438 return write(writer);
439}
440
446
448{
449 if (!writer.isNull()) {
450 if (!writer.write(return_helper)) {
451 return false;
452 }
453 }
454 return true;
455}
456
458{
459 if (reader.noMore()) {
460 reader.fail();
461 return false;
462 }
463 if (!reader.read(return_helper)) {
464 reader.fail();
465 return false;
466 }
467 return true;
468}
469
474
475// Constructor
477{
478 yarp().setOwner(*this);
479}
480
482{
483 if (!yarp().canWrite()) {
484 yError("Missing server method '%s'?", FakeTestMsgs_doSomethingRPC_helper::s_prototype);
485 }
487 bool ok = yarp().write(helper, helper);
488 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
489}
490
492{
493 if (!yarp().canWrite()) {
495 }
497 bool ok = yarp().write(helper, helper);
498 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
499}
500
501// help method
502std::vector<std::string> FakeTestMsgs::help(const std::string& functionName)
503{
504 bool showAll = (functionName == "--all");
505 std::vector<std::string> helpString;
506 if (showAll) {
507 helpString.emplace_back("*** Available commands:");
508 helpString.emplace_back(FakeTestMsgs_doSomethingRPC_helper::s_tag);
510 helpString.emplace_back("help");
511 } else {
512 if (functionName == FakeTestMsgs_doSomethingRPC_helper::s_tag) {
514 }
517 }
518 if (functionName == "help") {
519 helpString.emplace_back("std::vector<std::string> help(const std::string& functionName = \"--all\")");
520 helpString.emplace_back("Return list of available commands, or help message for a specific function");
521 helpString.emplace_back("@param functionName name of command for which to get a detailed description. If none or '--all' is provided, print list of available commands");
522 helpString.emplace_back("@return list of strings (one string per line)");
523 }
524 }
525 if (helpString.empty()) {
526 helpString.emplace_back("Command not found");
527 }
528 return helpString;
529}
530
531// read from ConnectionReader
533{
534 constexpr size_t max_tag_len = 1;
535 size_t tag_len = 1;
536
537 yarp::os::idl::WireReader reader(connection);
538 reader.expectAccept();
539 if (!reader.readListHeader()) {
540 reader.fail();
541 return false;
542 }
543
544 std::string tag = reader.readTag(1);
545 bool direct = (tag == "__direct__");
546 if (direct) {
547 tag = reader.readTag(1);
548 }
549 while (tag_len <= max_tag_len && !reader.isError()) {
550 if(tag == "getRemoteProtocolVersion") {
551 if (!reader.noMore()) {
552 yError("Reader invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
553 reader.fail();
554 return false;
555 }
556
557 auto proto = getLocalProtocolVersion();
558
559 yarp::os::idl::WireWriter writer(reader);
560 if (!writer.writeListHeader(1)) {
561 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
562 return false;}
563 if (!writer.write(proto)) {
564 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
565 return false;
566 }
567 reader.accept();
568 return true;
569 }
572 if (!helper.cmd.readArgs(reader)) {
573 return false;
574 }
575
576 helper.call(this);
577
578 yarp::os::idl::WireWriter writer(reader);
579 if (!helper.reply.write(writer)) {
580 return false;
581 }
582 reader.accept();
583 return true;
584 }
587 if (!helper.cmd.readArgs(reader)) {
588 return false;
589 }
590
591 helper.call(this);
592
593 yarp::os::idl::WireWriter writer(reader);
594 if (!helper.reply.write(writer)) {
595 return false;
596 }
597 reader.accept();
598 return true;
599 }
600 if (tag == "help") {
601 std::string functionName;
602 if (!reader.readString(functionName)) {
603 functionName = "--all";
604 }
605 auto help_strings = help(functionName);
606 yarp::os::idl::WireWriter writer(reader);
607 if (!writer.isNull()) {
608 if (!writer.writeListHeader(2)) {
609 return false;
610 }
611 if (!writer.writeTag("many", 1, 0)) {
612 return false;
613 }
614 if (!writer.writeListBegin(0, help_strings.size())) {
615 return false;
616 }
617 for (const auto& help_string : help_strings) {
618 if (!writer.writeString(help_string)) {
619 return false;
620 }
621 }
622 if (!writer.writeListEnd()) {
623 return false;
624 }
625 }
626 reader.accept();
627 return true;
628 }
629 if (reader.noMore()) {
630 reader.fail();
631 return false;
632 }
633 std::string next_tag = reader.readTag(1);
634 if (next_tag.empty()) {
635 break;
636 }
637 tag.append("_").append(next_tag);
638 tag_len = std::count(tag.begin(), tag.end(), '_') + 1;
639 }
640 return false;
641}
#define yError(...)
Definition Log.h:361
#define __YFUNCTION__
Definition Log.h:24
#define yWarning(...)
Definition Log.h:340
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_help
yarp::dev::ReturnValue(*)() funcptr_t
static constexpr size_t s_tag_len
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr size_t s_cmd_len
static constexpr const char * s_tag
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_prototype
static constexpr size_t s_reply_len
bool readTag(yarp::os::idl::WireReader &reader)
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::os::ApplicationNetworkProtocolVersion helper_proto
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
virtual yarp::dev::ReturnValue doSomethingUnimplementedRPC()
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
virtual std::vector< std::string > help(const std::string &functionName="--all")
virtual yarp::os::ApplicationNetworkProtocolVersion getRemoteProtocolVersion()
virtual yarp::dev::ReturnValue doSomethingRPC()
virtual yarp::os::ApplicationNetworkProtocolVersion getLocalProtocolVersion()
virtual bool checkProtocolVersion()
An interface for reading from a network connection.
An interface for writing to a network connection.
This is a base class for objects that can be both read from and be written to the YARP network.
Definition Portable.h:25
yarp::os::WireLink & yarp()
Get YARP state associated with this object.
Definition Wire.h:28
A "tamed" Portable, that promises to serialize itself in an IDL-friendly way.
IDL-friendly connection reader.
Definition WireReader.h:27
bool readString(std::string &str, bool *is_vocab=nullptr)
std::string readTag(size_t len=static_cast< size_t >(-1))
bool read(WirePortable &obj)
IDL-friendly connection writer.
Definition WireWriter.h:28
bool write(const WirePortable &obj) const
bool writeListHeader(int len) const
bool writeTag(const char *tag, int split, int len) const
bool writeString(const std::string &str, bool skip_tag=false) const
bool writeListBegin(int tag, size_t len) const
constexpr std::int16_t protocol_version
#define yCError(component,...)
#define YARP_LOG_COMPONENT(name,...)
The main, catch-all namespace for YARP.
Definition dirs.h:16
#define YARP_VERSION_PATCH
Definition version.h:12
#define YARP_VERSION_MAJOR
Definition version.h:10
#define YARP_VERSION_MINOR
Definition version.h:11