void Reading::clear() {
mapped = false;
deleted = false;
noprint = false;
matched_target = false;
matched_tests = false;
immutable = false;
baseform = 0;
hash = 0;
hash_plain = 0;
number = 0;
tags_bloom.clear();
tags_plain_bloom.clear();
tags_textual_bloom.clear();
mapping = 0;
parent = 0;
free_reading(next);
next = 0;
hit_by.clear();
tags_list.clear();
tags.clear();
tags_plain.clear();
tags_textual.clear();
tags_numerical.clear();
tags_string.clear();
tags_string_hash = 0;
}
void Cohort::clear() {
if (parent) {
parent->parent->cohort_map.erase(global_number);
parent->parent->dep_window.erase(global_number);
}
detach();
type = 0;
global_number = 0;
local_number = 0;
wordform = 0;
dep_self = 0;
dep_parent = std::numeric_limits<uint32_t>::max();
is_pleft = 0;
is_pright = 0;
parent = 0;
text.clear();
num_max.clear();
num_min.clear();
dep_children.clear();
possible_sets.clear();
relations.clear();
relations_input.clear();
foreach (iter1, readings) {
free_reading(*iter1);
}
/**
* \brief initialise new reading struct
*/
int reading_init(struct reading **r_p) {
struct reading *r;
if (!(r = calloc(1, sizeof(struct reading)))) {
log_stderr(LOG_ERROR, "Readings: Out of memory");
goto free;
}
r->count = 0;
*r_p = r;
return SS_SUCCESS;
free:
free_reading(r);
return SS_OUT_OF_MEM_ERROR;
}
foreach (iter3, delayed) {
free_reading(*iter3);
}
foreach (iter2, deleted) {
free_reading(*iter2);
}
int main(int argc, char **argv) {
int ret;
int c, option_index = 0;
/* select variables */
fd_set read_fds;
int nfds = 0;
/* mqtt variables */
char topic[MAX_TOPIC_LEN] = MQTT_DEFAULT_TOPIC;
char broker_ip[16] = MQTT_BROKER_IP;
int broker_port = MQTT_BROKER_PORT;
char clientid[UMQTT_CLIENTID_MAX_LEN] = "\0";
uint8_t retain = 0;
char msg[MAX_MSG_LEN] = "\0";
size_t len = MAX_MSG_LEN;
struct broker_conn *conn;
struct mqtt_packet *pkt = NULL;
/* reading variables */
struct reading *r = NULL;
ret = reading_init(&r);
if (ret) {
return -1;
}
/* set reading date to now */
time_t t = time(0);
/* Reading sensor id remaps */
struct sensor_remaps rmaps;
rmaps.count = 0;
char *rmap_buf[64];
/* tty variables */
char buf[RX_BUF_LEN];
size_t buf_len = RX_BUF_LEN;
device_type_t type = RAW_DEV;
struct tty_conn *tty;
ret = tty_conn_init(&tty);
if (ret) {
free_reading(r);
return -1;
}
/* set TTY defaults */
strcpy(tty->path, DEFAULT_TTY_DEV);
tty->baud = DEFAULT_TTY_BAUD;
static struct option long_options[] =
{
/* These options set a flag. */
{"help", no_argument, 0, 'h'},
{"verbose", required_argument, 0, 'v'},
{"type", required_argument, 0, 'T'},
{"device_id", required_argument, 0, 'd'},
{"sensor_id", required_argument, 0, 's'},
{"json", no_argument, 0, 'j'},
{"ini", no_argument, 0, 'i'},
{"remap", required_argument, 0, 'R'},
{"retain", no_argument, 0, 'r'},
{"tty-dev", required_argument, 0, 'D'},
{"baud", required_argument, 0, 'B'},
{"topic", required_argument, 0, 't'},
{"broker", required_argument, 0, 'b'},
{"port", required_argument, 0, 'p'},
{"clientid", required_argument, 0, 'c'},
{0, 0, 0, 0}
};
/* get arguments */
while (1)
{
if ((c = getopt_long(argc, argv, "hv:s:d:T:D:B:jirt:b:p:c:R:",
long_options, &option_index)) != -1) {
switch (c) {
case 'h':
return print_usage();
case 'v':
/* set log level */
if (optarg) {
set_log_level_str(optarg);
}
break;
case 'r':
/* set retain flag */
retain = 1;
break;
case 't':
/* Set topic */
if (optarg) {
strcpy(topic, optarg);
} else {
log_stderr(LOG_ERROR,
"The topic flag should be followed by a topic");
return print_usage();
}
break;
case 'T':
/* Set the device type */
if (optarg) {
if (strstr(optarg, CC_DEVICE_STR)) {
type = CURRENT_COST_DEV;
} else if (strstr(optarg, FLOW_DEVICE_STR)) {
type = FLOW_DEV;
} else {
/* default */
type = RAW_DEV;
}
} else {
log_stderr(LOG_ERROR,
"The device type flag should be followed by a device type");
return print_usage();
}
break;
case 'R':
/* Remap a devices sensor id with another sensor id */
if (optarg) {
strcpy((char *)rmap_buf, optarg);
rmaps.id[rmaps.count] = atoi((char *)rmap_buf);
rmaps.rmap_id[rmaps.count] =
atoi(strchr((char *)rmap_buf, ':') + 1);
log_stdout(LOG_INFO, "Remapping sensor ID: %d to %d",
rmaps.id[rmaps.count], rmaps.rmap_id[rmaps.count]);
rmaps.count++;
} else {
log_stderr(LOG_ERROR,
"The remap flag should be followed by two sensor IDs");
return print_usage();
}
break;
case 'D':
/* Set the TTY device file */
if (optarg) {
strcpy(tty->path, optarg);
} else {
log_stderr(LOG_ERROR,
"The device flag should be followed by a tty device");
return print_usage();
}
break;
case 'B':
/* Set the device file */
if (optarg) {
tty->baud = atoi(optarg);
} else {
log_stderr(LOG_ERROR,
"The baud rate flag should be followed by a baud rate");
return print_usage();
}
break;
case 'd':
/* Set a device_id */
if (optarg) {
r->device_id = atoi(optarg);
} else {
log_stderr(LOG_ERROR,
"The device_id flag should be followed by a device_id");
return print_usage();
}
break;
case 's':
/* Set a sensor_id */
if (optarg && r->count) {
r->meas[r->count - 1]->sensor_id = atoi(optarg);
} else {
log_stderr(LOG_ERROR,
"The sensor_id flag should follow a measurement flag, and"
" should be followed by a sensor_id");
return print_usage();
}
break;
case 'b':
/* Change the default broker ip */
if (optarg) {
strcpy(broker_ip, optarg);
} else {
log_stderr(LOG_ERROR,
"The broker flag should be followed by an IP address");
return print_usage();
}
break;
case 'p':
/* change the default port */
if (optarg) {
broker_port = *optarg;
} else {
log_stderr(LOG_ERROR,
"The port flag should be followed by a port");
return print_usage();
}
break;
case 'c':
/* Set clientid */
if (optarg) {
strcpy(clientid, optarg);
} else {
log_stderr(LOG_ERROR,
"The clientid flag should be followed by a clientid");
return print_usage();
}
break;
}
} else {
/* Final arguement */
break;
}
}
/* init connections */
log_stdout(LOG_INFO, "Initialising broker socket connection");
init_linux_socket_connection(&conn, broker_ip, sizeof(broker_ip), broker_port);
if (!conn) {
log_stdout(LOG_ERROR, "Initialising socket connection");
return -1;
}
if (clientid[0]) {
broker_set_clientid(conn, clientid, sizeof(clientid));
}
log_stdout(LOG_INFO, "Connecting to broker");
struct linux_broker_socket *skt = '\0';
if ((ret = broker_connect(conn))) {
log_stderr(LOG_ERROR, "Connecting to broker");
free_connection(conn);
return ret;
} else {
skt = (struct linux_broker_socket *)conn->context;
log_stdout(LOG_INFO,
"Connected to broker:\nip: %s port: %d", skt->ip, skt->port);
}
/* test tty config */
log_stdout(LOG_INFO, "TTY device: %s, baud: %d", tty->path, tty->baud);
if (tty_conn_check_config(tty)) {
log_stdout(LOG_ERROR, "Testing TTY device config");
return -1;
}
/* Open tty device */
ret = tty_conn_open(tty);
if (ret) {
log_stderr(LOG_ERROR, "Opening TTY device");
free_connection(conn);
free_tty_conn(tty);
return ret;
}
/* wait for data - main program loop */
while (1) {
/* select init */
FD_ZERO(&read_fds);
nfds = ((tty->fd > skt->sockfd) ? tty->fd : skt->sockfd) + 1;
FD_SET(tty->fd, &read_fds);
FD_SET(skt->sockfd, &read_fds);
ret = select(nfds, &read_fds, NULL, NULL, NULL);
if (ret == -1) {
if (errno == EINTR) {
log_stderr(LOG_ERROR, "Select: %s: %s", tty->path, strerror(errno));
continue;
}
log_stderr(LOG_ERROR, "Select failed: %s: %s", tty->path,
strerror(errno));
continue;
} else if (!ret) {
/* should never get here since disabled timeout */
log_stdout(LOG_DEBUG, "select timed out");
}
/* Determine if any fds are ready */
if (FD_ISSET(tty->fd, &read_fds)) {
/* packet border */
log_stdout(LOG_INFO,
"------------------------------------------------------------");
/* set reading time to now */
t = time(0);
localtime_r(&t, &r->t);
buf_len = RX_BUF_LEN;
ret = tty_conn_read(tty, (char *)&buf, &buf_len);
if (ret && ret != SS_CONTINUE) {
log_stderr(LOG_ERROR, "Read: %d:%s", errno, strerror(errno));
break;
} else if (ret == SS_CONTINUE) {
continue;
} else if (buf_len) {
/* process tty data */
log_stdout(LOG_INFO, "Processing received data");
if (CURRENT_COST_DEV == type) {
ret = process_cc_buffer(buf, &buf_len);
if (ret == SS_CONTINUE) {
log_stdout(LOG_INFO, "No data available");
continue;
}
/* process reading */
free_measurements(r);
ret = convert_cc_dev_reading(r, buf, buf_len);
if (ret) {
log_stderr(LOG_ERROR, "failed to decode output");
continue;
}
remap_reading_sensor_ids(r, &rmaps);
log_stdout(LOG_INFO, "Received new reading:");
print_reading(r);
} else if (FLOW_DEV == type) {
/* not currently supported */
} else if (RAW_DEV == type) {
/* Simply copy buffer to message payload */
memcpy((void *)msg, (void *)buf, (buf_len < len ? buf_len : len));
log_stdout(LOG_INFO, "RAW payload ready");
}
if (type != RAW_DEV) {
/* process message */
log_stdout(LOG_INFO, "Processing reading");
ret = convert_reading_json(r, msg, &len);
if (ret) {
log_stderr(LOG_ERROR, "failed to encode reading into JSON");
continue;
}
}
} else if (FD_ISSET(skt->sockfd, &read_fds)) {
/* process MQTT input */
/* need to test this to ensure packets are processed upon recipt */
ret = read_socket_packet(conn, pkt);
if (ret) {
log_stderr(LOG_ERROR, "failed to process packet input");
continue;
}
}
/* Process output MQTT packet is fall through case */
/* Create publish packet on new data */
pkt = construct_packet_headers(PUBLISH);
if (!pkt ||
(ret = set_publish_variable_header(pkt, topic, strlen(topic)))) {
log_stderr(LOG_ERROR, "Setting up packet");
ret = UMQTT_ERROR;
goto free;
}
ret = set_publish_fixed_flags(pkt, retain, 0, 0);
if (ret) {
log_stderr(LOG_ERROR, "Setting publish flags");
ret = UMQTT_ERROR;
goto free;
}
ret = init_packet_payload(pkt, PUBLISH, (uint8_t *)msg, strlen(msg));
if (ret) {
log_stderr(LOG_ERROR, "Attaching payload");
ret = UMQTT_ERROR;
goto free;
}
finalise_packet(pkt);
log_stdout(LOG_INFO, "Constructed MQTT PUBLISH packet:");
log_stdout(LOG_INFO, "Topic: %s", topic);
log_stdout(LOG_INFO, "Message: %s", msg);
/* Send packet */
ret = broker_send_packet(conn, pkt);
if (ret) {
log_stderr(LOG_ERROR, "Sending packet failed");
} else {
log_stdout(LOG_INFO, "Successfully sent packet to broker");
}
free_packet(pkt);
buf_len = RX_BUF_LEN;
}
}
free:
log_stdout(LOG_INFO, "Disconnecting from broker");
broker_disconnect(conn);
free_reading(r);
close_tty_conn(tty);
free_tty_conn(tty);
free_connection(conn);
free_packet(pkt);
return ret;
}
std::vector<Cohort*> MweSplitApplicator::splitMwe(Cohort* cohort) {
constexpr UChar rtrimblank[] = { ' ', '\n', '\r', '\t', 0 };
constexpr UChar textprefix[] = { ':', 0 };
std::vector<Cohort*> cos;
size_t n_wftags = 0;
size_t n_goodreadings = 0;
for (auto rter1 : cohort->readings) {
if (maybeWfTag(rter1) != NULL) {
++n_wftags;
}
++n_goodreadings;
}
if (n_wftags < n_goodreadings) {
if (n_wftags > 0) {
u_fprintf(ux_stderr, "WARNING: Line %u: Some but not all main-readings of %S had wordform-tags (not completely mwe-disambiguated?), not splitting.\n", cohort->line_number, cohort->wordform->tag.c_str());
// We also don't split if wordform-tags were only on sub-readings, but should we warn on such faulty input?
}
cos.push_back(cohort);
return cos;
}
for (auto r : cohort->readings) {
size_t pos = std::numeric_limits<size_t>::max();
Reading* prev = NULL; // prev == NULL || prev->next == rNew (or a ->next of rNew)
for (auto sub = r; sub; sub = sub->next) {
const Tag* wfTag = maybeWfTag(sub);
if (wfTag == NULL) {
prev = prev->next;
}
else {
++pos;
Cohort* c;
while (cos.size() < pos + 1) {
c = alloc_cohort(cohort->parent);
c->global_number = gWindow->cohort_counter++;
cohort->parent->appendCohort(c);
cos.push_back(c);
}
c = cos[pos];
const size_t wfEnd = wfTag->tag.size() - 3; // index before the final '>"'
const size_t i = 1 + wfTag->tag.find_last_not_of(rtrimblank, wfEnd);
const UString& wf = wfTag->tag.substr(0, i) + wfTag->tag.substr(wfEnd + 1);
if (c->wordform != 0 && wf != c->wordform->tag) {
u_fprintf(ux_stderr, "WARNING: Line %u: Ambiguous wordform-tags for same cohort, '%S' vs '%S', not splitting.\n", numLines, wf.c_str(), c->wordform->tag.c_str());
cos.clear();
cos.push_back(cohort);
return cos;
}
c->wordform = addTag(wf);
if (i < wfEnd + 1) {
c->text = textprefix + wfTag->tag.substr(i, wfEnd + 1 - i);
}
Reading* rNew = alloc_reading(*sub);
for (size_t i = 0; i < rNew->tags_list.size(); ++i) {
auto& tter = rNew->tags_list[i];
if (tter == wfTag->hash || tter == rNew->parent->wordform->hash) {
rNew->tags_list.erase(rNew->tags_list.begin() + i);
rNew->tags.erase(tter);
}
}
cos[pos]->appendReading(rNew);
rNew->parent = cos[pos];
if (prev != NULL) {
free_reading(prev->next);
prev->next = 0;
}
prev = rNew;
}
}
}
if (cos.size() == 0) {
u_fprintf(ux_stderr, "WARNING: Line %u: Tried splitting %S, but got no new cohorts; shouldn't happen.", numLines, cohort->wordform->tag.c_str());
cos.push_back(cohort);
}
// The last word forms are the top readings:
cos[0]->text = cohort->text;
std::reverse(cos.begin(), cos.end());
return cos;
}
