rroonga 5.0.1-x64-mingw32 → 5.0.2-x64-mingw32

data/vendor/local/include/msgpack/util.h

@@ -0,0 +1,23 @@
+/*
+ * MessagePack for C utilities
+ *
+ * Copyright (C) 2014 FURUHASHI Sadayuki
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+#ifndef MSGPACK_UTIL_H
+#define MSGPACK_UTIL_H
+
+#define MSGPACK_UNUSED(a) (void)(a)
+
+#endif /* MSGPACK_UTIL_H */

data/vendor/local/include/msgpack/version.h

@@ -15,22 +15,28 @@
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
-#ifndef MSGPACK_VERSION_H__
-#define MSGPACK_VERSION_H__
+#ifndef MSGPACK_VERSION_H
+#define MSGPACK_VERSION_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-
+MSGPACK_DLLEXPORT
 const char* msgpack_version(void);
+MSGPACK_DLLEXPORT
 int msgpack_version_major(void);
+MSGPACK_DLLEXPORT
 int msgpack_version_minor(void);
+MSGPACK_DLLEXPORT
+int msgpack_version_revision(void);
+
+#include "version_master.h"
 
-#define MSGPACK_VERSION "0.5.9"
-#define MSGPACK_VERSION_MAJOR 0
-#define MSGPACK_VERSION_MINOR 5
+#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)
 
 #ifdef __cplusplus
 }

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

