4 * Created on: Oct 31, 2010
16 #include <sys/types.h>
22 #include "DeviceConfig.hh"
23 #include "W1Configure.hh"
31 W1Store::W1Store(string device_id,
35 store_file_name = get_file_name(device_id, date_time);
36 log_debug("data file name: %s\n", store_file_name.c_str());
39 W1Store::W1Store(string file_name_param) {
42 store_file_name = file_name_param;
46 if (store_data != NULL) {
52 string W1Store::get_dir_name(string device_id, Date *date_time) {
57 d_name = DeviceConfig::get_base_dir_name();
58 snprintf(buffer, 30, "%d/%02d", date_time->year, date_time->month);
59 ret_val = W1Util::concat_paths(d_name, device_id);
60 ret_val = ret_val + "/" + buffer;
64 string W1Store::get_file_name(string device_id, Date *date_time) {
69 snprintf(buffer, 30, "%d-%02d-%02d", date_time->year, date_time->month, date_time->day);
71 fname = fname + DATAFILE_SUFFIX;
72 ret_val = get_dir_name(device_id, date_time);
73 ret_val = W1Util::concat_paths(ret_val, fname);
77 void W1Store::store(string device_id,
78 list<string> *string_list) {
85 f_path = get_file_name(device_id, date);
86 ostream = W1Util::open_for_writing(f_path.c_str());
87 // TODO: add mutex to protect string_list while it's read and emptied
88 if (ostream != NULL) {
89 if (ostream->is_open()) {
90 log_info("[%s] writing %d data values to file: %s\n", device_id.c_str(), string_list->size(), f_path.c_str());
91 while(string_list->size() > 0) {
92 line = string_list->front();
93 string_list->pop_front();
94 if (line.length() > 0) {
95 log_debug("storing line: %s\n", line.c_str());
96 *ostream << line << endl;
102 log_error("[%s] Could not store data to file: %s\n", device_id.c_str(), f_path.c_str());
107 log_error("[%s] Could not store data to file: %s\n", device_id.c_str(), f_path.c_str());
112 bool W1Store::load() {
119 if (store_data != NULL) {
123 in.open(store_file_name.c_str());
124 if (in.is_open() == true) {
125 while (in.eof() == false) {
127 data = Data::parse_data_string(line);
128 if (store_data == NULL) {
129 store_data = new DataRange(*data);
132 store_data->add_data(*data);
139 log_error("Could not load data from file: %s\n", store_file_name.c_str());
144 Data *W1Store::get_sum() {
155 if (store_data == NULL) {
158 if (store_data != NULL) {
159 row_count = store_data->get_data_row_count();
160 log_debug("data row count: %d\n", row_count);
162 col_count = store_data->get_data_column_count();
163 log_debug("data item count per row: %d\n", col_count);
164 ret_val = new Data(col_count);
166 for (ii = 0; ii < row_count - 1; ii++) {
167 data = store_data->get_data(ii);
168 for (jj = 0; jj < col_count; jj++) {
169 new_val = data->value_arr[jj];
170 ret_val->value_arr[jj] = ret_val->value_arr[jj] + new_val;
172 if (ii < (row_count - 2)) {
176 //log_debug("new val: %f, sum: %f\n", new_val, sum);
179 ret_val->set_date(data->get_date());
188 Data *W1Store::get_delta() {
198 dr = get_oldest_and_newest_data();
200 row_count = dr->get_data_row_count();
201 if (row_count == 2) {
202 o_data = dr->get_data(0);
203 n_data = dr->get_data(1);
204 col_count = dr->get_data_column_count();
205 ret_val = new Data(col_count);
207 for (ii = 0; ii < col_count; ii++) {
208 ret_val->value_arr[ii] = n_data->value_arr[ii] - o_data->value_arr[ii];
211 ret_val->set_date(n_data->get_date());
220 Data *W1Store::get_mean() {
227 if (store_data == NULL) {
230 if (store_data != NULL) {
231 row_count = store_data->get_data_row_count();
233 col_count = store_data->get_data_column_count();
236 for (ii = 0; ii < col_count; ii++) {
237 ret_val->value_arr[ii] = ret_val->value_arr[ii] / row_count;
238 log_debug("avg: %f\n", ret_val->value_arr[ii]);
246 Data *W1Store::get_max() {
258 if (store_data == NULL) {
261 if (store_data != NULL) {
262 row_count = store_data->get_data_row_count();
263 log_debug("data row count: %d\n", row_count);
265 col_count = store_data->get_data_column_count();
266 log_debug("data item count per row: %d\n", col_count);
267 min_val = numeric_limits<double>::min();
268 ret_val = new Data(col_count, min_val);
270 for (ii = 0; ii < row_count - 1; ii++) {
271 data = store_data->get_data(ii);
272 for (jj = 0; jj < col_count; jj++) {
273 new_val = data->value_arr[jj];
274 if (new_val > ret_val->value_arr[jj]) {
275 ret_val->value_arr[jj] = new_val;
278 if (ii < (row_count - 2)) {
284 ret_val->set_date(data->get_date());
293 Data *W1Store::get_min() {
305 if (store_data == NULL) {
308 if (store_data != NULL) {
309 row_count = store_data->get_data_row_count();
310 log_debug("data row count: %d\n", row_count);
312 col_count = store_data->get_data_column_count();
313 log_debug("data item count per row: %d\n", col_count);
314 max_val = numeric_limits<double>::max();
315 ret_val = new Data(col_count, max_val);
317 for (ii = 0; ii < row_count - 1; ii++) {
318 data = store_data->get_data(ii);
319 for (jj = 0; jj < col_count; jj++) {
320 new_val = data->value_arr[jj];
321 if (new_val < ret_val->value_arr[jj]) {
322 ret_val->value_arr[jj] = new_val;
325 if (ii < (row_count - 2)) {
331 ret_val->set_date(data->get_date());
340 vector<Data *> W1Store::get_mean(int freq_sec) {
350 vector<Data *> ret_val;
355 if (store_data == NULL) {
358 if (store_data != NULL) {
359 row_count = store_data->get_data_row_count();
361 col_count = store_data->get_data_column_count();
363 for (ii = 0; ii < row_count; ii++) {
364 data = store_data->get_data(ii);
368 calc = data->clone();
369 limit_d = data->get_date().clone();
372 limit_d->inc_seconds(freq_sec);
375 date = data->get_date();
376 if (date.before(*limit_d)) {
377 for (jj = 0; jj < col_count; jj++) {
378 calc->value_arr[jj] = calc->value_arr[jj] + data->value_arr[jj];
383 for (jj = 0; jj < col_count; jj++) {
384 calc->value_arr[jj] = calc->value_arr[jj] / d_count;
386 ret_val.push_back(calc);
388 calc = data->clone();
389 if (limit_d != NULL) {
392 limit_d = data->get_date().clone();
395 limit_d->inc_seconds(freq_sec);
405 if (limit_d != NULL) {
414 vector<Data *> W1Store::get_delta(int freq_sec) {
424 vector<Data *> ret_val;
429 if (store_data == NULL) {
432 if (store_data != NULL) {
433 row_count = store_data->get_data_row_count();
435 col_count = store_data->get_data_column_count();
437 for (ii = 0; ii < row_count; ii++) {
438 data = store_data->get_data(ii);
441 calc1 = data->clone();
442 limit_d = data->get_date().clone();
445 limit_d->inc_seconds(freq_sec);
452 date = data->get_date();
453 if (date.before(*limit_d)) {
457 calc2 = data->clone();
461 calc2 = calc1->clone();
463 for (jj = 0; jj < col_count; jj++) {
464 calc2->value_arr[jj] = calc2->value_arr[jj] - calc1->value_arr[jj];
466 ret_val.push_back(calc2);
468 calc1 = data->clone();
469 calc2 = NULL; // do not delete calc2 as it's stored to array
470 if (limit_d != NULL) {
473 limit_d = data->get_date().clone();
476 limit_d->inc_seconds(freq_sec);
490 if (limit_d != NULL) {
499 DataRange *W1Store::get_oldest_and_newest_data() {
512 if (store_data != NULL) {
513 row_count = store_data->get_data_row_count();
515 o_data = store_data->get_data(0);
516 n_data = store_data->get_data(row_count - 1);
520 if (range_data != NULL) {
521 row_count = range_data->get_data_row_count();
523 o_data = range_data->get_data(0);
524 n_data = range_data->get_data(row_count - 1);
528 in.open(store_file_name.c_str());
529 while (in.eof() == false) {
531 if (line.empty() == false) {
532 if (o_data == NULL) {
533 o_data = Data::parse_data_string(line);
538 if (prev_line.empty() == false) {
539 n_data = Data::parse_data_string(prev_line);
543 if ((o_data != NULL) &&
545 ret_val = new DataRange(*o_data);
546 ret_val->add_data(*n_data);
547 if (range_data != NULL) {
548 range_data = new DataRange(*o_data);
549 range_data->add_data(*n_data);
552 if (o_data != NULL) {
555 if (n_data != NULL) {
561 Data *W1Store::get_oldest_data() {
567 dr = get_oldest_and_newest_data();
569 row_count = dr->get_data_row_count();
570 if (row_count >= 1) {
571 ret_val = dr->get_data(0);
578 Data *W1Store::get_newest_data() {
584 dr = get_oldest_and_newest_data();
586 row_count = dr->get_data_row_count();
587 if (row_count == 2) {
588 ret_val = dr->get_data(1);