Cppcheck report - GATE C/C++ Framework: gate/streams.c

/* GATE PROJECT LICENSE:
+----------------------------------------------------------------------------+
| Copyright(c) 2018-2025, Stefan Meislinger <sm@opengate.at>                 |
| All rights reserved.                                                       |
|                                                                            |
| Redistribution and use in source and binary forms, with or without         |
| modification, are permitted provided that the following conditions are met:|
|                                                                            |
| 1. Redistributions of source code must retain the above copyright notice,  |
|    this list of conditions and the following disclaimer.                   |
| 2. Redistributions in binary form must reproduce the above copyright       |
|    notice, this list of conditions and the following disclaimer in the     |
|    documentation and/or other materials provided with the distribution.    |
|                                                                            |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"|
| AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE  |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE    |
| LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR        |
| CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF       |
| SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS   |
| INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN    |
| CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)    |
| ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF     |
| THE POSSIBILITY OF SUCH DAMAGE.                                            |
+----------------------------------------------------------------------------+
*/

#include "gate/streams.h"
#include "gate/results.h"
#include "gate/strings.h"
#include "gate/atomics.h"
#include "gate/debugging.h"
#include "gate/times.h"
#include "gate/arrays.h"

#include <stdarg.h>

#if defined(GATE_SYS_WIN)
#	define GATE_CORE_STREAMS_WINAPI 1
#elif defined(GATE_SYS_DOS)
#	define GATE_CORE_STREAMS_POSIX 1
#elif defined(GATE_SYS_POSIX)
#	define GATE_CORE_STREAMS_POSIX 1
#endif



/********************************
 * memory stream implementation *
 ********************************/

static void				gate_memstream_release_impl(void* self);
static int				gate_memstream_retain_impl(void* self);
static char const* gate_memstream_interface_name_impl(void* self);
static gate_result_t	gate_memstream_read_impl(void* self, char* buffer, gate_size_t bufferlength, gate_size_t* returned);
static gate_result_t	gate_memstream_peek_impl(void* self, char* buffer, gate_size_t bufferlength, gate_size_t* returned);
static gate_result_t	gate_memstream_write_impl(void* self, char const* buffer, gate_size_t bufferlength, gate_size_t* written);
static gate_result_t	gate_memstream_flush_impl(void* self);
static gate_result_t	gate_memstream_reserve_impl(void* self, gate_size_t space);
static gate_size_t		gate_memstream_size_impl(void* self);
static gate_result_t	gate_memstream_fill_impl(void* self, char fillitem, gate_size_t fillsize);
static gate_size_t		gate_memstream_discard_impl(void* self, gate_size_t bytestodiscard);
static gate_size_t		gate_memstream_discard_back_impl(void* self, gate_size_t bytestodiscard);
static char const* gate_memstream_get_data_impl(void* self);
static gate_result_t	gate_memstream_reset_impl(void* self);


static void				gate_memstream_release_static_impl(void* self);
static int				gate_memstream_retain_static_impl(void* self);
static gate_result_t	gate_memstream_write_static_impl(void* self, char const* buffer, gate_size_t bufferlength, gate_size_t* written);
static gate_result_t	gate_memstream_reserve_static_impl(void* self, gate_size_t space);
static gate_result_t	gate_memstream_fill_static_impl(void* self, char fillitem, gate_size_t fillsize);
static gate_result_t	gate_memstream_write_disabled_impl(void* self, char const* buffer, gate_size_t bufferlength, gate_size_t* written);
static gate_result_t	gate_memstream_reserve_disabled_impl(void* self, gate_size_t space);
static gate_result_t	gate_memstream_fill_disabled_impl(void* self, char fillitem, gate_size_t fillsize);

static void				gate_memstream_release_static_unmanaged_impl(void* self);

static GATE_INTERFACE_VTBL(gate_memstream) gate_memstream_static_unmanaged_readonly_vtbl;

static void gate_init_memstream_static_unmanaged_readonly_vtbl()
{
    if (!gate_memstream_static_unmanaged_readonly_vtbl.get_interface_name)
    {
        GATE_INTERFACE_VTBL(gate_memstream) const local_vtbl =
        {
            &gate_memstream_interface_name_impl,
            &gate_memstream_release_static_unmanaged_impl,
            &gate_memstream_retain_static_impl,

            &gate_memstream_read_impl,
            &gate_memstream_peek_impl,
            &gate_memstream_write_disabled_impl,
            &gate_memstream_flush_impl,

            &gate_memstream_get_data_impl,
            &gate_memstream_size_impl,
            &gate_memstream_reserve_disabled_impl,
            &gate_memstream_fill_disabled_impl,
            &gate_memstream_discard_impl,
            &gate_memstream_discard_back_impl,
            &gate_memstream_reset_impl
        };
        gate_memstream_static_unmanaged_readonly_vtbl = local_vtbl;
    }
}



static void gate_memstream_release_impl(void* self)
{
    gate_memstream_impl_t* strm = (gate_memstream_impl_t*)self;
    if (gate_atomic_int_dec(&strm->ref_counter) == 0)
    {
        /* release memstream */
        if (strm->priv_membuffer != NULL)
        {
            gate_mem_dealloc(strm->priv_membuffer);
            strm->priv_membuffer = NULL;
        }
        gate_mem_dealloc(strm);
    }
}
static int gate_memstream_retain_impl(void* self)
{
    gate_memstream_impl_t* strm = (gate_memstream_impl_t*)self;
    return gate_atomic_int_inc(&strm->ref_counter);
}
static char const* gate_memstream_interface_name_impl(void* self)
{
    (void)self;
    return GATE_INTERFACE_NAME_MEMSTREAM;
}

gate_result_t gate_memstream_read_impl(void* self, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    gate_memstream_impl_t* strm = (gate_memstream_impl_t*)self;
    if (bufferlength > strm->priv_memlength)
    {
        bufferlength = strm->priv_memlength;
    }
    if (bufferlength != 0)
    {
        gate_mem_copy(buffer, &strm->priv_membuffer[strm->priv_memoffset], bufferlength);
        strm->priv_memlength -= bufferlength;
        if (strm->priv_memlength == 0)
        {
            strm->priv_memoffset = 0;
        }
        else
        {
            strm->priv_memoffset += bufferlength;
        }
    }
    if (returned != NULL)
    {
        *returned = bufferlength;
    }
    return GATE_RESULT_OK;
}
gate_result_t gate_memstream_peek_impl(void* self, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    gate_memstream_impl_t* strm = (gate_memstream_impl_t*)self;
    if (bufferlength > strm->priv_memlength)
    {
        bufferlength = strm->priv_memlength;
    }
    if (bufferlength != 0)
    {
        gate_mem_copy(buffer, strm->priv_membuffer, bufferlength);
    }
    if (returned != NULL)
    {
        *returned = bufferlength;
    }
    return GATE_RESULT_OK;
}
gate_result_t gate_memstream_write_impl(void* self, char const* buffer, gate_size_t bufferlength, gate_size_t* written)
{
    gate_memstream_impl_t* strm = (gate_memstream_impl_t*)self;
    gate_result_t result = strm->vtbl->reserve(strm, bufferlength);
    if (GATE_FAILED(result))
    {
        return result;
    }

    gate_mem_copy(&strm->priv_membuffer[strm->priv_memoffset + strm->priv_memlength], buffer, bufferlength);
    strm->priv_memlength += bufferlength;

    if (written != NULL)
    {
        *written = bufferlength;
    }
    return GATE_RESULT_OK;
}
gate_result_t gate_memstream_flush_impl(void* self)
{
    (void)self;
    return GATE_RESULT_OK;
}
static gate_result_t gate_memstream_reserve_impl(void* self, gate_size_t space)
{
    gate_memstream_impl_t* strm = (gate_memstream_impl_t*)self;
    gate_size_t unusedspace = strm->priv_memcapacity - strm->priv_memlength;
    gate_size_t freespace = unusedspace - strm->priv_memoffset;
    if (space > freespace)
    {
        if (space > unusedspace)
        {
            /* reallocation is required */
            gate_size_t newcapacity = (strm->priv_memcapacity + space) + (strm->priv_memcapacity / 2);
            char* newbuffer = (char*)gate_mem_alloc(newcapacity);
            if (newbuffer == NULL)
            {
                return GATE_RESULT_OUTOFMEMORY;
            }
            if (strm->priv_memlength != 0)
            {
                gate_mem_copy(&newbuffer[0], &strm->priv_membuffer[strm->priv_memoffset], strm->priv_memlength);
            }
            if (strm->priv_membuffer != NULL)
            {
                gate_mem_dealloc(strm->priv_membuffer);
            }
            strm->priv_membuffer = newbuffer;
            strm->priv_memoffset = 0;
            strm->priv_memcapacity = newcapacity;
        }
        else
        {
            /* moving bytes to origin of buffer */
            gate_mem_copy(&strm->priv_membuffer[0], &strm->priv_membuffer[strm->priv_memoffset], strm->priv_memlength);
            strm->priv_memoffset = 0;
        }
    }
    return GATE_RESULT_OK;
}
static gate_size_t gate_memstream_size_impl(void* self)
{
    gate_memstream_impl_t* strm = (gate_memstream_impl_t*)self;
    return strm->priv_memlength;
}
static gate_result_t gate_memstream_fill_impl(void* self, char fillitem, gate_size_t fillsize)
{
    gate_memstream_impl_t* strm = (gate_memstream_impl_t*)self;
    gate_size_t ndx;
    char* ptr;
    gate_result_t result = strm->vtbl->reserve(strm, fillsize);

    if (GATE_FAILED(result))
    {
        return result;
    }

    ptr = &strm->priv_membuffer[strm->priv_memoffset + strm->priv_memlength];
    for (ndx = 0; ndx < fillsize; ++ndx, ++ptr)
    {
        *ptr = fillitem;
    }
    strm->priv_memlength += fillsize;
    return GATE_RESULT_OK;
}
static gate_size_t gate_memstream_discard_impl(void* self, gate_size_t bytestodiscard)
{
    gate_memstream_impl_t* strm = (gate_memstream_impl_t*)self;
    gate_size_t ret;
    if (bytestodiscard >= strm->priv_memlength)
    {
        ret = strm->priv_memlength;
        strm->priv_memoffset = 0;
        strm->priv_memlength = 0;
    }
    else
    {
        ret = bytestodiscard;
        strm->priv_memoffset += bytestodiscard;
        strm->priv_memlength -= bytestodiscard;
    }
    return ret;
}
static gate_size_t gate_memstream_discard_back_impl(void* self, gate_size_t bytestodiscard)
{
    gate_memstream_impl_t* strm = (gate_memstream_impl_t*)self;
    gate_size_t ret;
    if (bytestodiscard >= strm->priv_memlength)
    {
        ret = strm->priv_memlength;
        strm->priv_memoffset = 0;
        strm->priv_memlength = 0;
    }
    else
    {
        ret = bytestodiscard;
        strm->priv_memlength -= bytestodiscard;
    }
    return ret;
}
static char const* gate_memstream_get_data_impl(void* self)
{
    gate_memstream_impl_t* strm = (gate_memstream_impl_t*)self;
    return &strm->priv_membuffer[strm->priv_memoffset];
}

