src/value.c

   1 /*
   2 ODKDA: Data Access Library
   3         Value Object
   4
   5 Copyright (C) 2006 Carlos Daniel Ruvalcaba Valenzuela
   6         Contact me: <clsdaniel@gmail.com>
   7
   8 This library is free software; you can redistribute it and/or
   9 modify it under the terms of the GNU Lesser General Public
  10 License as published by the Free Software Foundation; either
  11 version 2.1 of the License, or (at your option) any later version.
  12
  13 This library is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 Lesser General Public License for more details.
  17
  18 You should have received a copy of the GNU Lesser General Public
  19 License along with this library; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21 */
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <malloc.h>
  26 #include <string.h>
  27
  28 #include <odkutils.h>
  29 #include <odkutils_xml.h>
  30
  31 #include <odkda/common.h>
  32 #include <odkda/date.h>
  33 #include <odkda/time.h>
  34 #include <odkda/datetime.h>
  35 #include <odkda/value.h>
  36
  37 void
  38 odk_value_delete (odkValue * v)
  39 {
  40         switch (v->type) {
  41         case ODKDA_TEXT:
  42                 free (v->vString);
  43                 break;
  44         case ODKDA_BLOB:
  45                 free (v->vBlob);
  46                 break;
  47         case ODKDA_DATE:
  48                 free (v->vDate);
  49                 break;
  50         case ODKDA_TIME:
  51                 free (v->vTime);
  52                 break;
  53         case ODKDA_DATETIME:
  54                 free (v->vDateTime);
  55                 break;
  56         default:
  57                 break;
  58         }
  59 }
  60
  61 void
  62 odk_value_init (odkValue * v)
  63 {
  64         v->changed = 0;
  65         switch (v->type) {
  66         case ODKDA_TEXT:
  67                 v->vString = NULL;
  68                 break;
  69         case ODKDA_BLOB:
  70                 v->vBlob = NULL;
  71                 break;
  72         case ODKDA_DATE:
  73                 v->vDate = NULL;
  74                 break;
  75         case ODKDA_TIME:
  76                 v->vTime = NULL;
  77                 break;
  78         case ODKDA_DATETIME:
  79                 v->vDateTime = NULL;
  80                 break;
  81         case ODKDA_BOOL:
  82                 v->vBool = false;
  83                 break;
  84         case ODKDA_CHAR:
  85                 v->vChar = 0;
  86                 break;
  87         case ODKDA_SHORT:
  88                 v->vShort = 0;
  89                 break;
  90         case ODKDA_INT:
  91                 v->vInt = 0;
  92                 break;
  93         case ODKDA_LONG:
  94                 v->vLong = 0;
  95                 break;
  96         case ODKDA_FLOAT:
  97                 v->vFloat = 0.0;
  98                 break;
  99         case ODKDA_DOUBLE:
 100                 v->vDouble = 0.0;
 101                 break;
 102         default:
 103                 break;
 104         }
 105 }
 106
 107 odkValue *
 108 odk_value_new (char type)
 109 {
 110         odkValue *v = (odkValue *) malloc (sizeof (odkValue));
 111
 112         object_register (v, "odkValue");
 113         object_append_destructor (v, (FREE_FUNC)&odk_value_delete);
 114         v->type = type;
 115         v->size = 0;
 116
 117         if (type != 0)
 118                 odk_value_init (v);
 119         return v;
 120 }
 121
 122 odkValue *
 123 odk_value_new_shared (char type, odkMemPool * m)
 124 {
 125         odkValue *v = (odkValue *) odk_mempool_alloc (m, sizeof (odkValue));
 126
 127         object_register (v, "odkValue");
 128         object_append_destructor (v, (FREE_FUNC)&odk_value_delete);
 129         v->type = type;
 130         v->size = 0;
 131
 132         if (type != 0)
 133                 odk_value_init (v);
 134         return v;
 135 }
 136
 137 int
 138 odk_value_set (odkValue * v, char *val)
 139 {
 140         if (v == NULL)
 141                 return 0;
 142
 143         v->changed = 1;
 144         v->vString = strcopy (val);
 145         v->size = strlen(val);
 146 }
 147
 148 int
 149 odk_value_set_bool (odkValue * v, bool val)
 150 {
 151         if (v == NULL)
 152                 return 0;
 153
 154         v->changed = 1;
 155         v->vBool = val;
 156 }
 157
 158 int
 159 odk_value_set_char (odkValue * v, char val)
 160 {
 161         if (v == NULL)
 162                 return 0;
 163
 164         v->changed = 1;
 165         v->vChar = val;
 166 }
 167
 168 int
 169 odk_value_set_short (odkValue * v, short val)
 170 {
 171         if (v == NULL)
 172                 return 0;
 173
 174         v->changed = 1;
 175         v->vShort = val;
 176 }
 177
 178 int
 179 odk_value_set_int (odkValue * v, int val)
 180 {
 181         if (v == NULL)
 182                 return 0;
 183
 184         v->changed = 1;
 185         v->vInt = val;
 186 }
 187
 188 int
 189 odk_value_set_long (odkValue * v, long val)
 190 {
 191         if (v == NULL)
 192                 return 0;
 193
 194         v->changed = 1;
 195         v->vLong = val;
 196 }
 197
 198 int
 199 odk_value_set_float (odkValue * v, float val)
 200 {
 201         if (v == NULL)
 202                 return 0;
 203
 204         v->changed = 1;
 205         v->vFloat = val;
 206 }
 207
 208 int
 209 odk_value_set_double (odkValue * v, double val)
 210 {
 211         if (v == NULL)
 212                 return 0;
 213
 214         v->changed = 1;
 215         v->vDouble = val;
 216 }
 217
 218 int
 219 odk_value_set_blob (odkValue * v, int size, void *val)
 220 {
 221         if (v == NULL)
 222                 return 0;
 223
 224         v->changed = 1;
 225         v->vBlob = val;
 226         v->size = size;
 227 }
 228
 229 int
 230 odk_value_set_date (odkValue * v, odkDate * val)
 231 {
 232         if (v == NULL)
 233                 return 0;
 234
 235         v->changed = 1;
 236         v->vDate = val;
 237 }
 238
 239 int
 240 odk_value_set_time (odkValue * v, odkTime * val)
 241 {
 242         if (v == NULL)
 243                 return 0;
 244
 245         v->changed = 1;
 246         v->vTime = val;
 247 }
 248
 249 int
 250 odk_value_set_datetime (odkValue * v, odkDateTime * val)
 251 {
 252         if (v == NULL)
 253                 return 0;
 254
 255         v->changed = 1;
 256         v->vDateTime = val;
 257 }
 258
 259 char *
 260 odk_value_get (odkValue * v)
 261 {
 262         char *ret = NULL;
 263
 264         switch (v->type) {
 265         case ODKDA_BOOL:
 266                 if (v->vBool) {
 267                         ret = strcopy ("True");
 268                 } else {
 269                         ret = strcopy ("False");
 270                 }
 271                 break;
 272         case ODKDA_CHAR:
 273                 ret = (char *) malloc (sizeof (char) * 4);
 274                 sprintf (ret, "%i", v->vChar);
 275                 break;
 276         case ODKDA_SHORT:
 277                 ret = (char *) malloc (sizeof (char) * 6);
 278                 sprintf (ret, "%i", v->vShort);
 279                 break;
 280         case ODKDA_INT:
 281                 ret = (char *) malloc (sizeof (char) * 10);
 282                 sprintf (ret, "%i", v->vInt);
 283                 break;
 284         case ODKDA_LONG:
 285                 ret = (char *) malloc (sizeof (char) * 16);
 286                 sprintf (ret, "%i", v->vLong);
 287                 break;
 288         case ODKDA_FLOAT:
 289                 ret = (char *) malloc (sizeof (char) * 20);
 290                 sprintf (ret, "%f", v->vFloat);
 291                 break;
 292         case ODKDA_DOUBLE:
 293                 ret = (char *) malloc (sizeof (char) * 25);
 294                 sprintf (ret, "%f", (float)v->vDouble);
 295                 break;
 296         case ODKDA_TEXT:
 297                 ret = strcopy (v->vString);
 298                 break;
 299         case ODKDA_BLOB:
 300                 ret = (char *) v->vBlob;
 301                 break;
 302         default:
 303                 ret = NULL;
 304                 break;
 305         }
 306
 307         return ret;
 308 }
 309
 310 bool
 311 odk_value_get_bool (odkValue * v)
 312 {
 313         if (v == NULL)
 314                 return 0;
 315
 316         return v->vBool;
 317 }
 318
 319 char
 320 odk_value_get_char (odkValue * v)
 321 {
 322         if (v == NULL)
 323                 return 0;
 324
 325         switch (v->type) {
 326         case ODKDA_BOOL:
 327                 return (char) v->vBool;
 328         case ODKDA_CHAR:
 329                 return v->vChar;
 330         default:
 331                 break;
 332         }
 333
 334         return 0;
 335 }
 336
 337 short
 338 odk_value_get_short (odkValue * v)
 339 {
 340         if (v == NULL)
 341                 return 0;
 342
 343         switch (v->type) {
 344         case ODKDA_BOOL:
 345                 return (short) v->vBool;
 346         case ODKDA_CHAR:
 347                 return (short) v->vChar;
 348         case ODKDA_SHORT:
 349                 return v->vShort;
 350         default:
 351                 break;
 352         }
 353
 354         return 0;
 355 }
 356
 357 int
 358 odk_value_get_int (odkValue * v)
 359 {
 360         if (v == NULL)
 361                 return 0;
 362
 363         switch (v->type) {
 364         case ODKDA_BOOL:
 365                 return (int) v->vBool;
 366         case ODKDA_CHAR:
 367                 return (int) v->vChar;
 368         case ODKDA_SHORT:
 369                 return (int) v->vShort;
 370         case ODKDA_INT:
 371                 return v->vInt;
 372         default:
 373                 break;
 374         }
 375
 376         return 0;
 377 }
 378
 379 long
 380 odk_value_get_long (odkValue * v)
 381 {
 382         if (v == NULL)
 383                 return 0;
 384
 385         switch (v->type) {
 386         case ODKDA_BOOL:
 387                 return (long) v->vBool;
 388         case ODKDA_CHAR:
 389                 return (long) v->vChar;
 390         case ODKDA_SHORT:
 391                 return (long) v->vShort;
 392         case ODKDA_INT:
 393                 return (long) v->vInt;
 394         case ODKDA_LONG:
 395                 return v->vLong;
 396         default:
 397                 break;
 398         }
 399
 400         return 0;
 401 }
 402
 403 float
 404 odk_value_get_float (odkValue * v)
 405 {
 406         if (v == NULL)
 407                 return 0;
 408
 409         switch (v->type) {
 410         case ODKDA_BOOL:
 411                 return (float) v->vBool;
 412         case ODKDA_CHAR:
 413                 return (float) v->vChar;
 414         case ODKDA_SHORT:
 415                 return (float) v->vShort;
 416         case ODKDA_INT:
 417                 return (float) v->vInt;
 418         case ODKDA_LONG:
 419                 return (float) v->vLong;
 420         case ODKDA_FLOAT:
 421                 return v->vFloat;
 422         case ODKDA_DOUBLE:
 423                 return (float) v->vDouble;
 424         default:
 425                 break;
 426         }
 427
 428         return 0.0f;
 429 }
 430
 431 double
 432 odk_value_get_double (odkValue * v)
 433 {
 434         if (v == NULL)
 435                 return 0;
 436
 437         switch (v->type) {
 438         case ODKDA_BOOL:
 439                 return (double) v->vBool;
 440         case ODKDA_CHAR:
 441                 return (double) v->vChar;
 442         case ODKDA_SHORT:
 443                 return (double) v->vShort;
 444         case ODKDA_INT:
 445                 return (double) v->vInt;
 446         case ODKDA_LONG:
 447                 return (double) v->vLong;
 448         case ODKDA_FLOAT:
 449                 return (double) v->vFloat;
 450         case ODKDA_DOUBLE:
 451                 return v->vDouble;
 452         default:
 453                 break;
 454         }
 455         return 0;
 456 }
 457
 458 void *
 459 odk_value_get_blob (odkValue * v)
 460 {
 461         if (v == NULL)
 462                 return NULL;
 463         return v->vBlob;
 464 }
 465
 466 odkDate *
 467 odk_value_get_date (odkValue * v)
 468 {
 469         if (v == NULL)
 470                 return NULL;
 471
 472         return v->vDate;
 473 }
 474
 475 odkTime *
 476 odk_value_get_time (odkValue * v)
 477 {
 478         if (v == NULL)
 479                 return NULL;
 480
 481         return v->vTime;
 482 }
 483
 484 odkDateTime *
 485 odk_value_get_datetime (odkValue * v)
 486 {
 487         if (v == NULL)
 488                 return NULL;
 489
 490         return v->vDateTime;
 491 }
 492
 493
 494 int odk_value_get_type(odkValue *v){
 495         if (v == NULL)
 496                 return 0;
 497
 498         return v->type;
 499 }
 500
 501 int odk_value_get_size(odkValue *v){
 502         if (v == NULL)
 503                 return 0;
 504
 505         return v->size;
 506 }
 507
 508 bool odk_value_is_changed(odkValue *v){
 509         if (v == NULL)
 510                 return 0;
 511
 512         return v->changed;
 513 }