FreeType-2.1.10 API Reference

List Processing

Synopsis

FT_ListFT_List_AddFT_List_Iterate
FT_ListNodeFT_List_InsertFT_List_Destructor
FT_ListRecFT_List_RemoveFT_List_Finalize
FT_ListNodeRecFT_List_Up
FT_List_FindFT_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).



FT_ListNode


  typedef struct FT_ListNodeRec_*  FT_ListNode;


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



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.


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.


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.


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.


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.


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.


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.


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.


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 interator 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.


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.


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.