[bug-recutils] [PATCH 10/13] src: keep indexes in rsets.

[Michał Masłowski]

---
 ChangeLog      | 22 ++++++++++++++
 src/rec-db.c   | 91 ++++++++++++++++++++++++++++++++++++++++++++++++++++++----
 src/rec-rset.c | 81 +++++++++++++++++++++++++++++++++++++++++++++++++++
 src/rec.h      |  9 ++++++
 4 files changed, 197 insertions(+), 6 deletions(-)

diff --git a/ChangeLog b/ChangeLog
index f5360e1..78c97b3 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,27 @@
 2012-08-19  Michał Masłowski  <address@hidden>
 
+       src: keep indexes in rsets.
+       * src/rec-db.c (struct rec_db_s): Add the index_file_list member.
+       (rec_db_new): Initialize index_file_list.
+       (rec_db_destroy): Free index_file_list.
+       (rec_db_add_rsets_from_file): Keep index files and their objects
+       open, store indexes in rsets.
+       (rec_db_index_file_dispose_fn): New function.
+       * src/rec-rset.c (struct rec_rset_s): Add tree_type and index_mset
+       members.
+       (rec_rset_new): Initialize tree_type and index_mset.
+       (rec_rset_destroy): Free index_mset.
+       (rec_rset_dup): Copy index_mset.
+       (rec_rset_index_mset): New function.
+       (rec_rset_index_tree_disp_fn): Likewise.
+       (rec_rset_index_tree_equal_fn): Likewise.
+       (rec_rset_index_tree_dup_fn): Likewise.
+       (rec_rset_index_tree_compare_fn): Likewise.
+       * src/rec.h (MSET_INDEX_TREE): New constant.
+       (rec_rset_index_mset): Add prototype.
+
+2012-08-19  Michał Masłowski  <address@hidden>
+
        src,torture: support duplicating index tree objects.
        * src/rec-idx-tree.c (rec_idx_tree_dup): New function.
        * src/rec.h: Add prototype for rec_idx_tree_dup.
diff --git a/src/rec-db.c b/src/rec-db.c
index aa5eb27..96e8ae9 100644
--- a/src/rec-db.c
+++ b/src/rec-db.c
@@ -47,6 +47,7 @@ struct rec_db_s
 
   gl_list_t parser_list;          /* Parsers for lazy loaded rsets.  */
   gl_list_t file_list;            /* Files for lazy loaded rsets.  */
+  gl_list_t index_file_list;      /* Index files with indexes for rsets.  */
 };
 
 /* Static functions defined in this file.  */
@@ -56,6 +57,7 @@ static bool rec_db_rset_equals_fn (const void *elt1,
 static void rec_db_rset_dispose_fn (const void *elt);
 static void rec_db_parser_dispose_fn (const void *elt);
 static void rec_db_file_dispose_fn (const void *elt);
+static void rec_db_index_file_dispose_fn (const void *elt);
 
 static rec_record_t rec_db_process_fex (rec_db_t db,
                                         rec_rset_t rset,
@@ -108,9 +110,14 @@ rec_db_new (void)
                                                 NULL,
                                                 rec_db_file_dispose_fn,
                                                 true);
+      new->index_file_list = gl_list_nx_create_empty (GL_ARRAY_LIST,
+                                                      NULL,
+                                                      NULL,
+                                                      
rec_db_index_file_dispose_fn,
+                                                      true);
 
       if ((new->rset_list == NULL) || (new->parser_list == NULL)
-          || (new->file_list == NULL))
+          || (new->file_list == NULL) || (new->index_file_list == NULL))
         {
           /* Out of memory.  */
           if (new->rset_list)
@@ -125,6 +132,12 @@ rec_db_new (void)
             {
               gl_list_free (new->file_list);
             }
+
+          if (new->index_file_list)
+            {
+              gl_list_free (new->index_file_list);
+            }
+
           free (new);
           new = NULL;
         }
