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

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

@@ -15,8 +15,8 @@
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
-#ifndef MSGPACK_ZBUFFER_H__
-#define MSGPACK_ZBUFFER_H__
+#ifndef MSGPACK_ZBUFFER_H
+#define MSGPACK_ZBUFFER_H
 
 #include "sysdep.h"
 #include <stdlib.h>
@@ -35,17 +35,17 @@ extern "C" {
  */
 
 typedef struct msgpack_zbuffer {
-	z_stream stream;
-	char* data;
-	size_t init_size;
+    z_stream stream;
+    char* data;
+    size_t init_size;
 } msgpack_zbuffer;
 
 #ifndef MSGPACK_ZBUFFER_INIT_SIZE
 #define MSGPACK_ZBUFFER_INIT_SIZE 8192
 #endif
 
-static inline bool msgpack_zbuffer_init(msgpack_zbuffer* zbuf,
-		int level, size_t init_size);
+static inline bool msgpack_zbuffer_init(
+    msgpack_zbuffer* zbuf, int level, size_t init_size);
 static inline void msgpack_zbuffer_destroy(msgpack_zbuffer* zbuf);
 
 static inline msgpack_zbuffer* msgpack_zbuffer_new(int level, size_t init_size);
@@ -71,130 +71,130 @@ static inline bool msgpack_zbuffer_expand(msgpack_zbuffer* zbuf);
 
 
 bool msgpack_zbuffer_init(msgpack_zbuffer* zbuf,
-		int level, size_t init_size)
+        int level, size_t init_size)
 {
-	memset(zbuf, 0, sizeof(msgpack_zbuffer));
-	zbuf->init_size = init_size;
-	if(deflateInit(&zbuf->stream, level) != Z_OK) {
-		free(zbuf->data);
-		return false;
-	}
-	return true;
+    memset(zbuf, 0, sizeof(msgpack_zbuffer));
+    zbuf->init_size = init_size;
+    if(deflateInit(&zbuf->stream, level) != Z_OK) {
+        free(zbuf->data);
+        return false;
+    }
+    return true;
 }
 
 void msgpack_zbuffer_destroy(msgpack_zbuffer* zbuf)
 {
-	deflateEnd(&zbuf->stream);
-	free(zbuf->data);
+    deflateEnd(&zbuf->stream);
+    free(zbuf->data);
 }
 
 msgpack_zbuffer* msgpack_zbuffer_new(int level, size_t init_size)
 {
-	msgpack_zbuffer* zbuf = (msgpack_zbuffer*)malloc(sizeof(msgpack_zbuffer));
-	if (zbuf == NULL) return NULL;
-	if(!msgpack_zbuffer_init(zbuf, level, init_size)) {
-		free(zbuf);
-		return NULL;
-	}
-	return zbuf;
+    msgpack_zbuffer* zbuf = (msgpack_zbuffer*)malloc(sizeof(msgpack_zbuffer));
+    if (zbuf == NULL) return NULL;
+    if(!msgpack_zbuffer_init(zbuf, level, init_size)) {
+        free(zbuf);
+        return NULL;
+    }
+    return zbuf;
 }
 
 void msgpack_zbuffer_free(msgpack_zbuffer* zbuf)
 {
-	if(zbuf == NULL) { return; }
-	msgpack_zbuffer_destroy(zbuf);
-	free(zbuf);
+    if(zbuf == NULL) { return; }
+    msgpack_zbuffer_destroy(zbuf);
+    free(zbuf);
 }
 
 bool msgpack_zbuffer_expand(msgpack_zbuffer* zbuf)
 {
-	size_t used = (char*)zbuf->stream.next_out - zbuf->data;
-	size_t csize = used + zbuf->stream.avail_out;
-	size_t nsize = (csize == 0) ? zbuf->init_size : csize * 2;
+    size_t used = (char*)zbuf->stream.next_out - zbuf->data;
+    size_t csize = used + zbuf->stream.avail_out;
+    size_t nsize = (csize == 0) ? zbuf->init_size : csize * 2;
 
-	char* tmp = (char*)realloc(zbuf->data, nsize);
-	if(tmp == NULL) {
-		return false;
-	}
+    char* tmp = (char*)realloc(zbuf->data, nsize);
+    if(tmp == NULL) {
+        return false;
+    }
 
-	zbuf->data = tmp;
-	zbuf->stream.next_out  = (Bytef*)(tmp + used);
-	zbuf->stream.avail_out = nsize - used;
+    zbuf->data = tmp;
+    zbuf->stream.next_out  = (Bytef*)(tmp + used);
+    zbuf->stream.avail_out = nsize - used;
 
-	return true;
+    return true;
 }
 
 int msgpack_zbuffer_write(void* data, const char* buf, size_t len)
 {
-	msgpack_zbuffer* zbuf = (msgpack_zbuffer*)data;
+    msgpack_zbuffer* zbuf = (msgpack_zbuffer*)data;
 
-	zbuf->stream.next_in = (Bytef*)buf;
-	zbuf->stream.avail_in = len;
+    zbuf->stream.next_in = (Bytef*)buf;
+    zbuf->stream.avail_in = len;
 
-	do {
-		if(zbuf->stream.avail_out < MSGPACK_ZBUFFER_RESERVE_SIZE) {
-			if(!msgpack_zbuffer_expand(zbuf)) {
-				return -1;
-			}
-		}
+    do {
+        if(zbuf->stream.avail_out < MSGPACK_ZBUFFER_RESERVE_SIZE) {
+            if(!msgpack_zbuffer_expand(zbuf)) {
+                return -1;
+            }
+        }
 
-		if(deflate(&zbuf->stream, Z_NO_FLUSH) != Z_OK) {
-			return -1;
-		}
-	} while(zbuf->stream.avail_in > 0);
+        if(deflate(&zbuf->stream, Z_NO_FLUSH) != Z_OK) {
+            return -1;
+        }
+    } while(zbuf->stream.avail_in > 0);
 
-	return 0;
+    return 0;
 }
 
 char* msgpack_zbuffer_flush(msgpack_zbuffer* zbuf)
 {
-	while(true) {
-		switch(deflate(&zbuf->stream, Z_FINISH)) {
-		case Z_STREAM_END:
-			return zbuf->data;
-		case Z_OK:
-			if(!msgpack_zbuffer_expand(zbuf)) {
-				return NULL;
-			}
-			break;
-		default:
-			return NULL;
-		}
-	}
+    while(true) {
+        switch(deflate(&zbuf->stream, Z_FINISH)) {
+        case Z_STREAM_END:
+            return zbuf->data;
+        case Z_OK:
+            if(!msgpack_zbuffer_expand(zbuf)) {
+                return NULL;
+            }
+            break;
+        default:
+            return NULL;
+        }
+    }
 }
 
 const char* msgpack_zbuffer_data(const msgpack_zbuffer* zbuf)
 {
-	return zbuf->data;
+    return zbuf->data;
 }
 
 size_t msgpack_zbuffer_size(const msgpack_zbuffer* zbuf)
 {
-	return (char*)zbuf->stream.next_out - zbuf->data;
+    return (char*)zbuf->stream.next_out - zbuf->data;
 }
 
 void msgpack_zbuffer_reset_buffer(msgpack_zbuffer* zbuf)
 {
-	zbuf->stream.avail_out += (char*)zbuf->stream.next_out - zbuf->data;
-	zbuf->stream.next_out = (Bytef*)zbuf->data;
+    zbuf->stream.avail_out += (char*)zbuf->stream.next_out - zbuf->data;
+    zbuf->stream.next_out = (Bytef*)zbuf->data;
 }
 
 bool msgpack_zbuffer_reset(msgpack_zbuffer* zbuf)
 {
-	if(deflateReset(&zbuf->stream) != Z_OK) {
-		return false;
-	}
-	msgpack_zbuffer_reset_buffer(zbuf);
-	return true;
+    if(deflateReset(&zbuf->stream) != Z_OK) {
+        return false;
+    }
+    msgpack_zbuffer_reset_buffer(zbuf);
+    return true;
 }
 
 char* msgpack_zbuffer_release_buffer(msgpack_zbuffer* zbuf)
 {
-	char* tmp = zbuf->data;
-	zbuf->data = NULL;
-	zbuf->stream.next_out = NULL;
-	zbuf->stream.avail_out = 0;
-	return tmp;
+    char* tmp = zbuf->data;
+    zbuf->data = NULL;
+    zbuf->stream.next_out = NULL;
+    zbuf->stream.avail_out = 0;
+    return tmp;
 }
 
 /** @} */

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

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ deflate buffer implementation
 //
