2023-12-18 23:13:44 -05:00
|
|
|
/*
|
|
|
|
* <Short Description>
|
|
|
|
* Copyright (C) 2023 Brett Terpstra
|
|
|
|
*
|
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef BLT_MEMORY_UTIL_H
|
|
|
|
#define BLT_MEMORY_UTIL_H
|
|
|
|
|
|
|
|
#include <type_traits>
|
|
|
|
#include <array>
|
|
|
|
#include <cstring>
|
|
|
|
#include <algorithm>
|
2024-01-07 13:06:39 -05:00
|
|
|
#include <cstdint>
|
2023-12-18 23:13:44 -05:00
|
|
|
|
|
|
|
#if defined(__clang__) || defined(__llvm__) || defined(__GNUC__) || defined(__GNUG__)
|
|
|
|
|
2024-02-21 20:24:00 -05:00
|
|
|
#if defined(__GNUC__) || defined(__GNUG__)
|
2024-03-07 09:00:19 -05:00
|
|
|
|
2024-02-21 20:24:00 -05:00
|
|
|
#include <byteswap.h>
|
2024-03-07 09:00:19 -05:00
|
|
|
|
2024-02-21 20:24:00 -05:00
|
|
|
#define SWAP16(val) bswap_16(val)
|
|
|
|
#define SWAP32(val) bswap_32(val)
|
|
|
|
#define SWAP64(val) bswap_64(val)
|
|
|
|
#else
|
|
|
|
#define SWAP16(val) __builtin_bswap16(val)
|
|
|
|
#define SWAP32(val) __builtin_bswap32(val)
|
|
|
|
#define SWAP64(val) __builtin_bswap64(val)
|
|
|
|
#endif
|
|
|
|
|
2023-12-18 23:13:44 -05:00
|
|
|
|
|
|
|
#if __cplusplus >= 202002L
|
2024-01-02 01:27:43 -05:00
|
|
|
|
2023-12-18 23:13:44 -05:00
|
|
|
#include <bit>
|
2024-01-02 01:27:43 -05:00
|
|
|
|
2023-12-18 23:13:44 -05:00
|
|
|
#define ENDIAN_LOOKUP(little_endian) (std::endian::native == std::endian::little && !little_endian) || \
|
|
|
|
(std::endian::native == std::endian::big && little_endian)
|
|
|
|
#else
|
|
|
|
#define ENDIAN_LOOKUP(little_endian) !little_endian
|
|
|
|
#endif
|
|
|
|
#elif defined(_MSC_VER)
|
|
|
|
#include <intrin.h>
|
|
|
|
#define SWAP16(val) _byteswap_ushort(val)
|
|
|
|
#define SWAP32(val) _byteswap_ulong(val)
|
|
|
|
#define SWAP64(val) _byteswap_uint64(val)
|
|
|
|
#define ENDIAN_LOOKUP(little_endian) !little_endian
|
|
|
|
#endif
|
|
|
|
|
|
|
|
namespace blt::mem
|
|
|
|
{
|
|
|
|
// Used to grab the byte-data of any T element. Defaults to Big Endian, however can be configured to use little endian
|
|
|
|
template<bool little_endian = false, typename BYTE_TYPE, typename T>
|
|
|
|
inline static int toBytes(const T& in, BYTE_TYPE* out)
|
|
|
|
{
|
|
|
|
if constexpr (!(std::is_same_v<BYTE_TYPE, std::int8_t> || std::is_same_v<BYTE_TYPE, std::uint8_t>))
|
|
|
|
static_assert("Must provide a signed/unsigned int8 type");
|
|
|
|
std::memcpy(out, (void*) &in, sizeof(T));
|
|
|
|
|
|
|
|
if constexpr (ENDIAN_LOOKUP(little_endian))
|
|
|
|
{
|
|
|
|
// TODO: this but better.
|
|
|
|
for (size_t i = 0; i < sizeof(T) / 2; i++)
|
|
|
|
std::swap(out[i], out[sizeof(T) - 1 - i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Used to cast the binary data of any T object, into a T object. Assumes data is in big ending (configurable)
|
|
|
|
template<bool little_endian = false, typename BYTE_TYPE, typename T>
|
|
|
|
inline static int fromBytes(const BYTE_TYPE* in, T& out)
|
|
|
|
{
|
|
|
|
if constexpr (!(std::is_same_v<BYTE_TYPE, std::int8_t> || std::is_same_v<BYTE_TYPE, std::uint8_t>))
|
|
|
|
static_assert("Must provide a signed/unsigned int8 type");
|
|
|
|
|
|
|
|
std::array<BYTE_TYPE, sizeof(T)> data;
|
|
|
|
std::memcpy(data.data(), in, sizeof(T));
|
|
|
|
|
|
|
|
if constexpr (ENDIAN_LOOKUP(little_endian))
|
|
|
|
{
|
|
|
|
// if we need to swap find the best way to do so
|
|
|
|
if constexpr (std::is_same_v<T, int16_t> || std::is_same_v<T, uint16_t>)
|
|
|
|
out = SWAP16(*reinterpret_cast<T*>(data.data()));
|
|
|
|
else if constexpr (std::is_same_v<T, int32_t> || std::is_same_v<T, uint32_t>)
|
|
|
|
out = SWAP32(*reinterpret_cast<T*>(data.data()));
|
|
|
|
else if constexpr (std::is_same_v<T, int64_t> || std::is_same_v<T, uint64_t>)
|
|
|
|
out = SWAP64(*reinterpret_cast<T*>(data.data()));
|
|
|
|
else
|
|
|
|
{
|
|
|
|
std::reverse(data.begin(), data.end());
|
|
|
|
out = *reinterpret_cast<T*>(data.data());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<bool little_endian = false, typename BYTE_TYPE, typename T>
|
|
|
|
inline static int fromBytes(const BYTE_TYPE* in, T* out)
|
|
|
|
{
|
|
|
|
return fromBytes(in, *out);
|
|
|
|
}
|
|
|
|
|
2024-06-24 13:52:15 -04:00
|
|
|
inline static size_t next_byte_allocation(size_t prev_size, size_t default_allocation_block = 8192, size_t default_size = 16)
|
2023-12-18 23:13:44 -05:00
|
|
|
{
|
2024-06-24 13:52:15 -04:00
|
|
|
if (prev_size < default_size)
|
|
|
|
return default_size;
|
2023-12-18 23:13:44 -05:00
|
|
|
if (prev_size < default_allocation_block)
|
|
|
|
return prev_size * 2;
|
|
|
|
return prev_size + default_allocation_block;
|
|
|
|
}
|
2024-01-02 01:27:43 -05:00
|
|
|
|
|
|
|
template<typename R, typename T>
|
|
|
|
inline static R type_cast(T type)
|
|
|
|
{
|
|
|
|
static_assert(sizeof(T) == sizeof(R));
|
|
|
|
R r;
|
|
|
|
std::memcpy(&r, &type, sizeof(type));
|
|
|
|
return r;
|
|
|
|
}
|
2024-03-07 09:00:19 -05:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace blt
|
|
|
|
{
|
|
|
|
template<typename V>
|
|
|
|
struct ptr_iterator
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
using iterator_category = std::random_access_iterator_tag;
|
|
|
|
using difference_type = std::ptrdiff_t;
|
|
|
|
using value_type = V;
|
|
|
|
using pointer = value_type*;
|
|
|
|
using reference = value_type&;
|
|
|
|
|
|
|
|
explicit ptr_iterator(V* v): _v(v)
|
|
|
|
{}
|
|
|
|
|
|
|
|
reference operator*() const
|
|
|
|
{ return *_v; }
|
|
|
|
|
|
|
|
pointer operator->()
|
|
|
|
{ return _v; }
|
|
|
|
|
|
|
|
ptr_iterator& operator++()
|
|
|
|
{
|
|
|
|
_v++;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
ptr_iterator& operator--()
|
|
|
|
{
|
|
|
|
_v--;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
ptr_iterator operator++(int)
|
|
|
|
{
|
|
|
|
auto tmp = *this;
|
|
|
|
++(*this);
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
ptr_iterator operator--(int)
|
|
|
|
{
|
|
|
|
auto tmp = *this;
|
|
|
|
--(*this);
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
friend bool operator==(const ptr_iterator& a, const ptr_iterator& b)
|
|
|
|
{
|
|
|
|
return a._v == b._v;
|
|
|
|
}
|
|
|
|
|
|
|
|
friend bool operator!=(const ptr_iterator& a, const ptr_iterator& b)
|
|
|
|
{
|
|
|
|
return a._v != b._v;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
V* _v;
|
|
|
|
};
|
2023-12-18 23:13:44 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif //BLT_MEMORY_UTIL_H
|