xanlib.h

Go to the documentation of this file.

/*
 * Copyright (C)  2010 Simone Campanoni, Michele Tartara
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#ifndef XANLIB_H
#define XANLIB_H

#include <semaphore.h>
#include <pthread.h>
#include <stddef.h>
#include <stdbool.h>

typedef struct XanListItem{
        void                    * data;         
        struct XanListItem      * next;         
        struct XanListItem      * prev;         
} XanListItem;

typedef struct XanList{
        
        /* Fields                       */
        void *                  (*alloc)        (size_t size);          
        void                    (*free)         (void *address);        
        void *                  (*clone)        (void *data);           
        int                     len;
        XanListItem             *firstItem;
        XanListItem             *lastItem;
        pthread_mutex_t         itemsMutex;

        /* Synchronized methods         */
        void                    (*synchAppendList)              (struct XanList *list, struct XanList *listToAppend); 
        XanListItem *           (*synchAppend)                  (struct XanList *list, void *data); 
        XanListItem *           (*synchInsert)                  (struct XanList *list, void *data); 
        XanListItem *           (*synchInsertBefore)            (struct XanList *list, XanListItem *prev, void *data); 
        XanListItem *           (*synchInsertAfter)             (struct XanList *list, XanListItem *prev, void *data); 
        void                    (*synchDelete)                  (struct XanList *list, void *data); 
        void                    (*synchDeleteAll)               (struct XanList *list, void *data); 
        void                    (*synchDeleteItem)              (struct XanList *list, XanListItem *item); 
        XanListItem *           (*synchFirst)                   (struct XanList *list); 
        XanListItem *           (*synchLast)                    (struct XanList *list); 
        void                    (*synchDestroyList)             (struct XanList *list); 
        void                    (*synchDestroyListAndData)      (struct XanList *list); 
        void                    (*synchEmptyOutList)            (struct XanList *list); 
        void *                  (*synchData)                    (struct XanList *list, XanListItem *item); 
        void **                 (*synchGetSlotData)             (struct XanList *list, XanListItem *item); 
        XanListItem *           (*synchNext)                    (struct XanList *list, XanListItem *item); 
        XanListItem *           (*synchPrev)                    (struct XanList *list, XanListItem *item); 
        int                     (*synchLength)                  (struct XanList *list); 
        struct XanList *        (*synchCloneList)               (struct XanList *list); 
        void                    (*synchSetCloneFunction)        (struct XanList *list, void * (*cloneFunction) (void *data)); 
        void *                  (*synchGetCloneFunction)        (struct XanList *list); 
        XanListItem *           (*synchFind)                    (struct XanList *list, void *data); 
        int                     (*synchEqualsInstancesNumber)   (struct XanList *list, void *data); 
        XanListItem *           (*synchGetElementFromPositionNumber)    (struct XanList *list, int positionNumber); 
        XanListItem *           (*synchMoveToBegin)                     (struct XanList *list, XanListItem *item); 
        int                     (*synchContainsTheSameElements) (struct XanList *list, struct XanList *otherList); 
        int                     (*synchShareSomeElements)       (struct XanList *list, struct XanList *otherList); 
        void                    (*synchDeleteClones)            (struct XanList *list); 
        /* Not synchronized methods     */
        XanListItem *           (*append)                       (struct XanList *list, void *data); 
        void                    (*appendList)                   (struct XanList *list, struct XanList *listToAppend); 
        XanListItem *           (*insert)                       (struct XanList *list, void *data); 
        XanListItem *           (*insertBefore)                 (struct XanList *list, XanListItem *prev, void *data); 
        XanListItem *           (*insertAfter)                  (struct XanList *list, XanListItem *prev, void *data); 
        void                    (*delete)                       (struct XanList *list, void *data); 
        void                    (*deleteAll)                    (struct XanList *list, void *data); 
        void                    (*deleteItem)                   (struct XanList *list, XanListItem *item); 
        XanListItem *           (*first)                        (struct XanList *list); 
        XanListItem *           (*last)                         (struct XanList *list); 
        void                    (*destroyList)                  (struct XanList *list); 
        void                    (*destroyListAndData)           (struct XanList *list); 
        void                    (*emptyOutList)                 (struct XanList *list); 
        void *                  (*data)                         (struct XanList *list, XanListItem *item); 
        void **                 (*getSlotData)                  (struct XanList *list, XanListItem *item); 
        XanListItem *           (*next)                         (struct XanList *list, XanListItem *item); 
        XanListItem *           (*prev)                         (struct XanList *list, XanListItem *item); 
        int                     (*length)                       (struct XanList *list); 
        struct XanList *        (*cloneList)                    (struct XanList *list); 
        void                    (*setCloneFunction)             (struct XanList *list, void * (*cloneFunction) (void *data)); 
        void *                  (*getCloneFunction)             (struct XanList *list); 
        XanListItem *           (*find)                         (struct XanList *list, void *data); 
        int                     (*equalsInstancesNumber)        (struct XanList *list, void *data); 
        XanListItem *           (*getElementFromPositionNumber) (struct XanList *list, int positionNumber); 
        XanListItem *           (*moveToBegin)                  (struct XanList *list, XanListItem *item); 
        int                     (*containsTheSameElements)      (struct XanList *list, struct XanList *otherList); 
        int                     (*shareSomeElements)            (struct XanList *list, struct XanList *otherList); 
        void                    (*deleteClones)                 (struct XanList *list); 
        void                    (*lock)                         (struct XanList *list); 
        void                    (*unlock)                       (struct XanList *list); 
} XanList;

