sylar/OmniaFramework
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Sync push

Browse source
This commit is contained in:
OmniaX-Dev 2026-05-17 06:46:17 +02:00
parent 14cb854387
commit 5f87625d23
7 changed files with 291 additions and 241 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/ogfx/gui/widgets/TreeView.hpp
View file

@ -32,7 +32,7 @@ namespace ogfx
{ {
class TreeView : public ScrollableWidget class TreeView : public ScrollableWidget
{ {
public: class Item : public ostd::__i_stringeable public: class Item : public ostd::I_stringeable
{ {
public: public:
inline Item(TreeView& parent) { m_treeView = &parent; } inline Item(TreeView& parent) { m_treeView = &parent; }

2
src/ostd/data/AnimationData.hpp
View file

@ -25,7 +25,7 @@
namespace ostd namespace ostd
{ {
struct AnimationData : public ostd::__i_stringeable { struct AnimationData : public ostd::I_stringeable {
i32 frameCount { 1 }; i32 frameCount { 1 };
i32 stillFrame { 0 }; i32 stillFrame { 0 };
f64 fps { 60.0 }; f64 fps { 60.0 };

2
src/ostd/data/BaseObject.hpp
View file

@ -27,7 +27,7 @@ namespace ostd
{ {
class OutputHandlerBase; class OutputHandlerBase;
struct Signal; struct Signal;
class BaseObject : public __i_stringeable, public __i_serializable class BaseObject : public I_stringeable, public I_serializable
{ {
public: using SignalCallback = std::function<void(Signal&)>; public: using SignalCallback = std::function<void(Signal&)>;
public: public:

259
src/ostd/io/Serial.cpp
View file

@ -3,189 +3,209 @@
namespace ostd namespace ostd
{ {
bool Serial::isValidAddress(u64 addr, u32 size) bool Serial::construct(u64 size, Serial::Endianness endianness, bool preInitialize, i8 initialValue)
{ {
if (addr == 0) return false; m_address = 1;
if (size == 0) return false; return m_data.construct(size, endianness, preInitialize, initialValue);
if (addr > u64Range::max() - size) return false; // u64 overflow check
return (addr + size - 1) < s_openStream.size();
} }
Serial::ReadResult<i8> Serial::read::int8(u64 addr) bool Serial::resetAddress(u64 newAddr)
{ {
if (!isStreamAttached()) return { 0, true }; if (newAddr == 0)
managed_address_check(addr); newAddr = 1; // Managed Address should never be 0, if the intent is to reset the managed address to the start of the Stream it will be set to 1
if (!isValidAddress(newAddr))
return false;
m_address = newAddr;
return true;
}
bool Serial::isValidAddress(u64 addr, u32 size) const
{
if (addr == 0) return false; // addr == 0 is managed mode and should never reach this point
if (size == 0) return false;
if (addr > u64Range::max() - size) return false; // u64 overflow check
return (addr + size - 1) < m_data.size();
}
Serial::ReadResult<i8> Serial::Reader::int8(u64 _addr)
{
if (isInvalid()) return { 0, true };
u64& addr = resolve_address(_addr);
if (!isValidAddress(addr, tTypeSize::INT8)) return { 0, true }; if (!isValidAddress(addr, tTypeSize::INT8)) return { 0, true };
i8 val = s_openStream[addr]; i8 val = data[addr];
s_addr += tTypeSize::INT8; addr += tTypeSize::INT8;
return { val, false }; return { val, false };
} }
Serial::ReadResult<u8> Serial::read::uint8(u64 addr) Serial::ReadResult<u8> Serial::Reader::uint8(u64 _addr)
{ {
auto res = int8(addr); auto res = int8(_addr);
return { cast<u8>(res.value), res.error }; return { cast<u8>(res.value), res.error };
} }
Serial::ReadResult<i16> Serial::read::int16(u64 addr) Serial::ReadResult<i16> Serial::Reader::int16(u64 _addr)
{ {
if (!isStreamAttached()) return { 0, true }; if (isInvalid()) return { 0, true };
managed_address_check(addr); u64& addr = resolve_address(_addr);
if (!isValidAddress(addr, tTypeSize::INT16)) return { 0, true }; if (!isValidAddress(addr, tTypeSize::INT16)) return { 0, true };
i16 val = 0; i16 val = 0;
if (isLittleEndian()) if (isLittleEndian())
{ {
val = ((s_openStream[addr + 0] ) & 0x00FFU) val = ((data[addr + 0] ) & 0x00FFU)
| ((s_openStream[addr + 1] << 8) & 0xFF00U); | ((data[addr + 1] << 8) & 0xFF00U);
} }
else if (isBigEndian()) else if (parent.isBigEndian())
{ {
val = ((s_openStream[addr + 0] << 8) & 0xFF00U) val = ((data[addr + 0] << 8) & 0xFF00U)
| ( s_openStream[addr + 1] & 0x00FFU); | ( data[addr + 1] & 0x00FFU);
} }
else return { 0, true }; else return { 0, true };
s_addr += tTypeSize::INT16; addr += tTypeSize::INT16;
return { val, false }; return { val, false };
} }
Serial::ReadResult<u16> Serial::read::uint16(u64 addr) Serial::ReadResult<u16> Serial::Reader::uint16(u64 _addr)
{ {
auto res = int16(addr); auto res = int16(_addr);
return { cast<u16>(res.value), res.error }; return { cast<u16>(res.value), res.error };
} }
Serial::ReadResult<i32> Serial::read::int32(u64 addr) Serial::ReadResult<i32> Serial::Reader::int32(u64 _addr)
{ {
if (!isStreamAttached()) return { 0, true }; if (isInvalid()) return { 0, true };
managed_address_check(addr); u64& addr = resolve_address(_addr);
if (!isValidAddress(addr, tTypeSize::INT32)) return { 0, true }; if (!isValidAddress(addr, tTypeSize::INT32)) return { 0, true };
i32 val = 0; i32 val = 0;
if (isLittleEndian()) if (isLittleEndian())
{ {
val = ((s_openStream[addr + 0] ) & 0x000000FF) val = ((data[addr + 0] ) & 0x000000FF)
| ((s_openStream[addr + 1] << 8) & 0x0000FF00) | ((data[addr + 1] << 8) & 0x0000FF00)
| ((s_openStream[addr + 2] << 16) & 0x00FF0000) | ((data[addr + 2] << 16) & 0x00FF0000)
| ((s_openStream[addr + 3] << 24) & 0xFF000000); | ((data[addr + 3] << 24) & 0xFF000000);
} }
else if (isBigEndian()) else if (isBigEndian())
{ {
val = ((s_openStream[addr + 0] << 24) & 0xFF000000U) val = ((data[addr + 0] << 24) & 0xFF000000U)
| ((s_openStream[addr + 1] << 16) & 0x00FF0000U) | ((data[addr + 1] << 16) & 0x00FF0000U)
| ((s_openStream[addr + 2] << 8) & 0x0000FF00U) | ((data[addr + 2] << 8) & 0x0000FF00U)
| ( s_openStream[addr + 3] & 0x000000FFU); | ( data[addr + 3] & 0x000000FFU);
} }
else return { 0, true }; else return { 0, true };
s_addr += tTypeSize::INT32; addr += tTypeSize::INT32;
return { val, false }; return { val, false };
} }
Serial::ReadResult<u32> Serial::read::uint32(u64 addr) Serial::ReadResult<u32> Serial::Reader::uint32(u64 _addr)
{ {
auto res = int32(addr); auto res = int32(_addr);
return { cast<u32>(res.value), res.error }; return { cast<u32>(res.value), res.error };
} }
Serial::ReadResult<i64> Serial::read::int64(u64 addr) Serial::ReadResult<i64> Serial::Reader::int64(u64 _addr)
{ {
if (!isStreamAttached()) return { 0, true }; if (isInvalid()) return { 0, true };
managed_address_check(addr); u64& addr = resolve_address(_addr);
if (!isValidAddress(addr, tTypeSize::INT64)) return { 0, true }; if (!isValidAddress(addr, tTypeSize::INT64)) return { 0, true };
i64 val = 0; i64 val = 0;
if (isLittleEndian()) if (isLittleEndian())
{ {
val = ( s_openStream[addr + 7] & 0x00000000000000FFU) val = ( data[addr + 7] & 0x00000000000000FFU)
| (( s_openStream[addr + 6] << 8) & 0x000000000000FF00U) | (( data[addr + 6] << 8) & 0x000000000000FF00U)
| (( s_openStream[addr + 5] << 16) & 0x0000000000FF0000U) | (( data[addr + 5] << 16) & 0x0000000000FF0000U)
| (( s_openStream[addr + 4] << 24) & 0x00000000FF000000U) | (( data[addr + 4] << 24) & 0x00000000FF000000U)
| (((i64)s_openStream[addr + 3] << 32) & 0x000000FF00000000U) | (((i64)data[addr + 3] << 32) & 0x000000FF00000000U)
| (((i64)s_openStream[addr + 2] << 40) & 0x0000FF0000000000U) | (((i64)data[addr + 2] << 40) & 0x0000FF0000000000U)
| (((i64)s_openStream[addr + 1] << 48) & 0x00FF000000000000U) | (((i64)data[addr + 1] << 48) & 0x00FF000000000000U)
| (((i64)s_openStream[addr + 0] << 56) & 0xFF00000000000000U); | (((i64)data[addr + 0] << 56) & 0xFF00000000000000U);
} }
else if (isBigEndian()) else if (isBigEndian())
{ {
val = (((i64)s_openStream[addr + 0] << 56) & 0xFF00000000000000U) val = (((i64)data[addr + 0] << 56) & 0xFF00000000000000U)
| (((i64)s_openStream[addr + 1] << 48) & 0x00FF000000000000U) | (((i64)data[addr + 1] << 48) & 0x00FF000000000000U)
| (((i64)s_openStream[addr + 2] << 40) & 0x0000FF0000000000U) | (((i64)data[addr + 2] << 40) & 0x0000FF0000000000U)
| (((i64)s_openStream[addr + 3] << 32) & 0x000000FF00000000U) | (((i64)data[addr + 3] << 32) & 0x000000FF00000000U)
| (( s_openStream[addr + 4] << 24) & 0x00000000FF000000U) | (( data[addr + 4] << 24) & 0x00000000FF000000U)
| (( s_openStream[addr + 5] << 16) & 0x0000000000FF0000U) | (( data[addr + 5] << 16) & 0x0000000000FF0000U)
| (( s_openStream[addr + 6] << 8) & 0x000000000000FF00U) | (( data[addr + 6] << 8) & 0x000000000000FF00U)
| ( s_openStream[addr + 7] & 0x00000000000000FFU); | ( data[addr + 7] & 0x00000000000000FFU);
} }
else return { 0, true }; else return { 0, true };
s_addr += tTypeSize::INT64; addr += tTypeSize::INT64;
return { val, false }; return { val, false };
} }
Serial::ReadResult<u64> Serial::read::uint64(u64 addr) Serial::ReadResult<u64> Serial::Reader::uint64(u64 _addr)
{ {
auto res = int64(addr); auto res = int64(_addr);
return { cast<u64>(res.value), res.error }; return { cast<u64>(res.value), res.error };
} }
Serial::ReadResult<f32> Serial::read::float32(u64 addr) Serial::ReadResult<f32> Serial::Reader::float32(u64 _addr)
{ {
if (!isStreamAttached()) return { 0, true }; if (isInvalid()) return { 0, true };
managed_address_check(addr); u64& addr = resolve_address(_addr);
if (!isValidAddress(addr, tTypeSize::FLOAT32)) return { 0, true }; if (!isValidAddress(addr, tTypeSize::FLOAT32)) return { 0, true };
__float_parser fp; __float_parser fp;
if (isLittleEndian()) if (isLittleEndian())
{ {
fp.data[3] = s_openStream[addr + 0]; fp.data[3] = data[addr + 0];
fp.data[2] = s_openStream[addr + 1]; fp.data[2] = data[addr + 1];
fp.data[1] = s_openStream[addr + 2]; fp.data[1] = data[addr + 2];
fp.data[0] = s_openStream[addr + 3]; fp.data[0] = data[addr + 3];
} }
else if (isBigEndian()) else if (isBigEndian())
{ {
fp.data[0] = s_openStream[addr + 0]; fp.data[0] = data[addr + 0];
fp.data[1] = s_openStream[addr + 1]; fp.data[1] = data[addr + 1];
fp.data[2] = s_openStream[addr + 2]; fp.data[2] = data[addr + 2];
fp.data[3] = s_openStream[addr + 3]; fp.data[3] = data[addr + 3];
} }
else return { 0, true }; else return { 0, true };
s_addr += tTypeSize::FLOAT32; addr += tTypeSize::FLOAT32;
return { fp.val, false }; return { fp.val, false };
} }
Serial::ReadResult<f64> Serial::read::float64(u64 addr) Serial::ReadResult<f64> Serial::Reader::float64(u64 _addr)
{ {
if (!isStreamAttached()) return { 0, true }; if (isInvalid()) return { 0, true };
managed_address_check(addr); u64& addr = resolve_address(_addr);
if (!isValidAddress(addr, tTypeSize::FLOAT64)) return { 0, true }; if (!isValidAddress(addr, tTypeSize::FLOAT64)) return { 0, true };
__double_parser dp; __double_parser dp;
if (isLittleEndian()) if (isLittleEndian())
{ {
dp.data[7] = s_openStream[addr++]; dp.data[7] = data[addr++];
dp.data[6] = s_openStream[addr++]; dp.data[6] = data[addr++];
dp.data[5] = s_openStream[addr++]; dp.data[5] = data[addr++];
dp.data[4] = s_openStream[addr++]; dp.data[4] = data[addr++];
dp.data[3] = s_openStream[addr++]; dp.data[3] = data[addr++];
dp.data[2] = s_openStream[addr++]; dp.data[2] = data[addr++];
dp.data[1] = s_openStream[addr++]; dp.data[1] = data[addr++];
dp.data[0] = s_openStream[addr ]; dp.data[0] = data[addr ];
} }
else if (isBigEndian()) else if (isBigEndian())
{ {
dp.data[0] = s_openStream[addr++]; dp.data[0] = data[addr++];
dp.data[1] = s_openStream[addr++]; dp.data[1] = data[addr++];
dp.data[2] = s_openStream[addr++]; dp.data[2] = data[addr++];
dp.data[3] = s_openStream[addr++]; dp.data[3] = data[addr++];
dp.data[4] = s_openStream[addr++]; dp.data[4] = data[addr++];
dp.data[5] = s_openStream[addr++]; dp.data[5] = data[addr++];
dp.data[6] = s_openStream[addr++]; dp.data[6] = data[addr++];
dp.data[7] = s_openStream[addr ]; dp.data[7] = data[addr ];
} }
else return { 0, true }; else return { 0, true };
s_addr += tTypeSize::FLOAT64; addr += tTypeSize::FLOAT64;
return { dp.val, false }; return { dp.val, false };
} }
bool Serial::read::stream(Stream& outStream, u64 addr, bool sizeStored, u32 size_if_not_stored) bool Serial::Reader::stream(u64 _addr, Stream& outStream, bool sizeStored, u32 size_if_not_stored)
{ {
if (!isStreamAttached()) return false; if (isInvalid()) return false;
managed_address_check(addr); u64& addr = resolve_address(_addr);
if (!sizeStored && size_if_not_stored < 1) return false; if (!sizeStored && size_if_not_stored < 1) return false;
u32 size = size_if_not_stored; u32 size = size_if_not_stored;
if (sizeStored) if (sizeStored)
@ -207,18 +227,18 @@ namespace ostd
else return false; else return false;
} }
if (!isValidAddress(addr, size)) return false; if (!isValidAddress(addr, size)) return false;
Serial::Stream data = { size, endianness }; Serial::Stream _data = { size, endianness };
StreamEdit edit = data.data(); StreamEdit edit = _data.data();
std::copy_n(s_openStream.begin() + addr, size, edit.begin()); std::copy_n(data.begin() + addr, size, edit.begin());
outStream = std::move(data); outStream = std::move(_data);
s_addr = addr + size; addr += size;
return true; return true;
} }
bool Serial::read::string(String& outString, u64 addr, bool sizeStored, u32 size_if_not_stored, bool null_terminated) bool Serial::Reader::string(u64 _addr, String& outString, bool sizeStored, u32 size_if_not_stored, bool null_terminated)
{ {
if (!isStreamAttached()) return false; if (isInvalid()) return false;
managed_address_check(addr); u64& addr = resolve_address(_addr);
if (!null_terminated || sizeStored) // I want null_terminated to have the lowest priority if (!null_terminated || sizeStored) // I want null_terminated to have the lowest priority
{ {
if (!sizeStored && size_if_not_stored < 1) return false; if (!sizeStored && size_if_not_stored < 1) return false;
@ -233,9 +253,9 @@ namespace ostd
if (!isValidAddress(addr, size)) return false; if (!isValidAddress(addr, size)) return false;
for (u64 i = addr; i < (addr + size); i++) for (u64 i = addr; i < (addr + size); i++)
{ {
outString += cast<char>(s_openStream[i]); outString += cast<char>(data[i]);
} }
s_addr = addr + size; addr += size;
return true; return true;
} }
else else
@ -252,12 +272,11 @@ namespace ostd
addr += tTypeSize::INT8; addr += tTypeSize::INT8;
} }
outString = out; outString = out;
s_addr = addr;
return true; return true;
} }
} }
bool Serial::read::object(__i_serializable& outObject, u64 addr) bool Serial::Reader::object(I_serializable& outObject, u64 addr)
{ {
Serial::Stream objData(0); Serial::Stream objData(0);
if (!stream(objData, addr, true, 0)) if (!stream(objData, addr, true, 0))
@ -267,7 +286,7 @@ namespace ostd
bool Serial::write::int8(u64 addr, i8 value) bool Serial::Writer::int8(u64 addr, i8 value)
{ {
if (!isStreamAttached()) return false; if (!isStreamAttached()) return false;
managed_address_check(addr); managed_address_check(addr);
@ -277,12 +296,12 @@ namespace ostd
return true; return true;
} }
bool Serial::write::uint8(u64 addr, u8 value) bool Serial::Writer::uint8(u64 addr, u8 value)
{ {
return int8(addr, cast<i8>(value)); return int8(addr, cast<i8>(value));
} }
bool Serial::write::int16(u64 addr, i16 value) bool Serial::Writer::int16(u64 addr, i16 value)
{ {
if (!isStreamAttached()) return false; if (!isStreamAttached()) return false;
managed_address_check(addr); managed_address_check(addr);
@ -302,12 +321,12 @@ namespace ostd
return true; return true;
} }
bool Serial::write::uint16(u64 addr, u16 value) bool Serial::Writer::uint16(u64 addr, u16 value)
{ {
return int16(addr, cast<i16>(value)); return int16(addr, cast<i16>(value));
} }
bool Serial::write::int32(u64 addr, i32 value) bool Serial::Writer::int32(u64 addr, i32 value)
{ {
if (!isStreamAttached()) return false; if (!isStreamAttached()) return false;
managed_address_check(addr); managed_address_check(addr);
@ -331,12 +350,12 @@ namespace ostd
return true; return true;
} }
bool Serial::write::uint32(u64 addr, u32 value) bool Serial::Writer::uint32(u64 addr, u32 value)
{ {
return int32(addr, cast<i32>(value)); return int32(addr, cast<i32>(value));
} }
bool Serial::write::int64(u64 addr, i64 value) bool Serial::Writer::int64(u64 addr, i64 value)
{ {
if (!isStreamAttached()) return false; if (!isStreamAttached()) return false;
managed_address_check(addr); managed_address_check(addr);
@ -368,14 +387,12 @@ namespace ostd
return true; return true;
} }
bool Serial::write::uint64(u64 addr, u64 value) bool Serial::Writer::uint64(u64 addr, u64 value)
{ {
if (!isStreamAttached()) return false;
if (!isValidAddress(addr, tTypeSize::UINT64)) return false;
return int64(addr, cast<i64>(value)); return int64(addr, cast<i64>(value));
} }
bool Serial::write::float32(u64 addr, f32 value) bool Serial::Writer::float32(u64 addr, f32 value)
{ {
if (!isStreamAttached()) return false; if (!isStreamAttached()) return false;
managed_address_check(addr); managed_address_check(addr);
@ -401,7 +418,7 @@ namespace ostd
return true; return true;
} }
bool Serial::write::float64(u64 addr, f64 value) bool Serial::Writer::float64(u64 addr, f64 value)
{ {
if (!isStreamAttached()) return false; if (!isStreamAttached()) return false;
managed_address_check(addr); managed_address_check(addr);
@ -435,7 +452,7 @@ namespace ostd
return true; return true;
} }
bool Serial::write::stream(u64 addr, const Stream& value, bool storeSize) bool Serial::Writer::stream(u64 addr, const Stream& value, bool storeSize)
{ {
if (!isStreamAttached()) return false; if (!isStreamAttached()) return false;
managed_address_check(addr); managed_address_check(addr);
@ -454,7 +471,7 @@ namespace ostd
return true; return true;
} }
bool Serial::write::string(u64 addr, const String& value, bool storeSize, bool null_terminated) bool Serial::Writer::string(u64 addr, const String& value, bool storeSize, bool null_terminated)
{ {
if (!isStreamAttached()) return false; if (!isStreamAttached()) return false;
managed_address_check(addr); managed_address_check(addr);
@ -480,7 +497,7 @@ namespace ostd
return true; return true;
} }
bool Serial::write::object(u64 addr, const __i_serializable& value) bool Serial::Writer::object(u64 addr, const I_serializable& value)
{ {
if (!isStreamAttached()) return false; if (!isStreamAttached()) return false;
const Serial::Stream data = value.serialize(); const Serial::Stream data = value.serialize();

245
src/ostd/io/Serial.hpp
View file

@ -25,7 +25,7 @@
namespace ostd namespace ostd
{ {
class __i_serializable; class I_serializable;
class Serial class Serial
{ {
public: template<typename T> struct ReadResult { T value; bool error { false }; }; public: template<typename T> struct ReadResult { T value; bool error { false }; };
@ -37,26 +37,13 @@ namespace ostd
public: public:
Stream(const Stream&) = delete; Stream(const Stream&) = delete;
Stream& operator=(const Stream&) = delete; Stream& operator=(const Stream&) = delete;
inline Stream(void) { } // Uninitialized Stream
inline Stream(u64 size, Endianness endianness = Endianness::LittleEndian, bool preInitialize = false, i8 initialValue = 0) { inline Stream(u64 size, Endianness endianness = Endianness::LittleEndian, bool preInitialize = false, i8 initialValue = 0) {
if (size < 1) return; construct(size, endianness, preInitialize, initialValue);
if constexpr (sizeof(size_t) < sizeof(uint64_t))
{
if (size > std::numeric_limits<size_t>::max())
throw "Serial::Stream size can't excede UINT32_MAX on a 32bit system.";
}
m_data = new i8[size];
m_size = size;
m_endianness = endianness;
if (preInitialize)
{
for (u64 i = 0; i < size; i++)
m_data[i] = initialValue;
}
} }
inline Stream(Stream&& other) noexcept : m_data(other.m_data), m_size(other.m_size) { inline Stream(Stream&& other) noexcept : m_data(other.m_data), m_size(other.m_size), m_endianness(other.m_endianness) {
other.m_data = nullptr; other.m_data = nullptr;
other.m_size = 0; other.m_size = 0;
m_endianness = other.m_endianness;
} }
inline Stream& operator=(Stream&& other) noexcept { inline Stream& operator=(Stream&& other) noexcept {
if (this != &other) { if (this != &other) {
@ -73,11 +60,30 @@ namespace ostd
delete[] m_data; delete[] m_data;
m_data = nullptr; m_data = nullptr;
} }
inline bool construct(u64 size, Endianness endianness = Endianness::LittleEndian, bool preInitialize = false, i8 initialValue = 0) {
if (isValid()) return false;
if (size < 1) return false;
if constexpr (sizeof(size_t) < sizeof(uint64_t))
{
if (size > std::numeric_limits<size_t>::max())
throw std::runtime_error("Serial::Stream size can't excede UINT32_MAX on a 32bit system.");
}
m_data = new i8[size];
m_size = size;
m_endianness = endianness;
if (preInitialize)
{
for (u64 i = 0; i < size; i++)
m_data[i] = initialValue;
}
return true;
}
inline bool isValid(void) const { return m_size > 0 && m_data != nullptr; } inline bool isValid(void) const { return m_size > 0 && m_data != nullptr; }
inline u64 size(void) const { return isValid() ? m_size : 0; } inline u64 size(void) const { return isValid() ? m_size : 0; }
inline bool isLittleEndian(void) const { return m_endianness == Endianness::LittleEndian; } inline bool isLittleEndian(void) const { return m_endianness == Endianness::LittleEndian; }
inline bool isBigEndian(void) const { return m_endianness == Endianness::BigEndian; } inline bool isBigEndian(void) const { return m_endianness == Endianness::BigEndian; }
inline Endianness getEndianness(void) const { return m_endianness; } inline Endianness getEndianness(void) const { return m_endianness; }
inline void setEndianness(Endianness endianness) { m_endianness = endianness; }
inline StreamEdit data() { inline StreamEdit data() {
if (isValid()) if (isValid())
return { m_data, cast<std::size_t>(m_size) }; return { m_data, cast<std::size_t>(m_size) };
@ -94,104 +100,131 @@ namespace ostd
u64 m_size { 0 }; u64 m_size { 0 };
Endianness m_endianness { Endianness::LittleEndian }; Endianness m_endianness { Endianness::LittleEndian };
}; };
private: struct Reader
{
inline Reader(Serial& _parent) : parent(_parent) { data = parent.m_data.data(); }
ReadResult<i8> int8(u64 addr);
inline ReadResult<i8> int8(void) { return int8(0); }
ReadResult<u8> uint8(u64 addr);
inline ReadResult<u8> uint8(void) { return uint8(0); }
ReadResult<i16> int16(u64 addr);
inline ReadResult<i16> int16(void) { return int16(0); }
ReadResult<u16> uint16(u64 addr);
inline ReadResult<u16> uint16(void) { return uint16(0); }
ReadResult<i32> int32(u64 addr);
inline ReadResult<i32> int32(void) { return int32(0); }
ReadResult<u32> uint32(u64 addr);
inline ReadResult<u32> uint32(void) { return uint32(0); }
ReadResult<i64> int64(u64 addr);
inline ReadResult<i64> int64(void) { return int64(0); }
ReadResult<u64> uint64(u64 addr);
inline ReadResult<u64> uint64(void) { return uint64(0); }
ReadResult<f32> float32(u64 addr);
inline ReadResult<f32> float32(void) { return float32(0); }
ReadResult<f64> float64(u64 addr);
inline ReadResult<f64> float64(void) { return float64(0); }
bool stream(u64 addr, Stream& outStream, bool sizeStored = true, u32 size_if_not_stored = 0);
inline bool stream(Stream& outStream, bool sizeStored = true, u32 size_if_not_stored = 0) { return stream(0, outStream, sizeStored, size_if_not_stored); }
bool string(u64 addr, String& outString, bool sizeStored = true, u32 size_if_not_stored = 0, bool null_terminated = false);
inline bool string(String& outString, bool sizeStored = true, u32 size_if_not_stored = 0, bool null_terminated = false) { return string(0, outString, sizeStored, size_if_not_stored, null_terminated); }
bool object(u64 addr, I_serializable& outObject);
inline bool object(I_serializable& outObject) { return object(0, outObject); }
private: // Convenience wrappers
inline bool isValid(void) const { return parent.isValid(); }
inline bool isInvalid(void) const { return parent.isInvalid(); }
inline bool isLittleEndian(void) const { return parent.isLittleEndian(); }
inline bool isBigEndian(void) const { return parent.isBigEndian(); }
inline u64& resolve_address(u64& addr) { return parent.resolve_address(addr); }
inline bool isValidAddress(u64 addr, u32 size = 1) const { return parent.isValidAddress(addr); }
private:
Serial& parent;
StreamView data;
};
private: struct Writer
{
inline Writer(Serial& _parent) : parent(_parent) { data = parent.m_data.data(); }
bool int8(u64 addr, i8 value);
inline bool int8(i8 value) { return int8(0, value); }
bool uint8(u64 addr, u8 value);
inline bool uint8(u8 value) { return uint8(0, value); }
bool int16(u64 addr, i16 value);
inline bool int16(i16 value) { return int16(0, value); }
bool uint16(u64 addr, u16 value);
inline bool uint16(u16 value) { return uint16(0, value); }
bool int32(u64 addr, i32 value);
inline bool int32(i32 value) { return int32(0, value); }
bool uint32(u64 addr, u32 value);
inline bool uint32(u32 value) { return uint32(0, value); }
bool int64(u64 addr, i64 value);
inline bool int64(i64 value) { return int64(0, value); }
bool uint64(u64 addr, u64 value);
inline bool uint64(u64 value) { return uint64(0, value); }
bool float32(u64 addr, f32 value);
inline bool float32(f32 value) { return float32(0, value); }
bool float64(u64 addr, f64 value);
inline bool float64(f64 value) { return float64(0, value); }
bool stream(u64 addr, const Stream& value, bool storeSize = true);
inline bool stream(const Stream& value, bool storeSize = true) { return stream(0, value, storeSize); }
bool string(u64 addr, const String& value, bool storeSize = true, bool null_terminated = false); // if sizeStored, null_terminated will be ignored
inline bool string(const String& value, bool storeSize = true, bool null_terminated = false) { return string(0, value, storeSize, null_terminated); }
bool object(u64 addr, const I_serializable& value);
inline bool object(const I_serializable& value) { return object(0, value); }
private: // Convenience wrappers
inline bool isValid(void) const { return parent.isValid(); }
inline bool isInvalid(void) const { return parent.isInvalid(); }
inline bool isLittleEndian(void) const { return parent.isLittleEndian(); }
inline bool isBigEndian(void) const { return parent.isBigEndian(); }
inline u64& resolve_address(u64& addr) { return parent.resolve_address(addr); }
inline bool isValidAddress(u64 addr, u32 size = 1) const { return parent.isValidAddress(addr); }
private:
Serial& parent;
StreamEdit data;
};
public: public:
inline static void attachStream(Stream& stream) { s_openStream = stream.data(); s_endianness = stream.getEndianness(); disableManagedAddress(); } inline Serial(void) : read(*this), write(*this) { }
inline static void detachStrean(void) { s_openStream = {}; } inline Serial(u64 size, Endianness endianness = Endianness::LittleEndian, bool preInitialize = false, i8 initialValue = 0) : read(*this), write(*this) { construct(size, endianness, preInitialize, initialValue); }
inline static bool setManagedAddress(u64 addr) { if (!isManagedAddressEnabled() || !isValidAddress(addr)) return false; s_addr = addr; return true; } bool construct(u64 size, Endianness endianness = Endianness::LittleEndian, bool preInitialize = false, i8 initialValue = 0);
inline static bool isManagedAddressEnabled(void) { return s_managedAddress; } bool resetAddress(u64 newAddr);
inline static void enableManagedAddress(bool enable = true) { s_managedAddress = enable; s_addr = 0; } bool isValidAddress(u64 addr, u32 size = 1) const;
inline static void disableManagedAddress(void) { enableManagedAddress(false); }
inline static bool isStreamAttached(void) { return !s_openStream.empty(); }
inline static bool isLittleEndian(void) { return s_endianness == Endianness::LittleEndian; }
inline static bool isBigEndian(void) { return s_endianness == Endianness::BigEndian; }
static bool isValidAddress(u64 addr, u32 size = 1);
public: struct read inline bool isValid(void) const { return m_data.isValid(); }
{ inline bool isInvalid(void) const { return !isValid(); }
ReadResult<i8> int8(u64 addr = 0); inline bool isLittleEndian(void) const { return m_data.isLittleEndian(); }
inline i8 int8d(u64 addr = 0, bool* outError = nullptr) { auto val = int8(addr); if (outError) *outError = val.error; return val.value; } inline bool isBigEndian(void) const { return m_data.isBigEndian(); }
ReadResult<u8> uint8(u64 addr = 0); inline Endianness getEndianness(void) const { return m_data.getEndianness(); }
inline u8 uint8d(u64 addr = 0, bool* outError = nullptr) { auto val = uint8(addr); if (outError) *outError = val.error; return val.value; }
ReadResult<i16> int16(u64 addr = 0);
inline i16 int16d(u64 addr = 0, bool* outError = nullptr) { auto val = int16(addr); if (outError) *outError = val.error; return val.value; }
ReadResult<u16> uint16(u64 addr = 0);
inline u16 uint16d(u64 addr = 0, bool* outError = nullptr) { auto val = uint16(addr); if (outError) *outError = val.error; return val.value; }
ReadResult<i32> int32(u64 addr = 0);
inline i32 int32d(u64 addr = 0, bool* outError = nullptr) { auto val = int32(addr); if (outError) *outError = val.error; return val.value; }
ReadResult<u32> uint32(u64 addr = 0);
inline u32 uint32d(u64 addr = 0, bool* outError = nullptr) { auto val = uint32(addr); if (outError) *outError = val.error; return val.value; }
ReadResult<i64> int64(u64 addr = 0);
inline i64 int64d(u64 addr = 0, bool* outError = nullptr) { auto val = int64(addr); if (outError) *outError = val.error; return val.value; }
ReadResult<u64> uint64(u64 addr = 0);
inline u64 uint64d(u64 addr = 0, bool* outError = nullptr) { auto val = uint64(addr); if (outError) *outError = val.error; return val.value; }
ReadResult<f32> float32(u64 addr = 0);
inline f32 float32d(u64 addr = 0, bool* outError = nullptr) { auto val = float32(addr); if (outError) *outError = val.error; return val.value; }
ReadResult<f64> float64(u64 addr = 0);
inline f64 float64d(u64 addr = 0, bool* outError = nullptr) { auto val = float64(addr); if (outError) *outError = val.error; return val.value; }
bool stream(Stream& outStream, u64 addr = 0, bool sizeStored = true, u32 size_if_not_stored = 0);
bool string(String& outString, u64 addr = 0, bool sizeStored = true, u32 size_if_not_stored = 0, bool null_terminated = false);
bool object(__i_serializable& outObject, u64 addr = 0);
private:
read(void) = default;
};
public: struct write
{
bool int8(u64 addr, i8 value);
inline bool int8(i8 value) { return int8(0, value); }
bool uint8(u64 addr, u8 value);
inline bool uint8(i8 value) { return uint8(0, value); }
bool int16(u64 addr, i16 value);
inline bool int16(i8 value) { return int16(0, value); }
bool uint16(u64 addr, u16 value);
inline bool uint16(i8 value) { return uint16(0, value); }
bool int32(u64 addr, i32 value);
inline bool int32(i8 value) { return int32(0, value); }
bool uint32(u64 addr, u32 value);
inline bool uint32(i8 value) { return uint32(0, value); }
bool int64(u64 addr, i64 value);
inline bool int64(i8 value) { return int64(0, value); }
bool uint64(u64 addr, u64 value);
inline bool uint64(i8 value) { return uint64(0, value); }
bool float32(u64 addr, f32 value);
inline bool float32(i8 value) { return float32(0, value); }
bool float64(u64 addr, f64 value);
inline bool float64(i8 value) { return float64(0, value); }
bool stream(u64 addr, const Stream& value, bool storeSize = true);
inline bool stream(const Stream& value, bool storeSize = true) { return stream(0, value, storeSize); }
bool string(u64 addr, const String& value, bool storeSize = true, bool null_terminated = false); // if sizeStored, null_terminated will be ignored
inline bool string(const String& value, bool storeSize = true, bool null_terminated = false) { return string(0, value, storeSize, null_terminated); }
bool object(u64 addr, const __i_serializable& value);
inline bool object(const __i_serializable& value) { return object(0, value); }
private:
write(void) = default;
};
private: private:
Serial(void) = default; inline u64& resolve_address(u64& addr) { if (addr == 0) return m_address; return addr; }
inline static void managed_address_check(u64& addr) { if (isManagedAddressEnabled()) addr = s_addr; } inline bool restore_address(void) { resetAddress(m_backupAddress); return false; } // Always returns false so it can be used as false on error in return statements
private: private:
inline static StreamEdit s_openStream { }; Stream m_data;
inline static Endianness s_endianness { Endianness::LittleEndian }; u64 m_address { 0 };
u64 m_backupAddress { 0 };
bool m_backupStored { false };
inline static u64 s_addr { 0 }; public:
inline static bool s_managedAddress { false }; Writer write;
Reader read;
}; };
class __i_serializable class I_serializable
{ {
public: public:
virtual Serial::Stream serialize(void) const = 0; virtual Serial::Stream serialize(void) const = 0;

16
src/ostd/math/Geometry.hpp
View file

@ -44,7 +44,7 @@
namespace ostd namespace ostd
{ {
struct Vec2 : public __i_stringeable struct Vec2 : public I_stringeable
{ {
//======================== Data ======================== //======================== Data ========================
f32 x { 0.0f }; f32 x { 0.0f };
@ -139,7 +139,7 @@ namespace ostd
}; };
template<class T> template<class T>
class Point : public __i_stringeable class Point : public I_stringeable
{ {
public: public:
T x; T x;
@ -194,7 +194,7 @@ namespace ostd
typedef Point<i16> I16Point; typedef Point<i16> I16Point;
typedef Point<i8> I8Point; typedef Point<i8> I8Point;
struct Vec3 : public __i_stringeable struct Vec3 : public I_stringeable
{ {
inline Vec3(f32 xx = 0, f32 yy = 0, f32 zz = 0) inline Vec3(f32 xx = 0, f32 yy = 0, f32 zz = 0)
{ {
@ -216,7 +216,7 @@ namespace ostd
f32 z; f32 z;
}; };
struct Vec4 : public __i_stringeable struct Vec4 : public I_stringeable
{ {
inline Vec4(f32 xx = 0, f32 yy = 0, f32 zz = 0, f32 ww = 0) inline Vec4(f32 xx = 0, f32 yy = 0, f32 zz = 0, f32 ww = 0)
{ {
@ -240,7 +240,7 @@ namespace ostd
f32 w; f32 w;
}; };
struct Triangle : public __i_stringeable struct Triangle : public I_stringeable
{ {
Vec2 vA; Vec2 vA;
Vec2 vB; Vec2 vB;
@ -284,7 +284,7 @@ namespace ostd
} }
}; };
class Rectangle : public __i_stringeable class Rectangle : public I_stringeable
{ {
public: public:
inline Rectangle(void) : x(0), y(0), w(0), h(0) {} inline Rectangle(void) : x(0), y(0), w(0), h(0) {}
@ -431,7 +431,7 @@ namespace ostd
}; };
template<class T> template<class T>
class Rect : public __i_stringeable class Rect : public I_stringeable
{ {
public: public:
Rect(void) = default; Rect(void) = default;
@ -457,7 +457,7 @@ namespace ostd
typedef Rect<i8> I8Rect; typedef Rect<i8> I8Rect;
template<class T> template<class T>
class Line : public __i_stringeable class Line : public I_stringeable
{ {
public: public:
Line(void) = default; Line(void) = default;

6
src/ostd/string/String.hpp
View file

@ -210,15 +210,15 @@ namespace ostd
ostd::cpp_string m_data; ostd::cpp_string m_data;
}; };
struct __i_stringeable struct I_stringeable
{ {
virtual String toString(void) const = 0; virtual String toString(void) const = 0;
friend std::ostream& operator<<(std::ostream& out, const __i_stringeable& val); friend std::ostream& operator<<(std::ostream& out, const I_stringeable& val);
inline operator String() const { return toString(); } inline operator String() const { return toString(); }
inline operator std::string() const { return toString(); } inline operator std::string() const { return toString(); }
}; };
inline std::ostream& operator<<(std::ostream& out, const __i_stringeable& val) inline std::ostream& operator<<(std::ostream& out, const I_stringeable& val)
{ {
out << val.toString(); out << val.toString();
return out; return out;