Rename item and bin "count" to "score" which is more accurate
authorCarl Worth <cworth@cworth.org>
Thu, 19 Apr 2007 05:38:28 +0000 (22:38 -0700)
committerCarl Worth <cworth@cworth.org>
Thu, 19 Apr 2007 05:38:28 +0000 (22:38 -0700)
There are several situations where the score is not really
a count of anything, (and more are to come in the future).

mnemon.c

index f80d67b10a15ede75c5095b005513dbb4622307e..9f28dfeb7a88dce584484c5648fafa0b75e49f6e 100644 (file)
--- a/mnemon.c
+++ b/mnemon.c
 typedef int bool_t;
 
 typedef struct _item {
-    int count;
+    int score;
     char *challenge;
     char *response;
 } item_t;
 
 typedef struct _bin {
-    int count;
+    int score;
     int items_size;
     int num_items;
     item_t **items;
@@ -126,11 +126,11 @@ xasprintf (char **strp, const char *fmt, ...)
 
 static void
 item_init (item_t      *item,
-          int           count,
+          int           score,
           const char   *challenge,
           const char   *response)
 {
-    item->count = count;
+    item->score = score;
 
     item->challenge = xmalloc (strlen (challenge) + 1 +
                               strlen (response) + 1);
@@ -186,7 +186,7 @@ category_grow (category_t *category)
 
 static item_t *
 category_add_item (category_t  *category,
-                  int           count,
+                  int           score,
                   const char   *challenge,
                   const char   *response)
 {
@@ -197,7 +197,7 @@ category_add_item (category_t       *category,
 
     item = &category->items[category->num_items++];
 
-    item_init (item, count, challenge, response);
+    item_init (item, score, challenge, response);
 
     return item;
 }
@@ -214,7 +214,7 @@ category_print (category_t  *category,
        if (i != 0)
            fprintf (file, "\n");
        fprintf (file, "%d\n%s\n%s\n",
-                item->count,
+                item->score,
                 item->challenge,
                 item->response);
     }
@@ -222,9 +222,9 @@ category_print (category_t  *category,
 
 static void
 bin_init (bin_t        *bin,
-         int    count)
+         int    score)
 {
-    bin->count = count;
+    bin->score = score;
 
     bin->items_size = 0;
     bin->num_items = 0;
@@ -253,7 +253,7 @@ static void
 bin_add_item (bin_t    *bin,
              item_t    *item)
 {
-    assert (item->count == bin->count);
+    assert (item->score == bin->score);
 
     if (bin->num_items == bin->items_size)
        bin_grow (bin);
@@ -355,15 +355,15 @@ mnemon_bins_grow (mnemon_t *mnemon)
 
 static bin_t *
 mnemon_get_bin (mnemon_t       *mnemon,
-               int              count)
+               int              score)
 {
     int i;
     bin_t *bin;
 
     for (i = 0; i < mnemon->num_bins; i++)
-       if (mnemon->bins[i].count == count)
+       if (mnemon->bins[i].score == score)
            return &mnemon->bins[i];
-       else if (mnemon->bins[i].count > count)
+       else if (mnemon->bins[i].score > score)
            break;
 
     if (mnemon->num_bins == mnemon->bins_size)
@@ -376,7 +376,7 @@ mnemon_get_bin (mnemon_t    *mnemon,
        memmove (bin + 1, bin, (mnemon->num_bins - i) * sizeof (bin_t));
     mnemon->num_bins++;
 
-    bin_init (bin, count);
+    bin_init (bin, score);
 
     return bin;
 }
@@ -429,7 +429,7 @@ mnemon_load_category (mnemon_t              *mnemon,
     category = mnemon_get_category (mnemon, name);
 
     while (1) {
-       int count;
+       int score;
        char *challenge, *response;
 
        /* Read bin number (ignoring blank separator lines) */
@@ -441,7 +441,7 @@ mnemon_load_category (mnemon_t              *mnemon,
            chomp (line);
        } while (*line == '\0');
 
-       count = strtol (line, &end, 10);
+       score = strtol (line, &end, 10);
        if (*end != '\0') {
            fprintf (stderr, "Failed to parse bin number from \"%s\" at %s:%d\n",
                     line, path, line_count);
@@ -464,7 +464,7 @@ mnemon_load_category (mnemon_t              *mnemon,
        chomp (line);
        response = line;
 
-       category_add_item (category, count, challenge, response);
+       category_add_item (category, score, challenge, response);
 
        free (challenge);
     }
@@ -483,7 +483,7 @@ mnemon_load_category (mnemon_t              *mnemon,
      * bin. */
     for (i = 0; i < category->num_items; i++) {
        item_t *item = &category->items[i];
-       bin_t *bin = mnemon_get_bin (mnemon, item->count);
+       bin_t *bin = mnemon_get_bin (mnemon, item->score);
 
        bin_add_item (bin, item);
     }
@@ -637,11 +637,11 @@ mnemon_do_challenges (mnemon_t *mnemon,
     int unlearned;
     int i;
 
-    /* Count the number of items with negative counts. */
+    /* Count the number of items with negative scores. */
     unlearned = 0;
     for (i = 0; i < mnemon->num_bins; i++) {
        bin = &mnemon->bins[i];
-       if (bin->count >= 0)
+       if (bin->score >= 0)
            break;
        unlearned += bin->num_items;
     }
@@ -663,7 +663,7 @@ mnemon_do_challenges (mnemon_t *mnemon,
     do {
        mnemon_select_item (mnemon, &bin, &item_index);
 
-       if (bin->count == 0)
+       if (bin->score == 0)
            to_introduce--;
 
        item = bin->items[item_index];
@@ -682,39 +682,39 @@ mnemon_do_challenges (mnemon_t *mnemon,
 
        /* If the bin is now empty, we must remove it. Also if we just
         * picked the last word we'll ever pick from the bin with
-        * count 0, then we can remove that as well. */
+        * score 0, then we can remove that as well. */
        if (bin->num_items == 0 ||
-           (bin->count == 0 && to_introduce == 0))
+           (bin->score == 0 && to_introduce == 0))
        {
            mnemon_remove_bin (mnemon, bin);
        }
 
        if (correct) {
-           item->count++;
-           /* We reserve an item count of 0 for an item that has
+           item->score++;
+           /* We reserve an item score of 0 for an item that has
             * never been asked. */
-           if (item->count == 0) {
-               item->count = 1;
+           if (item->score == 0) {
+               item->score = 1;
                unlearned--;
                printf ("You got it!");
-           } else if (item->count < 0) {
+           } else if (item->score < 0) {
                printf ("Yes---just give me %d more.",
-                       - item->count);
-           } else if (item->count == 1) {
+                       - item->score);
+           } else if (item->score == 1) {
                printf ("On your first try, no less!");
            } else {
-               printf ("Masterful (%dx).", item->count);
+               printf ("Masterful (%dx).", item->score);
            }
        } else {
            printf ("  %s is the correct answer.",
                    item->response);
-           if (item->count >= 0)
+           if (item->score >= 0)
                unlearned++;
-           item->count--;
-           /* Penalize an incorrect response by forcing the count
+           item->score--;
+           /* Penalize an incorrect response by forcing the score
             * negative. */
-           if (item->count >= 0) {
-               item->count = -1;
+           if (item->score >= 0) {
+               item->score = -1;
                printf ( " Oops, you knew that, right?\n ");
            }
        }
@@ -730,7 +730,7 @@ mnemon_do_challenges (mnemon_t *mnemon,
            printf ("Great job!");
        printf (")\n\n");
 
-       bin = mnemon_get_bin (mnemon, item->count);
+       bin = mnemon_get_bin (mnemon, item->score);
 
        bin_add_item (bin, item);
     } while (unlearned || to_introduce);