rroonga 6.0.5-x86-mingw32 → 6.0.7-x86-mingw32

data/vendor/local/include/msgpack/v1/version.hpp

@@ -0,0 +1,36 @@
+/*
+ * MessagePack for C++ version information
+ *
+ * Copyright (C) 2008-2013 FURUHASHI Sadayuki and Takatoshi Kondo
+ *
+ *    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_VERSION_HPP
+#define MSGPACK_VERSION_HPP
+
+#include "version_master.h"
+
+#define MSGPACK_STR(v) #v
+#define MSGPACK_VERSION_I(maj, min, rev) MSGPACK_STR(maj) "." MSGPACK_STR(min) "." MSGPACK_STR(rev)
+
+#define MSGPACK_VERSION MSGPACK_VERSION_I(MSGPACK_VERSION_MAJOR, MSGPACK_VERSION_MINOR, MSGPACK_VERSION_REVISION)
+
+inline const char* msgpack_version(void) {
+    return MSGPACK_VERSION;
+}
+
+inline int msgpack_version_major(void) {
+    return MSGPACK_VERSION_MAJOR;
+}
+
+inline int msgpack_version_minor(void) {
+    return MSGPACK_VERSION_MINOR;
+}
+
+inline int msgpack_version_revision(void) {
+    return MSGPACK_VERSION_REVISION;
+}
+
+#endif /* msgpack/version.hpp */

data/vendor/local/include/msgpack/v1/versioning.hpp

