gimp/libgimp/gimpparasite.c

/* parasite.c
 * Copyright (C) 1998 Jay Cox <jaycox@earthlink.net>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#include "parasiteP.h"
#include "parasite.h"
#include <string.h>
#include <glib.h>

Parasite *
parasite_new (const char *name, guint32 flags,
	      guint32 size, const void *data)
{
  Parasite *p;
  p = (Parasite *)g_malloc(sizeof(Parasite));
  if (name)
    p->name = g_strdup(name);
  else
    p->name = NULL;
  p->flags = flags;
  p->size = size;
  if (size)
    p->data = g_memdup(data, size);
  else
    p->data = NULL;
  return p;
}

void
parasite_free (Parasite *parasite)
{
  g_return_if_fail(parasite != NULL);
  if (parasite->name)
    g_free(parasite->name);
  if (parasite->data)
    g_free(parasite->data);
  g_free(parasite);
}

int
parasite_is_type (const Parasite *parasite, const char *name)
{
  if (!parasite)
    return FALSE;
  return (strcmp(parasite->name, name) == 0);
}

Parasite *
parasite_copy (const Parasite *parasite)
{
  if (parasite == NULL)
    return NULL;
  return parasite_new (parasite->name, parasite->flags,
		       parasite->size, parasite->data);
}

Parasite *
parasite_error()
{
  static Parasite *error_p = NULL;
  if (!error_p)
    error_p = parasite_new("error", 0, 0, NULL);
  return error_p;
}

int
parasite_is_error(const Parasite *p)
{
  if (p == NULL)
    return TRUE;
  return parasite_is_type(p, "error");
}

int
parasite_is_persistant(const Parasite *p)
{
  if (p == NULL)
    return FALSE;
  return (p->flags & PARASITE_PERSISTANT);
}

/* parasite list functions */

Parasite *
parasite_find_in_gslist (const GSList *list, const char *name)
{
  while (list)
  {
    if (parasite_is_type((Parasite *)(list->data), name))
      return (Parasite *)(list->data);
    list = list->next;
  }
  return NULL;
}

GSList*
parasite_add_to_gslist (const Parasite *parasite, GSList *list)
{
  Parasite *p;
  if (parasite_is_error(parasite))
    return list;
  if ((p = parasite_find_in_gslist(list, parasite->name)))
  {
    list = g_slist_remove(list, p);
    parasite_free(p);
  }
  return g_slist_prepend (list, parasite_copy(parasite));
}

GSList*
parasite_gslist_copy (const GSList *list)
{
  GSList *copy = NULL;
  while (list)
  {
    copy = g_slist_append (copy, parasite_copy((Parasite *)list->data));
    list = list->next;
  }
  return copy;
}

void
parasite_gslist_destroy (GSList *list)
{
  while (list)
  {
    parasite_free((Parasite *)list->data);
    list = g_slist_remove (list, list->data);
  }
}