static qeocore_type_t *type_nest_i_register(qeo_factory_t *factory)
{
    qeocore_type_t *outer = NULL;
    qeocore_type_t *inner = NULL;
    qeocore_type_t *member = NULL;
    // the outer struct level
    assert(NULL != (outer = qeocore_type_struct_new("org.qeo.test.NestedTests")));
    assert(NULL != (member = qeocore_type_primitive_new(QEOCORE_TYPECODE_INT32)));
    assert(QEO_OK == qeocore_type_struct_add(outer, member, "outer_int32", &_outer_int32_id, QEOCORE_FLAG_KEY));
    qeocore_type_free(member);
    assert(NULL != (member = qeocore_type_primitive_new(QEOCORE_TYPECODE_INT8)));
    assert(QEO_OK == qeocore_type_struct_add(outer, member, "outer_int8", &_outer_int8_id, QEOCORE_FLAG_NONE));
    qeocore_type_free(member);
    assert(NULL != (member = qeocore_type_string_new(0)));
    assert(QEO_OK == qeocore_type_struct_add(outer, member, "outer_string", &_outer_string_id, QEOCORE_FLAG_NONE));
    qeocore_type_free(member);

    // the inner struct is inserted
    assert(NULL != (inner = qeocore_type_struct_new("inner")));
    assert(NULL != (member = qeocore_type_primitive_new(QEOCORE_TYPECODE_INT32)));
    assert(QEO_OK == qeocore_type_struct_add(inner, member, "inner_int32", &_inner_int32_id, QEOCORE_FLAG_KEY));
    qeocore_type_free(member);
    assert(NULL != (member = qeocore_type_primitive_new(QEOCORE_TYPECODE_INT8)));
    assert(QEO_OK == qeocore_type_struct_add(inner, member, "inner_int8", &_inner_int8_id, QEOCORE_FLAG_NONE));
    qeocore_type_free(member);
    assert(NULL != (member = qeocore_type_string_new(0)));
    assert(QEO_OK == qeocore_type_struct_add(inner, member, "inner_string", &_inner_string_id, QEOCORE_FLAG_NONE));
    qeocore_type_free(member);
    assert(NULL != (member = qeocore_type_primitive_new(QEOCORE_TYPECODE_INT16)));
    assert(QEO_OK == qeocore_type_struct_add(inner, member, "inner_int16", &_inner_int16_id, QEOCORE_FLAG_NONE));
    qeocore_type_free(member);
    assert(NULL != (member = qeocore_type_primitive_new(QEOCORE_TYPECODE_INT64)));
    assert(QEO_OK == qeocore_type_struct_add(inner, member, "inner_int64", &_inner_int64_id, QEOCORE_FLAG_NONE));
    qeocore_type_free(member);

    // add inner to outer
    assert(QEO_OK == qeocore_type_struct_add(outer, inner, "inner", &_inner_id, QEOCORE_FLAG_NONE));

    // the outer struct level - continued
    assert(NULL != (member = qeocore_type_primitive_new(QEOCORE_TYPECODE_INT16)));
    assert(QEO_OK == qeocore_type_struct_add(outer, member, "outer_int16", &_outer_int16_id, QEOCORE_FLAG_NONE));
    qeocore_type_free(member);
    assert(NULL != (member = qeocore_type_primitive_new(QEOCORE_TYPECODE_INT64)));
    assert(QEO_OK == qeocore_type_struct_add(outer, member, "outer_int64", &_outer_int64_id, QEOCORE_FLAG_NONE));
    qeocore_type_free(member);


    // register the outer type
    assert(QEO_OK == qeocore_type_register(factory, outer, "org.qeo.test.QDMTestDynType"));
    // free
    qeocore_type_free(inner);
    return outer;
}
Beispiel #2
0
END_TEST