-// Copyright (C) 2010 FURUHASHI Sadayuki
+// Copyright (C) 2010-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,88 +15,157 @@
 //    See the License for the specific language governing permissions and
 //    limitations under the License.
 //
-#ifndef MSGPACK_ZBUFFER_HPP__
-#define MSGPACK_ZBUFFER_HPP__
+#ifndef MSGPACK_ZBUFFER_HPP
+#define MSGPACK_ZBUFFER_HPP
+
+#include "msgpack/versioning.hpp"
 
-#include "zbuffer.h"
 #include <stdexcept>
+#include <zlib.h>
+
+#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 {
 
+MSGPACK_API_VERSION_NAMESPACE(v1) {
 
-class zbuffer : public msgpack_zbuffer {
+class zbuffer {
 public:
-	zbuffer(int level = Z_DEFAULT_COMPRESSION,
-			size_t init_size = MSGPACK_ZBUFFER_INIT_SIZE)
-	{
-		if (!msgpack_zbuffer_init(this, level, init_size)) {
-			throw std::bad_alloc();
-		}
-	}
-
-	~zbuffer()
-	{
-		msgpack_zbuffer_destroy(this);
-	}
+    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)
-	{
-		if(msgpack_zbuffer_write(this, buf, len) < 0) {
-			throw std::bad_alloc();
-		}
-	}
-
-	char* flush()
-	{
-		char* buf = msgpack_zbuffer_flush(this);
-		if(!buf) {
-			throw std::bad_alloc();
-		}
-		return buf;
-	}
-
-	char* data()
-	{
-		return base::data;
-	}
-
-	const char* data() const
-	{
-		return base::data;
-	}
-
-	size_t size() const
-	{
-		return msgpack_zbuffer_size(this);
-	}
-
-	void reset()
-	{
-		if(!msgpack_zbuffer_reset(this)) {
-			throw std::bad_alloc();
-		}
-	}
-
-	void reset_buffer()
-	{
-		msgpack_zbuffer_reset_buffer(this);
-	}
-
-	char* release_buffer()
-	{
-		return msgpack_zbuffer_release_buffer(this);
-	}
+    void write(const char* buf, size_t len)
+    {
+        m_stream.next_in = reinterpret_cast<Bytef*>(const_cast<char*>(buf));
+        m_stream.avail_in = len;
+
+        do {
+            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();
+            }
+        } while(m_stream.avail_in > 0);
+    }
+
+    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:
-	typedef msgpack_zbuffer base;
+    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:
-	zbuffer(const zbuffer&);
+    z_stream m_stream;
+    char* m_data;
+    size_t m_init_size;
 };
 
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
 
 }  // namespace msgpack
 
 #endif /* msgpack/zbuffer.hpp */
-