blob: 8fc07768b7ae1d70ac56b602bddd00106cd6b257 [file] [log] [blame]
Ben Tynera8126fd2019-08-01 19:40:07 -05001/** @file hei_bit_string.cpp
2 * @brief BitString and BitStringBuffer class definitions
3 */
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -05004
Ben Tynera8126fd2019-08-01 19:40:07 -05005#include <hei_user_defines.hpp>
Zane Shelleyca9f6252019-10-25 21:17:30 -05006#include <util/hei_bit_string.hpp>
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -05007
8#include <algorithm>
9
Zane Shelley871adec2019-07-30 11:01:39 -050010namespace libhei
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -050011{
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -050012
13//##############################################################################
14// BitString class
15//##############################################################################
16
Ben Tynera8126fd2019-08-01 19:40:07 -050017// number of bits in a uint64_t
Ben Tyner7c796052020-02-03 19:00:37 -060018const uint64_t BitString::UINT64_BIT_LEN = sizeof(uint64_t) * 8;
Ben Tynera8126fd2019-08-01 19:40:07 -050019// number of bits in a uint8_t
Ben Tyner7c796052020-02-03 19:00:37 -060020const uint64_t BitString::UINT8_BIT_LEN = sizeof(uint8_t) * 8;
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -050021
22//------------------------------------------------------------------------------
23
Zane Shelley83da2452019-10-25 15:45:34 -050024uint64_t BitString::getFieldRight(uint64_t i_pos, uint64_t i_len) const
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -050025{
Zane Shelley83da2452019-10-25 15:45:34 -050026 HEI_ASSERT(nullptr != getBufAddr()); // must to have a valid address
27 HEI_ASSERT(0 < i_len); // must have at least one bit
28 HEI_ASSERT(i_len <= UINT64_BIT_LEN); // i_len length must be valid
29 HEI_ASSERT(i_pos + i_len <= getBitLen()); // field must be within range
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -050030
Ben Tynera8126fd2019-08-01 19:40:07 -050031 // Get the relative address of this byte and the relative starting position
32 // within the byte.
Zane Shelley7c8faa12019-10-28 22:26:28 -050033 uint64_t relPos = 0;
Zane Shelleyfe27b652019-10-28 11:33:07 -050034 uint8_t* relAddr = getRelativePosition(relPos, i_pos);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -050035
Ben Tynera8126fd2019-08-01 19:40:07 -050036 // Get the length of the target bit field within this byte and the length of
37 // the bit field for any remaining bits.
Zane Shelleyd0af3582019-09-19 10:48:59 -050038 uint64_t bf_len = i_len;
39 uint64_t remain_len = 0;
Zane Shelley83da2452019-10-25 15:45:34 -050040 if (UINT8_BIT_LEN < relPos + i_len)
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -050041 {
Ben Tynera8126fd2019-08-01 19:40:07 -050042 // The target bit field crosses a byte boundary. So truncate the bit
43 // length for this byte and update the remaining length.
44 bf_len = UINT8_BIT_LEN - relPos;
45 remain_len = i_len - bf_len;
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -050046 }
47
Ben Tynera8126fd2019-08-01 19:40:07 -050048 // Get the target bit field within this byte (right justified).
49 uint8_t bf = *relAddr;
50 bf <<= relPos; // Mask off uneeded bits on the left side.
51 bf >>= UINT8_BIT_LEN - bf_len; // Right justify the value.
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -050052
Ben Tynera8126fd2019-08-01 19:40:07 -050053 // Check for any remaining bits after this target byte.
Zane Shelley83da2452019-10-25 15:45:34 -050054 if (0 != remain_len)
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -050055 {
Ben Tynera8126fd2019-08-01 19:40:07 -050056 // Recursively call this function on the remaining bits and push them
57 // into the right side of the return value.
58 uint64_t val = static_cast<uint64_t>(bf) << remain_len;
Zane Shelley83da2452019-10-25 15:45:34 -050059 return val | getFieldRight(i_pos + bf_len, remain_len);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -050060 }
61
Ben Tynera8126fd2019-08-01 19:40:07 -050062 // Nothing more to do. Simply return this bit field.
63 return bf;
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -050064}
65
66//------------------------------------------------------------------------------
67
Zane Shelley83da2452019-10-25 15:45:34 -050068void BitString::setFieldLeft(uint64_t i_pos, uint64_t i_len, uint64_t i_val)
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -050069{
Zane Shelley83da2452019-10-25 15:45:34 -050070 HEI_ASSERT(nullptr != getBufAddr()); // must to have a valid address
71 HEI_ASSERT(0 < i_len); // must have at least one bit
72 HEI_ASSERT(i_len <= UINT64_BIT_LEN); // i_len length must be valid
73 HEI_ASSERT(i_pos + i_len <= getBitLen()); // field must be within range
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -050074
Ben Tynera8126fd2019-08-01 19:40:07 -050075 // Get the relative address of this byte and the relative starting position
76 // within the byte.
Zane Shelley7c8faa12019-10-28 22:26:28 -050077 uint64_t relPos = 0;
Zane Shelleyfe27b652019-10-28 11:33:07 -050078 uint8_t* relAddr = getRelativePosition(relPos, i_pos);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -050079
Ben Tynera8126fd2019-08-01 19:40:07 -050080 // Get the length of the target bit field within this byte and the length of
81 // the bit field for any remaining bits.
Zane Shelleyd0af3582019-09-19 10:48:59 -050082 uint64_t bf_len = i_len;
83 uint64_t remain_len = 0;
Zane Shelley83da2452019-10-25 15:45:34 -050084 if (UINT8_BIT_LEN < relPos + i_len)
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -050085 {
Ben Tynera8126fd2019-08-01 19:40:07 -050086 // The target bit field crosses a byte boundary. So truncate the bit
87 // length for this byte and update the remaining length.
88 bf_len = UINT8_BIT_LEN - relPos;
89 remain_len = i_len - bf_len;
90 }
91
92 // It is possible there are bits in this byte on either side of the target
93 // bit field that must be preserved. Get the length of each of those bit
94 // fields.
Zane Shelleyd0af3582019-09-19 10:48:59 -050095 uint64_t bf_l_len = relPos;
96 uint64_t bf_r_len = UINT8_BIT_LEN - (bf_l_len + bf_len);
Ben Tynera8126fd2019-08-01 19:40:07 -050097
98 // Get the target bit field from the left justified inputed value.
99 uint8_t bf = (i_val >> (UINT64_BIT_LEN - bf_len)) << bf_r_len;
100
101 // Get the bit fields on either side of the target bit field.
Zane Shelleyd0af3582019-09-19 10:48:59 -0500102 uint64_t bf_l_shift = UINT8_BIT_LEN - bf_l_len;
103 uint64_t bf_r_shift = UINT8_BIT_LEN - bf_r_len;
Zane Shelley7c8faa12019-10-28 22:26:28 -0500104
Zane Shelley7f7a42d2019-10-28 13:28:31 -0500105 uint8_t bf_l = *relAddr;
106 bf_l >>= bf_l_shift;
107 bf_l <<= bf_l_shift;
Zane Shelley7c8faa12019-10-28 22:26:28 -0500108
Zane Shelley7f7a42d2019-10-28 13:28:31 -0500109 uint8_t bf_r = *relAddr;
110 bf_r <<= bf_r_shift;
111 bf_r >>= bf_r_shift;
Ben Tynera8126fd2019-08-01 19:40:07 -0500112
113 // Combine all three parts of the byte and write it out to memory.
114 *relAddr = bf_l | bf | bf_r;
115
116 // Check for any remaining bits after this target byte.
Zane Shelley83da2452019-10-25 15:45:34 -0500117 if (0 != remain_len)
Ben Tynera8126fd2019-08-01 19:40:07 -0500118 {
119 // Recursively call this function on the remaining bits.
Zane Shelley83da2452019-10-25 15:45:34 -0500120 setFieldLeft(i_pos + bf_len, remain_len, i_val << bf_len);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500121 }
122}
123
124//------------------------------------------------------------------------------
125
Zane Shelley83da2452019-10-25 15:45:34 -0500126void BitString::setPattern(uint64_t i_sPos, uint64_t i_sLen, uint64_t i_pattern,
127 uint64_t i_pLen)
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500128{
Ben Tynera8126fd2019-08-01 19:40:07 -0500129
130 HEI_ASSERT(nullptr != getBufAddr()); // must to have a valid address
131 HEI_ASSERT(0 < i_sLen); // must have at least one bit
132 HEI_ASSERT(i_sPos + i_sLen <= getBitLen()); // field must be within range
133 HEI_ASSERT(0 < i_pLen); // must have at least one bit
Zane Shelley83da2452019-10-25 15:45:34 -0500134 HEI_ASSERT(i_pLen <= UINT64_BIT_LEN); // i_pLen length must be valid
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500135
136 // Get a bit string for the pattern subset (right justified).
Ben Tynera8126fd2019-08-01 19:40:07 -0500137 // Note that we cannot use a BitStringBuffer here because this function
138 // could be used in the constructor of BitStringBuffer, which could causes
139 // an infinite loop.
140 uint8_t a[sizeof(i_pattern)] = {};
Zane Shelleyc4771992019-10-28 22:01:49 -0500141 BitString bs{sizeof(i_pattern) * 8, a};
Ben Tynera8126fd2019-08-01 19:40:07 -0500142 bs.setFieldRight(0, i_pLen, i_pattern);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500143
144 // Iterate the range in chunks the size of i_pLen.
Zane Shelleyd0af3582019-09-19 10:48:59 -0500145 uint64_t endPos = i_sPos + i_sLen;
Zane Shelley83da2452019-10-25 15:45:34 -0500146 for (uint64_t pos = i_sPos; pos < endPos; pos += i_pLen)
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500147 {
148 // The true chunk size is either i_pLen or the leftovers at the end.
Zane Shelley83da2452019-10-25 15:45:34 -0500149 uint64_t len = std::min(i_pLen, endPos - pos);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500150
Ben Tynera8126fd2019-08-01 19:40:07 -0500151 // Get this chunk's pattern value, truncate (right justified) if needed.
Zane Shelley83da2452019-10-25 15:45:34 -0500152 uint64_t pattern = bs.getFieldRight(0, len);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500153
154 // Set the pattern in this string.
Zane Shelley83da2452019-10-25 15:45:34 -0500155 setFieldRight(pos, len, pattern);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500156 }
157}
158
159//------------------------------------------------------------------------------
160
Zane Shelleyfe27b652019-10-28 11:33:07 -0500161void BitString::setString(const BitString& i_sStr, uint64_t i_sPos,
Zane Shelley83da2452019-10-25 15:45:34 -0500162 uint64_t i_sLen, uint64_t i_dPos)
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500163{
164 // Ensure the source parameters are valid.
Zane Shelley83da2452019-10-25 15:45:34 -0500165 HEI_ASSERT(nullptr != i_sStr.getBufAddr());
166 HEI_ASSERT(0 < i_sLen); // at least one bit to copy
167 HEI_ASSERT(i_sPos + i_sLen <= i_sStr.getBitLen());
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500168
169 // Ensure the destination has at least one bit available to copy.
Zane Shelley83da2452019-10-25 15:45:34 -0500170 HEI_ASSERT(nullptr != getBufAddr());
171 HEI_ASSERT(i_dPos < getBitLen());
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500172
173 // If the source length is greater than the destination length than the
174 // extra source bits are ignored.
Zane Shelley83da2452019-10-25 15:45:34 -0500175 uint64_t actLen = std::min(i_sLen, getBitLen() - i_dPos);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500176
177 // The bit strings may be in overlapping memory spaces. So we need to copy
178 // the data in the correct direction to prevent overlapping.
Zane Shelleyd0af3582019-09-19 10:48:59 -0500179 uint64_t sRelOffset = 0, dRelOffset = 0;
Zane Shelleyfe27b652019-10-28 11:33:07 -0500180 uint8_t* sRelAddr = i_sStr.getRelativePosition(sRelOffset, i_sPos);
Zane Shelley7c8faa12019-10-28 22:26:28 -0500181 uint8_t* dRelAddr = getRelativePosition(dRelOffset, i_dPos);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500182
183 // Copy the data.
Zane Shelley83da2452019-10-25 15:45:34 -0500184 if ((dRelAddr == sRelAddr) && (dRelOffset == sRelOffset))
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500185 {
186 // Do nothing. The source and destination are the same.
187 }
Zane Shelley83da2452019-10-25 15:45:34 -0500188 else if ((dRelAddr < sRelAddr) ||
189 ((dRelAddr == sRelAddr) && (dRelOffset < sRelOffset)))
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500190 {
191 // Copy the data forward.
Zane Shelley83da2452019-10-25 15:45:34 -0500192 for (uint64_t pos = 0; pos < actLen; pos += UINT64_BIT_LEN)
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500193 {
Zane Shelley83da2452019-10-25 15:45:34 -0500194 uint64_t len = std::min(actLen - pos, UINT64_BIT_LEN);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500195
Zane Shelley83da2452019-10-25 15:45:34 -0500196 uint64_t value = i_sStr.getFieldRight(i_sPos + pos, len);
197 setFieldRight(i_dPos + pos, len, value);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500198 }
199 }
200 else // Copy the data backwards.
201 {
Ben Tynera8126fd2019-08-01 19:40:07 -0500202 // Get the first position of the last chunk (byte aligned).
Zane Shelley83da2452019-10-25 15:45:34 -0500203 uint64_t lastPos = ((actLen - 1) / UINT64_BIT_LEN) * UINT64_BIT_LEN;
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500204
205 // Start with the last chunk and work backwards.
Zane Shelley83da2452019-10-25 15:45:34 -0500206 for (int32_t pos = lastPos; 0 <= pos; pos -= UINT64_BIT_LEN)
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500207 {
Zane Shelley7c8faa12019-10-28 22:26:28 -0500208 uint64_t len = std::min(actLen - pos, UINT64_BIT_LEN);
Zane Shelley83da2452019-10-25 15:45:34 -0500209 uint64_t value = i_sStr.getFieldRight(i_sPos + pos, len);
210 setFieldRight(i_dPos + pos, len, value);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500211 }
212 }
213}
214
215//------------------------------------------------------------------------------
216
Zane Shelleyfe27b652019-10-28 11:33:07 -0500217void BitString::maskString(const BitString& i_mask)
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500218{
219 // Get the length of the smallest string.
Zane Shelley83da2452019-10-25 15:45:34 -0500220 uint64_t actLen = std::min(getBitLen(), i_mask.getBitLen());
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500221
Zane Shelley83da2452019-10-25 15:45:34 -0500222 for (uint64_t pos = 0; pos < actLen; pos += UINT64_BIT_LEN)
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500223 {
Zane Shelley83da2452019-10-25 15:45:34 -0500224 uint64_t len = std::min(actLen - pos, UINT64_BIT_LEN);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500225
Zane Shelley7c8faa12019-10-28 22:26:28 -0500226 uint64_t dVal = getFieldRight(pos, len);
Zane Shelley83da2452019-10-25 15:45:34 -0500227 uint64_t sVal = i_mask.getFieldRight(pos, len);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500228
Zane Shelley83da2452019-10-25 15:45:34 -0500229 setFieldRight(pos, len, dVal & ~sVal);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500230 }
231}
232
233//------------------------------------------------------------------------------
234
Zane Shelleyfe27b652019-10-28 11:33:07 -0500235bool BitString::isEqual(const BitString& i_str) const
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500236{
Zane Shelley83da2452019-10-25 15:45:34 -0500237 if (getBitLen() != i_str.getBitLen())
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500238 return false; // size not equal
239
Zane Shelley83da2452019-10-25 15:45:34 -0500240 for (uint64_t pos = 0; pos < getBitLen(); pos += UINT64_BIT_LEN)
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500241 {
Zane Shelley83da2452019-10-25 15:45:34 -0500242 uint64_t len = std::min(getBitLen() - pos, UINT64_BIT_LEN);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500243
Zane Shelley83da2452019-10-25 15:45:34 -0500244 if (getFieldRight(pos, len) != i_str.getFieldRight(pos, len))
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500245 return false; // bit strings do not match
246 }
247
248 return true; // bit strings match
249}
250
251//------------------------------------------------------------------------------
252
253bool BitString::isZero() const
254{
Zane Shelley83da2452019-10-25 15:45:34 -0500255 for (uint64_t pos = 0; pos < getBitLen(); pos += UINT64_BIT_LEN)
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500256 {
Zane Shelley83da2452019-10-25 15:45:34 -0500257 uint64_t len = std::min(getBitLen() - pos, UINT64_BIT_LEN);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500258
Zane Shelley83da2452019-10-25 15:45:34 -0500259 if (0 != getFieldRight(pos, len))
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500260 return false; // something is non-zero
261 }
262
263 return true; // everything was zero
264}
265
266//------------------------------------------------------------------------------
267
Zane Shelley83da2452019-10-25 15:45:34 -0500268uint64_t BitString::getSetCount(uint64_t i_pos, uint64_t i_len) const
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500269{
Zane Shelleyd0af3582019-09-19 10:48:59 -0500270 uint64_t endPos = i_pos + i_len;
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500271
Zane Shelley83da2452019-10-25 15:45:34 -0500272 HEI_ASSERT(endPos <= getBitLen());
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500273
Zane Shelleyd0af3582019-09-19 10:48:59 -0500274 uint64_t count = 0;
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500275
Zane Shelley83da2452019-10-25 15:45:34 -0500276 for (uint64_t i = i_pos; i < endPos; i++)
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500277 {
Zane Shelley7f7a42d2019-10-28 13:28:31 -0500278 if (isBitSet(i))
279 count++;
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500280 }
281
282 return count;
283}
284
285//------------------------------------------------------------------------------
286
Zane Shelleyec06f822019-12-05 22:23:19 -0600287bool BitString::operator<(const BitString& i_str) const
288{
289 // The two bit strings must be the same length. Otherwise, the comparison
290 // undefined (i.e. compare from the left vs. right).
291 HEI_ASSERT(getBitLen() == i_str.getBitLen());
292
293 for (uint64_t pos = 0; pos < getBitLen(); pos += UINT64_BIT_LEN)
294 {
295 uint64_t len = std::min(getBitLen() - pos, UINT64_BIT_LEN);
296
297 auto l_str = getFieldRight(pos, len);
298 auto r_str = i_str.getFieldRight(pos, len);
299
300 if (l_str < r_str)
301 {
302 return true;
303 }
304 // The loop can only continue if the values are equal.
305 else if (l_str > r_str)
306 {
307 return false;
308 }
309 }
310
311 return false;
312}
313
314//------------------------------------------------------------------------------
315
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500316BitStringBuffer BitString::operator~() const
317{
Zane Shelley83da2452019-10-25 15:45:34 -0500318 BitStringBuffer bsb(getBitLen());
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500319
Zane Shelley83da2452019-10-25 15:45:34 -0500320 for (uint64_t pos = 0; pos < getBitLen(); pos += UINT64_BIT_LEN)
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500321 {
Zane Shelley83da2452019-10-25 15:45:34 -0500322 uint64_t len = std::min(getBitLen() - pos, UINT64_BIT_LEN);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500323
Zane Shelley83da2452019-10-25 15:45:34 -0500324 uint64_t dVal = getFieldRight(pos, len);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500325
Zane Shelley83da2452019-10-25 15:45:34 -0500326 bsb.setFieldRight(pos, len, ~dVal);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500327 }
328
329 return bsb;
330}
331
332//------------------------------------------------------------------------------
333
Zane Shelleyfe27b652019-10-28 11:33:07 -0500334BitStringBuffer BitString::operator&(const BitString& i_bs) const
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500335{
336 // Get the length of the smallest string.
Zane Shelley83da2452019-10-25 15:45:34 -0500337 uint64_t actLen = std::min(getBitLen(), i_bs.getBitLen());
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500338
Zane Shelley83da2452019-10-25 15:45:34 -0500339 BitStringBuffer bsb(actLen);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500340
Zane Shelley83da2452019-10-25 15:45:34 -0500341 for (uint64_t pos = 0; pos < actLen; pos += UINT64_BIT_LEN)
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500342 {
Zane Shelley83da2452019-10-25 15:45:34 -0500343 uint64_t len = std::min(actLen - pos, UINT64_BIT_LEN);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500344
Zane Shelley7c8faa12019-10-28 22:26:28 -0500345 uint64_t dVal = getFieldRight(pos, len);
Zane Shelley83da2452019-10-25 15:45:34 -0500346 uint64_t sVal = i_bs.getFieldRight(pos, len);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500347
Zane Shelley83da2452019-10-25 15:45:34 -0500348 bsb.setFieldRight(pos, len, dVal & sVal);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500349 }
350
351 return bsb;
352}
353
354//------------------------------------------------------------------------------
355
Zane Shelleyfe27b652019-10-28 11:33:07 -0500356BitStringBuffer BitString::operator|(const BitString& i_bs) const
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500357{
358 // Get the length of the smallest string.
Zane Shelley83da2452019-10-25 15:45:34 -0500359 uint64_t actLen = std::min(getBitLen(), i_bs.getBitLen());
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500360
Zane Shelley83da2452019-10-25 15:45:34 -0500361 BitStringBuffer bsb(actLen);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500362
Zane Shelley83da2452019-10-25 15:45:34 -0500363 for (uint64_t pos = 0; pos < actLen; pos += UINT64_BIT_LEN)
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500364 {
Zane Shelley83da2452019-10-25 15:45:34 -0500365 uint64_t len = std::min(actLen - pos, UINT64_BIT_LEN);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500366
Zane Shelley7c8faa12019-10-28 22:26:28 -0500367 uint64_t dVal = getFieldRight(pos, len);
Zane Shelley83da2452019-10-25 15:45:34 -0500368 uint64_t sVal = i_bs.getFieldRight(pos, len);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500369
Zane Shelley83da2452019-10-25 15:45:34 -0500370 bsb.setFieldRight(pos, len, dVal | sVal);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500371 }
372
373 return bsb;
374}
375
376//------------------------------------------------------------------------------
377
Zane Shelley83da2452019-10-25 15:45:34 -0500378BitStringBuffer BitString::operator>>(uint64_t i_shift) const
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500379{
Zane Shelley83da2452019-10-25 15:45:34 -0500380 BitStringBuffer bsb(getBitLen()); // default all zeros
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500381
Zane Shelley83da2452019-10-25 15:45:34 -0500382 if (i_shift < getBitLen())
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500383 {
384 // bso overlays bsb, containing the shifted offset.
Zane Shelleyc4771992019-10-28 22:01:49 -0500385 BitString bso(bsb.getBitLen() - i_shift, bsb.getBufAddr(), i_shift);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500386
387 // Copy this into bso.
Zane Shelley83da2452019-10-25 15:45:34 -0500388 bso.setString(*this);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500389 }
390
391 return bsb;
392}
393
394//------------------------------------------------------------------------------
395
Zane Shelley83da2452019-10-25 15:45:34 -0500396BitStringBuffer BitString::operator<<(uint64_t i_shift) const
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500397{
Zane Shelley83da2452019-10-25 15:45:34 -0500398 BitStringBuffer bsb(getBitLen()); // default all zeros
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500399
Zane Shelley83da2452019-10-25 15:45:34 -0500400 if (i_shift < getBitLen())
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500401 {
402 // bso overlays *this, containing the shifted offset.
Zane Shelleyc4771992019-10-28 22:01:49 -0500403 BitString bso(this->getBitLen() - i_shift, this->getBufAddr(), i_shift);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500404
405 // Copy bso into bsb.
Zane Shelley83da2452019-10-25 15:45:34 -0500406 bsb.setString(bso);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500407 }
408
409 return bsb;
410}
411
412//------------------------------------------------------------------------------
413
Zane Shelleyfe27b652019-10-28 11:33:07 -0500414uint8_t* BitString::getRelativePosition(uint64_t& o_relPos,
Zane Shelley7c8faa12019-10-28 22:26:28 -0500415 uint64_t i_absPos) const
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500416{
Zane Shelley83da2452019-10-25 15:45:34 -0500417 HEI_ASSERT(nullptr != getBufAddr()); // must to have a valid address
418 HEI_ASSERT(i_absPos < getBitLen()); // must be a valid position
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500419
Ben Tynera8126fd2019-08-01 19:40:07 -0500420 o_relPos = (i_absPos + iv_offset) % UINT8_BIT_LEN;
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500421
Zane Shelleyfe27b652019-10-28 11:33:07 -0500422 return ((uint8_t*)iv_bufAddr + ((i_absPos + iv_offset) / UINT8_BIT_LEN));
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500423}
424
425//##############################################################################
426// BitStringBuffer class
427//##############################################################################
428
Zane Shelley83da2452019-10-25 15:45:34 -0500429BitStringBuffer::BitStringBuffer(uint64_t i_bitLen) :
430 BitString(i_bitLen, nullptr)
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500431{
432 initBuffer();
433}
434
435//------------------------------------------------------------------------------
436
437BitStringBuffer::~BitStringBuffer()
438{
Zane Shelleyc4771992019-10-28 22:01:49 -0500439 delete[](uint8_t*) getBufAddr();
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500440}
441
442//------------------------------------------------------------------------------
443
Zane Shelleyfe27b652019-10-28 11:33:07 -0500444BitStringBuffer::BitStringBuffer(const BitString& i_bs) :
Zane Shelley83da2452019-10-25 15:45:34 -0500445 BitString(i_bs.getBitLen(), nullptr)
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500446{
447 initBuffer();
Zane Shelley7f7a42d2019-10-28 13:28:31 -0500448 if (!i_bs.isZero())
449 {
450 setString(i_bs);
451 }
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500452}
453
454//------------------------------------------------------------------------------
455
Zane Shelleyfe27b652019-10-28 11:33:07 -0500456BitStringBuffer::BitStringBuffer(const BitStringBuffer& i_bsb) :
Zane Shelley83da2452019-10-25 15:45:34 -0500457 BitString(i_bsb.getBitLen(), nullptr)
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500458{
459 initBuffer();
Zane Shelley7f7a42d2019-10-28 13:28:31 -0500460 if (!i_bsb.isZero())
461 {
462 setString(i_bsb);
463 }
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500464}
465
466//------------------------------------------------------------------------------
467
Zane Shelleyfe27b652019-10-28 11:33:07 -0500468BitStringBuffer& BitStringBuffer::operator=(const BitString& i_bs)
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500469{
470 // The initBuffer() function will deallocate the buffer as well, however we
471 // also need to deallocate the buffer here before we set the length.
Zane Shelleyc4771992019-10-28 22:01:49 -0500472 delete[](uint8_t*) getBufAddr();
Zane Shelley83da2452019-10-25 15:45:34 -0500473 setBufAddr(nullptr);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500474
Zane Shelley83da2452019-10-25 15:45:34 -0500475 setBitLen(i_bs.getBitLen());
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500476 initBuffer();
Zane Shelley7f7a42d2019-10-28 13:28:31 -0500477 if (!i_bs.isZero())
478 {
479 setString(i_bs);
480 }
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500481
482 return *this;
483}
484
485//------------------------------------------------------------------------------
486
Zane Shelleyfe27b652019-10-28 11:33:07 -0500487BitStringBuffer& BitStringBuffer::operator=(const BitStringBuffer& i_bsb)
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500488{
Zane Shelley83da2452019-10-25 15:45:34 -0500489 if (this != &i_bsb) // Check for assignment to self
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500490 {
491 // The initBuffer() function will deallocate the buffer as well, however
492 // we also need to deallocate the buffer here before we set the length.
Zane Shelleyc4771992019-10-28 22:01:49 -0500493 delete[](uint8_t*) getBufAddr();
Zane Shelley83da2452019-10-25 15:45:34 -0500494 setBufAddr(nullptr);
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500495
Zane Shelley83da2452019-10-25 15:45:34 -0500496 setBitLen(i_bsb.getBitLen());
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500497 initBuffer();
Zane Shelley7f7a42d2019-10-28 13:28:31 -0500498 if (!i_bsb.isZero())
499 {
500 setString(i_bsb);
501 }
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500502 }
503
504 return *this;
505}
506
507//------------------------------------------------------------------------------
508
509void BitStringBuffer::initBuffer()
510{
511 // Deallocate the current buffer.
Zane Shelleyc4771992019-10-28 22:01:49 -0500512 delete[](uint8_t*) getBufAddr();
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500513
Ben Tynera8126fd2019-08-01 19:40:07 -0500514 // create new buffer, initialized to 0's
Zane Shelleyc4771992019-10-28 22:01:49 -0500515 setBufAddr(new uint8_t[getMinBytes(getBitLen())]());
Zane Shelleyfd3f9cc2019-07-29 15:02:24 -0500516}
517
Zane Shelley871adec2019-07-30 11:01:39 -0500518} // end namespace libhei