prop_dictionary_util.c revision 1.2.8.1 
1/*	$NetBSD: prop_dictionary_util.c,v 1.2.8.1 2008/05/18 12:28:47 yamt 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
44bool
45prop_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
60bool
61prop_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)							\
78bool								\
79prop_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									\
105bool								\
106prop_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									\
130bool								\
131prop_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									\
147bool								\
148prop_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
164TEMPLATE(8)
165TEMPLATE(16)
166TEMPLATE(32)
167TEMPLATE(64)
168
169#undef TEMPLATE
170
171#define	TEMPLATE(variant, qualifier)					\
172bool								\
173prop_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									\
188bool								\
189prop_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
205TEMPLATE(,)
206TEMPLATE(_nocopy,const)
207
208#undef TEMPLATE
209