static gate_result_t gate_memstream_reset_impl(void* self)
{
    gate_memstream_impl_t* strm = (gate_memstream_impl_t*)self;
    strm->priv_memoffset = 0;
    strm->priv_memlength = 0;
    return GATE_RESULT_OK;
}

static GATE_INTERFACE_VTBL(gate_memstream) gate_memstream_vtbl;

void gate_init_memstream_vtbl()
{
    if (!gate_memstream_vtbl.get_interface_name)
    {
        GATE_INTERFACE_VTBL(gate_memstream) const local_vtbl =
        {
            &gate_memstream_interface_name_impl,
            &gate_memstream_release_impl,
            &gate_memstream_retain_impl,

            &gate_memstream_read_impl,
            &gate_memstream_peek_impl,
            &gate_memstream_write_impl,
            &gate_memstream_flush_impl,

            &gate_memstream_get_data_impl,
            &gate_memstream_size_impl,
            &gate_memstream_reserve_impl,
            &gate_memstream_fill_impl,
            &gate_memstream_discard_impl,
            &gate_memstream_discard_back_impl,
            &gate_memstream_reset_impl
        };
        gate_memstream_vtbl = local_vtbl;
    }
}

gate_memstream_t* gate_memstream_create(gate_size_t capacity)
{
    gate_result_t result;
    gate_memstream_impl_t* ret = (gate_memstream_impl_t*)gate_mem_alloc(sizeof(gate_memstream_impl_t));
    if (ret != NULL)
    {
        gate_init_memstream_vtbl();
        ret->vtbl = &gate_memstream_vtbl;
        gate_atomic_int_set(&ret->ref_counter, 1);
        ret->priv_membuffer = NULL;
        ret->priv_memcapacity = 0;
        ret->priv_memoffset = 0;
        ret->priv_memlength = 0;
        if (capacity > 0)
        {
            result = ret->vtbl->reserve(ret, capacity);
            (void)result;
        }

    }
    return (gate_memstream_t*)ret;
}


static void	gate_memstream_release_static_impl(void* self)
{
    gate_memstream_impl_t* strm = (gate_memstream_impl_t*)self;
    if (0 == gate_atomic_int_dec(&strm->ref_counter))
    {
        gate_mem_dealloc(self);
    }
}
static int gate_memstream_retain_static_impl(void* self)
{
    gate_memstream_impl_t* strm = (gate_memstream_impl_t*)self;
    return (int)gate_atomic_int_inc(&strm->ref_counter);
}
static gate_result_t gate_memstream_write_static_impl(void* self, char const* buffer, gate_size_t bufferlength, gate_size_t* written)
{
    gate_memstream_impl_t* strm = (gate_memstream_impl_t*)self;
    gate_result_t ret = GATE_RESULT_OK;
    gate_size_t avail;
    if (bufferlength > 0)
    {
        avail = strm->priv_memcapacity - strm->priv_memlength;
        if (bufferlength > avail)
        {
            if (bufferlength < strm->priv_memcapacity)
            {
                avail = strm->priv_memcapacity - bufferlength;
                if (avail > strm->priv_memlength) avail = strm->priv_memlength;
                gate_mem_copy(
                    &strm->priv_membuffer[0],
                    &strm->priv_membuffer[strm->priv_memoffset + strm->priv_memlength - avail],
                    avail);
                strm->priv_memoffset = 0;
                strm->priv_memlength = avail;
                gate_mem_copy(&strm->priv_membuffer[strm->priv_memlength], buffer, bufferlength);
                strm->priv_memlength += bufferlength;
            }
            else
            {
                gate_mem_copy(
                    &strm->priv_membuffer[0],
                    &buffer[bufferlength - strm->priv_memcapacity],
                    strm->priv_memcapacity);
                strm->priv_memoffset = 0;
                strm->priv_memlength = strm->priv_memcapacity;
            }
        }
        else
        {
            if (strm->priv_memoffset != 0)
            {
                gate_mem_copy(&strm->priv_membuffer[0], &strm->priv_membuffer[strm->priv_memoffset], strm->priv_memlength);
                strm->priv_memoffset = 0;
            }
            gate_mem_copy(&strm->priv_membuffer[strm->priv_memlength], buffer, bufferlength);
            strm->priv_memlength += bufferlength;
        }
    }
    if (written != NULL) *written = bufferlength;
    return ret;
}
static gate_result_t gate_memstream_write_disabled_impl(void* self, char const* buffer, gate_size_t bufferlength, gate_size_t* written)
{
    (void)self;
    (void)buffer;
    (void)bufferlength;
    (void)written;
    return GATE_RESULT_NOTSUPPORTED;
}
static gate_result_t gate_memstream_reserve_disabled_impl(void* self, gate_size_t space)
{
    (void)self;
    (void)space;
    return GATE_RESULT_NOTSUPPORTED;
}
static gate_result_t gate_memstream_fill_disabled_impl(void* self, char fillitem, gate_size_t fillsize)
{
    (void)self;
    (void)fillitem;
    (void)fillsize;
    return GATE_RESULT_NOTSUPPORTED;
}

static gate_result_t gate_memstream_reserve_static_impl(void* self, gate_size_t space)
{
    gate_memstream_impl_t* strm = (gate_memstream_impl_t*)self;
    if (strm->priv_memoffset != 0)
    {
        gate_mem_copy(&strm->priv_membuffer[0], &strm->priv_membuffer[strm->priv_memoffset], strm->priv_memlength);
        strm->priv_memoffset = 0;
    }
    return (space > strm->priv_memcapacity) ? GATE_RESULT_OUTOFMEMORY : GATE_RESULT_OK;
}
static gate_result_t gate_memstream_fill_static_impl(void* self, char fillitem, gate_size_t fillsize)
{
    gate_memstream_impl_t* strm = (gate_memstream_impl_t*)self;
    gate_result_t ret = GATE_RESULT_OK;
    gate_size_t avail;
    char* ptr;
<--- The scope of the variable 'ptr' can be reduced. [+]
The scope of the variable 'ptr' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    gate_size_t index;
    gate_size_t preserve;
    if (fillsize != 0)
    {
        if (strm->priv_memoffset != 0)
        {
            gate_mem_copy(&strm->priv_membuffer[0], &strm->priv_membuffer[strm->priv_memoffset], strm->priv_memlength);
            strm->priv_memoffset = 0;
        }
        avail = strm->priv_memcapacity - strm->priv_memlength;
        if (fillsize > avail)
        {
            if (fillsize >= strm->priv_memcapacity)
            {
                ptr = &strm->priv_membuffer[0];
                fillsize = strm->priv_memcapacity;
                strm->priv_memoffset = 0;
                strm->priv_memlength = 0;
            }
            else
            {
                preserve = strm->priv_memcapacity - fillsize;
                gate_mem_copy(&strm->priv_membuffer[0], &strm->priv_membuffer[strm->priv_memoffset + strm->priv_memlength - preserve], preserve);
                strm->priv_memoffset = 0;
                strm->priv_memlength = preserve;
                ptr = &strm->priv_membuffer[preserve];
            }
        }
        else
        {
            ptr = &strm->priv_membuffer[strm->priv_memoffset + strm->priv_memlength];
        }
        for (index = 0; index != fillsize; ++index)
        {
            *ptr = fillitem;
            ++ptr;
        }
        strm->priv_memlength += fillsize;
    }
    return ret;
}


