]> pilppa.org Git - lib1wire.git/blob - src/Data.cc
Bug fix for counter device data saving.
[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(Data *data) {
199         val_matrix      = NULL;
200         column_count    = data->value_arr.size();
201         row_count       = 0;
202         unit            = data->get_unit();
203         add_data(data);
204 }
205
206 DataRange::DataRange(int value_count_per_data_item, string unit_param) {
207         val_matrix      = NULL;
208         column_count    = value_count_per_data_item;
209         row_count       = 0;
210         unit            = unit_param;
211 }
212
213 DataRange::~DataRange() {
214         unsigned int    ii;
215         Date            *date;
216
217         if (val_matrix != NULL) {
218                 free(val_matrix);
219                 val_matrix      = NULL;
220         }
221         for (ii = 0; ii < date_list.size(); ii++) {
222                 date    = date_list.at(ii);
223                 delete(date);
224         }
225 }
226
227 void DataRange::add_data(Data *data) {
228         int     ii;
229         int     indx;
230         Date    *date;
231         int     cnt;
232
233         //log_debug("old row_count: %d, column_count: %d, value_arr_size: %d\n", row_count, column_count, data.value_arr.size());
234         cnt             = (row_count + 1) * column_count;
235         val_matrix      = (double *)realloc(val_matrix, cnt * sizeof(double));
236         indx            = row_count * column_count;
237         cnt             = data->value_arr.size();
238         if (cnt != column_count) {
239                 log_error("Error when adding data... Invalid data item count!\n");
240                 if (cnt > column_count) {
241                         cnt     = column_count;
242                 }
243                 else {
244                         for (ii = cnt; ii < column_count; ii++) {
245                                 val_matrix[indx + ii]   = 0;
246                         }
247                 }
248         }
249         for (ii = 0; ii < cnt; ii++) {
250                 val_matrix[indx + ii]   = data->value_arr[ii];
251         }
252 /*
253         for (int ii = 0; ii < ((row_count + 1) * column_count); ii++) {
254                 log_debug("data_matrix[%d] = %f\n", ii, val_matrix[ii]);
255         }
256 */
257         date    = data->get_date().clone();
258         date_list.push_back(date);
259         row_count++;
260 }
261
262 Data *DataRange::get_data(int row_index) {
263         Data            *ret_val;
264         int             start_indx;
265         int             ii;
266         vector<double>  vect;
267         Date            *date;
268         double          val;
269
270         ret_val = NULL;
271         if ((row_index >= 0) &&
272             (row_index < row_count)) {
273                 start_indx      = row_index * column_count;
274                 for (ii = 0; ii < column_count; ii++) {
275                         //val   = val_matrix[0];
276                         val     = val_matrix[start_indx + ii];
277                         log_debug("val[%d] = %f\n", (start_indx + ii), val);
278                         vect.push_back(val);
279                 }
280                 date    = date_list.at(row_index);
281                 ret_val = new Data(&vect, date, unit);
282         }
283         return ret_val;
284 }
285
286 int DataRange::get_data_row_count() {
287         return row_count;
288 }
289
290 int DataRange::get_data_column_count() {
291         return column_count;
292 }
293
294 Data *DataRange::get_first_data() {
295         Data    *ret_val;
296
297         ret_val = NULL;
298         if (row_count > 0) {
299                 ret_val = get_data(0);
300         }
301         return ret_val;
302 }
303
304 Data *DataRange::get_last_data() {
305         return get_data(row_count - 1);
306 }
307
308 void DataRange::printout() {
309         int     ii;
310         Data    *data;
311
312         log_debug("---- DataRange, number of data items: %d\n ----", row_count);
313         for (ii = 0; ii < row_count; ii++) {
314                 data    = get_data(ii);
315                 if (data != NULL) {
316                         data->printout();
317                         delete(data);
318                 }
319         }
320         log_debug("---- DataRange printout done ----\n");
321 }