rroonga 9.0.3-x86-mingw32 → 9.0.7-x86-mingw32

data/test/test-schema-dumper.rb

@@ -395,6 +395,19 @@ column_create Terms Items_title COLUMN_INDEX|WITH_POSITION|INDEX_MEDIUM Items ti
       SCHEMA
     end
 
+    def test_large_index
+      define_index_schema(:title_index_options => {:size => :large})
+      assert_equal(<<-SCHEMA, dump)
+table_create Items TABLE_HASH_KEY ShortText
+column_create Items title COLUMN_SCALAR ShortText
+
+table_create Terms TABLE_PAT_KEY ShortText --default_tokenizer TokenBigram --token_filters TokenFilterStopWord --normalizer NormalizerAuto
+
+column_create Terms Items__key COLUMN_INDEX|WITH_POSITION Items _key
+column_create Terms Items_title COLUMN_INDEX|WITH_POSITION|INDEX_LARGE Items title
+      SCHEMA
+    end
+
     def test_weight_vector
       define_weight_vector_schema
       assert_equal(<<-SCHEMA, dump)

data/test/test-table.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009-2013  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2019  Kouhei Sutou <kou@clear-code.com>
 # Copyright (C) 2016  Masafumi Yokoyama <yokoyama@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
@@ -276,6 +276,25 @@ class TableTest < Test::Unit::TestCase
                  bookmark["created_at"].to_a)
   end
 
+  sub_test_case "#support_score?" do
+    setup
+    def setup_table
+      @table = Groonga::Hash.create(:name => "Bookmarks")
+    end
+
+    test "true" do
+       assert do
+         @table.select.support_score?
+      end
+    end
+
+    test "false" do
+      assert do
+        not @table.support_score?
+      end
+    end
+  end
+
   class DeleteTest < self
     setup
     def setup_data
@@ -738,6 +757,7 @@ class TableTest < Test::Unit::TestCase
 
     private
     def by_other_process
+      only_not_windows
       pid = Process.fork do
         yield
       end

data/test/test-variable.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2019  Sutou Kouhei <kou@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -16,13 +16,29 @@
 class VariableTest < Test::Unit::TestCase
   include GroongaTestUtils
 
-  setup :setup_database
+  def setup
+    setup_database
+    @expression = Groonga::Expression.new
+    @variable = @expression.define_variable
+  end
 
   def test_value
-    expression = Groonga::Expression.new
-    variable = expression.define_variable
-    assert_nil(variable.value)
-    variable.value = "morita"
-    assert_equal("morita", variable.value)
+    assert_nil(@variable.value)
+    @variable.value = "morita"
+    assert_equal("morita", @variable.value)
+  end
+
+  sub_test_case("#bulk?") do
+    def test_true
+      assert do
+        @variable.bulk?
+      end
+    end
+
+    def test_false
+      assert do
+        not @expression.bulk?
+      end
+    end
   end
 end

data/vendor/local/bin/generate-pdb.bat

@@ -1,38 +1,38 @@
-bin\cv2pdb.exe libexec\mecab\mecab-test-gen.exe libexec\mecab\mecab-test-gen.exe libexec\mecab\mecab-test-gen.pdb
-bin\cv2pdb.exe libexec\mecab\mecab-cost-train.exe libexec\mecab\mecab-cost-train.exe libexec\mecab\mecab-cost-train.pdb
-bin\cv2pdb.exe libexec\mecab\mecab-system-eval.exe libexec\mecab\mecab-system-eval.exe libexec\mecab\mecab-system-eval.pdb
-bin\cv2pdb.exe libexec\mecab\mecab-dict-index.exe libexec\mecab\mecab-dict-index.exe libexec\mecab\mecab-dict-index.pdb
-bin\cv2pdb.exe libexec\mecab\mecab-dict-gen.exe libexec\mecab\mecab-dict-gen.exe libexec\mecab\mecab-dict-gen.pdb
-bin\cv2pdb.exe bin\mecab.exe bin\mecab.exe bin\mecab.pdb
 bin\cv2pdb.exe bin\grndb.exe bin\grndb.exe bin\grndb.pdb