static void gate_memstream_release_static_unmanaged_impl(void* self)
{
    gate_memstream_impl_t* strm = (gate_memstream_impl_t*)self;
    if (0 == gate_atomic_int_dec(&strm->ref_counter))
    {
        /* do nothing */
    }
}

static GATE_INTERFACE_VTBL(gate_memstream) gate_memstream_static_unmanaged_vtbl;

void gate_init_memstream_static_unmanaged_vtbl()
{
    if (!gate_memstream_static_unmanaged_vtbl.get_interface_name)
    {
        GATE_INTERFACE_VTBL(gate_memstream) const local_vtbl =
        {
            &gate_memstream_interface_name_impl,
            &gate_memstream_release_static_unmanaged_impl,
            &gate_memstream_retain_static_impl,

            &gate_memstream_read_impl,
            &gate_memstream_peek_impl,
            &gate_memstream_write_static_impl,
            &gate_memstream_flush_impl,

            &gate_memstream_get_data_impl,
            &gate_memstream_size_impl,
            &gate_memstream_reserve_static_impl,
            &gate_memstream_fill_static_impl,
            &gate_memstream_discard_impl,
            &gate_memstream_discard_back_impl,
            &gate_memstream_reset_impl
        };
        gate_memstream_static_unmanaged_vtbl = local_vtbl;
    }
}

gate_memstream_t* gate_memstream_create_static_unmanaged(gate_memstream_impl_t* impl, void* buffer, gate_size_t capacity, gate_size_t used)
{
    gate_init_memstream_static_unmanaged_vtbl();
    impl->vtbl = &gate_memstream_static_unmanaged_vtbl;
    gate_atomic_int_init(&impl->ref_counter, 1);
    impl->priv_memoffset = 0;
    impl->priv_membuffer = (char*)buffer;
    impl->priv_memcapacity = capacity;
    impl->priv_memlength = used;
    return (gate_memstream_t*)impl;
}

static GATE_INTERFACE_VTBL(gate_memstream) gate_memstream_static_vtbl;
void gate_init_memstream_static_vtbl()
{
    if (!gate_memstream_static_vtbl.get_interface_name)
    {
        GATE_INTERFACE_VTBL(gate_memstream) const local_vtbl =
        {
            &gate_memstream_interface_name_impl,
            &gate_memstream_release_static_impl,
            &gate_memstream_retain_static_impl,

            &gate_memstream_read_impl,
            &gate_memstream_peek_impl,
            &gate_memstream_write_static_impl,
            &gate_memstream_flush_impl,

            &gate_memstream_get_data_impl,
            &gate_memstream_size_impl,
            &gate_memstream_reserve_static_impl,
            &gate_memstream_fill_static_impl,
            &gate_memstream_discard_impl,
            &gate_memstream_discard_back_impl,
            &gate_memstream_reset_impl
        };
        gate_memstream_static_vtbl = local_vtbl;
    }
}

gate_memstream_t* gate_memstream_create_static(void* buffer, gate_size_t capacity, gate_size_t used)
{
    gate_memstream_impl_t* impl = (gate_memstream_impl_t*)gate_mem_alloc(sizeof(gate_memstream_impl_t));
    if (impl != NULL)
    {
        gate_init_memstream_static_vtbl();
        impl->vtbl = &gate_memstream_static_vtbl;
        gate_atomic_int_init(&impl->ref_counter, 1);
        impl->priv_memoffset = 0;
        impl->priv_membuffer = (char*)buffer;
        impl->priv_memcapacity = capacity;
        impl->priv_memlength = used;
    }
    return (gate_memstream_t*)impl;
}

gate_memstream_t* gate_memstream_create_static_unmanaged_readonly(gate_memstream_impl_t* impl, void const* buffer, gate_size_t capacity, gate_size_t used)
{
    gate_init_memstream_static_unmanaged_readonly_vtbl();
    impl->vtbl = &gate_memstream_static_unmanaged_readonly_vtbl;
    gate_atomic_int_init(&impl->ref_counter, 1);
    impl->priv_memoffset = 0;
    impl->priv_membuffer = (char*)buffer;
    impl->priv_memcapacity = capacity;
    impl->priv_memlength = used;
    return (gate_memstream_t*)impl;
}



/*****************************************
 * control-memstream-view implementation *
 *****************************************/

typedef struct memview_class
{
    GATE_INTERFACE_VTBL(gate_controlstream)* vtbl;

    gate_atomic_int_t	ref_counter;
    char const* ptr_buffer;
    gate_size_t			buffer_len;
    gate_size_t			buffer_offset;
    gate_bool_t			closed;			/* true, when stream is closed */
    gate_object_t* ptr_container;	/* container holding mem-allocation, released on close*/
} memview_t;

static void memview_destroy(memview_t* self)
{
    if (self->ptr_container)
    {
        gate_object_release(self->ptr_container);
    }
    gate_mem_dealloc(self);
}

static char const* memview_get_interface_name(void* obj)
{
    GATE_UNUSED_ARG(obj);
    return GATE_INTERFACE_NAME_CONTROLSTREAM;
}
static void memview_release(void* obj)
{
    memview_t* const self = (memview_t*)obj;
    if (0 == gate_atomic_int_dec(&self->ref_counter))
    {
        memview_destroy(self);
    }
}
static int memview_retain(void* obj)
{
    memview_t* const self = (memview_t*)obj;
    return (int)gate_atomic_int_inc(&self->ref_counter);
}

static gate_result_t memview_peek(void* obj, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    memview_t* const self = (memview_t*)obj;
    gate_result_t result = GATE_RESULT_FAILED;
    gate_size_t copied = 0;
    gate_size_t available;

    do
    {
        if (!buffer || !obj)
        {
            result = GATE_RESULT_NULLPOINTER;
            break;
        }

        available = self->buffer_len - self->buffer_offset;

        if (self->closed || (available == 0))
        {
            /* react as end of stream */
            result = GATE_RESULT_OK;
            break;
        }

        copied = (bufferlength > available) ? available : bufferlength;
        gate_mem_copy(buffer, &self->ptr_buffer[self->buffer_offset], copied);
        result = GATE_RESULT_OK;
    } while (0);

    if (returned)
    {
        *returned = copied;
    }

    return result;
}

static gate_result_t memview_read(void* obj, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    memview_t* const self = (memview_t*)obj;
    gate_result_t result = GATE_RESULT_FAILED;
    gate_size_t copied = 0;

    result = memview_peek(obj, buffer, bufferlength, &copied);
    if (GATE_SUCCEEDED(result))
    {
        self->buffer_offset += copied;
        if (self->buffer_offset > self->buffer_len)
        {
            self->buffer_offset = self->buffer_len;
        }
    }

    if (returned)
    {
        *returned = copied;
    }

    return result;
}

static gate_result_t memview_write(void* obj, char const* buffer, gate_size_t bufferlength, gate_size_t* written)
{
    GATE_UNUSED_ARG(obj);
    GATE_UNUSED_ARG(buffer);
    GATE_UNUSED_ARG(bufferlength);
    GATE_UNUSED_ARG(written);
    return GATE_RESULT_NOTSUPPORTED;
}
static gate_result_t memview_flush(void* obj)
{
    GATE_UNUSED_ARG(obj);
    return GATE_RESULT_NOTSUPPORTED;
}

static gate_result_t memview_get_resource(void* obj, gate_enumint_t resource_type, gate_uintptr_t* resource)
{
    memview_t* const self = (memview_t*)obj;
    switch (resource_type)
    {
    case GATE_STREAM_RESOURCE_INPUT:
    case GATE_STREAM_RESOURCE_DEFAULT:
        if (resource)
        {
            *resource = (gate_uintptr_t)self->ptr_buffer;
        }
        return GATE_RESULT_OK;
    default:
    {
        return GATE_RESULT_NOTAVAILABLE;
    }
    }
}

