IndexSet.hpp

Collection of indices, ideally optimized for memory size.

Note

Status: ALPHA

class IndexRange
#include <IndexSet.hpp>

Index range is a simple pair of values indicating the start and end of a series of indices.

Public Functions

IndexRange() = default
inline IndexRange(size_t val)
inline IndexRange(size_t _start, size_t _end)
IndexRange(const IndexRange&) = default
IndexRange &operator=(const IndexRange&) = default
auto operator<=>(const IndexRange&) const = default
inline size_t GetStart() const
inline size_t GetEnd() const
inline size_t GetSize() const
inline void SetStart(size_t in)
inline void SetEnd(size_t in)
inline bool Has(size_t val) const
inline bool Has(IndexRange in) const
inline bool IsConnected(IndexRange in) const

Will identify if two ranges are next to each other or overlapping.

inline void Grow(size_t count = 1)

Grow this range (default, by one)

inline bool Insert(size_t val)

Insert a value into a range if valid; return false if not.

inline bool Append(IndexRange in)

Extend the current range with a new one. Must be perfectly adjacent!

inline bool Expand(size_t val)

Expand this range to encompass a provided value.

Parameters:

val – Value to expand through.

Returns:

Whether the range has changed due to this expansion.

template<typename ...Ts>
inline bool Expand(size_t val1, size_t val2, Ts... args)

Expand this range to encompass all provided values.

Parameters:

vals – Values to expand through

Returns:

Whether the range has changed due to this expansion.

inline bool Merge(IndexRange in)

Merge this range with another. Must be adjacent or overlap!

Private Members

size_t start = 0
size_t end = 0
class IndexRangeSet
#include <IndexSet.hpp>

IndexRanges is a class to maintain a series of ranges of indexes. The ranges will always be kept sorted and non-adjacent (i.e., there will always be at least one index missing between two ranges).

Public Functions

IndexRangeSet() = default
IndexRangeSet(const IndexRangeSet&) = default
IndexRangeSet(IndexRangeSet&&) = default
IndexRangeSet &operator=(const IndexRangeSet&) = default
IndexRangeSet &operator=(IndexRangeSet&&) = default
inline bool Has(size_t val) const
inline size_t GetStart() const
inline size_t GetEnd() const
inline size_t GetNumRanges() const
inline size_t GetSize() const

Calculate the total combined size of all ranges.

inline const vector<IndexRange> &GetRanges() &
inline bool Append(size_t val)

Add a new value that belongs at the end of the sets.

Parameters:

val – Value to add

Returns:

Did the append work? If it’s not at the end, returns false.

inline bool Append(IndexRange in)

Add an entire range that belongs at the end of the sets.

Parameters:

val – Range to add

Returns:

Did the append work? If it’s not at the end, returns false.

inline bool Insert(size_t val)

Insert a value into this range set.

Parameters:

val – Value to insert.

Returns:

Was there a change due to this insertion (or was it already there?)

inline bool Insert(IndexRange in)

Insert a whole range into this set, merging other ranges as needed.

Parameters:

in – New range to include.

Returns:

Was there a change due to this insertion (or were they already there?)

inline bool Remove(size_t val)

Remove a single value from this index range.

Parameters:

val – Value to remove

Returns:

Did the range change due to this removal?

Private Functions

inline size_t _FindRange(size_t val) const
inline void _GrowRange(size_t id)

Private Members

vector<IndexRange> range_set
class IndexBits
#include <IndexSet.hpp>

A class to maintain a set of indices with a bit vector to represent them.

Public Functions

IndexBits() = default
IndexBits(const IndexBits&) = default
IndexBits(IndexBits&&) = default
inline IndexBits(size_t min_val, size_t max_val)
IndexBits &operator=(const IndexBits&) = default
IndexBits &operator=(IndexBits&&) = default
inline bool Has(size_t val) const
inline size_t GetStart() const
inline size_t GetEnd() const
inline size_t GetNumRanges() const
inline size_t GetSize() const
inline bool Insert(size_t val)
inline bool Insert(IndexRange in)
inline bool Remove(size_t val)

Private Functions

inline size_t _CalcOffset(size_t val) const
inline void _ExpandRange(size_t val)

Increase the range of valid values.

Parameters:

val – Value to make sure can be set.

Private Members

BitVector bits
size_t offset = 0
class IndexSet
#include <IndexSet.hpp>

IndexSet maintains a collection of indices that can be easily manipulated. It will try to adjust representation to maintain speed and memory efficiency.

Public Functions

IndexSet() = default
inline ~IndexSet()
inline size_t GetSize() const
inline bool Has(size_t id) const
inline size_t GetMin() const
inline size_t GetMax() const
inline bool IsConsecutive() const
inline void Set(size_t id)

Public Members

_Index_Vals vals
IndexRangeSet ranges
IndexBits bits

Public Static Attributes

static constexpr const size_t npos = static_cast<size_t>(-1)

Private Types

enum class index_t

Values:

enumerator NONE
enumerator VALS1
enumerator VALS2
enumerator VALS3
enumerator RANGES
enumerator BITS

Private Functions

inline void _ReleaseUnion()

Free whatever type we currently have.

inline void _ToBits()

Convert the internal representation to use bits.

inline void _ToRanges()

Convert the internal representation to use a ranges.

Private Members

union IndexSet::[anonymous] [anonymous]
index_t type = index_t::NONE
struct _Index_Vals

Public Members

size_t id1
size_t id2
size_t id3