TrinityCore
Loading...
Searching...
No Matches
UpdateMask< Bits > Class Template Reference

#include <UpdateMask.h>

Public Member Functions

 UpdateMask ()
 
 UpdateMask (std::initializer_list< uint32 > init)
 
uint32 GetBlocksMask (uint32 index) const
 
uint32 GetBlock (uint32 index) const
 
bool operator[] (uint32 index) const
 
bool IsAnySet () const
 
void Reset (uint32 index)
 
void ResetAll ()
 
void Set (uint32 index)
 
void SetAll ()
 
UpdateMaskoperator&= (UpdateMask const &right)
 
UpdateMaskoperator|= (UpdateMask const &right)
 

Static Public Attributes

static constexpr uint32 BlockCount = (Bits + 31) / 32
 
static constexpr uint32 BlocksMaskCount = (BlockCount + 31) / 32
 

Private Member Functions

void InitFromBlocks (uint32 const *input, uint32 size)
 

Private Attributes

uint32 _blocksMask [BlocksMaskCount]
 
uint32 _blocks [BlockCount]
 

Detailed Description

template<uint32 Bits>
class UpdateMask< Bits >

Definition at line 31 of file UpdateMask.h.

Constructor & Destructor Documentation

◆ UpdateMask() [1/2]

template<uint32 Bits>
UpdateMask< Bits >::UpdateMask ( )
inline

Definition at line 37 of file UpdateMask.h.

38 {
39 std::fill(std::begin(_blocksMask), std::end(_blocksMask), 0);
40 std::fill(std::begin(_blocks), std::end(_blocks), 0);
41 }
uint32 _blocksMask[BlocksMaskCount]
Definition: UpdateMask.h:144
uint32 _blocks[BlockCount]
Definition: UpdateMask.h:145

◆ UpdateMask() [2/2]

template<uint32 Bits>
UpdateMask< Bits >::UpdateMask ( std::initializer_list< uint32 init)
inline

Definition at line 43 of file UpdateMask.h.

44 {
45 InitFromBlocks(init.begin(), init.size());
46 }
void InitFromBlocks(uint32 const *input, uint32 size)
Definition: UpdateMask.h:131
+ Here is the call graph for this function:

Member Function Documentation

◆ GetBlock()

template<uint32 Bits>
uint32 UpdateMask< Bits >::GetBlock ( uint32  index) const
inline

Definition at line 53 of file UpdateMask.h.

54 {
55 return _blocks[index];
56 }
+ Here is the caller graph for this function:

◆ GetBlocksMask()

template<uint32 Bits>
uint32 UpdateMask< Bits >::GetBlocksMask ( uint32  index) const
inline

Definition at line 48 of file UpdateMask.h.

49 {
50 return _blocksMask[index];
51 }
+ Here is the caller graph for this function:

◆ InitFromBlocks()

template<uint32 Bits>
void UpdateMask< Bits >::InitFromBlocks ( uint32 const *  input,
uint32  size 
)
inlineprivate

Definition at line 131 of file UpdateMask.h.

132 {
133 std::fill(std::begin(_blocksMask), std::end(_blocksMask), 0);
134
135 uint32 block = 0;
136 for (; block < size; ++block)
137 if ((_blocks[block] = input[block]) != 0)
139
140 for (; block < BlockCount; ++block)
141 _blocks[block] = 0;
142 }
uint32_t uint32
Definition: Define.h:143
static constexpr uint32 BlockCount
Definition: UpdateMask.h:34
constexpr std::size_t size()
Definition: UpdateField.h:786
constexpr std::size_t GetBlockIndex(std::size_t bit)
Definition: UpdateMask.h:26
constexpr uint32 GetBlockFlag(std::size_t bit)
Definition: UpdateMask.h:27
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ IsAnySet()

template<uint32 Bits>
bool UpdateMask< Bits >::IsAnySet ( ) const
inline

Definition at line 63 of file UpdateMask.h.

64 {
65 return std::any_of(std::begin(_blocksMask), std::end(_blocksMask), [](uint32 blockMask)
66 {
67 return blockMask != 0;
68 });
69 }
+ Here is the caller graph for this function:

◆ operator&=()

template<uint32 Bits>
UpdateMask & UpdateMask< Bits >::operator&= ( UpdateMask< Bits > const &  right)
inline