static gate_result_t memview_can_read(void* obj, gate_bool_t* return_value)
{
    memview_t* const self = (memview_t*)obj;
    if (return_value)
    {
        *return_value = !self->closed;
    }
    return GATE_RESULT_OK;
}
static gate_result_t memview_can_write(void* obj, gate_bool_t* return_value)
{
    GATE_UNUSED_ARG(obj);
    if (return_value)
    {
        *return_value = false;
    }
    return GATE_RESULT_OK;
}
static gate_result_t memview_get_size(void* obj, gate_int64_t* return_value)
{
    memview_t* const self = (memview_t*)obj;
    if (return_value)
    {
        *return_value = self->buffer_len;
    }
    return GATE_RESULT_OK;
}
static gate_result_t memview_get_available(void* obj, gate_int64_t* return_value)
{
    memview_t* const self = (memview_t*)obj;
    if (return_value)
    {
        *return_value = self->closed ? 0 : (gate_int64_t)(self->buffer_len - self->buffer_offset);
    }
    return GATE_RESULT_OK;
}
static gate_result_t memview_seek(void* obj, gate_int64_t position, gate_enumint_t origin, gate_int64_t* final_position)
{
    memview_t* const self = (memview_t*)obj;
    gate_result_t result = GATE_RESULT_FAILED;
    gate_size_t shift;

    if (self->closed)
    {
        return GATE_RESULT_NOTAVAILABLE;
    }

    switch (origin)
    {
    case GATE_STREAM_SEEK_BEGIN:
    {
        if (position < 0)<--- Assuming condition 'position<0' is false
        {
            result = GATE_RESULT_INVALIDARG;
            break;
        }
        if (position > (gate_int64_t)self->buffer_len)
        {
            result = GATE_RESULT_NOTSUPPORTED;
            break;
        }
        self->buffer_offset = (gate_size_t)(gate_uint64_t)position;
        result = GATE_RESULT_OK;
        break;
    }
    case GATE_STREAM_SEEK_CURRENT:
    {
        if (position < 0)<--- Condition 'position<0' is always false
        {
            shift = (gate_size_t)(gate_uint64_t)(-position);
            if (shift > self->buffer_offset)
            {
                result = GATE_RESULT_NOTSUPPORTED;
                break;
            }
            self->buffer_offset -= shift;
        }
        else
        {
            shift = (gate_size_t)(gate_uint64_t)position;
            if (self->buffer_offset + shift > self->buffer_len)
            {
                result = GATE_RESULT_NOTSUPPORTED;
                break;
            }
            self->buffer_offset += shift;
        }
        result = GATE_RESULT_OK;
        break;
    }
    case GATE_STREAM_SEEK_END:
    {
        if (position > 0)
        {
            result = GATE_RESULT_NOTSUPPORTED;
            break;
        }
        shift = (gate_size_t)(-position);
        if (shift > self->buffer_len)
        {
            result = GATE_RESULT_INVALIDARG;
            break;
        }
        self->buffer_offset = self->buffer_len - shift;
        result = GATE_RESULT_OK;
        break;
    }
    default:
    {
        result = GATE_RESULT_INVALIDARG;
        break;
    }
    }

    if (final_position)
    {
        *final_position = (gate_int64_t)(gate_uint64_t)self->buffer_offset;
    }
    return result;
}
static gate_result_t memview_reset(void* obj)
{
    memview_t* const self = (memview_t*)obj;
    self->buffer_offset = 0;
    return GATE_RESULT_OK;
}
static gate_result_t memview_close(void* obj, gate_enumint_t close_type)
{
    memview_t* const self = (memview_t*)obj;
    switch (close_type)
    {
    case GATE_STREAM_CLOSE_DEFAULT:
    case GATE_STREAM_CLOSE_INPUT:
        self->closed = true;
        return GATE_RESULT_OK;
    default:
        return GATE_RESULT_NOTSUPPORTED;
    }
}

static GATE_INTERFACE_VTBL(gate_controlstream) memview_vtbl;

static void init_memview_vtbl()
{
    if (memview_vtbl.get_interface_name == NULL)
    {
        GATE_INTERFACE_VTBL(gate_controlstream) local_vtbl =
        {
            &memview_get_interface_name,
            &memview_release,
            &memview_retain,

            &memview_read,
            &memview_peek,
            &memview_write,
            &memview_flush,

            &memview_get_resource,

            &memview_can_read,
            &memview_can_write,
            &memview_get_size,
            &memview_get_available,
            &memview_seek,
            &memview_reset,
            &memview_close
        };
        memview_vtbl = local_vtbl;
    }
}

gate_controlstream_t* gate_memstream_create_view(void const* buffer, gate_size_t length, gate_size_t offset, gate_object_t* ptr_container)
{
    gate_controlstream_t* ret = NULL;
    memview_t* newstrm = NULL;

    do
    {
        newstrm = (memview_t*)gate_mem_alloc(sizeof(memview_t));
        if (!newstrm)
        {
            break;
        }
        gate_mem_clear(newstrm, sizeof(memview_t));
        init_memview_vtbl();
        newstrm->vtbl = &memview_vtbl;
        gate_atomic_int_init(&newstrm->ref_counter, 1);
        newstrm->closed = false;
        newstrm->ptr_buffer = (char const*)buffer;
        newstrm->buffer_len = length;
        newstrm->buffer_offset = (offset > length) ? length : offset;
        newstrm->ptr_container = ptr_container;
        if (newstrm->ptr_container)
        {
            gate_object_retain(newstrm->ptr_container);
        }
        /* success case */
        ret = (gate_controlstream_t*)newstrm;
        newstrm = NULL;
    } while (0);

    if (newstrm)
    {
        memview_destroy(newstrm);
    }
    return ret;
}



/*****************************************
 * control-memstream-file implementation *
 *****************************************/

typedef struct memfile_class
{
    GATE_INTERFACE_VTBL(gate_controlstream)* vtbl;

    gate_atomic_int_t	ref_counter;
    gate_arraylist_t	storage;
    gate_size_t			storage_offset;	/* current read/write position */
    gate_bool_t			closed;			/* true, when stream is closed */
} memfile_t;

static void memfile_destroy(memfile_t* self)
{
    gate_arraylist_release(self->storage);
    gate_mem_dealloc(self);
}

static char const* memfile_get_interface_name(void* obj)
{
    GATE_UNUSED_ARG(obj);
    return GATE_INTERFACE_NAME_MEMFILE;
}
static void memfile_release(void* obj)
{
    memfile_t* const self = (memfile_t*)obj;
    if (0 == gate_atomic_int_dec(&self->ref_counter))
    {
        memfile_destroy(self);
    }
}
static int memfile_retain(void* obj)
{
    memfile_t* const self = (memfile_t*)obj;
    return (int)gate_atomic_int_inc(&self->ref_counter);
}

static gate_result_t memfile_peek(void* obj, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    memfile_t* const self = (memfile_t*)obj;
    gate_result_t result = GATE_RESULT_FAILED;
    gate_size_t copied = 0;
    gate_size_t available;
    gate_size_t storage_length;
    char const* ptr_storage_data = NULL;

    do
    {
        if (!buffer || !obj)
        {
            result = GATE_RESULT_NULLPOINTER;
            break;
        }

        storage_length = gate_arraylist_length(self->storage);
        GATE_DEBUG_ASSERT(self->storage_offset <= storage_length);
        available = storage_length - self->storage_offset;

        if (self->closed || (available == 0))
        {
            /* react as end of stream */
            result = GATE_RESULT_OK;
            break;
        }

        ptr_storage_data = (char const*)gate_arraylist_get(self->storage, self->storage_offset);
        if (!ptr_storage_data)
        {
            result = GATE_RESULT_NOTAVAILABLE;
            break;
        }
        copied = (bufferlength > available) ? available : bufferlength;
        gate_mem_copy(buffer, ptr_storage_data, copied);
        result = GATE_RESULT_OK;
    } while (0);

    if (returned)
    {
        *returned = copied;
    }

    return result;
}

static gate_result_t memfile_read(void* obj, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    memfile_t* const self = (memfile_t*)obj;
    gate_result_t result = GATE_RESULT_FAILED;
    gate_size_t copied = 0;

    result = memfile_peek(obj, buffer, bufferlength, &copied);
    if (GATE_SUCCEEDED(result))
    {
        self->storage_offset += copied;
    }

    if (returned)
    {
        *returned = copied;
    }

    return result;
}

static gate_result_t memfile_write(void* obj, char const* buffer, gate_size_t bufferlength, gate_size_t* written)
{
    memfile_t* const self = (memfile_t*)obj;
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_size_t stored_bytes = 0;
    gate_size_t storage_length;
    gate_size_t available;
    char* ptr_storage_data;

    do
    {
        storage_length = gate_arraylist_length(self->storage);
        GATE_DEBUG_ASSERT(self->storage_offset <= storage_length);
        available = storage_length - self->storage_offset;

        if (available > 0)
        {
            ptr_storage_data = (char*)gate_arraylist_get(self->storage, self->storage_offset);
            if (!ptr_storage_data)
            {
                ret = GATE_RESULT_NOTAVAILABLE;
                break;
            }
            stored_bytes = (bufferlength <= available) ? bufferlength : available;
            gate_mem_copy(ptr_storage_data, buffer, stored_bytes);
            self->storage_offset += stored_bytes;
            bufferlength -= stored_bytes;
            buffer += stored_bytes;
        }
        if (bufferlength > 0)
        {
            if (NULL == gate_arraylist_insert(self->storage, storage_length, buffer, bufferlength))
            {
                ret = (stored_bytes > 0) ? GATE_RESULT_OK : GATE_RESULT_OUTOFMEMORY;
                break;
            }
            self->storage_offset += bufferlength;
            stored_bytes += bufferlength;
        }
        ret = GATE_RESULT_OK;
    } while (0);

    if (written)
    {
        *written = stored_bytes;
    }
    return ret;
}
static gate_result_t memfile_flush(void* obj)
{
    GATE_UNUSED_ARG(obj);
    return GATE_RESULT_OK;
}

