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) {
84 list<Data *>::iterator iter;
88 log_info("[%s] writing %d data values to save.\n", device_id.c_str(), data_list->size());
89 // TODO: add mutex to protect string_list while it's read and emptied
90 for(iter = data_list->begin(); iter != data_list->end(); iter++) {
92 date = data->get_date();
93 n_path = get_file_name(device_id, &date);
94 if (n_path.compare(f_path) != 0) {
95 if (ostream != NULL) {
100 log_info("[%s] Opening file for save: %s\n", device_id.c_str(), f_path.c_str());
101 ostream = W1Util::open_for_writing(f_path.c_str());
103 if ((ostream != NULL) &&
104 (ostream->is_open() == true)) {
105 line = data->to_string();
106 if (line.length() > 0) {
107 log_debug("storing line: %s\n", line.c_str());
108 *ostream << line << endl;
112 log_error("[%s] File open for data save failed: %s\n", device_id.c_str(), f_path.c_str());
115 if (ostream != NULL) {
121 bool W1Store::load() {
128 if (store_data != NULL) {
132 log_debug("opening file: %s\n", store_file_name.c_str());
133 in.open(store_file_name.c_str());
134 if (in.is_open() == true) {
135 while (in.eof() == false) {
136 getline(in, data_str);
137 if (data_str.empty() == false) {
138 data = Data::parse_string(data_str);
140 if (store_data == NULL) {
141 store_data = new DataRange(data);
144 store_data->add_data(data);
153 log_error("Could not load data from file: %s\n", store_file_name.c_str());
158 Data *W1Store::get_sum() {
170 if (store_data == NULL) {
173 if (store_data != NULL) {
174 row_count = store_data->get_data_row_count();
175 log_debug("data row count: %d\n", row_count);
177 col_count = store_data->get_data_column_count();
178 log_debug("data item count per row: %d\n", col_count);
179 ret_val = new Data(col_count);
181 for (ii = 0; ii < row_count - 1; ii++) {
182 data = store_data->get_data(ii);
183 for (jj = 0; jj < col_count; jj++) {
184 new_val = data->value_arr[jj];
185 ret_val->value_arr[jj] = ret_val->value_arr[jj] + new_val;
187 if (ii < (row_count - 2)) {
191 //log_debug("new val: %f, sum: %f\n", new_val, sum);
194 date = data->get_date();
195 ret_val->set_date(&date);
204 Data *W1Store::get_delta() {
215 dr = get_oldest_and_newest_data();
217 row_count = dr->get_data_row_count();
218 if (row_count == 2) {
219 o_data = dr->get_data(0);
220 n_data = dr->get_data(1);
221 col_count = dr->get_data_column_count();
222 ret_val = new Data(col_count);
224 for (ii = 0; ii < col_count; ii++) {
225 log_debug("old_data[%d]: %f new data: %f\n", ii, o_data->value_arr[ii], n_data->value_arr[ii]);
226 ret_val->value_arr[ii] = n_data->value_arr[ii] - o_data->value_arr[ii];
229 date = n_data->get_date();
230 ret_val->set_date(&date);
239 Data *W1Store::get_mean() {
246 if (store_data == NULL) {
249 if (store_data != NULL) {
250 row_count = store_data->get_data_row_count();
252 col_count = store_data->get_data_column_count();
255 for (ii = 0; ii < col_count; ii++) {
256 ret_val->value_arr[ii] = ret_val->value_arr[ii] / row_count;
257 log_debug("avg: %f\n", ret_val->value_arr[ii]);
265 Data *W1Store::get_max() {
278 if (store_data == NULL) {
281 if (store_data != NULL) {
282 row_count = store_data->get_data_row_count();
283 log_debug("data row count: %d\n", row_count);
285 col_count = store_data->get_data_column_count();
286 log_debug("data item count per row: %d\n", col_count);
287 min_val = numeric_limits<double>::min();
288 data = store_data->get_data(0);
289 ret_val = new Data(col_count,
293 for (ii = 0; ii < row_count - 1; ii++) {
294 data = store_data->get_data(ii);
295 for (jj = 0; jj < col_count; jj++) {
296 new_val = data->value_arr[jj];
297 if (new_val > ret_val->value_arr[jj]) {
298 ret_val->value_arr[jj] = new_val;
301 if (ii < (row_count - 2)) {
307 date = data->get_date();
308 ret_val->set_date(&date);
317 Data *W1Store::get_min() {
330 if (store_data == NULL) {
333 if (store_data != NULL) {
334 row_count = store_data->get_data_row_count();
335 log_debug("data row count: %d\n", row_count);
337 col_count = store_data->get_data_column_count();
338 log_debug("data item count per row: %d\n", col_count);
339 max_val = numeric_limits<double>::max();
340 data = store_data->get_data(0);
341 ret_val = new Data(col_count,
345 for (ii = 0; ii < row_count - 1; ii++) {
346 data = store_data->get_data(ii);
347 for (jj = 0; jj < col_count; jj++) {
348 new_val = data->value_arr[jj];
349 if (new_val < ret_val->value_arr[jj]) {
350 ret_val->value_arr[jj] = new_val;
353 if (ii < (row_count - 2)) {
359 date = data->get_date();
360 ret_val->set_date(&date);
369 vector<Data *> W1Store::get_mean(int freq_sec) {
379 vector<Data *> ret_val;
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);
397 calc = data->clone();
398 limit_d = data->get_date().clone();
401 limit_d->inc_seconds(freq_sec);
404 date = data->get_date();
405 if (date.before(*limit_d)) {
406 for (jj = 0; jj < col_count; jj++) {
407 calc->value_arr[jj] = calc->value_arr[jj] + data->value_arr[jj];
412 for (jj = 0; jj < col_count; jj++) {
413 calc->value_arr[jj] = calc->value_arr[jj] / d_count;
415 ret_val.push_back(calc);
417 calc = data->clone();
418 if (limit_d != NULL) {
421 limit_d = data->get_date().clone();
424 limit_d->inc_seconds(freq_sec);
434 if (limit_d != NULL) {
443 vector<Data *> W1Store::get_delta(int freq_sec) {
453 vector<Data *> ret_val;
458 if (store_data == NULL) {
461 if (store_data != NULL) {
462 row_count = store_data->get_data_row_count();
464 col_count = store_data->get_data_column_count();
466 for (ii = 0; ii < row_count; ii++) {
467 data = store_data->get_data(ii);
470 calc1 = data->clone();
471 limit_d = data->get_date().clone();
474 limit_d->inc_seconds(freq_sec);
481 date = data->get_date();
482 if (date.before(*limit_d)) {
486 calc2 = data->clone();
490 calc2 = calc1->clone();
492 for (jj = 0; jj < col_count; jj++) {
493 calc2->value_arr[jj] = calc2->value_arr[jj] - calc1->value_arr[jj];
495 ret_val.push_back(calc2);
497 calc1 = data->clone();
498 calc2 = NULL; // do not delete calc2 as it's stored to array
499 if (limit_d != NULL) {
502 limit_d = data->get_date().clone();
505 limit_d->inc_seconds(freq_sec);
519 if (limit_d != NULL) {
528 DataRange *W1Store::get_oldest_and_newest_data() {
541 if (store_data != NULL) {
542 row_count = store_data->get_data_row_count();
544 o_data = store_data->get_data(0);
545 n_data = store_data->get_data(row_count - 1);
549 if (range_data != NULL) {
550 row_count = range_data->get_data_row_count();
552 o_data = range_data->get_data(0);
553 n_data = range_data->get_data(row_count - 1);
557 in.open(store_file_name.c_str());
558 while (in.eof() == false) {
560 if (line.empty() == false) {
561 if (o_data == NULL) {
562 o_data = Data::parse_string(line);
567 if (prev_line.empty() == false) {
568 n_data = Data::parse_string(prev_line);
572 if ((o_data != NULL) &&
574 ret_val = new DataRange(o_data);
575 ret_val->add_data(n_data);
576 if (range_data != NULL) {
577 range_data = new DataRange(o_data);
578 range_data->add_data(n_data);
581 if (o_data != NULL) {
584 if (n_data != NULL) {
590 Data *W1Store::get_oldest_data() {
596 dr = get_oldest_and_newest_data();
598 row_count = dr->get_data_row_count();
599 if (row_count >= 1) {
600 ret_val = dr->get_data(0);
607 Data *W1Store::get_newest_data() {
613 dr = get_oldest_and_newest_data();
615 row_count = dr->get_data_row_count();
616 if (row_count == 2) {
617 ret_val = dr->get_data(1);