int (*Add)(List *list,const void *data);

double MyDouble;
List *myList;
myList = iList.Create(sizeof(double));
// ...
iList.Add(myList,&myDouble);

double MyDouble;
doubleList *myList;
myList = idoubleList.Create();
// ...
idoubleList.Add(myList,myDouble);

iList.Add(list,object);
istrCollection.Add(strcol,object);

typedef struct tagCompareInfo {
    void *ExtraArgs;
    const void *ContainerLeft;
    const void *ContainerRight;
} CompareInfo;

typedef int (*CompareFunction)(const void *elem1, 
                               const void *elem2, 
                               CompareInfo *ExtraArgs);

struct Data {
    int Age; // Here the compiler can introduce padding bytes
    double Weight;
};

int fn(void)
{
    struct Data m;
    memset(&m,0,sizeof(m));
    m.Age = 23;
    m.Weight = 76;
    iVector.Add(DataCollection,&m);
}

typedef int (*SaveFunction)(const void *element, 
                               void *ExtraArg, 
                               FILE *OutputStream);

typedef int (*ReadFunction)(void *element, 
                               void *ExtraArg, 
                               FILE *InputStream);

typedef void *(*ErrorFunction)(const char *functionName,int code,...);

typedef int (*DestructorFunction)(void *object);

Container * iContainer.Create(size_t elementsize,...);

int iContainer.Add(Container *,const  void *element);

int iContainer.AddRange(Container *,size_t n,const void *elements[]);

int iContainer.Erase(Container *,const void *element);
int iContainer.EraseAll(Container *,const void *element);

int iContainer.EraseAt(Container *,size_t idx);

int iContainer.Erase(Container *,const char *Key);

int iContainer.PopBack(Container *d,void *outbuf);
int iContainer.PopFront(Container *d,void *outbuf);

int iContainer.RemoveRange(Container *c,size_t start, size_t end);

const void *iContainer.GetElement(const Container *,size_t index);
const void *iContainer.GetElement(const Container *,const void *Key);

Container *iContainer.GetRange(const Container *src,
                              size_t start, size_t end);

int (*Select)(Container *,const mask *);
Container *(*SelectCopy)(const Container *,const mask *);

Mask *(*CompareEqual)(const Container *,const Mask *);
Mask *(*CompareEqualScalar)(const Container *, const Mask *);

int iContainer.Sort(Container *);

newContainer * iContainer.Copy(const Container *);

int Save(const Container *c,FILE *stream, SaveFunction fn,void *arg);
Container *Load(FILE *stream,ReadGunction fn,void *arg);

int (*InsertIn)(Container *destination,
                size_t position,
                Container *source);
int (*Append)(SequentialContainer * SC1,SequentialContainer * SC2);

int (*InsertIn)(Container *destination, Container *source);

int (*ReplaceAt)(Container *dst,size_t position,void *newData);

int (*Replace)(Dictionary *Dict, const char *Key,void *Value);

// "Container" is a pointer to some container
for (size_t i=0; i<iContainer.Size(Container); i++) {
    someType *element = iContainer.GetElement(Container,i);
    // Use "element" here.
}

void iContainer.Apply(Container, //pointer to some container
                      int(*Applyfn)(void *elem,void *arg),
                      void *arg);

Iterator *it = iContainer.NewIterator(someContainer);
Mytype *Myobject;
for (myobject = it->GetFirst(it); 
     myobject!= NULL; 
     myobject = it->GetNext(it)) {
     // Work with "myobject" here
}
iContainer.DeleteIterator(it); // dispose the iterator object

void *iterator->GetFirst(iterator);
void *iterator->GetNext(iterator);
void *iterator->GetCurrent(iterator);

iterator *iContainer.NewIterator(Container); 
int iContainer.deleteIterator(iterator);

void *iterator->GetLast(iterator);
void *iterator->GetPrevious(iterator);
void *iterator->Seek(iterator i, size_t position);

    size_t iContainer.Size(const Container *);

    size_t iContainer.Sizeof(const Container *);

int Fn(void)
{
    char buf[iList.SizeofIterator(NULL)];
    Iterator *it = (Iterator *)buf;
    iList.InitIterator(it);
    // Use iterator "it" here
    // ...
    // No need to call deleteIterator at exit
}

typedef struct _Mask Mask;
typedef struct tagMaskInterface {
    int (*And)(Mask *src1,Mask *src2);
    int (*Clear)(Mask *m);
    Mask *(*Copy)(Mask *src);
    Mask *(*Create)(size_t length);
    Mask *(*CreateFromMask)(size_t length,char *data);
    int (*Finalize)(Mask *m);
    int (*Or)(Mask *src1,Mask *src2);
    size_t (*PopulationCount)(const Mask *m);
    int (*Set)(Mask *m,size_t idx,int val);
    size_t (*Size)(Mask *);
} iMask;

    int (*And)(Mask *src1,Mask *src2);

    int (*Clear)(Mask *m);

Mask *(*Copy)(Mask *src);

    Mask *(*CreateFromMask)(size_t length,char *data);

    Mask *(*Create)(size_t length);

    int (*Finalize)(Mask *m);

    int (*Not)(Mask *src);

    int (*Or)(Mask *src1,Mask *src2);

   size_t (*PopulationCount)(const Mask *m);

    int (*Set)(Mask *m,size_t idx,int val);

    size_t (*Size)(Mask *);

    size_t (*Sizeof)(Mask *);

typedef struct tagAllocator {
    void *(*malloc)(size_t);
    void  (*free)(void *);
    void *(*realloc)(void *,size_t);
    void *(*calloc)(size_t,size_t);
} ContainerAllocator;
extern ContainerAllocator * CurrentAllocator;

extern ContainerAllocator iDebugMalloc;

    int (*UseHeap)(Container *c);
    ContainerHeap *(*GetHeap)(Container *c);

typedef struct tagContainerHeapInterface {
   void (*Clear)(ContainerHeap *heap);
   ContainerHeap *(*Create)(size_t ElementSize,
                  const ContainerAllocator *m);
   void (*Finalize)(ContainerHeap *heap);
   int (*FreeObject)(ContainerHeap *heap,void *element);
   ContainerHeap *(*InitHeap)(void *heap,size_t nbElements,
                  const ContainerAllocator *allocator);
   Iterator *(*NewIterator)(ContainerHeap *);
   void *(*NewObject)(ContainerHeap *heap);
   size_t (*Sizeof)(ContainerHeap *heap);
   int (*deleteIterator)(Iterator *it);
} ContainerHeapInterface;

ContainerHeap *iHeap.Create(size_t elementSize, Allocator *m);

   ContainerHeap * (*InitHeap)(void *heap,size_t ElementSize,
                    ContainerAllocator *m);

   void *iHeap.newObject(ContainerHeap *heap);

   size_t iHeap.FreeObject(ContainerHeap *heap,void *element);

   void iHeap.Clear(ContainerHeap *heap);

    void iHeap.Finalize(ContainerHeap *heap);

    size_t iHeap.Sizeof(ContainerHeap *heap);

void SomeFunction(void)
{
    char buffer[iHeap.Sizeof(NULL)];
    ContainerHeap *ch;

    ch = iHeap.InitHeap(buffer,200,NULL);
    // ...
    iHeap.Clear(ch);
}

typedef struct _tagPoolAllocatorInterface {
    Pool  *(*Create)(ContainerAllocator *m);
    void  *(*Alloc)(Pool *pool,size_t size);
    void  *(*Calloc)(Pool *pool,size_t size);
    void   (*Clear)(Pool *);
    void   (*Finalize)(Pool *);
} PoolAllocatorInterface;

    Pool *iPool.Create(ContainerAllocator *m);

    void  *iPool.Alloc(Pool *pool,size_t size);

    void  *iPool.Calloc(Pool *pool,size_t n,size_t size);

    void iPool.Clear(Pool *);

    void   iPool.Finalize(Pool *);

typedef (*ErrorFunction)(const char *,int,...);
typedef struct {
  void        (*RaiseError)(const char *fname,int code,...);
  void        (*EmptyErrorFunction)(const char *fname,int code,...);
  const char *(*StrError)(int errorCode);
  ErrorFunction (*SetErrorFunction)(ErrorFunction);
  int         (*NullPtrError)(const char *);
} ErrorInterface;

 void      iError.RaiseError(const char *fname,int errcode,...);

 void      iError.EmptyErrorFunction(const char *fname,int errcode,...);

  const char *iError.StrError(int errorCode);

  ErrorFunction iError.SetErrorFunction(ErrorFunction);

int (*NullPtrError)(const char *msg);

int NullPtrError(const char *fname)
{
    iError.RaiseError(fname,CONTAINER_ERROR_BADARG);
    return CONTAINER_ERROR_BADARG;
}

typedef struct _Iterator {
    void *(*GetNext)(Iterator *);
    void *(*GetPrevious)(Iterator *);
    void *(*GetFirst)(Iterator *);
    void *(*GetCurrent)(Iterator *);
    void *(*GetLast)(Iterator *);
    void *(*Seek)(Iterator *it,size_t pos);
    int (*Replace)(Iterator *it, void *data, int drection);
} Iterator;

    void *(*GetCurrent)(Iterator *);

    void *(*GetFirst)(Iterator *);

Iterator *myIterator;
List *myList;
myType *obj; // "myList" stores objects of type "myType"
myIterator = iList.NewIterator(myList); // Request iterator
for (obj = myIterator->GetFirst(myIterator); 
     obj != NULL; 
     obj = myIterator->GetNext(myIterator)) {
     //Use obj here
}
iList.deleteIterator(myIterator); // Reclaim memory

    void *(*GetNext)(Iterator *);

    void *(*GetPrevious)(Iterator *);

Iterator *myIterator;
List *myList;
myType *obj; // "myList" stores objects of type "myType"
myIterator = iList.NewIterator(myList); // Request iterator
for (obj = myIterator->GetLast(myIterator); 
     obj != NULL; 
     obj = myIterator->GetPrevious(myIterator)) {
     //Use obj here
}
iList.deleteIterator(myIterator); // Reclaim memory

    void *(*GetLast)(Iterator *);

void *(*Seek)(Iterator *it,size_t pos);

int (*Replace)(Iterator *it,void *data, int direction);

typedef void (*ObserverFunction)(const void *ObservedObject,
                                 unsigned Operation, 
                                 void *ExtraInfo[]);

typedef struct tagObserverInterface {
    int (*Subscribe)(void *ObservedObject, 
                     ObserverFunction callback, unsigned Operations);
    int (*Notify)(const void *ObservedObject,unsigned operation,
                  void *ExtraInfo1,void *ExtraInfo2);
    size_t (*Unsubscribe)(void *ObservedObject,
                          ObserverFunction callback);
} ObserverInterface;
extern ObserverInterface iObserver;

typedef void (*ObserverFunction)(void *ObservedObject,
                                 unsigned Operation, void *ExtraInfo[]);

int (*Subscribe)(void *ObservedObject, ObserverFunction callback, 
                 unsigned Operations);

int (*Notify)(void *ObservedObject,unsigned Operation,
                  void *ExtraInfo1,void *ExtraInfo2);

size_t (*Unsubscribe)(void *ObservedObject, ObserverFunction callback);

include "containers.h"
static void fn(void *ObservedObject, unsigned operation,
               void *extraInfo[])
{
    printf("Object is %p, operation is %d\n",ObservedObject,operation);
}
int main(void)
{
    ValArrayInt * vInt = iValArrayInt.CreateSequence(24,0,1);

    printf("Original array: \n");
    iValArrayInt.Fprintf(vInt,stdout,"%d ");
    iObserver.Subscribe(vInt,fn,CCL_ADD|CCL_FINALIZE);
    printf("Adding an integer\n");
    iValArrayInt.Add(vInt,4096);
    iValArrayInt.Fprintf(vInt,stdout,"%d ");
    iValArrayInt.Finalize(vInt);
}
OUTPUT:
Original array: 
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 
Adding an integer
Object is 0x100100080, operation is 1
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 4096 
Object is 0x100100080, operation is 16

