YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
LLM_MessageData.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 (based on compiler 0.14.1-yarped)
7// yarpidl_thrift version 2.0 - 11/11/2026
8// This is an automatically generated file.
9// It could get re-generated if the ALLOW_IDL_GENERATION flag is on.
10
12
13namespace yarp::dev {
14
15// Constructor with field values
16LLM_MessageData::LLM_MessageData(const std::string& type,
17 const std::string& content,
18 const std::vector<std::string>& parameters,
19 const std::vector<std::string>& arguments) :
20 WirePortable(),
21 type(type),
22 content(content),
23 parameters(parameters),
24 arguments(arguments)
25{
26}
27
28// Read structure on a Wire
30{
31 if (!read_type(reader)) {
32 return false;
33 }
34 if (!read_content(reader)) {
35 return false;
36 }
37 if (!read_parameters(reader)) {
38 return false;
39 }
40 if (!read_arguments(reader)) {
41 return false;
42 }
43 if (reader.isError()) {
44 return false;
45 }
46 return true;
47}
48
49// Read structure on a Connection
51{
52 yarp::os::idl::WireReader reader(connection);
53 if (!reader.readListHeader(4)) {
54 return false;
55 }
56 if (!read(reader)) {
57 return false;
58 }
59 return true;
60}
61
62// Write structure on a Wire
64{
65 if (!write_type(writer)) {
66 return false;
67 }
68 if (!write_content(writer)) {
69 return false;
70 }
71 if (!write_parameters(writer)) {
72 return false;
73 }
74 if (!write_arguments(writer)) {
75 return false;
76 }
77 if (writer.isError()) {
78 return false;
79 }
80 return true;
81}
82
83// Write structure on a Connection
85{
86 yarp::os::idl::WireWriter writer(connection);
87 if (!writer.writeListHeader(4)) {
88 return false;
89 }
90 if (!write(writer)) {
91 return false;
92 }
93 return true;
94}
95
96// Convert to a printable string
97std::string LLM_MessageData::toString() const
98{
100 if (!yarp::os::Portable::copyPortable(*this, b)) {
101 return {};
102 }
103 return b.toString();
104}
105
106// read type field
107bool LLM_MessageData::read_type(yarp::os::idl::WireReader& reader)
108{
109 if (reader.noMore()) {
110 reader.fail();
111 return false;
112 }
113 if (!reader.readString(type)) {
114 reader.fail();
115 return false;
116 }
117 return true;
118}
119
120// write type field
121bool LLM_MessageData::write_type(const yarp::os::idl::WireWriter& writer) const
122{
123 if (!writer.writeString(type)) {
124 return false;
125 }
126 return true;
127}
128
129// read (nested) type field
130bool LLM_MessageData::nested_read_type(yarp::os::idl::WireReader& reader)
131{
132 if (reader.noMore()) {
133 reader.fail();
134 return false;
135 }
136 if (!reader.readString(type)) {
137 reader.fail();
138 return false;
139 }
140 return true;
141}
142
143// write (nested) type field
144bool LLM_MessageData::nested_write_type(const yarp::os::idl::WireWriter& writer) const
145{
146 if (!writer.writeString(type)) {
147 return false;
148 }
149 return true;
150}
151
152// read content field
153bool LLM_MessageData::read_content(yarp::os::idl::WireReader& reader)
154{
155 if (reader.noMore()) {
156 reader.fail();
157 return false;
158 }
159 if (!reader.readString(content)) {
160 reader.fail();
161 return false;
162 }
163 return true;
164}
165
166// write content field
167bool LLM_MessageData::write_content(const yarp::os::idl::WireWriter& writer) const
168{
169 if (!writer.writeString(content)) {
170 return false;
171 }
172 return true;
173}
174
175// read (nested) content field
176bool LLM_MessageData::nested_read_content(yarp::os::idl::WireReader& reader)
177{
178 if (reader.noMore()) {
179 reader.fail();
180 return false;
181 }
182 if (!reader.readString(content)) {
183 reader.fail();
184 return false;
185 }
186 return true;
187}
188
189// write (nested) content field
190bool LLM_MessageData::nested_write_content(const yarp::os::idl::WireWriter& writer) const
191{
192 if (!writer.writeString(content)) {
193 return false;
194 }
195 return true;
196}
197
198// read parameters field
199bool LLM_MessageData::read_parameters(yarp::os::idl::WireReader& reader)
200{
201 {
202 size_t _csize;
204 reader.readListBegin(_etype, _csize);
205 // WireReader removes BOTTLE_TAG_LIST from the tag
206 constexpr int expected_tag = ((BOTTLE_TAG_STRING) & (~BOTTLE_TAG_LIST));
207 if constexpr (expected_tag != 0) {
208 if (_csize != 0 && _etype.code != expected_tag) {
209 return false;
210 }
211 }
212 parameters.resize(_csize);
213 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
214 if (reader.noMore()) {
215 reader.fail();
216 return false;
217 }
218 if (!reader.readString(parameters[_i0])) {
219 reader.fail();
220 return false;
221 }
222 }
223 reader.readListEnd();
224 }
225 return true;
226}
227
228// write parameters field
229bool LLM_MessageData::write_parameters(const yarp::os::idl::WireWriter& writer) const
230{
231 if (!writer.writeListBegin(BOTTLE_TAG_STRING, parameters.size())) {
232 return false;
233 }
234 for (const auto& _item : parameters) {
235 if (!writer.writeString(_item, true)) {
236 return false;
237 }
238 }
239 if (!writer.writeListEnd()) {
240 return false;
241 }
242 return true;
243}
244
245// read (nested) parameters field
246bool LLM_MessageData::nested_read_parameters(yarp::os::idl::WireReader& reader)
247{
248 {
249 size_t _csize;
251 reader.readListBegin(_etype, _csize);
252 // WireReader removes BOTTLE_TAG_LIST from the tag
253 constexpr int expected_tag = ((BOTTLE_TAG_STRING) & (~BOTTLE_TAG_LIST));
254 if constexpr (expected_tag != 0) {
255 if (_csize != 0 && _etype.code != expected_tag) {
256 return false;
257 }
258 }
259 parameters.resize(_csize);
260 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
261 if (reader.noMore()) {
262 reader.fail();
263 return false;
264 }
265 if (!reader.readString(parameters[_i0])) {
266 reader.fail();
267 return false;
268 }
269 }
270 reader.readListEnd();
271 }
272 return true;
273}
274
275// write (nested) parameters field
276bool LLM_MessageData::nested_write_parameters(const yarp::os::idl::WireWriter& writer) const
277{
278 if (!writer.writeListBegin(BOTTLE_TAG_STRING, parameters.size())) {
279 return false;
280 }
281 for (const auto& _item : parameters) {
282 if (!writer.writeString(_item, true)) {
283 return false;
284 }
285 }
286 if (!writer.writeListEnd()) {
287 return false;
288 }
289 return true;
290}
291
292// read arguments field
293bool LLM_MessageData::read_arguments(yarp::os::idl::WireReader& reader)
294{
295 {
296 size_t _csize;
298 reader.readListBegin(_etype, _csize);
299 // WireReader removes BOTTLE_TAG_LIST from the tag
300 constexpr int expected_tag = ((BOTTLE_TAG_STRING) & (~BOTTLE_TAG_LIST));
301 if constexpr (expected_tag != 0) {
302 if (_csize != 0 && _etype.code != expected_tag) {
303 return false;
304 }
305 }
306 arguments.resize(_csize);
307 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
308 if (reader.noMore()) {
309 reader.fail();
310 return false;
311 }
312 if (!reader.readString(arguments[_i0])) {
313 reader.fail();
314 return false;
315 }
316 }
317 reader.readListEnd();
318 }
319 return true;
320}
321
322// write arguments field
323bool LLM_MessageData::write_arguments(const yarp::os::idl::WireWriter& writer) const
324{
325 if (!writer.writeListBegin(BOTTLE_TAG_STRING, arguments.size())) {
326 return false;
327 }
328 for (const auto& _item : arguments) {
329 if (!writer.writeString(_item, true)) {
330 return false;
331 }
332 }
333 if (!writer.writeListEnd()) {
334 return false;
335 }
336 return true;
337}
338
339// read (nested) arguments field
340bool LLM_MessageData::nested_read_arguments(yarp::os::idl::WireReader& reader)
341{
342 {
343 size_t _csize;
345 reader.readListBegin(_etype, _csize);
346 // WireReader removes BOTTLE_TAG_LIST from the tag
347 constexpr int expected_tag = ((BOTTLE_TAG_STRING) & (~BOTTLE_TAG_LIST));
348 if constexpr (expected_tag != 0) {
349 if (_csize != 0 && _etype.code != expected_tag) {
350 return false;
351 }
352 }
353 arguments.resize(_csize);
354 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
355 if (reader.noMore()) {
356 reader.fail();
357 return false;
358 }
359 if (!reader.readString(arguments[_i0])) {
360 reader.fail();
361 return false;
362 }
363 }
364 reader.readListEnd();
365 }
366 return true;
367}
368
369// write (nested) arguments field
370bool LLM_MessageData::nested_write_arguments(const yarp::os::idl::WireWriter& writer) const
371{
372 if (!writer.writeListBegin(BOTTLE_TAG_STRING, arguments.size())) {
373 return false;
374 }
375 for (const auto& _item : arguments) {
376 if (!writer.writeString(_item, true)) {
377 return false;
378 }
379 }
380 if (!writer.writeListEnd()) {
381 return false;
382 }
383 return true;
384}
385
386} // namespace yarp::dev
#define BOTTLE_TAG_STRING
Definition Bottle.h:27
#define BOTTLE_TAG_LIST
Definition Bottle.h:29
std::vector< std::string > parameters
possible parameters
std::string type
type of message (can be prompt, assistant, function, ...)
bool write(const yarp::os::idl::WireWriter &writer) const override
std::vector< std::string > arguments
possible arguments of the parameters
bool read(yarp::os::idl::WireReader &reader) override
std::string toString() const
std::string content
content of the message
A simple collection of objects that can be described and transmitted in a portable way.
Definition Bottle.h:64
std::string toString() const override
Gives a human-readable textual representation of the bottle.
Definition Bottle.cpp:212
An interface for reading from a network connection.
An interface for writing to a network connection.
static bool copyPortable(const PortWriter &writer, PortReader &reader)
Copy one portable to another, via writing and reading.
Definition Portable.cpp:16
IDL-friendly connection reader.
Definition WireReader.h:27
bool readString(std::string &str, bool *is_vocab=nullptr)
void readListBegin(yarp::os::idl::WireState &nstate, size_t &len)
IDL-friendly state.
Definition WireState.h:17
IDL-friendly connection writer.
Definition WireWriter.h:28
bool writeListHeader(int len) const
bool writeString(const std::string &str, bool skip_tag=false) const
bool writeListBegin(int tag, size_t len) const
For streams capable of holding different kinds of content, check what they actually have.