@@ -0,0 +1,69 @@
+/*
+ * MessagePack for C++ version switcher
+ *
+ * Copyright (C) 2014 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_VERSIONING_HPP
+#define MSGPACK_VERSIONING_HPP
+
+#if !defined(MSGPACK_DEFAULT_API_VERSION)
+#define MSGPACK_DEFAULT_API_VERSION 1
+#endif
+
+#define MSGPACK_DEFAULT_API_NS MSGPACK_DETAIL_PP_CAT(v, MSGPACK_DEFAULT_API_VERSION)
+
+#if   MSGPACK_DEFAULT_API_VERSION == 1
+#define MSGPACK_DETAIL_PP_ENABLE_NS_v1 ()
+//#elif MSGPACK_DEFAULT_API_VERSION == 2
+//#define MSGPACK_DETAIL_PP_ENABLE_NS_v2 ()
+#else
+#error
+#endif
+
+#define MSGPACK_DETAIL_PP_CAT(a, ...) MSGPACK_DETAIL_PP_PRIMITIVE_CAT(a, __VA_ARGS__)
+#define MSGPACK_DETAIL_PP_PRIMITIVE_CAT(a, ...) a ## __VA_ARGS__
+
+#define MSGPACK_DETAIL_PP_IIF(c) MSGPACK_DETAIL_PP_PRIMITIVE_CAT(MSGPACK_DETAIL_PP_IIF_, c)
+#define MSGPACK_DETAIL_PP_IIF_0(t, ...) __VA_ARGS__
+#define MSGPACK_DETAIL_PP_IIF_1(t, ...) t
+
+#define MSGPACK_DETAIL_PP_PROBE(x) x, 1
+
+#if defined(_MSC_VER)
+
+#define MSGPACK_DETAIL_PP_MSVC_VA_ARGS_WORKAROUND(define, args) define args
+#define MSGPACK_DETAIL_PP_CHECK(...) MSGPACK_DETAIL_PP_MSVC_VA_ARGS_WORKAROUND(MSGPACK_DETAIL_PP_CHECK_N, (__VA_ARGS__, 0))
+#define MSGPACK_DETAIL_PP_CHECK_N(x, n, ...) n
+
+#else  // defined(__MSC_VER)
+
+#define MSGPACK_DETAIL_PP_CHECK(...) MSGPACK_DETAIL_PP_CHECK_N(__VA_ARGS__, 0)
+#define MSGPACK_DETAIL_PP_CHECK_N(x, n, ...) n
+
+#endif // defined(__MSC_VER)
+
+
+#define MSGPACK_DETAIL_PP_NS_ENABLED_PROBE(ns)            MSGPACK_DETAIL_PP_NS_ENABLED_PROBE_PROXY( MSGPACK_DETAIL_PP_ENABLE_NS_##ns )
+#define MSGPACK_DETAIL_PP_NS_ENABLED_PROBE_PROXY(...)     MSGPACK_DETAIL_PP_NS_ENABLED_PROBE_PRIMIVIE(__VA_ARGS__)
+#define MSGPACK_DETAIL_PP_NS_ENABLED_PROBE_PRIMIVIE(x)    MSGPACK_DETAIL_PP_NS_ENABLED_PROBE_COMBINE_ x
+#define MSGPACK_DETAIL_PP_NS_ENABLED_PROBE_COMBINE_(...)  MSGPACK_DETAIL_PP_PROBE(~)
+
+#define MSGPACK_DETAIL_PP_IS_NS_ENABLED(ns) MSGPACK_DETAIL_PP_CHECK(MSGPACK_DETAIL_PP_NS_ENABLED_PROBE(ns))
+
+#if __cplusplus < 201103L
+#define MSGPACK_API_VERSION_NAMESPACE(ns) MSGPACK_DETAIL_PP_IIF(MSGPACK_DETAIL_PP_IS_NS_ENABLED(ns)) \
+    (namespace ns{}; using namespace ns; namespace ns, \
+     namespace ns)
+
+#else  // __cplusplus < 201103L
+
+#define MSGPACK_API_VERSION_NAMESPACE(ns) MSGPACK_DETAIL_PP_IIF(MSGPACK_DETAIL_PP_IS_NS_ENABLED(ns)) \
+    (inline namespace ns, namespace ns)
+
+#endif // __cplusplus < 201103L
+
+#endif // MSGPACK_VERSIONING_HPP

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

@@ -0,0 +1,292 @@
+//
+// MessagePack for C++ zero-copy buffer implementation
+//
+// Copyright (C) 2008-2013 FURUHASHI Sadayuki and 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_V1_VREFBUFFER_HPP
+#define MSGPACK_V1_VREFBUFFER_HPP
+
+#include "msgpack/v1/vrefbuffer_decl.hpp"
+
+#include <stdexcept>
+#include <algorithm>
+
+#if defined(_MSC_VER)
+// avoiding confliction std::max, std::min, and macro in windows.h
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#endif // defined(_MSC_VER)
+
+#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 = MSGPACK_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 = MSGPACK_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 = MSGPACK_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_V1_VREFBUFFER_HPP

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

@@ -0,0 +1,39 @@
+//
+// MessagePack for C++ zero-copy buffer implementation
+//
+// 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
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V1_VREFBUFFER_DECL_HPP
+#define MSGPACK_V1_VREFBUFFER_DECL_HPP
+
+#include "msgpack/versioning.hpp"
+
+#include <cstdlib>
+
+#ifndef MSGPACK_VREFBUFFER_REF_SIZE
+#define MSGPACK_VREFBUFFER_REF_SIZE 32
+#endif
+
+#ifndef MSGPACK_VREFBUFFER_CHUNK_SIZE
+#define MSGPACK_VREFBUFFER_CHUNK_SIZE 8192
+#endif
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+class vrefbuffer;
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_V1_VREFBUFFER_DECL_HPP

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

@@ -0,0 +1,159 @@
+//
+// MessagePack for C++ deflate buffer implementation
+//
+// Copyright (C) 2010-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
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V1_ZBUFFER_HPP
+#define MSGPACK_V1_ZBUFFER_HPP
+
+#include "msgpack/v1/zbuffer_decl.hpp"
+
+#include <stdexcept>
+#include <zlib.h>
+
+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(MSGPACK_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 = MSGPACK_NULLPTR;
+        m_stream.next_out = MSGPACK_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 == MSGPACK_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_V1_ZBUFFER_HPP