SqMod/source/Library/Utils/BufferInterpreter.hpp

#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_