]> pilppa.org Git - lib1wire.git/blobdiff - src/W1Store.cc
Optimisations and cleanups
[lib1wire.git] / src / W1Store.cc
index d59e12121bf5999cb005cab53725f2e22f7f9296..5db7b9b2ef349ce525584193b6968f017f975655 100644 (file)
@@ -27,24 +27,25 @@ using namespace w1;
 using namespace plp;
 
 std::string W1Store::store_base_dir    = DEFAULT_STORAGE_BASE_DIR;
-DataRange *data_range                  = NULL;
 
 W1Store::W1Store(string device_id,
                Date *date_time) {
-       data_range      = NULL;
+       store_data      = NULL;
+       range_data      = NULL;
        store_file_name = get_store_file_name(device_id, date_time);
        log_debug("data file name: %s\n", store_file_name.c_str());
 }
 
 W1Store::W1Store(string file_name_param) {
-       data_range      = NULL;
+       store_data      = NULL;
+       range_data      = NULL;
        store_file_name = file_name_param;
 }
 
 W1Store::~W1Store() {
-       if (data_range != NULL) {
-               delete(data_range);
-               data_range      = NULL;
+       if (store_data != NULL) {
+               delete(store_data);
+               store_data      = NULL;
        }
 }
 
@@ -129,29 +130,61 @@ void W1Store::load() {
        ifstream        in;
        string          line;
 
-       if (data_range != NULL) {
-               delete(data_range);
-               data_range      = NULL;
+       if (store_data != NULL) {
+               delete(store_data);
+               store_data      = NULL;
        }
        in.open(store_file_name.c_str());
        if (in.is_open() == true) {
                while (in.eof() == false) {
                        getline(in, line);
                        data    = W1Util::parse_data_line(line);
-                       if (data_range == NULL) {
-                               data_range      = new DataRange(*data);
+                       if (store_data == NULL) {
+                               store_data      = new DataRange(*data);
                        }
                        else {
-                               data_range->add_data(*data);
+                               store_data->add_data(*data);
                        }
                        delete(data);
                }
        }
 }
 
+Data *W1Store::get_delta() {
+       int             row_count;
+       int             col_count;
+       Data            *o_data;
+       Data            *n_data;
+       Data            *ret_val;
+       int             ii;
+       DataRange       *dr;
+
+       ret_val = NULL;
+       dr      = get_oldest_and_newest_data();
+       if (dr != NULL) {
+               row_count       = dr->get_data_row_count();
+               if (row_count == 2) {
+                       o_data          = dr->get_data(0);
+                       n_data          = dr->get_data(1);
+                       col_count       = dr->get_data_column_count();
+                       ret_val         = new Data(col_count);
+                       if (col_count > 0) {
+                               for (ii = 0; ii < col_count; ii++) {
+                                       ret_val->value_arr[ii]  = n_data->value_arr[ii] - o_data->value_arr[ii];
+                               }
+                       }
+                       ret_val->set_date(n_data->get_date());
+                       delete(o_data);
+                       delete(n_data);
+               }
+               delete(dr);
+       }
+       return ret_val;
+}
+
 Data *W1Store::get_mean() {
-       int     d_count;
-       int     i_count;
+       int     row_count;
+       int     col_count;
        double  avg;
        double  new_val;
        int     ii;
@@ -161,70 +194,138 @@ Data *W1Store::get_mean() {
        Data    *ret_val;
 
        ret_val = NULL;
-       if (data_range == NULL) {
+       data    = NULL;
+       if (store_data == NULL) {
                load();
        }
-       if (data_range != NULL) {
-               d_count = data_range->get_data_row_count();
-               log_debug("data row count: %d\n", d_count);
-               if (d_count > 0) {
-                       i_count = data_range->get_data_column_count();
-                       log_debug("data item count per row: %d\n", i_count);
-                       ret_val = new Data(i_count);
-                       if (i_count > 0) {
-                               for (ii = 0; ii < d_count - 1; ii++) {
-                                       data    = data_range->get_data(ii);
-                                       for (jj = 0; jj < i_count; jj++) {
+       if (store_data != NULL) {
+               row_count       = store_data->get_data_row_count();
+               log_debug("data row count: %d\n", row_count);
+               if (row_count > 0) {
+                       col_count       = store_data->get_data_column_count();
+                       log_debug("data item count per row: %d\n", col_count);
+                       ret_val         = new Data(col_count);
+                       if (col_count > 0) {
+                               for (ii = 0; ii < row_count - 1; ii++) {
+                                       data    = store_data->get_data(ii);
+                                       for (jj = 0; jj < col_count; jj++) {
                                                new_val                 = data->value_arr[jj];
                                                ret_val->value_arr[jj]  = ret_val->value_arr[jj] + new_val;
                                        }
-                                       if (ii < (d_count - 2)) {
+                                       if (ii < (row_count - 2)) {
                                                delete(data);
+                                               data    = NULL;
                                        }
                                        //log_debug("new val: %f, sum: %f\n", new_val, sum);
                                }
-                               for (ii = 0; ii < i_count; ii++) {
-                                       ret_val->value_arr[ii]  = ret_val->value_arr[ii] / d_count;
+                               for (ii = 0; ii < col_count; ii++) {
+                                       ret_val->value_arr[ii]  = ret_val->value_arr[ii] / row_count;
                                        log_debug("avg: %f\n", ret_val->value_arr[ii]);
                                }
                        }
                        ret_val->set_date(data->get_date());
-                       delete(data);
+                       if (data != NULL) {
+                               delete(data);
+                       }
                }
        }
        return ret_val;
 }
 
-Data *W1Store::load_first_data_row() {
-       Data            *ret_val;
+DataRange *W1Store::get_oldest_and_newest_data() {
+       DataRange       *ret_val;
        ifstream        in;
+       Data            *o_data;
+       Data            *n_data;
+       string          latest;
+       int             row_count;
        string          line;
+       string          prev_line;
 
        ret_val = NULL;
-       in.open(store_file_name.c_str());
-       if (in.eof() == false) {
-               getline(in, line);
-               ret_val = W1Util::parse_data_line(line);
+       o_data  = NULL;
+       n_data  = NULL;
+       if (store_data != NULL) {
+               row_count       = store_data->get_data_row_count();
+               if (row_count > 0) {
+                       o_data          = store_data->get_data(0);
+                       n_data          = store_data->get_data(row_count - 1);
+               }
+       }
+       else {
+               if (range_data != NULL) {
+                       row_count       = range_data->get_data_row_count();
+                       if (row_count > 0) {
+                               o_data          = range_data->get_data(0);
+                               n_data          = range_data->get_data(row_count - 1);
+                       }
+               }
+               else {
+                       in.open(store_file_name.c_str());
+                       while (in.eof() == false) {
+                               getline(in, line);
+                               if (line.empty() == false) {
+                                       if (o_data == NULL) {
+                                               o_data  = W1Util::parse_data_line(line);
+                                       }
+                                       prev_line       = line;
+                               }
+                       }
+                       if (prev_line.empty() == false) {
+                               n_data  = W1Util::parse_data_line(prev_line);
+                       }
+               }
+       }
+       if ((o_data != NULL) &&
+           (n_data != NULL)) {
+               ret_val = new DataRange(*o_data);
+               ret_val->add_data(*n_data);
+               if (range_data != NULL) {
+                       range_data      = new DataRange(*o_data);
+                       range_data->add_data(*n_data);
+               }
+       }
+       if (o_data != NULL) {
+               delete(o_data);
+       }
+       if (n_data != NULL) {
+               delete(n_data);
        }
        return ret_val;
 }
 
-Data *W1Store::load_last_data_row() {
+Data *W1Store::get_oldest_data() {
+       int             row_count;
+       int             col_count;
        Data            *ret_val;
-       ifstream        in;
-       string          line;
-       string          prev_line;
+       DataRange       *dr;
 
        ret_val = NULL;
-       in.open(store_file_name.c_str());
-       while (in.eof() == false) {
-               getline(in, line);
-               if (line.empty() == false) {
-                       prev_line       = line;
+       dr      = get_oldest_and_newest_data();
+       if (dr != NULL) {
+               row_count       = dr->get_data_row_count();
+               if (row_count >= 1) {
+                       ret_val = dr->get_data(0);
                }
+               delete(dr);
        }
-       if (prev_line.empty() == false) {
-               ret_val = W1Util::parse_data_line(prev_line);
+       return ret_val;
+}
+
+Data *W1Store::get_newest_data() {
+       int             row_count;
+       int             col_count;
+       Data            *ret_val;
+       DataRange       *dr;
+
+       ret_val = NULL;
+       dr      = get_oldest_and_newest_data();
+       if (dr != NULL) {
+               row_count       = dr->get_data_row_count();
+               if (row_count == 2) {
+                       ret_val = dr->get_data(1);
+               }
+               delete(dr);
        }
        return ret_val;
 }