Cleaned up shard files (except VPTree)

Cleaned up shard implementations, fixed a few bugs, and set up some
tests. There's still some work to be done in creating tests for the
weighted sampling operations for the alias and aug btree shards.

1 files changed, 31 insertions, 29 deletions

diff --git a/tests/include/rangequery.h b/tests/include/rangequery.h
index dbb71db..a8a73f7 100644
--- a/tests/include/rangequery.h
+++ b/tests/include/rangequery.h
@@ -9,8 +9,8 @@
  * Distributed under the Modified BSD License.
  *
  * WARNING: This file must be included in the main unit test set
- *          after the definition of an appropriate Shard and Rec
- *          type. In particular, Rec needs to implement the key-value
+ *          after the definition of an appropriate Shard and R
+ *          type. In particular, R needs to implement the key-value
  *          pair interface and Shard needs to support lower_bound. 
  *          For other types of record and shard, you'll need to
  *          use a different set of unit tests.
@@ -29,21 +29,23 @@
 //#include "testing.h"
 //#include <check.h>
 //using namespace de;
-//typedef ISAMTree<Rec> Shard;
+//typedef ISAMTree<R> Shard;
+
+#include "query/rangequery.h"
 
 
 START_TEST(t_range_query)
 {
-    auto buffer = create_sequential_mbuffer<Rec>(100, 1000);
+    auto buffer = create_sequential_mbuffer<R>(100, 1000);
     auto shard = Shard(buffer->get_buffer_view());
 
-    rq::Parms<Rec> parms;
+    rq::Parms<R> parms;
     parms.lower_bound = 300;
     parms.upper_bound = 500;
 
-    auto state = rq::Query<Rec, Shard>::get_query_state(&shard, &parms);
-    auto result = rq::Query<Rec, Shard>::query(&shard, state, &parms);
-    rq::Query<Rec, Shard>::delete_query_state(state);
+    auto state = rq::Query<R, Shard>::get_query_state(&shard, &parms);
+    auto result = rq::Query<R, Shard>::query(&shard, state, &parms);
+    rq::Query<R, Shard>::delete_query_state(state);
 
     ck_assert_int_eq(result.size(), parms.upper_bound - parms.lower_bound + 1);
     for (size_t i=0; i<result.size(); i++) {
@@ -58,17 +60,17 @@ END_TEST
 
 START_TEST(t_buffer_range_query)
 {
-    auto buffer = create_sequential_mbuffer<Rec>(100, 1000);
+    auto buffer = create_sequential_mbuffer<R>(100, 1000);
 
-    rq::Parms<Rec> parms;
+    rq::Parms<R> parms;
     parms.lower_bound = 300;
     parms.upper_bound = 500;
 
     {
         auto view = buffer->get_buffer_view();
-        auto state = rq::Query<Rec, Shard>::get_buffer_query_state(&view, &parms);
-        auto result = rq::Query<Rec, Shard>::buffer_query(state, &parms);
-        rq::Query<Rec, Shard>::delete_buffer_query_state(state);
+        auto state = rq::Query<R, Shard>::get_buffer_query_state(&view, &parms);
+        auto result = rq::Query<R, Shard>::buffer_query(state, &parms);
+        rq::Query<R, Shard>::delete_buffer_query_state(state);
 
         ck_assert_int_eq(result.size(), parms.upper_bound - parms.lower_bound + 1);
         for (size_t i=0; i<result.size(); i++) {
@@ -84,40 +86,40 @@ END_TEST
 
 START_TEST(t_range_query_merge)
 {    
-    auto buffer1 = create_sequential_mbuffer<Rec>(100, 200);
-    auto buffer2 = create_sequential_mbuffer<Rec>(400, 1000);
+    auto buffer1 = create_sequential_mbuffer<R>(100, 200);
+    auto buffer2 = create_sequential_mbuffer<R>(400, 1000);
 
     auto shard1 = Shard(buffer1->get_buffer_view());
     auto shard2 = Shard(buffer2->get_buffer_view());
 
-    rq::Parms<Rec> parms;
+    rq::Parms<R> parms;
     parms.lower_bound = 150;
     parms.upper_bound = 500;
 
     size_t result_size = parms.upper_bound - parms.lower_bound + 1 - 200;
 
-    auto state1 = rq::Query<Rec, Shard>::get_query_state(&shard1, &parms);
-    auto state2 = rq::Query<Rec, Shard>::get_query_state(&shard2, &parms);
+    auto state1 = rq::Query<R, Shard>::get_query_state(&shard1, &parms);
+    auto state2 = rq::Query<R, Shard>::get_query_state(&shard2, &parms);
 
-    std::vector<std::vector<de::Wrapped<Rec>>> results(2);
-    results[0] = rq::Query<Rec, Shard>::query(&shard1, state1, &parms);
-    results[1] = rq::Query<Rec, Shard>::query(&shard2, state2, &parms);
+    std::vector<std::vector<de::Wrapped<R>>> results(2);
+    results[0] = rq::Query<R, Shard>::query(&shard1, state1, &parms);
+    results[1] = rq::Query<R, Shard>::query(&shard2, state2, &parms);
 
-    rq::Query<Rec, Shard>::delete_query_state(state1);
-    rq::Query<Rec, Shard>::delete_query_state(state2);
+    rq::Query<R, Shard>::delete_query_state(state1);
+    rq::Query<R, Shard>::delete_query_state(state2);
 
     ck_assert_int_eq(results[0].size() + results[1].size(), result_size);
 
-    std::vector<std::vector<Wrapped<Rec>>> proc_results;
+    std::vector<std::vector<Wrapped<R>>> proc_results;
 
     for (size_t j=0; j<results.size(); j++) {
-        proc_results.emplace_back(std::vector<Wrapped<Rec>>());
+        proc_results.emplace_back(std::vector<Wrapped<R>>());
         for (size_t i=0; i<results[j].size(); i++) {
             proc_results[j].emplace_back(results[j][i]);
         }
     }
 
-    auto result = rq::Query<Rec, Shard>::merge(proc_results, nullptr);
+    auto result = rq::Query<R, Shard>::merge(proc_results, nullptr);
     std::sort(result.begin(), result.end());
 
     ck_assert_int_eq(result.size(), result_size);
@@ -137,8 +139,8 @@ END_TEST
 
 START_TEST(t_lower_bound)
 {
-    auto buffer1 = create_sequential_mbuffer<Rec>(100, 200);
-    auto buffer2 = create_sequential_mbuffer<Rec>(400, 1000);
+    auto buffer1 = create_sequential_mbuffer<R>(100, 200);
+    auto buffer2 = create_sequential_mbuffer<R>(400, 1000);
 
     auto shard1 = new Shard(buffer1->get_buffer_view());
     auto shard2 = new Shard(buffer2->get_buffer_view());
@@ -148,7 +150,7 @@ START_TEST(t_lower_bound)
     auto merged = Shard(shards);
 
     for (size_t i=100; i<1000; i++) {
-        Rec r;
+        R r;
         r.key = i;
         r.value = i;