ryan/libdpf
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Annotate noexcept and constexpr with HEDLEY, and add interval containment, ChaCha, and the dyadic range tables.

Browse source 
Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
Ryan Henry 2026-09-24 20:44:07 -06:00
parent 875f09fec1
commit 0d8a5a8131
97 changed files with 9212 additions and 1159 deletions
Download patch file Download diff file Expand all files Collapse all files

79
include/dpf/packed_array.hpp
View file

@ -50,15 +50,18 @@ class dynamic_packed_array
class lane_ref
{
public:
HEDLEY_NO_THROW
lane_ref(word_type * word, unsigned shift) noexcept
: word_{word}, shift_{shift} {}
HEDLEY_NO_THROW
HEDLEY_ALWAYS_INLINE
operator LaneT() const noexcept
{
return static_cast<LaneT>((*word_ >> shift_) & lane_mask);
}
HEDLEY_NO_THROW
HEDLEY_ALWAYS_INLINE
lane_ref & operator=(LaneT value) noexcept
{
@ -69,23 +72,28 @@ class dynamic_packed_array
return *this;
}
HEDLEY_NO_THROW
lane_ref & operator=(const lane_ref & other) noexcept
{
return (*this = static_cast<LaneT>(other));
}
HEDLEY_NO_THROW
friend bool operator==(lane_ref lhs, LaneT rhs) noexcept
{
return static_cast<LaneT>(lhs) == rhs;
}
HEDLEY_NO_THROW
friend bool operator==(LaneT lhs, lane_ref rhs) noexcept
{
return rhs == lhs;
}
HEDLEY_NO_THROW
friend bool operator!=(lane_ref lhs, LaneT rhs) noexcept
{
return !(lhs == rhs);
}
HEDLEY_NO_THROW
friend bool operator!=(LaneT lhs, lane_ref rhs) noexcept
{
return !(rhs == lhs);
@ -108,25 +116,33 @@ class dynamic_packed_array
using pointer = void;
using reference = lane_ref;
HEDLEY_NO_THROW
iterator() noexcept = default;
HEDLEY_NO_THROW
iterator(word_type * data, size_type index) noexcept
: data_{data}, index_{index} {}
HEDLEY_NO_THROW
lane_ref operator*() const noexcept { return ref_at(index_); }
HEDLEY_NO_THROW
lane_ref operator[](difference_type n) const noexcept
{
return ref_at(static_cast<size_type>(
static_cast<difference_type>(index_) + n));
}
HEDLEY_NO_THROW
iterator & operator++() noexcept { ++index_; return *this; }
HEDLEY_NO_THROW
iterator operator++(int) noexcept
{
iterator prev = *this;
++*this;
return prev;
}
HEDLEY_NO_THROW
iterator & operator--() noexcept { --index_; return *this; }
HEDLEY_NO_THROW
iterator operator--(int) noexcept
{
iterator prev = *this;
@ -134,53 +150,66 @@ class dynamic_packed_array
return prev;
}
HEDLEY_NO_THROW
iterator & operator+=(difference_type n) noexcept
{
index_ = static_cast<size_type>(
static_cast<difference_type>(index_) + n);
return *this;
}
HEDLEY_NO_THROW
iterator & operator-=(difference_type n) noexcept
{
return *this += -n;
}
HEDLEY_NO_THROW
friend iterator operator+(iterator it, difference_type n) noexcept
{
it += n;
return it;
}
HEDLEY_NO_THROW
friend iterator operator+(difference_type n, iterator it) noexcept
{
return it + n;
}
HEDLEY_NO_THROW
friend iterator operator-(iterator it, difference_type n) noexcept
{
it -= n;
return it;
}
HEDLEY_NO_THROW
friend difference_type operator-(iterator a, iterator b) noexcept
{
return static_cast<difference_type>(a.index_)
- static_cast<difference_type>(b.index_);
}
HEDLEY_NO_THROW
friend bool operator==(iterator a, iterator b) noexcept
{
return a.index_ == b.index_;
}
HEDLEY_NO_THROW
friend bool operator!=(iterator a, iterator b) noexcept
{
return !(a == b);
}
HEDLEY_NO_THROW
friend bool operator<(iterator a, iterator b) noexcept
{
return a.index_ < b.index_;
}
HEDLEY_NO_THROW
friend bool operator>(iterator a, iterator b) noexcept { return b < a; }
HEDLEY_NO_THROW
friend bool operator<=(iterator a, iterator b) noexcept { return !(b < a); }
HEDLEY_NO_THROW
friend bool operator>=(iterator a, iterator b) noexcept { return !(a < b); }
private:
HEDLEY_NO_THROW
lane_ref ref_at(size_type index) const noexcept
{
const size_type bit = index * lane_bits;
@ -213,12 +242,14 @@ class dynamic_packed_array
dynamic_packed_array(const dynamic_packed_array &) = delete;
dynamic_packed_array & operator=(const dynamic_packed_array &) = delete;
HEDLEY_NO_THROW
dynamic_packed_array(dynamic_packed_array && other) noexcept
: nlanes_{std::exchange(other.nlanes_, 0)},
nwords_{std::exchange(other.nwords_, 0)},
data_{std::move(other.data_)}
{}
HEDLEY_NO_THROW
dynamic_packed_array & operator=(dynamic_packed_array && other) noexcept
{
if (this != &other)
@ -232,13 +263,19 @@ class dynamic_packed_array
~dynamic_packed_array() = default;
HEDLEY_NO_THROW
size_type size() const noexcept { return nlanes_; }
HEDLEY_NO_THROW
bool empty() const noexcept { return nlanes_ == 0; }
HEDLEY_NO_THROW
size_type data_length() const noexcept { return nwords_; }
HEDLEY_NO_THROW
word_type * data() noexcept { return data_.get(); }
HEDLEY_NO_THROW
const word_type * data() const noexcept { return data_.get(); }
HEDLEY_NO_THROW
LaneT operator[](size_type i) const noexcept
{
assert(i < nlanes_);
@ -247,6 +284,7 @@ class dynamic_packed_array
return static_cast<LaneT>((data_[bit / 64u] >> shift) & lane_mask);
}
HEDLEY_NO_THROW
lane_ref operator[](size_type i) noexcept
{
assert(i < nlanes_);
@ -255,11 +293,17 @@ class dynamic_packed_array
static_cast<unsigned>(bit % 64u));
}
HEDLEY_NO_THROW
iterator begin() noexcept { return iterator{data(), 0}; }
HEDLEY_NO_THROW
iterator end() noexcept { return iterator{data(), nlanes_}; }
HEDLEY_NO_THROW
iterator begin() const noexcept { return iterator{data_.get(), 0}; }
HEDLEY_NO_THROW
iterator end() const noexcept { return iterator{data_.get(), nlanes_}; }
HEDLEY_NO_THROW
iterator cbegin() const noexcept { return begin(); }
HEDLEY_NO_THROW
iterator cend() const noexcept { return end(); }
private:
@ -284,25 +328,30 @@ class packed_share_output : public dynamic_packed_array<LaneT>
class reference
{
public:
HEDLEY_NO_THROW
explicit reference(typename lanes::reference lane) noexcept : lane_{lane} {}
HEDLEY_NO_THROW
operator share_type() const noexcept
{
return share_type::from_raw(static_cast<LaneT>(lane_));
}
HEDLEY_NO_THROW
reference & operator=(const share_type & share) noexcept
{
lane_ = share.raw();
return *this;
}
HEDLEY_NO_THROW
reference & operator=(LaneT value) noexcept
{
lane_ = value;
return *this;
}
HEDLEY_NO_THROW
reference & operator=(const reference & other) noexcept
{
return (*this = static_cast<share_type>(other));
@ -321,48 +370,68 @@ class packed_share_output : public dynamic_packed_array<LaneT>
using pointer = void;
using reference = share_type;
HEDLEY_NO_THROW
iterator() noexcept = default;
HEDLEY_NO_THROW
explicit iterator(typename lanes::iterator it) noexcept : it_{it} {}
HEDLEY_NO_THROW
share_type operator*() const noexcept
{
return share_type::from_raw(static_cast<LaneT>(*it_));
}
HEDLEY_NO_THROW
share_type operator[](difference_type n) const noexcept
{
return share_type::from_raw(static_cast<LaneT>(it_[n]));
}
HEDLEY_NO_THROW
iterator & operator++() noexcept { ++it_; return *this; }
HEDLEY_NO_THROW
iterator operator++(int) noexcept { iterator p = *this; ++*this; return p; }
HEDLEY_NO_THROW
iterator & operator--() noexcept { --it_; return *this; }
HEDLEY_NO_THROW
iterator operator--(int) noexcept { iterator p = *this; --*this; return p; }
HEDLEY_NO_THROW
iterator & operator+=(difference_type n) noexcept { it_ += n; return *this; }
HEDLEY_NO_THROW
iterator & operator-=(difference_type n) noexcept { it_ -= n; return *this; }
HEDLEY_NO_THROW
friend iterator operator+(iterator it, difference_type n) noexcept
{
it += n;
return it;
}
HEDLEY_NO_THROW
friend iterator operator+(difference_type n, iterator it) noexcept
{
return it + n;
}
HEDLEY_NO_THROW
friend iterator operator-(iterator it, difference_type n) noexcept
{
it -= n;
return it;
}
HEDLEY_NO_THROW
friend difference_type operator-(iterator a, iterator b) noexcept
{
return a.it_ - b.it_;
}
HEDLEY_NO_THROW
friend bool operator==(iterator a, iterator b) noexcept { return a.it_ == b.it_; }
HEDLEY_NO_THROW
friend bool operator!=(iterator a, iterator b) noexcept { return !(a == b); }
HEDLEY_NO_THROW
friend bool operator<(iterator a, iterator b) noexcept { return a.it_ < b.it_; }
HEDLEY_NO_THROW
friend bool operator>(iterator a, iterator b) noexcept { return b < a; }
HEDLEY_NO_THROW
friend bool operator<=(iterator a, iterator b) noexcept { return !(b < a); }
HEDLEY_NO_THROW
friend bool operator>=(iterator a, iterator b) noexcept { return !(a < b); }
private:
@ -375,7 +444,9 @@ class packed_share_output : public dynamic_packed_array<LaneT>
packed_share_output(const packed_share_output &) = delete;
packed_share_output & operator=(const packed_share_output &) = delete;
HEDLEY_NO_THROW
packed_share_output(packed_share_output &&) noexcept = default;
HEDLEY_NO_THROW
packed_share_output & operator=(packed_share_output &&) noexcept = default;
~packed_share_output() = default;
@ -383,26 +454,34 @@ class packed_share_output : public dynamic_packed_array<LaneT>
using lanes::empty;
using lanes::size;
HEDLEY_NO_THROW
reference operator[](size_type i) noexcept
{
return reference{lanes::operator[](i)};
}
HEDLEY_NO_THROW
share_type operator[](size_type i) const noexcept
{
return share_type::from_raw(lanes::operator[](i));
}
HEDLEY_NO_THROW
iterator begin() noexcept { return iterator{lanes::begin()}; }
HEDLEY_NO_THROW
iterator end() noexcept { return iterator{lanes::end()}; }
HEDLEY_NO_THROW
iterator begin() const noexcept
{
return iterator{typename lanes::iterator{this->data(), 0}};
}
HEDLEY_NO_THROW
iterator end() const noexcept
{
return iterator{typename lanes::iterator{this->data(), this->size()}};
}
HEDLEY_NO_THROW
iterator cbegin() const noexcept { return begin(); }
HEDLEY_NO_THROW
iterator cend() const noexcept { return end(); }
};