rroonga 6.0.5-x64-mingw32 → 6.0.7-x64-mingw32

data/vendor/local/include/msgpack/vrefbuffer.hpp

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ zero-copy buffer implementation
 //
-// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi
+// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
 //
 //    Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
@@ -10,283 +10,8 @@
 #ifndef MSGPACK_VREFBUFFER_HPP
 #define MSGPACK_VREFBUFFER_HPP
 
-#include "msgpack/versioning.hpp"
+#include "msgpack/vrefbuffer_decl.hpp"
 
-#include <stdexcept>
+#include "msgpack/v1/vrefbuffer.hpp"
 
-#ifndef MSGPACK_VREFBUFFER_REF_SIZE
-#define MSGPACK_VREFBUFFER_REF_SIZE 32
-#endif
-
-#ifndef MSGPACK_VREFBUFFER_CHUNK_SIZE
-#define MSGPACK_VREFBUFFER_CHUNK_SIZE 8192
-#endif
-
-#ifndef _WIN32
-#include <sys/uio.h>
-#else
-struct iovec {
-    void  *iov_base;
-    size_t iov_len;
-};
-#endif
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace detail {
-    // int64, uint64, double
-    std::size_t const packer_max_buffer_size = 9;
-} // detail
-
-class vrefbuffer {
-private:
-    struct chunk {
-        chunk* next;
-    };
-    struct inner_buffer {
-        size_t free;
-        char*  ptr;
-        chunk* head;
-    };
-public:
-    vrefbuffer(size_t ref_size = MSGPACK_VREFBUFFER_REF_SIZE,
-               size_t chunk_size = MSGPACK_VREFBUFFER_CHUNK_SIZE)
-        :m_ref_size(std::max(ref_size, detail::packer_max_buffer_size + 1)),
-         m_chunk_size(chunk_size)
-    {
-        size_t nfirst = (sizeof(iovec) < 72/2) ?
-            72 / sizeof(iovec) : 8;
-
-        iovec* array = static_cast<iovec*>(::malloc(
-            sizeof(iovec) * nfirst));
-        if(!array) {
-            throw std::bad_alloc();
-        }
-
-        m_tail  = array;
-        m_end   = array + nfirst;
-        m_array = array;
-
-        chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + chunk_size));
-        if(!c) {
-            ::free(array);
-            throw std::bad_alloc();
-        }
-        inner_buffer* const ib = &m_inner_buffer;
-
-        ib->free = chunk_size;
-        ib->ptr      = reinterpret_cast<char*>(c) + sizeof(chunk);
-        ib->head = c;
-        c->next = nullptr;
-
-    }
-
-    ~vrefbuffer()
-    {
-        chunk* c = m_inner_buffer.head;
-        while(true) {
-            chunk* n = c->next;
-            ::free(c);
-            if(n != NULL) {
-                c = n;
-            } else {
-                break;
-            }
-        }
-        ::free(m_array);
-    }
-
-public:
-    void write(const char* buf, size_t len)
-    {
-        if(len < m_ref_size) {
-            append_copy(buf, len);
-        } else {
-            append_ref(buf, len);
-        }
-    }
-
-    void append_ref(const char* buf, size_t len)
-    {
-        if(m_tail == m_end) {
-            const size_t nused = m_tail - m_array;
-            const size_t nnext = nused * 2;
-
-            iovec* nvec = static_cast<iovec*>(::realloc(
-                m_array, sizeof(iovec)*nnext));
-            if(!nvec) {
-                throw std::bad_alloc();
-            }
-
-            m_array = nvec;
-            m_end   = nvec + nnext;
-            m_tail  = nvec + nused;
-        }
-
-        m_tail->iov_base = const_cast<char*>(buf);
-        m_tail->iov_len     = len;
-        ++m_tail;
-    }
-
-    void append_copy(const char* buf, size_t len)
-    {
-        inner_buffer* const ib = &m_inner_buffer;
-
-        if(ib->free < len) {
-            size_t sz = m_chunk_size;
-            if(sz < len) {
-                sz = len;
-            }
-
-            chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + sz));
-            if(!c) {
-                throw std::bad_alloc();
-            }
-
-            c->next = ib->head;
-            ib->head = c;
-            ib->free = sz;
-            ib->ptr      = reinterpret_cast<char*>(c) + sizeof(chunk);
-        }
-
-        char* m = ib->ptr;
-        std::memcpy(m, buf, len);
-        ib->free -= len;
-        ib->ptr      += len;
-
-        if(m_tail != m_array && m ==
-            static_cast<const char*>(
-                const_cast<const void *>((m_tail - 1)->iov_base)
-            ) + (m_tail - 1)->iov_len) {
-            (m_tail - 1)->iov_len += len;
-            return;
-        } else {
-            append_ref( m, len);
-        }
-    }
-
-    const struct iovec* vector() const
-    {
-        return m_array;
-    }
-
-    size_t vector_size() const
-    {
-        return m_tail - m_array;
-    }
-
-    void migrate(vrefbuffer* to)
-    {
-        size_t sz = m_chunk_size;
-
-        chunk* empty = static_cast<chunk*>(::malloc(sizeof(chunk) + sz));
-        if(!empty) {
-            throw std::bad_alloc();
-        }
-
-        empty->next = nullptr;
-
-        const size_t nused = m_tail - m_array;
-        if(to->m_tail + nused < m_end) {
-            const size_t tosize = to->m_tail - to->m_array;
-            const size_t reqsize = nused + tosize;
-            size_t nnext = (to->m_end - to->m_array) * 2;
-            while(nnext < reqsize) {
-                size_t tmp_nnext = nnext * 2;
-                if (tmp_nnext <= nnext) {
-                    nnext = reqsize;
-                    break;
-                }
-                nnext = tmp_nnext;
-            }
-
-            iovec* nvec = static_cast<iovec*>(::realloc(
-                to->m_array, sizeof(iovec)*nnext));
-            if(!nvec) {
-                ::free(empty);
-                throw std::bad_alloc();
-            }
-
-            to->m_array = nvec;
-            to->m_end   = nvec + nnext;
-            to->m_tail  = nvec + tosize;
-        }
-
-        std::memcpy(to->m_tail, m_array, sizeof(iovec)*nused);
-
-        to->m_tail += nused;
-        m_tail = m_array;
-
-
-        inner_buffer* const ib = &m_inner_buffer;
-        inner_buffer* const toib = &to->m_inner_buffer;
-
-        chunk* last = ib->head;
-        while(last->next) {
-            last = last->next;
-        }
-        last->next = toib->head;
-        toib->head = ib->head;
-
-        if(toib->free < ib->free) {
-            toib->free = ib->free;
-            toib->ptr  = ib->ptr;
-        }
-
-        ib->head = empty;
-        ib->free = sz;
-        ib->ptr      = reinterpret_cast<char*>(empty) + sizeof(chunk);
-
-    }
-
-    void clear()
-    {
-        chunk* c = m_inner_buffer.head->next;
-        chunk* n;
-        while(c) {
-            n = c->next;
-            ::free(c);
-            c = n;
-        }
-
-        inner_buffer* const ib = &m_inner_buffer;
-        c = ib->head;
-        c->next = nullptr;
-        ib->free = m_chunk_size;
-        ib->ptr      = reinterpret_cast<char*>(c) + sizeof(chunk);
-
-        m_tail = m_array;
-    }
-
-#if defined(MSGPACK_USE_CPP03)
-private:
-    vrefbuffer(const vrefbuffer&);
-    vrefbuffer& operator=(const vrefbuffer&);
-#else  // defined(MSGPACK_USE_CPP03)
-    vrefbuffer(const vrefbuffer&) = delete;
-    vrefbuffer& operator=(const vrefbuffer&) = delete;
-#endif // defined(MSGPACK_USE_CPP03)
-
-private:
-    iovec* m_tail;
-    iovec* m_end;
-    iovec* m_array;
-
-    size_t m_ref_size;
-    size_t m_chunk_size;
-
-    inner_buffer m_inner_buffer;
-
-};
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
-
-#endif /* msgpack/vrefbuffer.hpp */
+#endif // MSGPACK_VREFBUFFER_HPP