typedef struct tagListInterface {
   int (*Add)(List *L,const void *newval);
   int (*AddRange)(List *L, size_t n,const void *data);
   void *(*Advance)(ListElement **pListElement);
   int (*Append)(List *l1,List *l2);
   int (*Apply)(List *L,int(Applyfn)(void *,void *),void *arg);
   void *(*Back)(const List *l);
   int (*Clear)(List *L);
   int (*Contains)(const List *L,const void *element);
   List *(*Copy)(const List *L);
   int (*CopyElement)(const List *list,size_t idx,void *OutBuffer);
   List *(*Create)(size_t element_size);
   List *(*CreateWithAllocator)(size_t elementsize,
         const ContainerAllocator *mm);
   void *(*ElementData)(ListElement *le);
   int (*Equal)(const List *l1,const List *l2);
   int (*Erase)(List *L,const void *);
   int (*EraseAll)(List *l,const void *);
   int (*EraseAt)(List *L,size_t idx);
   int (*EraseRange)(List *L,size_t start,size_t end);
   int (*Finalize)(List *L);
   ListElement *(*FirstElement)(List *l);
   void *(*Front)(const List *l);
   const ContainerAllocator *(*GetAllocator)(const List *list);
   void *(*GetElement)(const List *L,size_t idx);
   size_t (*GetElementSize)(const List *l);
   unsigned (*GetFlags)(const List *L);
   ContainerHeap *(*GetHeap)(const List *l);
   List *(*GetRange)(const List *l,size_t start,size_t end);
   int (*IndexOf)(const List *L,const void *SearchedElement,
        void *ExtraArgs,size_t *result);
   List *(*Init)(List *aList,size_t element_size);
   int (*InitIterator)(List *L,void *buf);
   List *(*InitWithAllocator)(List *aList,size_t element_size,
         const ContainerAllocator *mm);
   List *(*InitializeWith)(size_t elementSize,size_t n,
         const void *data);
   int (*InsertAt)(List *L,size_t idx,const void *newval);
   int (*InsertIn)(List *l, size_t idx,List *newData);
   ListElement *(*LastElement)(List *l);
   List *(*Load)(FILE *stream, ReadFunction loadFn,void *arg);
   Iterator *(*NewIterator)(List *L);
   ListElement *(*NextElement)(ListElement *le);
   int (*PopFront)(List *L,void *result);
   int (*PushFront)(List *L,const void *str);
   int (*RemoveRange)(List *l,size_t start, size_t end);
   int (*ReplaceAt)(List *L,size_t idx,const void *newval);
   int (*Reverse)(List *l);
   int (*RotateLeft)(List *l, size_t n);
   int (*RotateRight)(List *l,size_t n);
   int (*Save)(const List *L,FILE *stream, SaveFunction saveFn,
        void *arg);
   int (*Select)(List *src,const Mask *m);
   List *(*SelectCopy)(const List *src,const Mask *m);
   CompareFunction (*SetCompareFunction)(List *l,CompareFunction fn);
   DestructorFunction (*SetDestructor)(List *v,DestructorFunction fn);
   int (*SetElementData)(List *l, ListElement *le,void *data);
   ErrorFunction (*SetErrorFunction)(List *L,ErrorFunction);
   unsigned (*SetFlags)(List *L,unsigned flags);
   size_t (*Size)(const List *L);
   size_t (*Sizeof)(const List *l);
   size_t (*SizeofIterator)(const List *);
   ListElement *(*Skip)(ListElement *l,size_t n);
   int (*Sort)(List *l);
   List *(*SplitAfter)(List *l, ListElement *pt);
   int (*UseHeap)(List *L, const ContainerAllocator *m);
   int (*deleteIterator)(Iterator *);
} ListInterface;

#define CONTAINER_READONLY          1

#define CONTAINER_SORTED_FRONT      2
#define CONTAINER_SORTED_BACK       4

int (*Add)(List *l,const void *data);
int (*Add)(TYPEList *l, TYPE data);

/* This example shows how to: 
(1) Create a linked list of "double" data
(2) Fill it using the "Add" function
(3) Print it using the GetElement function */
#include <containers.h>
static void PrintList(List *AL)
{
    size_t i;
    for (i=0; i<iList.Size(AL);i++) {
        printf("%g ",*(double *)iList.GetElement(AL,i));
    }
    printf("\n");
}
static void FillList(List * AL,size_t siz)
{
    size_t i;

    for (i=0; i<siz;i++) {
        double d = i;
        iList.Add(AL,&d);
    }
}

int main(void)
{
    List *AL = iList.Create(sizeof(double));
    FillList(AL,10);
    PrintList(AL);
    return 0;
}
OUTPUT:
0 1 2 3 4 5 6 7 8 9

#include <containers.h>
#include <doublelist.h>
static void PrintList(doubleList *AL)
{
    size_t i;
    for (i=0; i<idoubleList.Size(AL);i++) {
        printf("%g ",idoubleList.GetElement(AL,i));
    }
    printf("\n");
}
static void FillList(doubleList * AL,size_t siz)
{
    size_t i;

    for (i=0; i<siz;i++) {
        idoubleList.Add(AL,(double)i);
    }
}

int main(void)
{
    doubleList *AL = idoubleList.Create();
    FillList(AL,10);
    PrintList(AL);
    return 0;
}
OUTPUT:
0 1 2 3 4 5 6 7 8 9

void *(*Advance)(ListElement **ppElement);
TYPE *(*Advance)(TYPEListElement **ppElement);

    int (*AddRange)(List * AL,size_t n, void *data);
    int (*AddRange)(TYPEList * AL,size_t n, TYPE *data);

    int (*Append)(List *list1,List *list2);

#include <containers.h>
static void PrintList(List *AL)
{
    size_t i;
    for (i=0; i<iList.Size(AL);i++) {
        printf("%g ",*(double *)iList.GetElement(AL,i));
    }
    printf("\n");
}
static void FillList(List * AL,size_t siz)
{
    size_t i;

    for (i=0; i<siz;i++) { double d = i; iList.Add(AL,&d);}
}

int main(void)
{
    List *L1 = iList.Create(sizeof(double));
    List *L2 = iList.Create(sizeof(double));
    FillList(L1,10);
    FillList(L2,10);
    iList.Append(L1,L2);
    PrintList(L1);
    return 0;
}
OUTPUT:
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9

    int (*Apply)(List l,int (Applyfn)(void *,void *),void *arg);
    int (*Apply)(List l,int (Applyfn)(TYPE ,void *),void *arg);

#include <containers.h>
static int Callback(void *pElement,void *pResult)
{
    double *p = pElement;
    double *result = pResult;
    *result += *p;
    return 1;
}
    
void main(void) 
{
    double sum = 0;
    List *list = iList.Create(sizeof(double));
    double d = 2;
    iList.Add(list,&d);
    d = 3;
    iList.Add(list,&d);
    iList.Apply(list,Callback,&sum);
    // Here sum should be 5.
    printf("%g\n",sum);
}

/* Template file example */
#include <containers.h>
#include "doublelist.h"
static int Callback(double Element,void *pResult)
{
    double *result = pResult;
    *result += Element;
    return 1;
}
    
void main(void) 
{
    double sum = 0;
    doubleList *list = idoubleList.Create();
    iList.Add(list,2);
    iList.Add(list,3);
    iList.Apply(list,Callback,&sum);
    // Here sum should be 5.
    printf("%g\n",sum);
}

const void *(*Back)(const List *list);
const TYPE  (*Back)(const TYPEList *l);

    int (*Clear)(List *l);

List *l;
    int m = iList.Clear(l);

    int (*Contains)(List *list,void *data);
    int (*Contains)(TYPEList *l, TYPE data);

List *list;
    int r = iList.Contains(list,&data);

    List *(*Copy)(const List *L);

List *newList,*OldList;
    newList = iList.Copy(OldList);
    if (newList == NULL) { /* Error handling */ }

    int (*CopyElement)(const List *list,size_t idx,void *outBuffer);
    int (*CopyElement)(const TYPEList *list,size_t idx,TYPE *outBuffer);

List *list; double d;
    if (iList.CopyElement(list,3,&d) > 0)
        printf("The value at position 3 is %g\n",d);

    List *(*Create)(size_t element_size);
    TYPEList *(*Create)(void); // Template version

List *ListOfDoubles = iList.Create(sizeof(double));
    doubleList *ListOfDoubles = idoubleList.Create();

List *(*CreateWithAllocator)(size_t elem_size,
                             ContainerAllocator *allocator);
// Template file version
TYPEList *(*CreateWithAllocator)(ContainerAllocator *allocator);

ContainerAllocator *myAllocator;
    List *ListOfDoubles = 
          iList.CreateWithAllocator(sizeof(double),myAllocator);
    doubleList *ListOfDoubles = 
          idoubleList.CreateWithAllocator(myAllocator);

    int deleteIterator(Iterator *it);

    int (*Equal)(const List *list1,const List *list2);

    int (*Erase)(List *list,void *const data);

double d = 2.3;
    List *list;
    int r = iList.Erase(list,&d);
    if (r > 0)
        printf("2.3 erased\n");
    else if (r == CONTAINER_ERROR_NOTFOUND)
        printf("No element with value 2.3 present\n");
    else
        printf("2.3 not erased. Error is \%s\n",iError.StrError(r));

    int (*EraseAll)(List *list,const void *data);

    int (*EraseAt)(List *list,size_t idx);

List *list;
    int r = iList.EraseAt(list,2);
    if (r > 0)
        printf("Element at position 2 erased\n");
    else
        printf("Error code %d\n",r);

  int (*EraseRange)(List *L,size_t start,size_t end);

#include <containers.h>
static void print_list(List *li)
{
        int i;
        for (i=0; i<iList.Size(li); i++)
                printf(" %d",*(int *)iList.GetElement(li,i));
        printf("\n");
}
int main(void)
{
    List *li = iList.Create(sizeof(int));
    int i;
    for (i=0; i<10;i++) {
        iList.Add(li,&i);
    }
    print_list(li);
    iList.EraseRange(li,3,8);
    print_list(li);
}
OUTPUT:
 0 1 2 3 4 5 6 7 8 9
 0 1 2 8 9

    int (*Finalize)(List *list);

List *list;
    int r = iList.Finalize(list);
    if (r < 0) { /* error handling */ }

ListElement *(*FirstElement)(List *list);

const void *(*Front)(const List *l);
TYPE *(*Front)(const TYPEList *l);

ContainerAllocator *(*GetAllocator)(const List *l);

    size_t (*GetElementSize)(const List *l);

List *l;
    size_t siz = iList.GetElementSize(l);

    const void *(*GetElement)(const List *list,size_t idx);
    const TYPE *(*GetElement)(const TYPEList *list,size_t idx);

List *list;
    doubleList *dlist;
    // ...
    double d = *(double *)iList.GetElement(list,3);
    double d = idoubleList.GetElement(dlist,3);

    unsigned (*GetFlags)(const List *l);
    unsigned (*SetFlags)(List *l,unsigned newFlags);

    List *(*GetRange)(const List *list,size_t start,size_t end);
    TYPE *(*GetRange)(const TYPEList *l,size_t start,size_t end);

List *list;
    List *range = iList.GetRange(list,2,5);
    if (range == NULL) { /* Error handling */ }

int (*IndexOf)(const List *l,const void *ElementToFind,
                               void *args,size_t *result);
int (*IndexOf)(const TYPEList *l,const TYPE ElementToFind,
                               void *args,size_t *result);

List *list;
    double data;
    size_t idx;
    int r = iList.IndexOf(list,&data,&idx);
    if (r == CONTAINER_ERROR_NOTFOUND)
        printf("Not found\n");
    else if (r < 0)
        printf("Error\n");
    else printf("Found at position %ld\n",idx);

List *(*Init)(List *aList,size_t element_size);
TYPEList *(*Init)(TYPEList *aList);

// This example uses C99
void Example(void)
{
    char aList[iList.Sizeof(NULL)];
    List *list = iList.Init((List *)aList);
    doubleList *l = idoubleList.Init((TYPEList *)aList);
}

List *(*InitializeWith)(size_t elementSize, size_t n,const void *Data);
// Template file version
TYPEList *(*InitializeWith)(size_t n,const TYPE *Data);

    List *(*InitWithAllocator)(List *aList,
                               size_t element_size,
                         const ContainerAllocator *allocator);
    TYPEList *(*InitWithAllocator)(TYPEList *aList,
                         const ContainerAllocator *allocator);

    int (*InsertAt)(List *L,size_t idx,const void *newData);
    int (*InsertAt)(TYPEList *L,size_t idx,const TYPE newData);

1 #include "containers.h"
  2 static int PrintInt(void *pdata,void *extraArgs)
  3 {
  4     int i = *(int *)pdata;
  5     fprintf(extraArgs,"%d ",i);
  6 }
  7 int main(void)
  8 {
  9     List *L;
 10     int data;
 11 
 12     L = iList.Create(sizeof(int));
 13     data = 0;
 14     iList.Add(L,&data);
 15     iList.PushFront(L,&data);
 16     data = 2;
 17     iList.InsertAt(L,1,&data); 
 18     data = 5;
 19     iList.Add(L,&data);
 20     data = 6;
 21     iList.Add(L,&data);
 22     iList.Apply(L,PrintInt,stdout);
 23     iList.Finalize(L);
 24 }
OUTPUT: 0 2 0 5 6

  1 #include "containers.h"
  2 #include "intlist.h"
  3 static int PrintInt(int data,void *extraArgs)
  4 {  
  5     fprintf(extraArgs,"%d ",data);
  6 }
  7 int main(void)
  8 {
  9     intList *L;
 10     int data;
 11 
 12     L = iintList.Create();
 13     iintList.Add(L,0);
 14     iintList.PushFront(L,0);
 15     iintList.InsertAt(L,1,2); 
 16     iintList.Add(L,5);
 17     iintList.Add(L,6);
 22     iintList.Apply(L,PrintInt,stdout);
 23     iintList.Finalize(L);
 24 }
OUTPUT: 0 2 0 5 6

    int (*InsertIn)(List *Destination, size_t position, List *source);

#include <containers.h>
/* Prints the contents of a list */
static void PrintList(List *AL)
{
    size_t i;
    printf("Count %ld\n",(long)iList.Size(AL));
    for (i=0; i<iList.Size(AL);i++) {
        printf("%g ",*(double *)iList.GetElement(AL,i));
    }
    printf("\n");
}
/* Fills a list with 10 numbers. The 10 is hardwired... */
static void FillList(List * AL,int start)
{
    size_t i;

    for (i=0; i<10;i++) {
        double d = i+start;
        iList.Add(AL,&d);
    }
}
/* Creates two lists: one with the numbers from 0 to 9, another 
   with numbers 100 to 109, then inserts the second into the 
   first at position 5 */
int main(void)
{
    List *AL = iList.Create(sizeof(double));
    List *AL1 =iList.Create(sizeof(double));
    FillList(AL,0);
    FillList(AL1,100);
    iList.InsertIn(AL,5,AL1);
    PrintList(AL);
    return 0;
}
OUTPUT:
Count 20
0 1 2 3 4 100 101 102 103 104 105 106 107 108 109 5 6 7 8 9

ListElement *(*LastElement)(List *l);

    List *(*Load)(FILE *stream,ReadFunction readFn,void *arg);

    Iterator *(*NewIterator)(List *list);

List *list;
    Iterator *it = iList.NewIterator(list);
    double *d;
    for (d=it->GetFirst(it); d != NULL; d = it->GetNext(it)) {
        double val = *d;
        // Work with the value here
    }
    iList.deleteIterator(it);

