src/StoreCache.cc

   1 /*
   2  * StoreCache.cc
   3  *
   4  *  Created on: Jan 6, 2011
   5  *      Author: lamikr
   6  */
   7 #include <plp/log.h>
   8
   9 #include "Store.hh"
  10 #include "StoreCache.hh"
  11 #include "StoreDay.hh"
  12 #include "DeviceConfig.hh"
  13 #include "W1Util.hh"
  14
  15 using namespace std;
  16 using namespace plp;
  17 using namespace w1;
  18
  19 StoreCache::StoreCache(string device_id_param,
  20                 Date *date_time_param): Store(device_id_param, date_time_param) {
  21 /*
  22         store_fname     = get_file_name(device_id_param,
  23                                 date_time_param,
  24                                 period_type_param,
  25                                 calc_type_param);
  26 */
  27 }
  28
  29 StoreCache::~StoreCache() {
  30 }
  31
  32 string StoreCache::get_dir_name(string device_id_param,
  33                                 Date *date_time_param,
  34                                 EnumSummaryPeriod period_type_param,
  35                                 EnumSummaryCalculationType calc_type_param) {
  36         string  ret_val;
  37         char    buffer[30];
  38         string  bd_name;
  39
  40         snprintf(buffer, 30, "%d/%02d", date_time_param->year, date_time_param->month);
  41         bd_name = DeviceConfig::get_base_dir_name();
  42         bd_name = W1Util::concat_paths(bd_name, CACHE_DIR_NAME);
  43         bd_name = W1Util::concat_paths(bd_name, device_id_param);
  44         bd_name = W1Util::concat_paths(bd_name, SUMMARY_PERIOD_NAMES_ARRAY[period_type_param]);
  45         bd_name = W1Util::concat_paths(bd_name, CALCULATION_TYPE_NAMES_ARRAY[calc_type_param]);
  46         ret_val = bd_name + "/" + buffer;
  47         return ret_val;
  48 }
  49
  50 string StoreCache::get_file_name(string device_id_param,
  51                                 Date *date_time_param,
  52                                 EnumSummaryPeriod period_type_param,
  53                                 EnumSummaryCalculationType calc_type_param) {
  54         string  ret_val;
  55         string  fname;
  56         char    buffer[30];
  57
  58         snprintf(buffer, 30, "%d-%02d-%02d",
  59                 date_time_param->year,
  60                 date_time_param->month,
  61                 date_time_param->day);
  62         fname   = buffer;
  63         fname   = fname + DATAFILE_SUFFIX;
  64         ret_val = get_dir_name(device_id_param, date_time_param, period_type_param, calc_type_param);
  65         ret_val = W1Util::concat_paths(ret_val, fname);
  66         return ret_val;
  67 }
  68
  69 DataRange *StoreCache::get_mean(EnumSummaryPeriod period_type_param) {
  70         int             row_count;
  71         DataRange       *ret_val;
  72         Data            *dta;
  73         string          fname;
  74         StoreDay        *store;
  75
  76         ret_val = NULL;
  77         fname   = get_file_name(device_id,
  78                                 date,
  79                                 period_type_param,
  80                                 MEAN);
  81         if (store_data == NULL) {
  82                 if (access(fname.c_str(), R_OK) == 0) {
  83                         load(fname);
  84                 }
  85         }
  86         if (store_data != NULL) {
  87                 row_count       = store_data->get_count();
  88                 if (row_count > 0) {
  89                         ret_val = new DataRange();
  90                         dta     = store_data->get(0);
  91                         ret_val->add(dta);
  92                         delete(dta);
  93                 }
  94         }
  95         if (ret_val == NULL) {
  96                 store   = new StoreDay(device_id, date);
  97                 ret_val = store->get_mean(period_type_param);
  98                 save(fname, ret_val, 4);
  99                 delete(store);
 100         }
 101         return ret_val;
 102 }
 103
 104 DataRange *StoreCache::get_sum(EnumSummaryPeriod period_type_param) {
 105         int             row_count;
 106         DataRange       *ret_val;
 107         Data            *dta;
 108         string          fname;
 109         StoreDay        *store;
 110
 111         ret_val = NULL;
 112         fname   = get_file_name(device_id,
 113                                 date,
 114                                 period_type_param,
 115                                 MEAN);
 116         if (store_data == NULL) {
 117                 if (access(fname.c_str(), R_OK) == 0) {
 118                         load(fname);
 119                 }
 120         }
 121         if (store_data != NULL) {
 122                 row_count       = store_data->get_count();
 123                 if (row_count > 0) {
 124                         ret_val = new DataRange();
 125                         dta     = store_data->get(0);
 126                         ret_val->add(dta);
 127                         delete(dta);
 128                 }
 129         }
 130         if (ret_val == NULL) {
 131                 store   = new StoreDay(device_id, date);
 132                 ret_val = store->get_sum(period_type_param);
 133                 save(fname, ret_val, 4);
 134                 delete(store);
 135         }
 136         return ret_val;
 137 }
 138
 139 DataRange *StoreCache::get_delta(EnumSummaryPeriod period_type_param) {
 140         int             row_count;
 141         DataRange       *ret_val;
 142         Data            *dta;
 143         string          fname;
 144         StoreDay        *store;
 145
 146         ret_val = NULL;
 147         fname   = get_file_name(device_id,
 148                                 date,
 149                                 period_type_param,
 150                                 MEAN);
 151         if (store_data == NULL) {
 152                 if (access(fname.c_str(), R_OK) == 0) {
 153                         // read from cache file
 154                         load(fname);
 155                 }
 156         }
 157         if (store_data != NULL) {
 158                 row_count       = store_data->get_count();
 159                 if (row_count > 0) {
 160                         ret_val = new DataRange();
 161                         dta     = store_data->get(0);
 162                         ret_val->add(dta);
 163                         delete(dta);
 164                 }
 165         }
 166         if (ret_val == NULL) {
 167                 store   = new StoreDay(device_id, date);
 168                 ret_val = store->get_delta(period_type_param);
 169                 save(fname, ret_val, 4);
 170                 delete(store);
 171         }
 172         return ret_val;
 173 }
 174
 175 DataRange *StoreCache::get_max(EnumSummaryPeriod period_type_param) {
 176         int             row_count;
 177         DataRange       *ret_val;
 178         Data            *dta;
 179         string          fname;
 180         StoreDay        *store;
 181
 182         ret_val = NULL;
 183         fname   = get_file_name(device_id,
 184                                 date,
 185                                 period_type_param,
 186                                 MEAN);
 187         if (store_data == NULL) {
 188                 if (access(fname.c_str(), R_OK) == 0) {
 189                         load(fname);
 190                 }
 191         }
 192         if (store_data != NULL) {
 193                 row_count       = store_data->get_count();
 194                 if (row_count > 0) {
 195                         ret_val = new DataRange();
 196                         dta     = store_data->get(0);
 197                         ret_val->add(dta);
 198                         delete(dta);
 199                 }
 200         }
 201         if (ret_val == NULL) {
 202                 store   = new StoreDay(device_id, date);
 203                 ret_val = store->get_max(period_type_param);
 204                 save(fname, ret_val, 4);
 205                 delete(store);
 206         }
 207         return ret_val;
 208 }
 209
 210 DataRange *StoreCache::get_min(EnumSummaryPeriod period_type_param) {
 211         int             row_count;
 212         DataRange       *ret_val;
 213         Data            *dta;
 214         string          fname;
 215         StoreDay        *store;
 216
 217         ret_val = NULL;
 218         fname   = get_file_name(device_id,
 219                                 date,
 220                                 period_type_param,
 221                                 MEAN);
 222         if (store_data == NULL) {
 223                 if (access(fname.c_str(), R_OK) == 0) {
 224                         load(fname);
 225                 }
 226         }
 227         if (store_data != NULL) {
 228                 row_count       = store_data->get_count();
 229                 if (row_count > 0) {
 230                         ret_val = new DataRange();
 231                         dta     = store_data->get(0);
 232                         ret_val->add(dta);
 233                         delete(dta);
 234                 }
 235         }
 236         if (ret_val == NULL) {
 237                 store   = new StoreDay(device_id, date);
 238                 ret_val = store->get_min(period_type_param);
 239                 save(fname, ret_val, 4);
 240                 delete(store);
 241         }
 242         return ret_val;
 243 }
 244
 245 void StoreCache::save(std::string fname_param, plp::DataRange *datarange_param, int decimal_count_param) {
 246         string          line;
 247         Data            *data;
 248         ofstream        *ostream;
 249         int             ii;
 250         int             cnt;
 251
 252         cnt     = datarange_param->get_count();
 253         ostream =  NULL;
 254         log_info("[%s] cacheing %d data values.\n", device_id.c_str(), cnt);
 255         ostream = W1Util::open_for_writing(fname_param.c_str());
 256         if ((ostream != NULL) &&
 257             (ostream->is_open() == true)) {
 258                 // TODO: add mutex to protect string_list while it's read and emptied
 259                 for(ii = 0; ii < cnt; ii++) {
 260                         data    = datarange_param->get(ii);
 261                         if (data != NULL) {
 262                                 line    = data->to_string(decimal_count_param);
 263                                 if (line.length() > 0) {
 264                                         *ostream << line << endl;
 265                                 }
 266                                 delete(data);
 267                         }
 268                 }
 269         }
 270         else {
 271                 log_error("[%s] File open for data save failed: %s\n", device_id.c_str(), fname_param.c_str());
 272         }
 273         if (ostream != NULL) {
 274                 ostream->close();
 275                 delete(ostream);
 276         }
 277 }