* made inline functions from avl_walk_{first,last,next,prev}
authorBernd Petrovitsch <bernd@firmix.at>
Sun, 11 Nov 2007 22:55:17 +0000 (22:55 +0000)
committerBernd Petrovitsch <bernd@firmix.at>
Sun, 11 Nov 2007 22:55:17 +0000 (22:55 +0000)
* created "const" versions of it
* inline_avl_comp_ipv4() is now also an inline function (and not a macro)
* created a typedef for the avl tree comparison functions and use it!
* cleanup: compare tree->comp to NULL as it is a pointer
* killed a superflous "return"at the end of a void function

src/lq_avl.c
src/lq_avl.h

index 74e279d..5a42dff 100755 (executable)
@@ -37,7 +37,7 @@
  * to the project. For more information see the website or contact
  * the copyright holders.
  *
- * $Id: lq_avl.c,v 1.14 2007/11/08 22:47:41 bernd67 Exp $
+ * $Id: lq_avl.c,v 1.15 2007/11/11 22:55:17 bernd67 Exp $
  */
 
 #include <stddef.h>
@@ -55,8 +55,8 @@
  * if avl_comp_default is set to zero, a fast
  * inline ipv4 comparison will be executed.
  */
-int (*avl_comp_default)(const void *, const void *) = NULL;
-int (*avl_comp_prefix_default)(const void *, const void *);
+avl_tree_comp avl_comp_default = NULL;
+avl_tree_comp avl_comp_prefix_default;
 
 int avl_comp_ipv4(const void *ip1, const void *ip2)
 {
@@ -68,7 +68,7 @@ int avl_comp_ipv6(const void *ip1, const void *ip2)
   return memcmp(ip1, ip2, 16);
 }
 
