rufus/src/libcdio/driver/ds.c

/*
  Copyright (C) 2005, 2008, 2011, 2016 Rocky Bernstein <rocky@gnu.org>
  Copyright (C) 2000 Herbert Valerio Riedel <hvr@gnu.org>

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  This program 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 General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifdef HAVE_CONFIG_H
# include "config.h"
# define __CDIO_CONFIG_H__ 1
#endif

#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif

#include <cdio/ds.h>
#include <cdio/util.h>
#include <cdio/types.h>
#include "cdio_assert.h"

struct _CdioList
{
  unsigned length;

  CdioListNode_t *begin;
  CdioListNode_t *end;
};

struct _CdioListNode
{
  CdioList_t *list;

  CdioListNode_t *next;

  void *data;
};

/* impl */

CdioList_t *
_cdio_list_new (void)
{
  CdioList_t *p_new_obj = calloc (1, sizeof (CdioList_t));

  return p_new_obj;
}

void
_cdio_list_free (CdioList_t *p_list, int free_data, CdioDataFree_t free_fn)
{
  while (_cdio_list_length (p_list))
    _cdio_list_node_free (_cdio_list_begin (p_list), free_data, free_fn);

  free (p_list);
}

unsigned
_cdio_list_length (const CdioList_t *p_list)
{
  cdio_assert (p_list != NULL);

  return p_list->length;
}

void
_cdio_list_prepend (CdioList_t *p_list, void *p_data)
{
  CdioListNode_t *p_new_node;

  cdio_assert (p_list != NULL);

  p_new_node = calloc (1, sizeof (CdioListNode_t));
  cdio_assert (p_new_node != NULL);

  p_new_node->list = p_list;
  p_new_node->next = p_list->begin;
  p_new_node->data = p_data;

  p_list->begin = p_new_node;
  if (p_list->length == 0)
    p_list->end = p_new_node;

  p_list->length++;
}

void
_cdio_list_append (CdioList_t *p_list, void *p_data)
{
  cdio_assert (p_list != NULL);

  if (p_list->length == 0)
    {
      _cdio_list_prepend (p_list, p_data);
    }
  else
    {
      CdioListNode_t *p_new_node = calloc (1, sizeof (CdioListNode_t));
      cdio_assert (p_new_node != NULL);

      p_new_node->list = p_list;
      p_new_node->next = NULL;
      p_new_node->data = p_data;

      p_list->end->next = p_new_node;
      p_list->end = p_new_node;

      p_list->length++;
    }
}

void
_cdio_list_foreach (CdioList_t *p_list, _cdio_list_iterfunc_t func,
                    void *p_user_data)
{
  CdioListNode_t *node;

  cdio_assert (p_list != NULL);
  cdio_assert (func != 0);

  for (node = _cdio_list_begin (p_list);
       node != NULL;
       node = _cdio_list_node_next (node))
    func (_cdio_list_node_data (node), p_user_data);
}

CdioListNode_t *
_cdio_list_find (CdioList_t *p_list, _cdio_list_iterfunc_t cmp_func,
                 void *p_user_data)
{
  CdioListNode_t *p_node;

  cdio_assert (p_list != NULL);
  cdio_assert (cmp_func != 0);

  for (p_node = _cdio_list_begin (p_list);
       p_node != NULL;
       p_node = _cdio_list_node_next (p_node))
    if (cmp_func (_cdio_list_node_data (p_node), p_user_data))
      break;

  return p_node;
}

CdioListNode_t *
_cdio_list_begin (const CdioList_t *p_list)
{
  cdio_assert (p_list != NULL);

  return p_list->begin;
}

CdioListNode_t *
_cdio_list_end (CdioList_t *p_list)
{
  cdio_assert (p_list != NULL);

  return p_list->end;
}

CdioListNode_t *
_cdio_list_node_next (CdioListNode_t *p_node)
{
  if (p_node)
    return p_node->next;

  return NULL;
}

void
_cdio_list_node_free (CdioListNode_t *p_node,
                      int free_data, CdioDataFree_t free_fn)
{
  CdioList_t *p_list;
  CdioListNode_t *prev_node;

  cdio_assert (p_node != NULL);

  p_list = p_node->list;

  cdio_assert (_cdio_list_length (p_list) > 0);

  if (free_data && free_fn)
    free_fn (_cdio_list_node_data (p_node));

  if (_cdio_list_length (p_list) == 1)
    {
      cdio_assert (p_list->begin == p_list->end);

      p_list->end = p_list->begin = NULL;
      p_list->length = 0;
      free (p_node);
      return;
    }

  cdio_assert (p_list->begin != p_list->end);

  if (p_list->begin == p_node)
    {
      p_list->begin = p_node->next;
      free (p_node);
      p_list->length--;
      return;
    }

  for (prev_node = p_list->begin; prev_node->next; prev_node = prev_node->next)
    if (prev_node->next == p_node)
      break;

  cdio_assert (prev_node->next != NULL);

  if (p_list->end == p_node)
    p_list->end = prev_node;

  prev_node->next = p_node->next;

  p_list->length--;

  free (p_node);
}

void *
_cdio_list_node_data (CdioListNode_t *p_node)
{
  if (p_node)
    return p_node->data;

  return NULL;
}

/* eof */


/*
 * Local variables:
 *  c-file-style: "gnu"
 *  tab-width: 8
 *  indent-tabs-mode: nil
 * End:
 */