framework/src/EngineController/param_spec.c

   1 /*
   2  * sync-agent-framework
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: JuHak Park <juhaki.park@samsung.com>,
   7  *          JuneHyuk Lee <junhyuk7.lee@samsung.com>,
   8  *          SunBong Ha <sunbong.ha@samsung.com>
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  * http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  *
  22  */
  23
  24
  25
  26
  27 /*
  28  * For any sort of issue you concern as to this software,
  29  * you may use following point of contact.
  30  * All resources contributed on this software
  31  * are orinigally written by S-Core Inc., a member of Samsung Group.
  32  *
  33  * Wook Choi <wook.choi@samsung.com>
  34  */
  35
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <stdarg.h>
  40 #include <assert.h>             /* TODO : replace with fw_assert.h */
  41 #include <glib.h>
  42 #include "EngineController/param_spec.h"
  43 #include "EngineController/param_spec_internal.h"
  44
  45 static inline ec_boolean is_flag_on(ECParamFlags flags, ECParamFlags check_flag);
  46 static inline void on_flag(ECParamFlags *flags, ECParamFlags on_flag);
  47
  48 /* TODO */
  49 static void free_param_spec(param_spec *pParam_spec);
  50
  51 /* internal */
  52 static ec_boolean param_char_validate_func(ec_int8 value, ec_int8 minimum, ec_int8 maximum);
  53 static ec_boolean param_uchar_validate_func(ec_uint8 value, ec_uint8 minimum, ec_uint8 maximum);
  54 static ec_boolean param_int_validate_func(ec_int value, ec_int minimum, ec_int maximum);
  55 static ec_boolean param_uint_validate_func(ec_uint value, ec_uint minimum, ec_uint maximum);
  56 static ec_boolean param_float_validate_func(ec_float value, ec_float minimum, ec_float maximum);
  57 static ec_boolean param_double_validate_func(ec_double value, ec_double minimum, ec_double maximum);
  58
  59 static param_spec_char_validate *alloc_init_param_spec_char_validate(ec_int8 minimum, ec_int8 maximum, char_validate_func valid_func);
  60 static param_spec_uchar_validate *alloc_init_param_spec_uchar_validate(ec_uint8 minimum, ec_uint8 maximum, uchar_validate_func valid_func);
  61 static param_spec_int_validate *alloc_init_param_spec_int_validate(ec_int minimum, ec_int maximum, int_validate_func valid_func);
  62 static param_spec_uint_validate *alloc_init_param_spec_uint_validate(ec_uint minimum, ec_uint maximum, uint_validate_func valid_func);
  63 static param_spec_float_validate *alloc_init_param_spec_float_validate(ec_float minimum, ec_float maximum, float_validate_func valid_func);
  64 static param_spec_double_validate *alloc_init_param_spec_double_validate(ec_double minimum, ec_double maximum, double_validate_func valid_func);
  65
  66 static ec_boolean alloc_and_init_param_spec_number_type_validate(const ECValueType value_type, ec_constpointer minimum, ec_constpointer maximum, private_validate *pPrivate_validate);
  67
  68 static param_spec *alloc_and_init_param_spec_default(const ECValueType value_type, const ec_char *name);
  69
  70 static param_spec *alloc_and_init_param_spec_number_type(const ECValueType value_type, const ec_char *name, ec_boolean is_input, ec_boolean is_output, ec_boolean input_validate_on, ec_constpointer input_minimum, ec_constpointer input_maximum, ec_boolean input_default_on, ec_constpointer input_default_value, ec_boolean output_validate_on, ec_constpointer output_minimum, ec_constpointer output_maximum);
  71
  72 static inline param_spec *alloc_and_init_param_spec_struct_type(const ec_char *name, ec_boolean is_input, ec_boolean is_output, ec_boolean input_validate_on, validate_struct_func_callback input_val_func, ec_boolean input_default_on, ec_constpointer input_default_value, ec_boolean output_validate_on, validate_struct_func_callback output_val_func, copy_struct_func_callback copy_func, free_struct_func_callback free_func);
  73
  74 static ec_boolean param_char_validate_func(ec_int8 value, ec_int8 minimum, ec_int8 maximum)
  75 {
  76         if (value < minimum)
  77                 return false;
  78         if (value > maximum)
  79                 return false;
  80         return true;
  81 }
  82
  83 static ec_boolean param_uchar_validate_func(ec_uint8 value, ec_uint8 minimum, ec_uint8 maximum)
  84 {
  85         if (value < minimum)
  86                 return false;
  87         if (value > maximum)
  88                 return false;
  89         return true;
  90 }
  91
  92 static ec_boolean param_int_validate_func(ec_int value, ec_int minimum, ec_int maximum)
  93 {
  94         if (value < minimum)
  95                 return false;
  96         if (value > maximum)
  97                 return false;
  98         return true;
  99 }
 100
 101 static ec_boolean param_uint_validate_func(ec_uint value, ec_uint minimum, ec_uint maximum)
 102 {
 103         if (value < minimum)
 104                 return false;
 105         if (value > maximum)
 106                 return false;
 107         return true;
 108 }
 109
 110 static ec_boolean param_float_validate_func(ec_float value, ec_float minimum, ec_float maximum)
 111 {
 112         if (value < minimum)
 113                 return false;
 114         if (value > maximum)
 115                 return false;
 116         return true;
 117 }
 118
 119 static ec_boolean param_double_validate_func(ec_double value, ec_double minimum, ec_double maximum)
 120 {
 121         if (value < minimum)
 122                 return false;
 123         if (value > maximum)
 124                 return false;
 125         return true;
 126 }
 127
 128 static param_spec_char_validate *alloc_init_param_spec_char_validate(ec_int8 minimum, ec_int8 maximum, char_validate_func valid_func)
 129 {
 130         param_spec_char_validate *pValid = (param_spec_char_validate *) malloc(sizeof(param_spec_char_validate));
 131         if (pValid == NULL) {
 132                 return NULL;
 133         }
 134
 135         pValid->minimum = minimum;
 136         pValid->maximum = maximum;
 137         pValid->valid_func = valid_func;
 138
 139         return pValid;
 140 }
 141
 142 static param_spec_uchar_validate *alloc_init_param_spec_uchar_validate(ec_uint8 minimum, ec_uint8 maximum, uchar_validate_func valid_func)
 143 {
 144         param_spec_uchar_validate *pValid = (param_spec_uchar_validate *) malloc(sizeof(param_spec_uchar_validate));
 145         if (pValid == NULL) {
 146                 return NULL;
 147         }
 148
 149         pValid->minimum = minimum;
 150         pValid->maximum = maximum;
 151         pValid->valid_func = valid_func;
 152
 153         return pValid;
 154 }
 155
 156 static param_spec_int_validate *alloc_init_param_spec_int_validate(ec_int minimum, ec_int maximum, int_validate_func valid_func)
 157 {
 158         param_spec_int_validate *pValid = (param_spec_int_validate *) malloc(sizeof(param_spec_int_validate));
 159         if (pValid == NULL) {
 160                 return NULL;
 161         }
 162
 163         pValid->minimum = minimum;
 164         pValid->maximum = maximum;
 165         pValid->valid_func = valid_func;
 166
 167         return pValid;
 168 }
 169
 170 static param_spec_uint_validate *alloc_init_param_spec_uint_validate(ec_uint minimum, ec_uint maximum, uint_validate_func valid_func)
 171 {
 172         param_spec_uint_validate *pValid = (param_spec_uint_validate *) malloc(sizeof(param_spec_uint_validate));
 173         if (pValid == NULL) {
 174                 return NULL;
 175         }
 176
 177         pValid->minimum = minimum;
 178         pValid->maximum = maximum;
 179         pValid->valid_func = valid_func;
 180
 181         return pValid;
 182 }
 183
 184 static param_spec_float_validate *alloc_init_param_spec_float_validate(ec_float minimum, ec_float maximum, float_validate_func valid_func)
 185 {
 186         param_spec_float_validate *pValid = (param_spec_float_validate *) malloc(sizeof(param_spec_float_validate));
 187         if (pValid == NULL) {
 188                 return NULL;
 189         }
 190
 191         pValid->minimum = minimum;
 192         pValid->maximum = maximum;
 193         pValid->valid_func = valid_func;
 194
 195         return pValid;
 196 }
 197
 198 static param_spec_double_validate *alloc_init_param_spec_double_validate(ec_double minimum, ec_double maximum, double_validate_func valid_func)
 199 {
 200         param_spec_double_validate *pValid = (param_spec_double_validate *) malloc(sizeof(param_spec_double_validate));
 201         if (pValid == NULL) {
 202                 return NULL;
 203         }
 204
 205         pValid->minimum = minimum;
 206         pValid->maximum = maximum;
 207         pValid->valid_func = valid_func;
 208
 209         return pValid;
 210 }
 211
 212 static param_spec *alloc_and_init_param_spec_default(const ECValueType value_type, const ec_char *name)
 213 {
 214         param_spec *pParam_spec = (param_spec *)calloc(1, sizeof(param_spec));
 215         if (pParam_spec == NULL) {
 216                 return NULL;
 217         }
 218
 219         ec_char *dup_name = strdup(name);
 220         if (dup_name == NULL) {
 221                 free_param_spec(pParam_spec);
 222                 return NULL;
 223         }
 224
 225         pParam_spec->ref_count = 1;
 226         pParam_spec->value_type = value_type;
 227         pParam_spec->name = dup_name;
 228         pParam_spec->flags = EC_PARAM_FLAG_DEFAULT;
 229
 230         return pParam_spec;
 231 }
 232
 233 static ec_boolean alloc_and_init_param_spec_number_type_validate(const ECValueType value_type, ec_constpointer minimum, ec_constpointer maximum, private_validate *pPrivate_validate)
 234 {
 235         ec_boolean success = false;
 236         switch (value_type) {
 237         case EC_VALUE_TYPE_CHAR:
 238                 {
 239                         param_spec_char_validate *pValid = alloc_init_param_spec_char_validate(*(ec_int8 *) minimum, *(ec_int8 *) maximum, param_char_validate_func);
 240                         if (pValid == NULL) {
 241                                 goto return_part;
 242                         }
 243                         pPrivate_validate->char_validate = pValid;
 244                 }
 245                 break;
 246         case EC_VALUE_TYPE_UCHAR:
 247                 {
 248                         param_spec_uchar_validate *pValid = alloc_init_param_spec_uchar_validate(*(ec_uint8 *) minimum, *(ec_uint8 *) maximum, param_uchar_validate_func);
 249                         if (pValid == NULL) {
 250                                 goto return_part;
 251                         }
 252                         pPrivate_validate->uchar_validate = pValid;
 253                 }
 254                 break;
 255         case EC_VALUE_TYPE_INT:
 256                 {
 257                         param_spec_int_validate *pValid = alloc_init_param_spec_int_validate(*(ec_int *)minimum, *(ec_int *)maximum, param_int_validate_func);
 258                         if (pValid == NULL) {
 259                                 goto return_part;
 260                         }
 261                         pPrivate_validate->int_validate = pValid;
 262                 }
 263                 break;
 264         case EC_VALUE_TYPE_UINT:
 265                 {
 266                         param_spec_uint_validate *pValid = alloc_init_param_spec_uint_validate(*(ec_uint *)minimum, *(ec_uint *)maximum, param_uint_validate_func);
 267                         if (pValid == NULL) {
 268                                 goto return_part;
 269                         }
 270                         pPrivate_validate->uint_validate = pValid;
 271                 }
 272                 break;
 273         case EC_VALUE_TYPE_FLOAT:
 274                 {
 275                         param_spec_float_validate *pValid = alloc_init_param_spec_float_validate(*(ec_float *) minimum, *(ec_float *) maximum, param_float_validate_func);
 276                         if (pValid == NULL) {
 277                                 goto return_part;
 278                         }
 279                         pPrivate_validate->float_validate = pValid;
 280                 }
 281                 break;
 282         case EC_VALUE_TYPE_DOUBLE:
 283                 {
 284                         param_spec_double_validate *pValid = alloc_init_param_spec_double_validate(*(ec_double *) minimum, *(ec_double *) maximum, param_double_validate_func);
 285                         if (pValid == NULL) {
 286                                 goto return_part;
 287                         }
 288                         pPrivate_validate->double_validate = pValid;
 289                 }
 290                 break;
 291         default:
 292                 assert(false);
 293         }
 294
 295         success = true;
 296
 297 return_part:
 298         return success;
 299 }
 300
 301 static param_spec *alloc_and_init_param_spec_number_type(const ECValueType value_type, const ec_char *name, ec_boolean is_input, ec_boolean is_output, ec_boolean input_validate_on, ec_constpointer input_minimum, ec_constpointer input_maximum, ec_boolean input_default_on, ec_constpointer input_default_value, ec_boolean output_validate_on, ec_constpointer output_minimum, ec_constpointer output_maximum)
 302 {
 303         ec_boolean success = true;
 304         param_spec *pParam_spec = alloc_and_init_param_spec_default(value_type, name);
 305         if (pParam_spec == NULL) {
 306                 goto error_part;
 307         }
 308
 309         if (is_input) {
 310                 on_flag(&(pParam_spec->flags), EC_PARAM_FLAG_INPUT);
 311
 312                 if (input_validate_on) {
 313                         on_flag(&(pParam_spec->flags), EC_PARAM_FLAG_INPUT_VALIDATE_ON);
 314                         success = alloc_and_init_param_spec_number_type_validate(value_type, input_minimum, input_maximum, &(pParam_spec->input_validate));
 315                         if (!success) {
 316                                 goto error_part;
 317                         }
 318                 }
 319
 320                 if (input_default_on) {
 321                         on_flag(&(pParam_spec->flags), EC_PARAM_FLAG_INPUT_DEFAULT_VALUE_ON);
 322                         param_value_set_value(&(pParam_spec->default_value), value_type, input_default_value);
 323                 }
 324         }
 325
 326         if (is_output) {
 327                 on_flag(&(pParam_spec->flags), EC_PARAM_FLAG_OUTPUT);
 328                 success = alloc_and_init_param_spec_number_type_validate(value_type, output_minimum, output_maximum, &(pParam_spec->output_validate));
 329         }
 330
 331         return pParam_spec;
 332
 333 error_part:
 334         free_param_spec(pParam_spec);
 335         return NULL;
 336 }
 337
 338 static inline param_spec *alloc_and_init_param_spec_struct_type(const ec_char *name, ec_boolean is_input, ec_boolean is_output, ec_boolean input_validate_on, validate_struct_func_callback input_val_func, ec_boolean input_default_on, ec_constpointer input_default_value, ec_boolean output_validate_on, validate_struct_func_callback output_val_func, copy_struct_func_callback copy_func, free_struct_func_callback free_func)
 339 {
 340         ec_boolean success = true;
 341         param_spec *pParam_spec = alloc_and_init_param_spec_default(EC_VALUE_TYPE_STRUCT, name);
 342         if (pParam_spec == NULL) {
 343                 goto error_part;
 344         }
 345
 346         if (is_input) {
 347                 on_flag(&(pParam_spec->flags), EC_PARAM_FLAG_INPUT);
 348
 349                 if (input_validate_on) {
 350                         on_flag(&(pParam_spec->flags), EC_PARAM_FLAG_INPUT_VALIDATE_ON);
 351                         pParam_spec->input_validate.struct_validate_func = input_val_func;
 352
 353                         if (!success) {
 354                                 goto error_part;
 355                         }
 356                 }
 357
 358                 if (input_default_on) {
 359                         on_flag(&(pParam_spec->flags), EC_PARAM_FLAG_INPUT_DEFAULT_VALUE_ON);
 360                         param_value_set_value(&(pParam_spec->default_value), EC_VALUE_TYPE_STRUCT, input_default_value);
 361                 }
 362         }
 363
 364         if (is_output) {
 365                 on_flag(&(pParam_spec->flags), EC_PARAM_FLAG_OUTPUT);
 366                 pParam_spec->output_validate.struct_validate_func = output_val_func;
 367         }
 368
 369         pParam_spec->copy_struct_func = copy_func;
 370         pParam_spec->free_struct_func = free_func;
 371
 372         return pParam_spec;
 373
 374 error_part:
 375         free_param_spec(pParam_spec);
 376         return NULL;
 377 }
 378
 379 inline ec_boolean is_input_flag_on(ECParamFlags flags)
 380 {
 381         return is_flag_on(flags, EC_PARAM_FLAG_INPUT);
 382 }
 383
 384 inline ec_boolean is_output_flag_on(ECParamFlags flags)
 385 {
 386         return is_flag_on(flags, EC_PARAM_FLAG_OUTPUT);
 387 }
 388
 389 inline ec_boolean is_input_validate_on_flag_on(ECParamFlags flags)
 390 {
 391         return is_flag_on(flags, EC_PARAM_FLAG_INPUT_VALIDATE_ON);
 392 }
 393
 394 inline ec_boolean is_output_validate_on_flag_on(ECParamFlags flags)
 395 {
 396         return is_flag_on(flags, EC_PARAM_FLAG_OUTPUT_VALIDATE_ON);
 397 }
 398
 399 inline ec_boolean is_input_default_value_on_flag_on(ECParamFlags flags)
 400 {
 401         return is_flag_on(flags, EC_PARAM_FLAG_INPUT_DEFAULT_VALUE_ON);
 402 }
 403
 404 inline ec_boolean is_flag_on(ECParamFlags flags, ECParamFlags check_flag)
 405 {
 406         return (flags & check_flag);
 407 }
 408
 409 static inline void on_flag(ECParamFlags *flags, ECParamFlags on_flag)
 410 {
 411         *flags |= on_flag;
 412 }
 413
 414 static void free_param_spec(param_spec *pParam_spec)
 415 {
 416         if (pParam_spec != NULL) {
 417                 if (pParam_spec->name != NULL) {
 418                         free(pParam_spec->name);
 419                 }
 420
 421                 /* note : don't free pParam_spec->pTask */
 422
 423                 /* TODO : free other element */
 424                 free(pParam_spec);
 425         }
 426 }
 427
 428 /* external */
 429 param_spec *param_spec_ref(param_spec *pParam_spec)
 430 {
 431         if (pParam_spec == NULL) {
 432                 return NULL;
 433         }
 434
 435         g_atomic_int_inc(&(pParam_spec->ref_count));
 436
 437         return pParam_spec;
 438 }
 439
 440 void param_spec_unref(param_spec *pParam_spec)
 441 {
 442         if (pParam_spec == NULL) {
 443                 return;
 444         }
 445
 446         if (g_atomic_int_dec_and_test(&(pParam_spec->ref_count))) {
 447                 free_param_spec(pParam_spec);
 448         }
 449 }
 450
 451 param_spec *param_spec_boolean(const ec_char *name, ec_boolean is_input, ec_boolean is_output, ec_boolean input_default_on, ec_boolean input_default_value)
 452 {
 453         ECValueType value_type = EC_VALUE_TYPE_BOOLEAN;
 454         param_spec *pParam_spec = alloc_and_init_param_spec_default(value_type, name);
 455         if (pParam_spec == NULL) {
 456                 goto error_part;
 457         }
 458
 459         if (is_input) {
 460                 on_flag(&(pParam_spec->flags), EC_PARAM_FLAG_INPUT);
 461
 462                 if (input_default_on) {
 463                         on_flag(&(pParam_spec->flags), EC_PARAM_FLAG_INPUT_DEFAULT_VALUE_ON);
 464                         param_value_set_value(&(pParam_spec->default_value), value_type, &input_default_value);
 465                 }
 466         }
 467
 468         if (is_output) {
 469                 on_flag(&(pParam_spec->flags), EC_PARAM_FLAG_OUTPUT);
 470         }
 471
 472         return pParam_spec;
 473
 474 error_part:
 475         free_param_spec(pParam_spec);
 476         return NULL;
 477 }
 478
 479 param_spec *param_spec_char(const ec_char *name, ec_boolean is_input, ec_boolean is_output, ec_boolean input_validate_on, ec_int8 input_minimum, ec_int8 input_maximum, ec_boolean input_default_on, ec_int8 input_default_value, ec_boolean output_validate_on, ec_int8 output_minimum, ec_int8 output_maximum)
 480 {
 481         param_spec *pParam_spec = alloc_and_init_param_spec_number_type(EC_VALUE_TYPE_CHAR, name,
 482                                                                         is_input, is_output,
 483                                                                         input_validate_on, &input_minimum, &input_maximum,
 484                                                                         input_default_on, &input_default_value,
 485                                                                         output_validate_on, &output_minimum, &output_maximum);
 486         return pParam_spec;
 487 }
 488
 489 param_spec *param_spec_uchar(const ec_char *name, ec_boolean is_input, ec_boolean is_output, ec_boolean input_validate_on, ec_uint8 input_minimum, ec_uint8 input_maximum, ec_boolean input_default_on, ec_uint8 input_default_value, ec_boolean output_validate_on, ec_uint8 output_minimum, ec_uint8 output_maximum)
 490 {
 491         param_spec *pParam_spec = alloc_and_init_param_spec_number_type(EC_VALUE_TYPE_UCHAR, name,
 492                                                                         is_input, is_output,
 493                                                                         input_validate_on, &input_minimum, &input_maximum,
 494                                                                         input_default_on, &input_default_value,
 495                                                                         output_validate_on, &output_minimum, &output_maximum);
 496         return pParam_spec;
 497 }
 498
 499 param_spec *param_spec_int(const ec_char *name, ec_boolean is_input, ec_boolean is_output, ec_boolean input_validate_on, ec_int input_minimum, ec_int input_maximum, ec_boolean input_default_on, ec_int input_default_value, ec_boolean output_validate_on, ec_int output_minimum, ec_int output_maximum)
 500 {
 501         param_spec *pParam_spec = alloc_and_init_param_spec_number_type(EC_VALUE_TYPE_INT, name,
 502                                                                         is_input, is_output,
 503                                                                         input_validate_on, &input_minimum, &input_maximum,
 504                                                                         input_default_on, &input_default_value,
 505                                                                         output_validate_on, &output_minimum, &output_maximum);
 506         return pParam_spec;
 507 }
 508
 509 param_spec *param_spec_uint(const ec_char *name, ec_boolean is_input, ec_boolean is_output, ec_boolean input_validate_on, ec_uint input_minimum, ec_uint input_maximum, ec_boolean input_default_on, ec_uint input_default_value, ec_boolean output_validate_on, ec_uint output_minimum, ec_uint output_maximum)
 510 {
 511         param_spec *pParam_spec = alloc_and_init_param_spec_number_type(EC_VALUE_TYPE_UINT, name,
 512                                                                         is_input, is_output,
 513                                                                         input_validate_on, &input_minimum, &input_maximum,
 514                                                                         input_default_on, &input_default_value,
 515                                                                         output_validate_on, &output_minimum, &output_maximum);
 516         return pParam_spec;
 517 }
 518
 519 param_spec *param_spec_float(const ec_char *name, ec_boolean is_input, ec_boolean is_output, ec_boolean input_validate_on, ec_float input_minimum, ec_float input_maximum, ec_boolean input_default_on, ec_float input_default_value, ec_boolean output_validate_on, ec_float output_minimum, ec_float output_maximum)
 520 {
 521         param_spec *pParam_spec = alloc_and_init_param_spec_number_type(EC_VALUE_TYPE_FLOAT, name,
 522                                                                         is_input, is_output,
 523                                                                         input_validate_on, &input_minimum, &input_maximum,
 524                                                                         input_default_on, &input_default_value,
 525                                                                         output_validate_on, &output_minimum, &output_maximum);
 526         return pParam_spec;
 527 }
 528
 529 param_spec *param_spec_double(const ec_char *name, ec_boolean is_input, ec_boolean is_output, ec_boolean input_validate_on, ec_double input_minimum, ec_double input_maximum, ec_boolean input_default_on, ec_double input_default_value, ec_boolean output_validate_on, ec_double output_minimum, ec_double output_maximum)
 530 {
 531         param_spec *pParam_spec = alloc_and_init_param_spec_number_type(EC_VALUE_TYPE_DOUBLE, name,
 532                                                                         is_input, is_output,
 533                                                                         input_validate_on, &input_minimum, &input_maximum,
 534                                                                         input_default_on, &input_default_value,
 535                                                                         output_validate_on, &output_minimum, &output_maximum);
 536         return pParam_spec;
 537 }
 538
 539 param_spec *param_spec_structure(const ec_char *name, copy_struct_func_callback copy_func, free_struct_func_callback free_func, ec_boolean is_input, ec_boolean is_output, ec_boolean input_validate_on, validate_struct_func_callback in_val_func, ec_boolean input_default_on, ec_pointer pDefault_Struct, ec_boolean output_validate_on, validate_struct_func_callback out_val_func)
 540 {
 541         return alloc_and_init_param_spec_struct_type(name, is_input, is_output, input_validate_on, in_val_func, input_default_on, pDefault_Struct, output_validate_on, out_val_func, copy_func, free_func);
 542 }
 543
 544 const ECValueType param_spec_get_value_type(param_spec *pParam_spec)
 545 {
 546         if (pParam_spec == NULL) {
 547                 return EC_VALUE_TYPE_UNKNOWN;
 548         }
 549
 550         return pParam_spec->value_type;
 551 }
 552
 553 const ec_char *param_spec_get_name(param_spec *pParam_spec)
 554 {
 555         if (pParam_spec == NULL) {
 556                 return NULL;
 557         }
 558
 559         return pParam_spec->name;
 560 }