START_TEST(test_dynamic_type)
{
    qeocore_type_t *structure = NULL, *sequence = NULL, *string = NULL, *primitive = NULL;
    qeocore_member_id_t id;

    /* init */
    stub_init();
    /* test */
    fail_unless(NULL != (structure = qeocore_type_struct_new("a_dynamic_struct")));
    fail_unless(NULL != (string = qeocore_type_string_new(0)));
    fail_unless(NULL != (primitive = qeocore_type_primitive_new(QEOCORE_TYPECODE_INT32)));
    fail_unless(NULL != (sequence = qeocore_type_sequence_new(primitive)));
    qeocore_type_free(primitive);
    id = QEOCORE_MEMBER_ID_DEFAULT;
    fail_unless(QEO_OK == qeocore_type_struct_add(structure, string, "a_string", &id, QEOCORE_FLAG_KEY));
    qeocore_type_free(string);
    id = QEOCORE_MEMBER_ID_DEFAULT;
    fail_unless(QEO_OK == qeocore_type_struct_add(structure, sequence, "a_sequence", &id, QEOCORE_FLAG_NONE));
    qeocore_type_free(sequence);
    /* clean up */
    qeocore_type_free(structure);
    stub_fini();
}
static qeocore_type_t *type_register(qeo_factory_t *factory)
{
    qeocore_type_t *bigdata = NULL;
    qeocore_type_t *primitive = NULL;
    qeocore_type_t *sequence = NULL;

    assert(NULL != (bigdata = qeocore_type_struct_new("org.qeo.test.bigdata")));
    assert(NULL != (primitive = qeocore_type_primitive_new(QEOCORE_TYPECODE_INT32)));
    assert(QEO_OK == qeocore_type_struct_add(bigdata, primitive, "size", &_size_id, QEOCORE_FLAG_KEY));
    qeocore_type_free(primitive);
    assert(NULL != (primitive = qeocore_type_primitive_new(QEOCORE_TYPECODE_INT8)));
    assert(NULL != (sequence = qeocore_type_sequence_new(primitive)));
    assert(QEO_OK == qeocore_type_struct_add(bigdata, sequence, "buf", &_buf_id, QEOCORE_FLAG_NONE));
    qeocore_type_free(sequence);
    qeocore_type_free(primitive);
    assert(QEO_OK == qeocore_type_register(factory, bigdata, "org.qeo.test.bigdata"));
    return bigdata;
}
Beispiel #4
0
static qeocore_type_t *build_object(const qeo_factory_t *factory, json_t *typedesc)
{
    qeocore_type_t    *qeoType  = NULL;
    const char        *name     = NULL;
    json_t            *value    = NULL;
    qeo_retcode_t     ret       = QEO_EFAIL;
    bool              iret      = true;
    const char        *topic    = NULL;

    assert(typedesc != NULL);
    assert(factory != NULL);

    do {
        json_t *type_topic = json_object_get(typedesc, KEY_TOPIC);
        if ((NULL == type_topic) || !json_is_string(type_topic)) {
            qeo_log_e("Invalid type_topic (%p)", type_topic);
            return qeoType;
        }

        json_t *properties = json_object_get(typedesc, KEY_PROPERTIES);
        if ((NULL == properties) || !json_is_object(properties)) {
            qeo_log_e("Invalid properties (%p)", properties);
            return qeoType;
        }

        topic = json_string_value(type_topic);
        //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 *) topic, "::", ".");

        qeoType = qeocore_type_struct_new(topic);

        if (qeoType == NULL) {
            qeo_log_e("qeocore_type_struct_new failed for topic:%s", topic);
            break;
        }
        qeo_log_d("Registered new struct with name %s", topic);

        void *iter = json_object_iter(properties);
        while (iter) {
            name = json_object_iter_key(iter);
            if (name == NULL) {
                qeo_log_e("name == NULL");
                iret = false;
                break;
            }

            value = json_object_iter_value(iter);
            if (value == NULL) {
                qeo_log_e("value == NULL");
                iret = false;
                break;
            }

            if (!json_is_object(value)) {
                qeo_log_e("no json object");
                iret = false;
                break;
            }

            if (QEO_OK != object_add_member(factory, qeoType, name, value)) {
                qeo_log_e("object add member failed");
                iret = false;
                break;
            }

            iter = json_object_iter_next(properties, iter);
        }

        if (true != iret) {
            break;
        }

        if (QEO_OK != qeocore_type_register(factory, qeoType, topic)) {
            qeo_log_e("failed to register type: %s", topic);
        }

        ret = QEO_OK;
    } while (0);

    if (ret != QEO_OK) {
        qeocore_type_free(qeoType);
        qeoType = NULL;
    }

    return qeoType;
}