thijn/SqMod
1
0
Fork 0
mirror of https://github.com/VCMP-SqMod/SqMod.git synced 2025-07-10 19:07:12 +02:00
Code Releases Activity

Untested update to the new plugin API.

Browse Source 
Various other changes to the plugin as well.
This commit is contained in:
Sandu Liviu Catalin
2016-05-22 06:20:38 +03:00
parent ddb52677bd
commit f2361a27c3
167 changed files with 15520 additions and 60635 deletions
Download Patch File Download Diff File Expand all files Collapse all files

644
source/Library/Utils/BufferWrapper.hpp Normal file
View File

@ -0,0 +1,644 @@
#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_