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