typedef struct XanVar{
        /* Fields                       */
        void    *data;
        sem_t   mutex;
        void *                  (*alloc)        (size_t size);
        void                    (*free)         (void *address);

        /* Methods                      */
        void *                  (*synchRead)            (struct XanVar *var);   
        void                    (*synchWrite)           (struct XanVar *var, void *data); 
        /* Not synchronized methods     */
        void *                  (*read)                 (struct XanVar *var);   
        void                    (*write)                (struct XanVar *var, void *data); 
        void                    (*lock)                 (struct XanVar *var);   
        void                    (*unlock)               (struct XanVar *var);   
        void                    (*destroyVarAndData)    (struct XanVar *var);   
} XanVar;

typedef struct XanPipe{

        /* Fields               */
        void *          (*alloc)                (size_t size);
        void            (*free)                 (void *addr);
        XanList         *items;
        pthread_mutex_t itemsMutex;
        pthread_cond_t  itemsCond;

        /* Methods              */
        void *          (*synchGet)             (struct XanPipe *pipe); 
        XanListItem *   (*synchPut)             (struct XanPipe *pipe, void *item); 
        XanListItem *   (*synchPutAtEnd)        (struct XanPipe *pipe, void *item); 
        XanListItem *   (*synchMoveToEnd)       (struct XanPipe *pipe, void *item); 
        void            (*synchDeleteItem)      (struct XanPipe *pipe, XanListItem *item); 
        int             (*synchIsEmpty)         (struct XanPipe *pipe); 
        void *          (*get)                  (struct XanPipe *pipe); 
        XanListItem *   (*put)                  (struct XanPipe *pipe, void *item); 
        XanListItem *   (*putAtEnd)             (struct XanPipe *pipe, void *item); 
        XanListItem *   (*moveToEnd)            (struct XanPipe *pipe, void *item); 
        void            (*deleteItem)           (struct XanPipe *pipe, XanListItem *item); 
        int             (*isEmpty)              (struct XanPipe *pipe); 
        void            (*lock)                 (struct XanPipe *pipe); 
        void            (*unlock)               (struct XanPipe *pipe); 
        void            (*destroyPipe)          (struct XanPipe *pipe); 
} XanPipe;

typedef struct XanStack{
        
        /* Fields               */
        XanList         *internalList;
        sem_t           mutex;

        /* Methods              */
        void *          (*synchPop)             (struct XanStack *stack);       
        void            (*synchPush)            (struct XanStack *stack, void *newElement); 
        int             (*synchGetSize)         (struct XanStack *stack);       
        void *          (*pop)                  (struct XanStack *stack);       
        void            (*push)                 (struct XanStack *stack, void *newElement); 
        int             (*getSize)              (struct XanStack *stack);       
        void            (*destroyStack)         (struct XanStack *stack);       
} XanStack;

bool xanStackSynchContains (XanStack *stack, void *element);
bool xanStackContains (XanStack *stack, void *element);

