static void on_regreq_available(const qeocore_reader_t *reader,
const qeocore_data_t *data,
uintptr_t userdata)
{
log_verbose("%s entry (%d)", __FUNCTION__, qeocore_data_get_status(data));
switch (qeocore_data_get_status(data)) {
case QEOCORE_DATA: {
org_qeo_system_RegistrationRequest_t *t = (org_qeo_system_RegistrationRequest_t *)qeocore_data_get_data(data);
/* verify struct */
validate_regreq(_current_regreq, t, false);
/* release main thread */
sem_post(&_sync);
break;
}
case QEOCORE_NO_MORE_DATA:
break;
case QEOCORE_REMOVE: {
org_qeo_system_RegistrationRequest_t *t = (org_qeo_system_RegistrationRequest_t *)qeocore_data_get_data(data);
/* verify struct */
validate_regreq(_current_regreq, t, true);
/* release main thread */
sem_post(&_sync);
break;
}
case QEOCORE_NOTIFY:
sem_post(&_notify_sync);
break;
default:
abort(); /* error */
}
log_verbose("%s exit", __FUNCTION__);
}
static void on_di_data_available(const qeocore_reader_t *reader,
const qeocore_data_t *data,
uintptr_t userdata){
qeo_retcode_t ret = QEO_OK;
switch (qeocore_data_get_status(data)) {
case QEOCORE_NOTIFY:
qeo_log_d("Notify received");
break;
case QEOCORE_DATA:
qeo_log_d("Data received");
ret = qeo_walk_tsm_for_unmarshal(_types, org_qeo_system_DeviceInfo_type, data, (uintptr_t)&_rcvd_di, QEO_T2D_FLAGS_ALL, &_di_ucbs);
break;
case QEOCORE_NO_MORE_DATA:
qeo_log_d("No more data received");
break;
case QEOCORE_REMOVE:
qeo_log_d("remove received");
break;
case QEOCORE_ERROR:
qeo_log_e("no callback called due to prior error");
break;
}
ck_assert_int_eq(ret, QEO_OK);
}
static void fwd_client_on_data(const qeocore_reader_t *reader,
const qeocore_data_t *data,
uintptr_t userdata)
{
qeo_factory_t *factory = (qeo_factory_t *)userdata;
qeocore_data_status_t status;
org_qeo_system_Forwarder_t *fwd_data;
org_qeo_system_ForwarderLocator_t fwd_locator;
qeo_mgmt_client_locator_t locator;
status = qeocore_data_get_status(data);
if (QEOCORE_DATA == status) {
fwd_data = (org_qeo_system_Forwarder_t *)qeocore_data_get_data(data);
/* check locator */
if ((NULL != fwd_data) && (DDS_SEQ_LENGTH(fwd_data->locator) > 0)) {
fwd_locator = DDS_SEQ_ITEM(fwd_data->locator, 0);
locator.type = fwd_locator.type;
locator.port = fwd_locator.port;
locator.address = fwd_locator.address;
client_state_machine_eval(factory, CLIENT_EVENT_FWD_DATA_RECEIVED, &locator, fwd_data->deviceId);
}
}
else if (QEOCORE_REMOVE == status) {
fwd_data = (org_qeo_system_Forwarder_t *)qeocore_data_get_data(data);
if (NULL != fwd_data) {
client_state_machine_eval(factory, CLIENT_EVENT_FWD_DATA_REMOVED, NULL, fwd_data->deviceId);
}
}
}
static void my_on_data_available(const qeocore_reader_t *reader,
const qeocore_data_t *data,
uintptr_t userdata)
{
switch (qeocore_data_get_status(data)) {
case QEOCORE_DATA: {
qeocore_data_t *seqdata = NULL;
byte_array_t array;
int i, size;
log_pid("reader received data");
assert(QEO_OK == qeocore_data_get_member(data, _size_id, &size));
assert(QEO_OK == qeocore_data_get_member(data, _buf_id, &seqdata));
assert(QEO_OK == qeocore_data_sequence_get(seqdata, (qeo_sequence_t *)&array, 0, QEOCORE_SIZE_UNLIMITED));
assert(size == DDS_SEQ_LENGTH(array));
assert(_test_size == DDS_SEQ_LENGTH(array));
for (i = 0; i < size; i++) {
assert(DDS_SEQ_ITEM(array, i) == (i & 0xff));
}
qeocore_data_sequence_free(seqdata, (qeo_sequence_t *)&array);
qeocore_data_free(seqdata);
sem_post(&_sync); /* release main thread */
break;
}
case QEOCORE_NO_MORE_DATA:
case QEOCORE_REMOVE:
/* ignore */
break;
default:
abort();
break;
}
}
static void fwd_server_on_data(const qeocore_reader_t *reader,
const qeocore_data_t *data,
uintptr_t userdata)
{
/* count number of local forwarder instances */
if (QEOCORE_NOTIFY == qeocore_data_get_status(data)) {
qeo_factory_t *factory = (qeo_factory_t *)reader->entity.factory;
int cnt = fwd_server_count_instances(reader);
fwd_server_state_machine_eval(factory, cnt, false);
}
}
static void on_data_available(const qeocore_reader_t *reader,
const qeocore_data_t *data,
uintptr_t userdata)
{
switch (qeocore_data_get_status(data)) {
case QEOCORE_DATA: {
struct timespec ts = { 0, 100*1000*1000 /* 100ms*/ };
nanosleep(&ts, NULL);
break;
}
default:
/*nop*/
break;
}
}
static void on_data_available(const qeocore_reader_t *reader,
const qeocore_data_t *data,
uintptr_t userdata)
{
log_verbose(" =================== %d on_data_available( is a type2 reader) \n", getpid());
switch (qeocore_data_get_status(data)) {
case QEOCORE_DATA: {
log_verbose(" =================== case QEOCORE_DATA \n");
type_qdm_version2_t *t = (type_qdm_version2_t *)qeocore_data_get_data(data);
/* verify struct */
log_verbose(" =================== received t->string = %s \n", t->string );
log_verbose(" =================== received t->i8 = %u \n", t->i8 );
log_verbose(" =================== received t->i16 = %u \n", t->i16 );
log_verbose(" =================== received t->i32 = %u \n", t->i32 );
log_verbose(" =================== received t->i64 = %" PRIu64 " \n", t->i64 );
log_verbose(" =================== received t->f32 = %f \n", t->f32 );
log_verbose(" =================== received t->boolean = %d \n", t->boolean );
log_verbose(" =================== received t->string_2 = %s \n", t->string_2 );
log_verbose(" =================== received t->i8_2 = %u \n", t->i8_2 );
log_verbose(" =================== received t->i16_2 = %u \n", t->i16_2 );
log_verbose(" =================== received t->i32_2 = %u \n", t->i32_2 );
log_verbose(" =================== received t->i64_2 = %" PRIu64 " \n", t->i64_2 );
log_verbose(" =================== received t->f32_2 = %f \n", t->f32_2 );
log_verbose(" =================== received t->boolean_2 = %d \n", t->boolean_2 );
assert(0 == strcmp(_type_qdm_version1.string, t->string));
assert(_type_qdm_version1.i8 == t->i8);
assert(_type_qdm_version1.i16 == t->i16);
assert(_type_qdm_version1.i32 == t->i32);
assert(_type_qdm_version1.i64 == t->i64);
assert(_type_qdm_version1.f32 == t->f32);
assert(_type_qdm_version1.boolean == t->boolean);
/* release main thread */
log_verbose(" =================== sem_post(&_sync) \n");
sem_post(&_sync);
break;
}
case QEOCORE_NO_MORE_DATA:
log_verbose(" =================== case QEOCORE_NO_MORE_DATA \n");
/* release main thread */
log_verbose(" =================== sem_post(&_sync_nodata) \n");
sem_post(&_sync_nodata);
break;
default:
abort();
break;
}
}
static void validate_data(const qeocore_data_t *data)
{
qeocore_data_t *inner = NULL;
int32_t i = 0;
assert(expected_status == qeocore_data_get_status(data));
/* check outer struct */
assert(QEO_OK == qeocore_data_get_member(data, _id_id, &i));
assert(123 == i);
if (expected_status == QEOCORE_DATA) {
/* check inner struct */
assert(QEO_OK == qeocore_data_get_member(data, _inner_id, &inner));
assert(QEO_OK == qeocore_data_get_member(inner, _num_id, &i));
assert(456 == i);
qeocore_data_free(inner);
}
}
static void on_data_available(const qeocore_reader_t *reader,
const qeocore_data_t *data,
uintptr_t userdata)
{
switch (qeocore_data_get_status(data)) {
case QEOCORE_DATA: {
struct timespec ts = { 0, 100*1000*1000 /* 100ms*/ };
assert(!_closed);
nanosleep(&ts, NULL);
assert(!_closed);
/* release main thread */
sem_post(&_sync);
break;
}
default:
/*nop*/
break;
}
}
static void my_on_data_available(const qeocore_reader_t *reader,
const qeocore_data_t *data,
uintptr_t userdata)
{
// the reader is a type_unnest reader
switch (qeocore_data_get_status(data)) {
case QEOCORE_DATA: {
int outer_int32_value_rx=0, outer_int8_value_rx=0, outer_int16_value_rx=0;
int64_t outer_int64_value_rx=0;
char* outer_string_value_rx="";
log_pid("===================================== reader received data");
assert(QEO_OK == qeocore_data_get_member(data, _outer_int32_id, &outer_int32_value_rx));
assert(QEO_OK == qeocore_data_get_member(data, _outer_int8_id, &outer_int8_value_rx));
assert(QEO_OK == qeocore_data_get_member(data, _outer_string_id, &outer_string_value_rx));
assert(QEO_OK == qeocore_data_get_member(data, _outer_int16_id, &outer_int16_value_rx));
assert(QEO_OK == qeocore_data_get_member(data, _outer_int64_id, &outer_int64_value_rx));
log_verbose(" =================== outer_int32_value_rx = %u \n", outer_int32_value_rx );
log_verbose(" =================== outer_int8_value_rx = %u \n", outer_int8_value_rx );
log_verbose(" =================== outer_string_value_rx = \"%s\" \n", outer_string_value_rx );
log_verbose(" =================== outer_int16_value_rx = %u \n", outer_int16_value_rx );
log_verbose(" =================== outer_int64_value_rx = %"PRIu64" \n", outer_int64_value_rx );
assert(outer_int32_value_rx==_outer_int32_value);
assert(outer_int8_value_rx==_outer_int8_value);
assert(0 == strcmp(_outer_string_value, outer_string_value_rx));
assert(outer_int16_value_rx==_outer_int16_value);
assert(outer_int64_value_rx==_outer_int64_value);
free(outer_string_value_rx);
sem_post(&_sync); /* release main thread */
break;
}
case QEOCORE_NO_MORE_DATA:
case QEOCORE_REMOVE:
/* ignore */
break;
default:
abort();
break;
}
}
static void on_data_available(const qeocore_reader_t *reader,
const qeocore_data_t *data,
uintptr_t userdata)
{
switch (qeocore_data_get_status(data)) {
case QEOCORE_DATA: {
org_qeo_dynamic_qdm_test_TypeWithStructs_t *t = (org_qeo_dynamic_qdm_test_TypeWithStructs_t *) qeocore_data_get_data(data);
/* verify struct TODO */
assert(NULL != t);
/* release main thread */
sem_post(&_sync);
break;
}
case QEOCORE_NO_MORE_DATA:
/* release main thread */
sem_post(&_sync_nodata);
break;
default:
abort();
break;
}
}
void core_callback_dispatcher(const qeocore_reader_t *reader,
const qeocore_data_t *data,
uintptr_t userdata)
{
reader_dispatcher_cookie *dc = (reader_dispatcher_cookie *)userdata;
switch (qeocore_data_get_status(data)) {
case QEOCORE_NOTIFY:
call_on_update(reader, dc);
break;
case QEOCORE_DATA:
call_on_data(reader, data, dc);
break;
case QEOCORE_NO_MORE_DATA:
call_on_no_more_data(reader, dc);
break;
case QEOCORE_REMOVE:
call_on_remove(reader, data, dc);
break;
case QEOCORE_ERROR:
qeo_log_e("no callback called due to prior error");
break;
}
}