data/vendor/local/include/msgpack/vrefbuffer_decl.hpp

@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ zero-copy buffer implementation
+//
+// Copyright (C) 2016 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_VREFBUFFER_DECL_HPP
+#define MSGPACK_VREFBUFFER_DECL_HPP
+
+#include "msgpack/v1/vrefbuffer_decl.hpp"
+#include "msgpack/v2/vrefbuffer_decl.hpp"
+
+#endif // MSGPACK_VREFBUFFER_DECL_HPP

data/vendor/local/include/msgpack/zbuffer.hpp

@@ -10,158 +10,8 @@
 #ifndef MSGPACK_ZBUFFER_HPP
 #define MSGPACK_ZBUFFER_HPP
 
-#include "msgpack/versioning.hpp"
+#include "msgpack/zbuffer_decl.hpp"
 
-#include <stdexcept>
-#include <zlib.h>
+#include "msgpack/v1/zbuffer.hpp"
 
-#ifndef MSGPACK_ZBUFFER_RESERVE_SIZE
-#define MSGPACK_ZBUFFER_RESERVE_SIZE 512
-#endif
-
-#ifndef MSGPACK_ZBUFFER_INIT_SIZE
-#define MSGPACK_ZBUFFER_INIT_SIZE 8192
-#endif
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-class zbuffer {
-public:
-    zbuffer(int level = Z_DEFAULT_COMPRESSION,
-            size_t init_size = MSGPACK_ZBUFFER_INIT_SIZE)
-        : m_data(nullptr), m_init_size(init_size)
-    {
-        m_stream.zalloc = Z_NULL;
-        m_stream.zfree = Z_NULL;
-        m_stream.opaque = Z_NULL;
-        m_stream.next_out = Z_NULL;
-        m_stream.avail_out = 0;
-        if(deflateInit(&m_stream, level) != Z_OK) {
-            throw std::bad_alloc();
-        }
-    }
-
-    ~zbuffer()
-    {
-        deflateEnd(&m_stream);
-        ::free(m_data);
-    }
-
-public:
-    void write(const char* buf, size_t len)
-    {
-        m_stream.next_in = reinterpret_cast<Bytef*>(const_cast<char*>(buf));
-        m_stream.avail_in = len;
-
-        while(m_stream.avail_in > 0) {
-            if(m_stream.avail_out < MSGPACK_ZBUFFER_RESERVE_SIZE) {
-                if(!expand()) {
-                    throw std::bad_alloc();
-                }
-            }
-
-            if(deflate(&m_stream, Z_NO_FLUSH) != Z_OK) {
-                throw std::bad_alloc();
-            }
-        }
-    }
-
-    char* flush()
-    {
-        while(true) {
-            switch(deflate(&m_stream, Z_FINISH)) {
-            case Z_STREAM_END:
-                return m_data;
-            case Z_OK:
-                if(!expand()) {
-                    throw std::bad_alloc();
-                }
-                break;
-            default:
-                throw std::bad_alloc();
-            }
-        }
-    }
-
-    char* data()
-    {
-        return m_data;
-    }
-
-    const char* data() const
-    {
-        return m_data;
-    }
-
-    size_t size() const
-    {
-        return reinterpret_cast<char*>(m_stream.next_out) - m_data;
-    }
-
-    void reset()
-    {
-        if(deflateReset(&m_stream) != Z_OK) {
-            throw std::bad_alloc();
-        }
-        reset_buffer();
-    }
-
-    void reset_buffer()
-    {
-        m_stream.avail_out += reinterpret_cast<char*>(m_stream.next_out) - m_data;
-        m_stream.next_out = reinterpret_cast<Bytef*>(m_data);
-    }
-
-    char* release_buffer()
-    {
-        char* tmp = m_data;
-        m_data = nullptr;
-        m_stream.next_out = nullptr;
-        m_stream.avail_out = 0;
-        return tmp;
-    }
-
-private:
-    bool expand()
-    {
-        size_t used = reinterpret_cast<char*>(m_stream.next_out) - m_data;
-        size_t csize = used + m_stream.avail_out;
-        size_t nsize = (csize == 0) ? m_init_size : csize * 2;
-
-        char* tmp = static_cast<char*>(::realloc(m_data, nsize));
-        if(tmp == nullptr) {
-            return false;
-        }
-
-        m_data = tmp;
-        m_stream.next_out  = reinterpret_cast<Bytef*>(tmp + used);
-        m_stream.avail_out = nsize - used;
-
-        return true;
-    }
-#if defined(MSGPACK_USE_CPP03)
-private:
-    zbuffer(const zbuffer&);
-    zbuffer& operator=(const zbuffer&);
-#else  // defined(MSGPACK_USE_CPP03)
-    zbuffer(const zbuffer&) = delete;
-    zbuffer& operator=(const zbuffer&) = delete;
-#endif // defined(MSGPACK_USE_CPP03)
-
-private:
-    z_stream m_stream;
-    char* m_data;
-    size_t m_init_size;
-};
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
-
-#endif /* msgpack/zbuffer.hpp */
+#endif // MSGPACK_ZBUFFER_HPP