typedef struct XanNode{
        
        /* Fields                               */
        XanList         *childrens;
        void            *data;
        struct XanNode  *parent;
        sem_t           mutex;
        void *                  (*alloc)        (size_t size);
        void                    (*free)         (void *address);
        void *                  (*clone)        (void *data);

        /* Methods synchronized                 */
        struct XanNode *        (*synchGetParent)       (struct XanNode *node); 
        struct XanNode *        (*synchGetNextChildren) (struct XanNode *node, struct XanNode *child); 
        struct XanNode *        (*synchAddNewChildren)  (struct XanNode *node, void *childData); 
        struct XanNode *        (*synchCloneTree)       (struct XanNode *node); 
        void                    (*synchAddChildren)     (struct XanNode *node, struct XanNode *child); 
        void                    (*synchDeleteChildren)  (struct XanNode *node, struct XanNode *child); 
        void                    (*synchSetParent)       (struct XanNode *node, struct XanNode *parent); 
        void                    (*synchSetData)         (struct XanNode *node, void *data); 
        void *                  (*synchGetData)         (struct XanNode *node); 
        XanList *               (*synchGetChildrens)    (struct XanNode *node); 
        void                    (*synchSetCloneFunction)(struct XanNode *node, void * (*cloneFunction) (void *data)); 
        void                    (*synchDestroyTree)     (struct XanNode *node); 
        void                    (*synchDestroyTreeAndData)(struct XanNode *node); 
        XanList *               (*synchToPreOrderList)  (struct XanNode *rootNode); 
        XanList *               (*synchToPostOrderList) (struct XanNode *rootNode); 
        XanList *               (*synchToInOrderList)   (struct XanNode *rootNode); 
        struct XanNode *        (*synchFind)            (struct XanNode *rootNode, void *data); 
        /* Methods not synchronized             */
        struct XanNode *        (*getParent)            (struct XanNode *node); 
        struct XanNode *        (*getNextChildren)      (struct XanNode *node, struct XanNode *child); 
        struct XanNode *        (*addNewChildren)       (struct XanNode *node, void *childData); 
        struct XanNode *        (*cloneTree)            (struct XanNode *node); 
        void                    (*addChildren)          (struct XanNode *node, struct XanNode *child); 
        void                    (*deleteChildren)       (struct XanNode *node, struct XanNode *child); 
        void                    (*setParent)            (struct XanNode *node, struct XanNode *parent); 
        void                    (*setData)              (struct XanNode *node, void *data); 
        void *                  (*getData)              (struct XanNode *node); 
        XanList *               (*getChildrens)         (struct XanNode *node); 
        void                    (*setCloneFunction)     (struct XanNode *node, void * (*cloneFunction) (void *data)); 
        void                    (*destroyTree)          (struct XanNode *node); 
        void                    (*destroyNode)          (struct XanNode *node); 
        void                    (*destroyTreeAndData)   (struct XanNode *node); 
        XanList *               (*toPreOrderList)       (struct XanNode *rootNode); 
        XanList *               (*toPostOrderList)      (struct XanNode *rootNode); 
        XanList *               (*toInOrderList)        (struct XanNode *rootNode); 
        struct XanNode *        (*find)                 (struct XanNode *rootNode, void *data); 
} XanNode;

typedef struct XanHashTableItem{
        bool    used;
        void    *elementID;
        void    *element;
        struct XanHashTableItem *next;
} XanHashTableItem;