-bin\cv2pdb.exe bin\groonga-suggest-create-dataset.exe bin\groonga-suggest-create-dataset.exe bin\groonga-suggest-create-dataset.pdb
+bin\cv2pdb.exe bin\lz4cat.exe bin\lz4cat.exe bin\lz4cat.pdb
+bin\cv2pdb.exe bin\unlz4.exe bin\unlz4.exe bin\unlz4.pdb
+bin\cv2pdb.exe bin\mecab.exe bin\mecab.exe bin\mecab.pdb
 bin\cv2pdb.exe bin\pcregrep.exe bin\pcregrep.exe bin\pcregrep.pdb
-bin\cv2pdb.exe bin\groonga.exe bin\groonga.exe bin\groonga.pdb
 bin\cv2pdb.exe bin\groonga-benchmark.exe bin\groonga-benchmark.exe bin\groonga-benchmark.pdb
 bin\cv2pdb.exe bin\pcretest.exe bin\pcretest.exe bin\pcretest.pdb
-bin\cv2pdb.exe bin\unlz4.exe bin\unlz4.exe bin\unlz4.pdb
+bin\cv2pdb.exe bin\groonga-suggest-create-dataset.exe bin\groonga-suggest-create-dataset.exe bin\groonga-suggest-create-dataset.pdb
 bin\cv2pdb.exe bin\lz4c.exe bin\lz4c.exe bin\lz4c.pdb
 bin\cv2pdb.exe bin\lz4.exe bin\lz4.exe bin\lz4.pdb
-bin\cv2pdb.exe bin\lz4cat.exe bin\lz4cat.exe bin\lz4cat.pdb
-bin\cv2pdb.exe bin\libpcreposix-0.dll bin\libpcreposix-0.dll bin\libpcreposix-0.pdb
-bin\cv2pdb.exe bin\libpcre-1.dll bin\libpcre-1.dll bin\libpcre-1.pdb
+bin\cv2pdb.exe bin\groonga.exe bin\groonga.exe bin\groonga.pdb
+bin\cv2pdb.exe libexec\mecab\mecab-test-gen.exe libexec\mecab\mecab-test-gen.exe libexec\mecab\mecab-test-gen.pdb
+bin\cv2pdb.exe libexec\mecab\mecab-cost-train.exe libexec\mecab\mecab-cost-train.exe libexec\mecab\mecab-cost-train.pdb
+bin\cv2pdb.exe libexec\mecab\mecab-dict-index.exe libexec\mecab\mecab-dict-index.exe libexec\mecab\mecab-dict-index.pdb
+bin\cv2pdb.exe libexec\mecab\mecab-dict-gen.exe libexec\mecab\mecab-dict-gen.exe libexec\mecab\mecab-dict-gen.pdb
+bin\cv2pdb.exe libexec\mecab\mecab-system-eval.exe libexec\mecab\mecab-system-eval.exe libexec\mecab\mecab-system-eval.pdb
+bin\cv2pdb.exe bin\libpcrecpp-0.dll bin\libpcrecpp-0.dll bin\libpcrecpp-0.pdb
 bin\cv2pdb.exe bin\libmsgpackc.dll bin\libmsgpackc.dll bin\libmsgpackc.pdb
-bin\cv2pdb.exe bin\zlib1.dll bin\zlib1.dll bin\zlib1.pdb
+bin\cv2pdb.exe bin\libstdc++-6.dll bin\libstdc++-6.dll bin\libstdc++-6.pdb
+bin\cv2pdb.exe bin\libpcre-1.dll bin\libpcre-1.dll bin\libpcre-1.pdb
 bin\cv2pdb.exe bin\libgcc_s_sjlj-1.dll bin\libgcc_s_sjlj-1.dll bin\libgcc_s_sjlj-1.pdb
