drinkingtea/nostalgia
drinkingtea/nostalgia
2
0
Fork 0
Code Issues 7 Pull Requests Actions Releases 9 Activity

[ox] Cleanup unnecessary namespace specifications

Browse Source
This commit is contained in:
Gary Talent 2021-05-05 21:12:35 -04:00
parent 72f53b08cb
commit 46ea85fa7d
23 changed files with 101 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
deps/ox/src/ox/claw/read.cpp vendored
View File

@ -64,7 +64,7 @@ Result<Buffer> stripClawHeader(const char *buff, std::size_t buffLen) noexcept {
oxReturnError(header); oxReturnError(header);
Buffer out(header.value.dataSize); Buffer out(header.value.dataSize);
ox_memcpy(out.data(), header.value.data, out.size()); ox_memcpy(out.data(), header.value.data, out.size());
return ox::move(out); return move(out);
} }
} }

14
deps/ox/src/ox/fs/filestore/filestoretemplate.hpp vendored
View File

@ -24,11 +24,11 @@ struct StatInfo {
template<typename size_t> template<typename size_t>
struct OX_PACKED FileStoreItem: public ptrarith::Item<size_t> { struct OX_PACKED FileStoreItem: public ptrarith::Item<size_t> {
ox::LittleEndian<size_t> id = 0; LittleEndian<size_t> id = 0;
ox::LittleEndian<uint8_t> fileType = 0; LittleEndian<uint8_t> fileType = 0;
ox::LittleEndian<size_t> links = 0; LittleEndian<size_t> links = 0;
ox::LittleEndian<size_t> left = 0; LittleEndian<size_t> left = 0;
ox::LittleEndian<size_t> right = 0; LittleEndian<size_t> right = 0;
FileStoreItem() = default; FileStoreItem() = default;
@ -65,8 +65,8 @@ class FileStoreTemplate {
static constexpr auto MaxInode = MaxValue<size_t> / 2; static constexpr auto MaxInode = MaxValue<size_t> / 2;
struct OX_PACKED FileStoreData { struct OX_PACKED FileStoreData {
ox::LittleEndian<size_t> rootNode = 0; LittleEndian<size_t> rootNode = 0;
ox::Random random; Random random;
}; };
size_t m_buffSize = 0; size_t m_buffSize = 0;

2
deps/ox/src/ox/fs/filesystem/filesystem.cpp vendored
View File

@ -56,7 +56,7 @@ Error FileSystem::read(const FileAddress &addr, std::size_t readStart, std::size
} }
} }
Result<Vector<String>> FileSystem::ls(const ox::String &dir) noexcept { Result<Vector<String>> FileSystem::ls(const String &dir) noexcept {
return ls(dir.c_str()); return ls(dir.c_str());
} }

2
deps/ox/src/ox/fs/filesystem/filesystem.hpp vendored
View File

@ -50,7 +50,7 @@ class FileSystem {
Result<const char*> directAccess(const FileAddress &addr) noexcept; Result<const char*> directAccess(const FileAddress &addr) noexcept;
Result<Vector<String>> ls(const ox::String &dir) noexcept; Result<Vector<String>> ls(const String &dir) noexcept;
virtual Result<Vector<String>> ls(const char *dir) noexcept = 0; virtual Result<Vector<String>> ls(const char *dir) noexcept = 0;

4
deps/ox/src/ox/fs/filesystem/passthroughfs.cpp vendored
View File

@ -23,7 +23,7 @@ PassThroughFS::PassThroughFS(const char *dirPath) {
PassThroughFS::~PassThroughFS() { PassThroughFS::~PassThroughFS() {
} }
ox::String PassThroughFS::basePath() { String PassThroughFS::basePath() {
return m_path.string().c_str(); return m_path.string().c_str();
} }
@ -101,7 +101,7 @@ Result<Vector<String>> PassThroughFS::ls(const char *dir) noexcept {
oxReturnError(OxError(ec.value(), "PassThroughFS: ls failed")); oxReturnError(OxError(ec.value(), "PassThroughFS: ls failed"));
for (auto &p : di) { for (auto &p : di) {
auto u8p = p.path().filename().u8string(); auto u8p = p.path().filename().u8string();
out.emplace_back(ox::bit_cast<const char*>(u8p.c_str())); out.emplace_back(bit_cast<const char*>(u8p.c_str()));
} }
return ox::move(out); return ox::move(out);
} }

4
deps/ox/src/ox/fs/filesystem/passthroughfs.hpp vendored
View File

@ -35,7 +35,7 @@ class PassThroughFS: public FileSystem {
~PassThroughFS(); ~PassThroughFS();
[[nodiscard]] [[nodiscard]]
ox::String basePath(); String basePath();
Error mkdir(const char *path, bool recursive = false) noexcept override; Error mkdir(const char *path, bool recursive = false) noexcept override;
@ -95,7 +95,7 @@ Error PassThroughFS::ls(const char *dir, F cb) noexcept {
oxReturnError(OxError(ec.value(), "PassThroughFS: ls failed")); oxReturnError(OxError(ec.value(), "PassThroughFS: ls failed"));
for (auto &p : di) { for (auto &p : di) {
auto u8p = p.path().filename().u8string(); auto u8p = p.path().filename().u8string();
oxReturnError(cb(ox::bit_cast<const char*>(u8p.c_str()), 0)); oxReturnError(cb(bit_cast<const char*>(u8p.c_str()), 0));
} }
return OxError(0); return OxError(0);
} }

12
deps/ox/src/ox/fs/ptrarith/nodebuffer.hpp vendored
View File

@ -20,9 +20,9 @@ class OX_PACKED NodeBuffer {
public: public:
struct OX_PACKED Header { struct OX_PACKED Header {
ox::LittleEndian<size_t> size = sizeof(Header); // capacity LittleEndian<size_t> size = sizeof(Header); // capacity
ox::LittleEndian<size_t> bytesUsed = sizeof(Header); LittleEndian<size_t> bytesUsed = sizeof(Header);
ox::LittleEndian<size_t> firstItem = 0; LittleEndian<size_t> firstItem = 0;
}; };
using ItemPtr = Ptr<Item, size_t, sizeof(Header)>; using ItemPtr = Ptr<Item, size_t, sizeof(Header)>;
@ -435,11 +435,11 @@ uint8_t *NodeBuffer<size_t, Item>::data() noexcept {
template<typename size_t> template<typename size_t>
struct OX_PACKED Item { struct OX_PACKED Item {
public: public:
ox::LittleEndian<size_t> prev = 0; LittleEndian<size_t> prev = 0;
ox::LittleEndian<size_t> next = 0; LittleEndian<size_t> next = 0;
private: private:
ox::LittleEndian<size_t> m_size = sizeof(Item); LittleEndian<size_t> m_size = sizeof(Item);
public: public:
size_t size() const { size_t size() const {

2
deps/ox/src/ox/model/desctypes.hpp vendored
View File

@ -179,6 +179,6 @@ Error modelRead(T *io, DescriptorField *field) {
return err; return err;
} }
using TypeStore = ox::HashMap<ModelString, DescriptorType*>; using TypeStore = HashMap<ModelString, DescriptorType*>;
} }

2
deps/ox/src/ox/model/descwrite.hpp vendored
View File

@ -145,7 +145,7 @@ class TypeDescWriter {
template<typename T> template<typename T>
Error TypeDescWriter::field(const char *name, T *val, std::size_t) { Error TypeDescWriter::field(const char *name, T *val, std::size_t) {
if (m_type) { if (m_type) {
constexpr typename ox::remove_pointer<decltype(val)>::type *p = nullptr; constexpr typename remove_pointer<decltype(val)>::type *p = nullptr;
bool alreadyExisted = false; bool alreadyExisted = false;
const auto t = type(p, &alreadyExisted); const auto t = type(p, &alreadyExisted);
oxAssert(t != nullptr, "field(const char *name, T *val, std::size_t): Type not found or generated"); oxAssert(t != nullptr, "field(const char *name, T *val, std::size_t): Type not found or generated");

6
deps/ox/src/ox/model/optype.hpp vendored
View File

@ -40,11 +40,11 @@ constexpr Error modelWriteDefinition(T*, O*) {
template<typename T, typename O> template<typename T, typename O>
constexpr Error model(T *io, O *obj) { constexpr Error model(T *io, O *obj) {
Error err; Error err;
if constexpr(ox_strcmp(T::opType(), ox::OpType::Read) == 0) { if constexpr(ox_strcmp(T::opType(), OpType::Read) == 0) {
err = modelRead(io, obj); err = modelRead(io, obj);
} else if constexpr(ox_strcmp(T::opType(), ox::OpType::Write) == 0) { } else if constexpr(ox_strcmp(T::opType(), OpType::Write) == 0) {
err = modelWrite(io, obj); err = modelWrite(io, obj);
} else if constexpr(ox_strcmp(T::opType(), ox::OpType::WriteDefinition) == 0) { } else if constexpr(ox_strcmp(T::opType(), OpType::WriteDefinition) == 0) {
err = modelWriteDefinition(io, obj); err = modelWriteDefinition(io, obj);
} }
oxAssert(err, "Missing model function"); oxAssert(err, "Missing model function");

6
deps/ox/src/ox/model/types.hpp vendored
View File

@ -60,7 +60,7 @@ class SerStr {
public: public:
template<std::size_t sz> template<std::size_t sz>
constexpr SerStr(BString<sz> *str) noexcept { explicit constexpr SerStr(BString<sz> *str) noexcept {
m_str = str->data(); m_str = str->data();
m_cap = str->cap(); m_cap = str->cap();
} }
@ -70,14 +70,14 @@ class SerStr {
m_cap = cap; m_cap = cap;
} }
constexpr SerStr(char **tgt, int cap = -1) noexcept { explicit constexpr SerStr(char **tgt, int cap = -1) noexcept {
m_tgt = tgt; m_tgt = tgt;
m_str = const_cast<char*>(*tgt); m_str = const_cast<char*>(*tgt);
m_cap = cap; m_cap = cap;
} }
template<std::size_t cap> template<std::size_t cap>
constexpr SerStr(char (&str)[cap]) noexcept { explicit constexpr SerStr(char (&str)[cap]) noexcept {
m_str = str; m_str = str;
m_cap = cap; m_cap = cap;
} }

28
deps/ox/src/ox/std/byteswap.hpp vendored
View File

@ -75,7 +75,7 @@ class OX_PACKED ByteSwapInteger {
m_value = other.m_value; m_value = other.m_value;
} }
constexpr ByteSwapInteger(T value) noexcept: m_value(ox::conditionalByteSwap<T, byteSwap>(value)) { constexpr ByteSwapInteger(T value) noexcept: m_value(conditionalByteSwap<T, byteSwap>(value)) {
} }
constexpr const ByteSwapInteger &operator=(const ByteSwapInteger &other) noexcept { constexpr const ByteSwapInteger &operator=(const ByteSwapInteger &other) noexcept {
@ -85,39 +85,39 @@ class OX_PACKED ByteSwapInteger {
template<typename I> template<typename I>
constexpr T operator=(I value) noexcept { constexpr T operator=(I value) noexcept {
m_value = ox::conditionalByteSwap<T, byteSwap>(value); m_value = conditionalByteSwap<T, byteSwap>(value);
return value; return value;
} }
constexpr operator T() const noexcept { constexpr operator T() const noexcept {
return ox::conditionalByteSwap<T, byteSwap>(m_value); return conditionalByteSwap<T, byteSwap>(m_value);
} }
template<typename I> template<typename I>
constexpr T operator+=(I other) noexcept { constexpr T operator+=(I other) noexcept {
auto newVal = *this + other; auto newVal = *this + other;
m_value = ox::conditionalByteSwap<T, byteSwap>(newVal); m_value = conditionalByteSwap<T, byteSwap>(newVal);
return newVal; return newVal;
} }
template<typename I> template<typename I>
constexpr T operator-=(I other) noexcept { constexpr T operator-=(I other) noexcept {
auto newVal = *this - other; auto newVal = *this - other;
m_value = ox::conditionalByteSwap<T, byteSwap>(newVal); m_value = conditionalByteSwap<T, byteSwap>(newVal);
return newVal; return newVal;
} }
template<typename I> template<typename I>
constexpr T operator*=(I other) noexcept { constexpr T operator*=(I other) noexcept {
auto newVal = *this * other; auto newVal = *this * other;
m_value = ox::conditionalByteSwap<T, byteSwap>(newVal); m_value = conditionalByteSwap<T, byteSwap>(newVal);
return newVal; return newVal;
} }
template<typename I> template<typename I>
constexpr T operator/=(I other) noexcept { constexpr T operator/=(I other) noexcept {
auto newVal = *this / other; auto newVal = *this / other;
m_value = ox::conditionalByteSwap<T, byteSwap>(newVal); m_value = conditionalByteSwap<T, byteSwap>(newVal);
return newVal; return newVal;
} }
@ -148,35 +148,35 @@ class OX_PACKED ByteSwapInteger {
template<typename I> template<typename I>
constexpr T operator&=(I other) noexcept { constexpr T operator&=(I other) noexcept {
auto newVal = *this & other; auto newVal = *this & other;
m_value = ox::conditionalByteSwap<T, byteSwap>(newVal); m_value = conditionalByteSwap<T, byteSwap>(newVal);
return newVal; return newVal;
} }
template<typename I> template<typename I>
constexpr T operator|=(I other) noexcept { constexpr T operator|=(I other) noexcept {
auto newVal = *this | other; auto newVal = *this | other;
m_value = ox::conditionalByteSwap<T, byteSwap>(newVal); m_value = conditionalByteSwap<T, byteSwap>(newVal);
return newVal; return newVal;
} }
template<typename I> template<typename I>
constexpr T operator^=(I other) noexcept { constexpr T operator^=(I other) noexcept {
auto newVal = *this ^ other; auto newVal = *this ^ other;
m_value = ox::conditionalByteSwap<T, byteSwap>(newVal); m_value = conditionalByteSwap<T, byteSwap>(newVal);
return newVal; return newVal;
} }
template<typename I> template<typename I>
constexpr T operator>>=(I other) noexcept { constexpr T operator>>=(I other) noexcept {
auto newVal = *this >> other; auto newVal = *this >> other;
m_value = ox::conditionalByteSwap<T, byteSwap>(newVal); m_value = conditionalByteSwap<T, byteSwap>(newVal);
return newVal; return newVal;
} }
template<typename I> template<typename I>
constexpr T operator<<=(I other) noexcept { constexpr T operator<<=(I other) noexcept {
auto newVal = *this << other; auto newVal = *this << other;
m_value = ox::conditionalByteSwap<T, byteSwap>(newVal); m_value = conditionalByteSwap<T, byteSwap>(newVal);
return newVal; return newVal;
} }
@ -198,9 +198,9 @@ class OX_PACKED ByteSwapInteger {
}; };
template<typename T> template<typename T>
using LittleEndian = ByteSwapInteger<T, ox::defines::BigEndian>; using LittleEndian = ByteSwapInteger<T, defines::BigEndian>;
template<typename T> template<typename T>
using BigEndian = ByteSwapInteger<T, ox::defines::LittleEndian>; using BigEndian = ByteSwapInteger<T, defines::LittleEndian>;
} }

6
deps/ox/src/ox/std/error.hpp vendored
View File

@ -59,7 +59,7 @@ struct [[nodiscard]] Error {
template<typename T> template<typename T>
struct [[nodiscard]] Result { struct [[nodiscard]] Result {
using type = typename ox::remove_reference<T>::type; using type = typename remove_reference<T>::type;
T value; T value;
Error error; Error error;
@ -73,7 +73,7 @@ struct [[nodiscard]] Result {
constexpr Result(const type &value, const Error &error = OxError(0)) noexcept: value(const_cast<type&>(value)), error(error) { constexpr Result(const type &value, const Error &error = OxError(0)) noexcept: value(const_cast<type&>(value)), error(error) {
} }
constexpr Result(type &&value, const Error &error = OxError(0)) noexcept: value(ox::move(value)), error(error) { constexpr Result(type &&value, const Error &error = OxError(0)) noexcept: value(move(value)), error(error) {
} }
explicit constexpr operator const type&() const noexcept { explicit constexpr operator const type&() const noexcept {
@ -100,7 +100,7 @@ struct [[nodiscard]] Result {
} }
constexpr Error moveTo(type *val) noexcept { constexpr Error moveTo(type *val) noexcept {
*val = ox::move(value); *val = move(value);
return error; return error;
} }

4
deps/ox/src/ox/std/fmt.hpp vendored
View File

@ -29,11 +29,11 @@ constexpr const char *stringify(const char *s) noexcept {
} }
template<std::size_t size> template<std::size_t size>
constexpr const char *stringify(const ox::BString<size> &s) noexcept { constexpr const char *stringify(const BString<size> &s) noexcept {
return s.c_str(); return s.c_str();
} }
constexpr const char *stringify(const ox::String &s) noexcept { constexpr const char *stringify(const String &s) noexcept {
return s.c_str(); return s.c_str();
} }

8
deps/ox/src/ox/std/hashmap.hpp vendored
View File

@ -96,8 +96,8 @@ HashMap<K, T>::HashMap(const HashMap<K, T> &other) {
template<typename K, typename T> template<typename K, typename T>
HashMap<K, T>::HashMap(HashMap<K, T> &&other) { HashMap<K, T>::HashMap(HashMap<K, T> &&other) {
m_keys = ox::move(other.m_keys); m_keys = move(other.m_keys);
m_pairs = ox::move(other.m_pairs); m_pairs = move(other.m_pairs);
} }
template<typename K, typename T> template<typename K, typename T>
@ -133,8 +133,8 @@ template<typename K, typename T>
HashMap<K, T> &HashMap<K, T>::operator=(HashMap<K, T> &&other) { HashMap<K, T> &HashMap<K, T>::operator=(HashMap<K, T> &&other) {
if (this != &other) { if (this != &other) {
clear(); clear();
m_keys = ox::move(other.m_keys); m_keys = move(other.m_keys);
m_pairs = ox::move(other.m_pairs); m_pairs = move(other.m_pairs);
} }
return *this; return *this;
} }

16
deps/ox/src/ox/std/heapmgr.cpp vendored
View File

@ -25,29 +25,29 @@ static constexpr std::size_t alignedSize(T = {}) noexcept {
return alignedSize(sizeof(T)); return alignedSize(sizeof(T));
} }
void HeapSegment::init(std::size_t maxSize = ox::bit_cast<std::size_t>(g_heapEnd)) noexcept { void HeapSegment::init(std::size_t maxSize = bit_cast<std::size_t>(g_heapEnd)) noexcept {
this->size = maxSize - ox::bit_cast<std::size_t>(this); this->size = maxSize - bit_cast<std::size_t>(this);
this->inUse = false; this->inUse = false;
} }
template<typename T> template<typename T>
T *HeapSegment::data() noexcept { T *HeapSegment::data() noexcept {
return ox::bit_cast<T*>(ox::bit_cast<uint8_t*>(this) + alignedSize(this)); return bit_cast<T*>(bit_cast<uint8_t*>(this) + alignedSize(this));
} }
template<typename T> template<typename T>
T *HeapSegment::end() noexcept { T *HeapSegment::end() noexcept {
const auto size = alignedSize(this) + alignedSize(this->size); const auto size = alignedSize(this) + alignedSize(this->size);
auto e = ox::bit_cast<uintptr_t>(ox::bit_cast<uint8_t*>(this) + size); auto e = bit_cast<uintptr_t>(bit_cast<uint8_t*>(this) + size);
return ox::bit_cast<T*>(e); return bit_cast<T*>(e);
} }
void initHeap(char *heapBegin, char *heapEnd) noexcept { void initHeap(char *heapBegin, char *heapEnd) noexcept {
g_heapBegin = ox::bit_cast<HeapSegment*>(heapBegin); g_heapBegin = bit_cast<HeapSegment*>(heapBegin);
g_heapEnd = ox::bit_cast<HeapSegment*>(heapEnd); g_heapEnd = bit_cast<HeapSegment*>(heapEnd);
heapIdx = g_heapBegin; heapIdx = g_heapBegin;
heapIdx->size = ox::bit_cast<std::size_t>(heapEnd) - ox::bit_cast<std::size_t>(heapIdx); heapIdx->size = bit_cast<std::size_t>(heapEnd) - bit_cast<std::size_t>(heapIdx);
heapIdx->inUse = false; heapIdx->inUse = false;
} }

2
deps/ox/src/ox/std/new.hpp vendored
View File

@ -46,7 +46,7 @@ constexpr void *operator new[](std::size_t, void *addr) noexcept {
namespace ox { namespace ox {
constexpr auto MallocaStackLimit = ox::defines::UseStdLib ? 1024 : 0; constexpr auto MallocaStackLimit = defines::UseStdLib ? 1024 : 0;
/** /**
* MallocaPtr will automatically cleanup the pointed to address upon * MallocaPtr will automatically cleanup the pointed to address upon

4
deps/ox/src/ox/std/random.cpp vendored
View File

@ -28,8 +28,8 @@ uint64_t Random::gen() noexcept {
auto retval = s0 + s1; auto retval = s0 + s1;
s1 ^= s0; s1 ^= s0;
m_seed[0] = ox::rotl(s0, 55) ^ s1 ^ (s1 << 14); m_seed[0] = rotl(s0, 55) ^ s1 ^ (s1 << 14);
m_seed[1] = ox::rotl(s1, 36); m_seed[1] = rotl(s1, 36);
return retval; return retval;
} }

4
deps/ox/src/ox/std/string.cpp vendored
View File

@ -44,7 +44,7 @@ String::String(const String &other) noexcept {
} }
String::String(String &&other) noexcept { String::String(String &&other) noexcept {
m_buff = ox::move(other.m_buff); m_buff = move(other.m_buff);
} }
String &String::operator=(const char *str) noexcept { String &String::operator=(const char *str) noexcept {
@ -80,7 +80,7 @@ String &String::operator=(const String &src) noexcept {
} }
String &String::operator=(String &&src) noexcept { String &String::operator=(String &&src) noexcept {
m_buff = ox::move(src.m_buff); m_buff = move(src.m_buff);
return *this; return *this;
} }

4
deps/ox/src/ox/std/trace.hpp vendored
View File

@ -34,11 +34,11 @@ struct TraceMsg {
int line = 0; int line = 0;
uint64_t time = 0; uint64_t time = 0;
const char *ch = ""; const char *ch = "";
ox::BString<100> msg; BString<100> msg;
}; };
template<typename T> template<typename T>
constexpr Error model(T *io, ox::trace::TraceMsg *obj) { constexpr Error model(T *io, TraceMsg *obj) {
io->template setTypeInfo<TraceMsg>(); io->template setTypeInfo<TraceMsg>();
oxReturnError(io->field("ch", &obj->ch)); oxReturnError(io->field("ch", &obj->ch));
oxReturnError(io->field("file", &obj->file)); oxReturnError(io->field("file", &obj->file));

54
deps/ox/src/ox/std/typetraits.hpp vendored
View File

@ -45,42 +45,42 @@ struct integral_constant {
}; };
using false_type = ox::integral_constant<bool, false>; using false_type = integral_constant<bool, false>;
using true_type = ox::integral_constant<bool, true>; using true_type = integral_constant<bool, true>;
// is_integral ///////////////////////////////////////////////////////////////// // is_integral /////////////////////////////////////////////////////////////////
template<typename T> struct is_integral: ox::false_type {}; template<typename T> struct is_integral: false_type {};
template<> struct is_integral<bool> : ox::true_type {}; template<> struct is_integral<bool> : true_type {};
template<> struct is_integral<wchar_t> : ox::true_type {}; template<> struct is_integral<wchar_t> : true_type {};
template<> struct is_integral<int8_t> : ox::true_type {}; template<> struct is_integral<int8_t> : true_type {};
template<> struct is_integral<uint8_t> : ox::true_type {}; template<> struct is_integral<uint8_t> : true_type {};
template<> struct is_integral<int16_t> : ox::true_type {}; template<> struct is_integral<int16_t> : true_type {};
template<> struct is_integral<uint16_t>: ox::true_type {}; template<> struct is_integral<uint16_t>: true_type {};
template<> struct is_integral<int32_t> : ox::true_type {}; template<> struct is_integral<int32_t> : true_type {};
template<> struct is_integral<uint32_t>: ox::true_type {}; template<> struct is_integral<uint32_t>: true_type {};
// some of these need to be done with the actual language syntax because no one // some of these need to be done with the actual language syntax because no one
// can agree on what an (u)int64_t is... // can agree on what an (u)int64_t is...
template<> struct is_integral<long>: ox::true_type {}; template<> struct is_integral<long>: true_type {};
template<> struct is_integral<long long>: ox::true_type {}; template<> struct is_integral<long long>: true_type {};
template<> struct is_integral<unsigned long>: ox::true_type {}; template<> struct is_integral<unsigned long>: true_type {};
template<> struct is_integral<unsigned long long>: ox::true_type {}; template<> struct is_integral<unsigned long long>: true_type {};
template<typename T> template<typename T>
constexpr bool is_integral_v = ox::is_integral<T>::value; constexpr bool is_integral_v = is_integral<T>::value;
template<typename T> struct is_bool: ox::false_type {}; template<typename T> struct is_bool: false_type {};
template<> struct is_bool<bool> : ox::true_type {}; template<> struct is_bool<bool> : true_type {};
template<typename T> template<typename T>
constexpr bool is_bool_v = ox::is_bool<T>::value; constexpr bool is_bool_v = is_bool<T>::value;
template<typename T> struct is_union: ox::integral_constant<bool, std::is_union_v<T>> {}; template<typename T> struct is_union: integral_constant<bool, std::is_union_v<T>> {};
template<typename T> template<typename T>
constexpr bool is_union_v = ox::is_union<T>(); constexpr bool is_union_v = is_union<T>();
// indicates the type can have members, but not that it necessarily does // indicates the type can have members, but not that it necessarily does
template<typename T> template<typename T>
@ -89,21 +89,21 @@ template<typename T>
constexpr bool memberable(...) { return false; } constexpr bool memberable(...) { return false; }
template<typename T> template<typename T>
struct is_class: ox::integral_constant<bool, !ox::is_union<T>::value && ox::memberable<T>(0)> {}; struct is_class: integral_constant<bool, !is_union<T>::value && memberable<T>(0)> {};
namespace test { namespace test {
struct TestClass {int i;}; struct TestClass {int i;};
union TestUnion {int i;}; union TestUnion {int i;};
static_assert(ox::is_class<TestClass>::value == true); static_assert(is_class<TestClass>::value == true);
static_assert(ox::is_class<TestUnion>::value == false); static_assert(is_class<TestUnion>::value == false);
static_assert(ox::is_class<int>::value == false); static_assert(is_class<int>::value == false);
} }
template<typename T> template<typename T>
constexpr bool is_class_v = ox::is_class<T>(); constexpr bool is_class_v = is_class<T>();
template<typename T> template<typename T>
constexpr bool is_signed_v = ox::integral_constant<bool, T(-1) < T(0)>::value; constexpr bool is_signed_v = integral_constant<bool, T(-1) < T(0)>::value;
// enable_if /////////////////////////////////////////////////////////////////// // enable_if ///////////////////////////////////////////////////////////////////

4
deps/ox/src/ox/std/utility.hpp vendored
View File

@ -13,8 +13,8 @@
namespace ox { namespace ox {
template<typename T> template<typename T>
constexpr typename ox::remove_reference<T>::type &&move(T &&t) noexcept { constexpr typename remove_reference<T>::type &&move(T &&t) noexcept {
return static_cast<typename ox::remove_reference<T>::type&&>(t); return static_cast<typename remove_reference<T>::type&&>(t);
} }
} }

12
deps/ox/src/ox/std/vector.hpp vendored
View File

@ -124,7 +124,7 @@ Vector<T>::Vector(const Vector<T> &other) {
m_cap = other.m_cap; m_cap = other.m_cap;
m_items = bit_cast<T*>(new AllocAlias<T>[m_cap]); m_items = bit_cast<T*>(new AllocAlias<T>[m_cap]);
for (std::size_t i = 0; i < m_size; i++) { for (std::size_t i = 0; i < m_size; i++) {
m_items[i] = ox::move(other.m_items[i]); m_items[i] = move(other.m_items[i]);
} }
} }
@ -246,7 +246,7 @@ bool Vector<T>::empty() const noexcept {
template<typename T> template<typename T>
void Vector<T>::clear() { void Vector<T>::clear() {
if constexpr(ox::is_class<T>()) { if constexpr(is_class<T>()) {
for (std::size_t i = 0; i < m_size; ++i) { for (std::size_t i = 0; i < m_size; ++i) {
m_items[i].~T(); m_items[i].~T();
} }
@ -288,7 +288,7 @@ void Vector<T>::insert(std::size_t pos, const T &val) {
expandCap(m_cap ? m_cap * 2 : 100); expandCap(m_cap ? m_cap * 2 : 100);
} }
for (auto i = m_size; i > pos; --i) { for (auto i = m_size; i > pos; --i) {
m_items[i] = ox::move(m_items[i - 1]); m_items[i] = move(m_items[i - 1]);
} }
m_items[pos] = val; m_items[pos] = val;
++m_size; ++m_size;
@ -326,7 +326,7 @@ Error Vector<T>::erase(std::size_t pos) {
} }
--m_size; --m_size;
for (auto i = pos; i < m_size; ++i) { for (auto i = pos; i < m_size; ++i) {
m_items[i] = ox::move(m_items[i + 1]); m_items[i] = move(m_items[i + 1]);
} }
return OxError(0); return OxError(0);
} }
@ -337,7 +337,7 @@ Error Vector<T>::unordered_erase(std::size_t pos) {
return OxError(1); return OxError(1);
} }
m_size--; m_size--;
m_items[pos] = ox::move(m_items[m_size]); m_items[pos] = move(m_items[m_size]);
return OxError(0); return OxError(0);
} }
@ -349,7 +349,7 @@ void Vector<T>::expandCap(std::size_t cap) {
if (oldItems) { // move over old items if (oldItems) { // move over old items
const auto itRange = cap > m_size ? m_size : cap; const auto itRange = cap > m_size ? m_size : cap;
for (std::size_t i = 0; i < itRange; i++) { for (std::size_t i = 0; i < itRange; i++) {
m_items[i] = ox::move(oldItems[i]); m_items[i] = move(oldItems[i]);
} }
for (std::size_t i = itRange; i < m_cap; i++) { for (std::size_t i = itRange; i < m_cap; i++) {
new (&m_items[i]) T; new (&m_items[i]) T;