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_id       = device_id_param;
  26         base_dir        = W1Store::get_store_base_dir();
  27         device_dir      = W1Util::concat_paths(base_dir, device_id);
  28         device_ch_dir   = W1Util::concat_paths(base_dir, "cache");
  29         device_ch_dir   = W1Util::concat_paths(device_ch_dir, device_id);
  30 }
  31
  32 W1DataList::~W1DataList() {
  33         //delete(device_dir);
  34 }
  35
  36 Data *W1DataList::find_first_data(vector<string> year_vector) {
  37         int             ii;
  38         string          year_dir;
  39         string          month_dir;
  40         vector<string>  month_vector;
  41         vector<string>  data_vector;
  42         string          f_name;
  43         W1Store         *store;
  44         Data            *ret_val;
  45
  46         ret_val = NULL;
  47         if (year_vector.size() > 0) {
  48                 // dirs are alphabetically sorted
  49                 year_dir        = year_vector.at(0);
  50                 year_dir        = W1Util::concat_paths(device_dir, year_dir);
  51                 month_vector    = W1Util::get_subdirectories(year_dir);
  52                 for (ii = 0; ii < month_vector.size(); ii++) {
  53                         month_dir       = month_vector.at(ii);
  54                         month_dir       = W1Util::concat_paths(year_dir, month_dir);
  55                         // scan data files from month dir
  56                         data_vector     = W1Util::get_data_files(month_dir);
  57                         if (data_vector.size() > 0) {
  58                                 f_name  = data_vector.at(0);
  59                                 f_name  = W1Util::concat_paths(month_dir, f_name);
  60                                 store   = new W1Store(f_name);
  61                                 ret_val = store->load_first_data_row();
  62                                 delete(store);
  63                                 break;
  64                         }
  65                 }
  66         }
  67         return ret_val;
  68 }
  69
  70 Data *W1DataList::find_last_data(vector<string> year_vector) {
  71         int             ii;
  72         string          year_dir;
  73         string          month_dir;
  74         vector<string>  month_vector;
  75         vector<string>  data_vector;
  76         string          f_name;
  77         Data            *ret_val;
  78         int             size;
  79         W1Store         *store;
  80
  81         ret_val = NULL;
  82         size    = year_vector.size();
  83         if (size > 0) {
  84                 // dirs are alphabetically sorted
  85                 year_dir        = year_vector.at(size - 1);
  86                 year_dir        = W1Util::concat_paths(device_dir, year_dir);
  87                 month_vector    = W1Util::get_subdirectories(year_dir);
  88                 for (ii = month_vector.size() - 1; ii >= 0; ii--) {
  89                         month_dir       = month_vector.at(ii);
  90                         month_dir       = W1Util::concat_paths(year_dir, month_dir);
  91                         // scan data files from month dir
  92                         data_vector     = W1Util::get_data_files(month_dir);
  93                         size    = data_vector.size();
  94                         if (size > 0) {
  95                                 f_name  = data_vector.at(size - 1);
  96                                 f_name  = W1Util::concat_paths(month_dir, f_name);
  97                                 store   = new W1Store(f_name);
  98                                 ret_val = store->load_last_data_row();
  99                                 delete(store);
 100                                 break;
 101                         }
 102                 }
 103         }
 104         return ret_val;
 105 }
 106
 107 DataRange *W1DataList::get_data_range() {
 108         DataRange       *ret_val;
 109         DIR             *data_dir;
 110         struct dirent   *year_dirent;
 111         vector<string>  year_list;
 112         Data            *first_data;
 113         Data            *last_data;
 114
 115         ret_val         = NULL;
 116         year_list       = W1Util::get_subdirectories(device_dir);
 117         first_data      = find_first_data(year_list);
 118         if (first_data != NULL) {
 119                 last_data       = find_last_data(year_list);
 120                 if (last_data != NULL) {
 121                         ret_val = new DataRange(*first_data);
 122                         ret_val->add_data(*last_data);
 123                         delete(last_data);
 124                 }
 125                 delete(first_data);
 126         }
 127         return ret_val;
 128 }
 129 /*
 130 long int get_date_as_seconds(struct tm *date) {
 131         long int ret_val;
 132
 133         ret_val = date->tm
 134                 date->tm_hour * 3600 +
 135                 date->tm_min * 60 +
 136                 date->tm_sec;
 137 }
 138 */
 139
 140 long int get_interval_type(Date *start_date,
 141                         Date *end_date) {
 142         int     diff;
 143         int     ret_val;
 144
 145         ret_val = 0;
 146         diff    = end_date->year - start_date->year;
 147         if (diff != 0) {
 148                 ret_val = 0;
 149         }
 150         else {
 151                 diff    = end_date->month - start_date->month;
 152                 if (diff != 0) {
 153                         ret_val = 1;
 154                 }
 155                 else {
 156                         diff    = end_date->day - start_date->day;
 157                         if (diff != 0) {
 158                                 ret_val = 2;
 159                         }
 160                         else {
 161                                 diff    = end_date->hour - start_date->hour;
 162                                 if (diff != 0) {
 163                                         ret_val = 3;
 164                                 }
 165                                 else {
 166                                         diff    = end_date->min - start_date->min;
 167                                         if (diff != 0) {
 168                                                 ret_val = 4;
 169                                         }
 170                                         else {
 171                                                 ret_val = 5;
 172                                         }
 173                                 }
 174                         }
 175                 }
 176         }
 177         return ret_val;
 178 }
 179
 180 string W1DataList::get_day_data(Date *date) {
 181         string ret_val;
 182
 183         ret_val = W1Store::get_store_file_name(device_id, date);
 184         return ret_val;
 185 }
 186
 187 Data *W1DataList::get_avg_day_data(Date *date) {
 188         return NULL;
 189 }
 190
 191 /*
 192 time_t to_seconds2(const char *date)
 193 {
 194         struct tm storage={0,0,0,0,0,0,0,0,0};
 195         char *p=NULL;
 196         time_t retval=0;
 197
 198         p=(char *)strptime(date,"%d-%b-%Y",&storage);
 199         if(p==NULL) {
 200                 retval=0;
 201         }
 202         else
 203         {
 204                 errno   = 0;
 205                 retval  =mktime(&storage);
 206                 if (retval == ((time_t)-1)) {
 207                         log_error("Error2 converting struct tm to seconds: %s\n", strerror(errno));
 208                 }
 209                 else {
 210                         log_debug("succ2: %ld\n", retval);
 211                 }
 212         }
 213         return retval;
 214 }
 215 */
 216
 217 DataRange *W1DataList::get_avg_day_data(Date *start_date,
 218                                         Date *end_date) {
 219         DataRange       *ret_val;
 220         Data            *data;
 221         W1Store         *store;
 222         Date            *date;
 223
 224         ret_val = NULL;
 225         date    = start_date->clone();
 226         while(date->before(*end_date)) {
 227                 store   = new W1Store(device_id, date);
 228                 store->load();
 229                 data    = store->get_mean();
 230                 data->printout();
 231                 if (ret_val == NULL) {
 232                         ret_val = new DataRange(*data);
 233                 }
 234                 else {
 235                         ret_val->add_data(*data);
 236                 }
 237                 delete(store);
 238                 delete(data);
 239                 date->tomorrow();
 240         }
 241         delete(date);
 242         return ret_val;
 243 }
 244
 245 DataRange *W1DataList::get_data(Date *start_date,
 246                                 Date *end_date) {
 247         DataRange       *ret_val;
 248         int             int_type;
 249
 250         ret_val         = NULL;
 251         start_date->printout();
 252         end_date->printout();
 253         int_type        = get_interval_type(start_date, end_date);
 254         switch(int_type) {
 255                 case 0:
 256                         log_debug("get avg year data\n");
 257                         break;
 258                 case 1:
 259                         log_debug("get avg month data\n");
 260                         break;
 261                 case 2:
 262                         log_debug("get avg day data\n");
 263                         ret_val = get_avg_day_data(start_date, end_date);
 264                         break;
 265                 case 3:
 266                         log_debug("get avg hour data\n");
 267                         break;
 268                 case 4:
 269                         log_debug("get avg min data\n");
 270                         break;
 271                 case 5:
 272                         log_debug("get avg sec data\n");
 273                         break;
 274         }
 275         return ret_val;
 276 }