@@ -154,6 +167,7 @@ rec_db_destroy (rec_db_t db)
       gl_list_free (db->rset_list);
       gl_list_free (db->parser_list);
       gl_list_free (db->file_list);
+      gl_list_free (db->index_file_list);
       free (db);
     }
 }
@@ -314,7 +328,11 @@ rec_db_add_rsets_from_file (rec_db_t db,
   char *idx_name;
   bool no_index = false;
   int64_t time;
-  size_t size, num_rsets = 0, location, char_location, n = 0, old_size;
+  size_t size, num_rsets = 0, location, char_location, n = 0, old_size,
+    index_size;
+  uint8_t *index = NULL;
+  uint64_t index_type;
+  rec_idx_tree_t tree;
 
   res = true;
   old_size = rec_db_size (db);
@@ -398,6 +416,13 @@ rec_db_add_rsets_from_file (rec_db_t db,
             {
               res = false;
             }
+          else
+            {
+              if (gl_list_nx_add_last (db->file_list, idx) == NULL)
+                {
+                  res = false;
+                }
+            }
         }
     }
   else
@@ -412,13 +437,58 @@ rec_db_add_rsets_from_file (rec_db_t db,
           fclose (in);
         }
     }
-  /* Close the index file.  In future it will be kept open for
-     indices to be used.  */
+
+  if (!no_index)
+    {
+      /* Store indexes in record sets. */
+      while (res && ((index = (uint8_t *)
+                      rec_idx_file_index (idx_file,
+                                          (char *) index,
+                                          &index_type,
+                                          &index_size)) != NULL))
+        {
+          tree = rec_idx_tree_new (index, index_type, index_size);
+          if (tree == NULL)
+            {
+              /* Unsupported index, won't be added. */
+              continue;
+            }
+
+          rset =
+            rec_db_get_rset (db,
+                             old_size + rec_idx_tree_get_rset_number (tree));
+          if (!rset)
+            {
+              /* Invalid index. */
+              res = false;
+              rec_idx_tree_destroy (tree);
+              break;
+            }
+          else if (!rec_mset_append (rec_rset_index_mset (rset),
+                                     MSET_INDEX_TREE,
+                                     tree, MSET_ANY))
+            {
+              res = false;
+              rec_idx_tree_destroy (tree);
+              break;
+            }
+        }
+    }
+
+  /* Keep the index file or close on error.  */
   if (idx_file)
     {
-      rec_idx_file_destroy (idx_file);
+      if (res && (gl_list_nx_add_last (db->index_file_list, idx_file) == NULL))
+        {
+          res = false;
+        }
+
+      if (!res)
+        {
+          rec_idx_file_destroy (idx_file);
+        }
     }
-  if (idx)
+  if (!res && idx)
     {
       fclose (idx);
     }
@@ -1973,4 +2043,13 @@ rec_db_file_dispose_fn (const void *elt)
   fclose (file);
 }
 
+static void
+rec_db_index_file_dispose_fn (const void *elt)
+{
+  rec_idx_file_t index_file;
+
+  index_file = (rec_idx_file_t) elt;
+  rec_idx_file_destroy (index_file);
+}
+
 /* End of rec-db.c */
diff --git a/src/rec-rset.c b/src/rec-rset.c
index fa5eeaa..c0af516 100644
--- a/src/rec-rset.c
+++ b/src/rec-rset.c
@@ -116,6 +116,10 @@ struct rec_rset_s
      infinite loops result from it requesting to finish the parsing
      again.  */
   bool finishing;
+
+  /* Storage for record set indexes. */
+  int index_tree_type;
+  rec_mset_t index_mset;
 };
 
 /* Static functions implemented below.  */
