src/W1DataList.cc

   1 /*
   2  * W1DataList.cc
   3  *
   4  *  Created on: Nov 7, 2010
   5  *      Author: lamikr
   6  */
   7 #include <dirent.h>
   8 #include <malloc.h>
   9 #include <errno.h>
  10 #include <string.h>
  11
  12 #include "W1Util.hh"
  13 #include "W1DataList.hh"
  14 #include "W1Store.hh"
  15
  16 #include "plp/log.h"
  17
  18 using namespace w1;
  19 using namespace std;
  20 using namespace plp;
  21
  22 W1DataList::W1DataList(string device_id_param) {
  23         string          base_dir;
  24
  25         device_config           = new DeviceConfig(device_id_param);
  26         summary_calc_type       = device_config->get_summary_calculation_type();
  27         device_id               = device_id_param;
  28         base_dir                = W1Store::get_base_dir_name();
  29         device_dir              = W1Util::concat_paths(base_dir, device_id);
  30         device_ch_dir           = W1Util::concat_paths(base_dir, "cache");
  31         device_ch_dir           = W1Util::concat_paths(device_ch_dir, device_id);
  32 }
  33
  34 W1DataList::~W1DataList() {
  35         delete(device_config);
  36 }
  37
  38 Data *W1DataList::find_oldest_data(vector<string> year_vector) {
  39         int             ii;
  40         string          year_dir;
  41         string          month_dir;
  42         vector<string>  month_vector;
  43         vector<string>  data_vector;
  44         string          f_name;
  45         W1Store         *store;
  46         Data            *ret_val;
  47
  48         ret_val = NULL;
  49         if (year_vector.size() > 0) {
  50                 // dirs are alphabetically sorted
  51                 year_dir        = year_vector.at(0);
  52                 year_dir        = W1Util::concat_paths(device_dir, year_dir);
  53                 month_vector    = W1Util::get_subdirectories(year_dir);
  54                 for (ii = 0; ii < month_vector.size(); ii++) {
  55                         month_dir       = month_vector.at(ii);
  56                         month_dir       = W1Util::concat_paths(year_dir, month_dir);
  57                         // scan data files from month dir
  58                         data_vector     = W1Util::get_data_files(month_dir);
  59                         if (data_vector.size() > 0) {
  60                                 f_name  = data_vector.at(0);
  61                                 f_name  = W1Util::concat_paths(month_dir, f_name);
  62                                 store   = new W1Store(f_name);
  63                                 ret_val = store->get_oldest_data();
  64                                 delete(store);
  65                                 break;
  66                         }
  67                 }
  68         }
  69         return ret_val;
  70 }
  71
  72 Data *W1DataList::find_newest_data(vector<string> year_vector) {
  73         int             ii;
  74         string          year_dir;
  75         string          month_dir;
  76         vector<string>  month_vector;
  77         vector<string>  data_vector;
  78         string          f_name;
  79         Data            *ret_val;
  80         int             size;
  81         W1Store         *store;
  82
  83         ret_val = NULL;
  84         size    = year_vector.size();
  85         if (size > 0) {
  86                 // dirs are alphabetically sorted
  87                 year_dir        = year_vector.at(size - 1);
  88                 year_dir        = W1Util::concat_paths(device_dir, year_dir);
  89                 month_vector    = W1Util::get_subdirectories(year_dir);
  90                 for (ii = month_vector.size() - 1; ii >= 0; ii--) {
  91                         month_dir       = month_vector.at(ii);
  92                         month_dir       = W1Util::concat_paths(year_dir, month_dir);
  93                         // scan data files from month dir
  94                         data_vector     = W1Util::get_data_files(month_dir);
  95                         size    = data_vector.size();
  96                         if (size > 0) {
  97                                 f_name  = data_vector.at(size - 1);
  98                                 f_name  = W1Util::concat_paths(month_dir, f_name);
  99                                 store   = new W1Store(f_name);
 100                                 ret_val = store->get_newest_data();
 101                                 delete(store);
 102                                 break;
 103                         }
 104                 }
 105         }
 106         return ret_val;
 107 }
 108
 109 DataRange *W1DataList::get_data_range() {
 110         DataRange       *ret_val;
 111         DIR             *data_dir;
 112         struct dirent   *year_dirent;
 113         vector<string>  year_list;
 114         Data            *first_data;
 115         Data            *newest_data;
 116
 117         ret_val         = NULL;
 118         year_list       = W1Util::get_subdirectories(device_dir);
 119         first_data      = find_oldest_data(year_list);
 120         if (first_data != NULL) {
 121                 newest_data     = find_newest_data(year_list);
 122                 if (newest_data != NULL) {
 123                         ret_val = new DataRange(*first_data);
 124                         ret_val->add_data(*newest_data);
 125                         delete(newest_data);
 126                 }
 127                 delete(first_data);
 128         }
 129         return ret_val;
 130 }
 131
 132 long int get_interval_type(Date *start_date,
 133                         Date *end_date) {
 134         int     diff;
 135         int     ret_val;
 136
 137         ret_val = 0;
 138         diff    = end_date->year - start_date->year;
 139         if (diff != 0) {
 140                 ret_val = 0;
 141         }
 142         else {
 143                 diff    = end_date->month - start_date->month;
 144                 if (diff != 0) {
 145                         ret_val = 1;
 146                 }
 147                 else {
 148                         diff    = end_date->day - start_date->day;
 149                         if (diff != 0) {
 150                                 ret_val = 2;
 151                         }
 152                         else {
 153                                 diff    = end_date->hour - start_date->hour;
 154                                 if (diff != 0) {
 155                                         ret_val = 3;
 156                                 }
 157                                 else {
 158                                         diff    = end_date->min - start_date->min;
 159                                         if (diff != 0) {
 160                                                 ret_val = 4;
 161                                         }
 162                                         else {
 163                                                 ret_val = 5;
 164                                         }
 165                                 }
 166                         }
 167                 }
 168         }
 169         return ret_val;
 170 }
 171
 172 Data *W1DataList::get_daily_summary(Date *date) {
 173         Data    *ret_val;
 174         W1Store *store;
 175
 176         store   = new W1Store(device_id, date);
 177         store->load();
 178         switch(summary_calc_type) {
 179                 case SUM:
 180                         ret_val = store->get_sum();
 181                         break;
 182                 case DELTA:
 183                         ret_val = store->get_delta();
 184                         break;
 185                 case MEAN:
 186                 default:
 187                         ret_val = store->get_mean();
 188                         break;
 189                 case MAX:
 190                         ret_val = store->get_max();
 191                         break;
 192                 case MIN:
 193                         ret_val = store->get_min();
 194                         break;
 195         }
 196         ret_val->printout();
 197         delete(store);
 198
 199         return ret_val;
 200 }
 201
 202 DataRange *W1DataList::get_daily_summary(Date *start_date,
 203                                         Date *end_date) {
 204         DataRange       *ret_val;
 205         Data            *data;
 206         Date            *date;
 207
 208         ret_val = NULL;
 209         date    = start_date->clone();
 210         while(date->before(*end_date)) {
 211                 data    = get_daily_summary(date);
 212                 if (ret_val == NULL) {
 213                         ret_val = new DataRange(*data);
 214                 }
 215                 else {
 216                         ret_val->add_data(*data);
 217                 }
 218                 delete(data);
 219                 date->tomorrow();
 220         }
 221         delete(date);
 222         return ret_val;
 223 }
 224
 225 DataRange *W1DataList::get_data(Date *start_date,
 226                                 Date *end_date) {
 227         DataRange       *ret_val;
 228         int             int_type;
 229
 230         ret_val         = NULL;
 231         start_date->printout();
 232         end_date->printout();
 233         int_type        = get_interval_type(start_date, end_date);
 234         switch(int_type) {
 235                 case 0:
 236                         log_debug("get yearly summary\n");
 237                         break;
 238                 case 1:
 239                         log_debug("get monthly summary\n");
 240                         break;
 241                 case 2:
 242                         log_debug("get daily summary\n");
 243                         ret_val = get_daily_summary(start_date, end_date);
 244                         break;
 245                 case 3:
 246                         log_debug("get hourly summary\n");
 247                         break;
 248                 case 4:
 249                         log_debug("get minute summary data\n");
 250                         break;
 251                 case 5:
 252                         log_debug("get second summary data\n");
 253                         break;
 254         }
 255         return ret_val;
 256 }