redis下的adlist

 //adlist.h
 #ifndef __ADLIST__H__
 #define __ADLIST__H__

 typedef struct listNode_ {
   struct listNode_ *prev;
   struct listNode_ *next;
   void *value;
 } listNode;

 typedef struct listIter_ {
   listNode *next;
   int      direction;
 }listIter;

 typedef struct List_ {
   listNode *head;
   listNode *tail;
   void *(*dup)(void *ptr);
   void (*free)(void *ptr);
   int (*match)(void *ptr, void *key);
   unsigned long len;
 }List;

 class ListM {
   public:
     enum {
       AL_START_HEAD = ,
       AL_START_TAIL = ,
       AL_START_ERR
     };  

     static List *ListCreate(void);
     static void ListRelease(List *list);

     static List *ListAddNodeHead(List *list, void *value);
     static List *ListAddNodeTail(List *list, void *value);
     static List *ListInsertNode(List *list,
                                 listNode *old_node,
                                 void *value,
                                 int after);

     static void ListDelNode(List *list, listNode *node);

     static listIter *ListGetIterator(List *list, int direction);
     static listNode *ListNext(listIter *iter);
     static void ListReleaseIterator(listIter *iter);

     static List *ListDup(List *orig);
     static listNode *ListSearchKey(List *list, void *key);
     static listNode *ListIndex(List *list, long index);

     static void ListRewind(List *list, listIter *li);
     static void ListRewindTail(List *list, listIter *li);
     static void ListRotate(List *list);

     static void Traversal(List *list);
 };

 #endif //__ADLIST__H__

 //adlist.cpp
 #include <stdlib.h>
 #include <iostream>
 #include "adlist.h"
 #include "zmalloc.h"

 List* ListM::ListCreate(void) {
    List *list;
    if((list = (List *)zmalloc(sizeof(List))) == NULL)
      return NULL;

    list->head = list->tail = NULL;
    list->len = ;
    list->dup = NULL;
    list->free = NULL;
    list->match = NULL;
    return list;
 }

 void ListM::ListRelease(List *list) {
   unsigned long len = ;
   listNode *current, *next;

   current = list->head;
   len = list->len;
   while(len--) {
     next = current->next;
     if(list->free) list->free(current->value);
     zfree(current);
     current = next;
   }
   zfree(list);
 }

 List *ListM::ListAddNodeHead(List *list, void *value) {

   listNode *node;

   if((node = (listNode *)zmalloc(sizeof(*node))) == NULL) {
     return NULL;
   }
   node->value = value;

   if(list->len == ) {
     list->head = list->tail = node;
     node->prev = node->next = NULL;
   } else {
     node->prev = NULL;
     node->next = list->head;
     list->head->prev = node;
     list->head = node;
   }
   list->len++;

   return list;
 }

 List *ListM::ListAddNodeTail(List *list, void *value) {

   listNode *node;

   if((node = (listNode *)zmalloc(sizeof(*node))) == NULL) {
     return NULL;
   }

   node->value = value;
   if(list->len == ) {
     list->head = list->tail = node;
     node->prev = node->next = NULL;
   } else {
     node->prev = list->tail;
     node->next = NULL;
     list->tail->next = node;
     list->tail = node;
   }
   list->len++;

   return list;
 }

 List *ListM::ListInsertNode(List *list, listNode *old_node, void *value,int after) {
    listNode *node;

    if((node = (listNode *)zmalloc(sizeof(*node))) == NULL) {
      return NULL;
    }

    node->value = value;
    if(after) {
     node->prev = old_node;
     node->next = old_node->next;
     if(list->tail == old_node) {
       list->tail = node;
     }
    } else {
     node->next = old_node;
     node->prev = old_node->prev;
     if(list->head == old_node) {
       list->head = node;
     }
    }

    if(node->prev != NULL) {
     node->prev->next = node;
    }

    if(node->next != NULL) {
     node->next->prev = node;
    }
    list->len++;

    return list;
 }

 void ListM::ListDelNode(List *list, listNode *node) {
   if(node->prev)
     node->prev->next =  node->next;
   else
     list->head = node->next;

   if(node->next)
     node->next->prev = node->prev;
   else
     list->tail = node->prev;

   if(list->free) list->free(node->value);
   zfree(node);
   list->len--;
 }

 listIter *ListM::ListGetIterator(List *list, int direction) {

   listIter *iter;

   if((iter = (listIter *)zmalloc(sizeof(*iter))) == NULL) return NULL;

   if(direction == AL_START_HEAD)
     iter->next = list->head;
   else
     iter->next = list->tail;
   iter->direction = direction;

   return iter;
 }

 listNode *ListM::ListNext(listIter *iter) {
   listNode *current = iter->next;

   if(current != NULL) {
     if(iter->direction == AL_START_HEAD)
       iter->next = current->next;
     else
       iter->next = current->prev;
   }
   return current;
 }

 void ListM::ListReleaseIterator(listIter *iter) {
   zfree(iter);
 }

 listNode *ListM::ListSearchKey(List *list, void *key) {
   listNode *node = NULL;
   listIter *iter = NULL;

   iter = ListGetIterator(list, AL_START_HEAD);
   while((node = ListNext(iter)) !=  NULL) {
     if(list->match) {
       if(list->match(node->value, key)) {
         ListReleaseIterator(iter);
         return node;
       }
     } else {
       if(key == node->value) {
         ListReleaseIterator(iter);
         return node;
       }
     }
   }

   ListReleaseIterator(iter);
   return NULL;
 }

 listNode *ListM::ListIndex(List *list, long index) {
   listNode *node = NULL;

   if(index <  ) {
     index = (-index) - ;
     node = list->tail;
     while(index-- && node) node = node->prev;
   } else {
     node = list->head;
     while(index-- && node) node = node->next;
   }
   return node;
 }

 void ListM::ListRewind(List *list, listIter *li) {
   li->next = list->head;
   li->direction = AL_START_HEAD;
 }

 void ListM::ListRewindTail(List *list, listIter *li) {
   li->next = list->tail;
   li->direction = AL_START_TAIL;
 }

 void ListM::ListRotate(List *list) {
   listNode *tail = list->tail;

   if(list->len <= )  return;

   list->tail = tail->prev;
   list->tail->next = NULL;

   list->head->prev = tail;
   tail->prev = NULL;
   tail->next = list->head;
   list->head = tail;
 }

 void ListM::Traversal(List *list) {
   if(list->head == list->tail ) return;

   listNode *node = NULL;
   listIter *iter = ListGetIterator(list, AL_START_HEAD);
   std::cout << "list data : ";
   while((node = ListNext(iter)) != NULL) {
     std::cout << *(int*)node->value << "\t";
   }
   std::cout << std::endl;
 }

 //main.cpp
 #include <iostream>
 #include "adlist.h"

 int main() {

   List *l = ListM::ListCreate();

   int value = ;
   ListM::ListAddNodeHead(l, (void*)&value); 

   int value2 = ;
   ListM::ListAddNodeHead(l, (void*)&value2);

   int value3 = ;
   ListM::ListAddNodeTail(l, (void*)&value3);

   ListM::Traversal(l);

   return ;
 }