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; }