static gate_result_t memfile_get_resource(void* obj, gate_enumint_t resource_type, gate_uintptr_t* resource)
{
    memfile_t* const self = (memfile_t*)obj;
    switch (resource_type)
    {
    case GATE_STREAM_RESOURCE_INPUT:
    case GATE_STREAM_RESOURCE_OUTPUT:
    case GATE_STREAM_RESOURCE_DEFAULT:
        if (resource)
        {
            *resource = (gate_uintptr_t)gate_arraylist_get(self->storage, 0);
        }
        return GATE_RESULT_OK;
    default:
    {
        return GATE_RESULT_NOTAVAILABLE;
    }
    }
}
static gate_result_t memfile_can_read(void* obj, gate_bool_t* return_value)
{
    memfile_t* const self = (memfile_t*)obj;
    if (return_value)
    {
        *return_value = !self->closed;
    }
    return GATE_RESULT_OK;
}
static gate_result_t memfile_can_write(void* obj, gate_bool_t* return_value)
{
    memfile_t* const self = (memfile_t*)obj;
    if (return_value)
    {
        *return_value = !self->closed;
    }
    return GATE_RESULT_OK;
}
static gate_result_t memfile_get_size(void* obj, gate_int64_t* return_value)
{
    memfile_t* const self = (memfile_t*)obj;
    if (return_value)
    {
        *return_value = (gate_int64_t)gate_arraylist_length(self->storage);
    }
    return GATE_RESULT_OK;
}
static gate_result_t memfile_get_available(void* obj, gate_int64_t* return_value)
{
    memfile_t* const self = (memfile_t*)obj;

    if (self->closed)
    {
        return GATE_RESULT_INVALIDSTATE;
    }
    else if (return_value)
    {
        gate_size_t storage_length = gate_arraylist_length(self->storage);
        GATE_DEBUG_ASSERT(self->storage_offset <= storage_length);
        *return_value = (gate_int64_t)(storage_length - self->storage_offset);
    }
    return GATE_RESULT_OK;
}
static gate_result_t memfile_seek(void* obj, gate_int64_t position, gate_enumint_t origin, gate_int64_t* final_position)
{
    memfile_t* const self = (memfile_t*)obj;
    gate_result_t result = GATE_RESULT_FAILED;
    gate_size_t shift;
    gate_size_t storage_length;

    if (self->closed)
    {
        return GATE_RESULT_NOTAVAILABLE;
    }

    storage_length = gate_arraylist_length(self->storage);

    switch (origin)
    {
    case GATE_STREAM_SEEK_BEGIN:
    {
        if (position < 0)<--- Assuming condition 'position<0' is false
        {
            result = GATE_RESULT_INVALIDARG;
            break;
        }
        if (position > (gate_int64_t)storage_length)
        {
            result = GATE_RESULT_NOTSUPPORTED;
            break;
        }
        self->storage_offset = (gate_size_t)(gate_uint64_t)position;
        result = GATE_RESULT_OK;
        break;
    }
    case GATE_STREAM_SEEK_CURRENT:
    {
        if (position < 0)<--- Condition 'position<0' is always false
        {
            shift = (gate_size_t)(gate_uint64_t)(-position);
            if (shift > self->storage_offset)
            {
                result = GATE_RESULT_NOTSUPPORTED;
                break;
            }
            self->storage_offset -= shift;
        }
        else
        {
            shift = (gate_size_t)(gate_uint64_t)position;
            if (self->storage_offset + shift > storage_length)
            {
                result = GATE_RESULT_NOTSUPPORTED;
                break;
            }
            self->storage_offset += shift;
        }
        result = GATE_RESULT_OK;
        break;
    }
    case GATE_STREAM_SEEK_END:
    {
        if (position > 0)
        {
            result = GATE_RESULT_NOTSUPPORTED;
            break;
        }
        shift = (gate_size_t)(-position);
        if (shift > storage_length)
        {
            result = GATE_RESULT_INVALIDARG;
            break;
        }
        self->storage_offset = storage_length - shift;
        result = GATE_RESULT_OK;
        break;
    }
    default:
    {
        result = GATE_RESULT_INVALIDARG;
        break;
    }
    }

    if (final_position)
    {
        *final_position = (gate_int64_t)(gate_uint64_t)self->storage_offset;
    }
    return result;
}
static gate_result_t memfile_reset(void* obj)
{
    memfile_t* const self = (memfile_t*)obj;
    self->storage_offset = 0;
    return GATE_RESULT_OK;
}
static gate_result_t memfile_close(void* obj, gate_enumint_t close_type)
{
    memfile_t* const self = (memfile_t*)obj;
    switch (close_type)
    {
    case GATE_STREAM_CLOSE_DEFAULT:
    case GATE_STREAM_CLOSE_INPUT:
    case GATE_STREAM_CLOSE_OUTPUT:
        self->closed = true;
        return GATE_RESULT_OK;
    default:
        return GATE_RESULT_NOTSUPPORTED;
    }
}

static GATE_INTERFACE_VTBL(gate_controlstream) memfile_vtbl;

static void init_memfile_vtbl()
{
    if (memfile_vtbl.get_interface_name == NULL)
    {
        GATE_INTERFACE_VTBL(gate_controlstream) local_vtbl =
        {
            &memfile_get_interface_name,
            &memfile_release,
            &memfile_retain,

            &memfile_read,
            &memfile_peek,
            &memfile_write,
            &memfile_flush,

            &memfile_get_resource,

            &memfile_can_read,
            &memfile_can_write,
            &memfile_get_size,
            &memfile_get_available,
            &memfile_seek,
            &memfile_reset,
            &memfile_close
        };
        memfile_vtbl = local_vtbl;
    }
}

gate_controlstream_t* gate_memfilestream_create(gate_size_t prealloc)
{
    gate_controlstream_t* ret = NULL;
    memfile_t* newstrm = NULL;

    do
    {
        newstrm = (memfile_t*)gate_mem_alloc(sizeof(memfile_t));
        if (!newstrm)
        {
            break;
        }
        gate_mem_clear(newstrm, sizeof(memfile_t));
        init_memfile_vtbl();
        newstrm->vtbl = &memfile_vtbl;
        gate_atomic_int_init(&newstrm->ref_counter, 1);
        newstrm->storage = gate_arraylist_create(sizeof(char), NULL, prealloc, NULL, NULL);
        if (!newstrm->storage)
        {
            break;
        }
        newstrm->closed = false;
        newstrm->storage_offset = 0;

        /* success case */
        ret = (gate_controlstream_t*)newstrm;
        newstrm = NULL;
    } while (0);

    if (newstrm)
    {
        memfile_destroy(newstrm);
    }
    return ret;
}

gate_controlstream_t* gate_memfilestream_share(gate_controlstream_t* ptr_memfile)
{
    gate_controlstream_t* ret = NULL;
    memfile_t* other_memfile = NULL;
    memfile_t* newstrm = NULL;

    do
    {
        if (!gate_object_implements_interface((gate_object_t*)ptr_memfile, GATE_INTERFACE_NAME_MEMFILE))
        {
            /* given stream is not a mem-file */
            break;
        }
        other_memfile = (memfile_t*)ptr_memfile;

        newstrm = (memfile_t*)gate_mem_alloc(sizeof(memfile_t));
        if (!newstrm)
        {
            break;
        }
        gate_mem_clear(newstrm, sizeof(memfile_t));
        init_memfile_vtbl();
        newstrm->vtbl = &memfile_vtbl;
        gate_atomic_int_init(&newstrm->ref_counter, 1);
        newstrm->storage = other_memfile->storage;
        if (!newstrm->storage)
        {
            break;
        }
        gate_arraylist_retain(newstrm->storage);
        newstrm->closed = false;
        newstrm->storage_offset = 0;

        /* success case */
        ret = (gate_controlstream_t*)newstrm;
        newstrm = NULL;
    } while (0);

    if (newstrm)
    {
        memfile_destroy(newstrm);
    }
    return ret;
}



/********************************
 * string stream implementation *
 ********************************/

static void gate_stringstream_release_impl(void* thisptr);
static int gate_stringstream_retain_impl(void* thisptr);
static char const* gate_stringstream_get_interface_name_impl(void* thisptr);
static gate_result_t gate_stringstream_read_impl(void* thisptr, char* buffer, gate_size_t bufferlength, gate_size_t* returned);
static gate_result_t gate_stringstream_peek_impl(void* thisptr, char* buffer, gate_size_t bufferlength, gate_size_t* returned);
static gate_result_t gate_stringstream_write_impl(void* thisptr, char const* buffer, gate_size_t bufferlength, gate_size_t* written);
static gate_result_t gate_stringstream_flush_impl(void* thisptr);

static char const* gate_stringstream_get_data_impl(void* thisptr);
static gate_size_t gate_stringstream_size_impl(void* thisptr);

static gate_result_t gate_stringstream_get_current_view_impl(void*, gate_string_t* ptr_output);
static gate_result_t gate_stringstream_to_string_impl(void*, gate_string_t* ptr_output);


static GATE_INTERFACE_VTBL(gate_stringstream) gate_stringstream_vtbl;
static void gate_init_stringstream_vtbl()
{
    if (!gate_stringstream_vtbl.get_interface_name)
    {
        GATE_INTERFACE_VTBL(gate_stringstream) local_vtbl =
        {
            &gate_stringstream_get_interface_name_impl,
            &gate_stringstream_release_impl,
            &gate_stringstream_retain_impl,

            &gate_stringstream_read_impl,
            &gate_stringstream_peek_impl,
            &gate_stringstream_write_impl,
            &gate_stringstream_flush_impl,

            &gate_stringstream_get_data_impl,
            &gate_stringstream_size_impl,
            &gate_stringstream_get_current_view_impl,
            &gate_stringstream_to_string_impl
        };
        gate_stringstream_vtbl = local_vtbl;
    }
}

