// *********************************************************
// -(anything)----------------------------------------------
void impmap_list(impmap *x, t_symbol *s, int argc, t_atom *argv)
{
if (x->mute)
return;
if (argc != x->size_out) {
post("vector size mismatch");
return;
}
int i = 0;
mapper_timetag_now(&x->tt);
mapper_device_start_queue(x->device, x->tt);
mapper_signal *psig = mapper_device_signals(x->device, MAPPER_DIR_OUTGOING);
while (psig) {
if (*psig == x->dummy_output) {
psig = mapper_signal_query_next(psig);
continue;
}
t_signal_ref *ref = mapper_signal_user_data(*psig);
int len = mapper_signal_length(*psig);
float v[len];
for (i = 0; i < len; i++) {
v[i] = atom_getfloat(argv + ref->offset + i);
}
mapper_signal_update(*psig, v, 1, x->tt);
psig = mapper_signal_query_next(psig);
}
mapper_device_send_queue(x->device, x->tt);
outlet_anything(x->outlet2, gensym("out"), argc, argv);
}
// *********************************************************
// -(set up new device and monitor)-------------------------
void impmap_update_output_vector_positions(impmap *x)
{
int i, k=0, count;
int num_outputs = mapper_device_num_signals(x->device, MAPPER_DIR_OUTGOING) - 1;
// store output signal pointers
mapper_signal signals[num_outputs];
mapper_signal *psig = mapper_device_signals(x->device, MAPPER_DIR_OUTGOING);
i = 0;
while (psig) {
if (*psig != x->dummy_output)
signals[i++] = *psig;
psig = mapper_signal_query_next(psig);
}
// sort output signal pointer array
qsort(signals, num_outputs, sizeof(mapper_signal), compare_signal_names);
// set offsets and user_data
for (i = 0; i < num_outputs; i++) {
x->signals_out[i].offset = k;
mapper_signal_set_user_data(signals[i], &x->signals_out[i]);
k += mapper_signal_length(signals[i]);
}
count = k < MAX_LIST ? k : MAX_LIST;
if (count != x->size_out && x->num_snapshots) {
post("implicitmap: output vector size has changed - resetting snapshots!");
impmap_clear_snapshots(x);
}
x->size_out = count;
}
// *********************************************************
// -(randomize)---------------------------------------------
void impmap_randomize(impmap *x)
{
int i;
float rand_val;
if (x->ready) {
mapper_timetag_now(&x->tt);
mapper_device_start_queue(x->device, x->tt);
mapper_signal *psig = mapper_device_signals(x->device, MAPPER_DIR_OUTGOING);
while (psig) {
if (*psig == x->dummy_output) {
psig = mapper_signal_query_next(psig);
continue;
}
t_signal_ref *ref = mapper_signal_user_data(*psig);
if (mapper_signal_type(*psig) != 'f')
continue;
int length = mapper_signal_length(*psig);
float v[length];
float *min = (float*)mapper_signal_minimum(*psig);
float *max = (float*)mapper_signal_maximum(*psig);
for (i = 0; i < length; i++) {
rand_val = (float)rand() / (float)RAND_MAX;
if (min && max) {
v[i] = rand_val * (max[i] - min[i]) + min[i];
}
else {
// if ranges have not been declared, assume normalized between 0 and 1
v[i] = rand_val;
}
maxpd_atom_set_float(x->buffer_out + ref->offset + i, v[i]);
}
mapper_signal_update(*psig, v, 1, x->tt);
psig = mapper_signal_query_next(psig);
}
mapper_device_send_queue(x->device, x->tt);
outlet_anything(x->outlet2, gensym("out"), x->size_out, x->buffer_out);
}
}
// *********************************************************
// -(new)---------------------------------------------------
void *impmap_new(t_symbol *s, int argc, t_atom *argv)
{
impmap *x = NULL;
long i;
const char *alias = NULL;
const char *iface = NULL;
#ifdef MAXMSP
if ((x = object_alloc(mapper_class))) {
x->outlet3 = listout((t_object *)x);
x->outlet2 = listout((t_object *)x);
x->outlet1 = listout((t_object *)x);
#else
if (x = (impmap *) pd_new(mapper_class) ) {
x->outlet1 = outlet_new(&x->ob, gensym("list"));
x->outlet2 = outlet_new(&x->ob, gensym("list"));
x->outlet3 = outlet_new(&x->ob, gensym("list"));
#endif
x->name = strdup("implicitmap");
for (i = 0; i < argc; i++) {
if ((argv + i)->a_type == A_SYM) {
if(strcmp(maxpd_atom_get_string(argv+i), "@alias") == 0) {
if ((argv+i+1)->a_type == A_SYM) {
alias = maxpd_atom_get_string(argv+i+1);
i++;
}
}
else if(strcmp(maxpd_atom_get_string(argv+i), "@interface") == 0) {
if ((argv+i+1)->a_type == A_SYM) {
iface = maxpd_atom_get_string(argv+i+1);
i++;
}
}
}
}
if (alias) {
free(x->name);
x->name = *alias == '/' ? strdup(alias+1) : strdup(alias);
}
if (impmap_setup_mapper(x, iface)) {
post("implicitmap: Error initializing.");
}
else {
x->ready = 0;
x->mute = 0;
x->new_in = 0;
x->query_count = 0;
x->num_snapshots = 0;
x->snapshots = 0;
// initialize input and output buffers
for (i = 0; i < MAX_LIST; i++) {
maxpd_atom_set_float(x->buffer_in+i, 0);
maxpd_atom_set_float(x->buffer_out+i, 0);
x->signals_in[i].x = x;
x->signals_out[i].x = x;
}
x->size_in = 0;
x->size_out = 0;
#ifdef MAXMSP
x->clock = clock_new(x, (method)impmap_poll); // Create the timing clock
x->timeout = clock_new(x, (method)impmap_output_snapshot);
#else
x->clock = clock_new(x, (t_method)impmap_poll);
x->timeout = clock_new(x, (t_method)impmap_output_snapshot);
#endif
clock_delay(x->clock, INTERVAL); // Set clock to go off after delay
}
}
return (x);
}
// *********************************************************
// -(free)--------------------------------------------------
void impmap_free(impmap *x)
{
if (x->clock) {
clock_unset(x->clock); // Remove clock routine from the scheduler
clock_free(x->clock); // Frees memory used by clock
}
if (x->device) {
mapper_device_free(x->device);
}
if (x->name) {
free(x->name);
}
impmap_clear_snapshots(x);
}
// *********************************************************
// -(print properties)--------------------------------------
void impmap_print_properties(impmap *x)
{
if (x->ready) {
//output name
maxpd_atom_set_string(&x->msg_buffer, mapper_device_name(x->device));
outlet_anything(x->outlet3, gensym("name"), 1, &x->msg_buffer);
mapper_network net = mapper_device_network(x->device);
//output interface
maxpd_atom_set_string(&x->msg_buffer, (char *)mapper_network_interface(net));
outlet_anything(x->outlet3, gensym("interface"), 1, &x->msg_buffer);
//output IP
const struct in_addr *ip = mapper_network_ip4(net);
if (ip) {
maxpd_atom_set_string(&x->msg_buffer, inet_ntoa(*ip));
outlet_anything(x->outlet3, gensym("IP"), 1, &x->msg_buffer);
}
//output port
maxpd_atom_set_int(&x->msg_buffer, mapper_device_port(x->device));
outlet_anything(x->outlet3, gensym("port"), 1, &x->msg_buffer);
//output numInputs
maxpd_atom_set_int(&x->msg_buffer, mapper_device_num_signals(x->device, MAPPER_DIR_INCOMING) - 1);
outlet_anything(x->outlet3, gensym("numInputs"), 1, &x->msg_buffer);
//output numOutputs
maxpd_atom_set_int(&x->msg_buffer, mapper_device_num_signals(x->device, MAPPER_DIR_OUTGOING) - 1);
outlet_anything(x->outlet3, gensym("numOutputs"), 1, &x->msg_buffer);
}
}
// *********************************************************
// -(inlet/outlet assist - maxmsp only)---------------------
#ifdef MAXMSP
void impmap_assist(impmap *x, void *b, long m, long a, char *s)
{
if (m == ASSIST_INLET) { // inlet
sprintf(s, "OSC input");
}
else { // outlet
if (a == 0) {
sprintf(s, "Mapped OSC inputs");
}
else if (a == 1) {
sprintf(s, "Snapshot data");
}
else {
sprintf(s, "Device information");
}
}
}
#endif
// *********************************************************
// -(snapshot)----------------------------------------------
void impmap_snapshot(impmap *x)
{
// if previous snapshot still in progress, output current snapshot status
if (x->query_count) {
post("still waiting for last snapshot");
return;
}
mapper_signal *psig;
x->query_count = 0;
// allocate a new snapshot
if (x->ready) {
t_snapshot new_snapshot = (t_snapshot)malloc(sizeof(t_snapshot));
new_snapshot->id = x->num_snapshots++;
new_snapshot->next = x->snapshots;
new_snapshot->inputs = calloc(x->size_in, sizeof(float));
new_snapshot->outputs = calloc(x->size_out, sizeof(float));
x->snapshots = new_snapshot;
}
// iterate through input signals and store their current values
psig = mapper_device_signals(x->device, MAPPER_DIR_INCOMING);
while (psig) {
if (*psig != x->dummy_input) {
void *value = (void*)mapper_signal_value(*psig, 0);
t_signal_ref *ref = mapper_signal_user_data(*psig);
int siglength = mapper_signal_length(*psig);
int length = ref->offset + siglength < MAX_LIST ? siglength : MAX_LIST - ref->offset;
// we can simply use memcpy here since all our signals are type 'f'
memcpy(&x->snapshots->inputs[ref->offset], value, length * sizeof(float));
}
psig = mapper_signal_query_next(psig);
}
mapper_timetag_now(&x->tt);
mapper_device_start_queue(x->device, x->tt);
// iterate through output signals and query the remote ends
psig = mapper_device_signals(x->device, MAPPER_DIR_OUTGOING);
while (psig) {
if (*psig != x->dummy_output) {
// query the remote value
x->query_count += mapper_signal_query_remotes(*psig, MAPPER_NOW);
}
psig = mapper_signal_query_next(psig);
}
mapper_device_send_queue(x->device, x->tt);
post("sent %i queries", x->query_count);
if (x->query_count)
clock_delay(x->timeout, 1000); // Set clock to go off after delay
}
// *********************************************************
// -(snapshot)----------------------------------------------
void impmap_output_snapshot(impmap *x)
{
if (x->query_count) {
post("query timeout! setting query count to 0 and outputting current values.");
x->query_count = 0;
}
maxpd_atom_set_int(x->buffer_in, x->snapshots->id+1);
outlet_anything(x->outlet3, gensym("numSnapshots"), 1, x->buffer_in);
maxpd_atom_set_float_array(x->buffer_in, x->snapshots->inputs, x->size_in);
outlet_anything(x->outlet2, gensym("in"), x->size_in, x->buffer_in);
maxpd_atom_set_float_array(x->buffer_out, x->snapshots->outputs, x->size_out);
outlet_anything(x->outlet2, gensym("out"), x->size_out, x->buffer_out);
maxpd_atom_set_int(x->buffer_in, x->snapshots->id);
outlet_anything(x->outlet2, gensym("snapshot"), 1, x->buffer_in);
}
// *********************************************************
// -(mute output)-------------------------------------------
void impmap_mute_output(impmap *x, t_symbol *s, int argc, t_atom *argv)
{
if (argc) {
if (argv->a_type == A_FLOAT)
x->mute = (int)atom_getfloat(argv);
#ifdef MAXMSP
else if (argv->a_type == A_LONG)
x->mute = atom_getlong(argv);
#endif
}
}
// *********************************************************
// -(process)-----------------------------------------------
void impmap_process(impmap *x)
{
outlet_anything(x->outlet2, gensym("process"), 0, 0);
}
int main(int argc, char **argv)
{
int i, j, result = 0;
// process flags for -v verbose, -h help
for (i = 1; i < argc; i++) {
if (argv[i] && argv[i][0] == '-') {
int len = strlen(argv[i]);
for (j = 1; j < len; j++) {
switch (argv[i][j]) {
case 'h':
eprintf("testdatabase.c: possible arguments "
"-q quiet (suppress output), "
"-h help\n");
return 1;
break;
case 'q':
verbose = 0;
break;
default:
break;
}
}
}
}
lo_message lom;
mapper_message msg;
uint64_t id = 1;
mapper_network net = mapper_network_new(0, 0, 0);
mapper_database db = &net->database;
mapper_device dev, *pdev, *pdev2;
mapper_signal sig, *psig, *psig2;
mapper_map *pmap, *pmap2;
/* Test the database functions */
lom = lo_message_new();
if (!lom) {
result = 1;
goto done;
}
lo_message_add_string(lom, "@port");
lo_message_add_int32(lom, 1234);
lo_message_add_string(lom, "@host");
lo_message_add_string(lom, "localhost");
lo_message_add_string(lom, "@num_inputs");
lo_message_add_int32(lom, 2);
lo_message_add_string(lom, "@num_outputs");
lo_message_add_int32(lom, 2);
if (!(msg = mapper_message_parse_properties(lo_message_get_argc(lom),
lo_message_get_types(lom),
lo_message_get_argv(lom)))) {
eprintf("1: Error, parsing failed.\n");
result = 1;
goto done;
}
mapper_database_add_or_update_device(db, "testdatabase.1", msg);
mapper_message_free(msg);
lo_message_free(lom);
lom = lo_message_new();
if (!lom) {
result = 1;
goto done;
}
lo_message_add_string(lom, "@port");
lo_message_add_int32(lom, 1234);
lo_message_add_string(lom, "@host");
lo_message_add_string(lom, "localhost");
lo_message_add_string(lom, "@num_inputs");
lo_message_add_int32(lom, 2);
lo_message_add_string(lom, "@num_outputs");
lo_message_add_int32(lom, 1);
if (!(msg = mapper_message_parse_properties(lo_message_get_argc(lom),
lo_message_get_types(lom),
lo_message_get_argv(lom)))) {
eprintf("1: Error, parsing failed.\n");
result = 1;
goto done;
}
mapper_database_add_or_update_device(db, "testdatabase__.2", msg);
mapper_message_free(msg);
lo_message_free(lom);
lom = lo_message_new();
if (!lom) {
result = 1;
goto done;
}
lo_message_add_string(lom, "@port");
lo_message_add_int32(lom, 3000);
lo_message_add_string(lom, "@host");
lo_message_add_string(lom, "192.168.0.100");
if (!(msg = mapper_message_parse_properties(lo_message_get_argc(lom),
lo_message_get_types(lom),
lo_message_get_argv(lom)))) {
eprintf("1: Error, parsing failed.\n");
result = 1;
goto done;
}
mapper_database_add_or_update_device(db, "testdatabase.3", msg);
mapper_message_free(msg);
lo_message_free(lom);
lom = lo_message_new();
if (!lom) {
result = 1;
goto done;
}
lo_message_add_string(lom, "@port");
lo_message_add_int32(lom, 5678);
lo_message_add_string(lom, "@host");
lo_message_add_string(lom, "192.168.0.100");
if (!(msg = mapper_message_parse_properties(lo_message_get_argc(lom),
lo_message_get_types(lom),
lo_message_get_argv(lom)))) {
eprintf("1: Error, parsing failed.\n");
result = 1;
goto done;
}
mapper_database_add_or_update_device(db, "testdatabase__.4", msg);
mapper_message_free(msg);
lo_message_free(lom);
lom = lo_message_new();
if (!lom) {
result = 1;
goto done;
}
lo_message_add_string(lom, "@direction");
lo_message_add_string(lom, "input");
lo_message_add_string(lom, "@type");
lo_message_add_char(lom, 'f');
lo_message_add_string(lom, "@id");
lo_message_add_int64(lom, id);
if (!(msg = mapper_message_parse_properties(lo_message_get_argc(lom),
lo_message_get_types(lom),
lo_message_get_argv(lom)))) {
eprintf("1: Error, parsing failed.\n");
result = 1;
goto done;
}
mapper_database_add_or_update_signal(db, "in1", "testdatabase.1", msg);
mapper_message_free(msg);
lo_message_free(lom);
lom = lo_message_new();
if (!lom) {
result = 1;
goto done;
}
id++;
lo_message_add_string(lom, "@direction");
lo_message_add_string(lom, "input");
lo_message_add_string(lom, "@type");
lo_message_add_char(lom, 'f');
lo_message_add_string(lom, "@id");
lo_message_add_int64(lom, id);
if (!(msg = mapper_message_parse_properties(lo_message_get_argc(lom),
lo_message_get_types(lom),
lo_message_get_argv(lom)))) {
eprintf("1: Error, parsing failed.\n");
result = 1;
goto done;
}
mapper_database_add_or_update_signal(db, "in2", "testdatabase.1", msg);
mapper_message_free(msg);
lo_message_free(lom);
lom = lo_message_new();
if (!lom) {
result = 1;
goto done;
}
id++;
lo_message_add_string(lom, "@direction");
lo_message_add_string(lom, "output");
lo_message_add_string(lom, "@type");
lo_message_add_char(lom, 'f');
lo_message_add_string(lom, "@id");
lo_message_add_int64(lom, id);
if (!(msg = mapper_message_parse_properties(lo_message_get_argc(lom),
lo_message_get_types(lom),
lo_message_get_argv(lom)))) {
eprintf("1: Error, parsing failed.\n");
result = 1;
goto done;
}
mapper_database_add_or_update_signal(db, "out1", "testdatabase.1", msg);
mapper_message_free(msg);
lo_message_free(lom);
lom = lo_message_new();
if (!lom) {
result = 1;
goto done;
}
id++;
lo_message_add_string(lom, "@direction");
lo_message_add_string(lom, "output");
lo_message_add_string(lom, "@type");
lo_message_add_char(lom, 'f');
lo_message_add_string(lom, "@id");
lo_message_add_int64(lom, id);
if (!(msg = mapper_message_parse_properties(lo_message_get_argc(lom),
lo_message_get_types(lom),
lo_message_get_argv(lom)))) {
eprintf("1: Error, parsing failed.\n");
result = 1;
goto done;
}
mapper_database_add_or_update_signal(db, "out2", "testdatabase.1", msg);
mapper_message_free(msg);
lo_message_free(lom);
lom = lo_message_new();
if (!lom) {
result = 1;
goto done;
}
id++;
lo_message_add_string(lom, "@direction");
lo_message_add_string(lom, "output");
lo_message_add_string(lom, "@type");
lo_message_add_char(lom, 'f');
lo_message_add_string(lom, "@id");
lo_message_add_int64(lom, id);
if (!(msg = mapper_message_parse_properties(lo_message_get_argc(lom),
lo_message_get_types(lom),
lo_message_get_argv(lom)))) {
eprintf("1: Error, parsing failed.\n");
result = 1;
goto done;
}
mapper_database_add_or_update_signal(db, "out1", "testdatabase__.2", msg);
mapper_message_free(msg);
lo_message_free(lom);
lom = lo_message_new();
if (!lom) {
result = 1;
goto done;
}
id++;
lo_message_add_string(lom, "@mode");
lo_message_add_string(lom, "bypass");
lo_message_add_string(lom, "@dst@bound_min");
lo_message_add_string(lom, "none");
lo_message_add_string(lom, "@id");
lo_message_add_int64(lom, id);
if (!(msg = mapper_message_parse_properties(lo_message_get_argc(lom),
lo_message_get_types(lom),
lo_message_get_argv(lom)))) {
eprintf("1: Error, parsing failed.\n");
result = 1;
goto done;
}
const char *src_sig_name = "testdatabase.1/out2";
mapper_database_add_or_update_map(db, 1, &src_sig_name,
"testdatabase__.2/in1", msg);
mapper_message_free(msg);
lo_message_free(lom);
lom = lo_message_new();
if (!lom) {
result = 1;
goto done;
}
id++;
lo_message_add_string(lom, "@mode");
lo_message_add_string(lom, "bypass");
lo_message_add_string(lom, "@dst@bound_min");
lo_message_add_string(lom, "none");
lo_message_add_string(lom, "@id");
lo_message_add_int64(lom, id);
if (!(msg = mapper_message_parse_properties(lo_message_get_argc(lom),
lo_message_get_types(lom),
lo_message_get_argv(lom)))) {
eprintf("1: Error, parsing failed.\n");
result = 1;
goto done;
}
src_sig_name = "testdatabase__.2/out1";
mapper_database_add_or_update_map(db, 1, &src_sig_name,
"testdatabase.1/in1", msg);
mapper_message_free(msg);
lo_message_free(lom);
lom = lo_message_new();
if (!lom) {
result = 1;
goto done;
}
id++;
lo_message_add_string(lom, "@mode");
lo_message_add_string(lom, "expression");
lo_message_add_string(lom, "@expression");
lo_message_add_string(lom, "(x-10)*80");
lo_message_add_string(lom, "@dst@bound_min");
lo_message_add_string(lom, "clamp");
lo_message_add_string(lom, "@src@min");
lo_message_add_float(lom, 0.f);
lo_message_add_float(lom, 1.f);
lo_message_add_string(lom, "@src@max");
lo_message_add_float(lom, 1.f);
lo_message_add_float(lom, 2.f);
lo_message_add_string(lom, "@id");
lo_message_add_int64(lom, id);
if (!(msg = mapper_message_parse_properties(lo_message_get_argc(lom),
lo_message_get_types(lom),
lo_message_get_argv(lom)))) {
eprintf("1: Error, parsing failed.\n");
result = 1;
goto done;
}
src_sig_name = "testdatabase.1/out1";
mapper_database_add_or_update_map(db, 1, &src_sig_name,
"testdatabase__.2/in2", msg);
mapper_message_free(msg);
lo_message_free(lom);
lom = lo_message_new();
if (!lom) {
result = 1;
goto done;
}
id++;
lo_message_add_string(lom, "@mode");
lo_message_add_string(lom, "expression");
lo_message_add_string(lom, "@expression");
lo_message_add_string(lom, "(x-10)*80");
lo_message_add_string(lom, "@dst@bound_min");
lo_message_add_string(lom, "clamp");
lo_message_add_string(lom, "@src@min");
lo_message_add_float(lom, 0.f);
lo_message_add_float(lom, 1.f);
lo_message_add_string(lom, "@src@max");
lo_message_add_float(lom, 1.f);
lo_message_add_float(lom, 2.f);
lo_message_add_string(lom, "@id");
lo_message_add_int64(lom, id);
if (!(msg = mapper_message_parse_properties(lo_message_get_argc(lom),
lo_message_get_types(lom),
lo_message_get_argv(lom)))) {
eprintf("1: Error, parsing failed.\n");
result = 1;
goto done;
}
src_sig_name = "testdatabase.1/out1";
mapper_database_add_or_update_map(db, 1, &src_sig_name,
"testdatabase__.2/in1", msg);
mapper_message_free(msg);
lo_message_free(lom);
/*********/
if (verbose) {
eprintf("Dump:\n");
mapper_database_print(db);
}
/*********/
eprintf("\n--- Devices ---\n");
eprintf("\nWalk the whole database:\n");
pdev = mapper_database_devices(db);
int count=0;
if (!pdev) {
eprintf("mapper_database_devices() returned 0.\n");
result = 1;
goto done;
}
if (!*pdev) {
eprintf("mapper_database_devices() returned something "
"which pointed to 0.\n");
result = 1;
goto done;
}
while (pdev) {
count ++;
printdevice(*pdev);
pdev = mapper_device_query_next(pdev);
}
if (count != 4) {
eprintf("Expected 4 records, but counted %d.\n", count);
result = 1;
goto done;
}
/*********/
eprintf("\nFind device named 'testdatabase.3':\n");
dev = mapper_database_device_by_name(db, "testdatabase.3");
if (!dev) {
eprintf("Not found.\n");
result = 1;
goto done;
}
printdevice(dev);
/*********/
eprintf("\nFind device named 'dummy':\n");
dev = mapper_database_device_by_name(db, "dummy");
if (dev) {
eprintf("unexpected found 'dummy': %p\n", dev);
result = 1;
goto done;
}
eprintf(" not found, good.\n");
/*********/
eprintf("\nFind devices matching '__':\n");
pdev = mapper_database_devices_by_name(db, "*__*");
count=0;
if (!pdev) {
eprintf("mapper_database_devices_by_name() returned 0.\n");
result = 1;
goto done;
}
if (!*pdev) {
eprintf("mapper_database_devices_by_name() returned something "
"which pointed to 0.\n");
result = 1;
goto done;
}
while (pdev) {
count ++;
printdevice(*pdev);
pdev = mapper_device_query_next(pdev);
}
if (count != 2) {
eprintf("Expected 2 records, but counted %d.\n", count);
result = 1;
goto done;
}
/*********/
eprintf("\nFind devices with property 'host'=='192.168.0.100':\n");
pdev = mapper_database_devices_by_property(db, "host", 1, 's',
"192.168.0.100", MAPPER_OP_EQUAL);
count=0;
if (!pdev) {
eprintf("mapper_database_devices_by_property() returned 0.\n");
result = 1;
goto done;
}
if (!*pdev) {
eprintf("mapper_database_devices_by_property() returned something "
"which pointed to 0.\n");
result = 1;
goto done;
}
while (pdev) {
count ++;
printdevice(*pdev);
pdev = mapper_device_query_next(pdev);
}
if (count != 2) {
eprintf("Expected 2 records, but counted %d.\n", count);
result = 1;
goto done;
}
/*********/
eprintf("\nFind devices with property 'port'<5678:\n");
int port = 5678;
pdev = mapper_database_devices_by_property(db, "port", 1, 'i', &port,
MAPPER_OP_LESS_THAN);
count=0;
if (!pdev) {
eprintf("mapper_database_devices_by_property() returned 0.\n");
result = 1;
goto done;
}
if (!*pdev) {
eprintf("mapper_database_devices_by_property() returned something "
"which pointed to 0.\n");
result = 1;
goto done;
}
while (pdev) {
count ++;
printdevice(*pdev);
pdev = mapper_device_query_next(pdev);
}
if (count != 3) {
eprintf("Expected 3 records, but counted %d.\n", count);
result = 1;
goto done;
}
/*********/
eprintf("\nFind devices with property 'num_outputs'==2:\n");
int temp = 2;
pdev = mapper_database_devices_by_property(db, "num_outputs", 1, 'i', &temp,
MAPPER_OP_EQUAL);
count=0;
if (!pdev) {
eprintf("mapper_database_devices_by_property() returned 0.\n");
result = 1;
goto done;
}
if (!*pdev) {
eprintf("mapper_database_devices_by_property() returned something "
"which pointed to 0.\n");
result = 1;
goto done;
}
while (pdev) {
count ++;
printdevice(*pdev);
pdev = mapper_device_query_next(pdev);
}
if (count != 1) {
eprintf("Expected 1 records, but counted %d.\n", count);
result = 1;
goto done;
}
/*********/
eprintf("\nFind devices with properties 'host'!='localhost' AND 'port'>=4000:\n");
pdev = mapper_database_devices_by_property(db, "host", 1, 's', "localhost",
MAPPER_OP_NOT_EQUAL);
pdev2 = mapper_database_devices_by_property(db, "port", 1, 'i', &port,
MAPPER_OP_GREATER_THAN_OR_EQUAL);
pdev = mapper_device_query_intersection(pdev, pdev2);
count=0;
if (!pdev) {
eprintf("mapper_database_devices_by_property() returned 0.\n");
result = 1;
goto done;
}
if (!*pdev) {
eprintf("mapper_database_devices_by_property() returned something "
"which pointed to 0.\n");
result = 1;
goto done;
}
while (pdev) {
count ++;
printdevice(*pdev);
pdev = mapper_device_query_next(pdev);
}
if (count != 1) {
eprintf("Expected 1 record, but counted %d.\n", count);
result = 1;
goto done;
}
/*********/
eprintf("\n--- Signals ---\n");
eprintf("\nFind all signals for device 'testdatabase.1':\n");
dev = mapper_database_device_by_name(db, "testdatabase.1");
psig = mapper_device_signals(dev, MAPPER_DIR_ANY);
count=0;
if (!psig) {
eprintf("mapper_device_signals() returned 0.\n");
result = 1;
goto done;
}
if (!*psig) {
eprintf("mapper_device_signals() returned something "
"which pointed to 0.\n");
result = 1;
goto done;
}
while (psig) {
count ++;
printsignal(*psig);
psig = mapper_signal_query_next(psig);
}
if (count != 4) {
eprintf("Expected 4 records, but counted %d.\n", count);
result = 1;
goto done;
}
/*********/
eprintf("\nFind all signals for device 'testdatabase__xx.2':\n");
dev = mapper_database_device_by_name(db, "testdatabase__xx.2");
psig = mapper_device_signals(dev, MAPPER_DIR_ANY);
count=0;
if (psig) {
eprintf("mapper_device_signals() incorrectly found something.\n");
printsignal(*psig);
mapper_signal_query_done(psig);
result = 1;
goto done;
}
else
eprintf(" correctly returned 0.\n");
/*********/
eprintf("\nFind all outputs for device 'testdatabase__.2':\n");
dev = mapper_database_device_by_name(db, "testdatabase__.2");
psig = mapper_device_signals(dev, MAPPER_DIR_ANY);
count=0;
if (!psig) {
eprintf("mapper_device_signals() returned 0.\n");
result = 1;
goto done;
}
if (!*psig) {
eprintf("mapper_device_signals() returned something "
"which pointed to 0.\n");
result = 1;
goto done;
}
while (psig) {
count ++;
printsignal(*psig);
psig = mapper_signal_query_next(psig);
}
if (count != 3) {
eprintf("Expected 3 records, but counted %d.\n", count);
result = 1;
goto done;
}
/*********/
eprintf("\nFind signal matching 'in' for device 'testdatabase.1':\n");
dev = mapper_database_device_by_name(db, "testdatabase.1");
psig = mapper_device_signals(dev, MAPPER_DIR_ANY);
psig2 = mapper_database_signals_by_name(db, "*in*");
psig = mapper_signal_query_intersection(psig, psig2);
count=0;
if (!psig) {
eprintf("intersection of mapper_device_signals() and "
"mapper_database_signals_by_name() returned 0.\n");
result = 1;
goto done;
}
if (!*psig) {
eprintf("intersection of mapper_device_signals() and "
"mapper_database_signals_by_name() returned something "
"which pointed to 0.\n");
result = 1;
goto done;
}
while (psig) {
count ++;
printsignal(*psig);
psig = mapper_signal_query_next(psig);
}
if (count != 2) {
eprintf("Expected 2 records, but counted %d.\n", count);
result = 1;
goto done;
}
/*********/
eprintf("\nFind signal matching 'out' for device 'testdatabase.1':\n");
dev = mapper_database_device_by_name(db, "testdatabase.1");
psig = mapper_device_signals(dev, MAPPER_DIR_ANY);
psig2 = mapper_database_signals_by_name(db, "*out*");
psig = mapper_signal_query_intersection(psig, psig2);
count=0;
if (!psig) {
eprintf("intersection of mapper_device_signals() and "
"mapper_database_signals_by_name() returned 0.\n");
result = 1;
goto done;
}
if (!*psig) {
eprintf("intersection of mapper_device_signals() and "
"mapper_database_signals_by_name() returned something "
"which pointed to 0.\n");
result = 1;
goto done;
}
while (psig) {
count ++;
printsignal(*psig);
psig = mapper_signal_query_next(psig);
}
if (count != 2) {
eprintf("Expected 2 records, but counted %d.\n", count);
result = 1;
goto done;
}
/*********/
eprintf("\nFind signal matching 'out' for device 'testdatabase__.2':\n");
dev = mapper_database_device_by_name(db, "testdatabase__.2");
psig = mapper_device_signals(dev, MAPPER_DIR_ANY);
psig2 = mapper_database_signals_by_name(db, "*out*");
psig = mapper_signal_query_intersection(psig, psig2);
count=0;
if (!psig) {
eprintf("intersection of mapper_device_signals() and "
"mapper_database_signals_by_name() returned 0.\n");
result = 1;
goto done;
}
if (!*psig) {
eprintf("intersection of mapper_device_signals() and "
"mapper_database_signals_by_name() returned something "
"which pointed to 0.\n");
result = 1;
goto done;
}
while (psig) {
count ++;
printsignal(*psig);
psig = mapper_signal_query_next(psig);
}
if (count != 1) {
eprintf("Expected 1 record, but counted %d.\n", count);
result = 1;
goto done;
}
/*********/
eprintf("\n--- maps ---\n");
eprintf("\nFind maps with source 'out1':\n");
psig = mapper_database_signals_by_name(db, "out1");
pmap = 0;
while (psig) {
pmap2 = mapper_signal_maps(*psig, MAPPER_DIR_OUTGOING);
pmap = mapper_map_query_union(pmap, pmap2);
psig = mapper_signal_query_next(psig);
}
count=0;
if (!pmap) {
eprintf("combined query returned 0.\n");
result = 1;
goto done;
}
if (!*pmap) {
eprintf("combined query returned something which pointed to 0.\n");
result = 1;
goto done;
}
while (pmap) {
count ++;
printmap(*pmap);
pmap = mapper_map_query_next(pmap);
}
if (count != 3) {
eprintf("Expected 3 records, but counted %d.\n", count);
result = 1;
goto done;
}
/*********/
eprintf("\nFind maps for device 'testdatabase.1', source 'out1':\n");
dev = mapper_database_device_by_name(db, "testdatabase.1");
sig = mapper_device_signal_by_name(dev, "out1");
pmap = mapper_signal_maps(sig, 0);
count=0;
if (!pmap) {
eprintf("mapper_signal_maps() returned 0.\n");
result = 1;
goto done;
}
if (!*pmap) {
eprintf("mapper_signal_maps() returned something which pointed to 0.\n");
result = 1;
goto done;
}
while (pmap) {
count ++;
printmap(*pmap);
pmap = mapper_map_query_next(pmap);
}
if (count != 2) {
eprintf("Expected 2 records, but counted %d.\n", count);
result = 1;
goto done;
}
/*********/
eprintf("\nFind maps with destination signal named 'in2':\n");
psig = mapper_database_signals_by_name(db, "in2");
pmap = 0;
while (psig) {
pmap2 = mapper_signal_maps(*psig, MAPPER_DIR_INCOMING);
pmap = mapper_map_query_union(pmap, pmap2);
psig = mapper_signal_query_next(psig);
}
count=0;
if (!pmap) {
eprintf("combined query returned 0.\n");
result = 1;
goto done;
}
if (!*pmap) {
eprintf("combined query returned something which pointed to 0.\n");
result = 1;
goto done;
}
while (pmap) {
count ++;
printmap(*pmap);
pmap = mapper_map_query_next(pmap);
}
if (count != 1) {
eprintf("Expected 1 record, but counted %d.\n", count);
result = 1;
goto done;
}
/*********/
eprintf("\nFind maps for device 'testdatabase__.2', destination 'in1':\n");
dev = mapper_database_device_by_name(db, "testdatabase__.2");
sig = mapper_device_signal_by_name(dev, "in1");
pmap = mapper_signal_maps(sig, MAPPER_DIR_INCOMING);
count=0;
if (!pmap) {
eprintf("mapper_signal_maps() returned 0.\n");
result = 1;
goto done;
}
if (!*pmap) {
eprintf("mapper_signal_maps() returned something which pointed to 0.\n");
result = 1;
goto done;
}
while (pmap) {
count ++;
printmap(*pmap);
pmap = mapper_map_query_next(pmap);
}
if (count != 2) {
eprintf("Expected 2 records, but counted %d.\n", count);
result = 1;
goto done;
}
/*********/
eprintf("\nFind maps for source device 'testdatabase__.2', signal 'out1'"
"\n AND dest device 'testdatabase.1', signal 'in1':\n");
// get maps with source signal
dev = mapper_database_device_by_name(db, "testdatabase__.2");
sig = mapper_device_signal_by_name(dev, "out1");
pmap = mapper_signal_maps(sig, MAPPER_DIR_OUTGOING);
// get maps with destination signal
dev = mapper_database_device_by_name(db, "testdatabase.1");
sig = mapper_device_signal_by_name(dev, "in1");
pmap2 = mapper_signal_maps(sig, MAPPER_DIR_INCOMING);
// intersect map queries
pmap = mapper_map_query_intersection(pmap, pmap2);
count=0;
if (!pmap) {
eprintf("combined query returned 0.\n");
result = 1;
goto done;
}
if (!*pmap) {
eprintf("combined query returned something which pointed to 0.\n");
result = 1;
goto done;
}
while (pmap) {
count ++;
printmap(*pmap);
pmap = mapper_map_query_next(pmap);
}
if (count != 1) {
eprintf("Expected 1 records, but counted %d.\n", count);
result = 1;
goto done;
}
/*********/
eprintf("\nFind maps for source device 'testdatabase__.2', signals matching 'out',"
"\n AND dest device 'testdatabase.1', all signals:\n");
// build source query
dev = mapper_database_device_by_name(db, "testdatabase__.2");
psig = mapper_device_signals(dev, MAPPER_DIR_ANY);
psig2 = mapper_database_signals_by_name(db, "*out*");
psig = mapper_signal_query_intersection(psig, psig2);
pmap = 0;
while (psig) {
pmap2 = mapper_signal_maps(*psig, MAPPER_DIR_OUTGOING);
pmap = mapper_map_query_union(pmap, pmap2);
psig = mapper_signal_query_next(psig);
}
// build destination query
dev = mapper_database_device_by_name(db, "testdatabase.1");
pmap2 = mapper_device_maps(dev, MAPPER_DIR_ANY);
// intersect queries
pmap = mapper_map_query_intersection(pmap, pmap2);
count=0;
if (!pmap) {
eprintf("combined query returned 0.\n");
result = 1;
goto done;
}
if (!*pmap) {
eprintf("combined query returned something which pointed to 0.\n");
result = 1;
goto done;
}
while (pmap) {
count ++;
printmap(*pmap);
pmap = mapper_map_query_next(pmap);
}
if (count != 1) {
eprintf("Expected 1 record, but counted %d.\n", count);
result = 1;
goto done;
}
/*********/
done:
mapper_network_free(net);
if (!verbose)
printf("..................................................");
printf("Test %s.\n", result ? "FAILED" : "PASSED");
return result;
}
