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 = 0,
      AL_START_TAIL = 1,
      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 = 0;
   list->dup = NULL;
   list->free = NULL;
   list->match = NULL;
   return list;
}

void ListM::ListRelease(List *list) {
  unsigned long len = 0;
  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 == 0) {
    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 == 0) {
    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 < 0 ) {
    index = (-index) - 1;
    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 <= 1)  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 << "	";
  }
  std::cout << std::endl;
}

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

int main() {

  List *l = ListM::ListCreate();
  
  int value = 1000;
  ListM::ListAddNodeHead(l, (void*)&value); 
  
  int value2 = 2000;
  ListM::ListAddNodeHead(l, (void*)&value2);

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

  ListM::Traversal(l);
  
  return 0;
}