typedef struct gate_stringstream_impl
{
    GATE_INTERFACE_VTBL(gate_stringstream)* vtbl;

    gate_atomic_int_t	ref_counter;
    gate_strbuilder_t* ptr_builder;
    gate_strbuilder_t	str_builder;
} gate_stringstream_impl_t;


gate_stringstream_t* gate_stringstream_create(gate_size_t capacity)
{
    gate_stringstream_impl_t* ret = gate_mem_alloc(sizeof(gate_stringstream_impl_t));
    if (ret != NULL)
    {
        gate_mem_clear(ret, sizeof(gate_stringstream_impl_t));
        gate_init_stringstream_vtbl();
        ret->vtbl = &gate_stringstream_vtbl;
        gate_atomic_int_init(&ret->ref_counter, 1);
        gate_strbuilder_create(&ret->str_builder, capacity);
        ret->ptr_builder = &ret->str_builder;
    }
    return (gate_stringstream_t*)ret;
}

gate_stringstream_t* gate_stringstream_create_builder(gate_strbuilder_t* external_strbuilder)
{
    gate_stringstream_impl_t* ret = gate_mem_alloc(sizeof(gate_stringstream_impl_t));
    if (ret != NULL)
    {
        gate_mem_clear(ret, sizeof(gate_stringstream_impl_t));
        gate_init_stringstream_vtbl();
        ret->vtbl = &gate_stringstream_vtbl;
        gate_atomic_int_init(&ret->ref_counter, 1);
        ret->ptr_builder = external_strbuilder;
    }
    return (gate_stringstream_t*)ret;
}


static void gate_stringstream_release_impl(void* ptr)
{
    gate_stringstream_impl_t* thisptr = (gate_stringstream_impl_t*)ptr;
    if (gate_atomic_int_dec(&thisptr->ref_counter) == 0)
    {
        if (&thisptr->str_builder == thisptr->ptr_builder)
        {
            gate_strbuilder_release(thisptr->ptr_builder);
        }
        gate_mem_dealloc(thisptr);
    }
}
static int gate_stringstream_retain_impl(void* ptr)
{
    gate_stringstream_impl_t* thisptr = (gate_stringstream_impl_t*)ptr;
    return (int)gate_atomic_int_inc(&thisptr->ref_counter);
}
static char const* gate_stringstream_get_interface_name_impl(void* ptr)
{
    (void)ptr;
    return GATE_INTERFACE_NAME_STRINGSTREAM;
}
static gate_result_t gate_stringstream_read_impl(void* ptr, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    gate_stringstream_impl_t* thisptr = (gate_stringstream_impl_t*)ptr;
    gate_size_t bytesread = 0;
    gate_result_t result = gate_stringstream_peek_impl(ptr, buffer, bufferlength, &bytesread);

    if (GATE_SUCCEEDED(result))
    {
        gate_strbuilder_discard(thisptr->ptr_builder, bytesread);
        if (returned != NULL)
        {
            *returned = bytesread;
        }
    }
    return result;
}
static gate_result_t gate_stringstream_peek_impl(void* ptr, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    gate_stringstream_impl_t* thisptr = (gate_stringstream_impl_t*)ptr;
    char const* dataptr = gate_strbuilder_ptr(thisptr->ptr_builder, 0);
    gate_size_t datalen = gate_strbuilder_length(thisptr->ptr_builder);
    if ((bufferlength > 0) && (buffer == NULL))
    {
        return GATE_RESULT_INVALIDARG;
    }
    if (bufferlength > datalen)
    {
        bufferlength = datalen;
    }
    if (bufferlength > 0)
    {
        if (NULL == gate_mem_copy(buffer, dataptr, bufferlength))
        {
            return GATE_RESULT_FAILED;
        }
    }
    if (returned != NULL)
    {
        *returned = bufferlength;
    }
    return GATE_RESULT_OK;
}
static gate_result_t gate_stringstream_write_impl(void* ptr, char const* buffer, gate_size_t bufferlength, gate_size_t* written)
{
    gate_stringstream_impl_t* thisptr = (gate_stringstream_impl_t*)ptr;
    gate_size_t lenwritten;
    gate_result_t ret;
    lenwritten = gate_strbuilder_append_text(thisptr->ptr_builder, buffer, bufferlength);
    ret = (lenwritten == 0) ? GATE_RESULT_FAILED : GATE_RESULT_OK;

    if (written != NULL)
    {
        *written = lenwritten;
    }
    return ret;
}
static gate_result_t gate_stringstream_flush_impl(void* ptr)
{
    (void)ptr;
    return GATE_RESULT_OK;
}

static char const* gate_stringstream_get_data_impl(void* ptr)
{
    gate_stringstream_impl_t* thisptr = (gate_stringstream_impl_t*)ptr;
    return gate_strbuilder_ptr(thisptr->ptr_builder, 0);
}
static gate_size_t gate_stringstream_size_impl(void* ptr)
{
    gate_stringstream_impl_t* thisptr = (gate_stringstream_impl_t*)ptr;
    return gate_strbuilder_length(thisptr->ptr_builder);
}
static gate_result_t gate_stringstream_get_current_view_impl(void* ptr, gate_string_t* ptr_output)
{
    gate_stringstream_impl_t* thisptr = (gate_stringstream_impl_t*)ptr;
    if (NULL != gate_string_create_static_len(ptr_output,
        gate_strbuilder_ptr(thisptr->ptr_builder, 0), gate_strbuilder_length(thisptr->ptr_builder)))
    {
        return GATE_RESULT_OK;
    }
    else
    {
        return GATE_RESULT_OUTOFMEMORY;
    }
}
static gate_result_t gate_stringstream_to_string_impl(void* ptr, gate_string_t* ptr_output)
{
    gate_stringstream_impl_t* thisptr = (gate_stringstream_impl_t*)ptr;
    if (NULL == gate_strbuilder_to_string(thisptr->ptr_builder, ptr_output))
    {
        return GATE_RESULT_FAILED;
    }
    else
    {
        return GATE_RESULT_OK;
    }
}



/********************************
 *  null stream implementation  *
 ********************************/

static void	gate_nullstream_release_impl(void* self)
{
    (void)self;
}
static int gate_nullstream_retain_impl(void* self)
{
    (void)self;
    return 1;
}
static char const* gate_nullstream_get_interface_name_impl(void* self)
{
    (void)self;
    return GATE_INTERFACE_NAME_STREAM;
}
static gate_result_t gate_nullstream_read_impl(void* self, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    (void)self;
    (void)buffer;
    (void)bufferlength;
    if (returned != NULL)
    {
        *returned = 0;
    }
    return GATE_RESULT_OK;
}
static gate_result_t gate_nullstream_peek_impl(void* self, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    (void)self;
    (void)buffer;
    (void)bufferlength;
    if (returned != NULL)
    {
        *returned = 0;
    }
    return GATE_RESULT_OK;
}
static gate_result_t gate_nullstream_write_impl(void* self, char const* buffer, gate_size_t bufferlength, gate_size_t* written)
{
    (void)self;
    (void)buffer;
    if (written != NULL)
    {
        *written = bufferlength;
    }
    return GATE_RESULT_OK;
}
static gate_result_t gate_nullstream_flush_impl(void* self)
{
    (void)self;
    return GATE_RESULT_OK;
}

static GATE_INTERFACE_VTBL(gate_stream) gate_nullstream_vtbl;
static gate_stream_t global_null_stream =
{
    &gate_nullstream_vtbl
};
static void gate_nullstream_vtbl_init()
{
    if (!gate_nullstream_vtbl.get_interface_name)
    {

        GATE_INTERFACE_VTBL(gate_stream) local_vtbl =
        {
            &gate_nullstream_get_interface_name_impl,
            &gate_nullstream_release_impl,
            &gate_nullstream_retain_impl,
            &gate_nullstream_read_impl,
            &gate_nullstream_peek_impl,
            &gate_nullstream_write_impl,
            &gate_nullstream_flush_impl
        };
        gate_nullstream_vtbl = local_vtbl;
    }
}

#define GATE_INTERFACE_VTBL_INIT(ifname, vtbl_instance, vtbl_block) \
	if(! ( vtbl_instance . get_interface_name ) ) { \
		GATE_INTERFACE_VTBL(gate_stream) local_vtbl = { GATE_STRIP_PARENTHESES vtbl_block }; \
		vtbl_instance = local_vtbl; \
	}


gate_stream_t* gate_nullstream()
{
    gate_nullstream_vtbl_init();

    return &global_null_stream;
}



gate_result_t gate_stream_read_block(gate_stream_t* stream, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    gate_result_t result = GATE_RESULT_OK;
    gate_size_t totalread = 0;
    gate_size_t blockread;
    while (totalread < bufferlength)
    {
        blockread = 0;
        result = gate_stream_read(stream, &buffer[totalread], bufferlength - totalread, &blockread);
        if (GATE_FAILED(result))
        {
            break;
        }
        GATE_DEBUG_ASSERT(blockread <= (bufferlength - totalread));
        if (blockread == 0)
        {
            break;
        }
        totalread += blockread;
    }
    if (returned != NULL)
    {
        *returned = totalread;
    }
    return result;
}