Definition at line 107 of file UpdateMask.h.

108 {
109 for (uint32 i = 0; i < BlocksMaskCount; ++i)
110 _blocksMask[i] &= right._blocksMask[i];
111
112 for (uint32 i = 0; i < BlockCount; ++i)
113 if (!(_blocks[i] &= right._blocks[i]))
115
116 return *this;
117 }
static constexpr uint32 BlocksMaskCount
Definition: UpdateMask.h:35
+ Here is the call graph for this function:

◆ operator[]()

template<uint32 Bits>
bool UpdateMask< Bits >::operator[] ( uint32  index) const
inline

Definition at line 58 of file UpdateMask.h.

59 {
60 return (_blocks[index / 32] & (1 << (index % 32))) != 0;
61 }

◆ operator|=()

template<uint32 Bits>
UpdateMask & UpdateMask< Bits >::operator|= ( UpdateMask< Bits > const &  right)
inline

Definition at line 119 of file UpdateMask.h.

120 {
121 for (std::size_t i = 0; i < BlocksMaskCount; ++i)
122 _blocksMask[i] |= right._blocksMask[i];
123
124 for (std::size_t i = 0; i < BlockCount; ++i)
125 _blocks[i] |= right._blocks[i];
126
127 return *this;
128 }

◆ Reset()

template<uint32 Bits>
void UpdateMask< Bits >::Reset ( uint32  index)
inline

Definition at line 71 of file UpdateMask.h.

72 {
73 std::size_t blockIndex = UpdateMaskHelpers::GetBlockIndex(index);
74 if (!(_blocks[blockIndex] &= ~UpdateMaskHelpers::GetBlockFlag(index)))
75 _blocksMask[UpdateMaskHelpers::GetBlockIndex(blockIndex)] &= ~UpdateMaskHelpers::GetBlockFlag(blockIndex);
76 }
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ ResetAll()

template<uint32 Bits>
void UpdateMask< Bits >::ResetAll ( )
inline

Definition at line 78 of file UpdateMask.h.

79 {
80 std::fill(std::begin(_blocksMask), std::end(_blocksMask), 0);
81 std::fill(std::begin(_blocks), std::end(_blocks), 0);
82 }
+ Here is the caller graph for this function:

◆ Set()

template<uint32 Bits>
void UpdateMask< Bits >::Set ( uint32  index)
inline

Definition at line 84 of file UpdateMask.h.

85 {
86 std::size_t blockIndex = UpdateMaskHelpers::GetBlockIndex(index);
87 _blocks[blockIndex] |= UpdateMaskHelpers::GetBlockFlag(index);
89 }
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ SetAll()

template<uint32 Bits>
void UpdateMask< Bits >::SetAll ( )
inline

Definition at line 91 of file UpdateMask.h.

92 {
93 std::fill(std::begin(_blocksMask), std::end(_blocksMask), 0xFFFFFFFF);
94 if (BlocksMaskCount % 32)
95 {
96 constexpr uint32 unused = 32 - (BlocksMaskCount % 32);
97 _blocksMask[BlocksMaskCount - 1] &= (0xFFFFFFFF >> unused);
98 }
99 std::fill(std::begin(_blocks), std::end(_blocks), 0xFFFFFFFF);
100 if (BlockCount % 32)
101 {
102 constexpr uint32 unused = 32 - (BlockCount % 32);
103 _blocks[BlockCount - 1] &= (0xFFFFFFFF >> unused);
104 }
105 }
+ Here is the caller graph for this function:

Member Data Documentation

◆ _blocks

template<uint32 Bits>
uint32 UpdateMask< Bits >::_blocks[BlockCount]
private

Definition at line 145 of file UpdateMask.h.

◆ _blocksMask

template<uint32 Bits>
uint32 UpdateMask< Bits >::_blocksMask[BlocksMaskCount]
private

Definition at line 144 of file UpdateMask.h.

◆ BlockCount

template<uint32 Bits>
constexpr uint32 UpdateMask< Bits >::BlockCount = (Bits + 31) / 32
staticconstexpr

Definition at line 34 of file UpdateMask.h.

◆ BlocksMaskCount

template<uint32 Bits>
constexpr uint32 UpdateMask< Bits >::BlocksMaskCount = (BlockCount + 31) / 32
staticconstexpr

Definition at line 35 of file UpdateMask.h.


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