src/sensor-data.c

   1 /*
   2  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Flora License, Version 1.1 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <stdlib.h>
  18 #include <pthread.h>
  19 #include "log.h"
  20 #include "sensor-data.h"
  21
  22 struct __sensor_data_s {
  23         sensor_data_type_e type;
  24         union {
  25                 int int_val;
  26                 unsigned int uint_val;
  27                 bool b_val;
  28                 double d_val;
  29                 char *str_val;
  30         } value;
  31         pthread_mutex_t mutex;
  32 };
  33
  34 sensor_data *sensor_data_new(sensor_data_type_e type)
  35 {
  36         sensor_data *data = NULL;
  37         retv_if(type == SENSOR_DATA_TYPE_NONE, NULL);
  38
  39         data = calloc(1, sizeof(sensor_data));
  40         retv_if(type == SENSOR_DATA_TYPE_NONE, NULL);
  41
  42         data->type = type;
  43         pthread_mutex_init(&data->mutex, NULL);
  44
  45         return data;
  46 }
  47
  48 void sensor_data_free(sensor_data *data)
  49 {
  50         ret_if(!data);
  51
  52         if (data->type == SENSOR_DATA_TYPE_STR) {
  53                 pthread_mutex_lock(&data->mutex);
  54                 free(data->value.str_val);
  55                 data->value.str_val = NULL;
  56                 pthread_mutex_unlock(&data->mutex);
  57         }
  58         pthread_mutex_destroy(&data->mutex);
  59
  60         free(data);
  61 }
  62
  63 int sensor_data_set_int(sensor_data *data, int value)
  64 {
  65         retv_if(!data, -1);
  66         retv_if(data->type != SENSOR_DATA_TYPE_INT, -1);
  67
  68         pthread_mutex_lock(&data->mutex);
  69         data->value.int_val = value;
  70         pthread_mutex_unlock(&data->mutex);
  71
  72         return 0;
  73 }
  74
  75 int sensor_data_set_uint(sensor_data *data, unsigned int value)
  76 {
  77         retv_if(!data, -1);
  78         retv_if(data->type != SENSOR_DATA_TYPE_UINT, -1);
  79
  80         pthread_mutex_lock(&data->mutex);
  81         data->value.uint_val = value;
  82         pthread_mutex_unlock(&data->mutex);
  83
  84         return 0;
  85 }
  86
  87 int sensor_data_set_bool(sensor_data *data, bool value)
  88 {
  89         retv_if(!data, -1);
  90         retv_if(data->type != SENSOR_DATA_TYPE_BOOL, -1);
  91
  92         pthread_mutex_lock(&data->mutex);
  93         data->value.b_val = value;
  94         pthread_mutex_unlock(&data->mutex);
  95
  96         return 0;
  97 }
  98
  99 int sensor_data_set_double(sensor_data *data, double value)
 100 {
 101         retv_if(!data, -1);
 102         retv_if(data->type != SENSOR_DATA_TYPE_DOUBLE, -1);
 103
 104         pthread_mutex_lock(&data->mutex);
 105         data->value.d_val = value;
 106         pthread_mutex_unlock(&data->mutex);
 107
 108         return 0;
 109 }
 110
 111 int sensor_data_set_string(sensor_data *data, const char *value, unsigned int size)
 112 {
 113         char *temp = NULL;
 114         retv_if(!data, -1);
 115         retv_if(data->type != SENSOR_DATA_TYPE_STR, -1);
 116         retv_if(!value, -1);
 117         retv_if(size == 0, -1);
 118
 119         temp = strndup(value, size);
 120         pthread_mutex_lock(&data->mutex);
 121         free(data->value.str_val);
 122         data->value.str_val = temp;
 123         pthread_mutex_unlock(&data->mutex);
 124
 125         return 0;
 126 }
 127
 128 int sensor_data_get_int(sensor_data *data, int *value)
 129 {
 130         retv_if(!data, -1);
 131         retv_if(!value, -1);
 132         retv_if(data->type != SENSOR_DATA_TYPE_INT, -1);
 133
 134         pthread_mutex_lock(&data->mutex);
 135         *value = data->value.int_val;
 136         pthread_mutex_unlock(&data->mutex);
 137
 138         return 0;
 139 }
 140
 141 int sensor_data_get_uint(sensor_data *data, unsigned int *value)
 142 {
 143         retv_if(!data, -1);
 144         retv_if(!value, -1);
 145         retv_if(data->type != SENSOR_DATA_TYPE_UINT, -1);
 146
 147         pthread_mutex_lock(&data->mutex);
 148         *value = data->value.uint_val;
 149         pthread_mutex_unlock(&data->mutex);
 150
 151         return 0;
 152 }
 153
 154 int sensor_data_get_bool(sensor_data *data, bool *value)
 155 {
 156         retv_if(!data, -1);
 157         retv_if(!value, -1);
 158         retv_if(data->type != SENSOR_DATA_TYPE_BOOL, -1);
 159
 160         pthread_mutex_lock(&data->mutex);
 161         *value = data->value.b_val;
 162         pthread_mutex_unlock(&data->mutex);
 163
 164         return 0;
 165 }
 166
 167 int sensor_data_get_double(sensor_data *data, double *value)
 168 {
 169         retv_if(!data, -1);
 170         retv_if(!value, -1);
 171         retv_if(data->type != SENSOR_DATA_TYPE_DOUBLE, -1);
 172
 173         pthread_mutex_lock(&data->mutex);
 174         *value = data->value.d_val;
 175         pthread_mutex_unlock(&data->mutex);
 176
 177         return 0;
 178 }
 179
 180 int sensor_data_get_string(sensor_data *data, const char **value)
 181 {
 182         retv_if(!data, -1);
 183         retv_if(!value, -1);
 184         retv_if(data->type != SENSOR_DATA_TYPE_STR, -1);
 185
 186         pthread_mutex_lock(&data->mutex);
 187         *value = data->value.str_val;
 188         pthread_mutex_unlock(&data->mutex);
 189
 190         return 0;
 191 }
 192