128 lines
2.5 KiB
C++
128 lines
2.5 KiB
C++
#pragma once
|
|
|
|
#include "Module.hpp"
|
|
|
|
#define PTR_OFFSET(first, offset) (*((&first) + offset))
|
|
#define MEMBER_OFFSET(s, m) (alni(&(((s*) 0)->m)))
|
|
|
|
namespace tp {
|
|
|
|
extern ModuleManifest gModuleUtils;
|
|
|
|
void memSetVal(void* p, uhalni byteSize, uint1 val);
|
|
void memCopy(void* left, const void* right, uhalni len);
|
|
int1 memCompare(const void* left, const void* right, uhalni len);
|
|
bool memEqual(const void* left, const void* right, uhalni len);
|
|
int1 memCompareVal(const void* left, uhalni len, uint1 val);
|
|
}
|
|
|
|
namespace tp {
|
|
[[nodiscard]] alnf randomFloat();
|
|
}
|
|
|
|
namespace tp {
|
|
|
|
template <typename T1, typename T2>
|
|
class Pair {
|
|
public:
|
|
Pair() = default;
|
|
|
|
template <typename U1, typename U2>
|
|
Pair(U1 t1, U2 t2) :
|
|
head(static_cast<T1>(t1)),
|
|
tail(static_cast<T2>(t2)) {}
|
|
|
|
union {
|
|
T1 t1;
|
|
T1 head;
|
|
T1 x;
|
|
T1 first;
|
|
};
|
|
|
|
union {
|
|
T2 t2;
|
|
T2 tail;
|
|
T2 y;
|
|
T2 second;
|
|
};
|
|
|
|
bool operator==(const Pair& in) const { return in.t1 == t1 && in.t2 == t2; }
|
|
|
|
bool operator!=(const Pair& in) const { return !this->operator==(in); }
|
|
};
|
|
|
|
template <typename Type = alni>
|
|
class Bits {
|
|
Type mFlags = 0;
|
|
|
|
public:
|
|
Bits() = default;
|
|
|
|
explicit Bits(Type val) { mFlags = val; }
|
|
|
|
explicit Bits(bool val) {
|
|
for (int bit = 0; bit < sizeof(Type); bit++) {
|
|
set(bit, val);
|
|
}
|
|
}
|
|
|
|
bool get(int1 idx) { return mFlags & (1l << idx); }
|
|
|
|
void set(int1 idx, bool val) {
|
|
if (val) {
|
|
mFlags |= (1l << idx);
|
|
} else {
|
|
mFlags &= ~(1l << idx);
|
|
}
|
|
}
|
|
};
|
|
|
|
template <typename tType = ualni>
|
|
class Range {
|
|
public:
|
|
class Iterator {
|
|
public:
|
|
tType mIndex;
|
|
|
|
explicit Iterator(tType pStartIndex) :
|
|
mIndex(pStartIndex) {}
|
|
|
|
tType index() const { return mIndex; }
|
|
|
|
inline void operator++() { mIndex++; }
|
|
|
|
inline operator tType() const { return mIndex; }
|
|
|
|
inline bool operator==(Iterator pIndex) { return mIndex == pIndex.mIndex; }
|
|
|
|
inline bool operator!=(Iterator pIndex) { return mIndex != pIndex.mIndex; }
|
|
|
|
inline const Iterator& operator*() { return *this; }
|
|
};
|
|
|
|
tType mBegin{};
|
|
tType mEnd{};
|
|
|
|
Range() = default;
|
|
|
|
explicit Range(tType pEndIndex) :
|
|
mBegin(0),
|
|
mEnd(pEndIndex) {}
|
|
|
|
Range(tType pStartIndex, tType pEndIndex) :
|
|
mBegin(pStartIndex),
|
|
mEnd(pEndIndex) {}
|
|
|
|
bool valid() const { return mBegin < mEnd; }
|
|
|
|
tType idxBegin() const { return mBegin; }
|
|
|
|
tType idxEnd() const { return mEnd; }
|
|
|
|
tType idxDiff() const { return mEnd - mBegin; }
|
|
|
|
Iterator begin() const { return Iterator(mBegin); }
|
|
|
|
Iterator end() const { return Iterator(mEnd); }
|
|
};
|
|
}
|