Dynamic Data: Binary Blob field

Hi jnugent,

The `body` member is already of variable size, since it's defined as a sequence, which is a dynamically-sized container: samples shared over DDS will only contain elements up to the sequence field's actual length, not its maximum (as would have instead been the case, had the member been declared as an array). My only suggestion is to consider changing the element type from `char` to `octet` in order to guarantee that the included bytes will never be interpreted as anything but a raw chunk of bytes by any of the various DDS language mappings (unless the contents are actually to be considered (utf-8) characters).

You can access the "contiguous buffer" associated with a sequence using FooSeq_get_contiguous_buffer (in C, but the same operation is also exposed in other language mappings). You should be able to receive from the socket directly into the sequence buffer with the following pattern:

1. Allocate memory in the sequence by calling FooSeq_set_maximum()+FooSeq_set_length() (or the convenience wrapper FooSeq_ensure_length, which allows to modify both max and length in a single call). Set maximum and length to the maximum size of a UDP packet you expect your application to receive.
2. Retrieve a pointer to the sequence's contiguous buffer (with FooSeq_get_contiguous_buffer) and pass it to your UDP receive call.
3. Update the sequence's length to the actual length of the received packet (by calling FooSeq_set_length with the actual size of the received packet returned by the UDP receive call).

Finally, you might be interested in taking a look the RTI Connext Gateway repository, which contains a collection of more advanced plugins for Routing Service, including some custom Adapters, that may prove useful as a reference to go beyond "trivial" examples.

I have thought of one possible caveat that I neglected to mention in my previous post: while it is true that you should be able to receive from the UDP socket into the buffer of a sequence (e.g. `DDS_OctetSeq`, which is the type of `LegacyEvents::data` in C if element is changed to `octet`) you will still need to perform one copy when setting this value into the DynamicData sample that will be propagated through RoutingService.

This is because DDS_DynamicData_set_octet_seq() (and other setters for sequence members) implicitly perform a copy of the sequence passed as input. The same is true for the corresponding getters, which also copy the sequence buffer into a user supplied sequence. There is no way currently to access a raw pointer to the buffer backing the sequence member of a DynamicData sample.

Because of this copy, you might want to consider using a sequence to simply wrap the receive buffer allocated by your application, instead of using the sequence API to do memory management of this buffer as suggested in my previous post (via the `set_maximum()` and `set_length()` operations), which would be mostly useful if you were to draw memory from the actual sample (which is possible for statically typed data, but as I said, it's not possible with DynamicData samples).

Instead, you could keep using your own buffer, "loan it" to a sequence via the FooSeq_loan_contiguous() operation, and then pass the value to `DynamicData_seq_XXX_seq()` to actually store it in a sample.

Hope this helps! Let me know if you have any questions.

Hi James,

I will post our off-line email yesterday: