List Struct Reference

#include <List.h>

Overview

Doubly-linked lists of raw C pointers.

Definition at line 60 of file List.h.

Inheritance diagram for List:

Properties
size_t	count
	The number of elements.
Consumer	destroy
	Optional destructor called when an element is removed.
ListNode *	head
	The head node.
Object	object
	The superclass.
ListNode *	tail
	The tail node.
Properties inherited from Object
Class *	clazz
	Every instance of Object begins with a pointer to its Class.
unsigned int	magic
	A header to allow introspection of Object types.

Methods
Class *	_List (void)
	The List archetype.
void	append (List *self, const ident element)
	Appends the given element to the tail of this List.
bool	contains (const List *self, const ident element)
void	enumerate (const List *self, ListEnumerator enumerator, ident element)
	Enumerates this List with the given function.
void	filter (List *self, Predicate predicate, ident data)
	Filters this List in place using predicate.
List *	filteredList (const List *self, Predicate predicate, ident data)
	Returns a new List containing elements of this List that pass predicate.
ident	find (const List *self, Predicate predicate, ident data)
List *	init (List *self)
	Initializes this List.
void	insertAfter (List *self, ListNode *node, const ident element)
	Inserts an element after the given node.
void	map (List *self, Functor functor, ident data)
	Transforms the elements in this List in place using functor.
List *	mappedList (const List *self, Functor functor, ident data)
	Returns a new List containing the elements of this List transformed by functor.
ListNode *	nodeForElement (const List *self, const ident element)
void	prepend (List *self, const ident element)
	Prepends the given element to the head of this List.
ident	reduce (const List *self, Reducer reducer, ident accumulator, ident data)
void	remove (List *self, const ident element)
	Removes the first occurrence of element from this List.
void	removeAll (List *self)
	Removes all elements from this List.
void	removeNode (List *self, ListNode *node)
	Removes the given node from this List.
void	sort (List *self, Comparator comparator)
	Sorts this List in-place using the given comparator.
void	sort (List *self, ListSortFunc sort)
Methods inherited from Object
Class *	_Object (void)
	The Object archetype.
Object *	copy (const Object *self)
	Creates a shallow copy of this Object.
void	dealloc (Object *self)
	Frees all resources held by this Object.
String *	description (const Object *self)
int	hash (const Object *self)
Object *	init (Object *self)
	Initializes this Object.
bool	isEqual (const Object *self, const Object *other)
	Tests equality of the other Object.
bool	isKindOfClass (const Object *self, const Class *clazz)
	Tests for Class hierarchy membership.

Protected Attributes
ListInterface *	interface [0]
	The interface type.
Protected Attributes inherited from Object
ObjectInterface *	interface [0]
	The interface type.

Property Details

count

size_t List::count

The number of elements.

Definition at line 76 of file List.h.

destroy

Consumer List::destroy

Optional destructor called when an element is removed.

Definition at line 91 of file List.h.

head

ListNode* List::head

The head node.

Definition at line 81 of file List.h.

interface

ListInterface* List::interface[0]

protected

The interface type.

Definition at line 71 of file List.h.

object

Object List::object

The superclass.

Definition at line 65 of file List.h.

tail

ListNode* List::tail

The tail node.

Definition at line 86 of file List.h.

Method Details

_List()

Class * _List

(

void

)

The List archetype.

Returns

The List Class.

Definition at line 406 of file List.c.

                   {
  static Class *clazz;
  static Once once;
 
  do_once(&once, {
    clazz = _initialize(&(const ClassDef) {
      .name = "List",
      .superclass = _Object(),
      .instanceSize = sizeof(List),
      .interfaceSize = sizeof(ListInterface),
      .initialize = initialize,
    });
  });
 
  return clazz;
}

append()

void append	(	List *	self,
		const ident	element
	)

Appends the given element to the tail of this List.

Parameters

self	The List.
element	The element to append.

Definition at line 72 of file List.c.

                                                    {
 
  ListNode *node = calloc(1, sizeof(ListNode));
  assert(node);
 
  node->element = element;
  node->prev = self->tail;
 
  if (self->tail) {
    self->tail->next = node;
  } else {
    self->head = node;
  }
 
  self->tail = node;
  self->count++;
}

contains()

bool contains	(	const List *	self,
		const ident	element
	)

Parameters

self	The List.
element	The element to search for (pointer equality).

Returns

True if this List contains the given element.

Definition at line 94 of file List.c.

                                                            {
  return $(self, nodeForElement, element) != NULL;
}

enumerate()

void enumerate	(	const List *	self,
		ListEnumerator	enumerator,
		ident	data
	)

Enumerates this List with the given function.

Parameters

self	The List.
enumerator	The enumerator function.
data	User data.

Definition at line 102 of file List.c.

                                                                                  {
 
  assert(enumerator);
 
  for (ListNode *node = self->head; node; ) {
    ListNode *next = node->next;
    if (enumerator(self, node, element)) {
      break;
    }
    node = next;
  }
}

filter()

void filter	(	List *	self,
		Predicate	predicate,
		ident	data
	)

Filters this List in place using predicate.

Parameters

self	The List.
predicate	The Predicate.
data	User data.

Definition at line 119 of file List.c.

                                                                {
 
  assert(predicate);
 
  for (ListNode *node = self->head; node; ) {
    ListNode *next = node->next;
    if (!predicate(node->element, data)) {
      $(self, removeNode, node);
    }
    node = next;
  }
}

filteredList()

List * filteredList	(	const List *	self,
		Predicate	predicate,
		ident	data
	)

Returns a new List containing elements of this List that pass predicate.

