list.h File Reference

Singly-linked list type. More...

#include <stddef.h>
#include <stdbool.h>
#include "queue.h"

Include dependency graph for list.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ListNode
	A List node for strings. More...

Typedefs
typedef void(*	list_free_t) (void **ptr)
	Prototype for a function to free List data. More...

Functions
	STAILQ_HEAD (ListHead, ListNode)
void	mutt_list_clear (struct ListHead *h)
	Free a list, but NOT its strings. More...
bool	mutt_list_compare (const struct ListHead *ah, const struct ListHead *bh)
	Compare two string lists. More...
struct ListNode *	mutt_list_find (const struct ListHead *h, const char *data)
	Find a string in a List. More...
void	mutt_list_free (struct ListHead *h)
	Free a List AND its strings. More...
void	mutt_list_free_type (struct ListHead *h, list_free_t fn)
	Free a List of type. More...
struct ListNode *	mutt_list_insert_after (struct ListHead *h, struct ListNode *n, char *s)
	Insert a string after a given ListNode. More...
struct ListNode *	mutt_list_insert_head (struct ListHead *h, char *s)
	Insert a string at the beginning of a List. More...
struct ListNode *	mutt_list_insert_tail (struct ListHead *h, char *s)
	Append a string to the end of a List. More...
bool	mutt_list_match (const char *s, struct ListHead *h)
	Is the string in the list (see notes) More...
size_t	mutt_list_str_split (struct ListHead *head, const char *src, char sep)
	Split a string into a list using a separator char. More...

Detailed Description

Singly-linked list type.

Authors

• Richard Russon
• Pietro Cerutti

Copyright

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 2 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/.

Definition in file list.h.

Typedef Documentation

list_free_t

typedef void(* list_free_t) (void **ptr)

Prototype for a function to free List data.

Parameters

[out]

ptr

Data to free

Definition at line 45 of file list.h.

Function Documentation

STAILQ_HEAD()

STAILQ_HEAD	(	ListHead	,
		ListNode
	)

mutt_list_clear()

void mutt_list_clear

(

struct ListHead *

h

)

Free a list, but NOT its strings.

Parameters

h	Head of the List

This can be used when the strings have a different lifetime to the List.

Definition at line 167 of file list.c.

{
  if (!h)
    return;

  struct ListNode *np = NULL, *tmp = NULL;
  STAILQ_FOREACH_SAFE(np, h, entries, tmp)
  {
    STAILQ_REMOVE(h, np, ListNode, entries);
    FREE(&np);
  }

  STAILQ_INIT(h);
}

Here is the caller graph for this function:

mutt_list_compare()

bool mutt_list_compare	(	const struct ListHead *	ah,
		const struct ListHead *	bh
	)

Compare two string lists.

Parameters

ah	First string list
bh	Second string list

Return values

true	Lists are identical

To be identical, the lists must both be the same length and contain the same strings. Two empty lists are identical.

Definition at line 218 of file list.c.