-bin\cv2pdb.exe bin\libpcrecpp-0.dll bin\libpcrecpp-0.dll bin\libpcrecpp-0.pdb
-bin\cv2pdb.exe bin\libmecab-2.dll bin\libmecab-2.dll bin\libmecab-2.pdb
 bin\cv2pdb.exe bin\libgroonga-0.dll bin\libgroonga-0.dll bin\libgroonga-0.pdb
+bin\cv2pdb.exe bin\libpcreposix-0.dll bin\libpcreposix-0.dll bin\libpcreposix-0.pdb
 bin\cv2pdb.exe bin\libonigmo-6.dll bin\libonigmo-6.dll bin\libonigmo-6.pdb
-bin\cv2pdb.exe bin\libstdc++-6.dll bin\libstdc++-6.dll bin\libstdc++-6.pdb
+bin\cv2pdb.exe bin\zlib1.dll bin\zlib1.dll bin\zlib1.pdb
+bin\cv2pdb.exe bin\libmecab-2.dll bin\libmecab-2.dll bin\libmecab-2.pdb
 bin\cv2pdb.exe lib\liblz4.dll lib\liblz4.dll lib\liblz4.pdb
-bin\cv2pdb.exe lib\groonga\plugins\tokenizers\mecab.dll lib\groonga\plugins\tokenizers\mecab.dll lib\groonga\plugins\tokenizers\mecab.pdb
 bin\cv2pdb.exe lib\groonga\plugins\suggest\suggest.dll lib\groonga\plugins\suggest\suggest.dll lib\groonga\plugins\suggest\suggest.pdb
-bin\cv2pdb.exe lib\groonga\plugins\query_expanders\tsv.dll lib\groonga\plugins\query_expanders\tsv.dll lib\groonga\plugins\query_expanders\tsv.pdb
-bin\cv2pdb.exe lib\groonga\plugins\normalizers\mysql.dll lib\groonga\plugins\normalizers\mysql.dll lib\groonga\plugins\normalizers\mysql.pdb
+bin\cv2pdb.exe lib\groonga\plugins\tokenizers\mecab.dll lib\groonga\plugins\tokenizers\mecab.dll lib\groonga\plugins\tokenizers\mecab.pdb
+bin\cv2pdb.exe lib\groonga\plugins\functions\vector.dll lib\groonga\plugins\functions\vector.dll lib\groonga\plugins\functions\vector.pdb
 bin\cv2pdb.exe lib\groonga\plugins\functions\time.dll lib\groonga\plugins\functions\time.dll lib\groonga\plugins\functions\time.pdb
 bin\cv2pdb.exe lib\groonga\plugins\functions\string.dll lib\groonga\plugins\functions\string.dll lib\groonga\plugins\functions\string.pdb
-bin\cv2pdb.exe lib\groonga\plugins\functions\number.dll lib\groonga\plugins\functions\number.dll lib\groonga\plugins\functions\number.pdb
-bin\cv2pdb.exe lib\groonga\plugins\functions\vector.dll lib\groonga\plugins\functions\vector.dll lib\groonga\plugins\functions\vector.pdb
 bin\cv2pdb.exe lib\groonga\plugins\functions\index_column.dll lib\groonga\plugins\functions\index_column.dll lib\groonga\plugins\functions\index_column.pdb
+bin\cv2pdb.exe lib\groonga\plugins\functions\number.dll lib\groonga\plugins\functions\number.dll lib\groonga\plugins\functions\number.pdb
 bin\cv2pdb.exe lib\groonga\plugins\functions\math.dll lib\groonga\plugins\functions\math.dll lib\groonga\plugins\functions\math.pdb
