## Xfce Generics

Xfce Generics — Generic data types and related functions.

## Synopsis

    #include <libxfce4util/libxfce4util.h>

    #define             XFCE_GENERIC_STACK                  (Type)
    #define             xfce_stack_new                      (StackType)
    #define             xfce_stack_free                     (stack)
    #define             xfce_stack_top                      (stack)
    #define             xfce_stack_pop                      (stack)
    #define             xfce_stack_push                     (stack,
                                                             value)

## Description

This module provides generic data types - as known from the C++ standard template library - for the brave C programmer. Since C does not provide any template mechanism, these generics are completely based on C preprocessor macros and the functions offer no type safety at all (though some common mistakes will surely be caught by the C compiler).

Example 2. Using a generic stack

      typedef XFCE_GENERIC_STACK(int) IntStack;
      IntStack *stack = xfce_stack_new (IntStack);
      xfce_stack_push (stack, 0);
      xfce_stack_push (stack, 1);
      printf ("Top is %d\n", xfce_stack_top (stack));
      xfce_stack_pop (stack);
      printf ("Top is %d\n", xfce_stack_top (stack));
      xfce_stack_free (stack);

## Details

### XFCE_GENERIC_STACK()

    #define             XFCE_GENERIC_STACK(Type)

This macro is used to create a new stack data type which elements are of `Type`. For example, to create a stack type that handles elements of type `double`, you'd write the following

    typedef XFCE_GENERIC_STACK(double) MyDoubleStack;

and furtheron refer to your stack type as `MyDoubleStack`.

`Type` : | Data type of the elements that should be handled by the stack. Can be any valid data type from simple int's to complex structures.

### xfce_stack_new()

    #define             xfce_stack_new(StackType)

Creates a new instance of `StackType` and returns a pointer to the newly created instance. For example, imagine you declared a type `MyDoubleStack` as shown above, you can instantiate this type with

    MyDoubleStack *my_stack = xfce_stack_new (MyDoubleStack);

`StackType` : | Type of stack declared with XFCE_GENERIC_STACK.

### xfce_stack_free()

    #define             xfce_stack_free(stack)

Frees a stack, that was allocated using xfce_stack_new.

`stack` : | A stack object.

### xfce_stack_top()

    #define             xfce_stack_top(stack)

Returns the top element from `stack`. Note that this function does not pop the top element, it just returns it.

`stack` : |

### xfce_stack_pop()

    #define             xfce_stack_pop(stack)

Removes the top element from `stack`.

`stack` : |

### xfce_stack_push()

    #define             xfce_stack_push(stack, value)

Pushes a new `value` on top of `stack`.

`stack` : |
`value` : |