typedef struct XanHashTable{

        /* Fields                       */
        XanHashTableItem        *table;
        unsigned int            primeIndex;
        unsigned int            length;
        unsigned int            size;
        int                     hasFixedLength;
        float                   currentLoadFactor;
        sem_t                   mutex;
        void *                  (*alloc)        (size_t size);
        void *                  (*realloc)      (void *oldAddress, size_t newSize);
        void                    (*free)         (void *addr);
        unsigned int            (*hash)         (void *element);
        int                     (*equals)       (void *key1, void *key2);
        void *                  (*clone)        (void *data);

        /* Synchronized methods         */
        void                    (*synchInsert)          (struct XanHashTable *table, void *key, void *element);
        void *                  (*synchLookup)          (struct XanHashTable *table, void *key);
        void                    (*synchDelete)          (struct XanHashTable *table, void *key);
        void                    (*synchDestroy)         (struct XanHashTable *table);   
        XanList *               (*synchToList)          (struct XanHashTable *table);   
        XanList *               (*synchToSlotList)      (struct XanHashTable *table);   
        int                     (*synchElementsInside)  (struct XanHashTable *table);   
        struct XanHashTable *   (*synchCloneHashTable)  (struct XanHashTable *table);   
        void                    (*synchSetCloneFunction)(struct XanHashTable *table, void * (*cloneFunction) (void *data));     
        void *                  (*synchGetCloneFunction)(struct XanHashTable *table);   
        /* Not synchronized methods     */
        void                    (*lock)                 (struct XanHashTable *table);   
        void                    (*unlock)               (struct XanHashTable *table);   
        void                    (*insert)               (struct XanHashTable *table, void *key, void *element);
        void *                  (*lookup)               (struct XanHashTable *table, void *key);        
        void                    (*delete)               (struct XanHashTable *table, void *key);        
        void                    (*destroy)              (struct XanHashTable *table);   
        XanList *               (*toList)               (struct XanHashTable *table);   
        XanList *               (*toSlotList)           (struct XanHashTable *table);   
        struct XanHashTable *   (*cloneHashTable)       (struct XanHashTable *table);   
        int                     (*elementsInside)       (struct XanHashTable *table);   
        void                    (*setCloneFunction)     (struct XanHashTable *table, void * (*cloneFunction) (void *data));     
        void *                  (*getCloneFunction)     (struct XanHashTable *table);   
} XanHashTable;

XanList * XanHashTable_ToItemList (XanHashTable *table); 

/* List                         */
XanList * xanListNew(void *(*allocFunction) (size_t size), void (*freeFunction) (void *addr), void * (*cloneFunction) (void *addr));

/* Variable                     */
XanVar * xanVarNew(void *(*allocFunction) (size_t size), void (*freeFunction) (void *addr));

/* Pipe                         */
XanPipe * xanPipeNew (void *(*allocFunction) (size_t size), void (*freeFunction) (void *addr));

/* Tree                         */
XanNode * xanNodeNew (void *(*allocFunction) (size_t size), void (*freeFunction) (void *addr), void * (*cloneFunction) (void *data));

/* Stack                        */
XanStack * xanStackNew (void *(*allocFunction) (size_t size), void (*freeFunction) (void *addr), void * (*cloneFunction) (void *data));

/* Hash table                   */
XanHashTable * xanHashTableNew(unsigned int length, int hasFixedLength, void *(*allocFunction) (size_t size), void *(*reallocFunction)(void *addr, size_t newSize), void (*freeFunction) (void *addr), unsigned int (*hashFunction) (void *element), int (*equalsFunction) (void *key1, void *key2));

/* Generic utilities            */
void print_err (char * message, int err);

void print_ascii_err (signed char * message, int err);

int str_has_suffix(char *string, char *suffix);

void libxanCompilationFlags(char *buffer, int bufferLength);

void libxanCompilationTime (char *buffer, int bufferLength);

char * libxanVersion();

/**********************************************************************************************************
 *                 xan_bitset
 **********************************************************************************************************/
typedef struct XanBitSet {
        size_t *data;
        size_t length;
} XanBitSet;

XanBitSet *XanBitSet_Alloc(size_t length);

void XanBitSet_ClearAll(XanBitSet *set);

void XanBitSet_SetAll(XanBitSet *set);

void XanBitSet_Subtract(XanBitSet *fromThis, XanBitSet *subtractThis);

void XanBitSet_Free(XanBitSet *set);

void XanBitSet_Intersect(XanBitSet *dest, XanBitSet *src);

int XanBitSet_GetCountOfBitsSet(XanBitSet *set);

bool XanBitSet_Equal(XanBitSet *bs1, XanBitSet *bs2);

XanBitSet* XanBitSet_Clone(XanBitSet *src);

void XanBitSet_Copy(XanBitSet *dest, XanBitSet *src);

void XanBitSet_ClearBit(XanBitSet *set, size_t pos);

void XanBitSet_SetBit(XanBitSet *set, size_t pos);

bool XanBitSet_IsBitSet(XanBitSet *set, size_t pos);

bool XanBitSet_IsSubSetOf(XanBitSet *setA, XanBitSet *setB);

void XanBitSet_Print(XanBitSet *set, int cr);

#endif

---