mirror of
https://github.com/VCMP-SqMod/SqMod.git
synced 2024-11-14 11:47:15 +01:00
645 lines
23 KiB
C++
645 lines
23 KiB
C++
#ifndef _LIBRARY_UTILS_BUFFERWRAPPER_HPP_
|
|
#define _LIBRARY_UTILS_BUFFERWRAPPER_HPP_
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
#include "Base/Shared.hpp"
|
|
#include "Base/Buffer.hpp"
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
namespace SqMod {
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
template < typename T > class BufferInterpreter;
|
|
|
|
/* ------------------------------------------------------------------------------------------------
|
|
* Squirrel wrapper for the shared buffer class.
|
|
*/
|
|
class BufferWrapper
|
|
{
|
|
private:
|
|
|
|
// --------------------------------------------------------------------------------------------
|
|
typedef SharedPtr< Buffer > SRef; // Strong reference type to the managed memory buffer.
|
|
typedef WeakPtr< Buffer > WRef; // Weak reference type to the managed memory buffer.
|
|
|
|
// --------------------------------------------------------------------------------------------
|
|
SRef m_Buffer; // The managed memory buffer.
|
|
|
|
public:
|
|
|
|
// --------------------------------------------------------------------------------------------
|
|
typedef Buffer::Value 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.
|
|
|
|
public:
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Create a memory buffer with the requested size.
|
|
*/
|
|
static Object Create(SzType n);
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Base constructor.
|
|
*/
|
|
BufferWrapper(const SRef & ref)
|
|
: m_Buffer(ref)
|
|
{
|
|
/* ... */
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Buffer constructor.
|
|
*/
|
|
BufferWrapper(Buffer && b)
|
|
: m_Buffer(new Buffer(std::move(b)))
|
|
{
|
|
/* ... */
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copy constructor.
|
|
*/
|
|
BufferWrapper(const BufferWrapper & o) = default;
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Move constructor.
|
|
*/
|
|
BufferWrapper(BufferWrapper && o) = default;
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Destructor.
|
|
*/
|
|
~BufferWrapper() = default;
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copy assignment operator.
|
|
*/
|
|
BufferWrapper & operator = (const BufferWrapper & o) = default;
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Move assignment operator.
|
|
*/
|
|
BufferWrapper & operator = (BufferWrapper && o) = default;
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve a reference to the managed memory buffer.
|
|
*/
|
|
const SRef & GetRef() const
|
|
{
|
|
return m_Buffer;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Validate the managed memory buffer reference.
|
|
*/
|
|
void Validate() const
|
|
{
|
|
// Do we even point to a valid buffer?
|
|
if (!m_Buffer)
|
|
{
|
|
STHROWF("Invalid memory buffer reference");
|
|
}
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Validate the managed memory buffer reference and the buffer itself.
|
|
*/
|
|
void ValidateDeeper() const
|
|
{
|
|
// Do we even point to a valid buffer?
|
|
if (!m_Buffer)
|
|
{
|
|
STHROWF("Invalid memory buffer reference");
|
|
}
|
|
// Validate the buffer itself
|
|
else if (!(*m_Buffer))
|
|
{
|
|
STHROWF("Invalid memory buffer");
|
|
}
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve a certain element type at the specified position.
|
|
*/
|
|
Value Get(SzType n) const
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Are we out of the memory buffer range?
|
|
if (n >= m_Buffer->Size())
|
|
{
|
|
STHROWF("Index (%u) is out of bounds (%u)", n, m_Buffer->Size());
|
|
}
|
|
// Return the requested element
|
|
return m_Buffer->At(n);
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Modify a certain element type at the specified position.
|
|
*/
|
|
void Set(SzType n, Value v)
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Are we out of the memory buffer range?
|
|
if (n >= m_Buffer->Size())
|
|
{
|
|
STHROWF("Index (%u) is out of bounds (%u)", n, m_Buffer->Size());
|
|
}
|
|
// Return the requested element
|
|
m_Buffer->At(n) = v;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve the element at the front of the buffer.
|
|
*/
|
|
Value GetFront() const
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Are we out of the memory buffer range?
|
|
if (m_Buffer->Capacity() < sizeof(Value))
|
|
{
|
|
STHROWF("Value size (%u starting at 0) is out of bounds (%u)",
|
|
sizeof(Value), m_Buffer->Capacity());
|
|
}
|
|
// Return the requested element
|
|
return m_Buffer->Front();
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Modify the element at the front of the buffer.
|
|
*/
|
|
void SetFront(Value v)
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Are we out of the memory buffer range?
|
|
if (m_Buffer->Capacity() < sizeof(Value))
|
|
{
|
|
STHROWF("Value size (%u starting at 0) is out of bounds (%u)",
|
|
sizeof(Value), m_Buffer->Capacity());
|
|
}
|
|
// Return the requested element
|
|
m_Buffer->Front() = v;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve the element after the first element in the buffer.
|
|
*/
|
|
Value GetNext() const
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Are we out of the memory buffer range?
|
|
if (m_Buffer->Capacity() < (sizeof(Value) * 2))
|
|
{
|
|
STHROWF("Value size (%u starting at %u) is out of bounds (%u)",
|
|
sizeof(Value), sizeof(Value), m_Buffer->Capacity());
|
|
}
|
|
// Return the requested element
|
|
return m_Buffer->Next();
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Modify the element after the first element in the buffer.
|
|
*/
|
|
void SetNext(Value v)
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Are we out of the memory buffer range?
|
|
if (m_Buffer->Capacity() < (sizeof(Value) * 2))
|
|
{
|
|
STHROWF("Value size (%u starting at %u) is out of bounds (%u)",
|
|
sizeof(Value), sizeof(Value), m_Buffer->Capacity());
|
|
}
|
|
// Return the requested element
|
|
m_Buffer->Next() = v;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve the element at the back of the buffer.
|
|
*/
|
|
Value GetBack() const
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Are we out of the memory buffer range?
|
|
if (m_Buffer->Capacity() < sizeof(Value))
|
|
{
|
|
STHROWF("Value size (%u starting at 0) is out of bounds (%u)",
|
|
sizeof(Value), m_Buffer->Capacity());
|
|
}
|
|
// Return the requested element
|
|
return m_Buffer->Back();
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Modify the element at the back of the buffer.
|
|
*/
|
|
void SetBack(Value v)
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Are we out of the memory buffer range?
|
|
if (m_Buffer->Capacity() < sizeof(Value))
|
|
{
|
|
STHROWF("Value size (%u starting at 0) is out of bounds (%u)",
|
|
sizeof(Value), m_Buffer->Capacity());
|
|
}
|
|
// Return the requested element
|
|
m_Buffer->Back() = v;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve the element before the last element in the buffer.
|
|
*/
|
|
Value GetPrev() const
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Are we out of the memory buffer range?
|
|
if (m_Buffer->Capacity() < (sizeof(Value) * 2))
|
|
{
|
|
STHROWF("Value size (%u starting at %u) is out of bounds (%u)",
|
|
sizeof(Value), sizeof(Value), m_Buffer->Capacity());
|
|
}
|
|
// Return the requested element
|
|
return m_Buffer->Prev();
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Modify the element before the last element in the buffer.
|
|
*/
|
|
void SetPrev(Value v)
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Are we out of the memory buffer range?
|
|
if (m_Buffer->Capacity() < (sizeof(Value) * 2))
|
|
{
|
|
STHROWF("Value size (%u starting at %u) is out of bounds (%u)",
|
|
sizeof(Value), sizeof(Value), m_Buffer->Capacity());
|
|
}
|
|
// Return the requested element
|
|
m_Buffer->Prev() = v;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Reposition the edit cursor to the specified number of elements ahead.
|
|
*/
|
|
void Advance(SzType n)
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Perform the requested operation
|
|
m_Buffer->Advance(n);
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Reposition the edit cursor to the specified number of elements behind.
|
|
*/
|
|
void Retreat(SzType n)
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Perform the requested operation
|
|
m_Buffer->Retreat(n);
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Reposition the edit cursor to a fixed position within the buffer.
|
|
*/
|
|
void Move(SzType n)
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Perform the requested operation
|
|
m_Buffer->Move(n);
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Append a value to the current cursor location and advance the cursor.
|
|
*/
|
|
void Push(Value v)
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Perform the requested operation
|
|
m_Buffer->Push(v);
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve the element at the cursor position.
|
|
*/
|
|
Value GetCursor() const
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Are we out of the memory buffer range?
|
|
if (m_Buffer->Position() >= m_Buffer->Size())
|
|
{
|
|
STHROWF("Value size (%u starting at %u) is out of bounds (%u)",
|
|
sizeof(Value), m_Buffer->Position(), m_Buffer->Capacity());
|
|
}
|
|
// Return the requested element
|
|
return m_Buffer->Cursor();
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Modify the element at the cursor position.
|
|
*/
|
|
void SetCursor(Value v)
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Are we out of the memory buffer range?
|
|
if (m_Buffer->Position() >= m_Buffer->Size())
|
|
{
|
|
STHROWF("Value size (%u starting at %u) is out of bounds (%u)",
|
|
sizeof(Value), m_Buffer->Position(), m_Buffer->Capacity());
|
|
}
|
|
// Return the requested element
|
|
m_Buffer->Cursor() = v;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve the element before the cursor position.
|
|
*/
|
|
Value GetBefore() const
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Are we out of the memory buffer range?
|
|
if (m_Buffer->Position() < sizeof(Value))
|
|
{
|
|
STHROWF("Value size (%u starting at 0) is out of bounds (%u)",
|
|
sizeof(Value), m_Buffer->Capacity());
|
|
}
|
|
// Return the requested element
|
|
return m_Buffer->Before();
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Modify the element before the cursor position.
|
|
*/
|
|
void SetBefore(Value v)
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Are we out of the memory buffer range?
|
|
if (m_Buffer->Position() < sizeof(Value))
|
|
{
|
|
STHROWF("Value size (%u starting at 0) is out of bounds (%u)",
|
|
sizeof(Value), m_Buffer->Capacity());
|
|
}
|
|
// Return the requested element
|
|
m_Buffer->Before() = v;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve the element after the cursor position.
|
|
*/
|
|
Value GetAfter() const
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Are we out of the memory buffer range?
|
|
if (m_Buffer->Capacity() < sizeof(Value) ||
|
|
(m_Buffer->Position() + sizeof(Value)) > (m_Buffer->Capacity() - sizeof(Value)))
|
|
{
|
|
STHROWF("Value size (%u starting at %u) is out of bounds (%u)",
|
|
sizeof(Value), m_Buffer->Position(), m_Buffer->Capacity());
|
|
}
|
|
// Return the requested element
|
|
return m_Buffer->After();
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Modify the element after the cursor position.
|
|
*/
|
|
void SetAfter(Value v)
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Are we out of the memory buffer range?
|
|
if (m_Buffer->Capacity() < sizeof(Value) ||
|
|
(m_Buffer->Position() + sizeof(Value)) > (m_Buffer->Capacity() - sizeof(Value)))
|
|
{
|
|
STHROWF("Value size (%u starting at %u) is out of bounds (%u)",
|
|
sizeof(Value), m_Buffer->Position(), m_Buffer->Capacity());
|
|
}
|
|
// Return the requested element
|
|
m_Buffer->After() = v;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve maximum elements it can hold for a certain type.
|
|
*/
|
|
SzType GetMax() const
|
|
{
|
|
return Buffer::Max();
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve the current buffer capacity in element count.
|
|
*/
|
|
SzType GetSize() const
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Return the requested information
|
|
return m_Buffer->Size();
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve the current buffer capacity in byte count.
|
|
*/
|
|
SzType GetCapacity() const
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Return the requested information
|
|
return m_Buffer->Capacity();
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve the current position of the cursor in the buffer.
|
|
*/
|
|
SzType GetPosition() const
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Return the requested information
|
|
return m_Buffer->Position();
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve the amount of unused buffer after the edit cursor.
|
|
*/
|
|
SzType GetRemaining() const
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Return the requested information
|
|
return m_Buffer->Remaining();
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Grow the size of the internal buffer by the specified amount of bytes.
|
|
*/
|
|
void Grow(SzType n)
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Perform the requested operation
|
|
return m_Buffer->Grow(n * sizeof(Value));
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Makes sure there is enough capacity to hold the specified element count.
|
|
*/
|
|
void Adjust(SzType n)
|
|
{
|
|
// Validate the managed buffer reference
|
|
Validate();
|
|
// Attempt to perform the requested operation
|
|
try
|
|
{
|
|
Buffer bkp(m_Buffer->Adjust(n * sizeof(Value)));
|
|
// Copy the data into the new buffer
|
|
m_Buffer->Write(0, bkp.Data(), bkp.Capacity());
|
|
m_Buffer->Move(bkp.Position());
|
|
}
|
|
catch (const std::exception & e)
|
|
{
|
|
STHROWF("%s", e.what()); // Re-package
|
|
}
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Write a 8 bit byte to the stream buffer.
|
|
*/
|
|
void WriteByte(SQInteger val);
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Write a 16 bit short to the stream buffer.
|
|
*/
|
|
void WriteShort(SQInteger val);
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Write a 32 bit integer to the stream buffer.
|
|
*/
|
|
void WriteInt(SQInteger val);
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Write a 32 bit float to the stream buffer.
|
|
*/
|
|
void WriteFloat(SQFloat val);
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Write a string to the stream buffer.
|
|
*/
|
|
void WriteString(CSStr val);
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Write a raw string to the stream buffer.
|
|
*/
|
|
void WriteRawString(CSStr val);
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Read a 8 bit byte to the stream buffer.
|
|
*/
|
|
SQInteger ReadByte();
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Read a 16 bit short to the stream buffer.
|
|
*/
|
|
SQInteger ReadShort();
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Read a 32 bit integer to the stream buffer.
|
|
*/
|
|
SQInteger ReadInt();
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Read a 32 bit float to the stream buffer.
|
|
*/
|
|
SQFloat ReadFloat();
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Read a string to the stream buffer.
|
|
*/
|
|
Object ReadString();
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Read a raw string to the stream buffer.
|
|
*/
|
|
Object ReadRawString(Uint32 len);
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve a signed 8 bit interpreter to this buffer.
|
|
*/
|
|
BufferInterpreter< Int8 > GetInt8Interpreter() const;
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve an unsigned 8 bit interpreter to this buffer.
|
|
*/
|
|
BufferInterpreter< Uint8 > GetUint8Interpreter() const;
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve a signed 16 bit interpreter to this buffer.
|
|
*/
|
|
BufferInterpreter< Int16 > GetInt16Interpreter() const;
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve an unsigned 16 bit interpreter to this buffer.
|
|
*/
|
|
BufferInterpreter< Uint16 > GetUint16Interpreter() const;
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve a signed 32 bit interpreter to this buffer.
|
|
*/
|
|
BufferInterpreter< Int32 > GetInt32Interpreter() const;
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve an unsigned 32 bit interpreter to this buffer.
|
|
*/
|
|
BufferInterpreter< Uint32 > GetUint32Interpreter() const;
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve a signed 64 bit interpreter to this buffer.
|
|
*/
|
|
BufferInterpreter< Int64 > GetInt64Interpreter() const;
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve an unsigned 64 bit interpreter to this buffer.
|
|
*/
|
|
BufferInterpreter< Uint64 > GetUint64Interpreter() const;
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve a 32 bit floating point interpreter to this buffer.
|
|
*/
|
|
BufferInterpreter< Float32 > GetFloat32Interpreter() const;
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Retrieve a 64 bit floating point interpreter to this buffer.
|
|
*/
|
|
BufferInterpreter< Float64 > GetFloat64Interpreter() const;
|
|
};
|
|
|
|
} // Namespace:: SqMod
|
|
|
|
#endif // _LIBRARY_UTILS_BUFFERWRAPPER_HPP_
|