int main() { qeo_factory_t *open_qeo = NULL; qeo_factory_t *closed_qeo = NULL; qeocore_type_t *tsm_type = NULL; qeocore_type_t *dyn_type = NULL; /* create two factories */ assert(NULL != (open_qeo = qeocore_factory_new(QEO_IDENTITY_OPEN))); init_factory(open_qeo); assert(NULL != (closed_qeo = qeocore_factory_new(QEO_IDENTITY_DEFAULT))); init_factory(closed_qeo); /* register TSM type in open domain factory */ assert(NULL != (tsm_type = qeocore_type_register_tsm(open_qeo, org_qeo_system_RegistrationRequest_type, org_qeo_system_RegistrationRequest_type->name))); /* register dynamic type in closed domain factory */ assert(NULL != (dyn_type = types_get(org_qeo_system_RegistrationRequest_type))); assert(QEO_OK == qeocore_type_register(closed_qeo, dyn_type, org_qeo_system_RegistrationRequest_type->name)); /* clean up */ qeocore_type_free(dyn_type); qeocore_type_free(tsm_type); qeocore_factory_close(closed_qeo); qeocore_factory_close(open_qeo); return 0; }
int main(int argc, const char **argv) { qeo_factory_t *factory; qeocore_type_t *type; qeocore_reader_t *reader; qeocore_reader_listener_t listener = { .on_data = on_data_available }; qeocore_writer_t *writer; pthread_t th = 0; /* initialize */ sem_init(&_sync, 0, 0); assert(NULL != (factory = qeocore_factory_new(QEO_IDENTITY_DEFAULT))); init_factory(factory); assert(NULL != (type = qeocore_type_register_tsm(factory, _tsm, _tsm[0].name))); assert(NULL != (reader = qeocore_reader_open(factory, type, NULL, QEOCORE_EFLAG_STATE_DATA | QEOCORE_EFLAG_ENABLE, &listener, NULL))); assert(NULL != (writer = qeocore_writer_open(factory, type, NULL, QEOCORE_EFLAG_STATE_DATA | QEOCORE_EFLAG_ENABLE, NULL, NULL))); /* start writer thread */ assert(0 == pthread_create(&th, NULL, run, writer)); /* make sure writing has started */ sem_wait(&_sync); /* shutdown reader */ qeocore_reader_close(reader); _closed = 1; /* shutdown writer */ _done = 1; pthread_join(th, NULL); qeocore_writer_close(writer); qeocore_type_free(type); qeocore_factory_close(factory); }
static void on_qeocore_on_factory_init_done(qeo_factory_t *factory, bool success) { uintptr_t puserdata = 0; factory_dispatcher_cookie *dc = NULL; qeo_json_factory_listener_t *listener = NULL; do { if ((qeocore_factory_get_user_data(factory, &puserdata)) != QEO_OK) { qeo_log_e("qeocore_factory_get_user_data failed"); return; } dc = (factory_dispatcher_cookie *)puserdata; if (dc == NULL) { qeo_log_e("dc == NULL"); return; } listener = (qeo_json_factory_listener_t *)dc->listener; if (listener == NULL) { qeo_log_e("listener == NULL"); return; } if (success) { listener->on_factory_init_done(factory, dc->userdata); } else { listener->on_factory_init_done(NULL, dc->userdata); qeocore_factory_close(factory); free(dc); } } while (0); }
static void run_writer(pid_t peer) { // writer is a type_nest_i writer qeo_factory_t *factory; qeocore_type_t *type_nest_i; qeocore_writer_t *writer; qeocore_data_t *outer=NULL; qeocore_data_t *inner=NULL; int status; /* initialize */ assert(NULL != (factory = qeocore_factory_new(QEO_IDENTITY_DEFAULT))); init_factory(factory); assert(NULL != (type_nest_i = type_nest_i_register(factory))); assert(NULL != (writer = qeocore_writer_open(factory, type_nest_i, NULL, QEOCORE_EFLAG_STATE_DATA | QEOCORE_EFLAG_ENABLE, NULL, NULL))); log_pid("=================================== writer initialized"); assert(NULL != (outer = qeocore_writer_data_new(writer))); /* fill outer struct */ assert(QEO_OK == qeocore_data_set_member(outer, _outer_int32_id, &_outer_int32_value)); assert(QEO_OK == qeocore_data_set_member(outer, _outer_int8_id, &_outer_int8_value)); assert(QEO_OK == qeocore_data_set_member(outer, _outer_string_id, &_outer_string_value)); assert(QEO_OK == qeocore_data_set_member(outer, _outer_int16_id, &_outer_int16_value)); assert(QEO_OK == qeocore_data_set_member(outer, _outer_int64_id, &_outer_int64_value)); /* fill inner struct */ assert(QEO_OK == qeocore_data_get_member(outer, _inner_id, &inner)); assert(QEO_OK == qeocore_data_set_member(inner, _inner_int32_id, &_inner_int32_value)); assert(QEO_OK == qeocore_data_set_member(inner, _inner_int8_id, &_inner_int8_value)); assert(QEO_OK == qeocore_data_set_member(inner, _inner_string_id, &_inner_string_value)); assert(QEO_OK == qeocore_data_set_member(inner, _inner_int16_id, &_inner_int16_value)); assert(QEO_OK == qeocore_data_set_member(inner, _inner_int64_id, &_inner_int64_value)); assert(QEO_OK == qeocore_data_set_member(outer, _inner_id, &inner)); log_verbose(" =================== _outer_int32_value = %u \n", _outer_int32_value ); log_verbose(" =================== _outer_int8_value = %u \n", _outer_int8_value ); log_verbose(" =================== _outer_int16_value = %u \n", _outer_int16_value ); log_verbose(" =================== _outer_int64_value = %"PRIu64" \n", _outer_int64_value ); log_verbose(" =================== _inner_int32_value = %u \n", _inner_int32_value ); log_verbose(" =================== _inner_int8_value = %u \n", _inner_int8_value ); log_verbose(" =================== _inner_int16_value = %u \n", _inner_int16_value ); log_verbose(" =================== _inner_int64_value = %"PRIu64" \n", _inner_int64_value ); /* write */ assert(QEO_OK == qeocore_writer_write(writer, outer)); log_pid("===================================== writer wrote outer data"); assert(peer == waitpid(peer, &status, 0)); assert(0 == status); log_pid("===================================== writer done"); /* clean up */ qeocore_data_free(inner); qeocore_data_free(outer); qeocore_writer_close(writer); qeocore_type_free(type_nest_i); qeocore_factory_close(factory); }
void qeo_json_factory_close(qeo_factory_t *factory) { if (NULL != factory) { uintptr_t userdata; qeocore_factory_get_user_data(factory, &userdata); factory_dispatcher_cookie *dc = (factory_dispatcher_cookie *)userdata; qeocore_factory_close(factory); free(dc); } }
static void run_writer(pid_t peer) { qeo_factory_t *factory; qeocore_type_t *type; qeocore_writer_t *writer; qeocore_data_t *data, *seqdata; byte_array_t array; int status, i; /* initialize */ assert(NULL != (factory = qeocore_factory_new(QEO_IDENTITY_DEFAULT))); init_factory(factory); assert(NULL != (type = type_register(factory))); assert(NULL != (writer = qeocore_writer_open(factory, type, NULL, QEOCORE_EFLAG_STATE_DATA | QEOCORE_EFLAG_ENABLE, NULL, NULL))); log_pid("writer initialized"); assert(NULL != (data = qeocore_writer_data_new(writer))); assert(QEO_OK == qeocore_data_set_member(data, _size_id, &_test_size)); /* init sequence */ DDS_SEQ_INIT(array); assert(NULL != (DDS_SEQ_DATA(array) = malloc(_test_size * sizeof(char)))); DDS_SEQ_LENGTH(array) = DDS_SEQ_MAXIMUM(array) = _test_size; for (i = 0; i < _test_size; i++) { DDS_SEQ_ITEM(array, i) = i & 0xff; } assert(QEO_OK == qeocore_data_get_member(data, _buf_id, &seqdata)); assert(QEO_OK == qeocore_data_sequence_set(seqdata, (const qeo_sequence_t *)&array, 0)); assert(QEO_OK == qeocore_data_set_member(data, _buf_id, &seqdata)); /* write */ assert(QEO_OK == qeocore_writer_write(writer, data)); log_pid("writer wrote data"); assert(peer == waitpid(peer, &status, 0)); assert(0 == status); log_pid("writer done"); /* clean up */ free(DDS_SEQ_DATA(array)); qeocore_data_free(seqdata); qeocore_data_free(data); qeocore_writer_close(writer); qeocore_type_free(type); qeocore_factory_close(factory); }
static void run_reader(void) { qeo_factory_t *factory; qeocore_type_t *type_nest_i; qeocore_reader_t *reader; qeocore_reader_listener_t listener = { .on_data = my_on_data_available }; sem_init(&_sync, 0, 0); assert(NULL != (factory = qeocore_factory_new(QEO_IDENTITY_DEFAULT))); init_factory(factory); assert(NULL != (type_nest_i = type_nest_i_register(factory))); assert(NULL != (reader = qeocore_reader_open(factory, type_nest_i, NULL, QEOCORE_EFLAG_STATE_DATA | QEOCORE_EFLAG_ENABLE, &listener, NULL))); log_pid("=============================== reader initialized"); sem_wait(&_sync); /* wait for sample */ log_pid("=============================== reader done"); sem_destroy(&_sync); qeocore_reader_close(reader); qeocore_type_free(type_nest_i); qeocore_factory_close(factory); }
int main(int argc, const char **argv) { qeo_factory_t *factory; qeocore_reader_t *reader; qeocore_writer_t *writer; qeocore_type_t *type; qeocore_data_t *rdata, *wdata; int i; for (i = 0; i < 2; i++) { /* initialize */ assert(NULL != (factory = qeocore_factory_new(QEO_IDENTITY_DEFAULT))); init_factory(factory); assert(NULL != (type = nested_type_get(1, 0, 0))); assert(QEO_OK == qeocore_type_register(factory, type, "nested")); assert(NULL != (reader = qeocore_reader_open(factory, type, NULL, QEOCORE_EFLAG_STATE_UPDATE | QEOCORE_EFLAG_ENABLE, NULL, NULL))); assert(NULL != (writer = qeocore_writer_open(factory, type, NULL, QEOCORE_EFLAG_STATE_UPDATE | QEOCORE_EFLAG_ENABLE, NULL, NULL))); /* write */ assert(NULL != (wdata = qeocore_writer_data_new(writer))); fill_data(wdata); assert(QEO_OK == qeocore_writer_write(writer, wdata)); /* check data */ assert(NULL != (rdata = qeocore_reader_data_new(reader))); assert(QEO_OK == qeocore_reader_read(reader, NULL, rdata)); expected_status = QEOCORE_DATA; validate_data(rdata); /* remove */ assert(QEO_OK == qeocore_writer_remove(writer, wdata)); /* clean up */ qeocore_data_free(wdata); qeocore_data_free(rdata); qeocore_writer_close(writer); qeocore_reader_close(reader); qeocore_type_free(type); qeocore_factory_close(factory); } }
int main(int argc, const char **argv) { qeo_factory_t *factory; qeocore_type_t *type; qeocore_reader_t *reader; qeocore_reader_listener_t listener = { .on_data = on_data_available }; qeocore_writer_t *writer; int i = 0; /* initialize */ sem_init(&_sync, 0, 0); sem_init(&_sync_nodata, 0, 0); assert(NULL != (factory = qeocore_factory_new(QEO_IDENTITY_DEFAULT))); init_factory(factory); assert(NULL != (type = qeocore_type_register_tsm(factory, org_qeo_dynamic_qdm_test_TypeWithStructs_type, org_qeo_dynamic_qdm_test_TypeWithStructs_type[0].name))); assert(NULL != (reader = qeocore_reader_open(factory, type, NULL, QEOCORE_EFLAG_EVENT_DATA, &listener, NULL))); assert(NULL != (writer = qeocore_writer_open(factory, type, NULL, QEOCORE_EFLAG_EVENT_DATA, NULL, NULL))); /* test late enabling of readers/writers */ assert(QEO_OK == qeocore_reader_enable(reader)); assert(QEO_OK == qeocore_writer_enable(writer)); /* send structure */ for(i = 0; i < 20; i++){ log_verbose("testing with %d", i); assert(QEO_OK == write_generated_data(writer, i)); log_verbose("waiting for data"); /* wait for reception */ sem_wait(&_sync); sem_wait(&_sync_nodata); } /* clean up */ qeocore_writer_close(writer); qeocore_reader_close(reader); qeocore_type_free(type); qeocore_factory_close(factory); sem_destroy(&_sync); }
int main(int argc, const char **argv) { pid_t pid; pid = fork(); if (pid == -1) { perror("fork failed"); exit(EXIT_FAILURE); } else if (pid == 0) { log_verbose("=================== WRITER of type 1 \n"); qeo_factory_t *factory; qeocore_type_t *type1; qeocore_writer_t *writer; /* initialize */ assert(NULL != (factory = qeocore_factory_new(QEO_IDENTITY_DEFAULT))); init_factory(factory); log_verbose(" =================== c qeocore_type_register_tsm(factory, _tsm_type_qdm_version1, _tsm_type_qdm_version1[0].name) \n"); assert(NULL != (type1 = qeocore_type_register_tsm(factory, _tsm_type_qdm_version1, _tsm_type_qdm_version1[0].name))); log_verbose(" =================== c qeocore_writer_open(factory, type1, NULL, QEOCORE_EFLAG_EVENT_DATA, NULL, NULL) \n"); assert(NULL != (writer = qeocore_writer_open(factory, type1, NULL, QEOCORE_EFLAG_EVENT_DATA, NULL, NULL))); /* test late enabling of readers/writers */ log_verbose(" =================== c qeocore_writer_enable(writer) \n"); assert(QEO_OK == qeocore_writer_enable(writer)); /* send structure */ sleep(2); log_verbose(" =================== c qeocore_writer_write(writer, &_type_qdm_version1) \n"); assert(QEO_OK == qeocore_writer_write(writer, &_type_qdm_version1)); sleep(2); /* clean up */ qeocore_writer_close(writer); qeocore_type_free(type1); qeocore_factory_close(factory); _exit(EXIT_SUCCESS); } else { log_verbose("=================== READER of type 2 \n"); qeo_factory_t *factory; qeocore_type_t *type2; qeocore_reader_t *reader; qeocore_reader_listener_t listener = { .on_data = on_data_available }; /* initialize */ sem_init(&_sync, 0, 0); sem_init(&_sync_nodata, 0, 0); assert(NULL != (factory = qeocore_factory_new(QEO_IDENTITY_DEFAULT))); init_factory(factory); log_verbose(" =================== p qeocore_type_register_tsm(factory, _tsm_type_qdm_version2, _tsm_type_qdm_version2[0].name) \n"); assert(NULL != (type2 = qeocore_type_register_tsm(factory, _tsm_type_qdm_version2, _tsm_type_qdm_version2[0].name))); log_verbose(" =================== p qeocore_reader_open(factory, type2, NULL, QEOCORE_EFLAG_EVENT_DATA, &listener, NULL) \n"); assert(NULL != (reader = qeocore_reader_open(factory, type2, NULL, QEOCORE_EFLAG_EVENT_DATA, &listener, NULL))); /* test late enabling of readers/writers */ log_verbose(" =================== p qeocore_reader_enable(reader) \n"); assert(QEO_OK == qeocore_reader_enable(reader)); /* wait for reception */ log_verbose(" =================== p sem_wait(&_sync) \n"); sem_wait(&_sync); log_verbose(" =================== p sem_wait(&_sync_nodata) \n"); sem_wait(&_sync_nodata); /* clean up */ qeocore_reader_close(reader); qeocore_type_free(type2); qeocore_factory_close(factory); sem_destroy(&_sync); int status; (void)waitpid(pid, &status, 0); } return EXIT_SUCCESS; }