1 files changed, 155 insertions, 180 deletions

diff --git a/include/framework/interface/Record.h b/include/framework/interface/Record.h
index 19ccadd..d3e77d8 100644
--- a/include/framework/interface/Record.h
+++ b/include/framework/interface/Record.h
@@ -1,272 +1,247 @@
 /*
  * include/framework/interface/Record.h
  *
- * Copyright (C) 2023 Douglas Rumbaugh <drumbaugh@psu.edu>
+ * Copyright (C) 2023-2024 Douglas Rumbaugh <drumbaugh@psu.edu>
  *
  * Distributed under the Modified BSD License.
  *
- * FIXME: the record implementations could probably be broken out into 
+ * FIXME: the record implementations could probably be broken out into
  *        different files, leaving only the interface here
  */
 #pragma once
 
-#include <cstring>
-#include <concepts>
 #include <cmath>
+#include <concepts>
+#include <cstring>
 
 #include "psu-util/hash.h"
 
 namespace de {
 
-template<typename R>
+template <typename R>
 concept RecordInterface = requires(R r, R s) {
-    { r < s } ->std::convertible_to<bool>;
-    { r == s } ->std::convertible_to<bool>;
+  { r < s } -> std::convertible_to<bool>;
+  { r == s } -> std::convertible_to<bool>;
 };
 
-template<typename R>
+template <typename R>
 concept WeightedRecordInterface = requires(R r) {
-    {r.weight} -> std::convertible_to<double>;
+  { r.weight } -> std::convertible_to<double>;
 };
 
-template<typename R>
+template <typename R>
 concept NDRecordInterface = RecordInterface<R> && requires(R r, R s) {
-    {r.calc_distance(s)} -> std::convertible_to<double>;
+  { r.calc_distance(s) } -> std::convertible_to<double>;
 };
 
 template <typename R>
 concept KVPInterface = RecordInterface<R> && requires(R r) {
-    r.key;
-    r.value;
+  r.key;
+  r.value;
 };
 
-template<typename R>
+template <typename R>
 concept AlexInterface = KVPInterface<R> && requires(R r) {
-    {r.key} -> std::convertible_to<size_t>;
-    {r.value} -> std::convertible_to<size_t>;
+  { r.key } -> std::convertible_to<size_t>;
+  { r.value } -> std::convertible_to<size_t>;
 };
 
-template<typename R>
-concept WrappedInterface = RecordInterface<R> && requires(R r, R s, bool b, int i) {
-    {r.header} -> std::convertible_to<uint32_t>;
-     r.rec;
-    {r.set_delete()};
-    {r.is_deleted()} -> std::convertible_to<bool>;
-    {r.set_tombstone(b)};
-    {r.is_tombstone()} -> std::convertible_to<bool>;
-    {r.set_timestamp(i)};
-    {r.get_timestamp()} -> std::convertible_to<uint32_t>;
-    {r.clear_timestamp()};
-    {r.is_visible()} -> std::convertible_to<bool>;
-    {r.set_visible()};
-    {r < s} -> std::convertible_to<bool>;
-    {r == s} ->std::convertible_to<bool>;
+template <typename R>
+concept WrappedInterface = RecordInterface<R> &&
+    requires(R r, R s, bool b, int i) {
+  { r.header } -> std::convertible_to<uint32_t>;
+  r.rec;
+  {r.set_delete()};
+  { r.is_deleted() } -> std::convertible_to<bool>;
+  {r.set_tombstone(b)};
+  { r.is_tombstone() } -> std::convertible_to<bool>;
+  {r.set_timestamp(i)};
+  { r.get_timestamp() } -> std::convertible_to<uint32_t>;
+  {r.clear_timestamp()};
+  { r.is_visible() } -> std::convertible_to<bool>;
+  {r.set_visible()};
+  { r < s } -> std::convertible_to<bool>;
+  { r == s } -> std::convertible_to<bool>;
 };
 
-template<RecordInterface R>
-struct Wrapped {
-    uint32_t header;
-    R rec;
+template <RecordInterface R> struct Wrapped {
+  uint32_t header;
+  R rec;
 
-    inline void set_delete() {
-        header |= 2;
-    }
+  inline void set_delete() { header |= 2; }
 
-    inline bool is_deleted() const {
-        return header & 2;
-    }
+  inline bool is_deleted() const { return header & 2; }
 
-    inline void set_visible() {
-        header |= 4;
-    }
+  inline void set_visible() { header |= 4; }
 
-    inline bool is_visible() const {
-        return header & 4;
-    }
+  inline bool is_visible() const { return header & 4; }
 
-    inline void set_timestamp(int ts) {
-        header |= (ts << 3);
-    }
-
-    inline int get_timestamp() const {
-        return header >> 3;
-    }
+  inline void set_timestamp(int ts) { header |= (ts << 3); }
 
-    inline void clear_timestamp() {
-        header &= 7;
-    }
+  inline int get_timestamp() const { return header >> 3; }
 
-    inline void set_tombstone(bool val=true) {
-        if (val) {
-            header |= 1;
-        } else {
-            header &= 0;
-        }
-    }
+  inline void clear_timestamp() { header &= 7; }
 
-    inline bool is_tombstone() const {
-        return header & 1;
+  inline void set_tombstone(bool val = true) {
+    if (val) {
+      header |= 1;
+    } else {
+      header &= 0;
     }
+  }
 
-    inline bool operator<(const Wrapped& other) const {
-        return rec < other.rec || (rec == other.rec && header < other.header);
-    }
+  inline bool is_tombstone() const { return header & 1; }
 
-    inline bool operator==(const Wrapped& other) const {
-        return rec == other.rec;
-    }
+  inline bool operator<(const Wrapped &other) const {
+    return rec < other.rec || (rec == other.rec && header < other.header);
+  }
 
+  inline bool operator==(const Wrapped &other) const {
+    return rec == other.rec;
+  }
 };
 
-template <typename K, typename V>
-struct Record {
-    K key;
-    V value;
+template <typename K, typename V> struct Record {
+  K key;
+  V value;
 
-    inline bool operator<(const Record& other) const {
-        return key < other.key || (key == other.key && value < other.value);
-    }
+  inline bool operator<(const Record &other) const {
+    return key < other.key || (key == other.key && value < other.value);
+  }
 
-    inline bool operator==(const Record& other) const {
-        return key == other.key && value == other.value;
-    }
+  inline bool operator==(const Record &other) const {
+    return key == other.key && value == other.value;
+  }
 };
 
-template<typename V>
-struct Record<const char*, V> {
-    const char* key;
-    V value;
-    size_t len;
+template <typename V> struct Record<const char *, V> {
+  const char *key;
+  V value;
+  size_t len;
 
-    inline bool operator<(const Record& other) const {
-        size_t n = std::min(len, other.len) + 1;
-        return strncmp(key, other.key, n) < 0;
-    }
+  inline bool operator<(const Record &other) const {
+    size_t n = std::min(len, other.len) + 1;
+    return strncmp(key, other.key, n) < 0;
+  }
 
-    inline bool operator==(const Record& other) const {
-        size_t n = std::min(len, other.len) + 1;
-        return strncmp(key, other.key, n) == 0;
-    }
+  inline bool operator==(const Record &other) const {
+    size_t n = std::min(len, other.len) + 1;
+    return strncmp(key, other.key, n) == 0;
+  }
 };
 
-template <typename K, typename V, typename W>
-struct WeightedRecord {
-    K key;
-    V value;
-    W weight = 1;
+template <typename K, typename V, typename W> struct WeightedRecord {
+  K key;
+  V value;
+  W weight = 1;
 
-    inline bool operator==(const WeightedRecord& other) const {
-        return key == other.key && value == other.value;
-    }
+  inline bool operator==(const WeightedRecord &other) const {
+    return key == other.key && value == other.value;
+  }
 
-   inline bool operator<(const WeightedRecord& other) const {
-        return key < other.key || (key == other.key && value < other.value);
-    }
+  inline bool operator<(const WeightedRecord &other) const {
+    return key < other.key || (key == other.key && value < other.value);
+  }
 };
 
+template <typename V, size_t D = 2> struct CosinePoint {
+  V data[D];
 
-template <typename V, size_t D=2>
-struct CosinePoint{
-    V data[D];
-
-    inline bool operator==(const CosinePoint& other) const {
-        for (size_t i=0; i<D; i++) {
-            if (data[i] != other.data[i]) {
-                return false;
-            }
-        }
-
-        return true;
+  inline bool operator==(const CosinePoint &other) const {
+    for (size_t i = 0; i < D; i++) {
+      if (data[i] != other.data[i]) {
+        return false;
+      }
     }
 
-    /* lexicographic order */
-    inline bool operator<(const CosinePoint& other) const {
-        for (size_t i=0; i<D; i++) {
-            if (data[i] < other.data[i]) {
-                return true;
-            } else if (data[i] > other.data[i]) {
-                return false;
-            }
-        }
+    return true;
+  }
 
+  /* lexicographic order */
+  inline bool operator<(const CosinePoint &other) const {
+    for (size_t i = 0; i < D; i++) {
+      if (data[i] < other.data[i]) {
+        return true;
+      } else if (data[i] > other.data[i]) {
         return false;
+      }
     }
 
-    inline double calc_distance(const CosinePoint& other) const {
+    return false;
+  }
 
-        double prod = 0;
-        double asquared = 0;
-        double bsquared = 0;
+  inline double calc_distance(const CosinePoint &other) const {
 
-        for (size_t i=0; i<D; i++) {
-            prod += data[i] * other.data[i];
-            asquared += data[i]*data[i];
-            bsquared += other.data[i]*other.data[i];
-        }
+    double prod = 0;
+    double asquared = 0;
+    double bsquared = 0;
 
-        return prod / std::sqrt(asquared * bsquared);
+    for (size_t i = 0; i < D; i++) {
+      prod += data[i] * other.data[i];
+      asquared += data[i] * data[i];
+      bsquared += other.data[i] * other.data[i];
     }
+
+    return prod / std::sqrt(asquared * bsquared);
+  }
 };
 
+template <typename V, size_t D = 2> struct EuclidPoint {
+  V data[D];
 
-template <typename V, size_t D=2>
-struct EuclidPoint{
-    V data[D];
+  inline bool operator==(const EuclidPoint &other) const {
+    for (size_t i = 0; i < D; i++) {
+      if (data[i] != other.data[i]) {
+        return false;
+      }
+    }
 
-    inline bool operator==(const EuclidPoint& other) const {
-        for (size_t i=0; i<D; i++) {
-            if (data[i] != other.data[i]) {
-                return false;
-            }
-        }
+    return true;
+  }
 
+  /* lexicographic order */
+  inline bool operator<(const EuclidPoint &other) const {
+    for (size_t i = 0; i < D; i++) {
+      if (data[i] < other.data[i]) {
         return true;
+      } else if (data[i] > other.data[i]) {
+        return false;
+      }
     }
 
-    /* lexicographic order */
-    inline bool operator<(const EuclidPoint& other) const {
-        for (size_t i=0; i<D; i++) {
-            if (data[i] < other.data[i]) {
-                return true;
-            } else if (data[i] > other.data[i]) {
-                return false;
-            }
-        }
+    return false;
+  }
 
-        return false;
+  inline double calc_distance(const EuclidPoint &other) const {
+    double dist = 0;
+    for (size_t i = 0; i < D; i++) {
+      dist += (data[i] - other.data[i]) * (data[i] - other.data[i]);
     }
 
-    inline double calc_distance(const EuclidPoint& other) const {
-        double dist = 0;
-        for (size_t i=0; i<D; i++) {
-            dist += (data[i] - other.data[i]) * (data[i] - other.data[i]);
-        }
-        
-        return std::sqrt(dist);
-    }
+    return std::sqrt(dist);
+  }
 };
 
-template<RecordInterface R>
-struct RecordHash {
-    size_t operator()(R const &rec) const {
-        return psudb::hash_bytes((std::byte *) &rec, sizeof(R));
-    }
+template <RecordInterface R> struct RecordHash {
+  size_t operator()(R const &rec) const {
+    return psudb::hash_bytes((std::byte *)&rec, sizeof(R));
+  }
 };
 
-template <typename R>
-class DistCmpMax {
+template <typename R> class DistCmpMax {
 public:
-    DistCmpMax(R *baseline) : P(baseline) {}
+  DistCmpMax(R *baseline) : P(baseline) {}
 
-    inline bool operator()(const R *a, const R *b) requires WrappedInterface<R> {
-        return a->rec.calc_distance(P->rec) > b->rec.calc_distance(P->rec); 
-    }
+  inline bool operator()(const R *a, const R *b) requires WrappedInterface<R> {
+    return a->rec.calc_distance(P->rec) > b->rec.calc_distance(P->rec);
+  }
 
-    inline bool operator()(const R *a, const R *b) requires (!WrappedInterface<R>){
-        return a->calc_distance(*P) > b->calc_distance(*P); 
-    }
+  inline bool operator()(const R *a,
+                         const R *b) requires(!WrappedInterface<R>) {
+    return a->calc_distance(*P) > b->calc_distance(*P);
+  }
 
 private:
-    R *P;
+  R *P;
 };
-}
+} // namespace de