X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/0c0857127aadbff3d4d1d317ca35b0c50621663a..509afa8dafbfc8a505586e5447a1ed4c76cf0ae3:/src/xbt/dict_cursor.c

diff --git a/src/xbt/dict_cursor.c b/src/xbt/dict_cursor.c
index 4dfb378379..d75e811870 100644
--- a/src/xbt/dict_cursor.c
+++ b/src/xbt/dict_cursor.c
@@ -2,89 +2,78 @@
 
 /* dict_cursor - iterators over dictionnaries                               */
 
-/* Authors: Martin Quinson                                                  */
-/* Copyright (C) 2003,2004 Martin Quinson.                                  */
+/* Copyright (c) 2003, 2004 Martin Quinson. All rights reserved.            */
 
 /* This program is free software; you can redistribute it and/or modify it
-   under the terms of the license (GNU LGPL) which comes with this package. */
+ * under the terms of the license (GNU LGPL) which comes with this package. */
 
-#include "gras_private.h"
+#include "xbt/misc.h"
 #include "dict_private.h"
 
-#include <stdlib.h> /* malloc() */
 #include <string.h> /* strlen() */
 
-GRAS_LOG_EXTERNAL_CATEGORY(dict);
-GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(dict_cursor,dict,"To traverse dictionaries");
+XBT_LOG_EXTERNAL_CATEGORY(dict);
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(dict_cursor,dict,"To traverse dictionaries");
 
 
 /*####[ Dict cursor functions ]#############################################*/
 /* To traverse (simple) dicts                                               */
 /* Don't add or remove entries to the dict while traversing !!!             */
 /*###########################################################################*/
