rawbuffer.h

Go to the documentation of this file.

// Evo C++ Library
/* Copyright 2019 Justin Crowell
Distributed under the BSD 2-Clause License -- see included file LICENSE.txt for details.
*/

#pragma once
#ifndef INCL_evo_impl_rawbuffer_h
#define INCL_evo_impl_rawbuffer_h

#include "sys.h"
#include "../type.h"

// Disable certain MSVC warnings for this file
#if defined(_MSC_VER)
    #pragma warning(push)
    #pragma warning(disable:4458)
#endif

namespace evo {


struct RawBuffer {
    char* data;         
    ulong size;         
    ulong used;         
    bool  owned;        

    RawBuffer() : data(NULL), size(0), used(0), owned(false)
        { }

    RawBuffer(ulong size) : data(NULL), size(0), used(0), owned(false)
        { resize(size); }

    ~RawBuffer() {
        if (owned)
            ::free(data);
    }

    ulong avail() const {
        assert( used <= size );
        return size - used;
    }

    ulong avail(ulong checksize) const {
        assert(used <= size);
        const ulong size_avail = size - used;
        return (checksize > size_avail ? size_avail : checksize);
    }

    RawBuffer& reset() {
        if (owned)
            ::free(data);
        data  = NULL;
        size  = 0;
        used  = 0;
        owned = false;
        return *this;
    }

    RawBuffer& ref(char* data, ulong size, ulong used=0) {
        assert( data != NULL );
        if (owned)
            ::free(this->data);
        this->data = data;
        this->size = size;
        this->used = used;
        owned      = false;
        return *this;
    }

    RawBuffer& resize(ulong newsize) {
        if (newsize == 0) {
            // Clear
            if (size > 0) {
                if (owned)
                    ::free(data);
                data  = NULL;
                size  = 0;
                used  = 0;
                owned = false;
            }
        } else if (size != newsize) {
            // New positive size
            assert( newsize > 0 );
            if (used > 0) {
                // Preserve existing items
                if (used > newsize)
                    used = newsize;
                char* const old_data = data;
                data = (char*)::malloc((size_t)newsize);
                memcpy(data, old_data, (size_t)used);
                if (owned)
                    ::free(old_data);
            } else {
                // New array
                if (owned)
                    ::free(data);
                data = (char*)::malloc((size_t)newsize);
            }
            size  = newsize;
            owned = true;
        }
        return *this;
    }

    RawBuffer& minsize(ulong min) {
        if (min > size)
            resize(min);
        return *this;
    }

    RawBuffer& clear() {
        used   = 0;
        return *this;
    }

    ulong insert(ulong index, ulong size=1) {
        ulong tempsize = used + size;
        if (tempsize > this->size)
            resize(tempsize);
        if (index < used) {
            // Insert
            memmove(data+index+size, data+index, used-index);
        } else {
            // Append
            index = used;
        }
        used += size;
        return index;
    }

    RawBuffer& remove(ulong index, ulong size=1) {
        if (index < used && size > 0) {
            // Size after removed items
            size_t tempsize = used - index;
            if (size >= tempsize)
                tempsize = 0;
            else
                tempsize -= size;

            // Remove
            if (tempsize > 0) {
                // Shift items after removed
                memmove(data+index, data+index+size, tempsize);
                used -= size;
            } else {
                // Remove all items after index
                used = index;
            }
        }
        return *this;
    }

    void flush(ulong& offset) {
        assert( used <= size );
        if (offset >= used) {
            offset = 0;
            used   = 0;
        } else if (offset > 0) {
            used -= offset;
            memmove(data, data+offset, used);
            offset = 0;
        }
    }

    ulong read(ulong& offset, char* buf, ulong readsize) {
        if (offset < used) {
            ulong maxsize = used - offset;
            if (readsize > maxsize)
                readsize = maxsize;
            memcpy(buf, data+offset, readsize);
            offset += readsize;
        } else
            readsize = 0;
        return readsize;
    }

    ulong write(const char* buf, ulong writesize) {
        if (used < size) {
            ulong maxsize = size - used;
            if (writesize > maxsize)
                writesize = maxsize;
            memcpy(data+used, buf, writesize);
            used += writesize;
        } else
            writesize = 0;
        return writesize;
    }

    ulong write(char ch, ulong count=1) {
        if (used < size) {
            const ulong maxsize = size - used;
            if (count > maxsize)
                count = maxsize;
            memset(data+used, ch, count);
            used += count;
        } else
            count = 0;
        return count;
    }

private:
    // Disable copying
    RawBuffer(const RawBuffer&);
    RawBuffer& operator=(const RawBuffer&);
};


}
#if defined(_MSC_VER)
    #pragma warning(pop)
#endif
#endif