WebSVN – Kolibri OS – Diff – /programs/develop/libraries/cairo/src/cairo-array.c

+/* -*- Mode: c; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 8; -*- */
 /* cairo - a vector graphics library with display and print output
+ *
  * Copyright © 2004 Red Hat, Inc
+ *
  * This library is free software; you can redistribute it and/or
  *	Kristian Høgsberg
  *	Carl Worth
  */
+#include "cairoint.h"
-#include "cairoint.h"
+#include "cairo-array-private.h"
 #include "cairo-error-private.h"
 /**
+ *
  * When finished using the array, _cairo_array_fini() should be
  * called to free resources allocated during use of the array.
  **/
 void
-_cairo_array_init (cairo_array_t *array, int element_size)
+_cairo_array_init (cairo_array_t *array, unsigned int element_size)
+{
     array->size = 0;
     array->num_elements = 0;
     array->element_size = element_size;
     array->elements = NULL;
-    array->is_snapshot = FALSE;
-}
-/**
- * _cairo_array_init_snapshot:
- * @array: A #cairo_array_t to be initialized as a snapshot
- * @other: The #cairo_array_t from which to create the snapshot
- *
- * Initialize @array as an immutable copy of @other. It is an error to
- * call an array-modifying function (other than _cairo_array_fini) on
- * @array after calling this function.
- **/
-void
-_cairo_array_init_snapshot (cairo_array_t	*array,
-			    const cairo_array_t *other)
-{
-    array->size = other->size;
-    array->num_elements = other->num_elements;
-    array->element_size = other->element_size;
-    array->elements = other->elements;
-    array->is_snapshot = TRUE;
+}
 /**
  * _cairo_array_fini:
  * _cairo_array_init() again first.
  **/
 void
 _cairo_array_fini (cairo_array_t *array)
+{
-    if (array->is_snapshot)
-	return;
-    if (array->elements) {
-	free (* array->elements);
-	free (array->elements);
+    free (array->elements);
+}
-}
 /**
  * _cairo_array_grow_by:
  * @array: a #cairo_array_t
     char *new_elements;
     unsigned int old_size = array->size;
     unsigned int required_size = array->num_elements + additional;
     unsigned int new_size;
-    assert (! array->is_snapshot);
     /* check for integer overflow */
     if (required_size > INT_MAX || required_size < array->num_elements)
 	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
 	new_size = old_size * 2;
     while (new_size < required_size)
