"Initial commit to Gerrit"
[profile/ivi/libgsf.git] / gsf / gsf-utils.h
1 /* vim: set sw=8: -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
2 /*
3  * gsf-utils.h: 
4  *
5  * Copyright (C) 2002-2006 Jody Goldberg (jody@gnome.org)
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of version 2.1 of the GNU Lesser General Public
9  * License as published by the Free Software Foundation.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
19  * USA
20  */
21
22 #ifndef GSF_UTILS_H
23 #define GSF_UTILS_H
24
25 #include <gsf/gsf.h>
26 #include <glib-object.h>
27
28 G_BEGIN_DECLS
29
30 /* Do this the ugly way so that we don't have to worry about alignment */
31
32 /**
33  * GSF_LE_GET_GUINT8
34  * @p: pointer to storage
35  *
36  * Interpret binary data as an unsigned 8-bit integer in little endian order.
37  *
38  * Returns: interpreted data
39  */
40 #define GSF_LE_GET_GUINT8(p) (*(guint8 const *)(p))
41
42 /**
43  * GSF_LE_GET_GUINT16
44  * @p: pointer to storage
45  *
46  * Interpret binary data as an unsigned 16-bit integer in little endian order.
47  *
48  * Returns: interpreted data
49  */
50 #define GSF_LE_GET_GUINT16(p)                           \
51         (guint16)((((guint8 const *)(p))[0] << 0)  |    \
52                   (((guint8 const *)(p))[1] << 8))
53
54 /**
55  * GSF_LE_GET_GUINT32
56  * @p: pointer to storage
57  *
58  * Interpret binary data as an unsigned 32-bit integer in little endian order.
59  *
60  * Returns: interpreted data
61  */
62 #define GSF_LE_GET_GUINT32(p)                           \
63         (guint32)((((guint8 const *)(p))[0] << 0)  |    \
64                   (((guint8 const *)(p))[1] << 8)  |    \
65                   (((guint8 const *)(p))[2] << 16) |    \
66                   (((guint8 const *)(p))[3] << 24))
67
68 /**
69  * GSF_LE_GET_GUINT64
70  * @p: pointer to storage
71  *
72  * Interpret binary data as an unsigned 64-bit integer in little endian order.
73  *
74  * Returns: interpreted data
75  */
76 #define GSF_LE_GET_GUINT64(p) (gsf_le_get_guint64 (p))
77
78 /**
79  * GSF_LE_GET_GINT8
80  * @p: pointer to storage
81  *
82  * Interpret binary data as a signed 8-bit integer in little endian order.
83  *
84  * Returns: interpreted data
85  */
86 #define GSF_LE_GET_GINT8(p) ((gint8)GSF_LE_GET_GUINT8(p))
87
88 /**
89  * GSF_LE_GET_GINT16
90  * @p: pointer to storage
91  *
92  * Interpret binary data as a signed 16-bit integer in little endian order.
93  *
94  * Returns: interpreted data
95  */
96 #define GSF_LE_GET_GINT16(p) ((gint16)GSF_LE_GET_GUINT16(p))
97
98 /**
99  * GSF_LE_GET_GINT32
100  * @p: pointer to storage
101  *
102  * Interpret binary data as a signed 32-bit integer in little endian order.
103  *
104  * Returns: interpreted data
105  */
106 #define GSF_LE_GET_GINT32(p) ((gint32)GSF_LE_GET_GUINT32(p))
107
108 /**
109  * GSF_LE_GET_GINT64
110  * @p: pointer to storage
111  *
112  * Interpret binary data as a signed 64-bit integer in little endian order.
113  *
114  * Returns: interpreted data
115  */
116 #define GSF_LE_GET_GINT64(p) ((gint64)GSF_LE_GET_GUINT64(p))
117
118 /**
119  * GSF_LE_GET_FLOAT
120  * @p: pointer to storage
121  *
122  * Interpret binary data as a float in little endian order.
123  *
124  * Returns: interpreted data
125  */
126 #define GSF_LE_GET_FLOAT(p) (gsf_le_get_float (p))
127
128 /**
129  * GSF_LE_GET_DOUBLE
130  * @p: pointer to storage
131  *
132  * Interpret binary data as a double in little endian order.
133  *
134  * Returns: interpreted data
135  */
136 #define GSF_LE_GET_DOUBLE(p) (gsf_le_get_double (p))
137
138 guint64 gsf_le_get_guint64 (void const *p);
139 float   gsf_le_get_float   (void const *p);
140 double  gsf_le_get_double  (void const *p);
141
142 /**
143  * GSF_LE_SET_GUINT8
144  * @p: pointer to storage
145  * @dat: 8-bit unsigned integer
146  *
147  * Store @dat in little endian order in memory pointed to by @p.
148  */
149 #define GSF_LE_SET_GUINT8(p, dat)                       \
150         (*((guint8 *)(p))      = ((dat)        & 0xff))
151
152 /**
153  * GSF_LE_SET_GUINT16
154  * @p: pointer to storage
155  * @dat: 16-bit unsigned integer
156  *
157  * Store @dat in little endian order in memory pointed to by @p.
158  */
159 #define GSF_LE_SET_GUINT16(p, dat)                      \
160         ((*((guint8 *)(p) + 0) = ((dat)        & 0xff)),\
161          (*((guint8 *)(p) + 1) = ((dat) >>  8) & 0xff))
162
163 /**
164  * GSF_LE_SET_GUINT32
165  * @p: pointer to storage
166  * @dat: 32-bit unsigned integer
167  *
168  * Store @dat in little endian order in memory pointed to by @p.
169  */
170 #define GSF_LE_SET_GUINT32(p, dat)                              \
171         ((*((guint8 *)(p) + 0) = (guchar) ((dat))       & 0xff),        \
172          (*((guint8 *)(p) + 1) = (guchar) ((dat) >>  8) & 0xff),        \
173          (*((guint8 *)(p) + 2) = (guchar) ((dat) >> 16) & 0xff),        \
174          (*((guint8 *)(p) + 3) = (guchar) ((dat) >> 24) & 0xff))
175
176 /**
177  * GSF_LE_SET_GUINT64
178  * @p: pointer to storage
179  * @dat: 64-bit unsigned integer
180  *
181  * Store @dat in little endian order in memory pointed to by @p.
182  */
183 #define GSF_LE_SET_GUINT64(p, dat)                      \
184         ((*((guint8 *)(p) + 0) = (guchar) ((dat))       & 0xff),        \
185          (*((guint8 *)(p) + 1) = (guchar) ((dat) >>  8) & 0xff),        \
186          (*((guint8 *)(p) + 2) = (guchar) ((dat) >> 16) & 0xff),        \
187          (*((guint8 *)(p) + 3) = (guchar) ((dat) >> 24) & 0xff),        \
188          (*((guint8 *)(p) + 4) = (guchar) ((dat) >> 32) & 0xff),        \
189          (*((guint8 *)(p) + 5) = (guchar) ((dat) >> 40) & 0xff),        \
190          (*((guint8 *)(p) + 6) = (guchar) ((dat) >> 48) & 0xff),        \
191          (*((guint8 *)(p) + 7) = (guchar) ((dat) >> 56) & 0xff))
192
193 /**
194  * GSF_LE_SET_GINT8
195  * @p: pointer to storage
196  * @dat: 8-bit signed integer
197  *
198  * Store @dat in little endian order in memory pointed to by @p.
199  */
200 #define GSF_LE_SET_GINT8(p,dat) GSF_LE_SET_GUINT8((p),(dat))
201
202 /**
203  * GSF_LE_SET_GINT16
204  * @p: pointer to storage
205  * @dat: 16-bit signed integer
206  *
207  * Store @dat in little endian order in memory pointed to by @p.
208  */
209 #define GSF_LE_SET_GINT16(p,dat) GSF_LE_SET_GUINT16((p),(dat))
210
211 /**
212  * GSF_LE_SET_GINT32
213  * @p: pointer to storage
214  * @dat: 32-bit signed integer
215  *
216  * Store @dat in little endian order in memory pointed to by @p.
217  */
218 #define GSF_LE_SET_GINT32(p,dat) GSF_LE_SET_GUINT32((p),(dat))
219
220 /**
221  * GSF_LE_SET_GINT64
222  * @p: pointer to storage
223  * @dat: 64-bit signed integer
224  *
225  * Store @dat in little endian order in memory pointed to by @p.
226  */
227 #define GSF_LE_SET_GINT64(p,dat) GSF_LE_SET_GUINT64((p),(dat))
228
229 /**
230  * GSF_LE_SET_FLOAT
231  * @p: pointer to storage
232  * @dat: float to be stored
233  *
234  * Store @dat in little endian order in memory pointed to by @p.
235  */
236 #define GSF_LE_SET_FLOAT(p,dat) gsf_le_set_float((p),(dat))
237
238 /**
239  * GSF_LE_SET_DOUBLE
240  * @p: pointer to storage
241  * @dat: double to be stored
242  *
243  * Store @dat in little endian order in memory pointed to by @p.
244  */
245 #define GSF_LE_SET_DOUBLE(p,dat) gsf_le_set_double((p),(dat))
246
247 void gsf_le_set_float  (void *p, float f);
248 void gsf_le_set_double (void *p, double d);
249
250 void gsf_init (void);
251 void gsf_shutdown (void);
252 void gsf_init_dynamic     (GTypeModule *module);
253 void gsf_shutdown_dynamic (GTypeModule *module);
254 gboolean gsf_debug_flag (const char *flag);
255
256 /* Debugging utilities */
257 void gsf_mem_dump   (guint8 const *ptr, size_t len);
258 void gsf_input_dump (GsfInput *input, gboolean dump_as_hex);
259
260 /* base64 encoding utilities */
261 guint8 *gsf_base64_encode_simple (guint8 const *data, size_t len);
262 size_t  gsf_base64_encode_close  (guint8 const *in, size_t inlen,
263                                   gboolean break_lines, guint8 *out,
264                                   int *state, guint *save);
265 size_t  gsf_base64_encode_step   (guint8 const *in, size_t len,
266                                   gboolean break_lines, guint8 *out,
267                                   int *state, guint *save);
268
269 size_t  gsf_base64_decode_simple (guint8 *data, size_t len);
270 size_t  gsf_base64_decode_step   (guint8 const *in, size_t len,
271                                   guint8 *out, int *state, guint *save);
272
273
274 /* For putting filenames into error messages.  */
275 char *gsf_filename_to_utf8 (char const *filename, gboolean quoted);
276
277 /* Some version checking */
278
279 /**
280  * libgsf_major_version:
281  *
282  * Major version number of libgsf, indicating the ABI version.
283  */
284 extern int libgsf_major_version;
285
286 /**
287  * libgsf_minor_version:
288  *
289  * Minor (secondary) version number of libgsf, indicating the API version.
290  */
291 extern int libgsf_minor_version;
292
293 /**
294  * libgsf_micro_version:
295  *
296  * Micro (tertiary) version number of libgsf, indicating bug fixes.
297  */
298 extern int libgsf_micro_version;
299
300 char const *gsf_extension_pointer (char const * path);
301 void        gsf_iconv_close (GIConv handle);
302
303 void        gsf_property_settings_collect_valist (GType object_type,
304                                                   GParameter **p_params,
305                                                   size_t *p_n_params,
306                                                   const gchar *first_property_name,
307                                                   va_list var_args);
308 void        gsf_property_settings_collect (GType object_type,
309                                            GParameter **p_params,
310                                            size_t *p_n_params,
311                                            const gchar *first_property_name,
312                                            ...);
313 void        gsf_property_settings_free (GParameter *params,
314                                         size_t n_params);
315
316 \f
317
318 /* Errors */
319
320 #define GSF_ERROR (gsf_error_quark ())
321
322 /**
323  * GsfError:
324  * @GSF_ERROR_OUT_OF_MEMORY: Memory allocation failed
325  * @GSF_ERROR_INVALID_DATA: Invalid data encountered (e.g. not enough data)
326  */
327
328 typedef enum {
329         GSF_ERROR_OUT_OF_MEMORY,
330         GSF_ERROR_INVALID_DATA
331 } GsfError;
332
333 GQuark gsf_error_quark (void);
334
335
336 G_END_DECLS
337
338 #endif /* GSF_UTILS_H */