+bin\cv2pdb.exe lib\groonga\plugins\normalizers\mysql.dll lib\groonga\plugins\normalizers\mysql.dll lib\groonga\plugins\normalizers\mysql.pdb
+bin\cv2pdb.exe lib\groonga\plugins\query_expanders\tsv.dll lib\groonga\plugins\query_expanders\tsv.dll lib\groonga\plugins\query_expanders\tsv.pdb
 bin\cv2pdb.exe lib\groonga\plugins\token_filters\stop_word.dll lib\groonga\plugins\token_filters\stop_word.dll lib\groonga\plugins\token_filters\stop_word.pdb

data/vendor/local/cmake/RapidJSONConfig.cmake

@@ -0,0 +1,3 @@
+get_filename_component(RAPIDJSON_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
+set(RAPIDJSON_INCLUDE_DIRS "/build/dist-x86/include")
+message(STATUS "RapidJSON found. Headers: ${RAPIDJSON_INCLUDE_DIRS}")

data/vendor/local/cmake/RapidJSONConfigVersion.cmake

@@ -0,0 +1,10 @@
+SET(PACKAGE_VERSION "1.1.0")
+
+IF (PACKAGE_FIND_VERSION VERSION_EQUAL PACKAGE_VERSION)
+  SET(PACKAGE_VERSION_EXACT "true")
+ENDIF (PACKAGE_FIND_VERSION VERSION_EQUAL PACKAGE_VERSION)
+IF (NOT PACKAGE_FIND_VERSION VERSION_GREATER PACKAGE_VERSION)
+  SET(PACKAGE_VERSION_COMPATIBLE "true")
+ELSE (NOT PACKAGE_FIND_VERSION VERSION_GREATER PACKAGE_VERSION)
+  SET(PACKAGE_VERSION_UNSUITABLE "true")
+ENDIF (NOT PACKAGE_FIND_VERSION VERSION_GREATER PACKAGE_VERSION)

data/vendor/local/include/groonga/groonga/expr.h

@@ -1,5 +1,6 @@
 /*
   Copyright(C) 2009-2017 Brazil
+  Copyright(C) 2019 Sutou Kouhei <kou@clear-code.com>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -123,6 +124,21 @@ GRN_API grn_rc grn_expr_snip_add_conditions(grn_ctx *ctx,
 
 GRN_API unsigned int grn_expr_estimate_size(grn_ctx *ctx, grn_obj *expr);
 
+GRN_API grn_rc
+grn_expr_set_query_log_tag_prefix(grn_ctx *ctx,
+                                  grn_obj *expr,
+                                  const char *prefix,
+                                  int prefix_len);
+GRN_API const char *
+grn_expr_get_query_log_tag_prefix(grn_ctx *ctx, grn_obj *expr);
+
+GRN_API grn_rc
+grn_expr_set_parent(grn_ctx *ctx,
+                    grn_obj *expr,
+                    grn_obj *parent);
+GRN_API grn_obj *
+grn_expr_get_parent(grn_ctx *ctx, grn_obj *expr);
+
 #ifdef __cplusplus
 }
 #endif

data/vendor/local/include/groonga/groonga/obj.h

@@ -50,6 +50,14 @@ GRN_API grn_bool grn_obj_is_index_column(grn_ctx *ctx, grn_obj *obj);
 GRN_API grn_bool grn_obj_is_accessor(grn_ctx *ctx, grn_obj *obj);
 GRN_API grn_bool grn_obj_is_id_accessor(grn_ctx *ctx, grn_obj *obj);
 GRN_API grn_bool grn_obj_is_key_accessor(grn_ctx *ctx, grn_obj *obj);
+GRN_API bool grn_obj_is_value_accessor(grn_ctx *ctx, grn_obj *obj);
+GRN_API bool grn_obj_is_score_accessor(grn_ctx *ctx, grn_obj *obj);
+GRN_API bool grn_obj_is_nsubrecs_accessor(grn_ctx *ctx, grn_obj *obj);
+GRN_API bool grn_obj_is_max_accessor(grn_ctx *ctx, grn_obj *obj);
+GRN_API bool grn_obj_is_min_accessor(grn_ctx *ctx, grn_obj *obj);
+GRN_API bool grn_obj_is_sum_accessor(grn_ctx *ctx, grn_obj *obj);
+GRN_API bool grn_obj_is_avg_accessor(grn_ctx *ctx, grn_obj *obj);
+GRN_API bool grn_obj_is_column_value_accessor(grn_ctx *ctx, grn_obj *obj);
 GRN_API grn_bool grn_obj_is_type(grn_ctx *ctx, grn_obj *obj);
 GRN_API grn_bool grn_obj_is_text_family_type(grn_ctx *ctx, grn_obj *obj);
 GRN_API grn_bool grn_obj_is_proc(grn_ctx *ctx, grn_obj *obj);

data/vendor/local/include/groonga/groonga/output.h

@@ -46,6 +46,11 @@ struct _grn_obj_format {
   grn_obj *expression;
 };
 
+GRN_API grn_rc grn_output_range_normalize(grn_ctx *ctx,
+                                          int size,
+                                          int *offset,
+                                          int *limit);
+
 #define GRN_OBJ_FORMAT_INIT(format,format_nhits,format_offset,format_limit,format_hits_offset) do { \
   GRN_PTR_INIT(&(format)->columns, GRN_OBJ_VECTOR, GRN_ID_NIL);\
   (format)->nhits = (format_nhits);\

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

@@ -18,10 +18,10 @@
 
 #pragma once
 
-#define GRN_VERSION "9.0.2"
+#define GRN_VERSION "9.0.6"
 #define GRN_VERSION_MAJOR 9
 #define GRN_VERSION_MINOR 0
-#define GRN_VERSION_MICRO 2
+#define GRN_VERSION_MICRO 6
 
 #define GRN_VERSION_OR_LATER(major, minor, micro)       \
   (GRN_VERSION_MAJOR > (major) ||                       \

data/vendor/local/include/rapidjson/allocators.h

@@ -0,0 +1,271 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// 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 RAPIDJSON_ALLOCATORS_H_
+#define RAPIDJSON_ALLOCATORS_H_
+
+#include "rapidjson.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+// Allocator
+
+/*! \class rapidjson::Allocator
+    \brief Concept for allocating, resizing and freeing memory block.
+    
+    Note that Malloc() and Realloc() are non-static but Free() is static.
+    
+    So if an allocator need to support Free(), it needs to put its pointer in 
+    the header of memory block.
+
+\code
+concept Allocator {
+    static const bool kNeedFree;    //!< Whether this allocator needs to call Free().
+
+    // Allocate a memory block.
+    // \param size of the memory block in bytes.
+    // \returns pointer to the memory block.
+    void* Malloc(size_t size);
+
+    // Resize a memory block.
+    // \param originalPtr The pointer to current memory block. Null pointer is permitted.
+    // \param originalSize The current size in bytes. (Design issue: since some allocator may not book-keep this, explicitly pass to it can save memory.)
+    // \param newSize the new size in bytes.
+    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize);
+
+    // Free a memory block.
+    // \param pointer to the memory block. Null pointer is permitted.
+    static void Free(void *ptr);
+};
+\endcode
+*/
+
+///////////////////////////////////////////////////////////////////////////////
+// CrtAllocator
+
+//! C-runtime library allocator.
+/*! This class is just wrapper for standard C library memory routines.
+    \note implements Allocator concept
+*/
+class CrtAllocator {
+public:
+    static const bool kNeedFree = true;
+    void* Malloc(size_t size) { 
+        if (size) //  behavior of malloc(0) is implementation defined.
+            return std::malloc(size);
+        else
+            return NULL; // standardize to returning NULL.
+    }
+    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) {
+        (void)originalSize;
+        if (newSize == 0) {
+            std::free(originalPtr);
+            return NULL;
+        }
+        return std::realloc(originalPtr, newSize);
+    }
+    static void Free(void *ptr) { std::free(ptr); }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// MemoryPoolAllocator
+
+//! Default memory allocator used by the parser and DOM.
+/*! This allocator allocate memory blocks from pre-allocated memory chunks. 
+
+    It does not free memory blocks. And Realloc() only allocate new memory.
+
+    The memory chunks are allocated by BaseAllocator, which is CrtAllocator by default.
+
+    User may also supply a buffer as the first chunk.
+
+    If the user-buffer is full then additional chunks are allocated by BaseAllocator.
+
+    The user-buffer is not deallocated by this allocator.
+
+    \tparam BaseAllocator the allocator type for allocating memory chunks. Default is CrtAllocator.
+    \note implements Allocator concept
+*/
+template <typename BaseAllocator = CrtAllocator>
+class MemoryPoolAllocator {
+public:
+    static const bool kNeedFree = false;    //!< Tell users that no need to call Free() with this allocator. (concept Allocator)
+
+    //! Constructor with chunkSize.
+    /*! \param chunkSize The size of memory chunk. The default is kDefaultChunkSize.
+        \param baseAllocator The allocator for allocating memory chunks.
+    */
+    MemoryPoolAllocator(size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) : 
+        chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(0), baseAllocator_(baseAllocator), ownBaseAllocator_(0)
+    {
+    }
+
+    //! Constructor with user-supplied buffer.
+    /*! The user buffer will be used firstly. When it is full, memory pool allocates new chunk with chunk size.
+
+        The user buffer will not be deallocated when this allocator is destructed.
+
+        \param buffer User supplied buffer.
+        \param size Size of the buffer in bytes. It must at least larger than sizeof(ChunkHeader).
+        \param chunkSize The size of memory chunk. The default is kDefaultChunkSize.
+        \param baseAllocator The allocator for allocating memory chunks.
+    */
+    MemoryPoolAllocator(void *buffer, size_t size, size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) :
+        chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(buffer), baseAllocator_(baseAllocator), ownBaseAllocator_(0)
+    {
+        RAPIDJSON_ASSERT(buffer != 0);
+        RAPIDJSON_ASSERT(size > sizeof(ChunkHeader));
+        chunkHead_ = reinterpret_cast<ChunkHeader*>(buffer);
+        chunkHead_->capacity = size - sizeof(ChunkHeader);
+        chunkHead_->size = 0;
+        chunkHead_->next = 0;
+    }
+
+    //! Destructor.
+    /*! This deallocates all memory chunks, excluding the user-supplied buffer.
+    */
+    ~MemoryPoolAllocator() {
+        Clear();
+        RAPIDJSON_DELETE(ownBaseAllocator_);
+    }
+
+    //! Deallocates all memory chunks, excluding the user-supplied buffer.
+    void Clear() {
+        while (chunkHead_ && chunkHead_ != userBuffer_) {
+            ChunkHeader* next = chunkHead_->next;
+            baseAllocator_->Free(chunkHead_);
+            chunkHead_ = next;
+        }
+        if (chunkHead_ && chunkHead_ == userBuffer_)
+            chunkHead_->size = 0; // Clear user buffer
+    }
+
+    //! Computes the total capacity of allocated memory chunks.
+    /*! \return total capacity in bytes.
+    */
+    size_t Capacity() const {
+        size_t capacity = 0;
+        for (ChunkHeader* c = chunkHead_; c != 0; c = c->next)
+            capacity += c->capacity;
+        return capacity;
+    }
+
+    //! Computes the memory blocks allocated.
+    /*! \return total used bytes.
+    */
+    size_t Size() const {
+        size_t size = 0;
+        for (ChunkHeader* c = chunkHead_; c != 0; c = c->next)
+            size += c->size;
+        return size;
+    }
+
+    //! Allocates a memory block. (concept Allocator)
+    void* Malloc(size_t size) {
+        if (!size)
+            return NULL;
+
+        size = RAPIDJSON_ALIGN(size);
+        if (chunkHead_ == 0 || chunkHead_->size + size > chunkHead_->capacity)
+            if (!AddChunk(chunk_capacity_ > size ? chunk_capacity_ : size))
+                return NULL;
+
+        void *buffer = reinterpret_cast<char *>(chunkHead_) + RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + chunkHead_->size;
+        chunkHead_->size += size;
+        return buffer;
+    }
+
+    //! Resizes a memory block (concept Allocator)
+    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) {
+        if (originalPtr == 0)
+            return Malloc(newSize);
+
+        if (newSize == 0)
+            return NULL;
+
+        originalSize = RAPIDJSON_ALIGN(originalSize);
+        newSize = RAPIDJSON_ALIGN(newSize);
+
+        // Do not shrink if new size is smaller than original
+        if (originalSize >= newSize)
+            return originalPtr;
+
+        // Simply expand it if it is the last allocation and there is sufficient space
+        if (originalPtr == reinterpret_cast<char *>(chunkHead_) + RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + chunkHead_->size - originalSize) {
+            size_t increment = static_cast<size_t>(newSize - originalSize);
+            if (chunkHead_->size + increment <= chunkHead_->capacity) {
+                chunkHead_->size += increment;
+                return originalPtr;
+            }
+        }
+
+        // Realloc process: allocate and copy memory, do not free original buffer.
+        if (void* newBuffer = Malloc(newSize)) {
+            if (originalSize)
+                std::memcpy(newBuffer, originalPtr, originalSize);
+            return newBuffer;
+        }
+        else
+            return NULL;
+    }
+
+    //! Frees a memory block (concept Allocator)
+    static void Free(void *ptr) { (void)ptr; } // Do nothing
+
+private:
+    //! Copy constructor is not permitted.
+    MemoryPoolAllocator(const MemoryPoolAllocator& rhs) /* = delete */;
+    //! Copy assignment operator is not permitted.
+    MemoryPoolAllocator& operator=(const MemoryPoolAllocator& rhs) /* = delete */;
+
+    //! Creates a new chunk.
+    /*! \param capacity Capacity of the chunk in bytes.
+        \return true if success.
+    */
+    bool AddChunk(size_t capacity) {
+        if (!baseAllocator_)
+            ownBaseAllocator_ = baseAllocator_ = RAPIDJSON_NEW(BaseAllocator());
+        if (ChunkHeader* chunk = reinterpret_cast<ChunkHeader*>(baseAllocator_->Malloc(RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + capacity))) {
+            chunk->capacity = capacity;
+            chunk->size = 0;
+            chunk->next = chunkHead_;
+            chunkHead_ =  chunk;
+            return true;
+        }
+        else
+            return false;
+    }
+
+    static const int kDefaultChunkCapacity = 64 * 1024; //!< Default chunk capacity.
+
+    //! Chunk header for perpending to each chunk.
+    /*! Chunks are stored as a singly linked list.
+    */
+    struct ChunkHeader {
+        size_t capacity;    //!< Capacity of the chunk in bytes (excluding the header itself).
+        size_t size;        //!< Current size of allocated memory in bytes.
+        ChunkHeader *next;  //!< Next chunk in the linked list.
+    };
+
+    ChunkHeader *chunkHead_;    //!< Head of the chunk linked-list. Only the head chunk serves allocation.
+    size_t chunk_capacity_;     //!< The minimum capacity of chunk when they are allocated.
+    void *userBuffer_;          //!< User supplied buffer.
+    BaseAllocator* baseAllocator_;  //!< base allocator for allocating memory chunks.
+    BaseAllocator* ownBaseAllocator_;   //!< base allocator created by this object.
+};
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_ENCODINGS_H_