dynsub¶
The dynsub example is a PoC for a C-based JSON printer of arbitrary data. It assumes that topic discovery is enabled, but doesn’t require it.
Running the example¶
Pass the name of a topic to dynsub and it waits for a writer of that topic to show up. When it finds one in the DCPSPublication topic, it tries to subscribe and print the received samples as JSON.
For example: Start the HelloworldPublisher
in one shell:
# bin/HelloworldPublisher
=== [Publisher] Waiting for a reader to be discovered ...
In another shell start dynsub
:
# bin/dynsub HelloWorldData_Msg
{"userID":1,"message":"Hello World"}
{"userID":1}
The second line is the “invalid sample” generated because of the termination of the publisher. In Cyclone DDS, only the key fields are valid, and therefore printed.
Instead of the HelloWorldData_Msg, the small publisher program “variouspub” can publish a number of different types. Pass it the name of the type to publish. For example:
# bin/variouspub B
This publishes samples at 1Hz until killed.
Source code¶
1// Copyright(c) 2022 to 2023 ZettaScale Technology and others
2//
3// This program and the accompanying materials are made available under the
4// terms of the Eclipse Public License v. 2.0 which is available at
5// http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
6// v. 1.0 which is available at
7// http://www.eclipse.org/org/documents/edl-v10.php.
8//
9// SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
10
11#include <stdio.h>
12#include <string.h>
13#include <stdlib.h>
14#include <assert.h>
15#include <locale.h>
16#include <signal.h>
17
18#include "dds/dds.h"
19#include "dynsub.h"
20
21// Interpreting the data of an arbitrary topic requires interpreting the type object that describes the data.
22// The type object type is defined by the XTypes specification (https://www.omg.org/spec/DDS-XTypes/) and it
23// comes in two forms: MinimalTypeObject and CompleteTypeObject. Only the latter includes field names, so
24// that's what need.
25//
26// Cyclone DDS includes a copy of the IDL as well as the corresponding type definitions in C as generated by
27// IDLC. So instead of including yet another copy, we simply refer to those. These files are not (yet?)
28// part of the stable API of Cyclone DDS and so the updates to Cyclone may change the locations or the names
29// of the relevant header files.
30//
31// The API uses `dds_typeobj_t` and `dds_typeinfo_t` that are opaque types but really amount to the
32// corresponding XTypes objects: DDS_XTypes_TypeObject and DDS_XTypes_TypeInformation. Rather than casting
33// pointers like we do here, they should be defined in a slightly different way so that they are not really
34// opaque. For now, this'll have to do.
35#include "dds/ddsc/dds_public_alloc.h"
36#include "dds/ddsi/ddsi_sertype.h"
37#include "dds/ddsi/ddsi_xt_typeinfo.h"
38
39#include "dds/ddsrt/threads.h"
40#include "dds/ddsi/ddsi_serdata.h"
41
42// For convenience, the DDS participant is global
43static dds_entity_t participant;
44
45static dds_entity_t termcond;
46
47// Helper function to wait for a DCPSPublication/DCPSSubscription to show up with the desired topic name,
48// then calls dds_find_topic to create a topic for that data writer's/reader's type up the retrieves the
49// type object.
50static dds_return_t get_topic_and_typeobj (const char *topic_name, dds_duration_t timeout, dds_entity_t *topic, DDS_XTypes_TypeObject **xtypeobj)
51{
52 const dds_entity_t waitset = dds_create_waitset (participant);
53 const dds_entity_t dcpspublication_reader = dds_create_reader (participant, DDS_BUILTIN_TOPIC_DCPSPUBLICATION, NULL, NULL);
54 const dds_entity_t dcpspublication_readcond = dds_create_readcondition (dcpspublication_reader, DDS_ANY_STATE);
55 const dds_entity_t dcpssubscription_reader = dds_create_reader (participant, DDS_BUILTIN_TOPIC_DCPSSUBSCRIPTION, NULL, NULL);
56 const dds_entity_t dcpssubscription_readcond = dds_create_readcondition (dcpssubscription_reader, DDS_ANY_STATE);
57 (void) dds_waitset_attach (waitset, dcpspublication_readcond, dcpspublication_reader);
58 (void) dds_waitset_attach (waitset, dcpssubscription_readcond, dcpssubscription_reader);
59 const dds_time_t abstimeout = (timeout == DDS_INFINITY) ? DDS_NEVER : dds_time () + timeout;
60 dds_return_t ret = DDS_RETCODE_OK;
61 *xtypeobj = NULL;
62 struct ppc ppc;
63 ppc_init (&ppc);
64 dds_attach_t triggered_reader_x;
65 while (*xtypeobj == NULL && dds_waitset_wait_until (waitset, &triggered_reader_x, 1, abstimeout) > 0)
66 {
67 void *epraw = NULL;
68 dds_sample_info_t si;
69 dds_entity_t triggered_reader = (dds_entity_t) triggered_reader_x;
70 if (dds_take (triggered_reader, &epraw, &si, 1, 1) <= 0)
71 continue;
72 dds_builtintopic_endpoint_t *ep = epraw;
73 const dds_typeinfo_t *typeinfo = NULL;
74 // We are only interested in DCPSPublications where the topic name matches and that carry type information
75 // (a non-XTypes capable DDS would not provide type information) because without that information there is
76 // no way we can do anything interesting with it.
77 if (strcmp (ep->topic_name, topic_name) == 0 && dds_builtintopic_get_endpoint_type_info (ep, &typeinfo) == 0 && typeinfo)
78 {
79 // Using dds_find_topic allows us to "clone" the topic definition including the topic QoS, but it does
80 // require that topic discovery is enabled in the configuration. The advantage of using dds_find_topic
81 // is that it creates a topic with the same name, type *and QoS*. That distinction only matters if
82 // topic is discovery is enabled and/or if the topic has a durability kind of of transient or persistent:
83 // - using a different topic QoS might result in an incompatible QoS notification if topic discovery is
84 // enabled (everything would still work).
85 // - transient/persistent data behaviour is defined in terms of the topic QoS actually really matters
86 //
87 // So we try to use dds_find_topic, and if that fails, try to go the other route using the writer's QoS
88 // as an approximation of the topic QoS.
89 if ((*topic = dds_find_topic (DDS_FIND_SCOPE_GLOBAL, participant, ep->topic_name, typeinfo, DDS_SECS (2))) < 0)
90 {
91 fprintf (stderr, "dds_find_topic: %s ... continuing on the assumption that topic discovery is disabled\n", dds_strretcode (*topic));
92 dds_topic_descriptor_t *descriptor;
93 if ((ret = dds_create_topic_descriptor(DDS_FIND_SCOPE_GLOBAL, participant, typeinfo, DDS_SECS (10), &descriptor)) < 0)
94 {
95 fprintf (stderr, "dds_create_topic_descriptor: %s\n", dds_strretcode (ret));
96 dds_return_loan (triggered_reader, &epraw, 1);
97 goto error;
98 }
99 dds_qset_data_representation (ep->qos, 0, NULL);
100 if ((*topic = dds_create_topic (participant, descriptor, ep->topic_name, ep->qos, NULL)) < 0)
101 {
102 fprintf (stderr, "dds_create_topic_descriptor: %s (be sure to enable topic discovery in the configuration)\n", dds_strretcode (*topic));
103 dds_delete_topic_descriptor (descriptor);
104 dds_return_loan (triggered_reader, &epraw, 1);
105 goto error;
106 }
107 dds_delete_topic_descriptor (descriptor);
108 }
109 // The topic suffices for creating a reader, but we also need the TypeObject to make sense of the data
110 if ((*xtypeobj = load_type_with_deps (participant, typeinfo, &ppc)) == NULL)
111 {
112 fprintf (stderr, "loading type with all dependencies failed\n");
113 dds_return_loan (triggered_reader, &epraw, 1);
114 goto error;
115 }
116 if (load_type_with_deps_min (participant, typeinfo, &ppc) == NULL)
117 {
118 fprintf (stderr, "loading minimal type with all dependencies failed\n");
119 dds_return_loan (triggered_reader, &epraw, 1);
120 goto error;
121 }
122 }
123 dds_return_loan (triggered_reader, &epraw, 1);
124 }
125 if (*xtypeobj)
126 {
127 // If we got the type object, populate the type cache
128 size_t align, size;
129 build_typecache_to (&(*xtypeobj)->_u.complete, &align, &size);
130 fflush (stdout);
131 struct typeinfo templ = { .key = { .key = (uintptr_t) *xtypeobj } } , *info;
132 if ((info = type_cache_lookup (&templ)) != NULL)
133 {
134 assert (info->release == NULL);
135 info->release = *xtypeobj;
136 }
137 else
138 {
139 // not sure whether this is at all possible
140 info = malloc (sizeof (*info));
141 assert (info);
142 *info = (struct typeinfo){ .key = { .key = (uintptr_t) *xtypeobj }, .typeobj = &(*xtypeobj)->_u.complete, .release = *xtypeobj, .align = align, .size = size };
143 type_cache_add (info);
144 }
145 }
146error:
147 dds_delete (dcpspublication_reader);
148 dds_delete (dcpssubscription_reader);
149 dds_delete (waitset);
150 return (*xtypeobj != NULL) ? DDS_RETCODE_OK : DDS_RETCODE_TIMEOUT;
151}
152
153static bool print_sample_normal (dds_entity_t reader, const DDS_XTypes_TypeObject *xtypeobj)
154{
155 void *raw = NULL;
156 dds_sample_info_t si;
157 dds_return_t ret;
158 if ((ret = dds_take (reader, &raw, &si, 1, 1)) < 0)
159 return false;
160 else if (ret != 0)
161 {
162 // ... that we then print
163 print_sample (si.valid_data, raw, &xtypeobj->_u.complete);
164 if (dds_return_loan (reader, &raw, 1) < 0)
165 return false;
166 }
167 return true;
168}
169
170static void hexdump (const unsigned char *msg, const size_t len)
171{
172 for (size_t off16 = 0; off16 < len; off16 += 16)
173 {
174 printf ("%04" PRIxSIZE " ", off16);
175 size_t off1;
176 for (off1 = 0; off1 < 16 && off16 + off1 < len; off1++)
177 printf ("%s %02x", (off1 == 8) ? " " : "", msg[off16 + off1]);
178 for (; off1 < 16; off1++)
179 printf ("%s ", (off1 == 8) ? " " : "");
180 printf (" |");
181 for (off1 = 0; off1 < 16 && off16 + off1 < len; off1++)
182 {
183 unsigned char c = msg[off16 + off1];
184 printf ("%c", (c >= 32 && c < 127) ? c : '.');
185 }
186 printf ("|\n");
187 }
188 fflush (stdout);
189}
190
191static const char *encodingstr (const struct ddsi_serdata *sd)
192{
193 uint16_t encoding;
194 ddsi_serdata_to_ser (sd, 0, 2, &encoding);
195 switch (encoding)
196 {
197 case DDSI_RTPS_CDR_BE:
198 case DDSI_RTPS_CDR_LE:
199 return "CDR";
200 case DDSI_RTPS_PL_CDR_BE:
201 case DDSI_RTPS_PL_CDR_LE:
202 return "PL_CDR";
203 case DDSI_RTPS_CDR2_BE:
204 case DDSI_RTPS_CDR2_LE:
205 return "CDR2";
206 case DDSI_RTPS_D_CDR2_BE:
207 case DDSI_RTPS_D_CDR2_LE:
208 return "D_CDR2";
209 case DDSI_RTPS_PL_CDR2_BE:
210 case DDSI_RTPS_PL_CDR2_LE:
211 return "PL_CDR2";
212 default:
213 return "unknown";
214 }
215}
216
217static bool print_sample_cdr (dds_entity_t reader, const DDS_XTypes_TypeObject *xtypeobj)
218{
219 // Note: doesn't print the exact CDR received, but the "normalised" one where byteswapping
220 // has been performed, booleans have been mapped to 0 or 1, and perhaps some other similar
221 // changes have been made.
222 struct ddsi_serdata *sd = NULL;
223 dds_sample_info_t si;
224 dds_return_t ret;
225 if ((ret = dds_takecdr (reader, &sd, 1, &si, 0)) < 0)
226 return false;
227 else if (ret != 0)
228 {
229 printf ("encoding: %s", encodingstr (sd));
230 if (!si.valid_data)
231 printf (" (expect XCDR2 because it is an invalid sample)");
232 printf ("\n");
233 if (ddsi_serdata_size (sd) == 4)
234 printf ("(no payload)\n");
235 else
236 {
237 ddsrt_iovec_t iov;
238 struct ddsi_serdata *refsd;
239 refsd = ddsi_serdata_to_ser_ref (sd, 4, ddsi_serdata_size (sd) - 4, &iov);
240 hexdump (iov.iov_base, iov.iov_len);
241 ddsi_serdata_to_ser_unref (refsd, &iov);
242 }
243
244 void *raw = calloc (1, sd->type->sizeof_type);
245 if (raw == NULL)
246 abort ();
247
248 bool ok;
249 if (si.valid_data)
250 ok = ddsi_serdata_to_sample (sd, raw, NULL, NULL);
251 else
252 {
253 const struct ddsi_sertype *st;
254 dds_get_entity_sertype (reader, &st);
255 ok = ddsi_serdata_untyped_to_sample (st, sd, raw, NULL, NULL);
256 }
257 if (ok)
258 print_sample (si.valid_data, raw, &xtypeobj->_u.complete);
259 else
260 printf ("(conversion to sample failed)\n");
261 ddsi_sertype_free_sample (sd->type, raw, DDS_FREE_CONTENTS);
262 free (raw);
263
264 ddsi_serdata_unref (sd);
265 }
266 return true;
267}
268
269#if !DDSRT_WITH_FREERTOS && !__ZEPHYR__
270static void signal_handler (int sig)
271{
272 (void) sig;
273 dds_set_guardcondition (termcond, true);
274}
275#endif
276
277#if !_WIN32 && !DDSRT_WITH_FREERTOS && !__ZEPHYR__
278static uint32_t sigthread (void *varg)
279{
280 sigset_t *set = varg;
281 int sig;
282 if (sigwait (set, &sig) == 0)
283 signal_handler (sig);
284 return 0;
285}
286#endif
287
288int main (int argc, char **argv)
289{
290 dds_return_t ret = 0;
291 dds_entity_t topic = 0;
292 bool raw_mode;
293 const char *topic_name;
294
295 // for printf("%ls")
296 setlocale (LC_CTYPE, "");
297
298 if (argc == 2)
299 {
300 raw_mode = false;
301 topic_name = argv[1];
302 }
303 else if (argc == 3 && strcmp (argv[1], "-r") == 0)
304 {
305 raw_mode = true;
306 topic_name = argv[2];
307 }
308 else
309 {
310 fprintf (stderr, "usage: %s [-r] topicname\n", argv[0]);
311 return 2;
312 }
313
314 participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
315 if (participant < 0)
316 {
317 fprintf (stderr, "dds_create_participant: %s\n", dds_strretcode (participant));
318 return 1;
319 }
320
321 // The one magic step: get a topic and type object ...
322 DDS_XTypes_TypeObject *xtypeobj;
323 type_cache_init ();
324 if ((ret = get_topic_and_typeobj (topic_name, DDS_SECS (10), &topic, &xtypeobj)) < 0)
325 {
326 fprintf (stderr, "get_topic_and_typeobj: %s\n", dds_strretcode (ret));
327 goto error;
328 }
329 // ... given those, we can create a reader just like we do normally ...
330 const dds_entity_t reader = dds_create_reader (participant, topic, NULL, NULL);
331 // ... and create a waitset that allows us to wait for any incoming data ...
332 const dds_entity_t waitset = dds_create_waitset (participant);
333 const dds_entity_t readcond = dds_create_readcondition (reader, DDS_ANY_STATE);
334 (void) dds_waitset_attach (waitset, readcond, 0);
335
336 termcond = dds_create_guardcondition (participant);
337 (void) dds_waitset_attach (waitset, termcond, 0);
338
339#ifdef _WIN32
340 signal (SIGINT, signal_handler);
341#elif !DDSRT_WITH_FREERTOS && !__ZEPHYR__
342 ddsrt_thread_t sigtid;
343 sigset_t sigset, osigset;
344 sigemptyset (&sigset);
345#ifdef __APPLE__
346 DDSRT_WARNING_GNUC_OFF(sign-conversion)
347#endif
348 sigaddset (&sigset, SIGHUP);
349 sigaddset (&sigset, SIGINT);
350 sigaddset (&sigset, SIGTERM);
351#ifdef __APPLE__
352 DDSRT_WARNING_GNUC_ON(sign-conversion)
353#endif
354 sigprocmask (SIG_BLOCK, &sigset, &osigset);
355 {
356 ddsrt_threadattr_t tattr;
357 ddsrt_threadattr_init (&tattr);
358 ddsrt_thread_create (&sigtid, "sigthread", &tattr, sigthread, &sigset);
359 }
360#endif
361
362 bool termflag = false;
363 while (!termflag)
364 {
365 (void) dds_waitset_wait (waitset, NULL, 0, DDS_INFINITY);
366 dds_read_guardcondition (termcond, &termflag);
367
368 bool ok = raw_mode ? print_sample_cdr (reader, xtypeobj) : print_sample_normal (reader, xtypeobj);
369 if (!ok)
370 break;
371 }
372
373#if _WIN32
374 signal_handler (SIGINT);
375#elif !DDSRT_WITH_FREERTOS && !__ZEPHYR__
376 {
377 /* get the attention of the signal handler thread */
378 void (*osigint) (int);
379 void (*osigterm) (int);
380 kill (getpid (), SIGTERM);
381 ddsrt_thread_join (sigtid, NULL);
382 osigint = signal (SIGINT, SIG_IGN);
383 osigterm = signal (SIGTERM, SIG_IGN);
384 sigprocmask (SIG_SETMASK, &osigset, NULL);
385 signal (SIGINT, osigint);
386 signal (SIGINT, osigterm);
387 }
388#endif
389
390error:
391 type_cache_free ();
392 dds_delete (participant);
393 return ret < 0;
394}
1struct A {
2 @key
3 string name;
4 string message;
5 unsigned long count;
6};
7
8struct T {
9 short s;
10 long l;
11};
12
13struct B {
14 A a;
15 sequence<T> ts;
16};
17
18struct C {
19 B b;
20 @key
21 short k;
22};
23
24module M1 {
25 @appendable
26 struct O {
27 @optional long x;
28 };
29};
30
31struct D {
32 wstring ws;
33 wchar wc;
34 unsigned long count;
35};
36
37struct U {
38 uint32 w;
39 @key string x;
40 string y;
41 @key uint32 z;
42};
43
44struct E {
45 uint32 a;
46 @key sequence<U> b[2];
47 @key uint32 c;
48};
1#include <stdio.h>
2#include <string.h>
3#include <stdlib.h>
4#include <signal.h>
5#include <assert.h>
6
7#include "dds/dds.h"
8#include "variouspub_types.h"
9
10static void *samples_a[] = {
11 &(A){ "Mariken", "Wie sidi, vrient?", 0 },
12 &(A){ "Die duvel", "Een meester vol consten,", 0 },
13 &(A){ "Die duvel", "Nieuwers af falende, wes ic besta.", 0 },
14 &(A){ "Mariken", "'t Comt mi alleleens met wien dat ick ga,", 0 },
15 &(A){ "Mariken", "Also lief gae ic metten quaetsten als metten besten.", 0 },
16 NULL
17};
18
19static void *samples_b[] = {
20 &(B){ {"Die duvel", "Wildi u liefde te mi werts vesten,", 0},
21 { ._length = 2, ._maximum = 2, ._release = false,
22 ._buffer = (T[]){ {2,3},{5,7} } } },
23 &(B){ {"Die duvel", "Ick sal u consten leeren sonder ghelijcke,", 0},
24 { ._length = 3, ._maximum = 3, ._release = false,
25 ._buffer = (T[]){ {11,13},{17,19},{23,29} } } },
26 &(B){ {"Die duvel", "Die seven vrie consten: rethorijcke, musijcke,", 0},
27 { ._length = 5, ._maximum = 5, ._release = false,
28 ._buffer = (T[]){ {31,37},{41,43},{47,52},{59,61},{67,71} } } },
29 &(B){ {"Die duvel", "Logica, gramatica ende geometrie,", 0},
30 { ._length = 7, ._maximum = 7, ._release = false,
31 ._buffer = (T[]){ {73,79},{83,89},{97,101},{103,107},{109,113},
32 {127,131},{137,139} } } },
33 &(B){ {"Die duvel", "Aristmatica ende alkenie,", 0},
34 { ._length = 11, ._maximum = 11, ._release = false,
35 ._buffer = (T[]){ {149,151},{157,163},{167,173},{179,181},
36 {191,193},{197, 199},{211,223},{227,229},
37 {233,239},{241,251},{257,263} } } },
38 NULL
39};
40
41static void *samples_c[] = {
42 &(C){ { {"Die duvel", "Dwelc al consten sijn seer curable.", 0},
43 { ._length = 13, ._maximum = 13, ._release = false,
44 ._buffer = (T[]){ {269,271},{277,281},{283,293},{307,311},
45 {313,317},{331,337},{347,349},{353,359},
46 {367,373},{379,383},{389,397},{401,409},
47 {419,421} } } },
48 8936 },
49 &(C){ { {"Die duvel", "Noyt vrouwe en leefde op eerde so able", 0},
50 { ._length = 17, ._maximum = 17, ._release = false,
51 ._buffer = (T[]){ {431,433},{439,443},{449,457},{461,463},
52 {467,479},{487,491},{499,503},{509,521},
53 {523,541},{547,557},{563,569},{571,577},
54 {587,593},{599,601},{607,613},{617,619},
55 {631,641} } } },
56 18088 },
57 &(C){ { {"Die duvel", "Als ic u maken sal.", 0},
58 { ._length = 19, ._maximum = 19, ._release = false,
59 ._buffer = (T[]){ {643,647},{653,659},{661,673},{677,683},
60 {691,701},{709,719},{727,733},{739,743},
61 {751,757},{761,769},{773,787},{797,809},
62 {811,821},{823,827},{829,839},{853,857},
63 {859,863},{877,881},{883,887} } } },
64 29172 },
65 &(C){ { {"Mariken", "So moetti wel zijn een constich man.", 0},
66 { ._length = 23, ._maximum = 23, ._release = false,
67 ._buffer = (T[]){ {907,911},{919,929},{937,941},{947,953},
68 {967,971},{977,983},{991,997},{1009,1013},
69 {1019,1021},{1031,1033},{1039,1049},{1051,1061},
70 {1063,1069},{1087,1091},{1093,1097},{1103,1109},
71 {1117,1123},{1129,1151},{1153,1163},{1171,1181},
72 {1187,1193},{1201,1213},{1217,1223} } } },
73 16022 },
74 &(C){ { {"Mariken", "Wie sidi dan?", 0},
75 { ._length = 29, ._maximum = 29, ._release = false,
76 ._buffer = (T[]){ {1229,1231},{1237,1249},{1259,1277},{1279,1283},
77 {1289,1291},{1297,1301},{1303,1307},{1319,1321},
78 {1327,1361},{1367,1373},{1381,1399},{1409,1423},
79 {1427,1429},{1433,1439},{1447,1451},{1453,1459},
80 {1471,1481},{1483,1487},{1489,1493},{1499,1511},
81 {1523,1531},{1543,1549},{1553,1559},{1567,1571},
82 {1579,1583},{1597,1601},{1607,1609},{1613,1619},
83 {1621,1627} } } },
84 17880 },
85 NULL
86};
87
88static int32_t long_4 = 4;
89static void *samples_M1_O[] = {
90 &(M1_O){ .x = NULL },
91 &(M1_O){ .x = &long_4 },
92 NULL
93};
94
95static void *samples_d[] = {
96 &(D){ L"😀 Een Kruyck gaat soo langh te water tot datse barst.", 0x2206, 0 },
97 &(D){ L"🙃 Men treckt een Boogh soo lang tot datse stucken knarst.", 0x2207, 0 },
98 &(D){ L"😊 De Steel-kunst doet zyn Meester de dood vaak verwerven.", 0x22a5, 0 },
99 NULL
100};
101
102static void *samples_e[] = {
103 &(E){ 0, {{0},{0}}, 456 },
104 &(E){ 0, {{0},{._length=1, ._maximum=1, ._buffer=&(U){34,"aap","noot",56}}}, 456},
105 &(E){ 0, {{0},{._length=1, ._maximum=1, ._buffer=&(U){78,"aap","zus",56}}}, 456},
106 &(E){ 0, {{0},{._length=1, ._maximum=1, ._buffer=&(U){78,"wim","zus",90}}}, 456},
107 NULL
108};
109
110static struct tpentry {
111 const char *name;
112 const dds_topic_descriptor_t *descr;
113 void **samples;
114 size_t count_offset;
115} tptab[] = {
116 { "A", &A_desc, samples_a, offsetof (A, count) },
117 { "B", &B_desc, samples_b, offsetof (B, a.count) },
118 { "C", &C_desc, samples_c, offsetof (C, b.a.count) },
119 { "M1::O", &M1_O_desc, samples_M1_O, SIZE_MAX },
120 { "D", &D_desc, samples_d, offsetof (D, count) },
121 { "E", &E_desc, samples_e, offsetof (E, a) },
122 { NULL, NULL, NULL, 0 }
123};
124
125static void usage (const char *argv0)
126{
127 fprintf (stderr, "usage: %s {", argv0);
128 const char *sep = "";
129 for (struct tpentry *tpentry = &tptab[0]; tpentry->name; tpentry++)
130 {
131 fprintf (stderr, "%s%s", sep, tpentry->name);
132 sep = "|";
133 }
134 fprintf (stderr, "}\n");
135 exit (2);
136}
137
138static volatile sig_atomic_t interrupted;
139
140static void sigint (int sig)
141{
142 (void) sig;
143 interrupted = 1;
144}
145
146int main (int argc, char **argv)
147{
148 if (argc != 2)
149 usage (argv[0]);
150 struct tpentry *tpentry;
151 for (tpentry = &tptab[0]; tpentry->name; tpentry++)
152 if (strcmp (tpentry->name, argv[1]) == 0)
153 break;
154 if (tpentry->name == NULL)
155 usage (argv[0]);
156
157 const dds_entity_t participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
158 if (participant < 0)
159 {
160 fprintf (stderr, "dds_create_participant: %s\n", dds_strretcode (participant));
161 return 1;
162 }
163
164 const dds_entity_t topic = dds_create_topic (participant, tpentry->descr, tpentry->name, NULL, NULL);
165 const dds_entity_t writer = dds_create_writer (participant, topic, NULL, NULL);
166 uint32_t sample_idx = 0;
167 uint32_t count = 0;
168 signal (SIGINT, sigint);
169 while (!interrupted)
170 {
171 dds_return_t ret = 0;
172 void *sample = tpentry->samples[sample_idx];
173 uint32_t * const countp =
174 (tpentry->count_offset != SIZE_MAX)
175 ? (uint32_t *) ((unsigned char *) sample + tpentry->count_offset)
176 : 0;
177 if (countp)
178 *countp = count++;
179 if ((ret = dds_write (writer, sample)) < 0)
180 {
181 fprintf (stderr, "dds_write: %s\n", dds_strretcode (ret));
182 dds_delete (participant);
183 return 1;
184 }
185 if (tpentry->samples[++sample_idx] == NULL)
186 {
187 sample_idx = 0;
188 }
189 dds_sleepfor (DDS_SECS (1));
190 }
191
192 dds_delete (participant);
193 return 0;
194}