-void avl_init(struct avl_tree *tree, int (*comp)(const void *, const void *))
+void avl_init(struct avl_tree *tree, avl_tree_comp comp)
 {
   tree->root = NULL;
   tree->first = NULL;
@@ -95,11 +95,11 @@ static struct avl_node *avl_find_rec_ipv4(struct avl_node *node, const void *key
 }
 
 static struct avl_node *avl_find_rec(struct avl_node *node, const void *key,
-                                     int (*comp)(const void *, const void *))
+                                     avl_tree_comp comp)
 {
   int diff;
 
-  if (0 == comp)
+  if (NULL == comp)
     return avl_find_rec_ipv4(node, key);
 
   diff = (*comp)(key, node->key);
@@ -132,7 +132,7 @@ struct avl_node *avl_find(struct avl_tree *tree, const void *key)
 
   node = avl_find_rec(tree->root, key, tree->comp);
 
-  if (0 == tree->comp)
+  if (NULL == tree->comp)
   {
     if (0 != inline_avl_comp_ipv4(node->key, key))
       return NULL;
@@ -213,9 +213,9 @@ static void avl_rotate_left(struct avl_tree *tree, struct avl_node *node)
 
 static void post_insert(struct avl_tree *tree, struct avl_node *node)
 {
-  struct avl_node *parent;
+  struct avl_node *parent = node->parent;
 
-  if ((parent = node->parent) == NULL)
+  if (parent == NULL)
     return;
 
   if (node == parent->left)
@@ -261,7 +261,6 @@ static void post_insert(struct avl_tree *tree, struct avl_node *node)
 
   avl_rotate_right(tree, node);
   avl_rotate_left(tree, node->parent->parent);
-  return;
 }
 
 static void avl_insert_before(struct avl_tree *tree, struct avl_node *pos_node,
@@ -344,7 +343,7 @@ int avl_insert(struct avl_tree *tree, struct avl_node *new, int allow_duplicates
   while (last->next != NULL && last->next->leader == 0)
     last = last->next;
 
-  if (0 == tree->comp)
+  if (NULL == tree->comp)
     diff = inline_avl_comp_ipv4(new->key, node->key);
 
   else
@@ -690,26 +689,6 @@ void avl_delete(struct avl_tree *tree, struct avl_node *node)
   avl_remove(tree, node);
 }
 
-struct avl_node *avl_walk_first(struct avl_tree *tree)
-{
-  return tree->first;
-}
-
-struct avl_node *avl_walk_last(struct avl_tree *tree)
-{
-  return tree->last;
-}
-
-struct avl_node *avl_walk_next(struct avl_node *node)
-{
-  return node->next;
-}
-
-struct avl_node *avl_walk_prev(struct avl_node *node)
-{
-  return node->prev;
-}
-
 /*
  * Local Variables:
  * c-basic-offset: 2
index a73a257..6ec0480 100755 (executable)
  * to the project. For more information see the website or contact
  * the copyright holders.
  *
- * $Id: lq_avl.h,v 1.12 2007/11/08 22:47:41 bernd67 Exp $
+ * $Id: lq_avl.h,v 1.13 2007/11/11 22:55:16 bernd67 Exp $
  */
 
 #ifndef _LQ_AVL_H
 #define _LQ_AVL_H
 
+#include "defs.h"
+
 struct avl_node
 {
   struct avl_node *parent;
@@ -56,35 +58,43 @@ struct avl_node
   unsigned char leader;
 };
 
+typedef int (*avl_tree_comp)(const void *, const void *);
+
 struct avl_tree
 {
   struct avl_node *root;
   struct avl_node *first;
   struct avl_node *last;
   unsigned int count;
-  int (*comp)(const void *, const void *);
+  avl_tree_comp comp;
 };
 
 #define AVL_DUP    1
 #define AVL_DUP_NO 0
 
-void avl_init(struct avl_tree *, int (*)(const void *, const void *));
+void avl_init(struct avl_tree *, avl_tree_comp);
 struct avl_node *avl_find(struct avl_tree *, const void *);
 int avl_insert(struct avl_tree *, struct avl_node *, int);
 void avl_delete(struct avl_tree *, struct avl_node *);
-struct avl_node *avl_walk_first(struct avl_tree *);
-struct avl_node *avl_walk_last(struct avl_tree *);
-struct avl_node *avl_walk_next(struct avl_node *);
-struct avl_node *avl_walk_prev(struct avl_node *);
 
-extern int (*avl_comp_default)(const void *, const void *);
-extern int (*avl_comp_prefix_default)(const void *, const void *);
+static INLINE struct avl_node *avl_walk_first(struct avl_tree *tree) { return tree->first; }
+static INLINE struct avl_node *avl_walk_last(struct avl_tree *tree) { return tree->last; }
+static INLINE struct avl_node *avl_walk_next(struct avl_node *node) { return node->next; }
+static INLINE struct avl_node *avl_walk_prev(struct avl_node *node) { return node->prev; }
+/* and const versions*/
+static INLINE const struct avl_node *avl_walk_first_c(const struct avl_tree *tree) { return tree->first; }
+static INLINE const struct avl_node *avl_walk_last_c(const struct avl_tree *tree) { return tree->last; }
+static INLINE const struct avl_node *avl_walk_next_c(const struct avl_node *node) { return node->next; }
+static INLINE const struct avl_node *avl_walk_prev_c(const struct avl_node *node) { return node->prev; }
+
+extern avl_tree_comp avl_comp_default;
+extern avl_tree_comp avl_comp_prefix_default;
 extern int avl_comp_ipv4(const void *, const void *);
 extern int avl_comp_ipv6(const void *, const void *);
 
-#define inline_avl_comp_ipv4(ip1, ip2) \
-  (*(unsigned int *)(ip1) == *(unsigned int *)(ip2) ? 0 :       \
-   *(unsigned int *)(ip1) < *(unsigned int *)(ip2) ? -1 : +1)
+static INLINE int inline_avl_comp_ipv4(const void *_ip1, const void *_ip2) {
+  const unsigned int *ip1 = _ip1, *ip2 = _ip2;
+  return *ip1 == *ip2 ? 0 : *ip1 < *ip2 ? -1 : +1; }
 
 #endif