gate_result_t gate_stream_read_line(gate_stream_t* stream, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    gate_result_t ret = GATE_RESULT_OK;
    gate_size_t pos = 0;
    gate_size_t lenread;

    while (pos != bufferlength)
    {
        ret = gate_stream_read(stream, &buffer[pos], 1, &lenread);
        GATE_BREAK_IF_FAILED(ret);
        if (lenread == 0)
        {
            /* end of stream */
            break;
        }
        if (buffer[pos] == '\b')
        {
            if (pos > 0)
            {
                --pos;
            }
            continue;
        }

        if (buffer[pos] == '\n')
        {
            /* end of line */
            ++pos;
            break;
        }
        ++pos;
    }
    if (returned != NULL)
    {
        *returned = pos;
    }
    return ret;
}


gate_result_t gate_stream_write_block(gate_stream_t* stream, char const* buffer, gate_size_t bufferlength, gate_size_t* written)
{
    gate_result_t result = GATE_RESULT_OK;
    gate_size_t totalwritten = 0;
    gate_size_t blockwritten;
    while (totalwritten < bufferlength)
    {
        blockwritten = 0;
        result = gate_stream_write(stream, &buffer[totalwritten], bufferlength - totalwritten, &blockwritten);
        /*result = stream->vtbl->write(stream, &buffer[totalwritten], bufferlength - totalwritten, &blockwritten);*/
        if (GATE_FAILED(result))
        {
            break;
        }
        GATE_DEBUG_ASSERT(blockwritten <= (bufferlength - totalwritten));
        if (blockwritten == 0)
        {
            result = GATE_RESULT_CANCELED;
            break;
        }
        totalwritten += blockwritten;
    }
    if (GATE_SUCCEEDED(result))
    {
        GATE_DEBUG_ASSERT(bufferlength == totalwritten);
    }
    if (written != NULL)
    {
        *written = totalwritten;
    }
    return result;
}


gate_result_t gate_stream_print_cstr(gate_stream_t* stream, gate_cstr_t text)
{
    gate_size_t textlength = gate_str_length(text);
    gate_size_t written;
    return gate_stream_write_block(stream, text, textlength, &written);
}
gate_result_t gate_stream_print_wstr(gate_stream_t* stream, gate_wstr_t wstr, gate_size_t wstr_len)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    char buffer[8192 + 4096];
    char* ptr_buffer = &buffer[0];
    gate_size_t max_utf8_length = wstr_len * 3 + 1;
    gate_size_t buffer_used;
    gate_string_t tmp = GATE_STRING_INIT_EMPTY;

    do
    {
        if (max_utf8_length >= sizeof(buffer))
        {
            ptr_buffer = (char*)gate_mem_alloc(max_utf8_length);
            if (ptr_buffer == NULL)
            {
                ret = GATE_RESULT_OUTOFMEMORY;
                break;
            }
        }

        buffer_used = gate_wstr_to_cstr(wstr, wstr_len, ptr_buffer, max_utf8_length);
        gate_string_create_static_len(&tmp, ptr_buffer, buffer_used);
        ret = gate_stream_print_string(stream, &tmp);
    } while (0);

    if ((ptr_buffer != NULL) && (ptr_buffer != &buffer[0]))
    {
        gate_mem_dealloc(ptr_buffer);
    }
    return ret;
}

gate_result_t gate_stream_println_cstr(gate_stream_t* stream, char const* text)
{
    gate_size_t textlength = gate_str_length(text);
    gate_result_t result = GATE_RESULT_OK;
    if (textlength > 0)
    {
        result = gate_stream_write_block(stream, text, textlength, NULL);
    }
    if (GATE_SUCCEEDED(result))
    {
        result = gate_stream_write_block(stream, GATE_STR_NEWLINE, GATE_STR_NEWLINE_LENGTH, NULL);
    }
    return result;
}
gate_result_t gate_stream_print_int(gate_stream_t* stream, gate_int32_t num)
{
    gate_char8_t buffer[24];
    gate_size_t bufferlength = gate_str_print_int32(buffer, sizeof(buffer), num);
    return gate_stream_write_block(stream, buffer, bufferlength, NULL);
}
gate_result_t gate_stream_print_uint(gate_stream_t* stream, gate_uint32_t num)
{
    gate_char8_t buffer[24];
    gate_size_t bufferlength = gate_str_print_uint32(buffer, sizeof(buffer), num);
    return gate_stream_write_block(stream, buffer, bufferlength, NULL);
}
gate_result_t gate_stream_print_int64(gate_stream_t* stream, gate_int64_t num)
{
    gate_char8_t buffer[48];
    gate_size_t bufferlength = gate_str_print_int64(buffer, sizeof(buffer), num);
    return gate_stream_write_block(stream, buffer, bufferlength, NULL);
}
gate_result_t gate_stream_print_uint64(gate_stream_t* stream, gate_uint64_t num)
{
    gate_char8_t buffer[48];
    gate_size_t bufferlength = gate_str_print_uint64(buffer, sizeof(buffer), num);
    return gate_stream_write_block(stream, buffer, bufferlength, NULL);
}
gate_result_t gate_stream_print_real(gate_stream_t* stream, gate_real64_t num, unsigned intlen, unsigned decimallen, unsigned grouplen)
{
    gate_char8_t buffer[64];
    gate_size_t bufferlength = gate_str_print_real(buffer, sizeof(buffer), num, intlen, decimallen, grouplen);
    return gate_stream_write_block(stream, buffer, bufferlength, NULL);
}
gate_result_t gate_stream_print_string(gate_stream_t* stream, gate_string_t const* text)
{
    if (text != NULL)
    {
        return gate_stream_write_block(stream, text->str, text->length, NULL);
    }
    else
    {
        return GATE_RESULT_OK;
    }
}


