src/Data.cc

   1 /*
   2  * DataRange.cc
   3  *
   4  *  Created on: Dec 7, 2010
   5  *      Author: lamikr
   6  */
   7
   8 #include <string>
   9 #include <iostream>
  10 #include <sstream>
  11
  12 #include <stdio.h>
  13 #include <time.h>
  14 #include <malloc.h>
  15
  16 #include <plp/log.h>
  17
  18 #include "Data.hh"
  19 #include "W1Util.hh"
  20
  21 using namespace std;
  22 using namespace plp;
  23 using namespace w1;
  24
  25 template <class NumberDataType>
  26 bool string_to_number(NumberDataType& result,
  27                  const std::string& string_param,
  28                  std::ios_base& (*format)(std::ios_base&))
  29 {
  30         std::istringstream iss(string_param);
  31         return !(iss >> format >> result).fail();
  32 }
  33
  34 Data::Data(int size) {
  35         value_arr.resize(size);
  36 }
  37
  38 Data::Data(int size, double default_value) {
  39         int ii;
  40
  41         value_arr.resize(size);
  42         for (ii = 0; ii < size; ii++) {
  43                 value_arr[ii]   = default_value;
  44         }
  45 }
  46
  47 Data::Data(vector<double> vector_param, Date *date_param) {
  48         unsigned int    ii;
  49         unsigned int    size;
  50
  51         size    = vector_param.size();
  52         //log_debug("Data(), value count: %d\n", size);
  53         value_arr.resize(size);
  54         for (ii = 0; ii < vector_param.size(); ii++) {
  55                 value_arr[ii]   = vector_param.at(ii);
  56                 //log_debug("Data(), value[%d]: %f\n", ii, value_arr[ii]);
  57         }
  58         date_time.copy(date_param);
  59 }
  60
  61 Data::Data(std::valarray<double> value_arr_param, Date *date_param) {
  62         unsigned int ii;
  63
  64         value_arr.resize(value_arr_param.size());
  65
  66         for (ii = 0; ii < value_arr_param.size(); ii++) {
  67                 value_arr[ii]   = value_arr_param[ii];
  68         }
  69         date_time.copy(date_param);
  70 }
  71
  72 Data::~Data() {
  73 }
  74
  75 plp::Date Data::get_date() {
  76         return date_time;
  77 }
  78
  79 void Data::set_date(plp::Date date) {
  80         date_time.copy(&date);
  81 }
  82
  83 void Data::printout() {
  84         unsigned int    ii;
  85
  86         date_time.printout();
  87         for (ii = 0; ii < value_arr.size(); ii++) {
  88                 log_debug("  data[%d] = %f\n", ii, value_arr[ii]);
  89         }
  90 }
  91
  92 Data *Data::parse_data_string(const string& dataline) {
  93         stringstream    ss(dataline);
  94         string          item;
  95         double          val;
  96         Data            *ret_val;
  97         int             ii;
  98         bool            suc_flg;
  99         vector<double>  v;
 100         Date            date;
 101
 102         ii      = 0;
 103         while(getline(ss, item, '|')) {
 104                 if (ii == 0) {
 105                         // parse date
 106                         date    = W1Util::parse_date_str(item);
 107                 }
 108                 // skip the device type and device id fields
 109                 // TODO: store device type and id to own file
 110                 else if (ii >= 3) {
 111                         suc_flg = string_to_number<double>(val, item, dec);
 112                         if (suc_flg) {
 113                                 //log_debug("adding number: %f\n", val);
 114                                 v.push_back(val);
 115                         }
 116                 }
 117                 ii++;
 118         }
 119         ret_val = new Data(v, &date);
 120         return ret_val;
 121 }
 122
 123 DataRange::DataRange(int value_count_per_data_item) {
 124         val_matrix      = NULL;
 125         column_count    = value_count_per_data_item;
 126         row_count       = 0;
 127 }
 128
 129 DataRange::DataRange(Data data) {
 130         val_matrix      = NULL;
 131         column_count    = data.value_arr.size();
 132         row_count       = 0;
 133         add_data(data);
 134 }
 135
 136 DataRange::~DataRange() {
 137         unsigned int    ii;
 138         Date            *date;
 139
 140         if (val_matrix != NULL) {
 141                 free(val_matrix);
 142                 val_matrix      = NULL;
 143         }
 144         for (ii = 0; ii < date_list.size(); ii++) {
 145                 date    = date_list.at(ii);
 146                 delete(date);
 147         }
 148 }
 149
 150 void DataRange::add_data(Data data) {
 151         unsigned int    ii;
 152         int             indx;
 153         Date            date;
 154
 155         //log_debug("old row_count: %d, column_count: %d, value_arr_size: %d\n", row_count, column_count, data.value_arr.size());
 156         val_matrix      = (double *)realloc(val_matrix, ((row_count + 1) * column_count) * sizeof(double));
 157         indx            = row_count * column_count;
 158         for (ii = 0; ii < data.value_arr.size(); ii++) {
 159                 val_matrix[indx + ii]   = data.value_arr[ii];
 160         }
 161 /*
 162         for (int ii = 0; ii < ((row_count + 1) * column_count); ii++) {
 163                 log_debug("data_matrix[%d] = %f\n", ii, val_matrix[ii]);
 164         }
 165 */
 166         date    = data.get_date();
 167         date_list.push_back(date.clone());
 168         row_count++;
 169 }
 170
 171 Data *DataRange::get_data(int row_index) {
 172         Data            *ret_val;
 173         int             start_indx;
 174         int             ii;
 175         vector<double>  vector;
 176         Date            *date;
 177
 178         ret_val = NULL;
 179         if ((row_index >= 0) &&
 180             (row_index < row_count)) {
 181                 start_indx      = row_index * column_count;
 182                 for (ii = 0; ii < column_count; ii++) {
 183                         vector.push_back(val_matrix[start_indx + ii]);
 184                 }
 185                 date    = date_list.at(row_index);
 186                 ret_val = new Data(vector, date);
 187         }
 188         return ret_val;
 189 }
 190
 191 int DataRange::get_data_row_count() {
 192         return row_count;
 193 }
 194
 195 int DataRange::get_data_column_count() {
 196         return column_count;
 197 }
 198
 199 Data *DataRange::get_first_data() {
 200         Data    *ret_val;
 201
 202         ret_val = NULL;
 203         if (row_count > 0) {
 204                 ret_val = get_data(0);
 205         }
 206         return ret_val;
 207 }
 208
 209 Data *DataRange::get_last_data() {
 210         return get_data(row_count - 1);
 211 }