source/blender/blenlib/intern/gsqueue.c

   1 /**
   2  * $Id$
   3  *
   4  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version. The Blender
  10  * Foundation also sells licenses for use in proprietary software under
  11  * the Blender License.  See http://www.blender.org/BL/ for information
  12  * about this.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software Foundation,
  21  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22  *
  23  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  24  * All rights reserved.
  25  *
  26  * The Original Code is: all of this file.
  27  *
  28  * Contributor(s): none yet.
  29  *
  30  * ***** END GPL/BL DUAL LICENSE BLOCK *****
  31  */
  32 #include <string.h>
  33
  34 #include "MEM_guardedalloc.h"
  35 #include "BLI_gsqueue.h"
  36
  37 #ifdef HAVE_CONFIG_H
  38 #include <config.h>
  39 #endif
  40
  41 typedef struct _GSQueueElem GSQueueElem;
  42 struct _GSQueueElem {
  43         GSQueueElem *next;
  44 };
  45
  46 struct _GSQueue {
  47         GSQueueElem     *head;
  48         GSQueueElem     *tail;
  49         int                     elem_size;
  50 };
  51
  52 GSQueue *BLI_gsqueue_new(int elem_size)
  53 {
  54         GSQueue *gq= MEM_mallocN(sizeof(*gq), "gqueue_new");
  55         gq->head= gq->tail= NULL;
  56         gq->elem_size= elem_size;
  57
  58         return gq;
  59 }
  60
  61 int BLI_gsqueue_is_empty(GSQueue *gq)
  62 {
  63         return (gq->head==NULL);
  64 }
  65
  66 void BLI_gsqueue_peek(GSQueue *gq, void *item_r)
  67 {
  68         memcpy(item_r, &gq->head[1], gq->elem_size);
  69 }
  70 void BLI_gsqueue_pop(GSQueue *gq, void *item_r)
  71 {
  72         GSQueueElem *elem= gq->head;
  73         if (elem==gq->tail) {
  74                 gq->head= gq->tail= NULL;
  75         } else {
  76                 gq->head= gq->head->next;
  77         }
  78
  79         if (item_r) memcpy(item_r, &elem[1], gq->elem_size);
  80         MEM_freeN(elem);
  81 }
  82 void BLI_gsqueue_push(GSQueue *gq, void *item)
  83 {
  84         GSQueueElem *elem= MEM_mallocN(sizeof(*elem)+gq->elem_size, "gqueue_push");
  85         memcpy(&elem[1], item, gq->elem_size);
  86         elem->next= NULL;
  87
  88         if (BLI_gsqueue_is_empty(gq)) {
  89                 gq->tail= gq->head= elem;
  90         } else {
  91                 gq->tail= gq->tail->next= elem;
  92         }
  93 }
  94 void BLI_gsqueue_pushback(GSQueue *gq, void *item)
  95 {
  96         GSQueueElem *elem= MEM_mallocN(sizeof(*elem)+gq->elem_size, "gqueue_push");
  97         memcpy(&elem[1], item, gq->elem_size);
  98         elem->next= gq->head;
  99
 100         if (BLI_gsqueue_is_empty(gq)) {
 101                 gq->head= gq->tail= elem;
 102         } else {
 103                 gq->head= elem;
 104         }
 105 }
 106
 107 void BLI_gsqueue_free(GSQueue *gq)
 108 {
 109         while (gq->head) {
 110                 BLI_gsqueue_pop(gq, NULL);
 111         }
 112         MEM_freeN(gq);
 113 }
 114
 115