4 * Created on: Oct 31, 2010
15 #include <sys/types.h>
21 #include "DeviceConfig.hh"
22 #include "W1Configure.hh"
30 W1Store::W1Store(string device_id,
34 store_file_name = get_file_name(device_id, date_time);
35 log_debug("data file name: %s\n", store_file_name.c_str());
38 W1Store::W1Store(string file_name_param) {
41 store_file_name = file_name_param;
45 if (store_data != NULL) {
51 string W1Store::get_dir_name(string device_id, Date *date_time) {
56 d_name = DeviceConfig::get_base_dir_name();
57 snprintf(buffer, 30, "%d/%02d", date_time->year, date_time->month);
58 ret_val = W1Util::concat_paths(d_name, device_id);
59 ret_val = ret_val + "/" + buffer;
63 string W1Store::get_file_name(string device_id, Date *date_time) {
68 snprintf(buffer, 30, "%d-%02d-%02d", date_time->year, date_time->month, date_time->day);
70 fname = fname + DATAFILE_SUFFIX;
71 ret_val = get_dir_name(device_id, date_time);
72 ret_val = W1Util::concat_paths(ret_val, fname);
76 void W1Store::save(string device_id,
77 std::list<Data *> *data_list,
85 list<Data *>::iterator iter;
89 log_info("[%s] writing %d data values to save.\n", device_id.c_str(), data_list->size());
90 // TODO: add mutex to protect string_list while it's read and emptied
91 for(iter = data_list->begin(); iter != data_list->end(); iter++) {
93 date = data->get_date();
94 n_path = get_file_name(device_id, &date);
95 if (n_path.compare(f_path) != 0) {
96 if (ostream != NULL) {
101 log_info("[%s] Opening file for save: %s\n", device_id.c_str(), f_path.c_str());
102 ostream = W1Util::open_for_writing(f_path.c_str());
104 if ((ostream != NULL) &&
105 (ostream->is_open() == true)) {
106 line = data->to_string(dec_precision);
107 if (line.length() > 0) {
108 log_debug("storing line: %s\n", line.c_str());
109 *ostream << line << endl;
113 log_error("[%s] File open for data save failed: %s\n", device_id.c_str(), f_path.c_str());
116 if (ostream != NULL) {
122 bool W1Store::load() {
129 if (store_data != NULL) {
133 log_debug("opening file: %s\n", store_file_name.c_str());
134 in.open(store_file_name.c_str());
135 if (in.is_open() == true) {
136 while (in.eof() == false) {
137 getline(in, data_str);
138 if (data_str.empty() == false) {
139 data = Data::parse_string(data_str);
141 if (store_data == NULL) {
142 store_data = new DataRange(data);
145 store_data->add_data(data);
154 log_error("Could not load data from file: %s\n", store_file_name.c_str());
159 Data *W1Store::get_sum() {
171 if (store_data == NULL) {
174 if (store_data != NULL) {
175 row_count = store_data->get_data_row_count();
176 log_debug("data row count: %d\n", row_count);
178 col_count = store_data->get_data_column_count();
179 log_debug("data item count per row: %d\n", col_count);
180 ret_val = new Data(col_count);
182 for (ii = 0; ii < row_count - 1; ii++) {
183 data = store_data->get_data(ii);
184 for (jj = 0; jj < col_count; jj++) {
185 new_val = data->value_arr[jj];
186 ret_val->value_arr[jj] = ret_val->value_arr[jj] + new_val;
188 if (ii < (row_count - 2)) {
192 //log_debug("new val: %f, sum: %f\n", new_val, sum);
195 date = data->get_date();
196 ret_val->set_date(&date);
205 Data *W1Store::get_delta() {
216 dr = get_oldest_and_newest_data();
218 row_count = dr->get_data_row_count();
219 if (row_count == 2) {
220 o_data = dr->get_data(0);
221 n_data = dr->get_data(1);
222 col_count = dr->get_data_column_count();
223 ret_val = new Data(col_count);
225 for (ii = 0; ii < col_count; ii++) {
226 log_debug("old_data[%d]: %f new data: %f\n", ii, o_data->value_arr[ii], n_data->value_arr[ii]);
227 ret_val->value_arr[ii] = n_data->value_arr[ii] - o_data->value_arr[ii];
230 date = n_data->get_date();
231 ret_val->set_date(&date);
240 Data *W1Store::get_mean() {
247 if (store_data == NULL) {
250 if (store_data != NULL) {
251 row_count = store_data->get_data_row_count();
253 col_count = store_data->get_data_column_count();
256 for (ii = 0; ii < col_count; ii++) {
257 ret_val->value_arr[ii] = ret_val->value_arr[ii] / row_count;
258 log_debug("avg: %f\n", ret_val->value_arr[ii]);
266 Data *W1Store::get_max() {
279 if (store_data == NULL) {
282 if (store_data != NULL) {
283 row_count = store_data->get_data_row_count();
284 log_debug("data row count: %d\n", row_count);
286 col_count = store_data->get_data_column_count();
287 log_debug("data item count per row: %d\n", col_count);
288 min_val = numeric_limits<double>::min();
289 data = store_data->get_data(0);
290 ret_val = new Data(col_count,
294 for (ii = 0; ii < row_count - 1; ii++) {
295 data = store_data->get_data(ii);
296 for (jj = 0; jj < col_count; jj++) {
297 new_val = data->value_arr[jj];
298 if (new_val > ret_val->value_arr[jj]) {
299 ret_val->value_arr[jj] = new_val;
302 if (ii < (row_count - 2)) {
308 date = data->get_date();
309 ret_val->set_date(&date);
318 Data *W1Store::get_min() {
331 if (store_data == NULL) {
334 if (store_data != NULL) {
335 row_count = store_data->get_data_row_count();
336 log_debug("data row count: %d\n", row_count);
338 col_count = store_data->get_data_column_count();
339 log_debug("data item count per row: %d\n", col_count);
340 max_val = numeric_limits<double>::max();
341 data = store_data->get_data(0);
342 ret_val = new Data(col_count,
346 for (ii = 0; ii < row_count - 1; ii++) {
347 data = store_data->get_data(ii);
348 for (jj = 0; jj < col_count; jj++) {
349 new_val = data->value_arr[jj];
350 if (new_val < ret_val->value_arr[jj]) {
351 ret_val->value_arr[jj] = new_val;
354 if (ii < (row_count - 2)) {
360 date = data->get_date();
361 ret_val->set_date(&date);
370 vector<Data *> *W1Store::get_sum(int freq_sec) {
379 vector<Data *> *ret_val;
381 ret_val = new vector<Data *>();
384 if (store_data == NULL) {
387 if (store_data != NULL) {
388 row_count = store_data->get_data_row_count();
390 col_count = store_data->get_data_column_count();
392 for (ii = 0; ii < row_count; ii++) {
393 data = store_data->get_data(ii);
396 calc = data->clone();
397 limit_d = data->get_date().clone();
400 limit_d->inc_seconds(freq_sec);
403 date = data->get_date();
404 if (date.before(*limit_d)) {
405 for (jj = 0; jj < col_count; jj++) {
406 calc->value_arr[jj] = calc->value_arr[jj] + data->value_arr[jj];
410 ret_val->push_back(calc);
411 calc = data->clone();
412 if (limit_d != NULL) {
415 limit_d = data->get_date().clone();
418 limit_d->inc_seconds(freq_sec);
428 if (limit_d != NULL) {
437 vector<Data *> *W1Store::get_mean(int freq_sec) {
447 vector<Data *> *ret_val;
449 ret_val = new vector<Data *>();
453 if (store_data == NULL) {
456 if (store_data != NULL) {
457 row_count = store_data->get_data_row_count();
459 col_count = store_data->get_data_column_count();
461 for (ii = 0; ii < row_count; ii++) {
462 data = store_data->get_data(ii);
466 calc = data->clone();
467 limit_d = data->get_date().clone();
470 limit_d->inc_seconds(freq_sec);
473 date = data->get_date();
474 if (date.before(*limit_d)) {
475 for (jj = 0; jj < col_count; jj++) {
476 calc->value_arr[jj] = calc->value_arr[jj] + data->value_arr[jj];
481 for (jj = 0; jj < col_count; jj++) {
482 calc->value_arr[jj] = calc->value_arr[jj] / d_count;
484 ret_val->push_back(calc);
486 calc = data->clone();
487 if (limit_d != NULL) {
490 limit_d = data->get_date().clone();
493 limit_d->inc_seconds(freq_sec);
503 if (limit_d != NULL) {
512 vector<Data *> *W1Store::get_delta(int freq_sec) {
522 vector<Data *> *ret_val;
524 ret_val = new vector<Data *>();
528 if (store_data == NULL) {
531 if (store_data != NULL) {
532 row_count = store_data->get_data_row_count();
534 col_count = store_data->get_data_column_count();
536 for (ii = 0; ii < row_count; ii++) {
537 data = store_data->get_data(ii);
540 calc1 = data->clone();
541 limit_d = data->get_date().clone();
544 limit_d->inc_seconds(freq_sec);
551 date = data->get_date();
552 if (date.before(*limit_d)) {
556 calc2 = data->clone();
560 calc2 = calc1->clone();
562 for (jj = 0; jj < col_count; jj++) {
563 calc2->value_arr[jj] = calc2->value_arr[jj] - calc1->value_arr[jj];
565 ret_val->push_back(calc2);
567 calc1 = data->clone();
568 calc2 = NULL; // do not delete calc2 as it's stored to array
569 if (limit_d != NULL) {
572 limit_d = data->get_date().clone();
575 limit_d->inc_seconds(freq_sec);
589 if (limit_d != NULL) {
598 vector<Data *> *W1Store::get_max_or_min(int freq_sec, bool max) {
607 vector<Data *> *ret_val;
609 ret_val = new vector<Data *>();
612 if (store_data == NULL) {
615 if (store_data != NULL) {
616 row_count = store_data->get_data_row_count();
618 col_count = store_data->get_data_column_count();
620 for (ii = 0; ii < row_count; ii++) {
621 data = store_data->get_data(ii);
624 calc = data->clone();
625 limit_d = data->get_date().clone();
628 limit_d->inc_seconds(freq_sec);
631 date = data->get_date();
632 if (date.before(*limit_d)) {
634 for (jj = 0; jj < col_count; jj++) {
635 if (calc->value_arr[jj] < data->value_arr[jj]) {
636 calc->value_arr[jj] = data->value_arr[jj];
641 for (jj = 0; jj < col_count; jj++) {
642 if (data->value_arr[jj] < calc->value_arr[jj]) {
643 calc->value_arr[jj] = data->value_arr[jj];
649 ret_val->push_back(calc);
650 calc = data->clone();
651 if (limit_d != NULL) {
654 limit_d = data->get_date().clone();
657 limit_d->inc_seconds(freq_sec);
667 if (limit_d != NULL) {
676 vector<Data *> *W1Store::get_max(int freq_sec) {
677 vector<Data *> *ret_val;
679 ret_val = get_max_or_min(freq_sec, true);
683 vector<Data *> *W1Store::get_min(int freq_sec) {
684 vector<Data *> *ret_val;
686 ret_val = get_max_or_min(freq_sec, false);
690 DataRange *W1Store::get_oldest_and_newest_data() {
703 if (store_data != NULL) {
704 row_count = store_data->get_data_row_count();
706 o_data = store_data->get_data(0);
707 n_data = store_data->get_data(row_count - 1);
711 if (range_data != NULL) {
712 row_count = range_data->get_data_row_count();
714 o_data = range_data->get_data(0);
715 n_data = range_data->get_data(row_count - 1);
719 in.open(store_file_name.c_str());
720 while (in.eof() == false) {
722 if (line.empty() == false) {
723 if (o_data == NULL) {
724 o_data = Data::parse_string(line);
729 if (prev_line.empty() == false) {
730 n_data = Data::parse_string(prev_line);
734 if ((o_data != NULL) &&
736 ret_val = new DataRange(o_data);
737 ret_val->add_data(n_data);
738 if (range_data != NULL) {
739 range_data = new DataRange(o_data);
740 range_data->add_data(n_data);
743 if (o_data != NULL) {
746 if (n_data != NULL) {
752 Data *W1Store::get_oldest_data() {
758 dr = get_oldest_and_newest_data();
760 row_count = dr->get_data_row_count();
761 if (row_count >= 1) {
762 ret_val = dr->get_data(0);
769 Data *W1Store::get_newest_data() {
775 dr = get_oldest_and_newest_data();
777 row_count = dr->get_data_row_count();
778 if (row_count == 2) {
779 ret_val = dr->get_data(1);