static qeo_retcode_t write_generated_data(qeocore_writer_t *writer, int arraysize){
org_qeo_dynamic_qdm_test_TypeWithStructs_t t = {};
size_t i, j;
qeo_retcode_t rc = QEO_EFAIL;
int stringsize = 10;
t.mfloat32 = 32;
t.mstring = "asdfdfasdfqwreqwrqwdfadfadsfadfd";
DDS_SEQ_INIT(t.msubstruct3);
org_qeo_dynamic_qdm_test_Substruct3_t ss3[arraysize];
char strings[arraysize][arraysize+2][stringsize];
for (i = 0; i < arraysize; ++i) {
ss3[i].msubfloat = i;
ss3[i].msubstring = str_random(strings[i][0], stringsize);
DDS_SEQ_INIT(ss3[i].msubstruct2);
org_qeo_dynamic_qdm_test_Substruct2_t ss2[arraysize];
for (j = 0; j < arraysize; ++j) {
ss2[j].msubshort = j*i;
ss2[j].msubstring = str_random(strings[i][j+2], stringsize);
}
dds_seq_from_array(&ss3[i].msubstruct2, ss2, arraysize);
}
dds_seq_from_array(&t.msubstruct3, ss3, arraysize);
DDS_SEQ_INIT(t.msubstruct1);
org_qeo_dynamic_qdm_test_Substruct1_t ss1[arraysize];
for (i = 0; i < arraysize; ++i) {
ss1[i].msubint32 = i;
ss1[i].msubstring = str_random(strings[i][1], stringsize);
}
dds_seq_from_array(&t.msubstruct1, ss1, arraysize);
rc = qeocore_writer_write(writer, &t);
for(i = 0; i < DDS_SEQ_LENGTH(t.msubstruct3); ++i) {
dds_seq_cleanup(&(DDS_SEQ_ITEM(t.msubstruct3, i).msubstruct2));
}
dds_seq_cleanup(&t.msubstruct3);
dds_seq_cleanup(&t.msubstruct1);
return rc;
}
static qeo_retcode_t fwd_server_instance_publish(const qeo_factory_t *factory)
{
qeo_retcode_t rc = QEO_OK;
org_qeo_system_Forwarder_t fwd_data = {
.locator = DDS_SEQ_INITIALIZER(org_qeo_system_ForwarderLocator_t)
};
fwd_data.deviceId = factory->qeo_id.device_id;
/* add locator if available */
if (QMGMT_LOCATORTYPE_UNKNOWN != factory->fwd.locator->type) {
org_qeo_system_ForwarderLocator_t locator_data;
locator_data.type = factory->fwd.locator->type;
locator_data.port = factory->fwd.locator->port;
locator_data.address = factory->fwd.locator->address;
rc = ddsrc_to_qeorc(dds_seq_append(&fwd_data.locator, &locator_data));
}
if (QEO_OK == rc) {
rc = qeocore_writer_write(factory->fwd.u.server.writer, &fwd_data);
}
dds_seq_cleanup(&fwd_data.locator);
return rc;
}
void test_dyn_array1 (void)
{
DDS_DynamicTypeSupport ts;
DDS_DynamicTypeBuilder sb, abc20;
DDS_TypeDescriptor *desc;
DDS_MemberDescriptor *md;
DDS_DynamicType s, ac20;
DDS_BoundSeq bounds;
DDS_DynamicData dd, dda, dd2;
DDS_ReturnCode_t rc;
unsigned i;
v_printf ("test_dyn_array1 - ");
/* 1. Create the type. */
desc = DDS_TypeDescriptor__alloc ();
fail_unless (desc != NULL);
desc->kind = DDS_STRUCTURE_TYPE;
desc->name = "dstruct1";
sb = DDS_DynamicTypeBuilderFactory_create_type (desc);
fail_unless (sb != NULL);
md = DDS_MemberDescriptor__alloc ();
fail_unless (md != NULL);
DDS_SEQ_INIT (bounds);
dds_seq_require (&bounds, 1);
DDS_SEQ_LENGTH (bounds) = 1;
DDS_SEQ_ITEM (bounds, 0) = 20;
abc20 = DDS_DynamicTypeBuilderFactory_create_array_type (
DDS_DynamicTypeBuilderFactory_get_primitive_type (DDS_CHAR_8_TYPE),
&bounds);
fail_unless (abc20 != NULL);
dds_seq_cleanup (&bounds);
ac20 = DDS_DynamicTypeBuilder_build (abc20);
fail_unless (ac20 != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (abc20);
md->name = "char_a";
md->index = md->id = 0;
md->type = ac20;
rc = DDS_DynamicTypeBuilder_add_member (sb, md);
fail_unless (rc == DDS_RETCODE_OK);
s = DDS_DynamicTypeBuilder_build (sb);
fail_unless (s != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (sb);
ts = DDS_DynamicTypeSupport_create_type_support (s);
fail_unless (ts != NULL);
DDS_TypeDescriptor__free (desc);
DDS_MemberDescriptor__free (md);
/* 2. Create a Dynamic Data item for this type. */
dd = DDS_DynamicDataFactory_create_data (s);
fail_unless (dd != NULL);
dda = DDS_DynamicDataFactory_create_data (ac20);
fail_unless (dda != NULL);
for (i = 0; i < 20; i++) {
SET_FIELD (dda, i, char8, i + '0');
}
SET_FIELD (dd, 0, complex, dda);
marshallDynamic (dd, &dd2, ts);
DDS_DynamicDataFactory_delete_data (dd);
DDS_DynamicDataFactory_delete_data (dda);
DDS_DynamicTypeBuilderFactory_delete_type (ac20);
DDS_DynamicTypeBuilderFactory_delete_type (s);
DDS_DynamicTypeSupport_delete_type_support (ts);
v_printf ("success!\r\n");
}
void test_dyn_array2 (void)
{
DDS_DynamicTypeSupport ts;
DDS_DynamicTypeBuilder sb1, sb1a, abi64, abs1a;
DDS_DynamicType s1, s1a, ai64, as1a;
DDS_TypeDescriptor *desc;
DDS_MemberDescriptor *md;
DDS_DynamicData dd, dds, dda, ddas, dd2;
DDS_ReturnCode_t rc;
DDS_BoundSeq bounds;
unsigned i, j;
v_printf ("test_dyn_array2 - ");
/* 1. Create the type. */
desc = DDS_TypeDescriptor__alloc ();
fail_unless (desc != NULL);
desc->kind = DDS_STRUCTURE_TYPE;
desc->name = "dstruct2a";
sb1a = DDS_DynamicTypeBuilderFactory_create_type (desc);
fail_unless (sb1a != NULL);
md = DDS_MemberDescriptor__alloc ();
fail_unless (md != NULL);
DDS_SEQ_INIT (bounds);
dds_seq_require (&bounds, 1);
DDS_SEQ_LENGTH (bounds) = 1;
DDS_SEQ_ITEM (bounds, 0) = 5;
abi64 = DDS_DynamicTypeBuilderFactory_create_array_type (
DDS_DynamicTypeBuilderFactory_get_primitive_type (DDS_INT_64_TYPE),
&bounds);
fail_unless (abi64 != NULL);
ai64 = DDS_DynamicTypeBuilder_build (abi64);
fail_unless (ai64 != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (abi64);
md->name = "i64";
md->index = md->id = 0;
md->type = ai64;
rc = DDS_DynamicTypeBuilder_add_member (sb1a, md);
fail_unless (rc == DDS_RETCODE_OK);
ADD_FIELD (sb1a, md, "ch", 1, 1, DDS_CHAR_8_TYPE);
s1a = DDS_DynamicTypeBuilder_build (sb1a);
fail_unless (s1a != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (sb1a);
DDS_SEQ_ITEM (bounds, 0) = 7;
abs1a = DDS_DynamicTypeBuilderFactory_create_array_type (s1a, &bounds);
fail_unless (abs1a != NULL);
dds_seq_cleanup (&bounds);
as1a = DDS_DynamicTypeBuilder_build (abs1a);
fail_unless (as1a != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (abs1a);
desc->kind = DDS_STRUCTURE_TYPE;
desc->name = "dstruct2";
sb1 = DDS_DynamicTypeBuilderFactory_create_type (desc);
fail_unless (sb1 != NULL);
ADD_FIELD (sb1, md, "c", 0, 0, DDS_CHAR_8_TYPE);
md->name = "str2";
md->index = md->id = 1;
md->type = as1a;
rc = DDS_DynamicTypeBuilder_add_member (sb1, md);
fail_unless (rc == DDS_RETCODE_OK);
ADD_FIELD (sb1, md, "u16", 2, 2, DDS_UINT_16_TYPE);
s1 = DDS_DynamicTypeBuilder_build (sb1);
fail_unless (s1 != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (sb1);
ts = DDS_DynamicTypeSupport_create_type_support (s1);
fail_unless (ts != NULL);
DDS_TypeDescriptor__free (desc);
DDS_MemberDescriptor__free (md);
/* 2. Create a Dynamic Data item for this type. */
dd = DDS_DynamicDataFactory_create_data (s1);
fail_unless (dd != NULL);
ddas = DDS_DynamicDataFactory_create_data (as1a);
fail_unless (ddas != NULL);
SET_FIELD (dd, 0, char8, 'A');
for (i = 0; i < 7; i++) {
dds = DDS_DynamicDataFactory_create_data (s1a);
fail_unless (dds != NULL);
dda = DDS_DynamicDataFactory_create_data (ai64);
fail_unless (dda != NULL);
for (j = 0; j < 5; j++) {
SET_FIELD (dda, j, int64, ((i + 6) * j) << i);
}
SET_FIELD (dds, 0, complex, dda);
DDS_DynamicDataFactory_delete_data (dda);
SET_FIELD (dds, 1, char8, i + 0x30);
SET_FIELD (ddas, i, complex, dds);
DDS_DynamicDataFactory_delete_data (dds);
}
SET_FIELD (dd, 1, complex, ddas);
DDS_DynamicDataFactory_delete_data (ddas);
SET_FIELD (dd, 2, uint16, 1366);
marshallDynamic (dd, &dd2, ts);
DDS_DynamicDataFactory_delete_data (dd);
DDS_DynamicTypeBuilderFactory_delete_type (s1);
DDS_DynamicTypeBuilderFactory_delete_type (as1a);
DDS_DynamicTypeBuilderFactory_delete_type (s1a);
DDS_DynamicTypeBuilderFactory_delete_type (ai64);
DDS_DynamicTypeSupport_delete_type_support (ts);
v_printf ("success!\r\n");
}
static qeocore_type_t *build_enum(const qeo_factory_t *factory, json_t *typedesc){
qeocore_type_t *qeoType = NULL;
qeocore_enum_constants_t vals = DDS_SEQ_INITIALIZER(qeocore_enum_constant_t);
const char *enumstr = NULL;
DDS_ReturnCode_t ddsret;
assert(typedesc != NULL);
assert(factory != NULL);
do {
json_t *type_enum = json_object_get(typedesc, KEY_ENUM);
if ((NULL == type_enum) || !json_is_string(type_enum)) {
qeo_log_e("Invalid type_enum (%p)", type_enum);
return qeoType;
}
json_t *values = json_object_get(typedesc, KEY_VALUES);
if ((NULL == values) || !json_is_object(values)) {
qeo_log_e("Invalid values (%p)", values);
return qeoType;
}
enumstr = json_string_value(type_enum);
//Replace all "::" with ".", because there's a mismatch in topic definitions found in the TSM structs, with "." and the QDM topic definitions with "::"
find_and_replace((char *) enumstr, "::", ".");
if ((ddsret = dds_seq_require(&vals, json_object_size(values))) != DDS_RETCODE_OK){
qeo_log_e("dds_seq_require failed (%d)", ddsret);
return NULL;
}
void *iter = json_object_iter(values);
while (iter) {
json_int_t labelint;
const char *name = json_object_iter_key(iter);
json_t *label = json_object_iter_value(iter);
if (!json_is_integer(label)){
qeo_log_e("not a integer");
}
labelint = json_integer_value(label);
if (labelint >= json_object_size(values)){
qeo_log_e("Currently we only support 0,1,2..[n-1] as labels");
break;
}
DDS_SEQ_ITEM(vals, labelint).name = (char *)name;
iter = json_object_iter_next(values, iter);
}
qeoType = qeocore_type_enum_new(enumstr, &vals);
if (qeoType == NULL){
qeo_log_e("Cannot register enum");
}
dds_seq_cleanup(&vals);
} while(0);
return qeoType;
}
void DDS_ParticipantBuiltinTopicData__clear (DDS_ParticipantBuiltinTopicData *data)
{
dds_seq_cleanup (&data->user_data.value);
}
void DDS_OctetSeq__clear (DDS_OctetSeq *octets)
{
dds_seq_cleanup (octets);
}
void DDS_StringSeq__clear (DDS_StringSeq *strings)
{
dds_seq_cleanup (strings);
}
void test_dyn_mutable2 (void)
{
DDS_DynamicTypeSupport ts;
DDS_DynamicTypeBuilder sb2, stb, sstb;
DDS_DynamicType s2, st, sst;
DDS_TypeDescriptor *desc;
DDS_MemberDescriptor *md;
DDS_DynamicData dd, dd2, dds;
DDS_ReturnCode_t rc;
DDS_StringSeq ss;
unsigned n;
char *strings [] = {
"Hi there", "blabla", "\0", NULL,
"got here", "not yet done", "", "num8",
"9", "10", "11", "12",
"13", "14", "15", "16",
"17", "18", "19", "done :)"
};
v_printf ("test_mutable2 - ");
/* 1. Create the type. */
desc = DDS_TypeDescriptor__alloc ();
fail_unless (desc != NULL);
desc->kind = DDS_STRUCTURE_TYPE;
desc->name = "dstruct2m";
sb2 = DDS_DynamicTypeBuilderFactory_create_type (desc);
fail_unless (sb2 != NULL);
md = DDS_MemberDescriptor__alloc ();
fail_unless (md != NULL);
ADD_FIELD (sb2, md, "u16", 0, 5, DDS_UINT_16_TYPE);
set_key_annotation (sb2, "u16");
stb = DDS_DynamicTypeBuilderFactory_create_string_type (DDS_UNBOUNDED_COLLECTION);
fail_unless (stb != NULL);
st = DDS_DynamicTypeBuilder_build (stb);
fail_unless (st != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (stb);
sstb = DDS_DynamicTypeBuilderFactory_create_sequence_type (st,
DDS_UNBOUNDED_COLLECTION);
fail_unless (sstb != NULL);
sst = DDS_DynamicTypeBuilder_build (sstb);
fail_unless (sst != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (sstb);
md->name = "s";
md->index = 1;
md->id = 6;
md->type = sst;
rc = DDS_DynamicTypeBuilder_add_member (sb2, md);
fail_unless (rc == DDS_RETCODE_OK);
set_ext_annotation (sb2, "MUTABLE_EXTENSIBILITY");
s2 = DDS_DynamicTypeBuilder_build (sb2);
fail_unless (s2 != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (sb2);
ts = DDS_DynamicTypeSupport_create_type_support (s2);
fail_unless (ts != NULL);
DDS_TypeDescriptor__free (desc);
DDS_MemberDescriptor__free (md);
/* 2. Create a Dynamic data item for this type. */
DDS_SEQ_INIT (ss);
dds_seq_from_array (&ss, strings, sizeof (strings) / sizeof (char *));
for (n = 0; n <= DDS_SEQ_MAXIMUM (ss); n++) {
dd = DDS_DynamicDataFactory_create_data (s2);
fail_unless (dd != NULL);
SET_FIELD (dd, 5, uint16, n);
dds = DDS_DynamicDataFactory_create_data (sst);
fail_unless (dds != NULL);
DDS_SEQ_LENGTH (ss) = n;
rc = DDS_DynamicData_set_string_values (dds, 0, &ss);
fail_unless (rc == DDS_RETCODE_OK);
SET_FIELD (dd, 6, complex, dds);
marshallDynamic (dd, &dd2, ts);
DDS_DynamicDataFactory_delete_data (dd);
DDS_DynamicDataFactory_delete_data (dds);
if (n > 2) {
n += 3;
if (n == 18)
n++;
}
}
dds_seq_cleanup (&ss);
DDS_DynamicTypeBuilderFactory_delete_type (s2);
DDS_DynamicTypeBuilderFactory_delete_type (sst);
DDS_DynamicTypeBuilderFactory_delete_type (st);
DDS_DynamicTypeSupport_delete_type_support (ts);
set_key_annotation (NULL, NULL);
set_ext_annotation (NULL, NULL);
v_printf ("success!\r\n");
}
void test_dyn_mutable1 (void)
{
DDS_DynamicTypeSupport ts;
DDS_DynamicTypeBuilder sb2, ostb;
DDS_DynamicType s2, ot, ost;
DDS_TypeDescriptor *desc;
DDS_MemberDescriptor *md;
DDS_DynamicData dd, dd2, dds;
DDS_ReturnCode_t rc;
DDS_ByteSeq bseq;
unsigned char values [] = { 0x22, 0x33, 0x4f, 0x5e, 0x6d, 0x7c, 0x8b };
v_printf ("test_mutable1 - ");
/* 1. Create the type. */
desc = DDS_TypeDescriptor__alloc ();
fail_unless (desc != NULL);
desc->kind = DDS_STRUCTURE_TYPE;
desc->name = "dstruct1m";
sb2 = DDS_DynamicTypeBuilderFactory_create_type (desc);
fail_unless (sb2 != NULL);
md = DDS_MemberDescriptor__alloc ();
fail_unless (md != NULL);
ADD_FIELD (sb2, md, "i16", 0, 99, DDS_INT_16_TYPE);
set_id_annotation (sb2, "i16", 20);
ADD_FIELD (sb2, md, "u32", 1, 2, DDS_UINT_32_TYPE);
set_key_annotation (sb2, "u32");
ADD_FIELD (sb2, md, "i32", 2, 100, DDS_INT_32_TYPE);
set_id_annotation (sb2, "i32", 50);
ADD_FIELD (sb2, md, "u16", 0, DDS_MEMBER_ID_INVALID, DDS_UINT_16_TYPE);
set_id_annotation (sb2, "u16", 10);
set_key_annotation (sb2, "u16");
ADD_FIELD (sb2, md, "u64", 5, 51, DDS_UINT_64_TYPE);
ADD_FIELD (sb2, md, "i64", 5, DDS_MEMBER_ID_INVALID, DDS_INT_64_TYPE);
ADD_FIELD (sb2, md, "fl", 6, 53, DDS_FLOAT_32_TYPE);
ADD_FIELD (sb2, md, "d", 7, 54, DDS_FLOAT_64_TYPE);
ADD_FIELD (sb2, md, "ch", 8, 55, DDS_CHAR_8_TYPE);
set_id_annotation (sb2, "ch", 5);
set_key_annotation (sb2, "ch");
set_id_annotation (sb2, "fl", 4);
ot = DDS_DynamicTypeBuilderFactory_get_primitive_type (DDS_BYTE_TYPE);
fail_unless (ot != NULL);
ostb = DDS_DynamicTypeBuilderFactory_create_sequence_type (ot,
DDS_UNBOUNDED_COLLECTION);
fail_unless (ostb != NULL);
ost = DDS_DynamicTypeBuilder_build (ostb);
fail_unless (ost != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (ostb);
md->name = "s";
md->index = 9;
md->id = 9;
md->type = ost;
rc = DDS_DynamicTypeBuilder_add_member (sb2, md);
fail_unless (rc == DDS_RETCODE_OK);
set_ext_annotation (sb2, "MUTABLE_EXTENSIBILITY");
s2 = DDS_DynamicTypeBuilder_build (sb2);
fail_unless (s2 != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (sb2);
ts = DDS_DynamicTypeSupport_create_type_support (s2);
fail_unless (ts != NULL);
DDS_TypeDescriptor__free (desc);
DDS_MemberDescriptor__free (md);
/* 2. Create a Dynamic data item for this type. */
dd = DDS_DynamicDataFactory_create_data (s2);
fail_unless (dd != NULL);
SET_FIELD (dd, 50, int32, -5);
SET_FIELD (dd, 10, uint16, 0xDEAD);
SET_FIELD (dd, 20, int16, INT16_MIN);
SET_FIELD (dd, 2, uint32, UINT32_MAX);
SET_FIELD (dd, 52, int64, 100);
SET_FIELD (dd, 4, float32, 0.5f);
SET_FIELD (dd, 54, float64, 100e-5);
SET_FIELD (dd, 5, char8, 'd');
SET_FIELD (dd, 51, uint64, 5010000);
dds = DDS_DynamicDataFactory_create_data (ost);
fail_unless (dds != NULL);
DDS_SEQ_INIT (bseq);
dds_seq_from_array (&bseq, values, sizeof (values));
rc = DDS_DynamicData_set_byte_values (dds, 0, &bseq);
dds_seq_cleanup (&bseq);
fail_unless (rc == DDS_RETCODE_OK);
SET_FIELD (dd, 9, complex, dds);
marshallDynamic (dd, &dd2, ts);
DDS_DynamicDataFactory_delete_data (dd);
DDS_DynamicDataFactory_delete_data (dds);
DDS_DynamicTypeBuilderFactory_delete_type (s2);
DDS_DynamicTypeBuilderFactory_delete_type (ost);
DDS_DynamicTypeSupport_delete_type_support (ts);
set_id_annotation (NULL, NULL, 0);
set_key_annotation (NULL, NULL);
set_ext_annotation (NULL, NULL);
v_printf ("success!\r\n");
}
