mirror of
https://github.com/VCMP-SqMod/SqMod.git
synced 2025-07-15 13:27:11 +02:00
Untested update to the new plugin API.
Various other changes to the plugin as well.
This commit is contained in:
Sandu Liviu Catalin
542
source/Library/Utils/BufferInterpreter.hpp
Normal file
542
source/Library/Utils/BufferInterpreter.hpp
Normal file
@ -0,0 +1,542 @@
|
||||
#ifndef _LIBRARY_UTILS_BUFFERINTERPRETER_HPP_
|
||||
#define _LIBRARY_UTILS_BUFFERINTERPRETER_HPP_
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include "Base/Shared.hpp"
|
||||
#include "Base/Buffer.hpp"
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
namespace SqMod {
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
class BufferWrapper;
|
||||
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* Used internally to obtain a reference to the memory buffer without including the wrapper header.
|
||||
*/
|
||||
const SharedPtr< Buffer > & GetBufferBufferRef(const BufferWrapper & buffer);
|
||||
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* Utility class used to interpret a memory buffer in different ways.
|
||||
*/
|
||||
template < typename T > class BufferInterpreter
|
||||
{
|
||||
private:
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
typedef SharedPtr< Buffer > SRef; // Strong reference type to the interpreted memory buffer.
|
||||
typedef WeakPtr< Buffer > WRef; // Weak reference type to the interpreted memory buffer.
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
WRef m_Buffer; // The interpreted memory buffer.
|
||||
|
||||
public:
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
typedef T Value; // The type of value used to represent a byte.
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
typedef Value & Reference; // A reference to the stored value type.
|
||||
typedef const Value & ConstRef; // A const reference to the stored value type.
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
typedef Value * Pointer; // A pointer to the stored value type.
|
||||
typedef const Value * ConstPtr; // A const pointer to the stored value type.
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
typedef Buffer::SzType SzType; // The type used to represent size in general.
|
||||
|
||||
protected:
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Attempt to obtain a strong reference to the memory buffer at all costs.
|
||||
*/
|
||||
SRef Validate() const
|
||||
{
|
||||
// Did the buffer that we reference expired?
|
||||
if (m_Buffer.Expired())
|
||||
{
|
||||
STHROWF("Invalid memory buffer reference");
|
||||
}
|
||||
// Obtain a strong reference to it
|
||||
return m_Buffer.Lock();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Attempt to obtain a strong reference to a valid memory buffer at all costs.
|
||||
*/
|
||||
SRef ValidateDeeper() const
|
||||
{
|
||||
// Did the buffer that we reference expired?
|
||||
if (m_Buffer.Expired())
|
||||
{
|
||||
STHROWF("Invalid memory buffer reference");
|
||||
}
|
||||
// Obtain a strong reference to it
|
||||
SRef ref = m_Buffer.Lock();
|
||||
// Validate the buffer itself
|
||||
if (!(*ref))
|
||||
{
|
||||
STHROWF("Invalid memory buffer");
|
||||
}
|
||||
// Return the reference
|
||||
return ref;
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Default constructor. (null)
|
||||
*/
|
||||
BufferInterpreter()
|
||||
: m_Buffer()
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Base constructor.
|
||||
*/
|
||||
BufferInterpreter(const WRef & ref)
|
||||
: m_Buffer(ref)
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Base constructor.
|
||||
*/
|
||||
BufferInterpreter(const SRef & ref)
|
||||
: m_Buffer(ref)
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Copy constructor.
|
||||
*/
|
||||
BufferInterpreter(const BufferInterpreter & o) = default;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Move constructor.
|
||||
*/
|
||||
BufferInterpreter(BufferInterpreter && o) = default;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Destructor.
|
||||
*/
|
||||
~BufferInterpreter() = default;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Copy assignment operator.
|
||||
*/
|
||||
BufferInterpreter & operator = (const BufferInterpreter & o) = default;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Move assignment operator.
|
||||
*/
|
||||
BufferInterpreter & operator = (BufferInterpreter && o) = default;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve a reference to the managed memory buffer.
|
||||
*/
|
||||
const WRef & GetRef() const
|
||||
{
|
||||
return m_Buffer;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Assign a different memory buffer to interpret from.
|
||||
*/
|
||||
void UseBuffer(const BufferWrapper & buffer)
|
||||
{
|
||||
m_Buffer = GetBufferBufferRef(buffer);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve a certain element type at the specified position.
|
||||
*/
|
||||
T Get(SzType n) const
|
||||
{
|
||||
// Acquire a reference to the memory buffer
|
||||
SRef b(Validate());
|
||||
// Are we out of the memory buffer range?
|
||||
if (n >= b->Size< T >())
|
||||
{
|
||||
STHROWF("Index (%u) is out of bounds (%u)", n, b->Size< T >());
|
||||
}
|
||||
// Return the requested element
|
||||
return b->At< T >(n);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify a certain element type at the specified position.
|
||||
*/
|
||||
void Set(SzType n, T v)
|
||||
{
|
||||
// Acquire a reference to the memory buffer
|
||||
SRef b(Validate());
|
||||
// Are we out of the memory buffer range?
|
||||
if (n >= b->Size< T >())
|
||||
{
|
||||
STHROWF("Index (%u) is out of bounds (%u)", n, b->Size< T >());
|
||||
}
|
||||
// Return the requested element
|
||||
b->At< T >(n) = v;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the element at the front of the buffer.
|
||||
*/
|
||||
T GetFront() const
|
||||
{
|
||||
// Acquire a reference to the memory buffer
|
||||
SRef b(Validate());
|
||||
// Are we out of the memory buffer range?
|
||||
if (b->Capacity() < sizeof(T))
|
||||
{
|
||||
STHROWF("Value size (%u starting at 0) is out of bounds (%u)",
|
||||
sizeof(T), b->Capacity());
|
||||
}
|
||||
// Return the requested element
|
||||
return b->Front< T >();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the element at the front of the buffer.
|
||||
*/
|
||||
void SetFront(T v)
|
||||
{
|
||||
// Acquire a reference to the memory buffer
|
||||
SRef b(Validate());
|
||||
// Are we out of the memory buffer range?
|
||||
if (b->Capacity() < sizeof(T))
|
||||
{
|
||||
STHROWF("Value size (%u starting at 0) is out of bounds (%u)",
|
||||
sizeof(T), b->Capacity());
|
||||
}
|
||||
// Return the requested element
|
||||
b->Front< T >() = v;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the element after the first element in the buffer.
|
||||
*/
|
||||
T GetNext() const
|
||||
{
|
||||
// Acquire a reference to the memory buffer
|
||||
SRef b(Validate());
|
||||
// Are we out of the memory buffer range?
|
||||
if (b->Capacity() < (sizeof(T) * 2))
|
||||
{
|
||||
STHROWF("Value size (%u starting at %u) is out of bounds (%u)",
|
||||
sizeof(T), sizeof(T), b->Capacity());
|
||||
}
|
||||
// Return the requested element
|
||||
return b->Next< T >();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the element after the first element in the buffer.
|
||||
*/
|
||||
void SetNext(T v)
|
||||
{
|
||||
// Acquire a reference to the memory buffer
|
||||
SRef b(Validate());
|
||||
// Are we out of the memory buffer range?
|
||||
if (b->Capacity() < (sizeof(T) * 2))
|
||||
{
|
||||
STHROWF("Value size (%u starting at %u) is out of bounds (%u)",
|
||||
sizeof(T), sizeof(T), b->Capacity());
|
||||
}
|
||||
// Return the requested element
|
||||
b->Next< T >() = v;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the element at the back of the buffer.
|
||||
*/
|
||||
T GetBack() const
|
||||
{
|
||||
// Acquire a reference to the memory buffer
|
||||
SRef b(Validate());
|
||||
// Are we out of the memory buffer range?
|
||||
if (b->Capacity() < sizeof(T))
|
||||
{
|
||||
STHROWF("Value size (%u starting at 0) is out of bounds (%u)",
|
||||
sizeof(T), b->Capacity());
|
||||
}
|
||||
// Return the requested element
|
||||
return b->Back< T >();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the element at the back of the buffer.
|
||||
*/
|
||||
void SetBack(T v)
|
||||
{
|
||||
// Acquire a reference to the memory buffer
|
||||
SRef b(Validate());
|
||||
// Are we out of the memory buffer range?
|
||||
if (b->Capacity() < sizeof(T))
|
||||
{
|
||||
STHROWF("Value size (%u starting at 0) is out of bounds (%u)",
|
||||
sizeof(T), b->Capacity());
|
||||
}
|
||||
// Return the requested element
|
||||
b->Back< T >() = v;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the element before the last element in the buffer.
|
||||
*/
|
||||
T GetPrev() const
|
||||
{
|
||||
// Acquire a reference to the memory buffer
|
||||
SRef b(Validate());
|
||||
// Are we out of the memory buffer range?
|
||||
if (b->Capacity() < (sizeof(T) * 2))
|
||||
{
|
||||
STHROWF("Value size (%u starting at %u) is out of bounds (%u)",
|
||||
sizeof(T), sizeof(T), b->Capacity());
|
||||
}
|
||||
// Return the requested element
|
||||
return b->Prev< T >();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the element before the last element in the buffer.
|
||||
*/
|
||||
void SetPrev(T v)
|
||||
{
|
||||
// Acquire a reference to the memory buffer
|
||||
SRef b(Validate());
|
||||
// Are we out of the memory buffer range?
|
||||
if (b->Capacity() < (sizeof(T) * 2))
|
||||
{
|
||||
STHROWF("Value size (%u starting at %u) is out of bounds (%u)",
|
||||
sizeof(T), sizeof(T), b->Capacity());
|
||||
}
|
||||
// Return the requested element
|
||||
b->Prev< T >() = v;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Reposition the edit cursor to the specified number of elements ahead.
|
||||
*/
|
||||
void Advance(SzType n)
|
||||
{
|
||||
// Acquire a reference to the memory buffer
|
||||
SRef b(Validate());
|
||||
// Perform the requested operation
|
||||
b->Advance< T >(n);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Reposition the edit cursor to the specified number of elements behind.
|
||||
*/
|
||||
void Retreat(SzType n)
|
||||
{
|
||||
// Acquire a reference to the memory buffer
|
||||
SRef b(Validate());
|
||||
// Perform the requested operation
|
||||
b->Retreat< T >(n);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Reposition the edit cursor to a fixed position within the buffer.
|
||||
*/
|
||||
void Move(SzType n)
|
||||
{
|
||||
// Acquire a reference to the memory buffer
|
||||
SRef b(Validate());
|
||||
// Perform the requested operation
|
||||
b->Move< T >(n);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Append a value to the current cursor location and advance the cursor.
|
||||
*/
|
||||
void Push(T v)
|
||||
{
|
||||
// Acquire a reference to the memory buffer
|
||||
SRef b(Validate());
|
||||
// Perform the requested operation
|
||||
b->Push< T >(v);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the element at the cursor position.
|
||||
*/
|
||||
T GetCursor() const
|
||||
{
|
||||
// Acquire a reference to the memory buffer
|
||||
SRef b(Validate());
|
||||
// Are we out of the memory buffer range?
|
||||
if (b->Position< T >() >= b->Size< T >())
|
||||
{
|
||||
STHROWF("Value size (%u starting at %u) is out of bounds (%u)",
|
||||
sizeof(T), b->Position(), b->Capacity());
|
||||
}
|
||||
// Return the requested element
|
||||
return b->Cursor< T >();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the element at the cursor position.
|
||||
*/
|
||||
void SetCursor(T v)
|
||||
{
|
||||
// Acquire a reference to the memory buffer
|
||||
SRef b(Validate());
|
||||
// Are we out of the memory buffer range?
|
||||
if (b->Position< T >() >= b->Size< T >())
|
||||
{
|
||||
STHROWF("Value size (%u starting at %u) is out of bounds (%u)",
|
||||
sizeof(T), b->Position(), b->Capacity());
|
||||
}
|
||||
// Return the requested element
|
||||
b->Cursor< T >() = v;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the element before the cursor position.
|
||||
*/
|
||||
T GetBefore() const
|
||||
{
|
||||
// Acquire a reference to the memory buffer
|
||||
SRef b(Validate());
|
||||
// Are we out of the memory buffer range?
|
||||
if (b->Position() < sizeof(T))
|
||||
{
|
||||
STHROWF("Value size (%u starting at 0) is out of bounds (%u)",
|
||||
sizeof(T), b->Capacity());
|
||||
}
|
||||
// Return the requested element
|
||||
return b->Before< T >();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the element before the cursor position.
|
||||
*/
|
||||
void SetBefore(T v)
|
||||
{
|
||||
// Acquire a reference to the memory buffer
|
||||
SRef b(Validate());
|
||||
// Are we out of the memory buffer range?
|
||||
if (b->Position() < sizeof(T))
|
||||
{
|
||||
STHROWF("Value size (%u starting at 0) is out of bounds (%u)",
|
||||
sizeof(T), b->Capacity());
|
||||
}
|
||||
// Return the requested element
|
||||
b->Before< T >() = v;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the element after the cursor position.
|
||||
*/
|
||||
T GetAfter() const
|
||||
{
|
||||
// Acquire a reference to the memory buffer
|
||||
SRef b(Validate());
|
||||
// Are we out of the memory buffer range?
|
||||
if (b->Capacity() < sizeof(T) || (b->Position() + sizeof(T)) > (b->Capacity() - sizeof(T)))
|
||||
{
|
||||
STHROWF("Value size (%u starting at %u) is out of bounds (%u)",
|
||||
sizeof(T), b->Position(), b->Capacity());
|
||||
}
|
||||
// Return the requested element
|
||||
return b->After< T >();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the element after the cursor position.
|
||||
*/
|
||||
void SetAfter(T v)
|
||||
{
|
||||
// Acquire a reference to the memory buffer
|
||||
SRef b(Validate());
|
||||
// Are we out of the memory buffer range?
|
||||
if (b->Capacity() < sizeof(T) || (b->Position() + sizeof(T)) > (b->Capacity() - sizeof(T)))
|
||||
{
|
||||
STHROWF("Value size (%u starting at %u) is out of bounds (%u)",
|
||||
sizeof(T), b->Position(), b->Capacity());
|
||||
}
|
||||
// Return the requested element
|
||||
b->After< T >() = v;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve maximum elements it can hold for a certain type.
|
||||
*/
|
||||
SzType GetMax() const
|
||||
{
|
||||
return Buffer::Max< T >();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the current buffer capacity in element count.
|
||||
*/
|
||||
SzType GetSize() const
|
||||
{
|
||||
return Validate()->template Size< T >();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the current buffer capacity in byte count.
|
||||
*/
|
||||
SzType GetCapacity() const
|
||||
{
|
||||
return Validate()->Capacity();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the current position of the cursor in the buffer.
|
||||
*/
|
||||
SzType GetPosition() const
|
||||
{
|
||||
return Validate()->template Position< T >();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the amount of unused buffer after the edit cursor.
|
||||
*/
|
||||
SzType GetRemaining() const
|
||||
{
|
||||
return Validate()->template Remaining< T >();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Grow the size of the internal buffer by the specified amount of bytes.
|
||||
*/
|
||||
void Grow(SzType n)
|
||||
{
|
||||
return Validate()->Grow(n * sizeof(T));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Makes sure there is enough capacity to hold the specified element count.
|
||||
*/
|
||||
void Adjust(SzType n)
|
||||
{
|
||||
// Acquire a reference to the memory buffer
|
||||
SRef b(Validate());
|
||||
// Attempt to perform the requested operation
|
||||
try
|
||||
{
|
||||
Buffer bkp(b->Adjust(n * sizeof(T)));
|
||||
// Copy the data into the new buffer
|
||||
b->Write(0, bkp.Data(), bkp.Capacity());
|
||||
b->Move(bkp.Position());
|
||||
}
|
||||
catch (const std::exception & e)
|
||||
{
|
||||
STHROWF("%s", e.what()); // Re-package
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
} // Namespace:: SqMod
|
||||
|
||||
#endif // _LIBRARY_UTILS_BUFFERINTERPRETER_HPP_
|
||||
Reference in New Issue
Block a user