Fix msvc warnings (#121)

Author: tzaeschke

include/phtree/common/b_plus_tree_hash_map.h

@@ -124,7 +124,7 @@ class b_plus_tree_hash_set {
         return *this;
     }
 
-    ~b_plus_tree_hash_set() {
+    ~b_plus_tree_hash_set() noexcept {
         delete root_;
     }
 

include/phtree/common/b_plus_tree_map.h

@@ -65,7 +65,7 @@ using namespace ::phtree::bptree::detail;
  *   merging by trying to reduce `dead space`
  *   (space between key1 and key2 that exceeds (key2 - key1)).
  */
-template <typename KeyT, typename ValueT, std::uint64_t COUNT_MAX>
+template <typename KeyT, typename ValueT, size_t COUNT_MAX>
 class b_plus_tree_map {
     static_assert(std::is_integral<KeyT>() && "Key type must be integer");
     static_assert(std::is_unsigned<KeyT>() && "Key type must unsigned");
@@ -127,7 +127,7 @@ class b_plus_tree_map {
         return *this;
     }
 
-    ~b_plus_tree_map() {
+    ~b_plus_tree_map() noexcept {
         delete root_;
     }
 

include/phtree/common/b_plus_tree_multimap.h

@@ -121,7 +121,7 @@ class b_plus_tree_multimap {
         return *this;
     }
 
-    ~b_plus_tree_multimap() {
+    ~b_plus_tree_multimap() noexcept {
         delete root_;
     }
 

include/phtree/common/common.h

@@ -49,7 +49,8 @@ namespace improbable::phtree {
  * an array.
  */
 template <dimension_t DIM, typename SCALAR>
-static hc_pos_64_t CalcPosInArray(const PhPoint<DIM, SCALAR>& valSet, bit_width_t postfix_len) {
+static hc_pos_dim_t<DIM> CalcPosInArray(
+    const PhPoint<DIM, SCALAR>& valSet, bit_width_t postfix_len) {
     // n=DIM,  i={0..n-1}
     // i = 0 :  |0|1|0|1|0|1|0|1|
     // i = 1 :  | 0 | 1 | 0 | 1 |
@@ -64,7 +65,7 @@ static hc_pos_64_t CalcPosInArray(const PhPoint<DIM, SCALAR>& valSet, bit_width_
         // set pos-bit if bit is set in value
         pos |= (valMask & valSet[i]) >> postfix_len;
     }
-    return pos;
+    return static_cast<hc_pos_dim_t<DIM>>(pos);
 }
 
 template <dimension_t DIM, typename SCALAR>

include/phtree/common/flat_array_map.h

@@ -31,42 +31,42 @@
  */
 namespace improbable::phtree {
 
-template <typename T, std::size_t SIZE>
+template <typename Key, typename Value, Key SIZE>
 class flat_array_map;
 
 namespace detail {
 
-template <typename T>
-using flat_map_pair = std::pair<size_t, T>;
+template <typename Key, typename Value>
+using flat_map_pair = std::pair<Key, Value>;
 
-template <typename T, std::size_t SIZE>
+template <typename Key, typename Value, Key SIZE>
 class flat_map_iterator {
-    friend flat_array_map<T, SIZE>;
+    friend flat_array_map<Key, Value, SIZE>;
 
   public:
     flat_map_iterator() : first{0}, map_{nullptr} {};
 
-    explicit flat_map_iterator(size_t index, const flat_array_map<T, SIZE>* map)
+    explicit flat_map_iterator(Key index, const flat_array_map<Key, Value, SIZE>* map)
     : first{index}, map_{map} {
         assert(index <= SIZE);
     }
 
     auto& operator*() const {
         assert(first < SIZE && map_->occupied(first));
-        return const_cast<flat_map_pair<T>&>(map_->data(first));
+        return const_cast<flat_map_pair<Key, Value>&>(map_->data(first));
     }
 
     auto* operator->() const {
         assert(first < SIZE && map_->occupied(first));
-        return const_cast<flat_map_pair<T>*>(&map_->data(first));
+        return const_cast<flat_map_pair<Key, Value>*>(&map_->data(first));
     }
 
-    auto& operator++() {
+    auto& operator++() noexcept {
         first = (first + 1) >= SIZE ? SIZE : map_->lower_bound_index(first + 1);
         return *this;
     }
 
-    auto operator++(int) {
+    auto operator++(int) noexcept {
         flat_map_iterator it(first, map_);
         ++(*this);
         return it;
@@ -81,8 +81,8 @@ class flat_map_iterator {
     }
 
   private:
-    size_t first;
-    const flat_array_map<T, SIZE>* map_;
+    Key first;
+    const flat_array_map<Key, Value, SIZE>* map_;
 };
 }  // namespace detail
 
@@ -93,49 +93,53 @@ class flat_map_iterator {
  * It has O(1) insertion/removal time complexity, but O(2^DIM) space complexity, so it is best used
  * when DIM is low and/or the map is known to have a high fill ratio.
  */
-template <typename T, std::size_t SIZE>
+template <typename Key, typename Value, Key SIZE>
 class flat_array_map {
-    using map_pair = detail::flat_map_pair<T>;
-    using iterator = detail::flat_map_iterator<T, SIZE>;
+    static_assert(std::is_integral<Key>() && "Key type must be integer");
+    static_assert(std::is_unsigned<Key>() && "Key type must unsigned");
+    using map_pair = detail::flat_map_pair<Key, Value>;
+    using iterator = detail::flat_map_iterator<Key, Value, SIZE>;
     friend iterator;
 
   public:
-    [[nodiscard]] auto find(size_t index) noexcept {
+    [[nodiscard]] auto find(Key index) noexcept {
         return iterator{occupied(index) ? index : SIZE, this};
     }
 
-    [[nodiscard]] auto lower_bound(size_t index) const {
-          return iterator{lower_bound_index(index), this};
+    [[nodiscard]] auto lower_bound(Key index) const noexcept {
+        return iterator{lower_bound_index(index), this};
     }
 
-    [[nodiscard]] auto begin() const {
-          return iterator{lower_bound_index(0), this};
+    [[nodiscard]] auto begin() const noexcept {
+        return iterator{lower_bound_index(0), this};
     }
 
-    [[nodiscard]] auto cbegin() const {
-          return iterator{lower_bound_index(0), this};
+    [[nodiscard]] auto cbegin() const noexcept {
+        return iterator{lower_bound_index(0), this};
     }
 
-    [[nodiscard]] auto end() const {
+    [[nodiscard]] auto end() const noexcept {
         return iterator{SIZE, this};
     }
 
     ~flat_array_map() noexcept {
         if (occupancy != 0) {
-            for (size_t i = 0; i < SIZE; ++i) {
+            for (Key i = 0; i < SIZE; ++i) {
                 if (occupied(i)) {
                     data(i).~pair();
                 }
             }
         }
     }
 
-    [[nodiscard]] size_t size() const {
-        return std::bitset<64>(occupancy).count();
+    [[nodiscard]] size_t size() const noexcept {
+        constexpr size_t BITS =
+            std::numeric_limits<Key>::digits + std::numeric_limits<Key>::is_signed;
+        return std::bitset<BITS>(occupancy).count();
     }
 
     template <typename... Args>
-    std::pair<map_pair*, bool> try_emplace(size_t index, Args&&... args) {
+    std::pair<map_pair*, bool> try_emplace(Key index, Args&&... args) {
         if (!occupied(index)) {
             new (reinterpret_cast<void*>(&data_[index])) map_pair(
                 std::piecewise_construct,
@@ -147,7 +151,7 @@ class flat_array_map {
         return {&data(index), false};
     }
 
-    bool erase(size_t index) {
+    bool erase(Key index) noexcept {
         if (occupied(index)) {
             data(index).~pair();
             unoccupy(index);
@@ -156,50 +160,50 @@ class flat_array_map {
         return false;
     }
 
-    bool erase(const iterator& iterator) {
+    bool erase(const iterator& iterator) noexcept {
         return erase(iterator.first);
     }
 
   private:
     /*
      * This returns the element at the given index, which is _not_ the n'th element (for n = index).
      */
-    map_pair& data(size_t index) {
+    map_pair& data(Key index) noexcept {
         assert(occupied(index));
         return *std::launder(reinterpret_cast<map_pair*>(&data_[index]));
     }
 
-    const map_pair& data(size_t index) const {
+    const map_pair& data(Key index) const noexcept {
         assert(occupied(index));
         return *std::launder(reinterpret_cast<const map_pair*>(&data_[index]));
     }
 
-    [[nodiscard]] size_t lower_bound_index(size_t index) const {
+    [[nodiscard]] Key lower_bound_index(Key index) const noexcept {
         assert(index < SIZE);
-        size_t num_zeros = CountTrailingZeros(occupancy >> index);
+        Key num_zeros = CountTrailingZeros(occupancy >> index);
         // num_zeros may be equal to SIZE if no bits remain
         return std::min(SIZE, index + num_zeros);
     }
 
-    void occupy(size_t index) {
+    void occupy(Key index) noexcept {
         assert(index < SIZE);
         assert(!occupied(index));
         // flip the bit
-        occupancy ^= (1ul << index);
+        occupancy ^= (Key{1} << index);
     }
 
-    void unoccupy(size_t index) {
+    void unoccupy(Key index) noexcept {
         assert(index < SIZE);
         assert(occupied(index));
         // flip the bit
-        occupancy ^= (1ul << index);
+        occupancy ^= (Key{1} << index);
     }
 
-    [[nodiscard]] bool occupied(size_t index) const {
-        return (occupancy >> index) & 1;
+    [[nodiscard]] bool occupied(Key index) const noexcept {
+        return (occupancy >> index) & Key{1};
     }
 
-    std::uint64_t occupancy = 0;
+    Key occupancy = 0;
     // We use an untyped array to avoid implicit calls to constructors and destructors of entries.
     std::aligned_storage_t<sizeof(map_pair), alignof(map_pair)> data_[SIZE];
 };
@@ -209,15 +213,15 @@ class flat_array_map {
  * This is useful to decouple instantiation of a node from instantiation of it's descendants
  * (the flat_array_map directly instantiates an array of descendants).
  */
-template <typename T, std::size_t SIZE>
+template <typename Key, typename Value, Key SIZE>
 class array_map {
     static_assert(SIZE <= 64);  // or else we need to adapt 'occupancy'
     static_assert(SIZE > 0);
-    using iterator = improbable::phtree::detail::flat_map_iterator<T, SIZE>;
+    using iterator = improbable::phtree::detail::flat_map_iterator<Key, Value, SIZE>;
 
   public:
     array_map() {
-        data_ = new flat_array_map<T, SIZE>();
+        data_ = new flat_array_map<Key, Value, SIZE>();
     }
 
     array_map(const array_map& other) = delete;
@@ -237,15 +241,15 @@ class array_map {
         delete data_;
     }
 
-    [[nodiscard]] auto find(size_t index) noexcept {
+    [[nodiscard]] auto find(Key index) noexcept {
         return data_->find(index);
     }
 
-    [[nodiscard]] auto find(size_t key) const noexcept {
+    [[nodiscard]] auto find(Key key) const noexcept {
         return const_cast<array_map&>(*this).find(key);
     }
 
-    [[nodiscard]] auto lower_bound(size_t index) const {
+    [[nodiscard]] auto lower_bound(Key index) const {
         return data_->lower_bound(index);
     }
 
@@ -267,17 +271,17 @@ class array_map {
     }
 
     template <typename... Args>
-    auto try_emplace(size_t index, Args&&... args) {
+    auto try_emplace(Key index, Args&&... args) {
         return data_->try_emplace(index, std::forward<Args>(args)...);
     }
 
     template <typename... Args>
-    auto try_emplace(const iterator&, size_t index, Args&&... args) {
+    auto try_emplace(const iterator&, Key index, Args&&... args) {
         // We ignore the iterator, this is an array based collection, so access is ~O(1).
         return data_->try_emplace(index, std::forward<Args>(args)...).first;
     }
 
-    bool erase(size_t index) {
+    bool erase(Key index) {
         return data_->erase(index);
     }
 
@@ -290,7 +294,7 @@ class array_map {
     }
 
   private:
-    flat_array_map<T, SIZE>* data_;
+    flat_array_map<Key, Value, SIZE>* data_;
 };
 
 }  // namespace improbable::phtree

include/phtree/common/flat_sparse_map.h

@@ -96,19 +96,19 @@ class sparse_map {
     }
 
     template <typename... Args>
-    auto emplace(size_t key, Args&&... args) {
+    auto emplace(KeyT key, Args&&... args) {
         auto iter = lower_bound(key);
         return try_emplace_base(iter, key, std::forward<Args>(args)...);
     }
 
     template <typename... Args>
-    auto try_emplace(size_t key, Args&&... args) {
+    auto try_emplace(KeyT key, Args&&... args) {
         auto iter = lower_bound(key);
         return try_emplace_base(iter, key, std::forward<Args>(args)...);
     }
 
     template <typename... Args>
-    auto try_emplace(iterator iter, size_t key, Args&&... args) {
+    auto try_emplace(iterator iter, KeyT key, Args&&... args) {
         return try_emplace_base(iter, key, std::forward<Args>(args)...).first;
     }
 

include/phtree/v16/node.h

@@ -43,11 +43,11 @@ template <dimension_t DIM, typename Entry>
 // using EntryMap = std::map<hc_pos_dim_t<DIM>, Entry>;
 using EntryMap = typename std::conditional_t<
     DIM <= 3,
-    array_map<Entry, (uint64_t(1) << DIM)>,
+    array_map<hc_pos_dim_t<DIM>, Entry, (size_t(1) << DIM)>,
     typename std::conditional_t<
         DIM <= 8,
         sparse_map<hc_pos_dim_t<DIM>, Entry>,
-        b_plus_tree_map<std::uint64_t, Entry, (uint64_t(1) << DIM)>>>;
+        b_plus_tree_map<hc_pos_dim_t<DIM>, Entry, (uint64_t(1) << DIM)>>>;
 
 template <dimension_t DIM, typename Entry>
 using EntryIterator = typename std::remove_const_t<decltype(EntryMap<DIM, Entry>().begin())>;
@@ -77,14 +77,14 @@ template <dimension_t DIM, typename T, typename SCALAR>
 class Node {
     using KeyT = PhPoint<DIM, SCALAR>;
     using EntryT = Entry<DIM, T, SCALAR>;
-    using hc_pos_t = hc_pos_64_t;
+    using hc_pos_t = hc_pos_dim_t<DIM>;
 
   public:
     Node() : entries_{} {}
 
     // Nodes should never be copied!
     Node(const Node&) = delete;
-    Node(Node&&) = default;
+    Node(Node&&) noexcept = default;
     Node& operator=(const Node&) = delete;
     Node& operator=(Node&&) = delete;