glib/gbuffer.c

   1 /*
   2  * Copyright © 2009, 2010 Codethink Limited
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the licence, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  *
  19  * Author: Ryan Lortie <desrt@desrt.ca>
  20  */
  21
  22 #include "config.h"
  23
  24 #include "gbufferprivate.h"
  25
  26 #include <glib/gstrfuncs.h>
  27 #include <glib/gatomic.h>
  28 #include <glib/gslice.h>
  29 #include <glib/gmem.h>
  30
  31 typedef struct
  32 {
  33   GBuffer buffer;
  34
  35   GDestroyNotify user_destroy;
  36   gpointer user_data;
  37 } GUserNotifyBuffer;
  38
  39 static void
  40 g_buffer_free_gfree (GBuffer *buffer)
  41 {
  42   g_free ((gpointer) buffer->data);
  43   g_slice_free (GBuffer, buffer);
  44 }
  45
  46 /* < private >
  47  * g_buffer_new_from_data:
  48  * @data: the data to be used for the buffer
  49  * @size: the size of @data
  50  *
  51  * Creates a new #GBuffer from @data.
  52  *
  53  * @data is copied.
  54  *
  55  * Returns: a reference to a new #GBuffer
  56  */
  57
  58 GBuffer *
  59 g_buffer_new_from_data (gconstpointer data,
  60                         gsize         size)
  61 {
  62   GBuffer *buffer;
  63
  64   buffer = g_slice_new (GBuffer);
  65   buffer->data = g_memdup (data, size);
  66   buffer->size = size;
  67   buffer->free_func = g_buffer_free_gfree;
  68   buffer->ref_count = 1;
  69
  70   return buffer;
  71 }
  72
  73 /* < private >
  74  * g_buffer_new_take_data:
  75  * @data: the data to be used for the buffer
  76  * @size: the size of @data
  77  * returns: a reference to a new #GBuffer
  78  *
  79  * Creates a new #GBuffer from @data.
  80  *
  81  * @data must have been created by a call to g_malloc(), g_malloc0() or
  82  * g_realloc() or by one of the many functions that wrap these calls
  83  * (such as g_new(), g_strdup(), etc).
  84  *
  85  * After this call, @data belongs to the buffer and may no longer be
  86  * modified by the caller.  g_free() will be called on @data when the
  87  * buffer is no longer in use.
  88  */
  89 GBuffer *
  90 g_buffer_new_take_data (gpointer data,
  91                         gsize    size)
  92 {
  93   GBuffer *buffer;
  94
  95   buffer = g_slice_new (GBuffer);
  96   buffer->data = data;
  97   buffer->size = size;
  98   buffer->free_func = g_buffer_free_gfree;
  99   buffer->ref_count = 1;
 100
 101   return buffer;
 102 }
 103
 104 static void
 105 g_buffer_free (GBuffer *buffer)
 106 {
 107   g_slice_free (GBuffer, buffer);
 108 }
 109
 110 /* < private >
 111  * g_buffer_new_from_static_data:
 112  * @data: the data to be used for the buffer
 113  * @size: the size of @data
 114  *
 115  * Creates a new #GBuffer from static data.
 116  *
 117  * @data must be static (ie: never modified or freed).
 118  *
 119  * Returns: a reference to a new #GBuffer
 120  */
 121 GBuffer *
 122 g_buffer_new_from_static_data (gconstpointer data,
 123                                gsize         size)
 124 {
 125   GBuffer *buffer;
 126
 127   buffer = g_slice_new (GBuffer);
 128   buffer->data = data;
 129   buffer->size = size;
 130   buffer->free_func = g_buffer_free;
 131   buffer->ref_count = 1;
 132
 133   return buffer;
 134 }
 135
 136 static void
 137 g_buffer_free_usernotify (GBuffer *buffer)
 138 {
 139   GUserNotifyBuffer *ubuffer = (GUserNotifyBuffer *) buffer;
 140
 141   ubuffer->user_destroy (ubuffer->user_data);
 142   g_slice_free (GUserNotifyBuffer, ubuffer);
 143 }
 144
 145 /* < private >
 146  * g_buffer_new_from_pointer:
 147  * @data: the data to be used for the buffer
 148  * @size: the size of @data
 149  * @notify: the function to call to release the data
 150  * @user_data: the data to pass to @notify
 151  *
 152  * Creates a #GBuffer from @data.
 153  *
 154  * When the last reference is dropped, @notify will be called on
 155  * @user_data.
 156  *
 157  * @data must not be modified after this call is made, until @notify has
 158  * been called to indicate that the buffer is no longer in use.
 159  *
 160  * Returns: a reference to a new #GBuffer
 161  */
 162 GBuffer *
 163 g_buffer_new_from_pointer (gconstpointer  data,
 164                            gsize          size,
 165                            GDestroyNotify notify,
 166                            gpointer       user_data)
 167 {
 168   GUserNotifyBuffer *ubuffer;
 169
 170   ubuffer = g_slice_new (GUserNotifyBuffer);
 171   ubuffer->buffer.data = data;
 172   ubuffer->buffer.size = size;
 173   ubuffer->buffer.free_func = g_buffer_free_usernotify;
 174   ubuffer->buffer.ref_count = 1;
 175   ubuffer->user_destroy = notify;
 176   ubuffer->user_data = user_data;
 177
 178   return (GBuffer *) ubuffer;
 179 }
 180
 181 /* < private >
 182  * g_buffer_ref:
 183  * @buffer: a #GBuffer
 184  *
 185  * Increase the reference count on @buffer.
 186  *
 187  * Returns: @buffer
 188  */
 189 GBuffer *
 190 g_buffer_ref (GBuffer *buffer)
 191 {
 192   g_atomic_int_inc (&buffer->ref_count);
 193
 194   return buffer;
 195 }
 196
 197 /* < private >
 198  * g_buffer_unref:
 199  * @buffer: a #GBuffer
 200  *
 201  * Releases a reference on @buffer.  This may result in the buffer being
 202  * freed.
 203  */
 204 void
 205 g_buffer_unref (GBuffer *buffer)
 206 {
 207   if (g_atomic_int_dec_and_test (&buffer->ref_count))
 208     if (buffer->free_func != NULL)
 209       buffer->free_func (buffer);
 210 }