Asterisk - The Open Source Telephony Project  GIT-master-a24979a
stringfields.h
Go to the documentation of this file.
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2006, Digium, Inc.
5  *
6  * Kevin P. Fleming <kpfleming@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18 
19 /*! \file
20  \page Stringfields String Fields
21  \brief String fields in structures
22 
23  This file contains objects and macros used to manage string
24  fields in structures without requiring them to be allocated
25  as fixed-size buffers or requiring individual allocations for
26  for each field.
27 
28  Using this functionality is quite simple. An example structure
29  with three fields is defined like this:
30 
31  \code
32  struct sample_fields {
33  int x1;
34  AST_DECLARE_STRING_FIELDS(
35  AST_STRING_FIELD(foo);
36  AST_STRING_FIELD(bar);
37  AST_STRING_FIELD(blah);
38  );
39  long x2;
40  };
41  \endcode
42 
43  When an instance of this structure is allocated (either statically or
44  dynamically), the fields and the pool of storage for them must be
45  initialized:
46 
47  \code
48  struct sample_fields *x;
49 
50  x = ast_calloc(1, sizeof(*x));
51  if (x == NULL || ast_string_field_init(x, 252)) {
52  if (x)
53  ast_free(x);
54  x = NULL;
55  ... handle error
56  }
57  \endcode
58 
59  Fields will default to pointing to an empty string, and will revert to
60  that when ast_string_field_set() is called with a NULL argument.
61  A string field will \b never contain NULL.
62 
63  ast_string_field_init(x, 0) will reset fields to the
64  initial value while keeping the pool allocated.
65 
66  Reading the fields is much like using 'const char * const' fields in the
67  structure: you cannot write to the field or to the memory it points to.
68 
69  Writing to the fields must be done using the wrapper macros listed below;
70  and assignments are always by value (i.e. strings are copied):
71  * ast_string_field_set() stores a simple value;
72  * ast_string_field_build() builds the string using a printf-style format;
73  * ast_string_field_build_va() is the varargs version of the above;
74  * variants of these function allow passing a pointer to the field
75  as an argument.
76 
77  \code
78  ast_string_field_set(x, foo, "infinite loop");
79  ast_string_field_set(x, foo, NULL); // set to an empty string
80  ast_string_field_ptr_set(x, &x->bar, "right way");
81 
82  ast_string_field_build(x, blah, "%d %s", zipcode, city);
83  ast_string_field_ptr_build(x, &x->blah, "%d %s", zipcode, city);
84 
85  ast_string_field_build_va(x, bar, fmt, args)
86  ast_string_field_ptr_build_va(x, &x->bar, fmt, args)
87  \endcode
88 
89  When the structure instance is no longer needed, the fields
90  and their storage pool must be freed:
91 
92  \code
93  ast_string_field_free_memory(x);
94  ast_free(x);
95  \endcode
96 
97  A new feature "Extended String Fields" has been added in 13.9.0.
98 
99  An extended field is one that is declared outside the AST_DECLARE_STRING_FIELDS
100  block but still inside the parent structure. It's most useful for extending
101  structures where adding a new string field to an existing AST_DECLARE_STRING_FIELDS
102  block would break ABI compatibility.
103 
104  Example:
105 
106  \code
107  struct original_structure_version {
108  AST_DECLARE_STRING_FIELDS(
109  AST_STRING_FIELD(foo);
110  AST_STRING_FIELD(bar);
111  );
112  int x1;
113  int x2;
114  };
115  \endcode
116 
117  Adding "blah" to the existing string fields breaks ABI compatibility because it changes
118  the offsets of x1 and x2.
119 
120  \code
121  struct new_structure_version {
122  AST_DECLARE_STRING_FIELDS(
123  AST_STRING_FIELD(foo);
124  AST_STRING_FIELD(bar);
125  AST_STRING_FIELD(blah);
126  );
127  int x1;
128  int x2;
129  };
130  \endcode
131 
132  However, adding "blah" as an extended string field to the end of the structure doesn't break
133  ABI compatibility but still allows the use of the existing pool.
134 
135  \code
136  struct new_structure_version {
137  AST_DECLARE_STRING_FIELDS(
138  AST_STRING_FIELD(foo);
139  AST_STRING_FIELD(bar);
140  );
141  int x1;
142  int x2;
143  AST_STRING_FIELD_EXTENDED(blah);
144  };
145  \endcode
146 
147  The only additional step required is to call ast_string_field_init_extended so the
148  pool knows about the new field. It must be called AFTER ast_string_field_init or
149  ast_calloc_with_stringfields. Although ast_calloc_with_stringfields is used in the
150  sample below, it's not necessary for extended string fields.
151 
152  \code
153 
154  struct new_structure_version *x = ast_calloc_with_stringfields(1, struct new_structure_version, 252);
155  if (!x) {
156  return;
157  }
158 
159  ast_string_field_init_extended(x, blah);
160  \endcode
161 
162  The new field can now be treated just like any other string field and it's storage will
163  be released with the rest of the string fields.
164 
165  \code
166  ast_string_field_set(x, foo, "infinite loop");
167  ast_stringfield_free_memory(x);
168  ast_free(x);
169  \endcode
170 
171  This completes the API description.
172 */
173 
174 #ifndef _ASTERISK_STRINGFIELDS_H
175 #define _ASTERISK_STRINGFIELDS_H
176 
177 #include "asterisk/inline_api.h"
178 #include "asterisk/vector.h"
179 
180 /*!
181  \internal
182  \brief An opaque type for managed string fields in structures
183 
184  Don't declare instances of this type directly; use the AST_STRING_FIELD()
185  macro instead.
186 
187  In addition to the string itself, the amount of space allocated for the
188  field is stored in the two bytes immediately preceding it.
189 */
190 typedef const char * ast_string_field;
191 
192 /* the type of storage used to track how many bytes were allocated for a field */
193 
195 
196 /*!
197  \internal
198  \brief A constant empty string used for fields that have no other value
199 */
200 extern const char *__ast_string_field_empty;
201 
202 /*!
203  \internal
204  \brief Structure used to hold a pool of space for string fields
205  \note base is aligned so base+used can stay aligned by incrementing used with
206  aligned numbers only
207 */
209  struct ast_string_field_pool *prev; /*!< pointer to the previous pool, if any */
210  size_t size; /*!< the total size of the pool */
211  size_t used; /*!< the space used in the pool */
212  size_t active; /*!< the amount of space actively in use by fields */
213  char base[0] __attribute__((aligned(__alignof__(ast_string_field_allocation)))); /*!< storage space for the fields */
214 };
215 
216 /*!
217  \internal
218  \brief The definition for the string field vector used for compare and copy
219  \since 13.9.0
220 */
222 
223 /*!
224  \internal
225  \brief Structure used to manage the storage for a set of string fields.
226 */
228  ast_string_field last_alloc; /*!< the last field allocated */
229  struct ast_string_field_pool *embedded_pool; /*!< pointer to the embedded pool, if any */
230  struct ast_string_field_vector string_fields; /*!< field vector for compare and copy */
231 };
232 
233 /*!
234  \internal
235  \brief Attempt to 'grow' an already allocated field to a larger size
236  \param mgr Pointer to the pool manager structure
237  \param pool_head Pointer to the current pool
238  \param needed Amount of space needed for this field
239  \param ptr Pointer to a field within the structure
240  \retval zero on success
241  \retval non-zero on failure
242 
243  This function will attempt to increase the amount of space allocated to
244  an existing field to the amount requested; this is only possible if the
245  field was the last field allocated from the current storage pool and
246  the pool has enough space available. If so, the additional space will be
247  allocated to this field and the field's address will not be changed.
248 */
250  struct ast_string_field_pool **pool_head, size_t needed,
251  const ast_string_field *ptr);
252 
253 /*!
254  \internal
255  \brief Allocate space for a field
256  \param mgr Pointer to the pool manager structure
257  \param pool_head Pointer to the current pool
258  \param needed Amount of space needed for this field
259  \param file, lineno, func
260  \retval NULL on failure
261  \return an address for the field on success.
262 
263  This function will allocate the requested amount of space from
264  the field pool. If the requested amount of space is not available,
265  an additional pool will be allocated.
266 */
268  struct ast_string_field_pool **pool_head, size_t needed,
269  const char *file, int lineno, const char *func);
270 
271 /*!
272  \internal
273  \brief Set a field to a complex (built) value
274  \param mgr Pointer to the pool manager structure
275  \param pool_head Pointer to the current pool
276  \param ptr Pointer to a field within the structure
277  \param format printf-style format string
278  \param file, lineno, func
279 */
280 void __ast_string_field_ptr_build(const char *file, int lineno, const char *func,
281  struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head,
282  ast_string_field *ptr, const char *format, ...) __attribute__((format(printf, 7, 8)));
283 
284 /*!
285  \internal
286  \brief Set a field to a complex (built) value
287  \param mgr Pointer to the pool manager structure
288  \param pool_head Pointer to the current pool
289  \param ptr Pointer to a field within the structure
290  \param format printf-style format string
291  \param ap va_list of the args for the format_string
292  \param file, lineno, func
293 */
295  struct ast_string_field_pool **pool_head,
296  ast_string_field *ptr, const char *format, va_list ap,
297  const char *file, int lineno, const char *func) __attribute__((format(printf, 4, 0)));
298 
299 /*!
300  \brief Declare a string field
301  \param name The field name
302 */
303 #define AST_STRING_FIELD(name) const ast_string_field name
304 
305 /*!
306  \brief Declare an extended string field
307  \since 13.9.0
308 
309  \param name The field name
310 */
311 #define AST_STRING_FIELD_EXTENDED(name) AST_STRING_FIELD(name)
312 
314  /*!
315  * Reset all string fields and free all extra pools that may have been created
316  * The allocation or structure can be reused as is.
317  */
319  /*!
320  * Reset all string fields and free all pools.
321  * If the pointer was returned by ast_calloc_with_stringfields, it can NOT be reused
322  * and should be immediately freed. Otherwise, you must call ast_string_field_init
323  * again if you want to reuse it.
324  */
326 };
327 
328 /*!
329  \brief Declare the fields needed in a structure
330  \param field_list The list of fields to declare, using AST_STRING_FIELD() for each one.
331  Internally, string fields are stored as a pointer to the head of the pool,
332  followed by individual string fields, and then a struct ast_string_field_mgr
333  which describes the space allocated.
334  We split the two variables so they can be used as markers around the
335  field_list, and this allows us to determine how many entries are in
336  the field, and play with them.
337  In particular, for writing to the fields, we rely on __field_mgr_pool to be
338  a non-const pointer, so we know it has the same size as ast_string_field,
339  and we can use it to locate the fields.
340 */
341 #define AST_DECLARE_STRING_FIELDS(field_list) \
342  struct ast_string_field_pool *__field_mgr_pool; \
343  field_list \
344  struct ast_string_field_mgr __field_mgr
345 
346 /*!
347  \brief Initialize a field pool and fields
348  \param x Pointer to a structure containing fields
349  \param size Amount of storage to allocate.
350  Use AST_STRINGFIELD_RESET to reset fields to the default value,
351  and release all but the most recent pool.
352  AST_STRINGFIELD_DESTROY (used internally) means free all pools which is
353  equivalent to calling ast_string_field_free_memory.
354 
355  \retval zero on success
356  \retval non-zero on failure
357 */
358 
359 #define ast_string_field_init(x, size) \
360 ({ \
361  int __res__ = -1; \
362  if (((void *)(x)) != (void *)NULL) { \
363  __res__ = __ast_string_field_init(&(x)->__field_mgr, &(x)->__field_mgr_pool, size, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
364  } \
365  __res__ ; \
366 })
367 
368 /*!
369  * \brief free all memory - to be called before destroying the object
370  *
371  * \param x
372  *
373  */
374 #define ast_string_field_free_memory(x) \
375 ({ \
376  int __res__ = -1; \
377  if (((void *)(x)) != (void *)NULL) { \
378  __res__ = __ast_string_field_free_memory(&(x)->__field_mgr, &(x)->__field_mgr_pool, \
379  AST_STRINGFIELD_DESTROY, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
380  } \
381  __res__; \
382 })
383 
385  struct ast_string_field_pool **pool_head, enum ast_stringfield_cleanup_type cleanup_type,
386  const char *file, int lineno, const char *func);
387 
388 /*!
389  * \brief Initialize an extended string field
390  * \since 13.9.0
391  *
392  * \param x Pointer to a structure containing the field
393  * \param field The extended field to initialize
394  * \retval zero on success
395  * \retval non-zero on error
396  *
397  * \note
398  * This macro must be called on ALL fields defined with AST_STRING_FIELD_EXTENDED after
399  * ast_string_field_init has been called.
400  */
401 #define ast_string_field_init_extended(x, field) \
402 ({ \
403  int __res__ = -1; \
404  if (((void *)(x)) != (void *)NULL) { \
405  ast_string_field *non_const = (ast_string_field *)&(x)->field; \
406  *non_const = __ast_string_field_empty; \
407  __res__ = AST_VECTOR_APPEND(&(x)->__field_mgr.string_fields, non_const); \
408  } \
409  __res__; \
410 })
411 
412 /*!
413  * \internal
414  * \brief internal version of ast_string_field_init
415  */
416 int __ast_string_field_init(struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head,
417  int needed, const char *file, int lineno, const char *func);
418 
419 /*!
420  * \brief Allocate a structure with embedded stringfields in a single allocation
421  * \param n Current implementation only allows 1 structure to be allocated
422  * \param type The type of structure to allocate
423  * \param size The number of bytes of space (minimum) to allocate for stringfields to use
424  * in each structure
425  *
426  * This function will allocate memory for one or more structures that use stringfields, and
427  * also allocate space for the stringfields and initialize the stringfield management
428  * structure embedded in the outer structure.
429  *
430  * \since 1.8
431  */
432 #define ast_calloc_with_stringfields(n, type, size) \
433  __ast_calloc_with_stringfields(n, sizeof(type), offsetof(type, __field_mgr), \
434  offsetof(type, __field_mgr_pool), size, __FILE__, __LINE__, __PRETTY_FUNCTION__)
435 
436 /*!
437  * \internal
438  * \brief internal version of ast_calloc_with_stringfields
439  */
440 void *__ast_calloc_with_stringfields(unsigned int num_structs,
441  size_t struct_size, size_t field_mgr_offset, size_t field_mgr_pool_offset, size_t pool_size,
442  const char *file, int lineno, const char *func);
443 
444 /*!
445  \internal
446  \brief Release a field's allocation from a pool
447  \param pool_head Pointer to the current pool
448  \param ptr Field to be released
449 
450  This function will search the pool list to find the pool that contains
451  the allocation for the specified field, then remove the field's allocation
452  from that pool's 'active' count. If the pool's active count reaches zero,
453  and it is not the current pool, then it will be freed.
454  */
456  const ast_string_field ptr);
457 
458 /*!
459  \brief Macro to provide access to the allocation field that lives immediately in front of a string field
460  \param x Pointer to the string field
461 
462  Note that x must be a pointer to a byte-sized type -- normally (char *) -- or this calculation
463  would break horribly
464 */
465 #define AST_STRING_FIELD_ALLOCATION(x) *((ast_string_field_allocation *) (x - __alignof__(ast_string_field_allocation)))
466 
467 /*!
468  \brief Set a field to a simple string value
469  \param x Pointer to a structure containing fields
470  \param ptr Pointer to a field within the structure
471  \param data String value to be copied into the field
472  \retval zero on success
473  \retval non-zero on error
474 */
475 #define ast_string_field_ptr_set(x, ptr, data) \
476 ({ \
477  int __res__ = -1; \
478  if (((void *)(x)) != (void *)NULL) { \
479  __res__ = ast_string_field_ptr_set_by_fields((x)->__field_mgr_pool, (x)->__field_mgr, ptr, data); \
480  } \
481  __res__; \
482 })
483 
484 #define __ast_string_field_ptr_set_by_fields(field_mgr_pool, field_mgr, ptr, data, file, lineno, func) \
485 ({ \
486  int __res__ = 0; \
487  const char *__d__ = (data); \
488  ast_string_field *__p__ = (ast_string_field *) (ptr); \
489  ast_string_field target = *__p__; \
490  if (__d__ == NULL || *__d__ == '\0') { \
491  __ast_string_field_release_active(field_mgr_pool, *__p__); \
492  *__p__ = __ast_string_field_empty; \
493  } else { \
494  size_t __dlen__ = strlen(__d__) + 1; \
495  if ((__dlen__ <= AST_STRING_FIELD_ALLOCATION(*__p__)) || \
496  (!__ast_string_field_ptr_grow(&field_mgr, &field_mgr_pool, __dlen__, __p__)) || \
497  (target = __ast_string_field_alloc_space(&field_mgr, &field_mgr_pool, __dlen__, file, lineno, func))) { \
498  if (target != *__p__) { \
499  __ast_string_field_release_active(field_mgr_pool, *__p__); \
500  *__p__ = target; \
501  } \
502  memcpy(* (void **) __p__, __d__, __dlen__); \
503  } else { \
504  __res__ = -1; \
505  } \
506  } \
507  __res__; \
508 })
509 
510 #define ast_string_field_ptr_set_by_fields(field_mgr_pool, field_mgr, ptr, data) \
511  __ast_string_field_ptr_set_by_fields(field_mgr_pool, field_mgr, ptr, data, __FILE__, __LINE__, __PRETTY_FUNCTION__)
512 
513 /*!
514  \brief Set a field to a simple string value
515  \param x Pointer to a structure containing fields
516  \param field Name of the field to set
517  \param data String value to be copied into the field
518  \retval zero on success
519  \retval non-zero on error
520 */
521 #define ast_string_field_set(x, field, data) \
522 ({ \
523  int __res__ = -1; \
524  if (((void *)(x)) != (void *)NULL) { \
525  __res__ = ast_string_field_ptr_set(x, &(x)->field, data); \
526  } \
527  __res__; \
528 })
529 
530 /*!
531  \brief Set a field to a complex (built) value
532  \param x Pointer to a structure containing fields
533  \param ptr Pointer to a field within the structure
534  \param fmt printf-style format string
535  \param args Arguments for format string
536 */
537 #define ast_string_field_ptr_build(x, ptr, fmt, args...) \
538 ({ \
539  int __res__ = -1; \
540  if (((void *)(x)) != (void *)NULL) { \
541  __ast_string_field_ptr_build(__FILE__, __LINE__, __PRETTY_FUNCTION__, \
542  &(x)->__field_mgr, &(x)->__field_mgr_pool, (ast_string_field *) ptr, fmt, args); \
543  __res__ = 0; \
544  } \
545  __res__; \
546 })
547 
548 /*!
549  \brief Set a field to a complex (built) value
550  \param x Pointer to a structure containing fields
551  \param field Name of the field to set
552  \param fmt printf-style format string
553  \param args Arguments for format string
554 */
555 #define ast_string_field_build(x, field, fmt, args...) \
556 ({ \
557  int __res__ = -1; \
558  if (((void *)(x)) != (void *)NULL) { \
559  __ast_string_field_ptr_build(__FILE__, __LINE__, __PRETTY_FUNCTION__, \
560  &(x)->__field_mgr, &(x)->__field_mgr_pool, (ast_string_field *) &(x)->field, fmt, args); \
561  __res__ = 0; \
562  } \
563  __res__; \
564 })
565 
566 /*!
567  \brief Set a field to a complex (built) value with prebuilt va_lists.
568  \param x Pointer to a structure containing fields
569  \param ptr Pointer to a field within the structure
570  \param fmt printf-style format string
571  \param args Arguments for format string in va_list format
572 */
573 #define ast_string_field_ptr_build_va(x, ptr, fmt, args) \
574 ({ \
575  int __res__ = -1; \
576  if (((void *)(x)) != (void *)NULL) { \
577  __ast_string_field_ptr_build_va(&(x)->__field_mgr, &(x)->__field_mgr_pool, (ast_string_field *) ptr, fmt, args, \
578  __FILE__, __LINE__, __PRETTY_FUNCTION__); \
579  __res__ = 0; \
580  } \
581  __res__; \
582 })
583 
584 /*!
585  \brief Set a field to a complex (built) value
586  \param x Pointer to a structure containing fields
587  \param field Name of the field to set
588  \param fmt printf-style format string
589  \param args Arguments for format string in va_list format
590 */
591 #define ast_string_field_build_va(x, field, fmt, args) \
592 ({ \
593  int __res__ = -1; \
594  if (((void *)(x)) != (void *)NULL) { \
595  __ast_string_field_ptr_build_va(&(x)->__field_mgr, &(x)->__field_mgr_pool, (ast_string_field *) &(x)->field, fmt, args, \
596  __FILE__, __LINE__, __PRETTY_FUNCTION__); \
597  __res__ = 0; \
598  } \
599  __res__; \
600 })
601 
602 /*!
603  \brief Compare the string fields in two instances of the same structure
604  \since 12
605  \param instance1 The first instance of the structure to be compared
606  \param instance2 The second instance of the structure to be compared
607  \retval zero if all string fields are equal (does not compare non-string field data)
608  \retval non-zero if the values of the string fields differ
609 */
610 #define ast_string_fields_cmp(instance1, instance2) \
611 ({ \
612  int __res__ = -1; \
613  if (((void *)(instance1)) != (void *)NULL && ((void *)(instance2)) != (void *)NULL) { \
614  __res__ = __ast_string_fields_cmp(&(instance1)->__field_mgr.string_fields, \
615  &(instance2)->__field_mgr.string_fields); \
616  } \
617  __res__; \
618 })
619 
621 
622 /*!
623  \brief Copy all string fields from one instance to another of the same structure
624  \since 12
625  \param copy The instance of the structure to be copied into
626  \param orig The instance of the structure to be copied from
627  \retval zero on success
628  \retval non-zero on error
629 */
630 #define ast_string_fields_copy(copy, orig) \
631 ({ \
632  int __res__ = -1; \
633  if (((void *)(copy)) != (void *)NULL && ((void *)(orig)) != (void *)NULL) { \
634  __res__ = __ast_string_fields_copy(((copy)->__field_mgr_pool), \
635  (struct ast_string_field_mgr *)&((copy)->__field_mgr), \
636  (struct ast_string_field_mgr *)&((orig)->__field_mgr), \
637  __FILE__, __LINE__, __PRETTY_FUNCTION__); \
638  } \
639  __res__; \
640 })
641 
642 int __ast_string_fields_copy(struct ast_string_field_pool *copy_pool,
643  struct ast_string_field_mgr *copy_mgr, struct ast_string_field_mgr *orig_mgr,
644  const char *file, int lineno, const char *func);
645 
646 #endif /* _ASTERISK_STRINGFIELDS_H */
static snd_pcm_format_t format
Definition: chan_alsa.c:106
Inlinable API function macro.
void __ast_string_field_ptr_build_va(struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, ast_string_field *ptr, const char *format, va_list ap, const char *file, int lineno, const char *func)
Definition: stringfields.c:286
int __ast_string_fields_cmp(struct ast_string_field_vector *left, struct ast_string_field_vector *right)
Definition: stringfields.c:424
void __ast_string_field_release_active(struct ast_string_field_pool *pool_head, const ast_string_field ptr)
Definition: stringfields.c:261
int __ast_string_fields_copy(struct ast_string_field_pool *copy_pool, struct ast_string_field_mgr *copy_mgr, struct ast_string_field_mgr *orig_mgr, const char *file, int lineno, const char *func)
Definition: stringfields.c:441
void __ast_string_field_ptr_build(const char *file, int lineno, const char *func, struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, ast_string_field *ptr, const char *format,...)
Definition: stringfields.c:369
int __ast_string_field_init(struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, int needed, const char *file, int lineno, const char *func)
Internal initialization function.
Definition: stringfields.c:171
uint16_t ast_string_field_allocation
Definition: stringfields.h:194
ast_stringfield_cleanup_type
Definition: stringfields.h:313
@ AST_STRINGFIELD_DESTROY
Definition: stringfields.h:325
@ AST_STRINGFIELD_RESET
Definition: stringfields.h:318
const char * __ast_string_field_empty
Definition: stringfields.c:43
int __ast_string_field_free_memory(struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, enum ast_stringfield_cleanup_type cleanup_type, const char *file, int lineno, const char *func)
Internal cleanup function.
Definition: stringfields.c:103
const char * ast_string_field
Definition: stringfields.h:190
void * __ast_calloc_with_stringfields(unsigned int num_structs, size_t struct_size, size_t field_mgr_offset, size_t field_mgr_pool_offset, size_t pool_size, const char *file, int lineno, const char *func)
Definition: stringfields.c:380
ast_string_field __ast_string_field_alloc_space(struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, size_t needed, const char *file, int lineno, const char *func)
Definition: stringfields.c:202
int __ast_string_field_ptr_grow(struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, size_t needed, const ast_string_field *ptr)
Definition: stringfields.c:240
struct ast_string_field_vector string_fields
Definition: stringfields.h:230
struct ast_string_field_pool * embedded_pool
Definition: stringfields.h:229
ast_string_field last_alloc
Definition: stringfields.h:228
struct ast_string_field_pool * prev
Definition: stringfields.h:209
Vector container support.
#define AST_VECTOR(name, type)
Define a vector structure.
Definition: vector.h:44