{
  if (!ah || !bh)
    return false;

  struct ListNode *a = STAILQ_FIRST(ah);
  struct ListNode *b = STAILQ_FIRST(bh);

  while (a && b)
  {
    if (!mutt_str_equal(a->data, b->data))
      return false;

    a = STAILQ_NEXT(a, entries);
    b = STAILQ_NEXT(b, entries);
  }
  if (a || b)
    return false;

  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_list_find()

struct ListNode* mutt_list_find	(	const struct ListHead *	h,
		const char *	data
	)

Find a string in a List.

Parameters

h	Head of the List
data	String to find

Return values

ptr	ListNode containing the string
NULL	if the string isn't found

Definition at line 102 of file list.c.

{
  if (!h)
    return NULL;

  struct ListNode *np = NULL;
  STAILQ_FOREACH(np, h, entries)
  {
    if (mutt_str_equal(np->data, data))
    {
      return np;
    }
  }
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_list_free()

void mutt_list_free

(

struct ListHead *

h

)

Free a List AND its strings.

Parameters

h	Head of the List

Definition at line 122 of file list.c.

{
  if (!h)
    return;

  struct ListNode *np = STAILQ_FIRST(h);
  struct ListNode *next = NULL;
  while (np)
  {
    next = STAILQ_NEXT(np, entries);
    FREE(&np->data);
    FREE(&np);
    np = next;
  }
  STAILQ_INIT(h);
}

Here is the caller graph for this function:

mutt_list_free_type()

void mutt_list_free_type	(	struct ListHead *	h,
		list_free_t	fn
	)

Free a List of type.

Parameters

h	Head of the List
fn	Function to free contents of ListNode

Definition at line 144 of file list.c.

{
  if (!h || !fn)
    return;

  struct ListNode *np = STAILQ_FIRST(h);
  struct ListNode *next = NULL;
  while (np)
  {
    next = STAILQ_NEXT(np, entries);
    fn((void **) &np->data);
    FREE(&np);
    np = next;
  }
  STAILQ_INIT(h);
}

Here is the caller graph for this function:

mutt_list_insert_after()

struct ListNode* mutt_list_insert_after	(	struct ListHead *	h,
		struct ListNode *	n,
		char *	s
	)

Insert a string after a given ListNode.

Parameters

h	Head of the List
n	ListNode after which the string will be inserted
s	String to insert

Return values

ptr	Newly created ListNode containing the string

Note

The inserted string isn't strdup()d

Definition at line 84 of file list.c.

{
  if (!h || !n)
    return NULL;

  struct ListNode *np = mutt_mem_calloc(1, sizeof(struct ListNode));
  np->data = s;
  STAILQ_INSERT_AFTER(h, n, np, entries);
  return np;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_list_insert_head()

struct ListNode* mutt_list_insert_head	(	struct ListHead *	h,
		char *	s
	)

Insert a string at the beginning of a List.

Parameters

h	Head of the List
s	String to insert

Return values

ptr	Newly inserted ListNode containing the string

Note

The inserted string isn't strdup()d

Definition at line 45 of file list.c.

{
  if (!h)
    return NULL;

  struct ListNode *np = mutt_mem_calloc(1, sizeof(struct ListNode));
  np->data = s;
  STAILQ_INSERT_HEAD(h, np, entries);
  return np;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_list_insert_tail()

struct ListNode* mutt_list_insert_tail	(	struct ListHead *	h,
		char *	s
	)

Append a string to the end of a List.

Parameters

h	Head of the List
s	String to insert

Return values

ptr	Newly appended ListNode containing the string

Note

The inserted string isn't strdup()d

Definition at line 64 of file list.c.

{
  if (!h)
    return NULL;

  struct ListNode *np = mutt_mem_calloc(1, sizeof(struct ListNode));
  np->data = s;
  STAILQ_INSERT_TAIL(h, np, entries);
  return np;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_list_match()

bool mutt_list_match	(	const char *	s,
		struct ListHead *	h
	)

Is the string in the list (see notes)

Parameters

s	String to match
h	Head of the List

Return values

true	String matches a List item (or List contains "*")

This is a very specific function. It searches a List of strings looking for a match. If the list contains a string "*", then it match any input string.

Note

The strings are compared to the length of the List item, e.g. List: "Red" matches Param: "Redwood", but not the other way around.

The case of the strings is ignored.

Definition at line 195 of file list.c.

{
  if (!h)
    return false;

  struct ListNode *np = NULL;
  STAILQ_FOREACH(np, h, entries)
  {
    if ((*np->data == '*') || mutt_istr_startswith(s, np->data))
      return true;
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_list_str_split()

size_t mutt_list_str_split	(	struct ListHead *	head,
		const char *	src,
		char	sep
	)

Split a string into a list using a separator char.

Parameters

head	List to add to
src	String to split
sep	Word separator

Return values

num	Number of items in list

Definition at line 247 of file list.c.

{
  if (!src || (*src == '\0'))
    return 0;

  size_t count = 0;
  while (true)
  {
    const char *start = src;
    while ((*src != '\0') && (*src != sep))
      src++;

    mutt_list_insert_tail(head, mutt_strn_dup(start, src - start));
    count++;

    if ((*src == '\0'))
      break;

    src++;
  }

  return count;
}

Here is the call graph for this function:

Here is the caller graph for this function: