src/prop_dictionary_util.c

   1 /*      $NetBSD: prop_dictionary_util.c,v 1.3 2008/04/28 20:22:53 martin Exp $  */
   2
   3 /*-
   4  * Copyright (c) 2006 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Jason R. Thorpe.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 /*
  33  * Utility routines to make it more convenient to work with values
  34  * stored in dictionaries.
  35  *
  36  * Note: There is no special magic going on here.  We use the standard
  37  * proplib(3) APIs to do all of this work.  Any application could do
  38  * exactly what we're doing here.
  39  */
  40
  41 #include <prop/proplib.h>
  42 #include "prop_object_impl.h"   /* only to hide kernel vs. not-kernel */
  43
  44 bool
  45 prop_dictionary_get_bool(prop_dictionary_t dict,
  46                          const char *key,
  47                          bool *valp)
  48 {
  49         prop_bool_t b;
  50
  51         b = prop_dictionary_get(dict, key);
  52         if (prop_object_type(b) != PROP_TYPE_BOOL)
  53                 return (false);
  54
  55         *valp = prop_bool_true(b);
  56
  57         return (true);
  58 }
  59
  60 bool
  61 prop_dictionary_set_bool(prop_dictionary_t dict,
  62                          const char *key,
  63                          bool val)
  64 {
  65         prop_bool_t b;
  66         int rv;
  67
  68         b = prop_bool_create(val);
  69         if (b == NULL)
  70                 return (false);
  71         rv = prop_dictionary_set(dict, key, b);
  72         prop_object_release(b);
  73
  74         return (rv);
  75 }
  76
  77 #define TEMPLATE(size)                                                  \
  78 bool                                                            \
  79 prop_dictionary_get_int ## size (prop_dictionary_t dict,                \
  80                                  const char *key,                       \
  81                                  int ## size ## _t *valp)               \
  82 {                                                                       \
  83         prop_number_t num;                                              \
  84                                                                         \
  85         num = prop_dictionary_get(dict, key);                           \
  86         if (prop_object_type(num) != PROP_TYPE_NUMBER)                  \
  87                 return (false);                                         \
  88                                                                         \
  89         if (prop_number_unsigned(num) &&                                \
  90             prop_number_unsigned_integer_value(num) >                   \
  91            /*CONSTCOND*/((size) ==  8 ?  INT8_MAX :                     \
  92                          (size) == 16 ? INT16_MAX :                     \
  93                          (size) == 32 ? INT32_MAX : INT64_MAX)) {       \
  94                 return (false);                                         \
  95         }                                                               \
  96                                                                         \
  97         if (prop_number_size(num) > (size))                             \
  98                 return (false);                                         \
  99                                                                         \
 100         *valp = (int ## size ## _t) prop_number_integer_value(num);     \
 101                                                                         \
 102         return (true);                                                  \
 103 }                                                                       \
 104                                                                         \
 105 bool                                                            \
 106 prop_dictionary_get_uint ## size (prop_dictionary_t dict,               \
 107                                   const char *key,                      \
 108                                   uint ## size ## _t *valp)             \
 109 {                                                                       \
 110         prop_number_t num;                                              \
 111                                                                         \
 112         num = prop_dictionary_get(dict, key);                           \
 113         if (prop_object_type(num) != PROP_TYPE_NUMBER)                  \
 114                 return (false);                                         \
 115                                                                         \
 116         if (prop_number_unsigned(num) == false &&                       \
 117             prop_number_integer_value(num) < 0) {                       \
 118                 return (false);                                         \
 119         }                                                               \
 120                                                                         \
 121         if (prop_number_size(num) > (size))                             \
 122                 return (false);                                         \
 123                                                                         \
 124         *valp = (uint ## size ## _t)                                    \
 125             prop_number_unsigned_integer_value(num);                    \
 126                                                                         \
 127         return (true);                                                  \
 128 }                                                                       \
 129                                                                         \
 130 bool                                                            \
 131 prop_dictionary_set_int ## size (prop_dictionary_t dict,                \
 132                                  const char *key,                       \
 133                                  int ## size ## _t val)                 \
 134 {                                                                       \
 135         prop_number_t num;                                              \
 136         int rv;                                                         \
 137                                                                         \
 138         num = prop_number_create_integer((int64_t) val);                \
 139         if (num == NULL)                                                \
 140                 return (false);                                         \
 141         rv = prop_dictionary_set(dict, key, num);                       \
 142         prop_object_release(num);                                       \
 143                                                                         \
 144         return (rv);                                                    \
 145 }                                                                       \
 146                                                                         \
 147 bool                                                            \
 148 prop_dictionary_set_uint ## size (prop_dictionary_t dict,               \
 149                                   const char *key,                      \
 150                                   uint ## size ## _t val)               \
 151 {                                                                       \
 152         prop_number_t num;                                              \
 153         int rv;                                                         \
 154                                                                         \
 155         num = prop_number_create_unsigned_integer((uint64_t) val);      \
 156         if (num == NULL)                                                \
 157                 return (false);                                         \
 158         rv = prop_dictionary_set(dict, key, num);                       \
 159         prop_object_release(num);                                       \
 160                                                                         \
 161         return (rv);                                                    \
 162 }
 163
 164 TEMPLATE(8)
 165 TEMPLATE(16)
 166 TEMPLATE(32)
 167 TEMPLATE(64)
 168
 169 #undef TEMPLATE
 170
 171 #define TEMPLATE(variant, qualifier)                                    \
 172 bool                                                            \
 173 prop_dictionary_get_cstring ## variant (prop_dictionary_t dict,         \
 174                                         const char *key,                \
 175                                         qualifier char **cpp)           \
 176 {                                                                       \
 177         prop_string_t str;                                              \
 178                                                                         \
 179         str = prop_dictionary_get(dict, key);                           \
 180         if (prop_object_type(str) != PROP_TYPE_STRING)                  \
 181                 return (false);                                         \
 182                                                                         \
 183         *cpp = prop_string_cstring ## variant (str);                    \
 184                                                                         \
 185         return (*cpp == NULL ? false : true);                           \
 186 }                                                                       \
 187                                                                         \
 188 bool                                                            \
 189 prop_dictionary_set_cstring ## variant (prop_dictionary_t dict,         \
 190                                         const char *key,                \
 191                                         const char *cp)                 \
 192 {                                                                       \
 193         prop_string_t str;                                              \
 194         int rv;                                                         \
 195                                                                         \
 196         str = prop_string_create_cstring ## variant (cp);               \
 197         if (str == NULL)                                                \
 198                 return (false);                                         \
 199         rv = prop_dictionary_set(dict, key, str);                       \
 200         prop_object_release(str);                                       \
 201                                                                         \
 202         return (rv);                                                    \
 203 }
 204
 205 TEMPLATE(,)
 206 TEMPLATE(_nocopy,const)
 207
 208 #undef TEMPLATE