DlistElement *(*NextElement)(DlistElement *le);

int (*PopFront)(List *L,void *result);

double d;
    int r = iList.PopFront(L,&d);
    if (r==0)
        printf("List empty\n");
    else if (r < 0) {
        printf("Error %d\n",r);
    else    printf("OK, popped value %g\n",d);

    int (*PushFront)(List *L,void *element);

double d = 2.3;
    if (iList.PushFront(list,&d) < 0)
        printf("Error\n");

int (*RemoveRange)(List *l,size_t start,size_t end);

    int (*ReplaceAt)(List *list,size_t idx,const void *newData);

List *list;
    double d = 6.7;
    int r = iList.ReplaceAt(list,2,&d);
    if (r < 0) { /* Error handling */ }

    int (*Reverse)(List *list);

#include <containers.h>
static void print_list(List *li)
{
        int i;
        for (i=0; i<iList.Size(li); i++)
                printf(" %d",*(int *)iList.GetElement(li,i));
        printf("\n");
}
int main(void)
{
    List *li = iList.Create(sizeof(int));
    int i;
    for (i=0; i<10;i++) {
        iList.Add(li,&i);
    }
    print_list(li);
    iList.Reverse(li);
    print_list(li);
}
OUTPUT
 0 1 2 3 4 5 6 7 8 9
 9 8 7 6 5 4 3 2 1 0

    int (*RotateRight)(List *src,size_t n);

    int (*RotateLeft)(List *src,size_t n);

int (*Save)(const List *l, FILE *stream,SaveFunction SaveFn, void *arg);

int (*Select)(List *l,Mask *m);

#include "containers.h"
static void printList(List *v)
{
    int i,*pi;

    for (i=0; i<iList.Size(v);i++) {
        pi = iList.GetElement(v,i);
        printf("%2d ",*pi);
    }
    printf("\n");
}

int main(void)
{
    List * vInt = iList.Create(sizeof(int));
    int i;
    Mask *m;

    for (i=1;i<=24;i++)
        iList.Add(vInt,&i);
    m = iMask.Create(24);
    printf("Original list: \n");
    printList(vInt);

    for (i=0;i<24;i++) {
        iMask.Set(m,i,i&1);
        printf("%2d ",i&1);
    }
    printf("\nSelect of the list:\n");

    iList.Select(vInt,m);
    printList(vInt);

    iList.Finalize(vInt);
    iMask.Finalize(m);
}
OUTPUT:
Original list: 
 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 
 0  1  0  1  0  1  0  1  0  1  0  1  0  1  0  1  0  1  0  1  0  1  0  1 
Select of the list:
 2  4  6  8 10 12 14 16 18 20 22 24 

List *(*SelectCopy)(const List *l,const Mask *m);

#include "containers.h"
static void printList(List *v)
{
        int i,*pi;

        for (i=0; i<iList.Size(v);i++) {
                pi = iList.GetElement(v,i);
                printf("%2d ",*pi);
        }
        printf("\n");
}

int main(void)
{
        List * vInt = iList.Create(sizeof(int));
        List *copy;
        int i;
        Mask *m;

        for (i=1;i<=24;i++)
                iList.Add(vInt,&i);
        m = iMask.Create(24);
        printf("Original list: \n");
        printList(vInt);

        for (i=0;i<24;i++) {
                iMask.Set(m,i,!(i&1));
                printf("%2d ",!(i&1));
        }
        printf("\nSelect of the list:\n");

        copy = iList.SelectCopy(vInt,m);
        printList(copy);

        iList.Finalize(vInt);
        iList.Finalize(copy);
        iMask.Finalize(m);
}
OUTPUT
Original list: 
 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 
 1  0  1  0  1  0  1  0  1  0  1  0  1  0  1  0  1  0  1  0  1  0  1  0 
Select of the list:
 1  3  5  7  9 11 13 15 17 19 21 23 

CompareFunction (*SetCompareFunction)(List l,CompareFunction f);

ErrorFunction fn,newfn;
    List *list;
    fn = iList.SetCompareFunction(list,newfn);

    DestructorFunction SetDestructor(List *l,DestructorFunction fn);

int (*SetElementData)(List *l, ListElement *le,void *data);

    ErrorFunction (*SetErrorFunction)(List *L,ErrorFunction); 

    size_t (*Size)(const List *l);

List *li;
    size_t bytes = iList.Size(li);

    size_t (*Sizeof)(const List *list);

#include "containers.h"
int main(void)
{
    List *l = iList.Create(sizeof(int));
    int i;

    for (i=0; i<10; i++)
        iList.Add(l,&i);
    // Queries for size of the list and for size of the list header
    printf("Size of list: %lu, sizeof list header %lu\n",
        iList.Sizeof(l),iList.Sizeof(NULL));
    // Prints the size of the data (int) and the size of a pointer
    printf("Sizeof int %lu, sizeof void * %lu\n",
        sizeof(int),sizeof(void *));
    iList.Finalize(l);
}

OUTPUT (64 bit system)
Size of list: 208, sizeof list header 88
Sizeof int 4, sizeof void * 8

    size_t (*SizeofIterator)(const List *list);

List *list;
    size_t  siz = iList.Sizeof(list);

    int (*Sort)(List *list);

List *list;
    if (iList.Sort(list) < 0) { /* Error handling */ }

    List *(*SplitAfter)(List *list, ListElement *point);

#include "containers.h"
/* This example creates a list of 16 double precision numbers
   and splits it after element 4. It prints the lists before and after
   the split, then exits
*/
static void Fprintf(List *v) // Prints a list of doubles
{
    int i;
    double *pi;

    for (i=0; i<iList.Size(v);i++) {
        pi = iList.GetElement(v,i);
        printf("%g ",*pi);
    }
    printf("\n");
}

int main(void)
{
    List *l,*newList;
    ListElement *le;
    int i;
    double d;

    l = iList.Create(sizeof(double));
    d = 1;
    for (i=0; i<16;i++) {
        iList.Add(l,&d);
        d += 1;
    }   
    printf("Original list:\n");
    Fprintf(l);
    le = iList.FirstElement(l);
    for (i=0; i<4;i++)
        le = iList.NextElement(le);
    printf("Element %g is at the split\n",*(double *)iList.ElementData(le));
    newList = iList.SplitAfter(l,le);
    printf("New list:\n");
    Fprintf(newList);
    printf("Source list\n");
    Fprintf(l);
    iList.Finalize(l);
    iList.Finalize(newList);
}

OUTPUT:
Original list:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 
Element 5 is at the split
New list:
6 7 8 9 10 11 12 13 14 15 16 
Source list
1 2 3 4 5 

    int (*UseHeap)(List *list,ContainerAllocator *m);

typedef struct tagDlistInterface {
   int (*Add)(Dlist *dl,const void *newval);
   int (*AddRange)(Dlist *l,size_t n,const void *data);
   void *(*Advance)(DlistElement **pDlistElement);
   int (*Append)(Dlist *l1,Dlist *l2);
   int (*Apply)(Dlist *L,int(Applyfn)(void *elem,void *extraArg),
        void *extraArg);
   void *(*Back)(const Dlist *l);
   int (*Clear)(Dlist *dl);
   int (*Contains)(const Dlist *dl,const void *element);
   Dlist *(*Copy)(const Dlist *dl);
   int (*CopyElement)(const Dlist *l,size_t idx,void *outbuf);
   Dlist *(*Create)(size_t elementsize);
   Dlist *(*CreateWithAllocator)(size_t,const ContainerAllocator *);
   void *(*ElementData)(DlistElement *le);
   int (*Equal)(const Dlist *l1,const Dlist *l2);
   int (*Erase)(Dlist *AL,const void *);
   int (*EraseAll)(Dlist *AL,const void *);
   int (*EraseAt)(Dlist *AL,size_t idx);
   int (*Finalize)(Dlist *AL);
   DlistElement *(*FirstElement)(Dlist *l);
   void *(*Front)(const Dlist *l);
   const ContainerAllocator *(*GetAllocator)(const Dlist *l);
   void *(*GetElement)(const Dlist *AL,size_t idx);
   size_t (*GetElementSize)(const Dlist *dl);
   unsigned (*GetFlags)(const Dlist *AL);
   Dlist *(*GetRange)(Dlist *l,size_t start,size_t end);
   int (*IndexOf)(const Dlist *AL,const void *SearchedElement,
        void *args,size_t *result);
   Dlist *(*Init)(Dlist *dlist,size_t elementsize);
   int (*InitIterator)(Dlist *,void *buf);
   Dlist *(*InitWithAllocator)(Dlist *L,size_t element_size,
          const ContainerAllocator *mm);
   Dlist *(*InitializeWith)(size_t elementSize, size_t n,
          const void *data);
   int (*InsertAt)(Dlist *AL,size_t idx,const void *newval);
   int (*InsertIn)(Dlist *l, size_t idx,Dlist *newData);
   DlistElement *(*LastElement)(Dlist *l);
   Dlist *(*Load)(FILE *stream, ReadFunction loadFn,void *arg);
   void *(*MoveBack)(DlistElement **pDlistElement);
   Iterator *(*NewIterator)(Dlist *);
   DlistElement *(*NextElement)(DlistElement *le);
   int (*PopBack)(Dlist *AL,void *result);
   int (*PopFront)(Dlist *AL,void *result);
   DlistElement *(*PreviousElement)(DlistElement *le);
   int (*PushBack)(Dlist *AL,const void *str);
   int (*PushFront)(Dlist *AL,const void *str);
   int (*RemoveRange)(Dlist *l,size_t start, size_t end);
   int (*ReplaceAt)(Dlist *AL,size_t idx,const void *newval);
   int (*Reverse)(Dlist *l);
   int (*RotateLeft)(Dlist *l, size_t n);
   int (*RotateRight)(Dlist *l,size_t n);
   int (*Save)(const Dlist *L,FILE *stream, SaveFunction saveFn,
        void *arg);
   int (*Select)(Dlist *src,const Mask *m);
   Dlist *(*SelectCopy)(const Dlist *src,const Mask *m);
   CompareFunction (*SetCompareFunction)(Dlist *l,CompareFunction fn);
   DestructorFunction (*SetDestructor)(Dlist *v,
                      DestructorFunction fn);
   int (*SetElementData)(Dlist *l, DlistElement *le,void *data);
   ErrorFunction (*SetErrorFunction)(Dlist *L,ErrorFunction);
   unsigned (*SetFlags)(Dlist *AL,unsigned flags);
   size_t (*Size)(const Dlist *dl);
   size_t (*Sizeof)(const Dlist *dl);
   size_t (*SizeofIterator)(const Dlist *);
   DlistElement *(*Skip)(DlistElement *l,size_t n);
   int (*Sort)(Dlist *l);
   Dlist *(*Splice)(Dlist *list,void *pos,Dlist *toInsert,
          int direction);
   Dlist *(*SplitAfter)(Dlist *l, DlistElement *pt);
   int (*UseHeap)(Dlist *L,const ContainerAllocator *m);
   int (*deleteIterator)(Iterator *);
} DlistInterface;

void *(*MoveBack)(ListElement **ppElement);

    int (*PopBack)(List *L,void *result);

double d;
    int r = iList.PopBack(L,&d);
    if (r==0)
        printf("List empty\n");
    else if (r < 0) {
        printf("Error %d\n",r);
    else    printf("OK, popped value %g\n",d);

DlistElement *(*PreviousElement)(DlistElement *le);

    int (*PushBack)(List *L,void *element);

double d = 2.3;
    if (iList.PushBack(list,&d) < 0)
        printf("Error\n");

Synopsis:
Dlist *(*Splice)(Dlist *list, void *Pos, Dlist *toInsert,int direction);

typedef struct tagVectorInterface {
   int (*Add)(Vector *AL,const void *newval);
   int (*AddRange)(Vector *AL,size_t n,const void *newvalues);
   int (*Append)(Vector *AL1, Vector *AL2);
   int (*Apply)(Vector *AL,int (*Applyfn)(void *element,void * arg),
        void *arg);
   void *(*Back)(const Vector *AL);
   int (*Clear)(Vector *AL);
   Mask *(*CompareEqual)(const Vector *left,const Vector *right,
         Mask *m);
   Mask *(*CompareEqualScalar)(const Vector *left, const void *right,
         Mask *m);
   int (*Contains)(const Vector *AL,const void *element,
        void *ExtraArgs);
   Vector *(*Copy)(const Vector *AL);
   int (*CopyElement)(const Vector *AL,size_t idx,void *outbuf);
   void **(*CopyTo)(const Vector *AL);
   Vector *(*Create)(size_t elementsize,size_t startsize);
   Vector *(*CreateWithAllocator)(size_t elemsiz,size_t startsiz,
           const ContainerAllocator *mm);
   int (*Equal)(const Vector *first,const Vector *second);
   int (*Erase)(Vector *AL,const void *);
   int (*EraseAll)(Vector *AL,const void *);
   int (*EraseAt)(Vector *AL,size_t idx);
   int (*Finalize)(Vector *AL);
   void *(*Front)(const Vector *AL);
   const ContainerAllocator *(*GetAllocator)(const Vector *AL);
   size_t (*GetCapacity)(const Vector *AL);
   void **(*GetData)(const Vector *AL);
   void *(*GetElement)(const Vector *AL,size_t idx);
   size_t (*GetElementSize)(const Vector *AL);
   unsigned (*GetFlags)(const Vector *AL);
   Vector *(*GetRange)(const Vector *AL, size_t start, size_t end);
   Vector *(*IndexIn)(Vector *SC,Vector *AL);
   int (*IndexOf)(const Vector *AL,const void *data,void *ExtraArgs,
        size_t *result);
   Vector *(*Init)(Vector *r,size_t elementsize,size_t startsize);
   int (*InitIterator)(Vector *V,void *buf);
   Vector *(*InitializeWith)(size_t elementSize, size_t n,
           const void *Data);
   int (*Insert)(Vector *AL,void *);
   int (*InsertAt)(Vector *AL,size_t idx,void *newval);
   int (*InsertIn)(Vector *AL, size_t idx,Vector *newData);
   Vector *(*Load)(FILE *stream, ReadFunction readFn,void *arg);
   int (*Mismatch)(Vector *a1,Vector *a2,size_t *mismatch);
   Iterator *(*NewIterator)(Vector *AL);
   int (*PopBack)(Vector *AL,void *result);
   int (*PushBack)(Vector *AL,const void *str);
   int (*RemoveRange)(Vector *SC,size_t start,size_t end);
   int (*ReplaceAt)(Vector *AL,size_t idx,void *newval);
   int (*Reserve)(Vector *src,size_t newCapacity);
   int (*Resize)(Vector *AL,size_t newSize);
   int (*Reverse)(Vector *AL);
   int (*RotateLeft)(Vector *V,size_t n);
   int (*RotateRight)(Vector *V,size_t n);
   int (*Save)(const Vector *AL,FILE *stream, SaveFunction saveFn,
        void *arg);
   int (*SearchWithKey)(Vector *vec,size_t startByte,size_t sizeKey,
        size_t startIndex,void *item,size_t *result);
   int (*Select)(Vector *src,const Mask *m);
   Vector *(*SelectCopy)(Vector *src,Mask *m);
   int (*SetCapacity)(Vector *AL,size_t newCapacity);
   CompareFunction (*SetCompareFunction)(Vector *l,
                   CompareFunction fn);
   DestructorFunction (*SetDestructor)(Vector *v,
                      DestructorFunction fn);
   ErrorFunction (*SetErrorFunction)(Vector *AL,ErrorFunction);
   unsigned (*SetFlags)(Vector *AL,unsigned flags);
   size_t (*Size)(const Vector *AL);
   size_t (*Sizeof)(const Vector *AL);
   size_t (*SizeofIterator)(const Vector *);
   int (*Sort)(Vector *AL);
   int (*deleteIterator)(Iterator *);
} VectorInterface;

    int (*Add)(Vector *AL,void *data);
    int (*Add)(TYPEVector, TYPE data);

Vector *AL = iVector.Create(sizeof(double));
    double data = 4.5;
    int result = iVector.Add(AL,&data);
    if (result < 0) { /* Error handling */ }

    // Template version
    #include "doubleVector.h"
    doubleVector *AL = idoubleVector.Create();
    int result = idoubleVector.Add(AL,4.5);
    if (result < 0) { /* Error handling */ }

    int (*Add)(Vector *AL,size_t n, void *data);
    int (*Add)(TYPEVector *AL,size_t n, TYPE *data);

Vector *AL;
    double data[] = {4.5, 4.6, 4.7 };
    AL = iVector.Create(sizeof(double),5);
    int result = iVector.Add(AL,3, data);
    if (result < 0) { /* Error handling */ }
    // Template version
    #include "doubleVector.h"
    doubleVector *AL = idoubleVector.Create(5);
    double data[] = {4.5, 4.6, 4.7 };
    int result = idoubleVector.Add(AL,3, data);
    if (result < 0) { /* Error handling */ }

  int (*Append)(Vector *AL1, Vector *AL2);

    int (*Apply)(Vector l,int (Applyfn)(void *,void *),void *arg);
    int (*Apply)(TYPEVector l,int (Applyfn)(TYPE,void *),void *arg);

static int Callback(void *pelement,void *pResult)
    {
        double *p = pelement;
        double *result = pResult;
        *result += *p;
        return 1;
    }
    double AddVector(Vector *l) {
        double sum = 0;
        Vector *alist = iVector.Create(sizeof(double),2);
        double d = 2;
        iVector.Add(alist,&d);
        d = 3;
        iVector.Add(alist,&d);
        iList.Apply(alist,Callback,&sum);
        // Here sum should be 5.
        return sum;
    }
    // ------------------------------Template version
    static int Callback(double element,void *pResult)
    {
        double *result = pResult;
        *result += element;
        return 1;
    }
    double AddVector(Vector *l) {
        double sum = 0;
        doubleVector *alist = idoubleVector.Create(2);
        idoubleVector.Add(alist,2);
        idoubleVector.Add(alist,3);
        idoubleList.Apply(alist,Callback,&sum);
        // Here sum should be 5.
        return sum;
    }

void *(*Back)(const Vector *v);
TYPE  (*Back)(const TYPEVector *v);

    int (*Clear)(Vector *l);

Vector *Al;
    int m = iVector.Clear(Al);

Mask *(*CompareEqual)(ValArray *left,ValArray *right,
                       Mask bitarray);

Mask[i] = (left[i] == right[i])

Mask *(*CompareEqual)(const Vector *left,const void *right,
                       Mask *bitarray);

bit[i] = (left[i] == right)

    int (*Contains)(Vector *a,void *data);
    int (*Contains)(TYPEVector *a,TYPE data);

Vector *a = iVector.Create(sizeof(double),2);
    double data = 78.67;
    int r = iVector.Contains(a,&data);
    // ---------------------------Template version
    doubleVector *a = iVector.Create(2);
    int r = iVector.Contains(a,78.67);

    Vector *(*Copy)(Vector *A);

Vector *newVector,*OldVector;
    newVector = iVector.Copy(OldVector);

    Vector *(*Copy)(const Vector *A,size_t idx,void *result);

Vector *V;
    char buffer[16];
    newVector = iVector.CopyElement(V,3,buffer);

void **(*CopyTo)(Vector *AL);

    int deleteIterator(Iterator *it);

    Vector *(*Create)(size_t element_size,size_t startsize);
    TYPEVector *(*Create)(size_t startsize);

Vector *DArray = iVector.Create(sizeof(double),100);

Vector *(*CreateWithAllocator)(size_t elementsize,
                    size_t startsize,ContainerAllocator *allocator);

    int (*Equal)(Vector *first,Vector *second);

    int (*Erase)(Vector *AL,void *data);
    int (*Erase)(TYPEVector *AL,TYPE data);

double d = 2.3;
    Vector *AL;
    int r = iVector.Erase(AL,&d);
    if (r > 0)
        printf("2.3 erased|n");
    else if (r == 0)
        printf("No element with value 2.3 present\n");
    else
        printf("error code %d\n",r);

    int (*EraseAll)(Vector *v,const void *data);
    int (*EraseAll)(TYPEVector *v,const TYPE data);    

    int (*EraseAt)(Vector *AL,size_t idx);

Vector *AL;
    int r = iVector.EraseAt(AL,2);
    if (r > 0)
        printf("Element at position 2 erased\n");
    else
        printf("Error code %d\n",r);

    int (*Finalize)(Vector *AL);

Vector *AL;
    int r = iVector.Finalize(AL);
    if (r < 0) { /* error handling */ }

void *(*Front)(const Vector *v);
TYPE  (*Front)(const TYPEVector *v);

    size_t (*GetCapacity)(const Vector *AL);

    size_t (*GetElementSize)(const Vector *AL);

Vector *AL;
    size_t siz = iVector.GetElementSize(AL);

void **(*GetData)(const Vector *AL);

    void *(*GetElement)(Vector *AL,size_t idx);
    TYPE *(*GetElement)(TYPEVector *AL,size_t idx);

Vector *AL;
    double *d = iVector.GetElement(AL,3);
    if (d == NULL) { /* Error handling */ }

    unsigned (*GetFlags)(Vector *AL);
    unsigned (*SetFlags)(Vector *AL,unsigned newFlags);

    Vector *(*GetRange)(Vector *AL,size_t start,size_t end);

Vector *AL;
    Vector *range = iVector.GetRange(AL,2,5);
    if (range == NULL) { /* Error handling */ }

Vector *(*IndexIn)(Vector *SC,Vector *AL);

int (*IndexOf)(Vector *l,void *data,void *ExtraArgs,size_t *result);
int (*IndexOf)(TYPEVector *l,TYPE data,void *ExtraArgs,size_t *result);

Vector *AL;
    double data = 6.8;
    size_t pos;
    int r = iVector.IndexOf(AL,&data,NULL,&pos);
    if (r == CONTAINER_ERROR_NOTFOUND)
        printf("Not found\n");

    int (*InsertAt)(Vector *AL,size_t idx,void *newData);
    int (*InsertAt)(TYPEVector *AL,size_t idx,TYPE newData);

double d = 2.7;
    Vector *AL = iVector.Create(sizeof(double),3);
    int r = iVector.InsertAt(AL,2,&d);
    if (r < 0) { /* Error handling */ }
    else { /* Normal processing */  }
    // --------------------------Template version
    doubleVector *AL = idoubleVector.Create(3);
    int r = idoubleVector.InsertAt(AL,2,2.7);
    if (r < 0) { /* Error handling */ }
    else { /* Normal processing */  }

    int (*InsertIn)(Vector *Destination, size_t pos, Vector *src);

#include <containers.h>
static void PrintVector(Vector *AL)
{
    size_t i;
    printf("Count %ld, Capacity %ld\n",(long)iVector.Size(AL),
                                  (long)iVector.GetCapacity(AL));
    for (i=0; i<iVector.Size(AL);i++) {
        printf("%g ",*(double *)iVector.GetElement(AL,i));
    }
    printf("\n");
}

static void FillVector(Vector * AL,int start)
{
    size_t i;

    for (i=0; i<10;i++) {
        double d = i+start;
        iVector.Add(AL,&d);
    }
}

int main(void)
{
    Vector *AL = iVector.Create(sizeof(double),10);
    Vector *AL1 =iVector.Create(sizeof(double),10);
    FillVector(AL,0);
    FillVector(AL1,100);
    iVector.InsertIn(AL,5,AL1);
    PrintVector(AL);
    return 0;
}
OUTPUT:
Count 20, Capacity 20
0 1 2 3 4 100 101 102 103 104 105 106 107 108 109 5 6 7 8 9
---------------------------------------------Template version
#include <containers.h>
#include "doublevector.h"
static void PrintVector(doubleVector *AL)
{
    size_t i;
    printf("Count %ld, Capacity %ld\n",(long)iVector.Size(AL),
                                  (long)iVector.GetCapacity(AL));
    for (i=0; i<iVector.Size(AL);i++) {
        printf("%g ",idoubleVector.GetElement(AL,i));
    }
    printf("\n");
}

static void FillVector(Vector * AL,int start)
{
    size_t i;

    for (i=0; i<10;i++) {
        idoubleVector.Add(AL,i+start);
    }
}

int main(void)
{
    Vector *AL = idoubleVector.Create(10);
    Vector *AL1 =idoubleVector.Create(10);
    FillVector(AL,0);
    FillVector(AL1,100);
    iVector.InsertIn(AL,5,AL1);
    PrintVector(AL);
    return 0;
}
OUTPUT:
Count 20, Capacity 20
0 1 2 3 4 100 101 102 103 104 105 106 107 108 109 5 6 7 8 9

   Vector *(*Load)(FILE *stream,ReadFunction readFn,void *arg);

    Iterator *(*NewIterator)(Vector *AL);

Vector *AL;
    Iterator *it = iVector.NewIterator(AL);
    double *d;
    for (d=it->GetFirst(it); d != NULL; d = it->GetNext(it)) {
        double val = *d;
        // Work with the value here
    }
    iVector.deleteIterator(it);

int (*Mismatch)(const Vector *a1,const Vector *a2,
                                         size_t *mismatch);

    int (*PopBack)(Vector *AL,void *result);
    int (*PopBack)(TYPEVector *AL,TYPE *result);

int (*RemoveRange)(Vector *SC,size_t start,size_t end);

    int (*ReplaceAt)(Vector *AL,size_t idx,void *newData);
    int (*ReplaceAt)(TYPEVector *AL,size_t idx,TYPE newData);

Vector *AL = iVector.Create(sizeof(double),2);
    double d = 6.7;
    int r = iVector.ReplaceAt(AL,2,&d);
    if (r < 0) { /* Error handling */ }
    // --------------------------------Template version
    doubleVector *AL = idoubleVector.Create(2);
    int r = idoubleVector.ReplaceAt(AL,2,6.7);
    if (r < 0) { /* Error handling */ }

int (*Reserve)(Vector *AL, size_t newSize);

int (*Resize)(Vector *AL, size_t newSize);

iVector.Resize(vec,iVector.Size(vec));

int (*Reverse)(Vector *AL);

    int (*RotateRight)(Vector *src,size_t n);

    int (*RotateLeft)(Vector *src,size_t n);

int (*Save)(const Vector *AL, FILE *out, SaveFunction Fn, void *arg);

Vector *AL;
    FILE *outFile;
    if (iVector.Save(AL,outFile,NULL,NULL) < 0) { 
        /* Handle error here */
    }

int (*SearchWithKey)(Vector *vec,size_t startByte,size_t sizeKey,
                     size_t startIndex,void *item, size_t*result);

int (*Select)(Vector *v,Mask *m);

Vector *(*SelectCopy)(Vector *v,Mask *m);

int (*SetCapacity)(Vector *AL,size_t newCapacity);

CompareFunction (*SetCompareFunction)(Vector *AL,
                                         CompareFunction f);

ErrorFunction fn,newfn;
    Vector *AL;
    fn = iVector.SetErrorFunction(AL,newfn);

DestructorFunction (*SetDestructor)(Vector *v,DestructorFunction fn);

    ErrorFunction (*SetErrorFunction)(Vector *V,ErrorFunction); 

    size_t (*Size)(const Vector *AL);

Vector *AL;
    size_t elem = iVector.Size(AL);

    size_t (*Sizeof)(Vector *AL);

Vector *AL;
    size_t  size = iVector.Sizeof(AL);

    int Sort(Vector *AL);

Vector *AL;
    if (iVector.Sort(AL) < 0) { /* Error handling */ }

typedef struct tagBitStringInterface {
   int (*Add)(BitString *BitStr,int);
   int (*AddRange)(BitString *b, size_t bitSize, void *data);
   BitString *(*And)(BitString *bsl,BitString *bsr);
   int (*AndAssign)(BitString *bsl,BitString *bsr);
   int (*Append)(BitString *left,BitString *right);
   int (*Apply)(BitString *BitStr,int (*Applyfn)(int ,void * arg),
        void *arg);
   uintmax_t (*BitBlockCount)(BitString *b);
   int (*BitLeftShift)(BitString *bs,size_t shift);
   int (*BitRightShift)(BitString *bs,size_t shift);
   int (*Clear)(BitString *BitStr);
   int (*Contains)(BitString *BitStr,BitString *str,void *ExtraArgs);
   BitString *(*Copy)(BitString *);
   int (*CopyBits)(BitString *bitstr,void *buf);
   BitString *(*Create)(size_t bitlen);
   BitString *(*CreateWithAllocator)(size_t startsiz,
              const ContainerAllocator *mm);
   int (*Equal)(BitString *bsl,BitString *bsr);
   int (*Erase)(BitString *BitStr,int bit);
   int (*EraseAt)(BitString *BitStr,size_t idx);
   int (*Finalize)(BitString *BitStr);
   const ContainerAllocator *(*GetAllocator)(const BitString *b);
   size_t (*GetCapacity)(BitString *BitStr);
   unsigned char *(*GetData)(BitString *BitStr);
   int (*GetElement)(BitString *BitStr,size_t idx);
   size_t (*GetElementSize)(BitString *b);
   unsigned (*GetFlags)(BitString *BitStr); 
   BitString *(*GetRange)(BitString *b,size_t start,size_t end);
   int (*IndexOf)(BitString *BitStr,int SearchedBit,void *ExtraArgs,
        size_t *result);
   BitString *(*Init)(BitString *BitStr,size_t bitlen);
   int (*InitIterator)(BitString *,void *);
   BitString *(*InitializeWith)(size_t size,void *data);
   size_t (*Insert)(BitString *BitStr,int bit);
   size_t (*InsertAt)(BitString *BitStr,size_t idx,int bit);
   int (*LessEqual)(BitString *bsl,BitString *bsr);
   BitString *(*Load)(FILE *stream, ReadFunction saveFn,void *arg);
   int (*Memset)(BitString *,size_t start,size_t stop,int newval);
   Iterator *(*NewIterator)(BitString *);
   BitString *(*Not)(BitString *bsl);
   int (*NotAssign)(BitString *bsl);
   BitString *(*Or)(BitString *left,BitString *right);
   int (*OrAssign)(BitString *bsl,BitString *bsr);
   int (*PopBack)(BitString *BitStr);
   uintmax_t (*PopulationCount)(BitString *b);
   size_t (*Print)(BitString *b,size_t bufsiz,unsigned char *out);
   int (*PushBack)(BitString *BitStr,int val);
   int (*ReplaceAt)(BitString *BitStr,size_t idx,int newval);
   BitString *(*Reverse)(BitString *b);
   int (*Save)(const BitString *bitstr,FILE *stream,
         SaveFunction saveFn,void *arg);
   int (*SetCapacity)(BitString *BitStr,size_t newCapacity);
   int (*SetElement)(BitString *bs,size_t position,int b);
   ErrorFunction *(*SetErrorFunction)(BitString *,ErrorFunction fn);
   unsigned (*SetFlags)(BitString *BitStr,unsigned flags);
   size_t (*Size)(BitString *BitStr); 
   size_t (*Sizeof)(BitString *b);
   BitString *(*StringToBitString)(unsigned char *);
   BitString *(*Xor)(BitString *bsl,BitString *bsr);
   int (*XorAssign)(BitString *bsl,BitString *bsr);
   int (*deleteIterator)(Iterator *);
} BitStringInterface;

    int (*Add)(BitString *BitStr,int);

#include "containers.h"
int main(int argc,char *argv[])
{
    size_t i;
    BitString *b;
    unsigned char buf[512];

    b = iBitString.Create(32);
    for (i=0; i<32;i++)
        iBitString.Add(b,i&1);
    iBitString.Print(b,sizeof(buf),buf);
    printf("%s\n",buf);
    return 0;
}
OUTPUT:
1010 1010  1010 1010  1010 1010  1010 1010

    BitString *(*And)(BitString *left,BitString *right);

#include "containers.h"
int main(int argc,char *argv[])
{
    size_t i;
    BitString *b,*c,*d;
    unsigned char buf[512];

    b = iBitString.Create(32);
    c = iBitString.Create(32);
    for (i=0; i<32;i++) {
        iBitString.Add(b,i&1);
        iBitString.Add(c,i<16);
    }
    iBitString.Print(b,sizeof(buf),buf);
    printf("%s\n",buf);
    printf(" AND\n");
    iBitString.Print(c,sizeof(buf),buf);
    printf("%s\n",buf);
    printf("=\n");
    d = iBitString.And(b,c);
    iBitString.Print(d,sizeof(buf),buf);
    printf("%s\n",buf);
    return 0;
}
OUTPUT:
1010 1010  1010 1010  1010 1010  1010 1010
 AND
0000 0000  0000 0000  1111 1111  1111 1111
=
0000 0000  0000 0000  1010 1010  1010 1010

    int (*AndAssign)(BitString *left,BitString *right);

#include "containers.h"
int main(int argc,char *argv[])
{
    size_t i;
    BitString *b,*c;
    unsigned char buf[512];

    b = iBitString.Create(32);
    c = iBitString.Create(32);
    for (i=0; i<32;i++) {
        iBitString.Add(b,i&1);
        iBitString.Add(c,i<16);
    }
    iBitString.Print(b,sizeof(buf),buf);
    printf("%s\n",buf);
    printf(" AND\n");
    iBitString.Print(c,sizeof(buf),buf);
    printf("%s\n",buf);
    printf("=\n");
    iBitString.AndAssign(b,c);
    iBitString.Print(b,sizeof(buf),buf);
    printf("%s\n",buf);
    return 0;
}
OUTPUT:
1010 1010  1010 1010  1010 1010  1010 1010
 AND
0000 0000  0000 0000  1111 1111  1111 1111
=
0000 0000  0000 0000  1010 1010  1010 1010

uintmax_t  (*BitBlockCount)(BitString *b);

#include "containers.h"
int main(int argc,char *argv[])
{
    size_t i;
    BitString *b,*c,*d;
    unsigned char buf[512];

    b = iBitString.Create(32);
    c = iBitString.Create(32);
    for (i=0; i<32;i++) {
        iBitString.Add(b,i&1);
        iBitString.Add(c,i<16);
    }
    iBitString.Print(b,sizeof(buf),buf);
    printf("%s BitBlockCount=%ld\n",buf,iBitString.BitBlockCount(b));
    iBitString.Print(c,sizeof(buf),buf);
    printf("%s BitBlockCount=%ld\n",buf,iBitString.BitBlockCount(c));
    return 0;
}
OUTPUT:
1010 1010  1010 1010  1010 1010  1010 1010 BitBlockCount=16
0000 0000  0000 0000  1111 1111  1111 1111 BitBlockCount=1

    int (*CopyBits)(BitString *b, void *buffer);

    1+iBitstring.Size(bitstr)/8

   unsigned char *(*GetData)(BitString *b);

   BitString *bitstr;
   size_t bytesize;

   bytesize = 1+iBitString.GetSize(bitstr)/CHAR_BIT;

BitString *(*GetRange)(BitString *b,size_t start,size_t end);

#include "containers.h"
int main(void)
{
    char outbuf[256];
    BitString *bs = iBitString.StringToBitString("0001 1111 0000 0000");
    BitString *bs1 = iBitString.GetRange(bs,8,14);
    BitString *bs2 = iBitString.GetRange(bs,7,14);
    iBitString.Print(bs,sizeof(outbuf),outbuf);
    printf("Original:%s \n",outbuf);
    iBitString.Print(bs1,sizeof(outbuf),outbuf);
    printf("Range 8,14: %s\n",outbuf);
    iBitString.Print(bs2,sizeof(outbuf),outbuf);
    printf("Range 7,14:%s\n",outbuf);
    return 0;
}
OUTPUT:
Original:0001 1111  0000 0000 
Range 8,14: 01 1111
Range 7,14:001 1110

int (*BitLeftShift)(BitString *bs,size_t shift);

#include "containers.h"
static void Putbs(BitString *bs,char *prompt)
{
    char outbuf[256];
    iBitString.Print(bs,sizeof(outbuf),outbuf);
    printf("%s: %s\n",prompt,outbuf);
}
int main(int argc,char *argv[])
{
    char outbuf[256];
    int ls;
    if (argc < 2) {
        fprintf(stderr,"Usage: %s: amount\n",argv[0]);
        return 0;
    }
    ls = atoi(argv[1]);
    BitString *bs = iBitString.StringToBitString("0001 1111 1010 0000");
    Putbs(bs,"Original         ");
    iBitString.BitLeftShift(bs,ls);
    sprintf(outbuf,"Shifted left by %d",ls);
    Putbs(bs,outbuf);
    return 0;
}
OUTPUT:
~/ccl/test $ ./a.out 1
Original         : 0001 1111  1010 0000
Shifted left by 1: 0011 1111  0100 0000
~/ccl/test $ ./a.out 3
Original         : 0001 1111  1010 0000
Shifted left by 3: 1111 1101  0000 0000

    BitString *(*Not)(BitString *src);

    int (*NotAssign)(BitString *src);

#include "containers.h"
int main(int argc,char *argv[])
{
    size_t i;
    BitString *b;
    unsigned char buf[512];

    b = iBitString.Create(32);
    for (i=0; i<32;i++) {
        iBitString.Add(b,i<16);
    }
    iBitString.Print(b,sizeof(buf),buf);
    printf("    b = %s\n",buf);
    iBitString.NotAssign(b);
    iBitString.Print(b,sizeof(buf),buf);
    printf("NOT b = %s\n",buf);
    return 0;
}
OUTPUT:
    b = 0000 0000  0000 0000  1111 1111  1111 1111
NOT b = 1111 1111  1111 1111  0000 0000  0000 0000

    BitString *(*ObjectToBitString)(size_t size,void *p);

#include "containers.h"
/* This example changes the sign of a double precision
number by changing its sign bit */
int main(void)
{
    double d = -0.125; /* Number is negative */
    BitString *b = iBitString.ObjectToBitString(sizeof(double),&d);
    /* Now set sign to zero, making the number positive */
    iBitString.SetElement(b,63,0);
    iBitString.CopyBits(b,&d);
    printf("%g\n",d);
    return 0;
}
OUTPUT:
0.125

    BitString *(*Or)(BitString *left,BitString *right);

    int (*OrAssign)(BitString *left,BitString *right);

uintmax_t  (*PopulationCount)(BitString *b);

  size_t (*Print)(BitString *b,size_t bufsiz,unsigned char *out);

    BitString *(*Reverse)(BitString *b);

#include "containers.h"
int main(int argc,char *argv[])
{
    size_t pos;
    BitString *b,*c;
    unsigned char buf[512];

    if (argc < 2) {
        fprintf(stderr,"Usage: %s <bitstring>\n",argv[0]);
        return 1;
    }
    b = iBitString.StringToBitString(argv[1]);
    iBitString.Print(b,sizeof(buf),buf);
    printf("Reversing bits of %s\n",buf);
    c = iBitString.Reverse(b);
    iBitString.Print(c,sizeof(buf),buf);
    printf("%s\n",buf);
    return 0;
}
OUTPUT:
Reversing bits of 1111 1100  0000 1111  1111 1111
1111 1111  1111 0000  0011 1111

   int (*RemoveAt)(BitString *bitStr,size_t idx);

#include "containers.h"
int main(int argc,char *argv[])
{
    size_t pos;
    BitString *b;
    unsigned char buf[512];

    if (argc < 3) {
        fprintf(stderr,"Usage: %s bitstring pos\n",argv[0]);
        return 1;
    }
    b = iBitString.StringToBitString(argv[1]);
    pos = atoi(argv[2]);
    iBitString.Print(b,sizeof(buf),buf);
    printf("Erasing bit %d of %s\n",pos,buf);
    iBitString.EraseAt(b,pos);
    iBitString.Print(b,sizeof(buf),buf);
    printf("%s\n",buf);
    return 0;
}
OUTPUT:
Erasing bit 2 of 11  1000 1110  0011 1000
1  1100 0111  0001 1100

    int (*Set)(BitString *B,size_t start,size_t stop,bool newvalue);

    BitString *(*StringToBitString)(unsigned char *);

    BitString *(*Xor)(BitString *left,BitString *right);

    int (*XorAssign)(BitString *left,BitString *right);

typedef struct tagstrCollectionInterface {
   int (*Add)(strCollection *SC,const char *newval);
   int (*AddRange)(strCollection *s,size_t n,const char **values);
   int (*Append)(strCollection *,strCollection *);
   int (*Apply)(strCollection *SC,int (*Applyfn)(char *,void * arg),
        void *arg);
   char *(*Back)(const strCollection *str);
   struct _Vector *(*CastToArray)(const strCollection *SC);
   int (*Clear)(strCollection *SC);
   Mask *(*CompareEqual)(const strCollection *left,
          const strCollection *right,Mask *m);
   Mask *(*CompareEqualScalar)(const strCollection *left,
          const char *str,Mask *m);
   int (*Contains)(const strCollection *SC,const char *str);
   strCollection *(*Copy)(const strCollection *SC);
   char **(*CopyTo)(const strCollection *SC);
   strCollection *(*Create)(size_t startsize);
   strCollection *(*CreateFromFile)(const char *fileName);
   strCollection *(*CreateWithAllocator)(size_t startsiz,
                  const ContainerAllocator *mm);
   int (*Equal)(const strCollection *SC1,const strCollection *SC2);
   int (*Erase)(strCollection *SC,const char *);
   int (*EraseAll)(strCollection *SC,const char *);
   int (*EraseAt)(strCollection *SC,size_t idx);
   int (*Finalize)(strCollection *SC);
   size_t (*FindFirst)(const strCollection *SC,const char *text);
   size_t (*FindNext)(const strCollection *SC, const char *text,
          size_t start);
   strCollection *(*FindText)(const strCollection *SC,
                  const char *text);
   Vector *(*FindTextIndex)(const strCollection *SC,const char *text);
   Vector *(*FindTextPositions)(const strCollection *SC,
           const char *text);
   char *(*Front)(const strCollection *str);
   const ContainerAllocator *(*GetAllocator)(const strCollection *AL);
   size_t (*GetCapacity)(const strCollection *SC);
   char **(*GetData)(const strCollection *SC);
   char *(*GetElement)(const strCollection *SC,size_t idx);
   size_t (*GetElementSize)(const strCollection *SC);
   unsigned (*GetFlags)(const strCollection *SC);
   strCollection *(*GetRange)(strCollection *SC, size_t start,
                  size_t end);
   strCollection *(*IndexIn)(const strCollection *SC,
                  const Vector *AL);
   int (*IndexOf)(const strCollection *SC,const char *SearchedString,
        size_t *result);
   strCollection *(*Init)(strCollection *result,size_t startsize);
   int (*InitIterator)(strCollection *SC,void *buf);
   strCollection *(*InitWithAllocator)(strCollection *c,size_t start,
                  const ContainerAllocator *mm);
   strCollection *(*InitializeWith)(size_t n, char **data);
   int (*Insert)(strCollection *SC,char *);
   int (*InsertAt)(strCollection *SC,size_t idx,const char *newval);
   int (*InsertIn)(strCollection *source, size_t idx,
        strCollection *newData);
   strCollection *(*Load)(FILE *stream, ReadFunction readFn,
                  void *arg);
   int (*Mismatch)(const strCollection *a1,const strCollection *a2,
        size_t *mismatch);
   Iterator *(*NewIterator)(strCollection *SC);
   size_t (*PopBack)(strCollection *, char *result,size_t bufsize);
   size_t (*PopFront)(strCollection *SC,char *outbuf,size_t buflen);
   int (*PushBack)(strCollection *,const char *data);
   int (*PushFront)(strCollection *SC,char *str);
   int (*RemoveRange)(strCollection *SC,size_t start,size_t end);
   int (*ReplaceAt)(strCollection *SC,size_t idx,char *newval);
   int (*Reverse)(strCollection *SC);
   int (*Save)(const strCollection *SC,FILE *stream,
         SaveFunction saveFn,void *arg);
   int (*Select)(strCollection *src, const Mask *m);
   strCollection *(*SelectCopy)(const strCollection *src,
                  const Mask *m);
   int (*SetCapacity)(strCollection *SC,size_t newCapacity);
   StringCompareFn (*SetCompareFunction)(strCollection *SC,
                   StringCompareFn);
   DestructorFunction (*SetDestructor)(strCollection *v,
                      DestructorFunction fn);
   ErrorFunction (*SetErrorFunction)(strCollection *SC,
                 ErrorFunction fn);
   unsigned (*SetFlags)(strCollection *SC,unsigned flags);
   size_t (*Size)(const strCollection *SC);
   size_t (*Sizeof)(const strCollection *SC);
   size_t (*SizeofIterator)(const strCollection *l);
   int (*Sort)(strCollection *SC);
   int (*WriteToFile)(const strCollection *SC,const char *filename);
   int (*deleteIterator)(Iterator *);
} strCollectionInterface;

    int (*AddRange)(strCollection *SC,size_t n,
                    const ElementType *data[]);

strCollection *SC = istrCollection.Create(10);
    char *data[] = { "one","two,"three"};
    int result = istrCollection.AddRange(SC,3,data);
    if (result < 0) { /* Error handling */ }

        Vector *(*CastToArray)(const strCollection *SC);

strCollection *(*CreateFromFile)(const char *fileName);

size_t (*FindFirstText)(const strCollection *SC,
                        const ElementType *text);

Iterator *(*Find)(const strCollection *SC,const ElementType *txt,
                       size_t start);

Vector *(*FindTextPositions)(const strCollection *SC,
                             const ElementType *text);

const CHARTYPE *(*Front)(const strCollection *l);

strCollection *(*Init)(strCollection *result, size_t startsize);

strCollection *(*InitWithAllocator)(strCollection *result, 
                         size_t startsize,
                         const ContainerAllocator *allocator);

int (*InsertIn)(strCollection *dst, size_t pos, 
                const strCollection *newData);

#include <containers.h>
static void PrintStringCollection(strCollection *AL)
{
    size_t i;
    printf("Count %ld, Capacity %ld\n",
           (long)istrCollection.Size(AL),
           (long)istrCollection.GetCapacity(AL));
    for (i=0; i<istrCollection.Size(AL);i++) {
        printf("%s ",istrCollection.GetElement(AL,i));
    }
    printf("\n");
}

static void FillStringCollection(strCollection * AL,int start)
{
    size_t i;
    char buf[256];

    for (i=0; i<10;i++) {
        double d = i+start;
        sprintf(buf,"%g",d);
        istrCollection.Add(AL,buf);
    }
}
int main(void)
{
    strCollection *AL = istrCollection.Create(10);
    strCollection *AL1 =istrCollection.Create(10);
    FillStringCollection(AL,0);
    FillStringCollection(AL1,100);
    istrCollection.InsertIn(AL,5,AL1);
    PrintStringCollection(AL);
    return 0;
}

Count 20, Capacity 20
0 1 2 3 4 100 101 102 103 104 105 106 107 108 109 5 6 7 8 9

int (*Mismatch)(const strCollection *a1,
                const strCollection *a2,
                           size_t *mismatch);

#include "containers.h"
char *table[] = {"String 1", "String 2","String 3","String 4",};

int main(void)
{
    size_t idx;
    strCollection *sc = istrCollection.Create(4);
    strCollection *sc2;
    istrCollection.AddRange(sc,sizeof(table)/sizeof(table[0]),table);
    sc2 = istrCollection.Copy(sc);
    istrCollection.ReplaceAt(sc,2,"String456");
    istrCollection.Mismatch(sc,sc2,&idx);
    printf("String collections differ at position %d\n",idx);
}
OUTPUT:
String collections differ at position 2

size_t (*PopBack)(strCollection *SC,ElementType *buf,size_t buflen);

int (*RemoveRange)(strCollection *SC,size_t start,size_t end);

StringCompareFn (*SetCompareFunction)(strCollection *SC,
                  StringCompareFn StrCmp);

typedef int (*StringCompareFn)(const void **s1,
                               const void **s2,CompareInfo *info);

int (*WriteToFile)(const strCollection *SC,const char *fileName);

typedef struct tagDictionaryInterface {
   int (*Add)(Dictionary *Dict,const char *key,const void *Data);
   int (*Apply)(Dictionary *Dict,int (*Applyfn)(const char *Key,
   Vector *(*CastToArray)(const Dictionary *);
   int (*Clear)(Dictionary *Dict);
   int (*Contains)(const Dictionary *dict,const char *key);
   Dictionary *(*Copy)(const Dictionary *dict);
   int (*CopyElement)(const Dictionary *Dict,const char *Key,
        void *outbuf);
   Dictionary *(*Create)(size_t ElementSize,size_t hint);
   Dictionary *(*CreateWithAllocator)(size_t elementsize,size_t hint,
               const ContainerAllocator *mm);
   int (*Equal)(const Dictionary *d1,const Dictionary *d2);
   int (*Erase)(Dictionary *Dict,const char *);
   int (*Finalize)(Dictionary *Dict);
   const ContainerAllocator *(*GetAllocator)(const Dictionary *Dict);
   void *(*GetElement)(const Dictionary *Dict,const char *Key);
   size_t (*GetElementSize)(const Dictionary *d);
   unsigned (*GetFlags)(const Dictionary *Dict);
   strCollection *(*GetKeys)(const Dictionary *Dict);
   double (*GetLoadFactor)(Dictionary *d);
   Dictionary *(*Init)(Dictionary *dict,size_t ElementSize,
               size_t hint);
   int (*InitIterator)(Dictionary *dict,void *buf);
   Dictionary *(*InitWithAllocator)(Dictionary *D,size_t elemsize,
               size_t hint,const ContainerAllocator *mm);
   Dictionary *(*InitializeWith)(size_t elementSize,size_t n,
                const char **Keys,const void *Values);
   int (*Insert)(Dictionary *Dict,const char *key,const void *Data);
   int (*InsertIn)(Dictionary *dst,Dictionary *src);
   Dictionary * (*Load)(FILE *stream, ReadFunction readFn, void *arg);
   Iterator *(*NewIterator)(Dictionary *dict);
   int (*Replace)(Dictionary *dict,const char *Key,const void *Data);
   int (*Save)(const Dictionary *Dict,FILE *stream,
         SaveFunction saveFn,void *arg);
   DestructorFunction (*SetDestructor)(Dictionary *v,
                      DestructorFunction fn);
   ErrorFunction (*SetErrorFunction)(Dictionary *Dict,
                 ErrorFunction fn);
   unsigned (*SetFlags)(Dictionary *Dict,unsigned flags);
   HashFunction (*SetHashFunction)(Dictionary *d,HashFunction newFn);
   size_t (*Size)(const Dictionary *Dict);
   size_t (*Sizeof)(const Dictionary *dict);
   size_t (*SizeofIterator)(const Dictionary *);
   int (*deleteIterator)(Iterator *);
} DictionaryInterface;

typedef struct tagWDictionaryInterface {
   int (*Add)(WDictionary *Dict,const wchar_t *key,const void *Data);
   int (*Apply)(WDictionary *Dict,int (*Applyfn)(const wchar_t *Key,
   Vector *(*CastToArray)(const WDictionary *);
   int (*Clear)(WDictionary *Dict);
   int (*Contains)(const WDictionary *dict,const wchar_t *key);
   WDictionary *(*Copy)(const WDictionary *dict);
   int (*CopyElement)(const WDictionary *Dict,const wchar_t *Key,
        void *outbuf);
   WDictionary *(*Create)(size_t ElementSize,size_t hint);
   WDictionary *(*CreateWithAllocator)(size_t elementsize,size_t hint,
                const ContainerAllocator *mm);
   int (*Equal)(const WDictionary *d1,const WDictionary *d2);
   int (*Erase)(WDictionary *Dict,const wchar_t *);
   int (*Finalize)(WDictionary *Dict);
   const ContainerAllocator *(*GetAllocator)(const WDictionary *Dict);
   void *(*GetElement)(const WDictionary *Dict,const wchar_t *Key);
   size_t (*GetElementSize)(const WDictionary *d);
   unsigned (*GetFlags)(const WDictionary *Dict);
   WstrCollection *(*GetKeys)(const WDictionary *Dict);
   double (*GetLoadFactor)(WDictionary *d);
   WDictionary *(*Init)(WDictionary *dict,size_t ElementSize,
                size_t hint);
   int (*InitIterator)(WDictionary *dict,void *buf);
   WDictionary *(*InitWithAllocator)(WDictionary *D,size_t elemsize,
                size_t hint,const ContainerAllocator *mm);
   WDictionary *(*InitializeWith)(size_t elementSize,size_t n,
                 const wchar_t **Keys,const void *Values);
   int (*Insert)(WDictionary *Dict,const wchar_t *key,
        const void *Data);
   int (*InsertIn)(WDictionary *dst,WDictionary *src);
   WDictionary * (*Load)(FILE *stream, ReadFunction readFn,
                  void *arg);
   Iterator *(*NewIterator)(WDictionary *dict);
   int (*Replace)(WDictionary *dict,const wchar_t *Key,
        const void *Data);
   int (*Save)(const WDictionary *Dict,FILE *stream,
         SaveFunction saveFn,void *arg);
   DestructorFunction (*SetDestructor)(WDictionary *v,
                      DestructorFunction fn);
   ErrorFunction (*SetErrorFunction)(WDictionary *Dict,
                 ErrorFunction fn);
   unsigned (*SetFlags)(WDictionary *Dict,unsigned flags);
   WHashFunction (*SetHashFunction)(WDictionary *d,
                 WHashFunction newFn);
   size_t (*Size)(const WDictionary *Dict);
   size_t (*Sizeof)(const WDictionary *dict);
   size_t (*SizeofIterator)(const WDictionary *);
   int (*deleteIterator)(Iterator *);
} WDictionaryInterface;

    int (*Add)(Dictionary *Dict,char *key,const void *data);

Dictionary *dict;
    double data = 4.5;
    int result = iDictionary.Add(dict,"Interest rate",&data);
    if (result < 0) { /* Error handling */ }

    int (*Apply)(Dictionary *Dict,
                  int (Applyfn)(const char *key,
                                void *data,
                                void *extraArg),
                  void *extraArg);

static int print(const char *key,
                      void *pElement,
                      void *pResult)
    {
        double *p = pElement;
        printf("%s: %g\n",key,*p);
        return 1;
    }
    int main(void) {
        Dictionary *dict = iDictionary.Create(sizeof(double),5);
        double d = 2;
        iDictionary.Add(dict,"First item",&d);
        d = 3;
        iDictionary.Add(dict,"Second item",&d);
        iDictionary.Apply(dict,print,NULL);
        return 0;
    }

First item: 2
Second item: 3

Vector *(*CastToArray)(Dictionary *);

    int (*Clear)(Dictionary *dict);

Dictionary *Dict;
    int m = iDictionary.Clear(Dict);

    int (*Contains)(Dictionary *Dict,const char *Key);

Dictionary *dict;
    int r = iDictionary.Contains(dict,"Item 1");

    Dictionary *(*Copy)(Dictionary *Dict);

Dictionary *newDict,*Old;
    newDict = iDictionary.Copy(Old);

    int (*CopyElement)(Dictionary *Dict,cont char *Key, void *outbuf);

Dictionary *Dict;
    int r = iDictionary.CopyElement(Dict,"Key",outbuf);
    if (r < 0) 
          ; // handle error
    else if (r == 0)
          ; nothing was copied
    else // Use outbuf data here

    Dictionary *(*Create)(size_t ElementSize,size_t hint);
    Dictionary *(*CreateWithAllocator)(size_t elementsize,size_t hint,
                                     ContainerAllocator *allocator);

    int deleteIterator(Iterator *it);

    int (*Equal)(Dictionary *d1,Dictionary *d2);

    int (*Erase)(Dictionary *Dict,const char *key);

double d = 2.3;
    Vector *AL;
    int r = iVector.Erase(AL,&d);
    if (r > 0)
        printf("2.3 erased|n");
    else if (r == 0)
        printf("No element with value 2.3 present\n");
    else
        printf("error code %d\n",r);

    int (*Finalize)(Dictionary *dict);

Dictionary *AL;
    int r = iDictionary.Finalize(AL);
    if (r < 0) { /* error handling */ }

    ContainerAllocator (*GetAllocator)(Dictionary *Dict);

    size_t (*GetElementSize)(const Dictionary *Dict);

Dictionary *Dict;
    size_t siz = iDictionary.GetElementSize(Dict);

void *(*GetElement)(Dictionary *Dict,const char *key);

Dictionary *Dict;
    double *d = iDictionary.GetElement(Dict,"Index");
    if (d == NULL) { /* Error handling */ }

unsigned (*GetFlags)(Dictionary *dict);

double (*GetLoadFactor)(Dictionary *dict);

int (*InsertIn)(Dictionary *dst,Dictionary *src);

	Dictionary *(*Init)(Dictionary *Dict,size_t elementsize,size_t hint);

Dictionary *(*InitializeWith)(size_t elemSize, size_t n, 
                         char **keys,void *Values);

    	Dictionary *(*InitWithAllocator)(Dictionary *Dict,
                        size_t elementsize, size_t hint,
                              ContainerAllocator *allocator);

int (*Insert)(Dictionary *Dict, const char *key,void *Data);

 Dictionary *(*Load)(FILE *stream,ReadFunction readFn,void *arg);

    Iterator *(*NewIterator)(Dictionary *Dict);

Dictionary *Dict;
    Iterator *it = iDictionary.NewIterator(Dict);
    double *d;
    for (d=it->GetFirst(it); d != NULL; d = it->GetNext(it)) {
        double val = *d;
        // Work with the value here
    }
    iDictionary.deleteIterator(it);

DestructorFunction SetDestructor(Dictionary *d,DestructorFunction fn);

size_t (*SetHashFunction)(Dicttionary *dict,HashFunction newFn);

    size_t (*Size)(const Dictionary *Dict);

Dictionary *Dict;
    size_t elem = iDictionary.Size(Dict);

int (*Save)(const Dictionary *D, FILE *out, SaveFunction Fn, void *arg);

Dictionary *Dict;
    FILE *outFile;
    if (iDictionary.Save(Dict,outFile,NULL,NULL) < 0) { 
        /* Handle error here */
    }

    size_t (*Sizeof)(Dictionary *Dict);

Dictionary *Dict;
    size_t  size = iDictionary.Sizeof(Dict);

ErrorFunction (*SetErrorFunction)(Dictionary *dict,ErrorFunction efn); 

    size_t (*Size)(const Dictionary *d);

Dictionary *d;
    size_t elem = iDictionary.Size(d);

typedef struct tagTreeMapInterface {
    int (*Add)(TreeMap *ST, void *Data,void *ExtraArgs); 
    int (*Apply)(TreeMap *ST,
                 int (*Applyfn)(const void *data,void *arg),
                 void *arg);
    TreeMap *(*Copy)(TreeMap *src);
    TreeMap *(*CreateWithAllocator)(size_t ElementSize,
                               ContainerAllocator *m);
    TreeMap *(*Create)(size_t ElementSize);
    unsigned (*GetFlags)(TreeMap *ST);
    int (*Clear)(TreeMap *ST); 
    int (*Contains)(TreeMap *ST,void *element,void *ExtraArgs);
    int (*deleteIterator)(Iterator *);
    int (*Erase)(TreeMap *tree, void *element,void *ExtraArgs);  
    int (*Equal)(TreeMap *t1, TreeMap *t2);
    int (*Finalize)(TreeMap *ST);  
    void *(*Find)(TreeMap *tree,void *element,void *ExtraArgs);
    size_t (*GetElementSize)(TreeMap *d);
    TreeMap *(*InitializeWith)(size_t elementSize, size_t n,
                               void *Elements);
    int (*Insert)(TreeMap *RB, const void *Data, void *ExtraArgs);
    Iterator *(*NewIterator)(TreeMap *);
    TreeMap *(*Load)(FILE *stream, ReadFunction loadFn,void *arg);
    int (*Save)(TreeMap *src,FILE *stream, 
                SaveFunction saveFn,void *arg);
    CompareFunction (*SetCompareFunction)(TreeMap *ST,
                                          CompareFunction fn);
    DestructorFunction (*SetDestructor)(TreeMap *Tree,
                                       DestructorFunction fn);
    ErrorFunction (*SetErrorFunction)(TreeMap *ST, ErrorFunction fn);
    unsigned (*SetFlags)(TreeMap *ST, unsigned flags); 
    size_t (*Sizeof)(TreeMap *ST);
    size_t (*Size)(TreeMap *ST);  
} TreeMapInterface;

typedef struct tagHashTableInterface {
   int (*Add)(HashTable *HT,const void *key,size_t klen,
        const void *Data);
   int (*Apply)(HashTable *HT,int (*Applyfn)(void *Key,size_t klen,
        void *data,void *arg),void *arg);
   int (*Clear)(HashTable *HT);
   int (*Contains)(const HashTable *ht,const void *Key,size_t klen);
   HashTable *(*Copy)(const HashTable *Orig,Pool *pool);
   HashTable *(*Create)(size_t ElementSize);
   int (*Erase)(HashTable *HT,const void *key,size_t klen);
   int (*Finalize)(HashTable *HT);
   void *(*GetElement)(const HashTable *HT,const void *Key,
         size_t klen);
   size_t (*GetElementSize)(const HashTable *HT);
   unsigned (*GetFlags)(const HashTable *HT);
   HashTable *(*Init)(HashTable *ht,size_t ElementSize);
   int (*InitIterator)(HashTable *SC,void *buf);
   HashTable *(*Load)(FILE *stream, ReadFunction readFn, void *arg);
   HashTable *(*Merge)(Pool *p, const HashTable *overlay,
         const HashTable *base, void * (*merger)(Pool *p,
         const void *key, size_t klen, const void *h1_val,
         const void *h2_val, const void *data), const void *data);
   Iterator *(*NewIterator)(HashTable *);
   HashTable *(*Overlay)(Pool *p, const HashTable *overlay,
               const HashTable *base);
   int (*Replace)(HashTable *HT,const void *key, size_t klen,
        const void *val);
   int (*Resize)(HashTable *HT,size_t newSize);
   int (*Save)(const HashTable *HT,FILE *stream, SaveFunction saveFn,
        void *arg);
   int (*Search)(HashTable *ht,int (*Comparefn)(void *rec,
         const void *key,size_t klen,const void *value), void *rec);
   DestructorFunction (*SetDestructor)(HashTable *v,
                      DestructorFunction fn);
   ErrorFunction (*SetErrorFunction)(HashTable *HT,ErrorFunction fn);
   unsigned (*SetFlags)(HashTable *HT,unsigned flags);
   GeneralHashFunction (*SetHashFunction)(HashTable *ht,
                        GeneralHashFunction hf);
   size_t (*Size)(const HashTable *HT);
   size_t (*Sizeof)(const HashTable *HT);
   size_t (*SizeofIterator)(const HashTable *ht);
   int (*deleteIterator)(Iterator *);
} HashTableInterface;

int (*Add)(HashTable *ht,
           void *key,
           size_t keyLength,
           const void *data);

HashTable *ht;
    double data = 4.5;
    int result = iHashTable.Add(ht,"Interest rate",
                                  strlen("Interest rate"),&data);
    if (result < 0) { /* Error handling */ }

    int (*Apply)(HashTable *ht,
                  int (Applyfn)(const char *key,
                                size_t keyLength,
                                void *data,
                                void *extraArg),
                  void *extraArg);

static int print(const char *key,
                      void *pElement,
                      void *pResult)
    {
        double *p = pElement;
        printf("%s: %g\n",key,*p);
        return 1;
    }
    int main(void) {
        Dictionary *dict = iDictionary.Create(sizeof(double),5);
        double d = 2;
        iDictionary.Add(dict,"First item",&d);
        d = 3;
        iDictionary.Add(dict,"Second item",&d);
        iDictionary.Apply(dict,print,NULL);
        return 0;
    }
Output should be:
First item: 2
Second item: 3

    int (*Clear)(HashTable *ht);

HashTable *ht;
    int m = iHashTable.Clear(ht);

    HashTable *(*Copy)(const HashTable *Orig,Pool *pool);

    HashTable *(*Create)(size_t ElementSize);

    int (*deleteIterator)(Iterator *);

    int (*Erase)(HashTable *HT,void *key,size_t keyLength);

void *(*GetElement)(const HashTable *H,const void *Key,size_t keyLen);

    unsigned (*GetFlags)(const HashTable *HT);

 HashTable *(*Load)(FILE *stream,ReadFunction readFn,void *arg);

    HashTable *(*Merge)(Pool *p, 
                        const HashTable *overlay, 
                        const HashTable *base,
                        void * (*merger)(Pool *p,
                                         const void *key,
                                         size_t keyLength,
                                         const void *h1_val,
                                         const void *h2_val,
                                         const void *data),
                        const void *data);

    Iterator *(*NewIterator)(HashTable *HT);

HashTable *HT;
    Iterator *it = iHashTable.NewIterator(HT);
    double *d;
    for (d=it->GetFirst(it); d != NULL; d = it->GetNext(it)) {
        double val = *d;
        // Work with the value here
    }
    iHashTable.deleteIterator(it);

    HashTable *(*Overlay)(Pool *p, 
                          const HashTable *overlay, 
                          const HashTable *base);

    int (*Resize)(HashTable *HT,size_t newSize);

    int  (*Replace)(HashTable *HT, const void *key,
                    size_t keyLength,const void *data);

int (*Save)(const HashTable *HT, FILE *out, SaveFunction Fn, void *arg);

HashTable *HT;
    FILE *outFile;
    if (iHashTable.Save(HT,outFile,NULL,NULL) < 0) { 
        /* Handle error here */
    }

ErrorFunction (*SetErrorFunction)(HashTable *HT,ErrorFunction fn); 

   size_t (*Size)(const HashTable *HT);

   size_t (*Sizeof)(const HashTable *HT);

typedef struct tagQueueInterface {
   int (*Back)(Queue *Q,void *result);
   int (*Clear)(Queue *Q);
   Queue *(*Create)(size_t elementSize);
   Queue *(*CreateWithAllocator)(size_t elementSize,
           ContainerAllocator *allocator);
   int (*Dequeue)(Queue *Q,void *result);
   int (*Enqueue)(Queue *Q, void *Element);
   int (*Finalize)(Queue *Q);
   int (*Front)(Queue *Q,void *result);
   List *(*GetData)(Queue *q);
   size_t (*Size)(Queue *Q);
   size_t (*Sizeof)(Queue *Q);
} QueueInterface;

    int   (*Front)(Queue *Q,void *result);

    int   (*Back)(Queue *Q,void *result);

List *(*GetData)(Queue *q);

iDeque.Size(deque) == 0

typedef struct tagDequeInterface {
   void (*Apply)(Deque *Q,int (*Applyfn)(void *,void * arg),
        void *arg);
   int (*Back)(Deque *d,void *outbuf);
   int (*Clear)(Deque *Q);
   size_t (*Contains)(Deque * d, void* item);
   Deque *(*Copy)(Deque *d);
   Deque *(*Create)(size_t elementSize);
   int (*Equal)(Deque *d1,Deque *d2);
   int (*Erase)(Deque * d, const void* item);
   int (*EraseAll)(Deque * d, const void* item);
   int (*Finalize)(Deque *Q);
   int (*Front)(Deque *d,void *outbuf);
   unsigned (*GetFlags)(Deque *Q);
   Deque *(*Init)(Deque *d,size_t elementSize);
   int (*InitIterator)(Deque *dc,void *buf);
   Deque *(*Load)(FILE *stream, ReadFunction readFn,void *arg);
   Iterator *(*NewIterator)(Deque *Deq);
   int (*PopBack)(Deque *d,void *outbuf);
   int (*PopFront)(Deque *d,void *outbuf);
   int (*PushBack)(Deque *Q,const void *Element);
   int (*PushFront)(Deque *Q, void *Element);
   int (*Reverse)(Deque * d);
   int (*Save)(const Deque *d,FILE *stream, SaveFunction saveFn,
        void *arg);
   DestructorFunction (*SetDestructor)(Deque *Q,
                      DestructorFunction fn);
   ErrorFunction (*SetErrorFunction)(Deque *d,ErrorFunction);
   unsigned (*SetFlags)(Deque *Q,unsigned newFlags);
   size_t (*Size)(Deque *Q);
   size_t (*Sizeof)(Deque *d);
   size_t (*SizeofIterator)(Deque *);
   int (*deleteIterator)(Iterator *);
} DequeInterface;

    void (*Apply)(Deque *d,int (Applyfn)(void *,void *),void *arg);

    int (*Back)(Deque *d,void *outbuf);

    int     (*Clear)(Deque *Q);

    size_t  (*Contains)(Deque * d, void* item);

    Deque  *(*Copy)(Deque *d);

    Deque  *(*Create)(size_t elementSize);

Deque *d = iDeque.Create(sizeof(myType));
    if (d == NULL) { /* Error handling */ }

    int (*Equal)(Deque *d1,Deque *d2);

    int (*Front)(Deque *d,void *outbuf);

    int (*Erase)(Deque * d, void* item);

    int (*Finalize)(Deque *d);

    unsigned (*GetFlags)(Deque *d);

 Deque *(*Load)(FILE *stream,ReadFunction readFn,void *arg);

    int (*PopBack)(Deque *d,void *outbuf);

    int (*PopFront)(Deque *d,void *outbuf);

    int (*PushBack)(Deque *d,void *element);

Deque *d;
    double data = 4.5;
    int result = iDeque.PushBack(d,&data);
    if (result < 0) { /* Error handling */ }

    int (*PushFront)(Deque *d,void *element);

Deque *d;
    double data = 4.5;
    int result = iDeque.PushFront(d,&data);
    if (result < 0) { /* Error handling */ }

int (*Save)(const Deque *d, FILE *out, SaveFunction Fn, void *arg);

Deque *d;
    FILE *outFile;
    if (iDeque.Save(d,outFile,NULL,NULL) < 0) { 
        /* Handle error here */
    }

CCL_PRIORITY_MIN
CCL_PRIORITY_MAX

typedef struct tagPQueueInterface {
   int (*Add)(PQueue *Q,intptr_t key,const void *Element);
   int (*Clear)(PQueue *Q);
   PQueue *(*Copy)(const PQueue *src);
   PQueue *(*Create)(size_t elementSize);
   PQueue *(*CreateWithAllocator)(size_t elementSize,
            ContainerAllocator *allocator);
   int (*Equal)(const PQueue *q1,const PQueue *q2);
   int (*Finalize)(PQueue *Q);
   intptr_t (*Front)(const PQueue *Q,void *result);
   intptr_t (*Pop)(PQueue *Q,void *result);
   int (*Push)(PQueue *Q,intptr_t key,const void *Element);
   size_t (*Size)(const PQueue *Q);
   size_t (*Sizeof)(const PQueue *Q);
   PQueue *(*Union)(PQueue *left, PQueue *right);
} PQueueInterface;

              
#include <stdlib.h>
#include "containers.h"
#define MAX_ITERATIONS 10
int main(void)
{
    char buf[20];
    PQueue *pq = iPQueue.Create(20);
    int r,i;
    for (i=0; i<MAX_ITERATIONS;i++) {
        char buf[20];
        int d = rand();
        snprintf(buf,20,"%d",d);
        r = iPQueue.Push(pq,d,buf);
        if (r < 0) break;
    }
    printf("The queue has %zu elements\n",iPQueue.Size(pq));
    printf("It uses %zu bytes. The size of the header structure is %zu\n",
            iPQueue.Sizeof(pq),iPQueue.Sizeof(NULL));
    r = iPQueue.Size(pq);
    for (i=0; i<r; i++){
        iPQueue.Pop(pq,buf);
        printf("%s ",buf);
    }
    printf("\n");
}
OUTPUT
The queue has 10 elements
It uses 968 bytes. The size of the header structure is 88
16807 101027544 282475249 470211272 984943658 1144108930 
1457850878 1458777923 1622650073 2007237709

int (*Add)(PQueue *q, intptr_t key,void *Element);

    int     (*Clear)(PQueue *Q);

    PQueue  *(*Create)(size_t elementSize);

    PQueue  *(*Copy)(PQueue *d);

    PQueue  *(*Create)(size_t elementSize);

    int (*Equal)(PQueue * q1, PQueue *q2);

    int (*Finalize)(PQueue *d);

    intptr_t (*Front)(PQueue *q,void *result);

    intptr_t (*Pop)(PQueue *d,void *outbuf);

int (*Push)(PQueue *q, intptr_t key,void *Element);

size_t (*Size)(PQueue *q);

size_t (*Sizeof)(PQueue *q);

typedef struct tagBloomFilterInterface {
    size_t (*CalculateSpace)(size_t maxfElements,double probability);
    BloomFilter *(*Create)(size_t maxElements,double probability);
    size_t (*Add)(BloomFilter *b,const void *key,size_t keylen);
    int (*Find)(BloomFilter *b,const void *key,size_t keylen);
    int (*Clear)(BloomFilter *b);
    int (*Finalize)(BloomFilter *b);
} BloomFilterInterface;

    size_t (*CalculateSpace)(size_t maxElements,double probability);

    BloomFilter *(*Create)(size_t maxElements,double probability);

    size_t (*Add)(BloomFilter *b,const void *key,size_t keylen);

    int (*Find)(BloomFilter *b,const void *key,size_t keylen);

    int (*Clear)(BloomFilter *b);

    int (*Finalize)(BloomFilter *b);

typedef struct tagValArrayInterface {
   int (*Abs)(ValArray *src); 
   ElementType (*Accumulate)(const ValArray *src);
   int (*Add)(ValArray *AL,ElementType newval);
   int (*AddRange)(ValArray *AL,size_t n,
         const ElementType *newvalues);
   int (*And)(ValArray *left, const ValArray *right);
   int (*AndScalar)(ValArray *left, const ElementType right);
   int (*Append)(ValArray *AL1, ValArray *AL2);
   int (*Apply)(ValArray *AL,int (*Applyfn)(ElementType element,
        void * arg),void *arg);
   ElementType (*Back)(const ValArray *src);
   int (*BitLeftShift)(ValArray *data,int shift);
   int (*BitRightShift)(ValArray *data, const int shift);
   int (*Clear)(ValArray *AL);
   char *(*Compare)(const ValArray *left, const ValArray *right,
         char *bytearray);
   Mask *(*CompareEqual)(const ValArray *left,const ValArray *right,
         Mask *bytearray);
   Mask *(*CompareEqualScalar)(const ValArray *left,
          const ElementType right, Mask *bytearray);
   char *(*CompareScalar)(const ValArray *left,
          const ElementType right,char *bytearray);
   int (*Contains)(const ValArray *AL,ElementType data);
   ValArray *(*Copy)(const ValArray *AL);
   int (*CopyElement)(const ValArray *AL,size_t idx,
        ElementType *outbuf);
   ElementType *(*CopyTo)(ValArray *AL);
   ValArray *(*Create)(size_t startsize);
   ValArray *(*CreateSequence)(size_t n,ElementType start,
              ElementType increment);
   ValArray *(*CreateWithAllocator)(size_t startsize,
              ContainerAllocator *allocator);
   int (*DivideBy)(ValArray *left, const ValArray *right);
   int (*DivideByScalar)(ValArray *left, ElementType right);
   int (*DivideScalarBy)(ValArray *left,ElementType right);
   int (*Equal)(const ValArray *first, const ValArray *second);
   int (*Erase)(ValArray *AL,ElementType elem);
   int (*EraseAt)(ValArray *AL,size_t idx);
   Mask *(*FCompare)(const ValArray *left, const ValArray *right,
          Mask *bytearray,ElementType tolerance);
   int (*FillSequential)(ValArray *dst,size_t length,ElementType start,
         ElementType increment);
   int (*Finalize)(ValArray *AL);
   int (*ForEach)(ValArray *src,ElementType (*ApplyFn)(ElementType));
   int (*Fprintf)(const ValArray *src,FILE *out,const char *fmt);
   ElementType (*Front)(const ValArray *src);
   ContainerAllocator *(*GetAllocator)(const ValArray *AL);
   size_t (*GetCapacity)(const ValArray *AL);
   ElementType *(*GetData)(const ValArray *src);
   ElementType (*GetElement)(const ValArray *AL,size_t idx);
   size_t (*GetElementSize)(const ValArray *AL);
   unsigned (*GetFlags)(const ValArray *AL);
   ValArray *(*GetRange)(const ValArray *AL, size_t start,
              size_t end);
   int (*GetSlice)(ValArray *array,size_t *start,size_t *length,
         size_t *increment);
   ValArray *(*IndexIn)(const ValArray *SC,const ValArraySize_t *AL);
   int (*IndexOf)(ValArray *AL,ElementType data,size_t *result);
   ValArray *(*Init)(ValArray *AL,size_t startsize);
   int (*InitIterator)(ValArray *AL,void *buf);
   ValArray *(*InitializeWith)(size_t n, ElementType *data);
   int (*Insert)(ValArray *AL,ElementType);
   int (*InsertAt)(ValArray *AL,size_t idx,ElementType newval);
   int (*InsertIn)(ValArray *AL, size_t idx, ValArray *newData);
   int (*Inverse)(ValArray *src);
   ValArray *(*Load)(FILE *stream);
   ElementType (*Max)(const ValArray *src);
   int (*Memset)(ValArray *dst,ElementType fillValue,size_t length);
   ElementType (*Min)(const ValArray *src);
   int (*Mismatch)(const ValArray *a1,const ValArray *a2,
        size_t *mismatch);
   int (*Mod)(ValArray *left,const ValArray *right);
   int (*ModScalar)(ValArray *left,const ElementType right);
   int (*MultiplyWith)(ValArray *left, const ValArray *right);
   int (*MultiplyWithScalar)(ValArray *left, ElementType right);
   Iterator *(*NewIterator)(ValArray *AL);
   int (*Not)(ValArray *left);
   int (*Or)(ValArray *left, const ValArray *right);
   int (*OrScalar)(ValArray *left, const ElementType right);
   int (*PopBack)(ValArray *AL,ElementType *result);
   ElementType (*Product)(const ValArray *src);
   int (*PushBack)(ValArray *AL,ElementType data);
   int (*RemoveRange)(ValArray *src,size_t start,size_t end);
   int (*ReplaceAt)(ValArray *AL,size_t idx,ElementType newval);
   int (*ResetSlice)(ValArray *array);
   int (*Resize)(ValArray *src, size_t newSize);
   int (*Reverse)(ValArray *AL);
   int (*RotateLeft)(ValArray *AL, size_t n);
   int (*RotateRight)(ValArray *AL,size_t n);
   int (*Save)(const ValArray *AL,FILE *stream);
   int (*Select)(ValArray *src,const Mask *m);
   ValArray *(*SelectCopy)(const ValArray *src,const Mask *m);
   int (*SetCapacity)(ValArray *AL,size_t newCapacity);
   CompareFunction (*SetCompareFunction)(ValArray *l,
                   CompareFunction fn);
   DestructorFunction (*SetDestructor)(ValArray *cb,
                      DestructorFunction fn);
   ErrorFunction (*SetErrorFunction)(ValArray *AL,ErrorFunction);
   unsigned (*SetFlags)(ValArray *AL,unsigned flags);
   int (*SetSlice)(ValArray *src,size_t start,size_t length,
        size_t increment);
   size_t (*Size)(const ValArray *AL);
   size_t (*Sizeof)(const ValArray *AL);
   size_t (*SizeofIterator)(const ValArray *);
   int (*Sort)(ValArray *AL);
   int (*SubtractFrom)(ValArray *left, const ValArray *right);
   int (*SubtractFromScalar)(ElementType left, ValArray *right);
   int (*SubtractScalarFrom)(ValArray *left, ElementType right);
   int (*SumScalarTo)(ValArray *left,ElementType right);
   int (*SumTo)(ValArray *left,const ValArray *right);
   int (*Xor)(ValArray *left, const ValArray *right);
   int (*XorScalar)(ValArray *left, const ElementType right);
   int (*deleteIterator)(Iterator *);
} ValArrayInterface;

    int (*Abs)(ValArray *src);

ElementType (*Accumulate)(ValArray *src);

    int (*Add)(ValArray *AL,ElementType newval);

    int (*AddRange)(ValArray *AL,size_t n,ElementType *newvalues);

int (*Apply)(ValArray *AL,
             int (*Applyfn)(ElementType element,void * arg),
             void *arg);

    int (*And)(ValArray *left,ValArray *right);

    int (*BitLeftShift)(ValArray *dst,int shift);

    int (*BitRightShift)(ValArray *dst,int shift);

   int (*Clear)(ValArray *array);

char *(*Compare)(ValArray *left,ValArray *right,
                       char *bitarray);

byte[i] = (left[i] < right[i]) ? -1 : (left[i] == right[i]) ? 0 : 1

char *(*CompareScalar)(const ValArray *left,
                       const ElementType right, char *bitarray);

byte[i] = (left[i] < right) ? -1 : (left[i] == right) ? 0 : 1

Mask *(*CompareEqual)(ValArray *left,ValArray *right,
                       Mask bitarray);

bit[i] = (left[i] == right[i])

Mask *(*CompareEqual)(ValArray *left,ElementType right,
                       Mask *bitarray);

bit[i] = (left[i] == right)

int (*Contains)(ValArray *a,ElementType data);

    ValArray *(*Copy)(const ValArray *A);

ElementType *(*CopyTo)(ValArray *AL);

ValArray *(*Create)(size_t capacity);

ValArray *(*CreateSequence)(size_t size,
                            ElementType startValue,
                            ElementType increment);

    int (*DivideBy)(ValArray *left,ValArray *right);

    int (*DivideByScalar)(ValArray *left, ElementType right);

    int (*DivideScalarBy)(ElementType left, ValArray *right);

int (*Equal)(const ValArray *src1,const ValArray *src2);

    int (*Erase)(ValArray *AL,ElementType data);

    int (*EraseAll)(ValArray *v,const void *data);

    int (*EraseAt)(ValArray *AL,size_t idx);

char *(*FCompare)(const ValArray *left, 
                  const ValArray *right,
                  unsigned char *bytearray, 
                  ElementType tolerance);

int (*FillSequential)(ValArray *a,
                      ElementType start,ElementType increment);