]> pilppa.org Git - lib1wire.git/blob - src/Data.cc
923def183ee6c553496022bc45eccb45c693434c
[lib1wire.git] / 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 #include <iomanip>
12
13 #include <stdio.h>
14 #include <time.h>
15 #include <malloc.h>
16
17 #include <plp/log.h>
18
19 #include "Data.hh"
20 #include "W1Util.hh"
21
22 using namespace std;
23 using namespace plp;
24 using namespace w1;
25
26 template <class NumberDataType>
27 bool string_to_number(NumberDataType& result,
28                  const string& string_param,
29                  std::ios_base& (*format)(std::ios_base&))
30 {
31         std::istringstream iss(string_param);
32         return !(iss >> format >> result).fail();
33 }
34
35 Data::Data(int size) {
36         value_arr.resize(size);
37 }
38
39 Data::Data(int size, double default_value, string unit_param) {
40         int ii;
41
42         value_arr.resize(size);
43         for (ii = 0; ii < size; ii++) {
44                 value_arr[ii]   = default_value;
45         }
46         unit    = unit_param;
47 }
48
49 Data::Data(vector<double> *vect_param) {
50         unsigned int    ii;
51         unsigned int    sz;
52
53         sz      = vect_param->size();
54         //log_debug("Data(), value count: %d\n", size);
55         value_arr.resize(sz);
56         for (ii = 0; ii < sz; ii++) {
57                 value_arr[ii]   = vect_param->at(ii);
58                 //log_debug("Data(), value[%d]: %f\n", ii, value_arr[ii]);
59         }
60 }
61
62 Data::Data(std::vector<double> *vector_param, string unit_param) {
63         unsigned int    ii;
64         unsigned int    sz;
65
66         sz      = vector_param->size();
67         //log_debug("Data(), value count: %d\n", size);
68         value_arr.resize(sz);
69         for (ii = 0; ii < sz; ii++) {
70                 value_arr[ii]   = vector_param->at(ii);
71                 //log_debug("Data(), value[%d]: %f\n", ii, value_arr[ii]);
72         }
73         unit    = unit_param;
74 }
75
76 Data::Data(vector<double> *vector_param,
77                 Date *date_param,
78                 string unit_param) {
79         unsigned int    ii;
80         unsigned int    size;
81
82         size    = vector_param->size();
83         //log_debug("Data(), value count: %d\n", size);
84         value_arr.resize(size);
85         for (ii = 0; ii < size; ii++) {
86                 value_arr[ii]   = vector_param->at(ii);
87                 //log_debug("Data(), value[%d]: %f\n", ii, value_arr[ii]);
88         }
89         date_time.copy(date_param);
90         unit    = unit_param;
91 }
92
93 Data::Data(std::valarray<double> *val_arr_param, Date *date_param) {
94         unsigned int    ii;
95         unsigned int    sz;
96
97         sz      = val_arr_param->size();
98         value_arr.resize(sz);
99         for (ii = 0; ii < sz; ii++) {
100                 value_arr[ii]   = (*val_arr_param)[ii];
101         }
102         date_time.copy(date_param);
103 }
104
105 Data::~Data() {
106 }
107
108 Data *Data::clone() {
109         Data    *ret_val;
110
111         ret_val = new Data(&value_arr, &date_time);
112         return ret_val;
113 }
114
115 void Data::printout() {
116         log_debug("  data: %s\n", to_string().c_str());
117 }
118
119 plp::Date Data::get_date() {
120         return date_time;
121 }
122
123 void Data::set_date(Date *date_param) {
124         date_time.copy(date_param);
125 }
126
127 string Data::get_unit() {
128         return unit;
129 }
130
131 Data *Data::parse_string(const string& dataline) {
132         stringstream    ss(dataline);
133         string          item;
134         double          val;
135         Data            *ret_val;
136         int             ii;
137         int             sz;
138         bool            suc_flg;
139         vector<double>  v;
140         string          unit;
141         Date            date;
142
143         ii      = 0;
144         ret_val = NULL;
145         //log_debug("parse_string: %s\n", dataline.c_str());
146         while(getline(ss, item, '|')) {
147                 if (ii == 0) {
148                         // parse date
149                         date    = W1Util::parse_date_str(item);
150                 }
151                 else if (ii >= 1) {
152                         suc_flg = string_to_number<double>(val, item, dec);
153                         if (suc_flg) {
154                                 //log_debug("adding number: %f\n", val);
155                                 v.push_back(val);
156                         }
157                 }
158                 ii++;
159         }
160         ii      = item.find_last_of(" ");
161         sz      = item.size();
162         if ((ii >= 0) &&
163             ((ii + 1) <= (sz - 1))) {
164                 unit    = item.substr(ii + 1);
165         }
166         else {
167                 unit    = "";
168         }
169         if (v.size() > 0) {
170                 ret_val = new Data(&v, &date, unit);
171         }
172         return ret_val;
173 }
174
175 string Data::to_string(int dec_precision) {
176         unsigned int    ii;
177         ostringstream   out;
178         string          ret_val;
179
180         ret_val = date_time.to_string();
181         if (value_arr.size() > 0) {
182                 for (ii = 0; ii < value_arr.size(); ii++) {
183                         out << "|" << fixed << setprecision(dec_precision) << value_arr[ii];
184                 }
185                 ret_val.append(out.str());
186                 if (unit.empty() == false) {
187                         ret_val.append(" ");
188                         ret_val.append(unit.c_str());
189                 }
190         }
191         return ret_val;
192 }
193
194 string Data::to_string() {
195         return to_string(3);
196 }
197
198 DataRange::DataRange() {
199         val_matrix      = NULL;
200         column_count    = 0;
201         row_count       = 0;
202         unit            = "";
203 }
204
205 DataRange::DataRange(Data *data) {
206         val_matrix      = NULL;
207         row_count       = 0;
208         if (data != NULL) {
209                 column_count    = data->value_arr.size();
210                 unit            = data->get_unit();
211                 add(data);
212         }
213         else {
214                 column_count    = 0;
215                 unit            = "";
216         }
217 }
218
219 DataRange::DataRange(DataRange *datarange) {
220         val_matrix      = NULL;
221         row_count       = 0;
222         column_count    = 0;
223         unit            = "";
224         if (datarange != NULL) {
225                 add(datarange);
226         }
227 }
228
229 DataRange::DataRange(int value_count_per_data_item, string unit_param) {
230         val_matrix      = NULL;
231         column_count    = value_count_per_data_item;
232         row_count       = 0;
233         unit            = unit_param;
234 }
235
236 DataRange::~DataRange() {
237         unsigned int    ii;
238         Date            *date;
239
240         if (val_matrix != NULL) {
241                 free(val_matrix);
242                 val_matrix      = NULL;
243         }
244         for (ii = 0; ii < date_list.size(); ii++) {
245                 date    = date_list.at(ii);
246                 delete(date);
247         }
248 }
249
250 void DataRange::add(Data *data) {
251         int     ii;
252         int     indx;
253         Date    *date;
254         int     cnt;
255
256         if (data != NULL) {
257                 if ((val_matrix == NULL) &&
258                     (column_count == 0) &&
259                     (unit.empty() == true)) {
260                         column_count    = data->value_arr.size();
261                         unit            = data->get_unit();
262                 }
263                 cnt             = (row_count + 1) * column_count;
264                 val_matrix      = (double *)realloc(val_matrix, cnt * sizeof(double));
265                 indx            = row_count * column_count;
266                 cnt             = data->value_arr.size();
267                 if (cnt != column_count) {
268                         log_error("Error when adding data... Invalid data item count!\n");
269                         if (cnt > column_count) {
270                                 cnt     = column_count;
271                         }
272                         else {
273                                 for (ii = cnt; ii < column_count; ii++) {
274                                         val_matrix[indx + ii]   = 0;
275                                 }
276                         }
277                 }
278                 for (ii = 0; ii < cnt; ii++) {
279                         val_matrix[indx + ii]   = data->value_arr[ii];
280                 }
281 /*
282                 for (int ii = 0; ii < ((row_count + 1) * column_count); ii++) {
283                         log_debug("data_matrix[%d] = %f\n", ii, val_matrix[ii]);
284                 }
285 */
286                 date    = data->get_date().clone();
287                 date_list.push_back(date);
288                 row_count++;
289         }
290 }
291
292 void DataRange::add(DataRange *datarange) {
293         int     ii;
294         int     cnt;
295         Data    *dta;
296
297         if (datarange != NULL) {
298                 cnt     = datarange->get_count();
299                 for (ii = 0; ii < cnt; ii++) {
300                         dta     = datarange->get(ii);
301                         add(dta);
302                         delete(dta);
303                 }
304         }
305 }
306
307 Data *DataRange::get(int row_index) {
308         Data            *ret_val;
309         int             start_indx;
310         int             ii;
311         vector<double>  vect;
312         Date            *date;
313         double          val;
314
315         ret_val = NULL;
316         if ((row_index >= 0) &&
317             (row_index < row_count)) {
318                 start_indx      = row_index * column_count;
319                 for (ii = 0; ii < column_count; ii++) {
320                         //val   = val_matrix[0];
321                         val     = val_matrix[start_indx + ii];
322                         //log_debug("val[%d] = %f\n", (start_indx + ii), val);
323                         vect.push_back(val);
324                 }
325                 date    = date_list.at(row_index);
326                 ret_val = new Data(&vect, date, unit);
327         }
328         return ret_val;
329 }
330
331 int DataRange::get_count() {
332         return row_count;
333 }
334
335 int DataRange::get_data_item_value_count() {
336         return column_count;
337 }
338
339 Data *DataRange::get_first() {
340         Data    *ret_val;
341
342         ret_val = NULL;
343         if (row_count > 0) {
344                 ret_val = get(0);
345         }
346         return ret_val;
347 }
348
349 Data *DataRange::get_last() {
350         return get(row_count - 1);
351 }
352
353 void DataRange::printout() {
354         int     ii;
355         Data    *data;
356
357         log_debug("---- DataRange, number of data items: %d\n ----", row_count);
358         for (ii = 0; ii < row_count; ii++) {
359                 data    = get(ii);
360                 if (data != NULL) {
361                         data->printout();
362                         delete(data);
363                 }
364         }
365         log_debug("---- DataRange printout done ----\n");
366 }