@@ -0,0 +1,44 @@
+/*
+ * MessagePack for C++ version information
+ *
+ * Copyright (C) 2008-2013 FURUHASHI Sadayuki and Takatoshi Kondo
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+#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/version_master.h

@@ -0,0 +1,3 @@
+#define MSGPACK_VERSION_MAJOR    1
+#define MSGPACK_VERSION_MINOR    0
+#define MSGPACK_VERSION_REVISION 1

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

@@ -0,0 +1,77 @@
+/*
+ * MessagePack for C++ version switcher
+ *
+ * Copyright (C) 2014 KONDO Takatoshi
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+#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_PP_CAT(v, MSGPACK_DEFAULT_API_VERSION)
+
+#if   MSGPACK_DEFAULT_API_VERSION == 1
+#define MSGPACK_PP_ENABLE_NS_v1 ()
+//#elif MSGPACK_DEFAULT_API_VERSION == 2
+//#define MSGPACK_PP_ENABLE_NS_v2 ()
+#else
+#error
+#endif
+
+#define MSGPACK_PP_CAT(a, ...) MSGPACK_PP_PRIMITIVE_CAT(a, __VA_ARGS__)
+#define MSGPACK_PP_PRIMITIVE_CAT(a, ...) a ## __VA_ARGS__
+
+#define MSGPACK_PP_IIF(c) MSGPACK_PP_PRIMITIVE_CAT(MSGPACK_PP_IIF_, c)
+#define MSGPACK_PP_IIF_0(t, ...) __VA_ARGS__
+#define MSGPACK_PP_IIF_1(t, ...) t
+
+#define MSGPACK_PP_PROBE(x) x, 1
+
+#if defined(_MSC_VER)
+
+#define MSGPACK_PP_MSVC_VA_ARGS_WORKAROUND(define, args) define args
+#define MSGPACK_PP_CHECK(...) MSGPACK_PP_MSVC_VA_ARGS_WORKAROUND(MSGPACK_PP_CHECK_N, (__VA_ARGS__, 0))
+#define MSGPACK_PP_CHECK_N(x, n, ...) n
+
+#else  // defined(__MSC_VER)
+
+#define MSGPACK_PP_CHECK(...) MSGPACK_PP_CHECK_N(__VA_ARGS__, 0)
+#define MSGPACK_PP_CHECK_N(x, n, ...) n
+
+#endif // defined(__MSC_VER)
+
+
+#define MSGPACK_PP_NS_ENABLED_PROBE(ns)            MSGPACK_PP_NS_ENABLED_PROBE_PROXY( MSGPACK_PP_ENABLE_NS_##ns )
+#define MSGPACK_PP_NS_ENABLED_PROBE_PROXY(...)     MSGPACK_PP_NS_ENABLED_PROBE_PRIMIVIE(__VA_ARGS__)
+#define MSGPACK_PP_NS_ENABLED_PROBE_PRIMIVIE(x)    MSGPACK_PP_NS_ENABLED_PROBE_COMBINE_ x
+#define MSGPACK_PP_NS_ENABLED_PROBE_COMBINE_(...)  MSGPACK_PP_PROBE(~)
+
+#define MSGPACK_PP_IS_NS_ENABLED(ns) MSGPACK_PP_CHECK(MSGPACK_PP_NS_ENABLED_PROBE(ns))
+
+#if __cplusplus < 201103
+#define MSGPACK_API_VERSION_NAMESPACE(ns) MSGPACK_PP_IIF(MSGPACK_PP_IS_NS_ENABLED(ns)) \
+    (namespace ns{}; using namespace ns; namespace ns, \
+     namespace ns)
+
+#else  // __cplusplus < 201103
+
+#define MSGPACK_API_VERSION_NAMESPACE(ns) MSGPACK_PP_IIF(MSGPACK_PP_IS_NS_ENABLED(ns)) \
+    (inline namespace ns, namespace ns)
+
+#endif // __cplusplus < 201103
+
+#endif // MSGPACK_VERSIONING_HPP

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

@@ -15,8 +15,8 @@
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
-#ifndef MSGPACK_VREFBUFFER_H__
-#define MSGPACK_VREFBUFFER_H__
+#ifndef MSGPACK_VREFBUFFER_H
+#define MSGPACK_VREFBUFFER_H
 
 #include "zone.h"
 #include <stdlib.h>
@@ -25,8 +25,8 @@
 #include <sys/uio.h>
 #else
 struct iovec {
-	void  *iov_base;
-	size_t iov_len;
+    void  *iov_base;
+    size_t iov_len;
 };
 #endif
 
@@ -45,20 +45,20 @@ struct msgpack_vrefbuffer_chunk;
 typedef struct msgpack_vrefbuffer_chunk msgpack_vrefbuffer_chunk;
 
 typedef struct msgpack_vrefbuffer_inner_buffer {
-	size_t free;
-	char*  ptr;
-	msgpack_vrefbuffer_chunk* head;
+    size_t free;
+    char*  ptr;
+    msgpack_vrefbuffer_chunk* head;
 } msgpack_vrefbuffer_inner_buffer;
 
 typedef struct msgpack_vrefbuffer {
-	struct iovec* tail;
-	struct iovec* end;
-	struct iovec* array;
+    struct iovec* tail;
+    struct iovec* end;
+    struct iovec* array;
 
-	size_t chunk_size;
-	size_t ref_size;
+    size_t chunk_size;
+    size_t ref_size;
 
-	msgpack_vrefbuffer_inner_buffer inner_buffer;
+    msgpack_vrefbuffer_inner_buffer inner_buffer;
 } msgpack_vrefbuffer;
 
 
@@ -70,8 +70,10 @@ typedef struct msgpack_vrefbuffer {
 #define MSGPACK_VREFBUFFER_CHUNK_SIZE 8192
 #endif
 
+MSGPACK_DLLEXPORT
 bool msgpack_vrefbuffer_init(msgpack_vrefbuffer* vbuf,
-		size_t ref_size, size_t chunk_size);
+        size_t ref_size, size_t chunk_size);
+MSGPACK_DLLEXPORT
 void msgpack_vrefbuffer_destroy(msgpack_vrefbuffer* vbuf);
 
 static inline msgpack_vrefbuffer* msgpack_vrefbuffer_new(size_t ref_size, size_t chunk_size);
@@ -82,14 +84,18 @@ static inline int msgpack_vrefbuffer_write(void* data, const char* buf, size_t l
 static inline const struct iovec* msgpack_vrefbuffer_vec(const msgpack_vrefbuffer* vref);
 static inline size_t msgpack_vrefbuffer_veclen(const msgpack_vrefbuffer* vref);
 
+MSGPACK_DLLEXPORT
 int msgpack_vrefbuffer_append_copy(msgpack_vrefbuffer* vbuf,
-		const char* buf, size_t len);
+        const char* buf, size_t len);
 
+MSGPACK_DLLEXPORT
 int msgpack_vrefbuffer_append_ref(msgpack_vrefbuffer* vbuf,
-		const char* buf, size_t len);
+        const char* buf, size_t len);
 
+MSGPACK_DLLEXPORT
 int msgpack_vrefbuffer_migrate(msgpack_vrefbuffer* vbuf, msgpack_vrefbuffer* to);
 
+MSGPACK_DLLEXPORT
 void msgpack_vrefbuffer_clear(msgpack_vrefbuffer* vref);
 
 /** @} */
