libvgcode::BitSet< T > Struct Template Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libvgcode/src/Bitset.hpp>

Collaboration diagram for libvgcode::BitSet< T >:

Public Member Functions
	BitSet ()=default
	BitSet (std::size_t size)
void	clear ()
void	setAll ()
bool	set (std::size_t index)
bool	reset (std::size_t index)
bool	operator[] (std::size_t index) const
template<typename U>
BitSet &	operator&= (const BitSet< U > &other)
template<typename U = T>
std::enable_if< is_atomic< U >, bool >::type	set_atomic (std::size_t index)
template<typename U = T>
std::enable_if< is_atomic< U >, bool >::type	reset_atomic (std::size_t index)
std::pair< std::size_t, std::size_t >	get_coords (std::size_t index) const
std::size_t	size_in_bytes_cpu () const

Public Attributes
std::size_t	size { 0 }
std::vector< T >	blocks { 0 }

Detailed Description

template<typename T = unsigned long long>
struct libvgcode::BitSet< T >

Constructor & Destructor Documentation

BitSet() [1/2]

template<typename T = unsigned long long>

libvgcode::BitSet< T >::BitSet ( )

default

Referenced by operator&=().

Here is the caller graph for this function:

BitSet() [2/2]

template<typename T = unsigned long long>

libvgcode::BitSet< T >::BitSet ( std::size_t size )

inline

: size(size), blocks(1 + (size / (sizeof(T) * 8))) { clear(); }

References blocks, clear(), and size.

Here is the call graph for this function:

Member Function Documentation

clear()

template<typename T = unsigned long long>

void libvgcode::BitSet< T >::clear ( )

inline

                 {
        for (std::size_t i = 0; i < blocks.size(); ++i) {
            blocks[i] &= T(0);
        }
    }

References blocks.

Referenced by BitSet().

Here is the caller graph for this function:

get_coords()

template<typename T = unsigned long long>

std::pair< std::size_t, std::size_t > libvgcode::BitSet< T >::get_coords ( std::size_t index ) const

inline

                                                                    {
        const std::size_t block_idx = index / (sizeof(T) * 8);
        const std::size_t bit_idx = index % (sizeof(T) * 8);
        return { block_idx, bit_idx };
    }

Referenced by operator[](), reset(), reset_atomic(), set(), and set_atomic().

Here is the caller graph for this function:

operator&=()

template<typename T = unsigned long long>

template<typename U>

BitSet & libvgcode::BitSet< T >::operator&= ( const BitSet< U > & other )

inline

                                                 {
        static_assert(sizeof(T) == sizeof(U), "Type1 and Type2 must be of the same size.");
        for (std::size_t i = 0; i < blocks.size(); ++i) {
            blocks[i] &= other.blocks[i];
        }
        return *this;
    }

References BitSet(), and blocks.

Here is the call graph for this function:

operator[]()

template<typename T = unsigned long long>

bool libvgcode::BitSet< T >::operator[] ( std::size_t index ) const

inline

                                             {
        const auto [block_idx, bit_idx] = get_coords(index);
        return ((blocks[block_idx] >> bit_idx) & 1) != 0;
    }

References blocks, and get_coords().

Here is the call graph for this function:

reset()

template<typename T = unsigned long long>

bool libvgcode::BitSet< T >::reset ( std::size_t index )

inline

                                {
        const auto [block_idx, bit_idx] = get_coords(index);
        const T mask = (T(1) << bit_idx);
        const bool flip = mask ^ blocks[block_idx];
        blocks[block_idx] &= (~mask);
        return flip;
    }

References blocks, and get_coords().

Here is the call graph for this function:

reset_atomic()

template<typename T = unsigned long long>

template<typename U = T>

std::enable_if< is_atomic< U >, bool >::type libvgcode::BitSet< T >::reset_atomic ( std::size_t index )

inline

                                                                                       {
        const auto [block_idx, bit_idx] = get_coords(index);
        const T mask = ~(static_cast<T>(1) << bit_idx);
        const T oldval = blocks[block_idx].fetch_and(mask, std::memory_order_relaxed);
        return oldval ^ (oldval and mask);
    }

References blocks, and get_coords().

Here is the call graph for this function:

set()

template<typename T = unsigned long long>

bool libvgcode::BitSet< T >::set ( std::size_t index )

inline

                              {
        const auto [block_idx, bit_idx] = get_coords(index);
        const T mask = (T(1) << bit_idx);
        bool flip = mask ^ blocks[block_idx];
        blocks[block_idx] |= mask;
        return flip;
    }

References blocks, and get_coords().

Here is the call graph for this function:

set_atomic()

template<typename T = unsigned long long>

template<typename U = T>

std::enable_if< is_atomic< U >, bool >::type libvgcode::BitSet< T >::set_atomic ( std::size_t index )

inline

                                                                                     {
        const auto [block_idx, bit_idx] = get_coords(index);
        const T mask = static_cast<T>(1) << bit_idx;
        const T oldval = blocks[block_idx].fetch_or(mask, std::memory_order_relaxed);
        return oldval ^ (oldval or mask);
    }

References blocks, and get_coords().

Here is the call graph for this function:

setAll()

template<typename T = unsigned long long>

void libvgcode::BitSet< T >::setAll ( )

inline

                  {
        for (std::size_t i = 0; i < blocks.size(); ++i) {
            blocks[i] |= ~T(0);
        }
    }

References blocks.

size_in_bytes_cpu()

template<typename T = unsigned long long>

std::size_t libvgcode::BitSet< T >::size_in_bytes_cpu ( ) const

inline

                                        {
        return blocks.size() * sizeof(T);
    }

References blocks.

Member Data Documentation

blocks

template<typename T = unsigned long long>

std::vector<T> libvgcode::BitSet< T >::blocks { 0 }

{ 0 };

Referenced by BitSet(), clear(), operator&=(), operator[](), reset(), reset_atomic(), set(), set_atomic(), setAll(), and size_in_bytes_cpu().

size

template<typename T = unsigned long long>

std::size_t libvgcode::BitSet< T >::size { 0 }

{ 0 };

Referenced by BitSet().

---

The documentation for this struct was generated from the following file:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libvgcode/src/Bitset.hpp