gtkD/src/glib/MemoryChunk.d

   1 /*
   2  * This file is part of gtkD.
   3  *
   4  * gtkD is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU Lesser General Public License as published by
   6  * the Free Software Foundation; either version 2.1 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * gtkD 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
  12  * GNU Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public License
  15  * along with gtkD; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 // generated automatically - do not change
  20 // find conversion definition on APILookup.txt
  21 // implement new conversion functionalities on the wrap.utils pakage
  22
  23 /*
  24  * Conversion parameters:
  25  * inFile  = glib-Memory-Chunks.html
  26  * outPack = glib
  27  * outFile = MemoryChunk
  28  * strct   = GMemChunk
  29  * realStrct=
  30  * ctorStrct=
  31  * clss    = MemoryChunk
  32  * interf  =
  33  * class Code: No
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  *      - g_mem_chunk_
  40  * omit structs:
  41  * omit prefixes:
  42  * omit code:
  43  * imports:
  44  *      - glib.Str
  45  * structWrap:
  46  * module aliases:
  47  * local aliases:
  48  */
  49
  50 module glib.MemoryChunk;
  51
  52 version(noAssert)
  53 {
  54         version(Tango)
  55         {
  56                 import tango.io.Stdout; // use the tango loging?
  57         }
  58 }
  59
  60 private import gtkc.glibtypes;
  61
  62 private import gtkc.glib;
  63
  64
  65 private import glib.Str;
  66
  67
  68
  69
  70 /**
  71  * Description
  72  * Memory chunks provide an space-efficient way to allocate equal-sized
  73  * pieces of memory, called atoms. However, due to the administrative
  74  * overhead (in particular for G_ALLOC_AND_FREE, and when used from multiple
  75  * threads), they are in practise often slower than direct use of g_malloc().
  76  * Therefore, memory chunks have been deprecated in favor of the
  77  * slice allocator,
  78  * which has been added in 2.10. All internal uses of memory chunks in
  79  * GLib have been converted to the g_slice API.
  80  * There are two types of memory chunks, G_ALLOC_ONLY, and G_ALLOC_AND_FREE.
  81  * G_ALLOC_ONLY chunks only allow allocation of atoms. The atoms can never
  82  * be freed individually. The memory chunk can only be free in its entirety.
  83  * G_ALLOC_AND_FREE chunks do allow atoms to be freed individually.
  84  * The disadvantage of this is that the memory chunk has to keep track of which
  85  * atoms have been freed. This results in more memory being used and a slight
  86  * degradation in performance.
  87  * To create a memory chunk use g_mem_chunk_new() or the convenience macro
  88  * g_mem_chunk_create().
  89  * To allocate a new atom use g_mem_chunk_alloc(), g_mem_chunk_alloc0(),
  90  * or the convenience macros g_chunk_new() or g_chunk_new0().
  91  * To free an atom use g_mem_chunk_free(), or the convenience macro
  92  * g_chunk_free(). (Atoms can only be freed if the memory chunk is created
  93  * with the type set to G_ALLOC_AND_FREE.)
  94  * To free any blocks of memory which are no longer being used, use
  95  * g_mem_chunk_clean(). To clean all memory chunks, use g_blow_chunks().
  96  * To reset the memory chunk, freeing all of the atoms, use g_mem_chunk_reset().
  97  * To destroy a memory chunk, use g_mem_chunk_destroy().
  98  * To help debug memory chunks, use g_mem_chunk_info() and g_mem_chunk_print().
  99  * Example3.Using a GMemChunk
 100  *  GMemChunk *mem_chunk;
 101  *  gchar *mem[10000];
 102  *  gint i;
 103  *  /+* Create a GMemChunk with atoms 50 bytes long, and memory blocks holding
 104  *  100 bytes. Note that this means that only 2 atoms fit into each memory
 105  *  block and so isn't very efficient. +/
 106  *  mem_chunk = g_mem_chunk_new ("test mem chunk", 50, 100, G_ALLOC_AND_FREE);
 107  *  /+* Now allocate 10000 atoms. +/
 108  *  for (i = 0; i < 10000; i++)
 109  *  {
 110          *  mem[i] = g_chunk_new (gchar, mem_chunk);
 111          *  /+* Fill in the atom memory with some junk. +/
 112          *  for (j = 0; j < 50; j++)
 113          *      mem[i][j] = i * j;
 114  *  }
 115  *  /+* Now free all of the atoms. Note that since we are going to destroy the
 116  *  GMemChunk, this wouldn't normally be used. +/
 117  *  for (i = 0; i < 10000; i++)
 118  *  {
 119          *  g_mem_chunk_free (mem_chunk, mem[i]);
 120  *  }
 121  *  /+* We are finished with the GMemChunk, so we destroy it. +/
 122  *  g_mem_chunk_destroy (mem_chunk);
 123  * Example4.Using a GMemChunk with data structures
 124  *  GMemChunk *array_mem_chunk;
 125  *  GRealArray *array;
 126  *  /+* Create a GMemChunk to hold GRealArray structures, using the
 127  *  g_mem_chunk_create() convenience macro. We want 1024 atoms in each
 128  *  memory block, and we want to be able to free individual atoms. +/
 129  *  array_mem_chunk = g_mem_chunk_create (GRealArray, 1024, G_ALLOC_AND_FREE);
 130  *  /+* Allocate one atom, using the g_chunk_new() convenience macro. +/
 131  *  array = g_chunk_new (GRealArray, array_mem_chunk);
 132  *  /+* We can now use array just like a normal pointer to a structure. +/
 133  *  array->data = NULL;
 134  *  array->len = 0;
 135  *  array->alloc = 0;
 136  *  array->zero_terminated = (zero_terminated ? 1 : 0);
 137  *  array->clear = (clear ? 1 : 0);
 138  *  array->elt_size = elt_size;
 139  *  /+* We can free the element, so it can be reused. +/
 140  *  g_chunk_free (array, array_mem_chunk);
 141  *  /+* We destroy the GMemChunk when we are finished with it. +/
 142  *  g_mem_chunk_destroy (array_mem_chunk);
 143  */
 144 public class MemoryChunk
 145 {
 146
 147         /** the main Gtk struct */
 148         protected GMemChunk* gMemChunk;
 149
 150
 151         public GMemChunk* getMemoryChunkStruct()
 152         {
 153                 return gMemChunk;
 154         }
 155
 156
 157         /** the main Gtk struct as a void* */
 158         protected void* getStruct()
 159         {
 160                 return cast(void*)gMemChunk;
 161         }
 162
 163         /**
 164          * Sets our main struct and passes it to the parent class
 165          */
 166         public this (GMemChunk* gMemChunk)
 167         {
 168                 version(noAssert)
 169                 {
 170                         if ( gMemChunk is null )
 171                         {
 172                                 int zero = 0;
 173                                 version(Tango)
 174                                 {
 175                                         Stdout("struct gMemChunk is null on constructor").newline;
 176                                 }
 177                                 else
 178                                 {
 179                                         printf("struct gMemChunk is null on constructor");
 180                                 }
 181                                 zero = zero / zero;
 182                         }
 183                 }
 184                 else
 185                 {
 186                         assert(gMemChunk !is null, "struct gMemChunk is null on constructor");
 187                 }
 188                 this.gMemChunk = gMemChunk;
 189         }
 190
 191         /**
 192          */
 193
 194
 195
 196
 197         /**
 198          * Warning
 199          * g_mem_chunk_new has been deprecated since version 2.10 and should not be used in newly-written code. Use the slice allocator
 200          *  instead
 201          * Creates a new GMemChunk.
 202          * name:
 203          * a string to identify the GMemChunk. It is not copied so it
 204          * should be valid for the lifetime of the GMemChunk. It is only used in
 205          * g_mem_chunk_print(), which is used for debugging.
 206          * atom_size:
 207          * the size, in bytes, of each element in the GMemChunk.
 208          * area_size:
 209          * the size, in bytes, of each block of memory allocated to contain
 210          * the atoms.
 211          * type:
 212          * the type of the GMemChunk.
 213          * G_ALLOC_AND_FREE is used if the atoms will be freed individually.
 214          * G_ALLOC_ONLY should be used if atoms will never be freed individually.
 215          * G_ALLOC_ONLY is quicker, since it does not need to track free atoms,
 216          * but it obviously wastes memory if you no longer need many of the atoms.
 217          * Returns:
 218          * the new GMemChunk.
 219          */
 220         public this (char[] name, int atomSize, uint areaSize, int type)
 221         {
 222                 // GMemChunk* g_mem_chunk_new (const gchar *name,  gint atom_size,  gulong area_size,  gint type);
 223                 this(cast(GMemChunk*)g_mem_chunk_new(Str.toStringz(name), atomSize, areaSize, type) );
 224         }
 225
 226         /**
 227          * Warning
 228          * g_mem_chunk_alloc has been deprecated since version 2.10 and should not be used in newly-written code. Use g_slice_alloc() instead
 229          * Allocates an atom of memory from a GMemChunk.
 230          * mem_chunk:
 231          * a GMemChunk.
 232          * Returns:
 233          * a pointer to the allocated atom.
 234          */
 235         public void* alloc()
 236         {
 237                 // gpointer g_mem_chunk_alloc (GMemChunk *mem_chunk);
 238                 return g_mem_chunk_alloc(gMemChunk);
 239         }
 240
 241         /**
 242          * Warning
 243          * g_mem_chunk_alloc0 has been deprecated since version 2.10 and should not be used in newly-written code. Use g_slice_alloc0() instead
 244          * Allocates an atom of memory from a GMemChunk, setting the memory to 0.
 245          * mem_chunk:
 246          * a GMemChunk.
 247          * Returns:
 248          * a pointer to the allocated atom.
 249          */
 250         public void* alloc0()
 251         {
 252                 // gpointer g_mem_chunk_alloc0 (GMemChunk *mem_chunk);
 253                 return g_mem_chunk_alloc0(gMemChunk);
 254         }
 255
 256         /**
 257          * Warning
 258          * g_mem_chunk_free has been deprecated since version 2.10 and should not be used in newly-written code. Use g_slice_free1() instead
 259          * Frees an atom in a GMemChunk.
 260          * This should only be called if the GMemChunk was created with
 261          * G_ALLOC_AND_FREE. Otherwise it will simply return.
 262          * mem_chunk:
 263          * a GMemChunk.
 264          * mem:
 265          * a pointer to the atom to free.
 266          */
 267         public void free(void* mem)
 268         {
 269                 // void g_mem_chunk_free (GMemChunk *mem_chunk,  gpointer mem);
 270                 g_mem_chunk_free(gMemChunk, mem);
 271         }
 272
 273         /**
 274          * Warning
 275          * g_mem_chunk_destroy has been deprecated since version 2.10 and should not be used in newly-written code. Use the slice
 276          *  allocator instead
 277          * Frees all of the memory allocated for a GMemChunk.
 278          * mem_chunk:
 279          * a GMemChunk.
 280          */
 281         public void destroy()
 282         {
 283                 // void g_mem_chunk_destroy (GMemChunk *mem_chunk);
 284                 g_mem_chunk_destroy(gMemChunk);
 285         }
 286
 287
 288
 289
 290
 291         /**
 292          * Warning
 293          * g_mem_chunk_reset has been deprecated since version 2.10 and should not be used in newly-written code. Use the slice
 294          *  allocator instead
 295          * Resets a GMemChunk to its initial state.
 296          * It frees all of the currently allocated blocks of memory.
 297          * mem_chunk:
 298          * a GMemChunk.
 299          */
 300         public void reset()
 301         {
 302                 // void g_mem_chunk_reset (GMemChunk *mem_chunk);
 303                 g_mem_chunk_reset(gMemChunk);
 304         }
 305
 306         /**
 307          * Warning
 308          * g_mem_chunk_clean has been deprecated since version 2.10 and should not be used in newly-written code. Use the slice
 309          *  allocator instead
 310          * Frees any blocks in a GMemChunk which are no longer being used.
 311          * mem_chunk:
 312          * a GMemChunk.
 313          */
 314         public void clean()
 315         {
 316                 // void g_mem_chunk_clean (GMemChunk *mem_chunk);
 317                 g_mem_chunk_clean(gMemChunk);
 318         }
 319
 320         /**
 321          * Warning
 322          * g_blow_chunks has been deprecated since version 2.10 and should not be used in newly-written code. Use the slice
 323          *  allocator instead
 324          * Calls g_mem_chunk_clean() on all GMemChunk objects.
 325          */
 326         public static void gBlowChunks()
 327         {
 328                 // void g_blow_chunks (void);
 329                 g_blow_chunks();
 330         }
 331
 332         /**
 333          * Warning
 334          * g_mem_chunk_info has been deprecated since version 2.10 and should not be used in newly-written code. Use the slice
 335          *  allocator instead
 336          * Outputs debugging information for all GMemChunk objects currently in use.
 337          * It outputs the number of GMemChunk objects currently allocated,
 338          * and calls g_mem_chunk_print() to output information on each one.
 339          */
 340         public static void info()
 341         {
 342                 // void g_mem_chunk_info (void);
 343                 g_mem_chunk_info();
 344         }
 345
 346         /**
 347          * Warning
 348          * g_mem_chunk_print has been deprecated since version 2.10 and should not be used in newly-written code. Use the slice
 349          *  allocator instead
 350          * Outputs debugging information for a GMemChunk.
 351          * It outputs the name of the GMemChunk (set with g_mem_chunk_new()),
 352          * the number of bytes used, and the number of blocks of memory allocated.
 353          * mem_chunk:
 354          * a GMemChunk.
 355          */
 356         public void print()
 357         {
 358                 // void g_mem_chunk_print (GMemChunk *mem_chunk);
 359                 g_mem_chunk_print(gMemChunk);
 360         }
 361 }