@@ -97,41 +103,41 @@ void msgpack_vrefbuffer_clear(msgpack_vrefbuffer* vref);
 
 static inline msgpack_vrefbuffer* msgpack_vrefbuffer_new(size_t ref_size, size_t chunk_size)
 {
-	msgpack_vrefbuffer* vbuf = (msgpack_vrefbuffer*)malloc(sizeof(msgpack_vrefbuffer));
-	if (vbuf == NULL) return NULL;
-	if(!msgpack_vrefbuffer_init(vbuf, ref_size, chunk_size)) {
-		free(vbuf);
-		return NULL;
-	}
-	return vbuf;
+    msgpack_vrefbuffer* vbuf = (msgpack_vrefbuffer*)malloc(sizeof(msgpack_vrefbuffer));
+    if (vbuf == NULL) return NULL;
+    if(!msgpack_vrefbuffer_init(vbuf, ref_size, chunk_size)) {
+        free(vbuf);
+        return NULL;
+    }
+    return vbuf;
 }
 
 static inline void msgpack_vrefbuffer_free(msgpack_vrefbuffer* vbuf)
 {
-	if(vbuf == NULL) { return; }
-	msgpack_vrefbuffer_destroy(vbuf);
-	free(vbuf);
+    if(vbuf == NULL) { return; }
+    msgpack_vrefbuffer_destroy(vbuf);
+    free(vbuf);
 }
 
 static inline int msgpack_vrefbuffer_write(void* data, const char* buf, size_t len)
 {
-	msgpack_vrefbuffer* vbuf = (msgpack_vrefbuffer*)data;
+    msgpack_vrefbuffer* vbuf = (msgpack_vrefbuffer*)data;
 
-	if(len < vbuf->ref_size) {
-		return msgpack_vrefbuffer_append_copy(vbuf, buf, len);
-	} else {
-		return msgpack_vrefbuffer_append_ref(vbuf, buf, len);
-	}
+    if(len < vbuf->ref_size) {
+        return msgpack_vrefbuffer_append_copy(vbuf, buf, len);
+    } else {
+        return msgpack_vrefbuffer_append_ref(vbuf, buf, len);
+    }
 }
 
 static inline const struct iovec* msgpack_vrefbuffer_vec(const msgpack_vrefbuffer* vref)
 {
-	return vref->array;
+    return vref->array;
 }
 
 static inline size_t msgpack_vrefbuffer_veclen(const msgpack_vrefbuffer* vref)
 {
-	return (size_t)(vref->tail - vref->array);
+    return (size_t)(vref->tail - vref->array);
 }
 
 

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

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ zero-copy buffer implementation
 //
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi
 //
 //    Licensed under the Apache License, Version 2.0 (the "License");
 //    you may not use this file except in compliance with the License.
@@ -15,85 +15,282 @@
 //    See the License for the specific language governing permissions and
 //    limitations under the License.
 //
-#ifndef MSGPACK_VREFBUFFER_HPP__
-#define MSGPACK_VREFBUFFER_HPP__
+#ifndef MSGPACK_VREFBUFFER_HPP
+#define MSGPACK_VREFBUFFER_HPP
+
+#include "msgpack/versioning.hpp"
 
-#include "vrefbuffer.h"
 #include <stdexcept>
 
+#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 {
 
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+
+namespace detail {
+    // int64, uint64, double
+    std::size_t const packer_max_buffer_size = 9;
+} // detail
 
-class vrefbuffer : public msgpack_vrefbuffer {
+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)
-	{
-		if (!msgpack_vrefbuffer_init(this, ref_size, chunk_size)) {
-			throw std::bad_alloc();
-		}
-	}
-
-	~vrefbuffer()
-	{
-		msgpack_vrefbuffer_destroy(this);
-	}
+    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 < base::ref_size) {
-			append_copy(buf, len);
-		} else {
-			append_ref(buf, len);
-		}
-	}
-
-	void append_ref(const char* buf, size_t len)
-	{
-		if(msgpack_vrefbuffer_append_ref(this, buf, len) < 0) {
-			throw std::bad_alloc();
-		}
-	}
-
-	void append_copy(const char* buf, size_t len)
-	{
-		if(msgpack_vrefbuffer_append_copy(this, buf, len) < 0) {
-			throw std::bad_alloc();
-		}
-	}
-
-	const struct iovec* vector() const
-	{
-		return msgpack_vrefbuffer_vec(this);
-	}
-
-	size_t vector_size() const
-	{
-		return msgpack_vrefbuffer_veclen(this);
-	}
-
-	void migrate(vrefbuffer* to)
-	{
-		if(msgpack_vrefbuffer_migrate(this, to) < 0) {
-			throw std::bad_alloc();
-		}
-	}
-
-	void clear()
-	{
-		msgpack_vrefbuffer_clear(this);
-	}
+    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:
-	typedef msgpack_vrefbuffer base;
+    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:
-	vrefbuffer(const vrefbuffer&);
+    iovec* m_tail;
+    iovec* m_end;
+    iovec* m_array;
+
+    size_t m_ref_size;
+    size_t m_chunk_size;
+
+    inner_buffer m_inner_buffer;
+
 };
 
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
 
 }  // namespace msgpack
 
 #endif /* msgpack/vrefbuffer.hpp */
-