X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/73596976dc2dc001e643ad3b68653da9a1cb6e8a..07c12189c716ea527ddcf8f8b55983213dead2bf:/src/xbt/dynar.cpp

diff --git a/src/xbt/dynar.cpp b/src/xbt/dynar.cpp
index 35ca11ac1b..62a607ee40 100644
--- a/src/xbt/dynar.cpp
+++ b/src/xbt/dynar.cpp
@@ -10,6 +10,7 @@
 #include "xbt/sysdep.h"
 #include "xbt/log.h"
 #include "xbt/ex.h"
+#include <xbt/ex.hpp>
 #include "xbt/dynar.h"
 #include <sys/types.h>
 
@@ -17,7 +18,7 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_dyn, xbt, "Dynamic arrays");
 
 static inline void _sanity_check_dynar(xbt_dynar_t dynar)
 {
-  xbt_assert(dynar, "dynar is NULL");
+  xbt_assert(dynar, "dynar is nullptr");
 }
 
 static inline void _sanity_check_idx(int idx)
@@ -83,7 +84,7 @@ void xbt_dynar_dump(xbt_dynar_t dynar)
 /** @brief Constructor
  *
  * \param elmsize size of each element in the dynar
- * \param free_f function to call each time we want to get rid of an element (or NULL if nothing to do).
+ * \param free_f function to call each time we want to get rid of an element (or nullptr if nothing to do).
  *
  * Creates a new dynar. If a free_func is provided, the elements have to be pointer of pointer. That is to say that
  * dynars can contain either base types (int, char, double, etc) or pointer of pointers (struct **).
@@ -95,7 +96,7 @@ xbt_dynar_t xbt_dynar_new(const unsigned long elmsize, void_f_pvoid_t const free
   dynar->size = 0;
   dynar->used = 0;
   dynar->elmsize = elmsize;
-  dynar->data = NULL;
+  dynar->data = nullptr;
   dynar->free_f = free_f;
 
   return dynar;
@@ -114,7 +115,7 @@ void xbt_dynar_free_container(xbt_dynar_t * dynar)
     xbt_dynar_t d = *dynar;
     free(d->data);
     free(d);
-    *dynar = NULL;
+    *dynar = nullptr;
   }
 }
 
@@ -370,7 +371,7 @@ void xbt_dynar_remove_at(xbt_dynar_t const dynar, const int idx, void *const obj
 /** @brief Remove a slice of the dynar, sliding the rest of the values to the left
  *
  * This function removes an n-sized slice that starts at element idx. It is equivalent to xbt_dynar_remove_at with a
- * NULL object argument if n equals to 1.
+ * nullptr object argument if n equals to 1.
  *
  * Each of the removed elements is freed using the free_f function passed at dynar creation.
  */
