Several data read and store fixes.

[lib1wire.git] / src / W1Store.cc

diff --git a/src/W1Store.cc b/src/W1Store.cc
index 80dde72388e325635b26abfda9455bf19d96ebea..9913d0dcd8cefad6787cdcf299accf15fd56b210 100644 (file)
--- a/src/W1Store.cc
+++ b/src/W1Store.cc
@@ -19,6 +19,7 @@
 
 #include <plp/log.h>
 
+#include "DeviceConfig.hh"
 #include "W1Configure.hh"
 #include "W1Store.hh"
 #include "W1Util.hh"
@@ -27,8 +28,6 @@ using namespace std;
 using namespace w1;
 using namespace plp;
 
-std::string W1Store::store_base_dir    = DEFAULT_STORAGE_BASE_DIR;
-
 W1Store::W1Store(string device_id,
                Date *date_time) {
        store_data      = NULL;
@@ -50,30 +49,14 @@ W1Store::~W1Store() {
        }
 }
 
-void W1Store::set_base_dir_name(string store_param) {
-       int     pos;
-       int     b_count;
-
-       pos     = store_param.find_last_of("/");
-       b_count = store_param.length();
-       if (pos == (b_count - 1)) {
-               store_base_dir  = store_param;
-       }
-       else {
-               store_base_dir  = store_param + "/";
-       }
-}
-
-string W1Store::get_base_dir_name() {
-       return store_base_dir;
-}
-
 string W1Store::get_dir_name(string device_id, Date *date_time) {
        string  ret_val;
        char    buffer[30];
+       string  d_name;
 
+       d_name  = DeviceConfig::get_base_dir_name();
        snprintf(buffer, 30, "%d/%02d", date_time->year, date_time->month);
-       ret_val = W1Util::concat_paths(store_base_dir, device_id);
+       ret_val = W1Util::concat_paths(d_name, device_id);
        ret_val = ret_val + "/" + buffer;
        return ret_val;
 }
@@ -126,11 +109,13 @@ void W1Store::store(std::string device_id,
        delete(date);
 }
 