gate_result_t gate_stream_print(gate_stream_t* stream, ...)
{
    gate_result_t ret = GATE_RESULT_OK;
    int print_type;
<--- The scope of the variable 'print_type' can be reduced. [+]
The scope of the variable 'print_type' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    gate_bool_t continue_loop = true;
    gate_bool_t val_bool;
    char val_chr[2] = GATE_INIT_EMPTY;
    char const* val_cstr;
    gate_string_t const* val_str;
    gate_int8_t val_i8;
    gate_uint8_t val_ui8;
    gate_int16_t val_i16;
    gate_uint16_t val_ui16;
    gate_int32_t val_i32;
    gate_uint32_t val_ui32;
    gate_int64_t val_i64;
    gate_uint64_t val_ui64;
    gate_real32_t val_r32;
    gate_real64_t val_r64;
    void* val_ptr;
    char const* ptr_text = NULL;
    char buffer[512];
    gate_size_t text_len;
    va_list vl;
    va_start(vl, stream);

    /* INFO: types small than [int] are converted to [int]
       https://stackoverflow.com/questions/23983471/char-is-promoted-to-int-when-passed-through-in-c
    */

    while (continue_loop)
    {
        print_type = va_arg(vl, int);
        ptr_text = NULL;
        text_len = 0;
        switch (print_type)
        {
        case GATE_PRINT_END:
        {
            text_len = 0;
            continue_loop = false;
            break;
        }
        case GATE_PRINT_CHAR:
        {
            val_chr[0] = (char)va_arg(vl, int);
            ptr_text = &val_chr[0];
            text_len = 1;
            break;
        }
        case GATE_PRINT_NEWLINE:
        {
            ptr_text = GATE_STR_NEWLINE;
            text_len = GATE_STR_NEWLINE_LENGTH;
            break;
        }
        case GATE_PRINT_CR:
        {
            ptr_text = GATE_STR_CR;
            text_len = 1;
            break;
        }
        case GATE_PRINT_LF:
        {
            ptr_text = GATE_STR_LF;
            text_len = 1;
            break;
        }
        case GATE_PRINT_CRLF:
        {
            ptr_text = GATE_STR_CRLF;
            text_len = 2;
            break;
        }
        case GATE_PRINT_CSTR:
        {
            val_cstr = va_arg(vl, char const*);
            ptr_text = val_cstr;
            text_len = gate_str_length(val_cstr);
            break;
        }
        case GATE_PRINT_STRING:
        {
            val_str = va_arg(vl, gate_string_t const*);
            ptr_text = val_str->str;
            text_len = val_str->length;
            break;
        }
        case GATE_PRINT_BOOL:
        {
            val_bool = (gate_bool_t)va_arg(vl, int);
            ptr_text = val_bool ? "true" : "false";
            text_len = val_bool ? 4 : 5;
            break;
        }
        case GATE_PRINT_I8:
        {
            val_i8 = (gate_int8_t)va_arg(vl, int);
            text_len = gate_str_print_int16(buffer, sizeof(buffer), val_i8);
            ptr_text = buffer;
            break;
        }
        case GATE_PRINT_UI8:
        {
            val_ui8 = (gate_uint8_t)va_arg(vl, int);
            text_len = gate_str_print_uint16(buffer, sizeof(buffer), val_ui8);
            ptr_text = buffer;
            break;
        }
        case GATE_PRINT_I16:
        {
            val_i16 = (gate_int16_t)va_arg(vl, int);
            text_len = gate_str_print_int16(buffer, sizeof(buffer), val_i16);
            ptr_text = buffer;
            break;
        }
        case GATE_PRINT_UI16:
        {
            val_ui16 = (gate_uint16_t)va_arg(vl, int);
            text_len = gate_str_print_uint16(buffer, sizeof(buffer), val_ui16);
            ptr_text = buffer;
            break;
        }
        case GATE_PRINT_I32:
        {
            val_i32 = va_arg(vl, gate_int32_t);
            text_len = gate_str_print_int32(buffer, sizeof(buffer), val_i32);
            ptr_text = buffer;
            break;
        }
        case GATE_PRINT_UI32:
        {
            val_ui32 = va_arg(vl, gate_uint32_t);
            text_len = gate_str_print_uint32(buffer, sizeof(buffer), val_ui32);
            ptr_text = buffer;
            break;
        }
        case GATE_PRINT_I64:
        {
            val_i64 = va_arg(vl, gate_int64_t);
            text_len = gate_str_print_int64(buffer, sizeof(buffer), val_i64);
            ptr_text = buffer;
            break;
        }
        case GATE_PRINT_UI64:
        {
            val_ui64 = va_arg(vl, gate_uint64_t);
            text_len = gate_str_print_uint64(buffer, sizeof(buffer), val_ui64);
            ptr_text = buffer;
            break;
        }
        case GATE_PRINT_H8:
        {
            val_ui8 = (gate_uint8_t)va_arg(vl, unsigned int);
            text_len = gate_str_print_hex(buffer, sizeof(buffer), val_ui8, 1, false);
            ptr_text = buffer;
            break;
        }
        case GATE_PRINT_H16:
        {
            val_ui16 = (gate_uint16_t)va_arg(vl, unsigned int);
            text_len = gate_str_print_hex(buffer, sizeof(buffer), val_ui16, 2, false);
            ptr_text = buffer;
            break;
        }
        case GATE_PRINT_H32:
        {
            val_ui32 = (gate_uint32_t)va_arg(vl, gate_uint32_t);
            text_len = gate_str_print_hex(buffer, sizeof(buffer), val_ui32, 4, false);
            ptr_text = buffer;
            break;
        }
        case GATE_PRINT_H64:
        {
            val_ui64 = (gate_uint64_t)va_arg(vl, gate_uint64_t);
            text_len = gate_str_print_hex(buffer, sizeof(buffer), val_ui64, 8, false);
            ptr_text = buffer;
            break;
        }
        case GATE_PRINT_R32:
        {
            val_r32 = (gate_real32_t)va_arg(vl, double);
            text_len = gate_str_print_real(buffer, sizeof(buffer), val_r32, 0, 6, 0);
            ptr_text = buffer;
            break;
        }
        case GATE_PRINT_R64:
        {
            val_r64 = va_arg(vl, gate_real64_t);
            text_len = gate_str_print_real(buffer, sizeof(buffer), val_r64, 0, 6, 0);
            ptr_text = buffer;
            break;
        }
        case GATE_PRINT_ADDRESS:
        {
            val_ptr = va_arg(vl, void*);
            if (sizeof(void*) == 2)
            {
                text_len = gate_str_print_hex_uint16(buffer, sizeof(buffer), (gate_uint16_t)(gate_uintptr_t)val_ptr, true);
            }
            else if (sizeof(void*) == 4)
            {
                text_len = gate_str_print_hex_uint32(buffer, sizeof(buffer), (gate_uint32_t)(gate_uintptr_t)val_ptr, true);
            }
            else
            {
                text_len = gate_str_print_hex_uint64(buffer, sizeof(buffer), (gate_uint64_t)(gate_uintptr_t)val_ptr, true);
            }
            ptr_text = buffer;
            break;
        }
        default:
        {
            ret = GATE_RESULT_INVALIDARG;
            continue_loop = false;
            break;
        }
        }

        ret = gate_stream_write_block(stream, ptr_text, text_len, &text_len);
        GATE_BREAK_IF_FAILED(ret);
    }
    va_end(vl);
    return ret;
}

static gate_result_t gate_stream_peek_utf8_char(gate_stream_t* stream, gate_char32_t* chr, gate_size_t* decoded)
{
    char utf8_buffer[16];
    gate_size_t bytes_returned = 0;
    gate_size_t bytes_decoded = 0;
    gate_result_t ret = GATE_RESULT_FAILED;

    ret = gate_stream_peek(stream, utf8_buffer, sizeof(utf8_buffer), &bytes_returned);
    if (GATE_SUCCEEDED(ret))
    {
        if (bytes_returned == 0)
        {
            /* end of stream reached */
            *chr = 0;
            *decoded = 0;
        }
        else
        {
            bytes_decoded = gate_char_read_utf8(utf8_buffer, bytes_returned, chr);
            if (bytes_decoded == 0)
            {
                /* utf8 error, return byte value instead */
                *chr = (gate_char32_t)(gate_uint8_t)utf8_buffer[0];
                *decoded = 1;
            }
            else
            {
                *decoded = bytes_decoded;
            }
        }
    }
    return ret;
}

gate_size_t	gate_stream_scan_char32(gate_stream_t* stream, gate_char32_t* chr)
{
    /* TODO */
    return 0;
}
gate_size_t	gate_stream_scan_char16(gate_stream_t* stream, gate_char16_t* chr)
{
    /* TODO */
    return 0;
}
gate_size_t	gate_stream_scan_char8(gate_stream_t* stream, gate_char8_t* chr)
{
    /* TODO */
    return 0;
}


gate_size_t	gate_stream_scan_int(gate_stream_t* stream, gate_int32_t* num)
{
    /* TODO */
    return 0;
}
gate_size_t	gate_stream_scan_uint(gate_stream_t* stream, gate_uint32_t* num)
{
    /* TODO */
    return 0;
}
gate_size_t	gate_stream_scan_int64(gate_stream_t* stream, gate_int64_t* num)
{
    /* TODO */
    return 0;
}
gate_size_t	gate_stream_scan_uint64(gate_stream_t* stream, gate_uint64_t* num)
{
    /* TODO */
    return 0;
}
gate_size_t	gate_stream_scan_real(gate_stream_t* stream, gate_real64_t* num)
{
    /* TODO */
    return 0;
}
gate_size_t	gate_stream_scan_string(gate_stream_t* stream, gate_string_t* text)
{
    /* TODO */
    return 0;
}




gate_result_t gate_stream_transfer_buffer(gate_stream_t* src, gate_stream_t* dst, char* buffer, gate_size_t buffersize)
{
    gate_size_t bytes_read;
    gate_size_t bytes_written;
    gate_result_t result;
    for (;;)
    {
        result = gate_stream_read(src, buffer, buffersize, &bytes_read);
        if (GATE_FAILED(result))
        {
            break;
        }
        if (bytes_read == 0)
        {
            /* end of stream reached */
            break;
        }
        result = gate_stream_write_block(dst, buffer, bytes_read, &bytes_written);
        if (GATE_FAILED(result))
        {
            break;
        }
    }
    return result;
}

gate_result_t gate_stream_transfer_limit(gate_stream_t* src, gate_uint64_t limit, gate_stream_t* dst, gate_uint64_t* transferred)
{
    char buffer[GATE_MAX_COPYBUFFER_LENGTH];
    static gate_size_t const buffer_size = sizeof(buffer);
    gate_size_t next_size;
    gate_size_t bytes_read;
    gate_size_t bytes_written;
    gate_result_t result = GATE_RESULT_OK;
    gate_uint64_t counter = 0;
    while (limit > 0)
    {
        next_size = (limit > buffer_size) ? buffer_size : (gate_size_t)limit;
        result = gate_stream_read(src, buffer, next_size, &bytes_read);
        if (GATE_FAILED(result))
        {
            break;
        }
        if (bytes_read == 0)
        {
            /* end of stream reached */
            break;
        }
        GATE_DEBUG_ASSERT(limit >= bytes_read);
        limit -= bytes_read;
        result = gate_stream_write_block(dst, buffer, bytes_read, &bytes_written);
        if (GATE_FAILED(result))
        {
            break;
        }
        GATE_DEBUG_ASSERT(bytes_read == bytes_written);
        counter += bytes_written;
    }
    if (transferred)
    {
        *transferred = counter;
    }
    return result;
}


gate_result_t gate_stream_transfer(gate_stream_t* src, gate_stream_t* dst)
{
    char buffer[GATE_MAX_COPYBUFFER_LENGTH];
    return gate_stream_transfer_buffer(src, dst, buffer, sizeof(buffer));
}

gate_result_t gate_stream_skip(gate_stream_t* src, gate_uint64_t count, gate_uint64_t* bytes_skipped)
{
    char buffer[GATE_MAX_COPYBUFFER_LENGTH];
    gate_size_t nextlen;
    gate_size_t returned = 1;
    gate_result_t result = GATE_RESULT_OK;
    gate_uint64_t actual_skipped = 0;

    while ((count != 0) && (returned != 0))
    {
        nextlen = (count > GATE_MAX_COPYBUFFER_LENGTH) ? GATE_MAX_COPYBUFFER_LENGTH : (gate_size_t)count;
        result = gate_stream_read_block(src, buffer, nextlen, &returned);
        GATE_BREAK_IF_FAILED(result);
        GATE_DEBUG_ASSERT(returned <= nextlen);
        actual_skipped += returned;
        count -= returned;
    }
    if (bytes_skipped)
    {
        *bytes_skipped = actual_skipped;
    }
    return result;
}