@@ -460,15 +461,14 @@ signed int xbt_dynar_search_or_negative(xbt_dynar_t const dynar, void *const ele
  */
 int xbt_dynar_member(xbt_dynar_t const dynar, void *const elem)
 {
-  try {
-    xbt_dynar_search(dynar, elem);
-  }
-  catch (xbt_ex& e) {
-    if (e.category == not_found_error)
-      return 0;
-    throw;
-  }
-  return 1;
+  unsigned long it;
+
+  for (it = 0; it < dynar->used; it++)
+    if (!memcmp(_xbt_dynar_elm(dynar, it), elem, dynar->elmsize)) {
+      return 1;
+    }
+
+  return 0;
 }
 
 /** @brief Make room at the end of the dynar for a new element, and return a pointer to it.
@@ -554,7 +554,7 @@ void xbt_dynar_map(const xbt_dynar_t dynar, void_f_pvoid_t const op)
  */
 void xbt_dynar_cursor_rm(xbt_dynar_t dynar, unsigned int *const cursor)
 {
-  xbt_dynar_remove_at(dynar, (*cursor)--, NULL);
+  xbt_dynar_remove_at(dynar, (*cursor)--, nullptr);
 }
 
 /** @brief Sorts a dynar according to the function <tt>compar_fn</tt>
@@ -646,7 +646,7 @@ XBT_PUBLIC(void) xbt_dynar_three_way_partition(xbt_dynar_t const dynar, int_f_pv
   xbt_free(tmp);
 }
 
-/** @brief Transform a dynar into a NULL terminated array. 
+/** @brief Transform a dynar into a nullptr terminated array. 
  *
  *  \param dynar the dynar to transform
  *  \return pointer to the first element of the array
@@ -681,7 +681,7 @@ int xbt_dynar_compare(xbt_dynar_t d1, xbt_dynar_t d2, int(*compar)(const void *,
   if((!d1) && (!d2)) return 0;
   if((!d1) || (!d2))
   {
-    XBT_DEBUG("NULL dynar d1=%p d2=%p",d1,d2);
+    XBT_DEBUG("nullptr dynar d1=%p d2=%p",d1,d2);
     xbt_dynar_free(&d2);
     return 1;
   }
@@ -720,13 +720,12 @@ XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(xbt_dyn);
 XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
 {
   /* Vars_decl [doxygen cruft] */
-  xbt_dynar_t d;
-  int i, cpt;
+  int i;
   unsigned int cursor;
   int *iptr;
 
   xbt_test_add("==== Traverse the empty dynar");
-  d = xbt_dynar_new(sizeof(int), NULL);
+  xbt_dynar_t d = xbt_dynar_new(sizeof(int), nullptr);
   xbt_dynar_foreach(d, cursor, i) {
     xbt_die( "Damnit, there is something in the empty dynar");
   }
@@ -737,8 +736,8 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
   xbt_test_add("==== Push %d int, set them again 3 times, traverse them, shift them", NB_ELEM);
   /* Populate_ints [doxygen cruft] */
   /* 1. Populate the dynar */
-  d = xbt_dynar_new(sizeof(int), NULL);
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  d = xbt_dynar_new(sizeof(int), nullptr);
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     xbt_dynar_push_as(d, int, cpt);     /* This is faster (and possible only with scalars) */
     /* xbt_dynar_push(d,&cpt);       This would also work */
     xbt_test_log("Push %d, length=%lu", cpt, xbt_dynar_length(d));
@@ -747,23 +746,25 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
   /* 2. Traverse manually the dynar */
   for (cursor = 0; cursor < NB_ELEM; cursor++) {
     iptr = (int*) xbt_dynar_get_ptr(d, cursor);
-    xbt_test_assert(cursor == (unsigned int) *iptr, "The retrieved value is not the same than the injected one (%u!=%d)", cursor, cpt);
+    xbt_test_assert(cursor == (unsigned int)*iptr, "The retrieved value is not the same than the injected one (%u!=%d)",
+                    cursor, *iptr);
   }
 
   /* 3. Traverse the dynar using the neat macro to that extend */
+  int cpt;
   xbt_dynar_foreach(d, cursor, cpt) {
     xbt_test_assert(cursor == (unsigned int) cpt, "The retrieved value is not the same than the injected one (%u!=%d)", cursor, cpt);
   }
   /* end_of_traversal */
 
-  for (cpt = 0; cpt < NB_ELEM; cpt++)
+  for (int cpt = 0; cpt < NB_ELEM; cpt++)
     *(int *) xbt_dynar_get_ptr(d, cpt) = cpt;
 
-  for (cpt = 0; cpt < NB_ELEM; cpt++)
+  for (int cpt = 0; cpt < NB_ELEM; cpt++)
     *(int *) xbt_dynar_get_ptr(d, cpt) = cpt;
   /*     xbt_dynar_set(d,cpt,&cpt); */
 
-  for (cpt = 0; cpt < NB_ELEM; cpt++)
+  for (int cpt = 0; cpt < NB_ELEM; cpt++)
     *(int *) xbt_dynar_get_ptr(d, cpt) = cpt;
 
   cpt = 0;
@@ -775,7 +776,7 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
 
   /* shifting [doxygen cruft] */
   /* 4. Shift all the values */
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     xbt_dynar_shift(d, &i);
     xbt_test_assert(i == cpt, "The retrieved value is not the same than the injected one (%d!=%d)", i, cpt);
     xbt_test_log("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
@@ -801,12 +802,12 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
   /* in your code is naturally the way to go outside a regression test */
 
   xbt_test_add("==== Unshift/pop %d int", NB_ELEM);
-  d = xbt_dynar_new(sizeof(int), NULL);
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  d = xbt_dynar_new(sizeof(int), nullptr);
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     xbt_dynar_unshift(d, &cpt);
     XBT_DEBUG("Push %d, length=%lu", cpt, xbt_dynar_length(d));
   }
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     i = xbt_dynar_pop_as(d, int);
     xbt_test_assert(i == cpt, "The retrieved value is not the same than the injected one (%d!=%d)", i, cpt);
     xbt_test_log("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
@@ -816,7 +817,7 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
   /* in your code is naturally the way to go outside a regression test */
 
   xbt_test_add ("==== Push %d int, insert 1000 int in the middle, shift everything", NB_ELEM);
-  d = xbt_dynar_new(sizeof(int), NULL);
+  d = xbt_dynar_new(sizeof(int), nullptr);
   for (cpt = 0; cpt < NB_ELEM; cpt++) {
     xbt_dynar_push_as(d, int, cpt);
     XBT_DEBUG("Push %d, length=%lu", cpt, xbt_dynar_length(d));
@@ -846,7 +847,7 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
   /* in your code is naturally the way to go outside a regression test */
 
   xbt_test_add("==== Push %d int, remove 2000-4000. free the rest", NB_ELEM);
-  d = xbt_dynar_new(sizeof(int), NULL);
+  d = xbt_dynar_new(sizeof(int), nullptr);
   for (cpt = 0; cpt < NB_ELEM; cpt++)
     xbt_dynar_push_as(d, int, cpt);
 
@@ -863,31 +864,31 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
 /*******************************************************************************/
 XBT_TEST_UNIT("insert",test_dynar_insert,"Using the xbt_dynar_insert and xbt_dynar_remove functions")
 {
-  xbt_dynar_t d = xbt_dynar_new(sizeof(unsigned int), NULL);
+  xbt_dynar_t d = xbt_dynar_new(sizeof(unsigned int), nullptr);
   unsigned int cursor;
-  int cpt;
 
   xbt_test_add("==== Insert %d int, traverse them, remove them",NB_ELEM);
   /* Populate_ints [doxygen cruft] */
   /* 1. Populate the dynar */
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     xbt_dynar_insert_at(d, cpt, &cpt);
     xbt_test_log("Push %d, length=%lu", cpt, xbt_dynar_length(d));
   }
 
   /* 3. Traverse the dynar */
+  int cpt;
   xbt_dynar_foreach(d, cursor, cpt) {
     xbt_test_assert(cursor == (unsigned int) cpt, "The retrieved value is not the same than the injected one (%u!=%d)", cursor, cpt);
   }
   /* end_of_traversal */
 
   /* Re-fill with the same values using set_as (and re-verify) */
-  for (cpt = 0; cpt < NB_ELEM; cpt++)
+  for (int cpt = 0; cpt < NB_ELEM; cpt++)
     xbt_dynar_set_as(d, cpt, int, cpt);
   xbt_dynar_foreach(d, cursor, cpt)
     xbt_test_assert(cursor == (unsigned int) cpt, "The retrieved value is not the same than the injected one (%u!=%d)", cursor, cpt);
 
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     int val;
     xbt_dynar_remove_at(d,0,&val);
     xbt_test_assert(cpt == val, "The retrieved value is not the same than the injected one (%u!=%d)", cursor, cpt);
@@ -898,8 +899,8 @@ XBT_TEST_UNIT("insert",test_dynar_insert,"Using the xbt_dynar_insert and xbt_dyn
 
   /* ********************* */
   xbt_test_add("==== Insert %d int in reverse order, traverse them, remove them",NB_ELEM);
-  d = xbt_dynar_new(sizeof(int), NULL);
-  for (cpt = NB_ELEM-1; cpt >=0; cpt--) {
+  d = xbt_dynar_new(sizeof(int), nullptr);
+  for (int cpt = NB_ELEM - 1; cpt >= 0; cpt--) {
     xbt_dynar_replace(d, cpt, &cpt);
     xbt_test_log("Push %d, length=%lu", cpt, xbt_dynar_length(d));
   }
@@ -929,7 +930,7 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
   double d1, d2;
 
   xbt_test_add("==== Traverse the empty dynar");
-  d = xbt_dynar_new(sizeof(int), NULL);
+  d = xbt_dynar_new(sizeof(int), nullptr);
   xbt_dynar_foreach(d, cursor, cpt) {
     xbt_test_assert(FALSE, "Damnit, there is something in the empty dynar");
   }
@@ -938,7 +939,7 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
   /* in your code is naturally the way to go outside a regression test */
 
   xbt_test_add("==== Push/shift 5000 doubles");
-  d = xbt_dynar_new(sizeof(double), NULL);
+  d = xbt_dynar_new(sizeof(double), nullptr);
   for (cpt = 0; cpt < 5000; cpt++) {
     d1 = (double) cpt;
     xbt_dynar_push(d, &d1);
@@ -957,7 +958,7 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
   /* in your code is naturally the way to go outside a regression test */
 
   xbt_test_add("==== Unshift/pop 5000 doubles");
-  d = xbt_dynar_new(sizeof(double), NULL);
+  d = xbt_dynar_new(sizeof(double), nullptr);
   for (cpt = 0; cpt < 5000; cpt++) {
     d1 = (double) cpt;
     xbt_dynar_unshift(d, &d1);
@@ -972,7 +973,7 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
   /* in your code is naturally the way to go outside a regression test */
 
   xbt_test_add("==== Push 5000 doubles, insert 1000 doubles in the middle, shift everything");
-  d = xbt_dynar_new(sizeof(double), NULL);
+  d = xbt_dynar_new(sizeof(double), nullptr);
   for (cpt = 0; cpt < 5000; cpt++) {
     d1 = (double) cpt;
     xbt_dynar_push(d, &d1);
@@ -1005,7 +1006,7 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
   /* in your code is naturally the way to go outside a regression test */
 
   xbt_test_add("==== Push 5000 double, remove 2000-4000. free the rest");
-  d = xbt_dynar_new(sizeof(double), NULL);
+  d = xbt_dynar_new(sizeof(double), nullptr);
   for (cpt = 0; cpt < 5000; cpt++) {
     d1 = (double) cpt;
     xbt_dynar_push(d, &d1);
@@ -1025,14 +1026,12 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
 /*******************************************************************************/
 XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
 {
-  xbt_dynar_t d;
-  int cpt;
   unsigned int iter;
   char buf[1024];
   char *s1, *s2;
 
   xbt_test_add("==== Traverse the empty dynar");
-  d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
+  xbt_dynar_t d = xbt_dynar_new(sizeof(char*), &xbt_free_ref);
   xbt_dynar_foreach(d, iter, s1) {
     xbt_test_assert(FALSE, "Damnit, there is something in the empty dynar");
   }
@@ -1044,27 +1043,27 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
   /* Populate_str [doxygen cruft] */
   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
   /* 1. Populate the dynar */
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     s1 = xbt_strdup(buf);
     xbt_dynar_push(d, &s1);
   }
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     s1 = xbt_strdup(buf);
     xbt_dynar_replace(d, cpt, &s1);
   }
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     s1 = xbt_strdup(buf);
     xbt_dynar_replace(d, cpt, &s1);
   }
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     s1 = xbt_strdup(buf);
     xbt_dynar_replace(d, cpt, &s1);
   }
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     xbt_dynar_shift(d, &s2);
     xbt_test_assert(!strcmp(buf, s2), "The retrieved value is not the same than the injected one (%s!=%s)", buf, s2);
@@ -1076,7 +1075,7 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
 
   xbt_test_add("==== Unshift, traverse and pop %d strings", NB_ELEM);
   d = xbt_dynar_new(sizeof(char **), &xbt_free_ref);
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     s1 = xbt_strdup(buf);
     xbt_dynar_unshift(d, &s1);
@@ -1087,7 +1086,7 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
     xbt_test_assert(!strcmp(buf, s1), "The retrieved value is not the same than the injected one (%s!=%s)", buf, s1);
   }
   /* 3. Traverse the dynar with the macro */
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     xbt_dynar_pop(d, &s2);
     xbt_test_assert(!strcmp(buf, s2), "The retrieved value is not the same than the injected one (%s!=%s)", buf, s2);
@@ -1100,32 +1099,32 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
 
   xbt_test_add("==== Push %d strings, insert %d strings in the middle, shift everything", NB_ELEM, NB_ELEM / 5);
   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     s1 = xbt_strdup(buf);
     xbt_dynar_push(d, &s1);
   }
-  for (cpt = 0; cpt < NB_ELEM / 5; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM / 5; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     s1 = xbt_strdup(buf);
     xbt_dynar_insert_at(d, NB_ELEM / 2, &s1);
   }
 
-  for (cpt = 0; cpt < NB_ELEM / 2; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM / 2; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     xbt_dynar_shift(d, &s2);
     xbt_test_assert(!strcmp(buf, s2),
                      "The retrieved value is not the same than the injected one at the begining (%s!=%s)", buf, s2);
     free(s2);
   }
-  for (cpt = (NB_ELEM / 5) - 1; cpt >= 0; cpt--) {
+  for (int cpt = (NB_ELEM / 5) - 1; cpt >= 0; cpt--) {
     snprintf(buf,1023, "%d", cpt);
     xbt_dynar_shift(d, &s2);
     xbt_test_assert(!strcmp(buf, s2),
                      "The retrieved value is not the same than the injected one in the middle (%s!=%s)", buf, s2);
     free(s2);
   }
-  for (cpt = NB_ELEM / 2; cpt < NB_ELEM; cpt++) {
+  for (int cpt = NB_ELEM / 2; cpt < NB_ELEM; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     xbt_dynar_shift(d, &s2);
     xbt_test_assert(!strcmp(buf, s2), "The retrieved value is not the same than the injected one at the end (%s!=%s)",
@@ -1138,12 +1137,12 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
 
   xbt_test_add("==== Push %d strings, remove %d-%d. free the rest", NB_ELEM, 2 * (NB_ELEM / 5), 4 * (NB_ELEM / 5));
   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     s1 = xbt_strdup(buf);
     xbt_dynar_push(d, &s1);
   }
-  for (cpt = 2 * (NB_ELEM / 5); cpt < 4 * (NB_ELEM / 5); cpt++) {
+  for (int cpt = 2 * (NB_ELEM / 5); cpt < 4 * (NB_ELEM / 5); cpt++) {
     snprintf(buf,1023, "%d", cpt);
     xbt_dynar_remove_at(d, 2 * (NB_ELEM / 5), &s2);
     xbt_test_assert(!strcmp(buf, s2), "Remove a bad value. Got %s, expected %s", s2, buf);