-void W1Store::load() {
+bool W1Store::load() {
        Data            *data;
        ifstream        in;
        string          line;
+       bool            ret_val;
 
+       ret_val = false;
        if (store_data != NULL) {
                delete(store_data);
                store_data      = NULL;
@@ -148,7 +133,12 @@ void W1Store::load() {
                        }
                        delete(data);
                }
+               ret_val = true;
        }
+       else {
+               log_error("Could not load data from file: %s\n", store_file_name.c_str());
+       }
+       return ret_val;
 }
 
 Data *W1Store::get_sum() {
@@ -157,7 +147,6 @@ Data *W1Store::get_sum() {
        double  new_val;
        int     ii;
        int     jj;
-       Date    *date;
        Data    *data;
        Data    *ret_val;
 
@@ -260,7 +249,6 @@ Data *W1Store::get_max() {
        double  new_val;
        int     ii;
        int     jj;
-       Date    *date;
        Data    *data;
        Data    *ret_val;
        double  min_val;
@@ -308,7 +296,6 @@ Data *W1Store::get_min() {
        double  new_val;
        int     ii;
        int     jj;
-       Date    *date;
        Data    *data;
        Data    *ret_val;
        double  max_val;
@@ -350,6 +337,165 @@ Data *W1Store::get_min() {
        return ret_val;
 }
 
+vector<Data *> W1Store::get_mean(int freq_sec) {
+       int             row_count;
+       int             col_count;
+       int             d_count;
+       int             jj;
+       int             ii;
+       Data            *data;
+       Data            *calc;
+       Date            *limit_d;
+       Date            date;
+       vector<Data *>  ret_val;
+
+       calc    = NULL;
+       limit_d = NULL;
+       d_count = 1;
+       if (store_data == NULL) {
+               load();
+       }
+       if (store_data != NULL) {
+               row_count       = store_data->get_data_row_count();
+               if (row_count > 0) {
+                       col_count       = store_data->get_data_column_count();
+                       if (col_count > 0) {
+                               for (ii = 0; ii < row_count; ii++) {
+                                       data    = store_data->get_data(ii);
+                                       if (data != NULL) {
+                                               if (calc == NULL) {
+                                                       d_count         = 1;
+                                                       calc            = data->clone();
+                                                       limit_d         = data->get_date().clone();
+                                                       limit_d->min    = 0;
+                                                       limit_d->sec    = 0;
+                                                       limit_d->inc_seconds(freq_sec);
+                                               }
+                                               else {
+                                                       date    = data->get_date();
+                                                       if (date.before(*limit_d)) {
+                                                               for (jj = 0; jj < col_count; jj++) {
+                                                                       calc->value_arr[jj]     = calc->value_arr[jj] + data->value_arr[jj];
+                                                               }
+                                                               d_count++;
+                                                       }
+                                                       else {
+                                                               for (jj = 0; jj < col_count; jj++) {
+                                                                       calc->value_arr[jj]     = calc->value_arr[jj] / d_count;
+                                                               }
+                                                               ret_val.push_back(calc);
+                                                               d_count         = 1;
+                                                               calc            = data->clone();
+                                                               if (limit_d != NULL) {
+                                                                       delete(limit_d);
+                                                               }
+                                                               limit_d         = data->get_date().clone();
+                                                               limit_d->min    = 0;
+                                                               limit_d->sec    = 0;
+                                                               limit_d->inc_seconds(freq_sec);
+                                                       }
+                                               }
+                                               delete(data);
+                                       }
+                               }
+                               if (calc != NULL) {
+                                       delete(calc);
+                                       calc    = NULL;
+                               }
+                               if (limit_d != NULL) {
+                                       delete(limit_d);
+                               }
+                       }
+               }
+       }
+       return ret_val;
+}
+
+vector<Data *> W1Store::get_delta(int freq_sec) {
+       int             row_count;
+       int             col_count;
+       int             jj;
+       int             ii;
+       Data            *data;
+       Data            *calc1;
+       Data            *calc2;
+       Date            *limit_d;
+       Date            date;
+       vector<Data *>  ret_val;
+
+       calc1   = NULL;
+       calc2   = NULL;
+       limit_d = NULL;
+       if (store_data == NULL) {
+               load();
+       }
+       if (store_data != NULL) {
+               row_count       = store_data->get_data_row_count();
+               if (row_count > 0) {
+                       col_count       = store_data->get_data_column_count();
+                       if (col_count > 0) {
+                               for (ii = 0; ii < row_count; ii++) {
+                                       data    = store_data->get_data(ii);
+                                       if (data != NULL) {
+                                               if (calc1 == NULL) {
+                                                       calc1           = data->clone();
+                                                       limit_d         = data->get_date().clone();
+                                                       limit_d->min    = 0;
+                                                       limit_d->sec    = 0;
+                                                       limit_d->inc_seconds(freq_sec);
+                                                       if (calc2 != NULL) {
+                                                               delete(calc2);
+                                                       }
+                                                       calc2           = NULL;
+                                               }
+                                               else {
+                                                       date    = data->get_date();
+                                                       if (date.before(*limit_d)) {
+                                                               if (calc2 != NULL) {
+                                                                       delete(calc2);
+                                                               }
+                                                               calc2   = data->clone();
+                                                       }
+                                                       else {
+                                                               if (calc2 == NULL) {
+                                                                       calc2   = calc1->clone();
+                                                               }
+                                                               for (jj = 0; jj < col_count; jj++) {
+                                                                       calc2->value_arr[jj]    = calc2->value_arr[jj] - calc1->value_arr[jj];
+                                                               }
+                                                               ret_val.push_back(calc2);
+                                                               delete(calc1);
+                                                               calc1   = data->clone();
+                                                               calc2   = NULL; // do not delete calc2 as it's stored to array
+                                                               if (limit_d != NULL) {
+                                                                       delete(limit_d);
+                                                               }
+                                                               limit_d         = data->get_date().clone();
+                                                               limit_d->min    = 0;
+                                                               limit_d->sec    = 0;
+                                                               limit_d->inc_seconds(freq_sec);
+                                                       }
+                                               }
+                                               delete(data);
+                                       }
+                               }
+                               if (calc1 != NULL) {
+                                       delete(calc1);
+                                       calc1   = NULL;
+                               }
+                               if (calc2 != NULL) {
+                                       delete(calc2);
+                                       calc2   = NULL;
+                               }
+                               if (limit_d != NULL) {
+                                       delete(limit_d);
+                               }
+                       }
+               }
+       }
+       return ret_val;
+}
+
 DataRange *W1Store::get_oldest_and_newest_data() {
        DataRange       *ret_val;
        ifstream        in;
@@ -414,7 +560,6 @@ DataRange *W1Store::get_oldest_and_newest_data() {
 
 Data *W1Store::get_oldest_data() {
        int             row_count;
-       int             col_count;
        Data            *ret_val;
        DataRange       *dr;
 
@@ -432,7 +577,6 @@ Data *W1Store::get_oldest_data() {
 
 Data *W1Store::get_newest_data() {
        int             row_count;
-       int             col_count;
        Data            *ret_val;
        DataRange       *dr;