@@ -168,6 +172,11 @@ static int rec_rset_compare_typed_records (rec_rset_t rset,
                                            
 static bool rec_rset_finish_parsing (rec_rset_t rset);
 
+static void rec_rset_index_tree_disp_fn (void *data);
+static bool rec_rset_index_tree_equal_fn (void *data1, void *data2);
+static void *rec_rset_index_tree_dup_fn (void *data);
+static int rec_rset_index_tree_compare_fn (void *data1, void *data2, int 
type2);
+
 /* The following macro is used by some functions to reduce
    verbosity.  */
 
@@ -227,6 +236,26 @@ rec_rset_new (void)
                                                        
rec_rset_comment_equal_fn,
                                                        rec_rset_comment_dup_fn,
                                                        
rec_rset_comment_compare_fn);
+
+          /* Create the index mset and register its types. */
+          rset->index_mset = rec_mset_new ();
+          if (rset->index_mset)
+            {
+              rset->index_tree_type =
+                rec_mset_register_type (rset->index_mset,
+                                        "index tree",
+                                        rec_rset_index_tree_disp_fn,
+                                        rec_rset_index_tree_equal_fn,
+                                        rec_rset_index_tree_dup_fn,
+                                        rec_rset_index_tree_compare_fn);
+            }
+          else
+            {
+              /* Out of memory.  */
+
+              rec_rset_destroy (rset);
+              rset = NULL;
+            }
         }
       else
         {
@@ -266,6 +295,7 @@ rec_rset_destroy (rec_rset_t rset)
 
       rec_fex_destroy (rset->order_by_fields);
 
+      rec_mset_destroy (rset->index_mset);
       rec_mset_destroy (rset->mset);
       free (rset);
     }
@@ -316,6 +346,14 @@ rec_rset_dup (rec_rset_t rset)
       rec_rset_destroy (new);
       return NULL;
     }
+
+  new->index_mset = rec_mset_dup (rset->index_mset);
+  if (!new->index_mset)
+    {
+      /* Out of memory.  */
+      rec_rset_destroy (new);
+      return NULL;
+    }
   
   return new;
 }
@@ -1027,6 +1065,12 @@ rec_rset_store_parser (rec_rset_t rset,
   rset->parser_line = line;
 }
 
+rec_mset_t
+rec_rset_index_mset (rec_rset_t rset)
+{
+  return rset->index_mset;
+}
+
 /*
  * Private functions
  */
@@ -1889,4 +1933,41 @@ rec_rset_finish_parsing (rec_rset_t rset)
     }
 }
 
+static void
+rec_rset_index_tree_disp_fn (void *data)
+{
+  rec_idx_tree_destroy ((rec_idx_tree_t) data);
+}
+
+static bool
+rec_rset_index_tree_equal_fn (void *data1, void *data2)
+{
+  return data1 == data2;
+}
+
+static void *
+rec_rset_index_tree_dup_fn (void *data)
+{
+  return rec_idx_tree_dup ((rec_idx_tree_t) data);
+}
+
+static int
+rec_rset_index_tree_compare_fn (void *data1, void *data2, int type2)
+{
+  /* Index trees cannot be compared, just compare pointers. */
+  if (data1 == data2)
+    {
+      return 0;
+    }
+  else if (data1 < data2)
+    {
+      return -1;
+    }
+  else
+    {
+      return 1;
+    }
+}
+
+
 /* End of rec-rset.c */
diff --git a/src/rec.h b/src/rec.h
index e71005e..223c09a 100644
--- a/src/rec.h
+++ b/src/rec.h
@@ -1041,6 +1041,10 @@ typedef struct rec_rset_s *rec_rset_t;
 
 #define MSET_RECORD 1
 
+/* Record set index mset types. */
+
+#define MSET_INDEX_TREE 1
+
 /* Opaque data type representing a parser.  */
 
 typedef struct rec_parser_s *rec_parser_t;
@@ -1129,6 +1133,11 @@ size_t rec_rset_char_location (rec_rset_t rset);
 
 void rec_rset_set_char_location (rec_rset_t rset, size_t char_location);
 
+/* Return the multi-set containing the indexes of the given record
+   set.  */
+
+rec_mset_t rec_rset_index_mset (rec_rset_t rset);
+
 /***************** Record descriptor management ******************/
 
 /* Return the record descriptor of a given record set.  NULL is
-- 
1.7.11.4