INSANEMODE/OpenAssetTools
1
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2025-06-22 12:47:53 -05:00
Code Issues Packages Projects Releases Wiki Activity

ZoneWriting stuff

Browse Source
This commit is contained in:
Jan
2021-03-16 12:37:15 +01:00
parent 9d26c9c927
commit 4feea62280
15 changed files with 625 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
src/ZoneWriting/Zone/Stream/IZoneOutputStream.h
View File

@ -9,42 +9,52 @@
class IZoneOutputStream : public IZoneStream
{
public:
static constexpr void* PTR_FOLLOWING = reinterpret_cast<void*>(-1);
static constexpr void* PTR_INSERT = reinterpret_cast<void*>(-2);
virtual void Align(int alignTo) = 0;
virtual void* WriteDataRaw(void* dst, size_t size) = 0;
virtual void* WriteDataInBlock(void* dst, size_t size) = 0;
virtual void* WriteDataRaw(const void* dst, size_t size) = 0;
virtual void* WriteDataInBlock(const void* dst, size_t size) = 0;
virtual void IncBlockPos(size_t size) = 0;
virtual void WriteNullTerminated(void* dst) = 0;
virtual void WriteNullTerminated(const void* dst) = 0;
virtual bool ReusableShouldWrite(void** pPtr, size_t size, size_t count, std::type_index type) = 0;
virtual void MarkFollowing(void** pPtr) = 0;
template<typename T>
bool ReusableShouldWrite(T** pPtr)
{
return ReusableShouldWrite(pPtr, sizeof(T), 1, std::type_index(typeid(T)));
return ReusableShouldWrite(reinterpret_cast<void**>(reinterpret_cast<uintptr_t>(pPtr)), sizeof(T), 1, std::type_index(typeid(T)));
}
template<typename T>
bool ReusableShouldWrite(T** pPtr, size_t count)
bool ReusableShouldWrite(T** pPtr, const size_t count)
{
return ReusableShouldWrite(pPtr, sizeof(T), count, std::type_index(typeid(T)));
return ReusableShouldWrite(reinterpret_cast<void**>(reinterpret_cast<uintptr_t>(pPtr)), sizeof(T), count, std::type_index(typeid(T)));
}
template<typename T>
T* Write(T* dst)
{
return static_cast<T*>(WriteDataInBlock(const_cast<void*>(reinterpret_cast<const void*>(dst)), sizeof(T)));
return static_cast<T*>(WriteDataInBlock(reinterpret_cast<const void*>(dst), sizeof(T)));
}
template<typename T>
T* Write(T* dst, const uint32_t count)
{
return static_cast<T*>(WriteDataInBlock(const_cast<void*>(reinterpret_cast<const void*>(dst)), count * sizeof(T)));
return static_cast<T*>(WriteDataInBlock(reinterpret_cast<const void*>(dst), count * sizeof(T)));
}
template<typename T>
T* WritePartial(T* dst, const size_t size)
{
return static_cast<T*>(WriteDataInBlock(const_cast<void*>(reinterpret_cast<const void*>(dst)), size));
return static_cast<T*>(WriteDataInBlock(reinterpret_cast<const void*>(dst), size));
}
template<typename T>
void MarkFollowing(T*& ptr)
{
MarkFollowing(reinterpret_cast<void**>(reinterpret_cast<uintptr_t>(&ptr)));
}
};

27
src/ZoneWriting/Zone/Stream/Impl/InMemoryZoneOutputStream.cpp
View File

@ -64,7 +64,7 @@ void InMemoryZoneOutputStream::Align(const int align)
{
assert(!m_block_stack.empty());
if (align > 0)
if (align > 1)
{
auto* block = m_block_stack.top();
@ -75,14 +75,14 @@ void InMemoryZoneOutputStream::Align(const int align)
}
}
void* InMemoryZoneOutputStream::WriteDataRaw(void* src, const size_t size)
void* InMemoryZoneOutputStream::WriteDataRaw(const void* src, const size_t size)
{
auto* result = m_zone_data->GetBufferOfSize(size);
memcpy(result, src, size);
return result;
}
void* InMemoryZoneOutputStream::WriteDataInBlock(void* src, const size_t size)
void* InMemoryZoneOutputStream::WriteDataInBlock(const void* src, const size_t size)
{
assert(!m_block_stack.empty());
@ -130,9 +130,9 @@ void InMemoryZoneOutputStream::IncBlockPos(const size_t size)
}
}
void InMemoryZoneOutputStream::WriteNullTerminated(void* src)
void InMemoryZoneOutputStream::WriteNullTerminated(const void* src)
{
const auto len = strlen(static_cast<char*>(src));
const auto len = strlen(static_cast<const char*>(src));
WriteDataInBlock(src, len + 1);
}
@ -161,9 +161,20 @@ uintptr_t InMemoryZoneOutputStream::InsertPointer()
return result;
}
void InMemoryZoneOutputStream::MarkFollowing(void** pPtr)
{
assert(!m_block_stack.empty());
assert(pPtr != nullptr);
*pPtr = m_block_stack.top()->m_type == XBlock::Type::BLOCK_TYPE_TEMP ? PTR_INSERT : PTR_FOLLOWING;
}
bool InMemoryZoneOutputStream::ReusableShouldWrite(void** pPtr, const size_t entrySize, const size_t entryCount, std::type_index type)
{
assert(!m_block_stack.empty());
assert(pPtr != nullptr);
if (*pPtr == nullptr)
return false;
const auto inTemp = m_block_stack.top()->m_type == XBlock::Type::BLOCK_TYPE_TEMP;
const auto foundEntriesForType = m_reusable_entries.find(type);
@ -173,8 +184,7 @@ bool InMemoryZoneOutputStream::ReusableShouldWrite(void** pPtr, const size_t ent
auto zoneOffset = inTemp ? InsertPointer() : GetCurrentZonePointer();
entries.emplace_back(*pPtr, entrySize, entryCount, zoneOffset);
m_reusable_entries.emplace(std::make_pair(type, std::move(entries)));
*pPtr = inTemp ? PTR_INSERT : PTR_FOLLOWING;
return true;
}
@ -190,7 +200,6 @@ bool InMemoryZoneOutputStream::ReusableShouldWrite(void** pPtr, const size_t ent
auto zoneOffset = inTemp ? InsertPointer() : GetCurrentZonePointer();
foundEntriesForType->second.emplace_back(*pPtr, entrySize, entryCount, zoneOffset);
*pPtr = inTemp ? PTR_INSERT : PTR_FOLLOWING;
return true;
}

10
src/ZoneWriting/Zone/Stream/Impl/InMemoryZoneOutputStream.h
View File

@ -9,9 +9,6 @@
class InMemoryZoneOutputStream final : public IZoneOutputStream
{
static constexpr void* PTR_FOLLOWING = reinterpret_cast<void*>(-1);
static constexpr void* PTR_INSERT = reinterpret_cast<void*>(-2);
class ReusableEntry
{
public:
@ -44,9 +41,10 @@ public:
void PushBlock(block_t block) override;
block_t PopBlock() override;
void Align(int align) override;
void* WriteDataRaw(void* src, size_t size) override;
void* WriteDataInBlock(void* src, size_t size) override;
void* WriteDataRaw(const void* src, size_t size) override;
void* WriteDataInBlock(const void* src, size_t size) override;
void IncBlockPos(size_t size) override;
void WriteNullTerminated(void* src) override;
void WriteNullTerminated(const void* src) override;
void MarkFollowing(void** pPtr) override;
bool ReusableShouldWrite(void** pPtr, size_t entrySize, size_t entryCount, std::type_index type) override;
};