Parameters

self	The List.
predicate	The Predicate.
data	User data.

Returns

A new filtered List.

Definition at line 136 of file List.c.

                                                                             {
 
  assert(predicate);
 
  List *list = $(alloc(List), init);
  for (ListNode *node = self->head; node; node = node->next) {
    if (predicate(node->element, data)) {
      $(list, append, node->element);
    }
  }
 
  return list;
}

find()

ident find	(	const List *	self,
		Predicate	predicate,
		ident	data
	)

Parameters

self	The List.
predicate	The Predicate.
data	User data.

Returns

The first element to pass predicate, or NULL.

Definition at line 154 of file List.c.

                                                                     {
 
  assert(predicate);
 
  for (ListNode *node = self->head; node; node = node->next) {
    if (predicate(node->element, data)) {
      return node->element;
    }
  }
 
  return NULL;
}

init()

List * init

(

List *

self

)

Initializes this List.

Parameters

self

The List.

Returns

The initialized List, or NULL on error.

Definition at line 173 of file List.c.

                              {
 
  self = (List *) super(Object, self, init);
  return self;
}

insertAfter()

void insertAfter	(	List *	self,
		ListNode *	node,
		const ident	element
	)

Inserts an element after the given node.

Parameters

self	The List.
node	The node to insert after, or NULL to prepend.
element	The element to insert.

Definition at line 183 of file List.c.

                                                                         {
 
  if (node == NULL || node == self->tail) {
    $(self, append, element);
    return;
  }
 
  ListNode *newNode = calloc(1, sizeof(ListNode));
  assert(newNode);
 
  newNode->element = element;
  newNode->prev = node;
  newNode->next = node->next;
 
  if (node->next) {
    node->next->prev = newNode;
  }
  node->next = newNode;
 
  self->count++;
}

map()

void map	(	List *	self,
		Functor	functor,
		ident	data
	)

Transforms the elements in this List in place using functor.

Parameters

self	The List.
functor	The Functor.
data	User data.

Definition at line 209 of file List.c.

                                                         {
 
  assert(functor);
 
  for (ListNode *node = self->head; node; node = node->next) {
    node->element = functor(node->element, data);
  }
}

mappedList()

List * mappedList	(	const List *	self,
		Functor	functor,
		ident	data
	)

Returns a new List containing the elements of this List transformed by functor.

Parameters

self	The List.
functor	The Functor.
data	User data.

Returns

A new mapped List.

Definition at line 222 of file List.c.

                                                                       {
 
  assert(functor);
 
  List *list = $(alloc(List), init);
  for (ListNode *node = self->head; node; node = node->next) {
    $(list, append, functor(node->element, data));
  }
 
  return list;
}

nodeForElement()

ListNode * nodeForElement	(	const List *	self,
		const ident	element
	)

Parameters

self	The List.
element	The element to find (pointer equality).

Returns

The first node whose data matches, or NULL.

Definition at line 238 of file List.c.

                                                                       {
 
  for (ListNode *node = self->head; node; node = node->next) {
    if (node->element == element) {
      return node;
    }
  }
 
  return NULL;
}

prepend()

void prepend	(	List *	self,
		const ident	element
	)

Prepends the given element to the head of this List.

Parameters

self	The List.
element	The element to prepend.

Definition at line 253 of file List.c.

                                                     {
 
  ListNode *node = calloc(1, sizeof(ListNode));
  assert(node);
 
  node->element = element;
  node->next = self->head;
 
  if (self->head) {
    self->head->prev = node;
  } else {
    self->tail = node;
  }
 
  self->head = node;
  self->count++;
}

reduce()

ident reduce	(	const List *	self,
		Reducer	reducer,
		ident	accumulator,
		ident	data
	)

Parameters

self	The List.
reducer	The Reducer.
accumulator	The initial accumulator value.
data	User data.

Returns

The reduction result.

Definition at line 275 of file List.c.

                                                                                      {
 
  assert(reducer);
 
  for (ListNode *node = self->head; node; node = node->next) {
    accumulator = reducer(node->element, accumulator, data);
  }
 
  return accumulator;
}

remove()

void remove	(	List *	self,
		const ident	element
	)

Removes the first occurrence of element from this List.

Parameters

self	The List.
element	The element to remove.

removeAll()

void removeAll

(

List *

self

)

Removes all elements from this List.

Parameters

self

The List.

Definition at line 290 of file List.c.

                                  {
 
  ListNode *node = self->head;
  while (node) {
    ListNode *next = node->next;
    if (self->destroy) {
      self->destroy(node->element);
    }
    free(node);
    node = next;
  }
 
  self->head = self->tail = NULL;
  self->count = 0;
}

removeNode()

void removeNode	(	List *	self,
		ListNode *	node
	)

Removes the given node from this List.

Parameters

self	The List.
node	The node to remove.

Definition at line 322 of file List.c.

                                                   {
 
  assert(node);
 
  if (node->prev) {
    node->prev->next = node->next;
  } else {
    self->head = node->next;
  }
 
  if (node->next) {
    node->next->prev = node->prev;
  } else {
    self->tail = node->prev;
  }
 
  if (self->destroy) {
    self->destroy(node->element);
  }
 
  free(node);
  self->count--;
}

sort() [1/2]

void sort	(	List *	self,
		Comparator	comparator
	)

Sorts this List in-place using the given comparator.

Parameters

self	The List.
comparator	The Comparator.

sort() [2/2]

void sort	(	List *	self,
		ListSortFunc	sort
	)

---

The documentation for this struct was generated from the following files:

• Sources/Objectively/List.h
• Sources/Objectively/List.c