-struct gras_dict_cursor_ {
+struct xbt_dict_cursor_ {
   /* we store all level encountered until here, to backtrack on next() */
-  gras_dynar_t *keys;
-  gras_dynar_t *key_lens;
-  int           pos;
-  int           pos_len;
-  gras_dictelm_t  *head;
+  xbt_dynar_t   keys;
+  xbt_dynar_t   key_lens;
+  int            pos;
+  int            pos_len;
+  xbt_dictelm_t head;
 };
 
-static _GRAS_INLINE
-gras_error_t
-_cursor_push_keys(gras_dict_cursor_t *p_cursor,
-                  gras_dictelm_t        *p_elm);
+static _XBT_INLINE void
+_cursor_push_keys(xbt_dict_cursor_t p_cursor,
+                  xbt_dictelm_t     p_elm);
 
-#undef gras_dict_CURSOR_DEBUG
-/*#define gras_dict_CURSOR_DEBUG 1*/
+#undef xbt_dict_CURSOR_DEBUG
+/*#define xbt_dict_CURSOR_DEBUG 1*/
 
 /**
- * gras_dict_cursor_new:
+ * xbt_dict_cursor_new:
  *
  * @head: the head of the dict
  * @cursor: the curent position in the dict
  *
  * Structure creator
  */
-gras_error_t
-gras_dict_cursor_new(const gras_dict_t          *p_head,
-                     /*OUT*/gras_dict_cursor_t **pp_cursor) {
-  gras_error_t        errcode  = no_error;
-  gras_dict_cursor_t *p_cursor = NULL;
+xbt_dict_cursor_t 
+xbt_dict_cursor_new(const xbt_dict_t head) {
+  xbt_dict_cursor_t res = NULL;
 
-  p_cursor = malloc(sizeof(gras_dict_cursor_t));
-  if (!p_cursor)
-    RAISE_MALLOC;
+  res = xbt_new(s_xbt_dict_cursor_t,1);
+  res->keys     = xbt_dynar_new(sizeof(char **), NULL);
+  res->key_lens = xbt_dynar_new(sizeof(int  *),  NULL);
+  res->pos      = 0;
+  res->pos_len  = 0;
+  res->head     = head ? head->head : NULL;
 
-  TRY(gras_dynar_new(&p_cursor->keys,     sizeof(char **), NULL));
-  TRY(gras_dynar_new(&p_cursor->key_lens, sizeof(int  *),  NULL));
+  xbt_dict_cursor_rewind(res);
 
-  p_cursor->pos     = 0;
-  p_cursor->pos_len = 0;
-  p_cursor->head    = p_head ? p_head->head : NULL;
-
-  TRY(gras_dict_cursor_rewind(p_cursor));
-
-  *pp_cursor = p_cursor;
-
-  return errcode;
+  return res;
 }
 
 /**
- * gras_dict_cursor_free:
+ * xbt_dict_cursor_free:
  *
  * @cursor: poor victim
  *
  * Structure destructor
  */
 void
-gras_dict_cursor_free(gras_dict_cursor_t *p_cursor) {
-  if (p_cursor) {
-    gras_dynar_free(p_cursor->keys);
-    gras_dynar_free(p_cursor->key_lens);
-    memset(p_cursor, 0, sizeof(gras_dict_cursor_t));
-    free(p_cursor);
+xbt_dict_cursor_free(xbt_dict_cursor_t *cursor) {
+  if (*cursor) {
+    xbt_dynar_free(&((*cursor)->keys));
+    xbt_dynar_free(&((*cursor)->key_lens));
+    xbt_free(*cursor);
+    *cursor = NULL;
   }
 }
 
@@ -93,13 +82,13 @@ gras_dict_cursor_free(gras_dict_cursor_t *p_cursor) {
  *
  * Sanity check to see if the head contains something
  */
-static _GRAS_INLINE
-gras_error_t
-__cursor_not_null(gras_dict_cursor_t *p_cursor) {
+static _XBT_INLINE
+xbt_error_t
+__cursor_not_null(xbt_dict_cursor_t cursor) {
 
-  gras_assert0(p_cursor, "Null cursor");
+  xbt_assert0(cursor, "Null cursor");
 
-  if (!p_cursor->head) {
+  if (!cursor->head) {
     return mismatch_error;
   }
 
@@ -107,178 +96,166 @@ __cursor_not_null(gras_dict_cursor_t *p_cursor) {
 }
 
 
-static _GRAS_INLINE
-gras_error_t
-_cursor_push_keys(gras_dict_cursor_t *p_cursor,
-                  gras_dictelm_t        *p_elm) {
-  gras_error_t         errcode = no_error;
-  gras_dictelm_t      *p_child = NULL;
+static _XBT_INLINE
+void
+_cursor_push_keys(xbt_dict_cursor_t cursor,
+                  xbt_dictelm_t     elm) {
+  xbt_dictelm_t       child = NULL;
   int                  i       = 0;
   static volatile int  count   = 0; /* ??? */
 
-  CDEBUG1(dict_cursor, "Push childs of %p in the cursor", (void*)p_elm);
+  CDEBUG1(dict_cursor, "Push childs of %p in the cursor", (void*)elm);
 
-  if (p_elm->content) {
-    TRY(gras_dynar_push(p_cursor->keys,     &p_elm->key    ));
-    TRY(gras_dynar_push(p_cursor->key_lens, &p_elm->key_len));
+  if (elm->content) {
+    xbt_dynar_push(cursor->keys,     &elm->key    );
+    xbt_dynar_push(cursor->key_lens, &elm->key_len);
     count++;
   }
 
-  gras_dynar_foreach(p_elm->sub, i, p_child) {
-    if (p_child)
-      TRY(_cursor_push_keys(p_cursor, p_child));
+  xbt_dynar_foreach(elm->sub, i, child) {
+    if (child)
+      _cursor_push_keys(cursor, child);
   }
 
   CDEBUG1(dict_cursor, "Count = %d", count);
-
-  return errcode;
 }
 
 /**
- * gras_dict_cursor_rewind:
+ * xbt_dict_cursor_rewind:
  * @cursor: the cursor
- * @Returns: gras_error_t
+ * @Returns: xbt_error_t
  *
  * back to the first element
  */
-gras_error_t
-gras_dict_cursor_rewind(gras_dict_cursor_t *p_cursor) {
-  gras_error_t errcode = no_error;
+void
+xbt_dict_cursor_rewind(xbt_dict_cursor_t cursor) {
 
-  CDEBUG0(dict_cursor, "gras_dict_cursor_rewind");
-  gras_assert(p_cursor);
+  CDEBUG0(dict_cursor, "xbt_dict_cursor_rewind");
+  xbt_assert(cursor);
 
-  gras_dynar_reset(p_cursor->keys);
-  gras_dynar_reset(p_cursor->key_lens);
+  xbt_dynar_reset(cursor->keys);
+  xbt_dynar_reset(cursor->key_lens);
 
-  if (!p_cursor->head)
-    return no_error;
+  if (!cursor->head)
+    return ;
 
-  TRY(_cursor_push_keys(p_cursor, p_cursor->head));
+  _cursor_push_keys(cursor, cursor->head);
 
-  gras_dynar_cursor_first(p_cursor->keys,     &p_cursor->pos    );
-  gras_dynar_cursor_first(p_cursor->key_lens, &p_cursor->pos_len);
+  xbt_dynar_cursor_first(cursor->keys,     &cursor->pos    );
+  xbt_dynar_cursor_first(cursor->key_lens, &cursor->pos_len);
 
-  return errcode;
 }
 
 /**
- * gras_dict_cursor_first:
+ * xbt_dict_cursor_first:
  * @dict: on what to let the cursor iterate
  * @cursor: dest address
  *
  * Create the cursor if it does not exists. Rewind it in any case.
  */
-void         gras_dict_cursor_first    (const gras_dict_t   *dict,
-					gras_dict_cursor_t **cursor){
-  gras_error_t errcode;
+void xbt_dict_cursor_first (const xbt_dict_t   dict,
+			     xbt_dict_cursor_t *cursor){
 
   if (!*cursor) {
     DEBUG0("Create the cursor on first use");
-    errcode = gras_dict_cursor_new(dict,cursor);
-    gras_assert1(errcode == no_error, "Unable to create the cursor, got error %s",
-		 gras_error_name(errcode));
+    *cursor=xbt_dict_cursor_new(dict);
   }
 
-  errcode = gras_dict_cursor_rewind(*cursor);
-  gras_assert1(errcode == no_error, "Unable to rewind the cursor before use, got error %s",
-	       gras_error_name(errcode));
+  xbt_dict_cursor_rewind(*cursor);
 }
 
 
 /**
- * gras_dict_cursor_step:
+ * xbt_dict_cursor_step:
  * @cursor: the cursor
  *
  * Move to the next element. 
  */
 void
-gras_dict_cursor_step(gras_dict_cursor_t *p_cursor) {
-  gras_assert(p_cursor);
+xbt_dict_cursor_step(xbt_dict_cursor_t cursor) {
+  xbt_assert(cursor);
 
-  gras_dynar_cursor_step(p_cursor->keys,     &p_cursor->pos);
-  gras_dynar_cursor_step(p_cursor->key_lens, &p_cursor->pos_len);
+  xbt_dynar_cursor_step(cursor->keys,     &cursor->pos);
+  xbt_dynar_cursor_step(cursor->key_lens, &cursor->pos_len);
 }
 
 /**
- * gras_dict_cursor_get_or_free:
+ * xbt_dict_cursor_get_or_free:
  * @cursor: the cursor
  * @Returns: true if it's ok, false if there is no more data
  *
  * Get current data
  */
 int
-gras_dict_cursor_get_or_free(gras_dict_cursor_t **cursor,
+xbt_dict_cursor_get_or_free(xbt_dict_cursor_t  *cursor,
 			     char               **key,
 			     void               **data) {
-  gras_error_t  errcode = no_error;
+  xbt_error_t  errcode = no_error;
   int           key_len = 0;
   
   if (!cursor || !(*cursor))
     return FALSE;
 
-  if (gras_dynar_length((*cursor)->keys) <= (*cursor)->pos) {
-    gras_dict_cursor_free(*cursor);
-    *cursor=NULL;
+  if (xbt_dynar_length((*cursor)->keys) <= (*cursor)->pos) {
+    xbt_dict_cursor_free(cursor);
     return FALSE;
   }
     
-  gras_dynar_get((*cursor)->keys,     (*cursor)->pos,     key    );
-  gras_dynar_get((*cursor)->key_lens, (*cursor)->pos_len, &key_len);
+  *key    = xbt_dynar_get_as((*cursor)->keys,     (*cursor)->pos,     char*);
+  key_len = xbt_dynar_get_as((*cursor)->key_lens, (*cursor)->pos_len, int);
 
-  errcode = gras_dictelm_get_ext((*cursor)->head, *key, key_len, data);
+  errcode = xbt_dictelm_get_ext((*cursor)->head, *key, key_len, data);
   if (errcode == mismatch_error) {
-    gras_dict_cursor_free(*cursor);
-    *cursor=NULL;
+    xbt_dict_cursor_free(cursor);
     return FALSE;
   }
 
-  gras_assert1(errcode == no_error,
+  xbt_assert1(errcode == no_error,
 	       "Unexpected problem while retrieving the content of cursor. Got %s",
-	       gras_error_name(errcode));
+	       xbt_error_name(errcode));
 
   return TRUE;
 }
 
 /**
- * gras_dict_cursor_get_key:
+ * xbt_dict_cursor_get_key:
  * @cursor: the cursor
  * @key: the current element
- * @Returns: gras_error_t
+ * @Returns: xbt_error_t
  *
  * Get current key
  */
-gras_error_t
-gras_dict_cursor_get_key(gras_dict_cursor_t  *p_cursor,
+xbt_error_t
+xbt_dict_cursor_get_key(xbt_dict_cursor_t   cursor,
                          /*OUT*/char        **key) {
-  gras_error_t errcode = no_error;
+  xbt_error_t errcode = no_error;
 
-  TRY(__cursor_not_null(p_cursor));
+  TRY(__cursor_not_null(cursor));
 
-  gras_dynar_get(p_cursor->keys, p_cursor->pos - 1, key);
+  *key = xbt_dynar_get_as(cursor->keys, cursor->pos - 1, char*);
 
   return errcode;
 }
 
 /**
- * gras_dict_cursor_get_data:
+ * xbt_dict_cursor_get_data:
  * @cursor: the cursor
  *
  * Get current data
  */
-gras_error_t
-gras_dict_cursor_get_data(gras_dict_cursor_t  *p_cursor,
+xbt_error_t
+xbt_dict_cursor_get_data(xbt_dict_cursor_t   cursor,
                           /*OUT*/void        **data) {
-  gras_error_t  errcode = no_error;
+  xbt_error_t  errcode = no_error;
   char         *key     = NULL;
   int           key_len = 0;
 
-  TRY(__cursor_not_null(p_cursor));
+  TRY(__cursor_not_null(cursor));
 
-  gras_dynar_get(p_cursor->keys,     p_cursor->pos-1,     &key    );
-  gras_dynar_get(p_cursor->key_lens, p_cursor->pos_len-1, &key_len);
+  key     = xbt_dynar_get_as(cursor->keys,     cursor->pos-1,  char *);
+  key_len = xbt_dynar_get_as(cursor->key_lens, cursor->pos_len-1, int);
 
-  TRY(gras_dictelm_get_ext(p_cursor->head, key, key_len, data));
+  TRY(xbt_dictelm_get_ext(cursor->head, key, key_len, data));
 
   return errcode;
 }