-	new_size = new_size * 2;
-    if (array->elements == NULL) {
-	array->elements = malloc (sizeof (char *));
-	if (unlikely (array->elements == NULL))
-	    return _cairo_error (CAIRO_STATUS_NO_MEMORY);
-	*array->elements = NULL;
 	new_size = new_size * 2;
     array->size = new_size;
-    new_elements = _cairo_realloc_ab (*array->elements,
+    new_elements = _cairo_realloc_ab (array->elements,
 			              array->size, array->element_size);
     if (unlikely (new_elements == NULL)) {
 	array->size = old_size;
 	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+    }
  * beyond @num_elements are simply "forgotten".
  **/
 void
 _cairo_array_truncate (cairo_array_t *array, unsigned int num_elements)
+{
-    assert (! array->is_snapshot);
     if (num_elements < array->num_elements)
 	array->num_elements = num_elements;
+}
 _cairo_array_index (cairo_array_t *array, unsigned int index)
+{
     /* We allow an index of 0 for the no-elements case.
      * This makes for cleaner calling code which will often look like:
+     *
-     *    elements = _cairo_array_index (array, num_elements);
+     *    elements = _cairo_array_index (array, 0);
      *	  for (i=0; i < num_elements; i++) {
      *        ... use elements[i] here ...
      *    }
+     *
      * which in the num_elements==0 case gets the NULL pointer here,
     if (index == 0 && array->num_elements == 0)
 	return NULL;
+    assert (index < array->num_elements);
+    return array->elements + index * array->element_size;
+}
+/**
+ * _cairo_array_index_const:
+ * @array: a #cairo_array_t
+ * Returns: A pointer to the object stored at @index.
+ *
+ * If the resulting value is assigned to a pointer to an object of the same
+ * element_size as initially passed to _cairo_array_init() then that
+ * pointer may be used for further direct indexing with []. For
+ * example:
+ *
+ *
+ *	cairo_array_t array;
+ *	const double *values;
+ *
+ *	_cairo_array_init (&array, sizeof(double));
+ *	... calls to _cairo_array_append() here ...
+ *
+ *	values = _cairo_array_index_const (&array, 0);
+ *      for (i = 0; i < _cairo_array_num_elements (&array); i++)
+ *	    ... read values[i] here ...
+ *
+ **/
+const void *
+_cairo_array_index_const (const cairo_array_t *array, unsigned int index)
+{
+    /* We allow an index of 0 for the no-elements case.
+     * This makes for cleaner calling code which will often look like:
+     *
+     *    elements = _cairo_array_index_const (array, 0);
+     *	  for (i=0; i < num_elements; i++) {
+     *        ... read elements[i] here ...
+     *    }
+     *
+     * which in the num_elements==0 case gets the NULL pointer here,
+     * but never dereferences it.
+     */
+    if (index == 0 && array->num_elements == 0)
+	return NULL;
     assert (index < array->num_elements);
-    return (void *) &(*array->elements)[index * array->element_size];
+    return array->elements + index * array->element_size;
+}
 /**
  * _cairo_array_copy_element:
  * @array: a #cairo_array_t
+ *
  * Copy a single element out of the array from index @index into the
  * location pointed to by @dst.
+ **/
+void
- **/
+_cairo_array_copy_element (const cairo_array_t *array,
-void
+			   unsigned int         index,
-_cairo_array_copy_element (cairo_array_t *array, int index, void *dst)
+			   void                *dst)
+{
-    memcpy (dst, _cairo_array_index (array, index), array->element_size);
+    memcpy (dst, _cairo_array_index_const (array, index), array->element_size);
+}
  **/
 cairo_status_t
 _cairo_array_append (cairo_array_t	*array,
 		     const void		*element)
+{
-    assert (! array->is_snapshot);
     return _cairo_array_append_multiple (array, element, 1);
+}
 /**
  * operation.
  **/
 cairo_status_t
 _cairo_array_append_multiple (cairo_array_t	*array,
 			      const void	*elements,
-			      int		 num_elements)
+			      unsigned int	 num_elements)
+{
     cairo_status_t status;
     void *dest;
-    assert (! array->is_snapshot);
     status = _cairo_array_allocate (array, num_elements, &dest);
     if (unlikely (status))
 	return status;
 		       unsigned int	  num_elements,
 		       void		**elements)
+{
     cairo_status_t status;
-    assert (! array->is_snapshot);
     status = _cairo_array_grow_by (array, num_elements);
     if (unlikely (status))
 	return status;
     assert (array->num_elements + num_elements <= array->size);
-    *elements = &(*array->elements)[array->num_elements * array->element_size];
+    *elements = array->elements + array->num_elements * array->element_size;
  * @array: a #cairo_array_t
  * Returns: The number of elements stored in @array.
+ *
  * This space was left intentionally blank, but gtk-doc filled it.
  **/
-int
+unsigned int
-_cairo_array_num_elements (cairo_array_t *array)
+_cairo_array_num_elements (const cairo_array_t *array)
+{
     return array->num_elements;
+}
  * Returns: The number of elements for which there is currently space
  * allocated in @array.
+ *
  * This space was left intentionally blank, but gtk-doc filled it.
  **/
-int
+unsigned int
-_cairo_array_size (cairo_array_t *array)
+_cairo_array_size (const cairo_array_t *array)
+{
     return array->size;
+}
     num_slots = array->num_elements;
     if (num_slots) {
 	cairo_user_data_slot_t *slots;
 	slots = _cairo_array_index (array, 0);
+	while (num_slots--) {
-	do {
+	    cairo_user_data_slot_t *s = &slots[num_slots];
-	    if (slots->user_data != NULL && slots->destroy != NULL)
+	    if (s->user_data != NULL && s->destroy != NULL)
-		slots->destroy (slots->user_data);
+		s->destroy (s->user_data);
-	    slots++;
 	} while (--num_slots);
+    }
     return CAIRO_STATUS_SUCCESS;
+}
 cairo_status_t
 _cairo_user_data_array_copy (cairo_user_data_array_t	*dst,
-			     cairo_user_data_array_t	*src)
+			     const cairo_user_data_array_t	*src)
+{
     /* discard any existing user-data */
     if (dst->num_elements != 0) {
 	_cairo_user_data_array_fini (dst);
 	_cairo_user_data_array_init (dst);
-    }
-    if (src->num_elements == 0)
 	return CAIRO_STATUS_SUCCESS;
     return _cairo_array_append_multiple (dst,
-					 _cairo_array_index (src, 0),
+					 _cairo_array_index_const (src, 0),
 					 src->num_elements);
+}

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/cairo/src/cairo-array.c – Rev 1892 → 3959