Style, comments.

Author: evoskuil

include/bitcoin/database/impl/primitives/arrayhead.ipp

@@ -41,9 +41,8 @@ inline size_t CLASS::size() const NOEXCEPT
 TEMPLATE
 inline size_t CLASS::buckets() const NOEXCEPT
 {
-    const auto count = position_to_link(size()).value;
-    BC_ASSERT(count < Link::terminal);
-    return system::possible_narrow_cast<size_t>(count);
+    using namespace system;
+    return possible_narrow_cast<size_t>(position_to_link(size()).value);
 }
 
 TEMPLATE
@@ -99,7 +98,7 @@ TEMPLATE
 bool CLASS::get_body_count(Link& count) const NOEXCEPT
 {
     const auto ptr = file_.get();
-    if (!ptr || size_ > size())
+    if (!ptr || bucket_size > size())
         return false;
 
     count = to_array<Link::size>(ptr->data());
@@ -110,7 +109,7 @@ TEMPLATE
 bool CLASS::set_body_count(const Link& count) NOEXCEPT
 {
     const auto ptr = file_.get();
-    if (!ptr || size_ > size())
+    if (!ptr || bucket_size > size())
         return false;
 
     // If head is padded then last bytes are fill (0xff).
@@ -135,13 +134,13 @@ Link CLASS::at(size_t key) const NOEXCEPT
         // Reads full padded word.
         const auto raw = ptr->data();
         // xcode clang++16 does not support C++20 std::atomic_ref.
-        ////const std::atomic_ref<integer> head(unsafe_byte_cast<integer>(raw));
-        const auto& head = *pointer_cast<std::atomic<integer>>(raw);
+        ////const std::atomic_ref<Link::integer> head(unsafe_byte_cast<Link::integer>(raw));
+        const auto& head = *pointer_cast<std::atomic<Link::integer>>(raw);
         return head.load(std::memory_order_relaxed);
     }
     else
     {
-        const auto& head = to_array<size_>(ptr->data());
+        const auto& head = to_array<bucket_size>(ptr->data());
         mutex_.lock_shared();
         const auto top = head;
         mutex_.unlock_shared();
@@ -156,7 +155,7 @@ bool CLASS::push(const Link& link, const Link& index) NOEXCEPT
     constexpr auto fill = bit_all<uint8_t>;
 
     // Allocate as necessary and fill allocations.
-    const auto ptr = file_.set(link_to_position(index), size_, fill);
+    const auto ptr = file_.set(link_to_position(index), bucket_size, fill);
     if (is_null(ptr))
         return false;
 
@@ -165,14 +164,14 @@ bool CLASS::push(const Link& link, const Link& index) NOEXCEPT
         // Writes full padded word (0x00 fill).
         const auto raw = ptr->data();
         // xcode clang++16 does not support C++20 std::atomic_ref.
-        ////const std::atomic_ref<integer> head(unsafe_byte_cast<integer>(raw));
-        auto& head = *pointer_cast<std::atomic<integer>>(raw);
+        ////const std::atomic_ref<Link::integer> head(unsafe_byte_cast<Link::integer>(raw));
+        auto& head = *pointer_cast<std::atomic<Link::integer>>(raw);
         head.store(link, std::memory_order_relaxed);
     }
     else
     {
         bytes current = link;
-        auto& head = to_array<size_>(ptr->data());
+        auto& head = to_array<bucket_size>(ptr->data());
 
         mutex_.lock();
         head = std::move(current);

include/bitcoin/database/impl/primitives/arraymap.ipp

@@ -149,21 +149,21 @@ inline Link CLASS::at(size_t key) const NOEXCEPT
 }
 
 TEMPLATE
-template <typename Element, if_equal<Element::size, Size>>
+ELEMENT_CONSTRAINT
 inline bool CLASS::at(size_t key, Element& element) const NOEXCEPT
 {
     return get(at(key), element);
 }
 
 TEMPLATE
-template <typename Element, if_equal<Element::size, Size>>
+ELEMENT_CONSTRAINT
 inline bool CLASS::get(const Link& link, Element& element) const NOEXCEPT
 {
     return read(body_.get(), link, element);
 }
 
 TEMPLATE
-template <typename Element, if_equal<Element::size, Size>>
+ELEMENT_CONSTRAINT
 bool CLASS::put(size_t key, const Element& element) NOEXCEPT
 {
     using namespace system;
@@ -176,15 +176,16 @@ bool CLASS::put(size_t key, const Element& element) NOEXCEPT
     iostream stream{ *ptr };
     finalizer sink{ stream };
 
-    if constexpr (!is_slab) { BC_DEBUG_ONLY(sink.set_limit(Size * element.count());) }
+    if constexpr (!is_slab) { BC_DEBUG_ONLY(sink.set_limit(RowSize * element.count());) }
     return element.to_data(sink) && head_.push(link, head_.index(key));
 }
 
 // protected
 // ----------------------------------------------------------------------------
 
+// static
 TEMPLATE
-template <typename Element, if_equal<Element::size, Size>>
+ELEMENT_CONSTRAINT
 bool CLASS::read(const memory_ptr& ptr, const Link& link,
     Element& element) NOEXCEPT
 {
@@ -209,7 +210,7 @@ bool CLASS::read(const memory_ptr& ptr, const Link& link,
     iostream stream{ offset, size - position };
     reader source{ stream };
 
-    if constexpr (!is_slab) { BC_DEBUG_ONLY(source.set_limit(Size * element.count());) }
+    if constexpr (!is_slab) { BC_DEBUG_ONLY(source.set_limit(RowSize * element.count());) }
     return element.from_data(source);
 }
 

include/bitcoin/database/impl/primitives/hashhead.ipp

@@ -35,6 +35,7 @@ CLASS::hashhead(storage& head, size_t bits) NOEXCEPT
     buckets_(system::power2<bucket_integer>(bits)),
     mask_(system::unmask_right<bucket_integer>(bits))
 {
+    BC_ASSERT_MSG(mask_ < max_size_t, "insufficient domain");
 }
 
 TEMPLATE
@@ -107,9 +108,6 @@ TEMPLATE
 inline Link CLASS::index(const Key& key) const NOEXCEPT
 {
     using namespace system;
-    BC_ASSERT_MSG(mask_ < max_size_t, "insufficient domain");
-    BC_ASSERT_MSG(is_nonzero(buckets_), "hash table requires buckets");
-
     const auto index = possible_narrow_cast<bucket_integer>(keys::hash<Key>(key));
     return bit_and<bucket_integer>(mask_, index);
 }

include/bitcoin/database/impl/primitives/hashmap.ipp

@@ -292,7 +292,7 @@ bool CLASS::set(const memory_ptr& ptr, const Link& link, const Key& key,
     finalizer sink{ stream };
     sink.skip_bytes(index_size);
 
-    if constexpr (!is_slab) { BC_DEBUG_ONLY(sink.set_limit(Size * element.count());) }
+    if constexpr (!is_slab) { BC_DEBUG_ONLY(sink.set_limit(RowSize * element.count());) }
     return element.to_data(sink);
 }
 
@@ -507,7 +507,7 @@ bool CLASS::write(const memory_ptr& ptr, const Link& link, const Key& key,
     keys::write(sink, key);
 
     // Commit element to body and search (terminal is a valid bucket index).
-    if constexpr (!is_slab) { BC_DEBUG_ONLY(sink.set_limit(Size * element.count());) }
+    if constexpr (!is_slab) { BC_DEBUG_ONLY(sink.set_limit(RowSize * element.count());) }
     auto& next = unsafe_array_cast<uint8_t, Link::size>(offset);
     return element.to_data(sink) && head_.push(link, next, head_.index(key));
 }

include/bitcoin/database/impl/query/archive_write.ipp

@@ -147,12 +147,12 @@ code CLASS::set_code(const tx_link& tx_fk, const transaction& tx) NOEXCEPT
         if (!store_.point.expand(ins_fk + inputs))
             return error::tx_point_allocate;
 
-        // This must be set after tx.set and before tx.commit, since searchable and
-        // produces an association to tx.link, and is also an integral part of tx.
-        const auto ptr = store_.point.get_memory();
-
         // Collect duplicates to store in duplicate table.
         std::vector<chain::cref_point> twins{};
+        const auto ptr = store_.point.get_memory();
+
+        // This must be set after tx.set and before tx.commit, since searchable and
+        // produces an association to tx.link, and is also an integral part of tx.
         for (const auto& in: *ins)
         {
             ///////////////////////////////////////////////////////////////////

include/bitcoin/database/primitives/arrayhead.hpp

@@ -30,7 +30,7 @@ namespace database {
 
 /// Dynamically expanding array map header.
 /// Less efficient than a fixed-size header.
-template <typename Link, bool Align>
+template <class Link, bool Align>
 class arrayhead
 {
 public:
@@ -71,12 +71,11 @@ class arrayhead
     bool push(const Link& link, const Link& index) NOEXCEPT;
 
 private:
-    using integer = Link::integer;
-    static_assert(std::atomic<integer>::is_always_lock_free);
-    static constexpr auto size_ = Align ? sizeof(integer) : Link::size;
-
-    // Body does not use padded link size.
     using body = manager<Link, system::data_array<zero>, Link::size>;
+    static_assert(std::atomic<Link::integer>::is_always_lock_free);
+    static_assert(is_nonzero(Link::size));
+    static constexpr auto bucket_size = Align ? sizeof(Link::integer) :
+        Link::size;
 
     template <size_t Bytes>
     static inline auto& to_array(memory::iterator it) NOEXCEPT
@@ -87,19 +86,19 @@ class arrayhead
     static constexpr Link position_to_link(size_t position) NOEXCEPT
     {
         using namespace system;
-        static_assert(is_nonzero(size_));
-        const auto link = floored_subtract(position / size_, one);
-        return possible_narrow_cast<integer>(link);
+        const auto offset = floored_divide(position, bucket_size);
+        const auto link = floored_subtract(offset, one);
+        return possible_narrow_cast<Link::integer>(link);
     }
 
     // Byte offset of bucket index within head file.
     // [body_size][[bucket[0]...bucket[buckets-1]]]
     static constexpr size_t link_to_position(const Link& index) NOEXCEPT
     {
         using namespace system;
-        BC_ASSERT(!is_multiply_overflow<size_t>(index, size_));
-        BC_ASSERT(!is_add_overflow(size_, index * size_));
-        return possible_narrow_cast<size_t>(size_ + index * size_);
+        BC_ASSERT(!is_multiply_overflow<size_t>(index, bucket_size));
+        BC_ASSERT(!is_add_overflow(bucket_size, index * bucket_size));
+        return possible_narrow_cast<size_t>(add1(index) * bucket_size);
     }
 
     // These are thread safe.
@@ -111,7 +110,7 @@ class arrayhead
 } // namespace database
 } // namespace libbitcoin
 
-#define TEMPLATE template <typename Link, bool Align>
+#define TEMPLATE template <class Link, bool Align>
 #define CLASS arrayhead<Link, Align>
 
 #include <bitcoin/database/impl/primitives/arrayhead.ipp>

include/bitcoin/database/primitives/arraymap.hpp

@@ -35,7 +35,7 @@ namespace database {
 /// Readers and writers are always prepositioned at data, and are limited to
 /// the extent the record/slab size is known (limit can always be removed).
 /// Streams are always initialized from first element byte up to file limit.
-template <typename Link, size_t Size, bool Align>
+template <class Link, size_t RowSize, bool Align>
 class arraymap
 {
 public:
@@ -95,29 +95,28 @@ class arraymap
     inline Link at(size_t key) const NOEXCEPT;
 
     /// Get first element matching key, false if not found/error (unverified).
-    template <typename Element, if_equal<Element::size, Size> = true>
+    template <typename Element, if_equal<Element::size, RowSize> = true>
     inline bool at(size_t key, Element& element) const NOEXCEPT;
 
     /// Get element at link, false if deserialize error.
-    template <typename Element, if_equal<Element::size, Size> = true>
+    template <typename Element, if_equal<Element::size, RowSize> = true>
     inline bool get(const Link& link, Element& element) const NOEXCEPT;
 
     /// Allocate, set, commit element to key.
     /// Expands table AND HEADER as necessary.
-    template <typename Element, if_equal<Element::size, Size> = true>
+    template <typename Element, if_equal<Element::size, RowSize> = true>
     bool put(size_t key, const Element& element) NOEXCEPT;
 
 protected:
     /// Get element at link using memory object, false if deserialize error.
-    template <typename Element, if_equal<Element::size, Size> = true>
+    template <typename Element, if_equal<Element::size, RowSize> = true>
     static bool read(const memory_ptr& ptr, const Link& link,
         Element& element) NOEXCEPT;
 
 private:
-    static constexpr auto is_slab = (Size == max_size_t);
-
+    static constexpr auto is_slab = (RowSize == max_size_t);
     using head = database::arrayhead<Link, Align>;
-    using body = database::manager<Link, system::data_array<0>, Size>;
+    using body = database::manager<Link, system::data_array<0>, RowSize>;
 
     // Thread safe (index/top/push).
     // Not thread safe (create/open/close/backup/restore).
@@ -133,8 +132,10 @@ using array_map = arraymap<linkage<Element::pk>, Element::size, Element::align>;
 } // namespace database
 } // namespace libbitcoin
 
-#define TEMPLATE template <typename Link, size_t Size, bool Align>
-#define CLASS arraymap<Link, Size, Align>
+#define TEMPLATE template <class Link, size_t RowSize, bool Align>
+#define CLASS arraymap<Link, RowSize, Align>
+#define ELEMENT_CONSTRAINT template <class Element, \
+    if_equal<Element::size, RowSize>>
 
 #include <bitcoin/database/impl/primitives/arraymap.ipp>
 

include/bitcoin/database/primitives/hashhead.hpp

@@ -75,9 +75,10 @@ class hashhead
     using bucket_integer = Link::integer;
     using cell_integer = unsigned_type<CellSize>;
     static_assert(std::atomic<cell_integer>::is_always_lock_free);
-    static constexpr auto aligned = (CellSize == sizeof(cell_integer));
+    static_assert(is_nonzero(Link::size));
     static constexpr auto bucket_size = Link::size;
     static constexpr auto filter_size = CellSize - bucket_size;
+    static constexpr auto aligned = (CellSize == sizeof(cell_integer));
 
     template <size_t Bytes>
     static inline auto& to_array(memory::iterator it) NOEXCEPT
@@ -91,8 +92,8 @@ class hashhead
     {
         using namespace system;
         BC_ASSERT(!is_multiply_overflow<size_t>(index, CellSize));
-        BC_ASSERT(!is_add_overflow(size_, index * CellSize));
-        return possible_narrow_cast<size_t>(CellSize + index * CellSize);
+        BC_ASSERT(!is_add_overflow(CellSize, index * CellSize));
+        return possible_narrow_cast<size_t>(add1(index) * CellSize);
     }
 
     // These are thread safe.

include/bitcoin/database/primitives/iterator.hpp

@@ -41,7 +41,7 @@ namespace database {
 
 /// This class is not thread safe.
 /// Size non-max implies record manager (ordinal record links).
-template <typename Link, typename Key, size_t Size = max_size_t>
+template <class Link, class Key, size_t Size = max_size_t>
 class iterator
 {
 public:
@@ -93,7 +93,7 @@ class iterator
 } // namespace libbitcoin
 
 #define TEMPLATE \
-template <typename Link, typename Key, size_t Size>
+template <class Link, class Key, size_t Size>
 #define CLASS iterator<Link, Key, Size>
 
 #include <bitcoin/database/impl/primitives/iterator.ipp>

include/bitcoin/database/primitives/keys.hpp

@@ -25,7 +25,7 @@ namespace libbitcoin {
 namespace database {
 namespace keys {
 
-template <typename Key>
+template <class Key>
 constexpr size_t size() NOEXCEPT
 {
     if constexpr (is_same_type<Key, system::chain::point>)
@@ -39,7 +39,7 @@ constexpr size_t size() NOEXCEPT
     }
 }
 
-template <typename Key>
+template <class Key>
 inline size_t hash(const Key& value) NOEXCEPT
 {
     if constexpr (is_same_type<Key, system::chain::point>)
@@ -56,7 +56,7 @@ inline size_t hash(const Key& value) NOEXCEPT
     }
 }
 
-template <typename Key>
+template <class Key>
 inline void write(writer& sink, const Key& key) NOEXCEPT
 {
     if constexpr (is_same_type<Key, system::chain::point>)
@@ -70,7 +70,7 @@ inline void write(writer& sink, const Key& key) NOEXCEPT
     }
 }
 
-template <typename Array, typename Key>
+template <class Array, class Key>
 inline bool compare(const Array& bytes, const Key& key) NOEXCEPT
 {
     using namespace system;