jaby/jabyengine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Remove the ComplexBitMap

Browse Source
This commit is contained in:
jaby
2023-03-22 20:46:08 +01:00
parent 550d657478
commit 94c078dc9f
13 changed files with 307 additions and 489 deletions
Download Patch File Download Diff File Expand all files Collapse all files

119
include/PSX/Auxiliary/bits.hpp
View File

@@ -1,17 +1,88 @@
#ifndef __JABYENGINE_BITS_HPP__
#define __JABYENGINE_BITS_HPP__
#include "../jabyengine_defines.h"
#include "types.hpp"
namespace JabyEngine {
namespace bit {
namespace value {
template<typename T>
static constexpr T set_normalized(T raw_value, T value, size_t start_bit, size_t length);
}
}
struct ClearBit {
uint16_t pos;
constexpr ClearBit(uint16_t bit_pos) : pos(bit_pos) {
}
};
struct Bit {
uint16_t pos;
constexpr Bit(uint16_t bit_pos) : pos(bit_pos) {
}
constexpr ClearBit operator!() const {
return ClearBit(this->pos);
}
};
struct BitRange {
template<typename T>
using RangeValuePair = pair<BitRange, T>;
uint16_t pos;
uint16_t length;
constexpr BitRange(uint16_t pos, uint16_t length) : pos(pos), length(length) {
}
static constexpr BitRange from_to(uint16_t first_bit, uint16_t last_bit) {
return BitRange(first_bit, (last_bit - first_bit) + 1);
}
template<typename T>
constexpr RangeValuePair<T> with(T value) const {
return {*this, value};
}
template<typename T>
constexpr T as_value(T value) const {
return bit::value::set_normalized(static_cast<T>(0), value, this->pos, this->length);
}
template<typename T>
constexpr RangeValuePair<T> range_max() const {
return BitRange::with<T>((1 << this->length) - 1);
}
};
namespace bit {
template<typename T>
static constexpr T clear(T raw_value, size_t bit) {
return (raw_value & ~(1 << bit));
}
template<typename T>
static constexpr T clear(T raw_value, Bit bit) {
return clear(raw_value, bit.pos);
}
template<typename T>
static constexpr T set(T raw_value, size_t bit) {
return (raw_value | (1 << bit));
}
template<typename T>
static constexpr T clear(T raw_value, size_t bit) {
return (raw_value & ~(1 << bit));
static constexpr T set(T raw_value, Bit bit) {
return set(raw_value, bit.pos);
}
template<typename T>
static constexpr T set(T raw_value, ClearBit bit) {
return clear(raw_value, bit.pos);
}
template<typename T>
@@ -19,30 +90,52 @@ namespace JabyEngine {
return static_cast<bool>(raw_value & (1 << bit));
}
namespace value {
template<typename T>
static constexpr T crop_value(T raw_value, size_t length) {
return (raw_value & ((1 << length) - 1));
}
template<typename T>
static constexpr bool is_set(T raw_value, Bit bit) {
return is_set(raw_value, bit.pos);
}
template<typename T>
static constexpr T range_mask(size_t start_bit, size_t length) {
return (((1 << length) - 1) << start_bit);
namespace value {
namespace helper {
template<typename T>
static constexpr T crop_value(T raw_value, size_t length) {
return (raw_value & ((1 << length) - 1));
}
template<typename T>
static constexpr T range_mask(size_t start_bit, size_t length) {
return (((1 << length) - 1) << start_bit);
}
}
template<typename T>
static constexpr T clear_normalized(T raw_value, size_t start_bit, size_t length) {
return (raw_value & ~range_mask<T>(start_bit, length));
return (raw_value & ~helper::range_mask<T>(start_bit, length));
}
template<typename T>
static constexpr T set_normalized(T raw_value, T value, size_t start_bit, size_t length) {
return (clear_normalized(raw_value, start_bit, length) | (crop_value(value, length) << start_bit));
return (clear_normalized(raw_value, start_bit, length) | (helper::crop_value(value, length) << start_bit));
}
template<typename T>
static constexpr T set_normalized(T raw_value, BitRange bits, T value) {
return set_normalized(raw_value, value, bits.pos, bits.length);
}
template<typename T, typename S>
static constexpr T set_normalized(T raw_value, const BitRange::RangeValuePair<S> &value_pair) {
return set_normalized(raw_value, value_pair.first, static_cast<T>(value_pair.second));
}
template<typename T>
static constexpr T get_normalized(T raw_value, size_t start_bit, size_t length) {
return crop_value((raw_value & range_mask<T>(start_bit, length)) >> start_bit, length);
return helper::crop_value((raw_value & helper::range_mask<T>(start_bit, length)) >> start_bit, length);
}
template<typename T>
static constexpr T get_normalized(T raw_value, BitRange range) {
return get_normalized(raw_value, range.pos, range.length);
}
}

202
include/PSX/Auxiliary/complex_bitmap.hpp
View File

@@ -3,208 +3,6 @@
#include "bits.hpp"
namespace JabyEngine {
struct ClearBitValue {
size_t bit;
constexpr ClearBitValue(size_t bit) : bit(bit) {
}
};
template<typename T>
struct Bit {
typedef T ValueType;
size_t value;
constexpr Bit(size_t value) : value(value) {
}
constexpr operator size_t() const {
return this->value;
}
constexpr ClearBitValue operator!() const {
return ClearBitValue(this->value);
}
};
template<typename T>
struct BitRangeValue {
T value;
size_t begin;
size_t length;
constexpr BitRangeValue() = default;
constexpr BitRangeValue(T value, size_t begin, size_t length) : value(value), begin(begin), length(length) {
}
};
template<typename T>
struct BitRange {
typedef T ValueType;
size_t begin;
size_t length;
static constexpr BitRange<T> from_to(size_t start, size_t end) {
return {start, (end - start + 1)};
}
constexpr BitRangeValue<T> with(T value) const {
return BitRangeValue(value, this->begin, this->length);
}
constexpr BitRangeValue<T> max() const {
return BitRange<T>::with((1 << this->length) - 1);
}
};
template<typename T>
static constexpr __always_inline BitRangeValue<T> operator<<(const BitRange<T>& range, T value) {
return BitRangeValue{value, range.begin, range.length};
}
template<typename T>
class ComplexBitMap {
public:
typedef T UnderlyingType;
T raw;
private:
template<typename S>
constexpr __always_inline ComplexBitMap<T>& set_va(const S& value) {
return this->set(value);
}
template<typename S, typename...ARGS>
constexpr __always_inline ComplexBitMap<T>& set_va(const S& value, const ARGS&...args) {
return this->set_va(value).set_va(args...);
}
public:
template<typename...ARGS>
static constexpr __always_inline ComplexBitMap<T> with(ARGS...args) {
return ComplexBitMap().set_va(args...);
}
//Accesssing bits
template<typename S>
constexpr ComplexBitMap<T>& set_bit(S bit) {
this->raw = bit::set(this->raw, static_cast<size_t>(bit));
return *this;
}
template<typename S>
constexpr void set_bit(S bit) volatile {
this->raw = bit::set(this->raw, static_cast<size_t>(bit));
}
template<typename S>
constexpr ComplexBitMap<T>& clear_bit(S bit) {
this->raw = bit::clear(this->raw, static_cast<size_t>(bit));
return *this;
}
template<typename S>
constexpr void clear_bit(S bit) volatile {
this->raw = bit::clear(this->raw, static_cast<size_t>(bit));
}
template<typename S>
constexpr bool is_bit_set(S bit) {
return bit::is_set(this->raw, static_cast<size_t>(bit));
}
template<typename S>
constexpr bool is_bit_set(S bit) const volatile {
return bit::is_set(this->raw, static_cast<size_t>(bit));
}
//Accessing values
template<typename S>
constexpr ComplexBitMap<T>& set_value(S value, const BitRange<S>& range) {
this->raw = bit::value::set_normalized(this->raw, static_cast<T>(value), range.begin, range.length);
return *this;
}
template<typename S>
constexpr void set_value(S value, const BitRange<S>& range) volatile {
this->raw = bit::value::set_normalized(this->raw, static_cast<T>(value), range.begin, range.length);
}
template<typename S>
constexpr ComplexBitMap<T>& clear_value(const BitRange<S>& range) {
this->raw = bit::value::clear_normalized(this->raw, range.begin, range.length);
return *this;
}
template<typename S>
constexpr void clear_value(const BitRange<S>& range) volatile {
this->raw = bit::value::clear_normalized(this->raw, range.begin, range.length);
}
template<typename S>
constexpr S get_value(const BitRange<S>& range) const {
return static_cast<S>(bit::value::get_normalized(this->raw, range.begin, range.length));
}
template<typename S>
constexpr S get_value(const BitRange<S>& range) const volatile {
return static_cast<S>(bit::value::get_normalized(this->raw, range.begin, range.length));
}
//For easier checking
constexpr bool is(Bit<T> bit) const {
return ComplexBitMap::is_bit_set(bit);
}
constexpr bool is(Bit<T> bit) const volatile {
return ComplexBitMap::is_bit_set(bit);
}
// For easier constructing
template<typename S>
constexpr __always_inline ComplexBitMap<T>& set(const BitRange<S>& range, T value) {
this->set_value(value, range);
return *this;
}
template<typename S>
constexpr __always_inline ComplexBitMap<T>& set(const BitRangeValue<S>& value) {
this->set_value(value.value, {value.begin, value.length});
return *this;
}
template<typename S>
constexpr __always_inline ComplexBitMap<T>& set(const Bit<S>& bit) {
this->set_bit(bit.value);
return *this;
}
constexpr __always_inline ComplexBitMap<T>& set(const ClearBitValue& value) {
this->clear_bit(value.bit);
return *this;
}
constexpr __always_inline ComplexBitMap<T>& operator|(const BitRangeValue<T>& value) {
this->set_value(value.value, value.range);
return *this;
}
constexpr __always_inline ComplexBitMap<T>& operator|(const Bit<T>& bit) {
this->set_bit(bit.value);
return *this;
}
constexpr __always_inline ComplexBitMap<T>& operator|(const ClearBitValue& value) {
this->clear_bit(value.bit);
return *this;
}
constexpr __always_inline operator T() const {
return this->raw;
}
};
}
#endif //!__JABYENGINE_COMPLEX_BITMAP_HPP__