no longer need to pass the size to rapidjson

1 files changed, 88 insertions, 29 deletions

diff --git a/external/rapidjson/internal/stack.h b/external/rapidjson/internal/stack.h
index d4d3c92de..dcc975728 100644
--- a/external/rapidjson/internal/stack.h
+++ b/external/rapidjson/internal/stack.h
@@ -1,27 +1,24 @@
-// Copyright (C) 2011 Milo Yip

+// 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.

 //

-// Permission is hereby granted, free of charge, to any person obtaining a copy

-// of this software and associated documentation files (the "Software"), to deal

-// in the Software without restriction, including without limitation the rights

-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

-// copies of the Software, and to permit persons to whom the Software is

-// furnished to do so, subject to the following conditions:

+// 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

 //

-// The above copyright notice and this permission notice shall be included in

-// all copies or substantial portions of the Software.

+// http://opensource.org/licenses/MIT

 //

-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

-// THE SOFTWARE.

+// 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_INTERNAL_STACK_H_

 #define RAPIDJSON_INTERNAL_STACK_H_

 

-namespace rapidjson {

+#include "../rapidjson.h"

+#include "swap.h"

+

+RAPIDJSON_NAMESPACE_BEGIN

 namespace internal {

 

 ///////////////////////////////////////////////////////////////////////////////

@@ -35,15 +32,63 @@ class Stack {
 public:

     // Optimization note: Do not allocate memory for stack_ in constructor.

     // Do it lazily when first Push() -> Expand() -> Resize().

-    Stack(Allocator* allocator, size_t stackCapacity) : allocator_(allocator), ownAllocator(0), stack_(0), stackTop_(0), stackEnd_(0), initialCapacity_(stackCapacity) {

+    Stack(Allocator* allocator, size_t stackCapacity) : allocator_(allocator), ownAllocator_(0), stack_(0), stackTop_(0), stackEnd_(0), initialCapacity_(stackCapacity) {

         RAPIDJSON_ASSERT(stackCapacity > 0);

-        if (!allocator_)

-            ownAllocator = allocator_ = new Allocator();

     }

 

+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS

+    Stack(Stack&& rhs)

+        : allocator_(rhs.allocator_),

+          ownAllocator_(rhs.ownAllocator_),

+          stack_(rhs.stack_),

+          stackTop_(rhs.stackTop_),

+          stackEnd_(rhs.stackEnd_),

+          initialCapacity_(rhs.initialCapacity_)

+    {

+        rhs.allocator_ = 0;

+        rhs.ownAllocator_ = 0;

+        rhs.stack_ = 0;

+        rhs.stackTop_ = 0;

+        rhs.stackEnd_ = 0;

+        rhs.initialCapacity_ = 0;

+    }

+#endif

+

     ~Stack() {

-        Allocator::Free(stack_);

-        delete ownAllocator; // Only delete if it is owned by the stack

+        Destroy();

+    }

+

+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS

+    Stack& operator=(Stack&& rhs) {

+        if (&rhs != this)

+        {

+            Destroy();

+

+            allocator_ = rhs.allocator_;

+            ownAllocator_ = rhs.ownAllocator_;

+            stack_ = rhs.stack_;

+            stackTop_ = rhs.stackTop_;

+            stackEnd_ = rhs.stackEnd_;

+            initialCapacity_ = rhs.initialCapacity_;

+

+            rhs.allocator_ = 0;

+            rhs.ownAllocator_ = 0;

+            rhs.stack_ = 0;

+            rhs.stackTop_ = 0;

+            rhs.stackEnd_ = 0;

+            rhs.initialCapacity_ = 0;

+        }

+        return *this;

+    }

+#endif

+

+    void Swap(Stack& rhs) RAPIDJSON_NOEXCEPT {

+        internal::Swap(allocator_, rhs.allocator_);

+        internal::Swap(ownAllocator_, rhs.ownAllocator_);

+        internal::Swap(stack_, rhs.stack_);

+        internal::Swap(stackTop_, rhs.stackTop_);

+        internal::Swap(stackEnd_, rhs.stackEnd_);

+        internal::Swap(initialCapacity_, rhs.initialCapacity_);

     }

 

     void Clear() { stackTop_ = stack_; }

@@ -87,9 +132,16 @@ public:
     }

 

     template<typename T>

-    T* Bottom() { return (T*)stack_; }

+    T* Bottom() { return reinterpret_cast<T*>(stack_); }

+

+    bool HasAllocator() const {

+        return allocator_ != 0;

+    }

 

-    Allocator& GetAllocator() { return *allocator_; }

+    Allocator& GetAllocator() {

+        RAPIDJSON_ASSERT(allocator_);

+        return *allocator_;

+    }

     bool Empty() const { return stackTop_ == stack_; }

     size_t GetSize() const { return static_cast<size_t>(stackTop_ - stack_); }

     size_t GetCapacity() const { return static_cast<size_t>(stackEnd_ - stack_); }

@@ -99,9 +151,11 @@ private:
     void Expand(size_t count) {

         // Only expand the capacity if the current stack exists. Otherwise just create a stack with initial capacity.

         size_t newCapacity;

-        if (stack_ == 0)

+        if (stack_ == 0) {

+            if (!allocator_)

+                ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator());

             newCapacity = initialCapacity_;

-        else {

+        } else {

             newCapacity = GetCapacity();

             newCapacity += (newCapacity + 1) / 2;

         }

@@ -114,17 +168,22 @@ private:
 

     void Resize(size_t newCapacity) {

         const size_t size = GetSize();  // Backup the current size

-        stack_ = (char*)allocator_->Realloc(stack_, GetCapacity(), newCapacity);

+        stack_ = static_cast<char*>(allocator_->Realloc(stack_, GetCapacity(), newCapacity));

         stackTop_ = stack_ + size;

         stackEnd_ = stack_ + newCapacity;

     }

 

+    void Destroy() {

+        Allocator::Free(stack_);

+        RAPIDJSON_DELETE(ownAllocator_); // Only delete if it is owned by the stack

+    }

+

     // Prohibit copy constructor & assignment operator.

     Stack(const Stack&);

     Stack& operator=(const Stack&);

 

     Allocator* allocator_;

-    Allocator* ownAllocator;

+    Allocator* ownAllocator_;

     char *stack_;

     char *stackTop_;

     char *stackEnd_;

@@ -132,6 +191,6 @@ private:
 };

 

 } // namespace internal

-} // namespace rapidjson

+RAPIDJSON_NAMESPACE_END

 

 #endif // RAPIDJSON_STACK_H_