# FreeType-2.3.4 API Reference

# List Processing

## Synopsis

| FT_List |  | FT_List_Add |  | FT_List_Iterate
| FT_ListNode |  | FT_List_Insert |  | FT_List_Destructor
| FT_ListRec |  | FT_List_Remove |  | FT_List_Finalize
| FT_ListNodeRec |  | FT_List_Up |  |
| FT_List_Find |  | FT_List_Iterator |  |

This section contains various definitions related to list processing using doubly-linked nodes.

#### FT_List
      typedef struct FT_ListRec_*  FT_List;
A handle to a list record (see FT_ListRec).

[Index] |  | [TOC]

#### FT_ListNode
      typedef struct FT_ListNodeRec_*  FT_ListNode;
Many elements and objects in FreeType are listed through an FT_List record (see FT_ListRec). As its name suggests, an FT_ListNode is a handle to a single list element.

[Index] |  | [TOC]

#### FT_ListRec
      typedef struct  FT_ListRec_
      {
        FT_ListNode  head;
        FT_ListNode  tail;

      } FT_ListRec;
A structure used to hold a simple doubly-linked list. These are used in many parts of FreeType.
fields
head | The head (first element) of doubly-linked list.
tail | The tail (last element) of doubly-linked list.

[Index] |  | [TOC]

#### FT_ListNodeRec
      typedef struct  FT_ListNodeRec_
      {
        FT_ListNode  prev;
        FT_ListNode  next;
        void*        data;

      } FT_ListNodeRec;
A structure used to hold a single list element.
fields
prev | The previous element in the list. NULL if first.
next | The next element in the list. NULL if last.
data | A typeless pointer to the listed object.

[Index] |  | [TOC]

#### FT_List_Find
      FT_EXPORT( FT_ListNode )
      FT_List_Find( FT_List  list,
                    void*    data );
Finds the list node for a given listed object.
input
list | A pointer to the parent list.
data | The address of the listed object.
return
List node. NULL if it wasn't found.

[Index] |  | [TOC]

#### FT_List_Add
      FT_EXPORT( void )
      FT_List_Add( FT_List      list,
                   FT_ListNode  node );
Appends an element to the end of a list.
inout
list | A pointer to the parent list.
node | The node to append.

[Index] |  | [TOC]

#### FT_List_Insert
      FT_EXPORT( void )
      FT_List_Insert( FT_List      list,
                      FT_ListNode  node );
Inserts an element at the head of a list.
inout
list | A pointer to parent list.
node | The node to insert.

[Index] |  | [TOC]

#### FT_List_Remove
      FT_EXPORT( void )
      FT_List_Remove( FT_List      list,
                      FT_ListNode  node );
Removes a node from a list. This function doesn't check whether the node is in the list!
input
node | The node to remove.
inout
list | A pointer to the parent list.

[Index] |  | [TOC]

#### FT_List_Up
      FT_EXPORT( void )
      FT_List_Up( FT_List      list,
                  FT_ListNode  node );
Moves a node to the head/top of a list. Used to maintain LRU lists.
inout
list | A pointer to the parent list.
node | The node to move.

[Index] |  | [TOC]

#### FT_List_Iterator
      typedef FT_Error
      (*FT_List_Iterator)( FT_ListNode  node,
                           void*        user );
An FT_List iterator function which is called during a list parse by FT_List_Iterate.
input
node | The current iteration list node.
user | A typeless pointer passed to FT_List_Iterate. Can be used to point to the iteration's state.

[Index] |  | [TOC]

#### FT_List_Iterate
      FT_EXPORT( FT_Error )
      FT_List_Iterate( FT_List           list,
                       FT_List_Iterator  iterator,
                       void*             user );
Parses a list and calls a given iterator function on each element. Note that parsing is stopped as soon as one of the iterator calls returns a non-zero value.
input
list | A handle to the list.
iterator | An iterator function, called on each node of the list.
user | A user-supplied field which is passed as the second argument to the iterator.
return
The result (a FreeType error code) of the last iterator call.

[Index] |  | [TOC]

#### FT_List_Destructor
      typedef void
      (*FT_List_Destructor)( FT_Memory  memory,
                             void*      data,
                             void*      user );
An FT_List iterator function which is called during a list finalization by FT_List_Finalize to destroy all elements in a given list.
input
system | The current system object.
data | The current object to destroy.
user | A typeless pointer passed to FT_List_Iterate. It can be used to point to the iteration's state.

[Index] |  | [TOC]

#### FT_List_Finalize
      FT_EXPORT( void )
      FT_List_Finalize( FT_List             list,
                        FT_List_Destructor  destroy,
                        FT_Memory           memory,
                        void*               user );
Destroys all elements in the list as well as the list itself.
input
list | A handle to the list.
destroy | A list destructor that will be applied to each element of the list.
memory | The current memory object which handles deallocation.
user | A user-supplied field which is passed as the last argument to the destructor.

[Index] |  | [TOC]