commit d3c6cf5c0ace70c423d0fc9e279be5e5e576b4ce
Author: robofish <1683502971@qq.com>
Date: Mon Jul 7 02:34:34 2025 +0800
RC2025启动！
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..26c84c8
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,65 @@
+# ---> C++
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+# ---> ROS2
+install/
+log/
+build/
+
+# Ignore generated docs
+*.dox
+*.wikidoc
+
+# eclipse stuff
+.project
+.cproject
+
+# qcreator stuff
+CMakeLists.txt.user
+
+srv/_*.py
+*.pcd
+*.pyc
+qtcreator-*
+*.user
+
+*~
+
+# Emacs
+.#*
+
+# Colcon custom files
+COLCON_IGNORE
+AMENT_IGNORE
+
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..e69de29
diff --git a/build.sh b/build.sh
new file mode 100644
index 0000000..e2c47a5
--- /dev/null
+++ b/build.sh
@@ -0,0 +1 @@
+colcon build
diff --git a/nav.sh b/nav.sh
new file mode 100644
index 0000000..08c20a1
--- /dev/null
+++ b/nav.sh
@@ -0,0 +1,19 @@
+source install/setup.bash
+
+commands=(
+ "/bin/python3 /home/robofish/RC2025/src/rm_driver/rm_serial_driver/script/pub_aim.py"
+ "ros2 launch rm_nav_bringup bringup_real.launch.py \
+ world:=RC2025 \
+ mode:=nav \
+ lio:=fastlio \
+ localization:=icp \
+ lio_rviz:=false \
+ nav_rviz:=true"
+ "ros2 launch rm_simpal_move simple_move.launch.py"
+ "ros2 topic pub /move_goal rm_msgs/msg/MoveGoal '{x: 0.56, y: 3.960, angle: 0.0, max_speed: 10.0, tolerance: 0.1, rotor: false}' --once"
+)
+
+for cmd in "${commands[@]}"; do
+ gnome-terminal -- bash -c "source install/setup.bash; $cmd; exec bash"
+ sleep 0.5
+done
\ No newline at end of file
diff --git a/src/rm_driver/livox_ros_driver2/.gitignore b/src/rm_driver/livox_ros_driver2/.gitignore
new file mode 100644
index 0000000..429bd72
--- /dev/null
+++ b/src/rm_driver/livox_ros_driver2/.gitignore
@@ -0,0 +1,10 @@
+devel/
+build/
+install/
+log/
+
+.vscode/
+__pycache__/
+.catkin_workspace
+*.gv
+*.pdf
\ No newline at end of file
diff --git a/src/rm_driver/livox_ros_driver2/LICENSE b/src/rm_driver/livox_ros_driver2/LICENSE
new file mode 100644
index 0000000..180f9d2
--- /dev/null
+++ b/src/rm_driver/livox_ros_driver2/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 ziknagXie
+
+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:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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.
diff --git a/src/rm_driver/livox_ros_driver2/README.md b/src/rm_driver/livox_ros_driver2/README.md
new file mode 100644
index 0000000..d93cfe3
--- /dev/null
+++ b/src/rm_driver/livox_ros_driver2/README.md
@@ -0,0 +1,329 @@
+# Livox ROS Driver 2
+
+Livox ROS Driver 2 is the 2nd-generation driver package used to connect LiDAR products produced by Livox, applicable for ROS (noetic recommended) and ROS2 (foxy or humble recommended).
+
+## ATTENTION
+
+本仓库为深圳北理莫斯科大学北极熊战队内部修改版，非原版 livox_ros_driver2 。
+
+相较于原版，修改了消息发布机制和 ```MID360_config.json``` 的 ip
+
+```ros2 launch msg_MID360_launch.py``` 时会同时发布 ```CustomMsg``` 和 ```PointCloud2``` 两种类型消息。
+
+ **Topic name** | **Type** | **Note**
+:------------------------:|:-------------------------------:|:--------------:
+ /livox/lidar | livox_ros_driver2/msg/CustomMsg | mid360 自定义消息类型
+ /livox/lidar/pointcloud | sensor_msgs/msg/PointCloud2 | ROS2 点云消息格式
+ /livox/imu | sensor_msgs/msg/Imu | mid360 机内 imu
+
+## 1. Preparation
+
+### 1.1 OS requirements
+
+ * Ubuntu 22.04 for ROS2 Humble;
+
+ **Tips:**
+
+ Colcon is a build tool used in ROS2.
+
+ How to install colcon: [Colcon installation instructions](https://docs.ros.org/en/foxy/Tutorials/Beginner-Client-Libraries/Colcon-Tutorial.html)
+
+### 1.2 Install ROS2 Humble
+
+For ROS2 Humble installation, please refer to:
+[ROS Humble installation instructions](https://docs.ros.org/en/humble/Installation/Ubuntu-Install-Debians.html)
+
+Desktop-Full installation is recommend.
+
+## 2. Build & Run Livox ROS Driver 2
+
+### 2.1 Clone Livox ROS Driver 2 source code:
+
+```shell
+git clone https://gitee.com/SMBU-POLARBEAR/livox_ros_driver2_humble.git
+```
+
+ **Note :**
+
+ Be sure to clone the source code in a '[work_space]/src/' folder (as shown above), otherwise compilation errors will occur due to the compilation tool restriction.
+
+### 2.2 Build & install the Livox-SDK2
+
+ **Note :**
+
+ Please follow the guidance of installation in the [Livox-SDK2/README.md](https://github.com/Livox-SDK/Livox-SDK2/blob/master/README.md)
+
+### 2.3 Build the Livox ROS Driver 2:
+
+### For ROS2 Humble:
+```shell
+colcon build --symlink-install
+```
+
+### 2.4 Run Livox ROS Driver 2:
+
+```shell
+source install/setup.sh
+ros2 launch livox_ros_driver2 [launch file]
+```
+
+in which,
+
+* **[launch file]** : is the ROS2 launch file you want to use; the 'launch_ROS2' folder contains several launch samples for your reference.
+
+A rviz launch example for HAP LiDAR would be:
+
+```shell
+ros2 launch livox_ros_driver2 rviz_HAP_launch.py
+```
+
+## 3. Launch file and livox_ros_driver2 internal parameter configuration instructions
+
+### 3.1 Launch file configuration instructions
+
+Launch files of ROS are in the "ws_livox/src/livox_ros_driver2/launch_ROS1" directory and launch files of ROS2 are in the "ws_livox/src/livox_ros_driver2/launch_ROS2" directory. Different launch files have different configuration parameter values and are used in different scenarios:
+
+| launch file name | Description |
+| ------------------------- | ------------------------------------------------------------ |
+| rviz_HAP.launch | Connect to HAP LiDAR device
Publish pointcloud2 format data
Autoload rviz |
+| msg_HAP.launch | Connect to HAP LiDAR device
Publish livox customized pointcloud data|
+| rviz_MID360.launch | Connect to MID360 LiDAR device
Publish pointcloud2 format data
Autoload rviz|
+| msg_MID360.launch | Connect to MID360 LiDAR device
Publish livox customized pointcloud data |
+| rviz_mixed.launch | Connect to HAP and MID360 LiDAR device
Publish pointcloud2 format data
Autoload rviz|
+| msg_mixed.launch | Connect to HAP and MID360 LiDAR device
Publish livox customized pointcloud data |
+
+### 3.2 Livox ros driver 2 internal main parameter configuration instructions
+
+All internal parameters of Livox_ros_driver2 are in the launch file. Below are detailed descriptions of the three commonly used parameters :
+
+| Parameter | Detailed description | Default |
+| ------------ | ------------------------------------------------------------ | ------- |
+| publish_freq | Set the frequency of point cloud publish
Floating-point data type, recommended values 5.0, 10.0, 20.0, 50.0, etc. The maximum publish frequency is 100.0 Hz.| 10.0 |
+| multi_topic | If the LiDAR device has an independent topic to publish pointcloud data
0 -- All LiDAR devices use the same topic to publish pointcloud data
1 -- Each LiDAR device has its own topic to publish point cloud data | 0 |
+| xfer_format | Set pointcloud format
0 -- Livox pointcloud2(PointXYZRTLT) pointcloud format
1 -- Livox customized pointcloud format
2 -- Standard pointcloud2 (pcl :: PointXYZI) pointcloud format in the PCL library (just for ROS) | 0 |
+
+ **Note :**
+
+ Other parameters not mentioned in this table are not suggested to be changed unless fully understood.
+
+ ***Livox_ros_driver2 pointcloud data detailed description :***
+
+1. Livox pointcloud2 (PointXYZRTLT) point cloud format, as follows :
+
+```c
+float32 x # X axis, unit:m
+float32 y # Y axis, unit:m
+float32 z # Z axis, unit:m
+float32 intensity # the value is reflectivity, 0.0~255.0
+uint8 tag # livox tag
+uint8 line # laser number in lidar
+float64 timestamp # Timestamp of point
+```
+ **Note :**
+
+ The number of points in the frame may be different, but each point provides a timestamp.
+
+2. Livox customized data package format, as follows :
+
+```c
+std_msgs/Header header # ROS standard message header
+uint64 timebase # The time of first point
+uint32 point_num # Total number of pointclouds
+uint8 lidar_id # Lidar device id number
+uint8[3] rsvd # Reserved use
+CustomPoint[] points # Pointcloud data
+```
+
+ Customized Point Cloud (CustomPoint) format in the above customized data package :
+
+```c
+uint32 offset_time # offset time relative to the base time
+float32 x # X axis, unit:m
+float32 y # Y axis, unit:m
+float32 z # Z axis, unit:m
+uint8 reflectivity # reflectivity, 0~255
+uint8 tag # livox tag
+uint8 line # laser number in lidar
+```
+
+3. The standard pointcloud2 (pcl :: PointXYZI) format in the PCL library (only ROS can publish):
+
+ Please refer to the pcl :: PointXYZI data structure in the point_types.hpp file of the PCL library.
+
+## 4. LiDAR config
+
+LiDAR Configurations (such as ip, port, data type... etc.) can be set via a json-style config file. Config files for single HAP, Mid360 and mixed-LiDARs are in the "config" folder. The parameter naming *'user_config_path'* in launch files indicates such json file path.
+
+1. Follow is a configuration example for HAP LiDAR (located in config/HAP_config.json):
+
+```json
+{
+ "lidar_summary_info" : {
+ "lidar_type": 8 # protocol type index, please don't revise this value
+ },
+ "HAP": {
+ "device_type" : "HAP",
+ "lidar_ipaddr": "",
+ "lidar_net_info" : {
+ "cmd_data_port": 56000, # command port
+ "push_msg_port": 0,
+ "point_data_port": 57000,
+ "imu_data_port": 58000,
+ "log_data_port": 59000
+ },
+ "host_net_info" : {
+ "cmd_data_ip" : "192.168.1.5", # host ip (it can be revised)
+ "cmd_data_port": 56000,
+ "push_msg_ip": "",
+ "push_msg_port": 0,
+ "point_data_ip": "192.168.1.5", # host ip
+ "point_data_port": 57000,
+ "imu_data_ip" : "192.168.1.5", # host ip
+ "imu_data_port": 58000,
+ "log_data_ip" : "",
+ "log_data_port": 59000
+ }
+ },
+ "lidar_configs" : [
+ {
+ "ip" : "192.168.1.100", # ip of the LiDAR you want to config
+ "pcl_data_type" : 1,
+ "pattern_mode" : 0,
+ "blind_spot_set" : 50,
+ "extrinsic_parameter" : {
+ "roll": 0.0,
+ "pitch": 0.0,
+ "yaw": 0.0,
+ "x": 0,
+ "y": 0,
+ "z": 0
+ }
+ }
+ ]
+}
+```
+
+The parameter attributes in the above json file are described in the following table :
+
+**LiDAR configuration parameter**
+| Parameter | Type | Description | Default |
+| :------------------------- | ------- | ------------------------------------------------------------ | --------------- |
+| ip | String | Ip of the LiDAR you want to config | 192.168.1.100 |
+| pcl_data_type | Int | Choose the resolution of the point cloud data to send
1 -- Cartesian coordinate data (32 bits)
2 -- Cartesian coordinate data (16 bits)
3 --Spherical coordinate data| 1 |
+| pattern_mode | Int | Space scan pattern
0 -- non-repeating scanning pattern mode
1 -- repeating scanning pattern mode
2 -- repeating scanning pattern mode (low scanning rate) | 0 |
+| blind_spot_set (Only for HAP LiDAR) | Int | Set blind spot
Range from 50 cm to 200 cm | 50 |
+| extrinsic_parameter | | Set extrinsic parameter
The data types of "roll" "picth" "yaw" are float
The data types of "x" "y" "z" are int
|
+
+For more infomation about the HAP config, please refer to:
+[HAP Config File Description](https://github.com/Livox-SDK/Livox-SDK2/wiki/hap-config-file-description)
+
+2. When connecting multiple LiDARs, add objects corresponding to different LiDARs to the "lidar_configs" array. Examples of mixed-LiDARs config file contents are as follows :
+
+```json
+{
+ "lidar_summary_info" : {
+ "lidar_type": 8 # protocol type index, please don't revise this value
+ },
+ "HAP": {
+ "lidar_net_info" : { # HAP ports, please don't revise these values
+ "cmd_data_port": 56000, # HAP command port
+ "push_msg_port": 0,
+ "point_data_port": 57000,
+ "imu_data_port": 58000,
+ "log_data_port": 59000
+ },
+ "host_net_info" : {
+ "cmd_data_ip" : "192.168.1.5", # host ip
+ "cmd_data_port": 56000,
+ "push_msg_ip": "",
+ "push_msg_port": 0,
+ "point_data_ip": "192.168.1.5", # host ip
+ "point_data_port": 57000,
+ "imu_data_ip" : "192.168.1.5", # host ip
+ "imu_data_port": 58000,
+ "log_data_ip" : "",
+ "log_data_port": 59000
+ }
+ },
+ "MID360": {
+ "lidar_net_info" : { # Mid360 ports, please don't revise these values
+ "cmd_data_port": 56100, # Mid360 command port
+ "push_msg_port": 56200,
+ "point_data_port": 56300,
+ "imu_data_port": 56400,
+ "log_data_port": 56500
+ },
+ "host_net_info" : {
+ "cmd_data_ip" : "192.168.1.5", # host ip
+ "cmd_data_port": 56101,
+ "push_msg_ip": "192.168.1.5", # host ip
+ "push_msg_port": 56201,
+ "point_data_ip": "192.168.1.5", # host ip
+ "point_data_port": 56301,
+ "imu_data_ip" : "192.168.1.5", # host ip
+ "imu_data_port": 56401,
+ "log_data_ip" : "",
+ "log_data_port": 56501
+ }
+ },
+ "lidar_configs" : [
+ {
+ "ip" : "192.168.1.100", # ip of the HAP you want to config
+ "pcl_data_type" : 1,
+ "pattern_mode" : 0,
+ "blind_spot_set" : 50,
+ "extrinsic_parameter" : {
+ "roll": 0.0,
+ "pitch": 0.0,
+ "yaw": 0.0,
+ "x": 0,
+ "y": 0,
+ "z": 0
+ }
+ },
+ {
+ "ip" : "192.168.1.12", # ip of the Mid360 you want to config
+ "pcl_data_type" : 1,
+ "pattern_mode" : 0,
+ "extrinsic_parameter" : {
+ "roll": 0.0,
+ "pitch": 0.0,
+ "yaw": 0.0,
+ "x": 0,
+ "y": 0,
+ "z": 0
+ }
+ }
+ ]
+}
+```
+
+## 5. Supported LiDAR list
+
+* HAP
+* Mid360
+* (more types are comming soon...)
+
+## 6. FAQ
+
+### 6.1 launch with "livox_lidar_rviz_HAP.launch" but no point cloud display on the grid?
+
+Please check the "Global Options - Fixed Frame" field in the RViz "Display" pannel. Set the field value to "livox_frame" and check the "PointCloud2" option in the pannel.
+
+### 6.2 launch with command "ros2 launch livox_lidar_rviz_HAP_launch.py" but cannot open shared object file "liblivox_sdk_shared.so" ?
+
+Please add '/usr/local/lib' to the env LD_LIBRARY_PATH.
+
+* If you want to add to current terminal:
+
+ ```shell
+ export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:/usr/local/lib
+ ```
+
+* If you want to add to current user:
+
+ ```shell
+ vim ~/.bashrc
+ export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:/usr/local/lib
+ source ~/.bashrc
+ ```
diff --git a/src/rm_driver/livox_ros_driver2/src/3rdparty/rapidjson/allocators.h b/src/rm_driver/livox_ros_driver2/src/3rdparty/rapidjson/allocators.h
new file mode 100644
index 0000000..03010d5
--- /dev/null
+++ b/src/rm_driver/livox_ros_driver2/src/3rdparty/rapidjson/allocators.h
@@ -0,0 +1,308 @@
+// 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
+*/
+
+/*! \def RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY
+ \ingroup RAPIDJSON_CONFIG
+ \brief User-defined kDefaultChunkCapacity definition.
+
+ User can define this as any \c size that is a power of 2.
+*/
+
+#ifndef RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY
+#define RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY (64 * 1024)
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// 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
+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(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(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(chunkHead_) +
+ RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + chunkHead_->size -
+ originalSize) {
+ size_t increment = static_cast(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(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 =
+ RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY; //!< 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_
diff --git a/src/rm_driver/livox_ros_driver2/src/3rdparty/rapidjson/cursorstreamwrapper.h b/src/rm_driver/livox_ros_driver2/src/3rdparty/rapidjson/cursorstreamwrapper.h
new file mode 100644
index 0000000..045ddb8
--- /dev/null
+++ b/src/rm_driver/livox_ros_driver2/src/3rdparty/rapidjson/cursorstreamwrapper.h
@@ -0,0 +1,81 @@
+// 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_CURSORSTREAMWRAPPER_H_
+#define RAPIDJSON_CURSORSTREAMWRAPPER_H_
+
+#include "stream.h"
+
+#if defined(__GNUC__)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4702) // unreachable code
+RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Cursor stream wrapper for counting line and column number if error exists.
+/*!
+ \tparam InputStream Any stream that implements Stream Concept
+*/
+template >
+class CursorStreamWrapper : public GenericStreamWrapper {
+ public:
+ typedef typename Encoding::Ch Ch;
+
+ CursorStreamWrapper(InputStream &is)
+ : GenericStreamWrapper(is), line_(1), col_(0) {}
+
+ // counting line and column number
+ Ch Take() {
+ Ch ch = this->is_.Take();
+ if (ch == '\n') {
+ line_++;
+ col_ = 0;
+ } else {
+ col_++;
+ }
+ return ch;
+ }
+
+ //! Get the error line number, if error exists.
+ size_t GetLine() const { return line_; }
+ //! Get the error column number, if error exists.
+ size_t GetColumn() const { return col_; }
+
+ private:
+ size_t line_; //!< Current Line
+ size_t col_; //!< Current Column
+};
+
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+RAPIDJSON_DIAG_POP
+#endif
+
+#if defined(__GNUC__)
+RAPIDJSON_DIAG_POP
+#endif
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_CURSORSTREAMWRAPPER_H_
diff --git a/src/rm_driver/livox_ros_driver2/src/3rdparty/rapidjson/document.h b/src/rm_driver/livox_ros_driver2/src/3rdparty/rapidjson/document.h
new file mode 100644
index 0000000..27addb7
--- /dev/null
+++ b/src/rm_driver/livox_ros_driver2/src/3rdparty/rapidjson/document.h
@@ -0,0 +1,3309 @@
+// 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_DOCUMENT_H_
+#define RAPIDJSON_DOCUMENT_H_
+
+/*! \file document.h */
+
+#include
+#include // placement new
+#include "encodedstream.h"
+#include "internal/meta.h"
+#include "internal/strfunc.h"
+#include "memorystream.h"
+#include "reader.h"
+
+RAPIDJSON_DIAG_PUSH
+#ifdef __clang__
+RAPIDJSON_DIAG_OFF(padded)
+RAPIDJSON_DIAG_OFF(switch - enum)
+RAPIDJSON_DIAG_OFF(c++ 98 - compat)
+#elif defined(_MSC_VER)
+RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
+RAPIDJSON_DIAG_OFF(
+ 4244) // conversion from kXxxFlags to 'uint16_t', possible loss of data
+#endif
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_OFF(effc++)
+#endif // __GNUC__
+
+#ifndef RAPIDJSON_NOMEMBERITERATORCLASS
+#include // std::random_access_iterator_tag
+#endif
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+#include // std::move
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+// Forward declaration.
+template
+class GenericValue;
+
+template
+class GenericDocument;
+
+//! Name-value pair in a JSON object value.
+/*!
+ This class was internal to GenericValue. It used to be a inner struct.
+ But a compiler (IBM XL C/C++ for AIX) have reported to have problem with
+ that so it moved as a namespace scope struct.
+ https://code.google.com/p/rapidjson/issues/detail?id=64
+*/
+template
+class GenericMember {
+ public:
+ GenericValue
+ name; //!< name of member (must be a string)
+ GenericValue value; //!< value of member.
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+ //! Move constructor in C++11
+ GenericMember(GenericMember &&rhs) RAPIDJSON_NOEXCEPT
+ : name(std::move(rhs.name)),
+ value(std::move(rhs.value)) {}
+
+ //! Move assignment in C++11
+ GenericMember &operator=(GenericMember &&rhs) RAPIDJSON_NOEXCEPT {
+ return *this = static_cast(rhs);
+ }
+#endif
+
+ //! Assignment with move semantics.
+ /*! \param rhs Source of the assignment. Its name and value will become a null
+ * value after assignment.
+ */
+ GenericMember &operator=(GenericMember &rhs) RAPIDJSON_NOEXCEPT {
+ if (RAPIDJSON_LIKELY(this != &rhs)) {
+ name = rhs.name;
+ value = rhs.value;
+ }
+ return *this;
+ }
+
+ // swap() for std::sort() and other potential use in STL.
+ friend inline void swap(GenericMember &a,
+ GenericMember &b) RAPIDJSON_NOEXCEPT {
+ a.name.Swap(b.name);
+ a.value.Swap(b.value);
+ }
+
+ private:
+ //! Copy constructor is not permitted.
+ GenericMember(const GenericMember &rhs);
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericMemberIterator
+
+#ifndef RAPIDJSON_NOMEMBERITERATORCLASS
+
+//! (Constant) member iterator for a JSON object value
+/*!
+ \tparam Const Is this a constant iterator?
+ \tparam Encoding Encoding of the value. (Even non-string values need to
+ have the same encoding in a document) \tparam Allocator Allocator type for
+ allocating memory of object, array and string.
+
+ This class implements a Random Access Iterator for GenericMember elements
+ of a GenericValue, see ISO/IEC 14882:2003(E) C++ standard, 24.1
+ [lib.iterator.requirements].
+
+ \note This iterator implementation is mainly intended to avoid implicit
+ conversions from iterator values to \c NULL,
+ e.g. from GenericValue::FindMember.
+
+ \note Define \c RAPIDJSON_NOMEMBERITERATORCLASS to fall back to a
+ pointer-based implementation, if your platform doesn't provide
+ the C++ header.
+
+ \see GenericMember, GenericValue::MemberIterator,
+ GenericValue::ConstMemberIterator
+ */
+template
+class GenericMemberIterator {
+ friend class GenericValue;
+ template
+ friend class GenericMemberIterator;
+
+ typedef GenericMember PlainType;
+ typedef typename internal::MaybeAddConst::Type ValueType;
+
+ public:
+ //! Iterator type itself
+ typedef GenericMemberIterator Iterator;
+ //! Constant iterator type
+ typedef GenericMemberIterator ConstIterator;
+ //! Non-constant iterator type
+ typedef GenericMemberIterator NonConstIterator;
+
+ /** \name std::iterator_traits support */
+ //@{
+ typedef ValueType value_type;
+ typedef ValueType *pointer;
+ typedef ValueType &reference;
+ typedef std::ptrdiff_t difference_type;
+ typedef std::random_access_iterator_tag iterator_category;
+ //@}
+
+ //! Pointer to (const) GenericMember
+ typedef pointer Pointer;
+ //! Reference to (const) GenericMember
+ typedef reference Reference;
+ //! Signed integer type (e.g. \c ptrdiff_t)
+ typedef difference_type DifferenceType;
+
+ //! Default constructor (singular value)
+ /*! Creates an iterator pointing to no element.
+ \note All operations, except for comparisons, are undefined on such
+ values.
+ */
+ GenericMemberIterator() : ptr_() {}
+
+ //! Iterator conversions to more const
+ /*!
+ \param it (Non-const) iterator to copy from
+
+ Allows the creation of an iterator from another GenericMemberIterator
+ that is "less const". Especially, creating a non-constant iterator
+ from a constant iterator are disabled:
+ \li const -> non-const (not ok)
+ \li const -> const (ok)
+ \li non-const -> const (ok)
+ \li non-const -> non-const (ok)
+
+ \note If the \c Const template parameter is already \c false, this
+ constructor effectively defines a regular copy-constructor.
+ Otherwise, the copy constructor is implicitly defined.
+ */
+ GenericMemberIterator(const NonConstIterator &it) : ptr_(it.ptr_) {}
+ Iterator &operator=(const NonConstIterator &it) {
+ ptr_ = it.ptr_;
+ return *this;
+ }
+
+ //! @name stepping
+ //@{
+ Iterator &operator++() {
+ ++ptr_;
+ return *this;
+ }
+ Iterator &operator--() {
+ --ptr_;
+ return *this;
+ }
+ Iterator operator++(int) {
+ Iterator old(*this);
+ ++ptr_;
+ return old;
+ }
+ Iterator operator--(int) {
+ Iterator old(*this);
+ --ptr_;
+ return old;
+ }
+ //@}
+
+ //! @name increment/decrement
+ //@{
+ Iterator operator+(DifferenceType n) const { return Iterator(ptr_ + n); }
+ Iterator operator-(DifferenceType n) const { return Iterator(ptr_ - n); }
+
+ Iterator &operator+=(DifferenceType n) {
+ ptr_ += n;
+ return *this;
+ }
+ Iterator &operator-=(DifferenceType n) {
+ ptr_ -= n;
+ return *this;
+ }
+ //@}
+
+ //! @name relations
+ //@{
+ bool operator==(ConstIterator that) const { return ptr_ == that.ptr_; }
+ bool operator!=(ConstIterator that) const { return ptr_ != that.ptr_; }
+ bool operator<=(ConstIterator that) const { return ptr_ <= that.ptr_; }
+ bool operator>=(ConstIterator that) const { return ptr_ >= that.ptr_; }
+ bool operator<(ConstIterator that) const { return ptr_ < that.ptr_; }
+ bool operator>(ConstIterator that) const { return ptr_ > that.ptr_; }
+ //@}
+
+ //! @name dereference
+ //@{
+ Reference operator*() const { return *ptr_; }
+ Pointer operator->() const { return ptr_; }
+ Reference operator[](DifferenceType n) const { return ptr_[n]; }
+ //@}
+
+ //! Distance
+ DifferenceType operator-(ConstIterator that) const {
+ return ptr_ - that.ptr_;
+ }
+
+ private:
+ //! Internal constructor from plain pointer
+ explicit GenericMemberIterator(Pointer p) : ptr_(p) {}
+
+ Pointer ptr_; //!< raw pointer
+};
+
+#else // RAPIDJSON_NOMEMBERITERATORCLASS
+
+// class-based member iterator implementation disabled, use plain pointers
+
+template
+class GenericMemberIterator;
+
+//! non-const GenericMemberIterator
+template
+class GenericMemberIterator {
+ //! use plain pointer as iterator type
+ typedef GenericMember *Iterator;
+};
+//! const GenericMemberIterator
+template
+class GenericMemberIterator {
+ //! use plain const pointer as iterator type
+ typedef const GenericMember *Iterator;
+};
+
+#endif // RAPIDJSON_NOMEMBERITERATORCLASS
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericStringRef
+
+//! Reference to a constant string (not taking a copy)
+/*!
+ \tparam CharType character type of the string
+
+ This helper class is used to automatically infer constant string
+ references for string literals, especially from \c const \b (!)
+ character arrays.
+
+ The main use is for creating JSON string values without copying the
+ source string via an \ref Allocator. This requires that the referenced
+ string pointers have a sufficient lifetime, which exceeds the lifetime
+ of the associated GenericValue.
+
+ \b Example
+ \code
+ Value v("foo"); // ok, no need to copy & calculate length
+ const char foo[] = "foo";
+ v.SetString(foo); // ok
+
+ const char* bar = foo;
+ // Value x(bar); // not ok, can't rely on bar's lifetime
+ Value x(StringRef(bar)); // lifetime explicitly guaranteed by user
+ Value y(StringRef(bar, 3)); // ok, explicitly pass length
+ \endcode
+
+ \see StringRef, GenericValue::SetString
+*/
+template
+struct GenericStringRef {
+ typedef CharType Ch; //!< character type of the string
+
+//! Create string reference from \c const character array
+#ifndef __clang__ // -Wdocumentation
+ /*!
+ This constructor implicitly creates a constant string reference from
+ a \c const character array. It has better performance than
+ \ref StringRef(const CharType*) by inferring the string \ref length
+ from the array length, and also supports strings containing null
+ characters.
+
+ \tparam N length of the string, automatically inferred
+
+ \param str Constant character array, lifetime assumed to be longer
+ than the use of the string in e.g. a GenericValue
+
+ \post \ref s == str
+
+ \note Constant complexity.
+ \note There is a hidden, private overload to disallow references to
+ non-const character arrays to be created via this constructor.
+ By this, e.g. function-scope arrays used to be filled via
+ \c snprintf are excluded from consideration.
+ In such cases, the referenced string should be \b copied to the
+ GenericValue instead.
+ */
+#endif
+ template
+ GenericStringRef(const CharType (&str)[N]) RAPIDJSON_NOEXCEPT
+ : s(str),
+ length(N - 1) {}
+
+//! Explicitly create string reference from \c const character pointer
+#ifndef __clang__ // -Wdocumentation
+ /*!
+ This constructor can be used to \b explicitly create a reference to
+ a constant string pointer.
+
+ \see StringRef(const CharType*)
+
+ \param str Constant character pointer, lifetime assumed to be longer
+ than the use of the string in e.g. a GenericValue
+
+ \post \ref s == str
+
+ \note There is a hidden, private overload to disallow references to
+ non-const character arrays to be created via this constructor.
+ By this, e.g. function-scope arrays used to be filled via
+ \c snprintf are excluded from consideration.
+ In such cases, the referenced string should be \b copied to the
+ GenericValue instead.
+ */
+#endif
+ explicit GenericStringRef(const CharType *str)
+ : s(str), length(NotNullStrLen(str)) {}
+
+//! Create constant string reference from pointer and length
+#ifndef __clang__ // -Wdocumentation
+/*! \param str constant string, lifetime assumed to be longer than the use of
+ the string in e.g. a GenericValue \param len length of the string,
+ excluding the trailing NULL terminator
+
+ \post \ref s == str && \ref length == len
+ \note Constant complexity.
+ */
+#endif
+ GenericStringRef(const CharType *str, SizeType len)
+ : s(RAPIDJSON_LIKELY(str) ? str : emptyString), length(len) {
+ RAPIDJSON_ASSERT(str != 0 || len == 0u);
+ }
+
+ GenericStringRef(const GenericStringRef &rhs)
+ : s(rhs.s), length(rhs.length) {}
+
+ //! implicit conversion to plain CharType pointer
+ operator const Ch *() const { return s; }
+
+ const Ch *const s; //!< plain CharType pointer
+ const SizeType length; //!< length of the string (excluding the trailing NULL
+ //!terminator)
+
+ private:
+ SizeType NotNullStrLen(const CharType *str) {
+ RAPIDJSON_ASSERT(str != 0);
+ return internal::StrLen(str);
+ }
+
+ /// Empty string - used when passing in a NULL pointer
+ static const Ch emptyString[];
+
+ //! Disallow construction from non-const array
+ template
+ GenericStringRef(CharType (&str)[N]) /* = delete */;
+ //! Copy assignment operator not permitted - immutable type
+ GenericStringRef &operator=(const GenericStringRef &rhs) /* = delete */;
+};
+
+template
+const CharType GenericStringRef::emptyString[] = {CharType()};
+
+//! Mark a character pointer as constant string
+/*! Mark a plain character pointer as a "string literal". This function
+ can be used to avoid copying a character string to be referenced as a
+ value in a JSON GenericValue object, if the string's lifetime is known
+ to be valid long enough.
+ \tparam CharType Character type of the string
+ \param str Constant string, lifetime assumed to be longer than the use of
+ the string in e.g. a GenericValue \return GenericStringRef string reference
+ object \relatesalso GenericStringRef
+
+ \see GenericValue::GenericValue(StringRefType),
+ GenericValue::operator=(StringRefType),
+ GenericValue::SetString(StringRefType), GenericValue::PushBack(StringRefType,
+ Allocator&), GenericValue::AddMember
+*/
+template
+inline GenericStringRef StringRef(const CharType *str) {
+ return GenericStringRef(str);
+}
+
+//! Mark a character pointer as constant string
+/*! Mark a plain character pointer as a "string literal". This function
+ can be used to avoid copying a character string to be referenced as a
+ value in a JSON GenericValue object, if the string's lifetime is known
+ to be valid long enough.
+
+ This version has better performance with supplied length, and also
+ supports string containing null characters.
+
+ \tparam CharType character type of the string
+ \param str Constant string, lifetime assumed to be longer than the use of
+ the string in e.g. a GenericValue \param length The length of source string.
+ \return GenericStringRef string reference object
+ \relatesalso GenericStringRef
+*/
+template
+inline GenericStringRef StringRef(const CharType *str,
+ size_t length) {
+ return GenericStringRef(str, SizeType(length));
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+//! Mark a string object as constant string
+/*! Mark a string object (e.g. \c std::string) as a "string literal".
+ This function can be used to avoid copying a string to be referenced as a
+ value in a JSON GenericValue object, if the string's lifetime is known
+ to be valid long enough.
+
+ \tparam CharType character type of the string
+ \param str Constant string, lifetime assumed to be longer than the use of
+ the string in e.g. a GenericValue \return GenericStringRef string reference
+ object \relatesalso GenericStringRef \note Requires the definition of the
+ preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING.
+*/
+template
+inline GenericStringRef StringRef(
+ const std::basic_string &str) {
+ return GenericStringRef(str.data(), SizeType(str.size()));
+}
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericValue type traits
+namespace internal {
+
+template
+struct IsGenericValueImpl : FalseType {};
+
+// select candidates according to nested encoding and allocator types
+template
+struct IsGenericValueImpl::Type,
+ typename Void::Type>
+ : IsBaseOf<
+ GenericValue,
+ T>::Type {};
+
+// helper to match arbitrary GenericValue instantiations, including derived
+// classes
+template
+struct IsGenericValue : IsGenericValueImpl::Type {};
+
+} // namespace internal
+
+///////////////////////////////////////////////////////////////////////////////
+// TypeHelper
+
+namespace internal {
+
+template
+struct TypeHelper {};
+
+template
+struct TypeHelper {
+ static bool Is(const ValueType &v) { return v.IsBool(); }
+ static bool Get(const ValueType &v) { return v.GetBool(); }
+ static ValueType &Set(ValueType &v, bool data) { return v.SetBool(data); }
+ static ValueType &Set(ValueType &v, bool data,
+ typename ValueType::AllocatorType &) {
+ return v.SetBool(data);
+ }
+};
+
+template
+struct TypeHelper {
+ static bool Is(const ValueType &v) { return v.IsInt(); }
+ static int Get(const ValueType &v) { return v.GetInt(); }
+ static ValueType &Set(ValueType &v, int data) { return v.SetInt(data); }
+ static ValueType &Set(ValueType &v, int data,
+ typename ValueType::AllocatorType &) {
+ return v.SetInt(data);
+ }
+};
+
+template
+struct TypeHelper {
+ static bool Is(const ValueType &v) { return v.IsUint(); }
+ static unsigned Get(const ValueType &v) { return v.GetUint(); }
+ static ValueType &Set(ValueType &v, unsigned data) { return v.SetUint(data); }
+ static ValueType &Set(ValueType &v, unsigned data,
+ typename ValueType::AllocatorType &) {
+ return v.SetUint(data);
+ }
+};
+
+#ifdef _MSC_VER
+RAPIDJSON_STATIC_ASSERT(sizeof(long) == sizeof(int));
+template
+struct TypeHelper {
+ static bool Is(const ValueType &v) { return v.IsInt(); }
+ static long Get(const ValueType &v) { return v.GetInt(); }
+ static ValueType &Set(ValueType &v, long data) { return v.SetInt(data); }
+ static ValueType &Set(ValueType &v, long data,
+ typename ValueType::AllocatorType &) {
+ return v.SetInt(data);
+ }
+};
+
+RAPIDJSON_STATIC_ASSERT(sizeof(unsigned long) == sizeof(unsigned));
+template
+struct TypeHelper {
+ static bool Is(const ValueType &v) { return v.IsUint(); }
+ static unsigned long Get(const ValueType &v) { return v.GetUint(); }
+ static ValueType &Set(ValueType &v, unsigned long data) {
+ return v.SetUint(data);
+ }
+ static ValueType &Set(ValueType &v, unsigned long data,
+ typename ValueType::AllocatorType &) {
+ return v.SetUint(data);
+ }
+};
+#endif
+
+template
+struct TypeHelper {
+ static bool Is(const ValueType &v) { return v.IsInt64(); }
+ static int64_t Get(const ValueType &v) { return v.GetInt64(); }
+ static ValueType &Set(ValueType &v, int64_t data) { return v.SetInt64(data); }
+ static ValueType &Set(ValueType &v, int64_t data,
+ typename ValueType::AllocatorType &) {
+ return v.SetInt64(data);
+ }
+};
+
+template
+struct TypeHelper {
+ static bool Is(const ValueType &v) { return v.IsUint64(); }
+ static uint64_t Get(const ValueType &v) { return v.GetUint64(); }
+ static ValueType &Set(ValueType &v, uint64_t data) {
+ return v.SetUint64(data);
+ }
+ static ValueType &Set(ValueType &v, uint64_t data,
+ typename ValueType::AllocatorType &) {
+ return v.SetUint64(data);
+ }
+};
+
+template
+struct TypeHelper {
+ static bool Is(const ValueType &v) { return v.IsDouble(); }
+ static double Get(const ValueType &v) { return v.GetDouble(); }
+ static ValueType &Set(ValueType &v, double data) { return v.SetDouble(data); }
+ static ValueType &Set(ValueType &v, double data,
+ typename ValueType::AllocatorType &) {
+ return v.SetDouble(data);
+ }
+};
+
+template
+struct TypeHelper {
+ static bool Is(const ValueType &v) { return v.IsFloat(); }
+ static float Get(const ValueType &v) { return v.GetFloat(); }
+ static ValueType &Set(ValueType &v, float data) { return v.SetFloat(data); }
+ static ValueType &Set(ValueType &v, float data,
+ typename ValueType::AllocatorType &) {
+ return v.SetFloat(data);
+ }
+};
+
+template
+struct TypeHelper {
+ typedef const typename ValueType::Ch *StringType;
+ static bool Is(const ValueType &v) { return v.IsString(); }
+ static StringType Get(const ValueType &v) { return v.GetString(); }
+ static ValueType &Set(ValueType &v, const StringType data) {
+ return v.SetString(typename ValueType::StringRefType(data));
+ }
+ static ValueType &Set(ValueType &v, const StringType data,
+ typename ValueType::AllocatorType &a) {
+ return v.SetString(data, a);
+ }
+};
+
+#if RAPIDJSON_HAS_STDSTRING
+template
+struct TypeHelper> {
+ typedef std::basic_string StringType;
+ static bool Is(const ValueType &v) { return v.IsString(); }
+ static StringType Get(const ValueType &v) {
+ return StringType(v.GetString(), v.GetStringLength());
+ }
+ static ValueType &Set(ValueType &v, const StringType &data,
+ typename ValueType::AllocatorType &a) {
+ return v.SetString(data, a);
+ }
+};
+#endif
+
+template
+struct TypeHelper {
+ typedef typename ValueType::Array ArrayType;
+ static bool Is(const ValueType &v) { return v.IsArray(); }
+ static ArrayType Get(ValueType &v) { return v.GetArray(); }
+ static ValueType &Set(ValueType &v, ArrayType data) { return v = data; }
+ static ValueType &Set(ValueType &v, ArrayType data,
+ typename ValueType::AllocatorType &) {
+ return v = data;
+ }
+};
+
+template
+struct TypeHelper {
+ typedef typename ValueType::ConstArray ArrayType;
+ static bool Is(const ValueType &v) { return v.IsArray(); }
+ static ArrayType Get(const ValueType &v) { return v.GetArray(); }
+};
+
+template
+struct TypeHelper {
+ typedef typename ValueType::Object ObjectType;
+ static bool Is(const ValueType &v) { return v.IsObject(); }
+ static ObjectType Get(ValueType &v) { return v.GetObject(); }
+ static ValueType &Set(ValueType &v, ObjectType data) { return v = data; }
+ static ValueType &Set(ValueType &v, ObjectType data,
+ typename ValueType::AllocatorType &) {
+ return v = data;
+ }
+};
+
+template
+struct TypeHelper {
+ typedef typename ValueType::ConstObject ObjectType;
+ static bool Is(const ValueType &v) { return v.IsObject(); }
+ static ObjectType Get(const ValueType &v) { return v.GetObject(); }
+};
+
+} // namespace internal
+
+// Forward declarations
+template
+class GenericArray;
+template
+class GenericObject;
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericValue
+
+//! Represents a JSON value. Use Value for UTF8 encoding and default allocator.
+/*!
+ A JSON value can be one of 7 types. This class is a variant type supporting
+ these types.
+
+ Use the Value if UTF8 and default allocator
+
+ \tparam Encoding Encoding of the value. (Even non-string values need to
+ have the same encoding in a document) \tparam Allocator Allocator type for
+ allocating memory of object, array and string.
+*/
+template >
+class GenericValue {
+ public:
+ //! Name-value pair in an object.
+ typedef GenericMember Member;
+ typedef Encoding EncodingType; //!< Encoding type from template parameter.
+ typedef Allocator AllocatorType; //!< Allocator type from template parameter.
+ typedef typename Encoding::Ch Ch; //!< Character type derived from Encoding.
+ typedef GenericStringRef
+ StringRefType; //!< Reference to a constant string
+ typedef typename GenericMemberIterator::Iterator
+ MemberIterator; //!< Member iterator for iterating in object.
+ typedef typename GenericMemberIterator::Iterator
+ ConstMemberIterator; //!< Constant member iterator for iterating in
+ //!< object.
+ typedef GenericValue
+ *ValueIterator; //!< Value iterator for iterating in array.
+ typedef const GenericValue
+ *ConstValueIterator; //!< Constant value iterator for iterating in array.
+ typedef GenericValue
+ ValueType; //!< Value type of itself.
+ typedef GenericArray Array;
+ typedef GenericArray ConstArray;
+ typedef GenericObject Object;
+ typedef GenericObject ConstObject;
+
+ //!@name Constructors and destructor.
+ //@{
+
+ //! Default constructor creates a null value.
+ GenericValue() RAPIDJSON_NOEXCEPT : data_() { data_.f.flags = kNullFlag; }
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+ //! Move constructor in C++11
+ GenericValue(GenericValue &&rhs) RAPIDJSON_NOEXCEPT : data_(rhs.data_) {
+ rhs.data_.f.flags = kNullFlag; // give up contents
+ }
+#endif
+
+ private:
+ //! Copy constructor is not permitted.
+ GenericValue(const GenericValue &rhs);
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+ //! Moving from a GenericDocument is not permitted.
+ template
+ GenericValue(GenericDocument &&rhs);
+
+ //! Move assignment from a GenericDocument is not permitted.
+ template
+ GenericValue &operator=(
+ GenericDocument &&rhs);
+#endif
+
+ public:
+ //! Constructor with JSON value type.
+ /*! This creates a Value of specified type with default content.
+ \param type Type of the value.
+ \note Default content for number is zero.
+ */
+ explicit GenericValue(Type type) RAPIDJSON_NOEXCEPT : data_() {
+ static const uint16_t defaultFlags[] = {
+ kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag,
+ kArrayFlag, kShortStringFlag, kNumberAnyFlag};
+ RAPIDJSON_NOEXCEPT_ASSERT(type >= kNullType && type <= kNumberType);
+ data_.f.flags = defaultFlags[type];
+
+ // Use ShortString to store empty string.
+ if (type == kStringType) data_.ss.SetLength(0);
+ }
+
+ //! Explicit copy constructor (with allocator)
+ /*! Creates a copy of a Value by using the given Allocator
+ \tparam SourceAllocator allocator of \c rhs
+ \param rhs Value to copy from (read-only)
+ \param allocator Allocator for allocating copied elements and buffers.
+ Commonly use GenericDocument::GetAllocator(). \param copyConstStrings Force
+ copying of constant strings (e.g. referencing an in-situ buffer) \see
+ CopyFrom()
+ */
+ template
+ GenericValue(const GenericValue &rhs,
+ Allocator &allocator, bool copyConstStrings = false) {
+ switch (rhs.GetType()) {
+ case kObjectType: {
+ SizeType count = rhs.data_.o.size;
+ Member *lm = reinterpret_cast(
+ allocator.Malloc(count * sizeof(Member)));
+ const typename GenericValue::Member *rm =
+ rhs.GetMembersPointer();
+ for (SizeType i = 0; i < count; i++) {
+ new (&lm[i].name)
+ GenericValue(rm[i].name, allocator, copyConstStrings);
+ new (&lm[i].value)
+ GenericValue(rm[i].value, allocator, copyConstStrings);
+ }
+ data_.f.flags = kObjectFlag;
+ data_.o.size = data_.o.capacity = count;
+ SetMembersPointer(lm);
+ } break;
+ case kArrayType: {
+ SizeType count = rhs.data_.a.size;
+ GenericValue *le = reinterpret_cast(
+ allocator.Malloc(count * sizeof(GenericValue)));
+ const GenericValue *re =
+ rhs.GetElementsPointer();
+ for (SizeType i = 0; i < count; i++)
+ new (&le[i]) GenericValue(re[i], allocator, copyConstStrings);
+ data_.f.flags = kArrayFlag;
+ data_.a.size = data_.a.capacity = count;
+ SetElementsPointer(le);
+ } break;
+ case kStringType:
+ if (rhs.data_.f.flags == kConstStringFlag && !copyConstStrings) {
+ data_.f.flags = rhs.data_.f.flags;
+ data_ = *reinterpret_cast(&rhs.data_);
+ } else
+ SetStringRaw(StringRef(rhs.GetString(), rhs.GetStringLength()),
+ allocator);
+ break;
+ default:
+ data_.f.flags = rhs.data_.f.flags;
+ data_ = *reinterpret_cast(&rhs.data_);
+ break;
+ }
+ }
+
+//! Constructor for boolean value.
+/*! \param b Boolean value
+ \note This constructor is limited to \em real boolean values and rejects
+ implicitly converted types like arbitrary pointers. Use an explicit
+ cast to \c bool, if you want to construct a boolean JSON value in such
+ cases.
+ */
+#ifndef RAPIDJSON_DOXYGEN_RUNNING // hide SFINAE from Doxygen
+ template
+ explicit GenericValue(T b, RAPIDJSON_ENABLEIF((internal::IsSame)))
+ RAPIDJSON_NOEXCEPT // See #472
+#else
+ explicit GenericValue(bool b) RAPIDJSON_NOEXCEPT
+#endif
+ : data_() {
+ // safe-guard against failing SFINAE
+ RAPIDJSON_STATIC_ASSERT((internal::IsSame::Value));
+ data_.f.flags = b ? kTrueFlag : kFalseFlag;
+ }
+
+ //! Constructor for int value.
+ explicit GenericValue(int i) RAPIDJSON_NOEXCEPT : data_() {
+ data_.n.i64 = i;
+ data_.f.flags =
+ (i >= 0) ? (kNumberIntFlag | kUintFlag | kUint64Flag) : kNumberIntFlag;
+ }
+
+ //! Constructor for unsigned value.
+ explicit GenericValue(unsigned u) RAPIDJSON_NOEXCEPT : data_() {
+ data_.n.u64 = u;
+ data_.f.flags = (u & 0x80000000)
+ ? kNumberUintFlag
+ : (kNumberUintFlag | kIntFlag | kInt64Flag);
+ }
+
+ //! Constructor for int64_t value.
+ explicit GenericValue(int64_t i64) RAPIDJSON_NOEXCEPT : data_() {
+ data_.n.i64 = i64;
+ data_.f.flags = kNumberInt64Flag;
+ if (i64 >= 0) {
+ data_.f.flags |= kNumberUint64Flag;
+ if (!(static_cast(i64) &
+ RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000)))
+ data_.f.flags |= kUintFlag;
+ if (!(static_cast(i64) &
+ RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
+ data_.f.flags |= kIntFlag;
+ } else if (i64 >= static_cast(
+ RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
+ data_.f.flags |= kIntFlag;
+ }
+
+ //! Constructor for uint64_t value.
+ explicit GenericValue(uint64_t u64) RAPIDJSON_NOEXCEPT : data_() {
+ data_.n.u64 = u64;
+ data_.f.flags = kNumberUint64Flag;
+ if (!(u64 & RAPIDJSON_UINT64_C2(0x80000000, 0x00000000)))
+ data_.f.flags |= kInt64Flag;
+ if (!(u64 & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000)))
+ data_.f.flags |= kUintFlag;
+ if (!(u64 & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
+ data_.f.flags |= kIntFlag;
+ }
+
+ //! Constructor for double value.
+ explicit GenericValue(double d) RAPIDJSON_NOEXCEPT : data_() {
+ data_.n.d = d;
+ data_.f.flags = kNumberDoubleFlag;
+ }
+
+ //! Constructor for float value.
+ explicit GenericValue(float f) RAPIDJSON_NOEXCEPT : data_() {
+ data_.n.d = static_cast(f);
+ data_.f.flags = kNumberDoubleFlag;
+ }
+
+ //! Constructor for constant string (i.e. do not make a copy of string)
+ GenericValue(const Ch *s, SizeType length) RAPIDJSON_NOEXCEPT : data_() {
+ SetStringRaw(StringRef(s, length));
+ }
+
+ //! Constructor for constant string (i.e. do not make a copy of string)
+ explicit GenericValue(StringRefType s) RAPIDJSON_NOEXCEPT : data_() {
+ SetStringRaw(s);
+ }
+
+ //! Constructor for copy-string (i.e. do make a copy of string)
+ GenericValue(const Ch *s, SizeType length, Allocator &allocator) : data_() {
+ SetStringRaw(StringRef(s, length), allocator);
+ }
+
+ //! Constructor for copy-string (i.e. do make a copy of string)
+ GenericValue(const Ch *s, Allocator &allocator) : data_() {
+ SetStringRaw(StringRef(s), allocator);
+ }
+
+#if RAPIDJSON_HAS_STDSTRING
+ //! Constructor for copy-string from a string object (i.e. do make a copy of
+ //! string)
+ /*! \note Requires the definition of the preprocessor symbol \ref
+ * RAPIDJSON_HAS_STDSTRING.
+ */
+ GenericValue(const std::basic_string &s, Allocator &allocator) : data_() {
+ SetStringRaw(StringRef(s), allocator);
+ }
+#endif
+
+ //! Constructor for Array.
+ /*!
+ \param a An array obtained by \c GetArray().
+ \note \c Array is always pass-by-value.
+ \note the source array is moved into this value and the sourec array
+ becomes empty.
+ */
+ GenericValue(Array a) RAPIDJSON_NOEXCEPT : data_(a.value_.data_) {
+ a.value_.data_ = Data();
+ a.value_.data_.f.flags = kArrayFlag;
+ }
+
+ //! Constructor for Object.
+ /*!
+ \param o An object obtained by \c GetObject().
+ \note \c Object is always pass-by-value.
+ \note the source object is moved into this value and the sourec object
+ becomes empty.
+ */
+ GenericValue(Object o) RAPIDJSON_NOEXCEPT : data_(o.value_.data_) {
+ o.value_.data_ = Data();
+ o.value_.data_.f.flags = kObjectFlag;
+ }
+
+ //! Destructor.
+ /*! Need to destruct elements of array, members of object, or copy-string.
+ */
+ ~GenericValue() {
+ if (Allocator::kNeedFree) { // Shortcut by Allocator's trait
+ switch (data_.f.flags) {
+ case kArrayFlag: {
+ GenericValue *e = GetElementsPointer();
+ for (GenericValue *v = e; v != e + data_.a.size; ++v)
+ v->~GenericValue();
+ Allocator::Free(e);
+ } break;
+
+ case kObjectFlag:
+ for (MemberIterator m = MemberBegin(); m != MemberEnd(); ++m)
+ m->~Member();
+ Allocator::Free(GetMembersPointer());
+ break;
+
+ case kCopyStringFlag:
+ Allocator::Free(const_cast(GetStringPointer()));
+ break;
+
+ default:
+ break; // Do nothing for other types.
+ }
+ }
+ }
+
+ //@}
+
+ //!@name Assignment operators
+ //@{
+
+ //! Assignment with move semantics.
+ /*! \param rhs Source of the assignment. It will become a null value after
+ * assignment.
+ */
+ GenericValue &operator=(GenericValue &rhs) RAPIDJSON_NOEXCEPT {
+ if (RAPIDJSON_LIKELY(this != &rhs)) {
+ this->~GenericValue();
+ RawAssign(rhs);
+ }
+ return *this;
+ }
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+ //! Move assignment in C++11
+ GenericValue &operator=(GenericValue &&rhs) RAPIDJSON_NOEXCEPT {
+ return *this = rhs.Move();
+ }
+#endif
+
+ //! Assignment of constant string reference (no copy)
+ /*! \param str Constant string reference to be assigned
+ \note This overload is needed to avoid clashes with the generic primitive
+ type assignment overload below. \see GenericStringRef, operator=(T)
+ */
+ GenericValue &operator=(StringRefType str) RAPIDJSON_NOEXCEPT {
+ GenericValue s(str);
+ return *this = s;
+ }
+
+ //! Assignment with primitive types.
+ /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t
+ \param value The value to be assigned.
+
+ \note The source type \c T explicitly disallows all pointer types,
+ especially (\c const) \ref Ch*. This helps avoiding implicitly
+ referencing character strings with insufficient lifetime, use
+ \ref SetString(const Ch*, Allocator&) (for copying) or
+ \ref StringRef() (to explicitly mark the pointer as constant) instead.
+ All other pointer types would implicitly convert to \c bool,
+ use \ref SetBool() instead.
+ */
+ template
+ RAPIDJSON_DISABLEIF_RETURN((internal::IsPointer), (GenericValue &))
+ operator=(T value) {
+ GenericValue v(value);
+ return *this = v;
+ }
+
+ //! Deep-copy assignment from Value
+ /*! Assigns a \b copy of the Value to the current Value object
+ \tparam SourceAllocator Allocator type of \c rhs
+ \param rhs Value to copy from (read-only)
+ \param allocator Allocator to use for copying
+ \param copyConstStrings Force copying of constant strings (e.g.
+ referencing an in-situ buffer)
+ */
+ template
+ GenericValue &CopyFrom(const GenericValue &rhs,
+ Allocator &allocator, bool copyConstStrings = false) {
+ RAPIDJSON_ASSERT(static_cast(this) !=
+ static_cast(&rhs));
+ this->~GenericValue();
+ new (this) GenericValue(rhs, allocator, copyConstStrings);
+ return *this;
+ }
+
+ //! Exchange the contents of this value with those of other.
+ /*!
+ \param other Another value.
+ \note Constant complexity.
+ */
+ GenericValue &Swap(GenericValue &other) RAPIDJSON_NOEXCEPT {
+ GenericValue temp;
+ temp.RawAssign(*this);
+ RawAssign(other);
+ other.RawAssign(temp);
+ return *this;
+ }
+
+ //! free-standing swap function helper
+ /*!
+ Helper function to enable support for common swap implementation pattern
+ based on \c std::swap: \code void swap(MyClass& a, MyClass& b) { using
+ std::swap; swap(a.value, b.value);
+ // ...
+ }
+ \endcode
+ \see Swap()
+ */
+ friend inline void swap(GenericValue &a, GenericValue &b) RAPIDJSON_NOEXCEPT {
+ a.Swap(b);
+ }
+
+ //! Prepare Value for move semantics
+ /*! \return *this */
+ GenericValue &Move() RAPIDJSON_NOEXCEPT { return *this; }
+ //@}
+
+ //!@name Equal-to and not-equal-to operators
+ //@{
+ //! Equal-to operator
+ /*!
+ \note If an object contains duplicated named member, comparing equality
+ with any object is always \c false. \note Complexity is quadratic in
+ Object's member number and linear for the rest (number of all values in the
+ subtree and total lengths of all strings).
+ */
+ template
+ bool operator==(const GenericValue &rhs) const {
+ typedef GenericValue RhsType;
+ if (GetType() != rhs.GetType()) return false;
+
+ switch (GetType()) {
+ case kObjectType: // Warning: O(n^2) inner-loop
+ if (data_.o.size != rhs.data_.o.size) return false;
+ for (ConstMemberIterator lhsMemberItr = MemberBegin();
+ lhsMemberItr != MemberEnd(); ++lhsMemberItr) {
+ typename RhsType::ConstMemberIterator rhsMemberItr =
+ rhs.FindMember(lhsMemberItr->name);
+ if (rhsMemberItr == rhs.MemberEnd() ||
+ lhsMemberItr->value != rhsMemberItr->value)
+ return false;
+ }
+ return true;
+
+ case kArrayType:
+ if (data_.a.size != rhs.data_.a.size) return false;
+ for (SizeType i = 0; i < data_.a.size; i++)
+ if ((*this)[i] != rhs[i]) return false;
+ return true;
+
+ case kStringType:
+ return StringEqual(rhs);
+
+ case kNumberType:
+ if (IsDouble() || rhs.IsDouble()) {
+ double a = GetDouble(); // May convert from integer to double.
+ double b = rhs.GetDouble(); // Ditto
+ return a >= b && a <= b; // Prevent -Wfloat-equal
+ } else
+ return data_.n.u64 == rhs.data_.n.u64;
+
+ default:
+ return true;
+ }
+ }
+
+ //! Equal-to operator with const C-string pointer
+ bool operator==(const Ch *rhs) const {
+ return *this == GenericValue(StringRef(rhs));
+ }
+
+#if RAPIDJSON_HAS_STDSTRING
+ //! Equal-to operator with string object
+ /*! \note Requires the definition of the preprocessor symbol \ref
+ * RAPIDJSON_HAS_STDSTRING.
+ */
+ bool operator==(const std::basic_string &rhs) const {
+ return *this == GenericValue(StringRef(rhs));
+ }
+#endif
+
+ //! Equal-to operator with primitive types
+ /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t,
+ * \c double, \c true, \c false
+ */
+ template
+ RAPIDJSON_DISABLEIF_RETURN(
+ (internal::OrExpr, internal::IsGenericValue>),
+ (bool))
+ operator==(const T &rhs) const {
+ return *this == GenericValue(rhs);
+ }
+
+ //! Not-equal-to operator
+ /*! \return !(*this == rhs)
+ */
+ template
+ bool operator!=(const GenericValue &rhs) const {
+ return !(*this == rhs);
+ }
+
+ //! Not-equal-to operator with const C-string pointer
+ bool operator!=(const Ch *rhs) const { return !(*this == rhs); }
+
+ //! Not-equal-to operator with arbitrary types
+ /*! \return !(*this == rhs)
+ */
+ template
+ RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue), (bool))
+ operator!=(const T &rhs) const {
+ return !(*this == rhs);
+ }
+
+ //! Equal-to operator with arbitrary types (symmetric version)
+ /*! \return (rhs == lhs)
+ */
+ template
+ friend RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue), (bool))
+ operator==(const T &lhs, const GenericValue &rhs) {
+ return rhs == lhs;
+ }
+
+ //! Not-Equal-to operator with arbitrary types (symmetric version)
+ /*! \return !(rhs == lhs)
+ */
+ template
+ friend RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue), (bool))
+ operator!=(const T &lhs, const GenericValue &rhs) {
+ return !(rhs == lhs);
+ }
+ //@}
+
+ //!@name Type
+ //@{
+
+ Type GetType() const { return static_cast(data_.f.flags & kTypeMask); }
+ bool IsNull() const { return data_.f.flags == kNullFlag; }
+ bool IsFalse() const { return data_.f.flags == kFalseFlag; }
+ bool IsTrue() const { return data_.f.flags == kTrueFlag; }
+ bool IsBool() const { return (data_.f.flags & kBoolFlag) != 0; }
+ bool IsObject() const { return data_.f.flags == kObjectFlag; }
+ bool IsArray() const { return data_.f.flags == kArrayFlag; }
+ bool IsNumber() const { return (data_.f.flags & kNumberFlag) != 0; }
+ bool IsInt() const { return (data_.f.flags & kIntFlag) != 0; }
+ bool IsUint() const { return (data_.f.flags & kUintFlag) != 0; }
+ bool IsInt64() const { return (data_.f.flags & kInt64Flag) != 0; }
+ bool IsUint64() const { return (data_.f.flags & kUint64Flag) != 0; }
+ bool IsDouble() const { return (data_.f.flags & kDoubleFlag) != 0; }
+ bool IsString() const { return (data_.f.flags & kStringFlag) != 0; }
+
+ // Checks whether a number can be losslessly converted to a double.
+ bool IsLosslessDouble() const {
+ if (!IsNumber()) return false;
+ if (IsUint64()) {
+ uint64_t u = GetUint64();
+ volatile double d = static_cast(u);
+ return (d >= 0.0) &&
+ (d <
+ static_cast((std::numeric_limits::max)())) &&
+ (u == static_cast(d));
+ }
+ if (IsInt64()) {
+ int64_t i = GetInt64();
+ volatile double d = static_cast(i);
+ return (d >=
+ static_cast((std::numeric_limits::min)())) &&
+ (d < static_cast((std::numeric_limits::max)())) &&
+ (i == static_cast(d));
+ }
+ return true; // double, int, uint are always lossless
+ }
+
+ // Checks whether a number is a float (possible lossy).
+ bool IsFloat() const {
+ if ((data_.f.flags & kDoubleFlag) == 0) return false;
+ double d = GetDouble();
+ return d >= -3.4028234e38 && d <= 3.4028234e38;
+ }
+ // Checks whether a number can be losslessly converted to a float.
+ bool IsLosslessFloat() const {
+ if (!IsNumber()) return false;
+ double a = GetDouble();
+ if (a < static_cast(-(std::numeric_limits::max)()) ||
+ a > static_cast((std::numeric_limits::max)()))
+ return false;
+ double b = static_cast(static_cast(a));
+ return a >= b && a <= b; // Prevent -Wfloat-equal
+ }
+
+ //@}
+
+ //!@name Null
+ //@{
+
+ GenericValue &SetNull() {
+ this->~GenericValue();
+ new (this) GenericValue();
+ return *this;
+ }
+
+ //@}
+
+ //!@name Bool
+ //@{
+
+ bool GetBool() const {
+ RAPIDJSON_ASSERT(IsBool());
+ return data_.f.flags == kTrueFlag;
+ }
+ //!< Set boolean value
+ /*! \post IsBool() == true */
+ GenericValue &SetBool(bool b) {
+ this->~GenericValue();
+ new (this) GenericValue(b);
+ return *this;
+ }
+
+ //@}
+
+ //!@name Object
+ //@{
+
+ //! Set this value as an empty object.
+ /*! \post IsObject() == true */
+ GenericValue &SetObject() {
+ this->~GenericValue();
+ new (this) GenericValue(kObjectType);
+ return *this;
+ }
+
+ //! Get the number of members in the object.
+ SizeType MemberCount() const {
+ RAPIDJSON_ASSERT(IsObject());
+ return data_.o.size;
+ }
+
+ //! Get the capacity of object.
+ SizeType MemberCapacity() const {
+ RAPIDJSON_ASSERT(IsObject());
+ return data_.o.capacity;
+ }
+
+ //! Check whether the object is empty.
+ bool ObjectEmpty() const {
+ RAPIDJSON_ASSERT(IsObject());
+ return data_.o.size == 0;
+ }
+
+ //! Get a value from an object associated with the name.
+ /*! \pre IsObject() == true
+ \tparam T Either \c Ch or \c const \c Ch (template used for disambiguation
+ with \ref operator[](SizeType)) \note In version 0.1x, if the member is not
+ found, this function returns a null value. This makes issue 7. Since 0.2,
+ if the name is not correct, it will assert. If user is unsure whether a
+ member exists, user should use HasMember() first. A better approach is to
+ use FindMember(). \note Linear time complexity.
+ */
+ template
+ RAPIDJSON_DISABLEIF_RETURN(
+ (internal::NotExpr<
+ internal::IsSame::Type, Ch>>),
+ (GenericValue &))
+ operator[](T *name) {
+ GenericValue n(StringRef(name));
+ return (*this)[n];
+ }
+ template
+ RAPIDJSON_DISABLEIF_RETURN(
+ (internal::NotExpr<
+ internal::IsSame::Type, Ch>>),
+ (const GenericValue &))
+ operator[](T *name) const {
+ return const_cast(*this)[name];
+ }
+
+ //! Get a value from an object associated with the name.
+ /*! \pre IsObject() == true
+ \tparam SourceAllocator Allocator of the \c name value
+
+ \note Compared to \ref operator[](T*), this version is faster because it
+ does not need a StrLen(). And it can also handle strings with embedded null
+ characters.
+
+ \note Linear time complexity.
+ */
+ template
+ GenericValue &operator[](
+ const GenericValue &name) {
+ MemberIterator member = FindMember(name);
+ if (member != MemberEnd())
+ return member->value;
+ else {
+ RAPIDJSON_ASSERT(false); // see above note
+
+ // This will generate -Wexit-time-destructors in clang
+ // static GenericValue NullValue;
+ // return NullValue;
+
+ // Use static buffer and placement-new to prevent destruction
+ static char buffer[sizeof(GenericValue)];
+ return *new (buffer) GenericValue();
+ }
+ }
+ template
+ const GenericValue &operator[](
+ const GenericValue &name) const {
+ return const_cast(*this)[name];
+ }
+
+#if RAPIDJSON_HAS_STDSTRING
+ //! Get a value from an object associated with name (string object).
+ GenericValue &operator[](const std::basic_string &name) {
+ return (*this)[GenericValue(StringRef(name))];
+ }
+ const GenericValue &operator[](const std::basic_string &name) const {
+ return (*this)[GenericValue(StringRef(name))];
+ }
+#endif
+
+ //! Const member iterator
+ /*! \pre IsObject() == true */
+ ConstMemberIterator MemberBegin() const {
+ RAPIDJSON_ASSERT(IsObject());
+ return ConstMemberIterator(GetMembersPointer());
+ }
+ //! Const \em past-the-end member iterator
+ /*! \pre IsObject() == true */
+ ConstMemberIterator MemberEnd() const {
+ RAPIDJSON_ASSERT(IsObject());
+ return ConstMemberIterator(GetMembersPointer() + data_.o.size);
+ }
+ //! Member iterator
+ /*! \pre IsObject() == true */
+ MemberIterator MemberBegin() {
+ RAPIDJSON_ASSERT(IsObject());
+ return MemberIterator(GetMembersPointer());
+ }
+ //! \em Past-the-end member iterator
+ /*! \pre IsObject() == true */
+ MemberIterator MemberEnd() {
+ RAPIDJSON_ASSERT(IsObject());
+ return MemberIterator(GetMembersPointer() + data_.o.size);
+ }
+
+ //! Request the object to have enough capacity to store members.
+ /*! \param newCapacity The capacity that the object at least need to have.
+ \param allocator Allocator for reallocating memory. It must be the same
+ one as used before. Commonly use GenericDocument::GetAllocator(). \return
+ The value itself for fluent API. \note Linear time complexity.
+ */
+ GenericValue &MemberReserve(SizeType newCapacity, Allocator &allocator) {
+ RAPIDJSON_ASSERT(IsObject());
+ if (newCapacity > data_.o.capacity) {
+ SetMembersPointer(reinterpret_cast(allocator.Realloc(
+ GetMembersPointer(), data_.o.capacity * sizeof(Member),
+ newCapacity * sizeof(Member))));
+ data_.o.capacity = newCapacity;
+ }
+ return *this;
+ }
+
+ //! Check whether a member exists in the object.
+ /*!
+ \param name Member name to be searched.
+ \pre IsObject() == true
+ \return Whether a member with that name exists.
+ \note It is better to use FindMember() directly if you need the obtain the
+ value as well. \note Linear time complexity.
+ */
+ bool HasMember(const Ch *name) const {
+ return FindMember(name) != MemberEnd();
+ }
+
+#if RAPIDJSON_HAS_STDSTRING
+ //! Check whether a member exists in the object with string object.
+ /*!
+ \param name Member name to be searched.
+ \pre IsObject() == true
+ \return Whether a member with that name exists.
+ \note It is better to use FindMember() directly if you need the obtain the
+ value as well. \note Linear time complexity.
+ */
+ bool HasMember(const std::basic_string &name) const {
+ return FindMember(name) != MemberEnd();
+ }
+#endif
+
+ //! Check whether a member exists in the object with GenericValue name.
+ /*!
+ This version is faster because it does not need a StrLen(). It can also
+ handle string with null character. \param name Member name to be searched.
+ \pre IsObject() == true
+ \return Whether a member with that name exists.
+ \note It is better to use FindMember() directly if you need the obtain the
+ value as well. \note Linear time complexity.
+ */
+ template
+ bool HasMember(const GenericValue &name) const {
+ return FindMember(name) != MemberEnd();
+ }
+
+ //! Find member by name.
+ /*!
+ \param name Member name to be searched.
+ \pre IsObject() == true
+ \return Iterator to member, if it exists.
+ Otherwise returns \ref MemberEnd().
+
+ \note Earlier versions of Rapidjson returned a \c NULL pointer, in case
+ the requested member doesn't exist. For consistency with e.g.
+ \c std::map, this has been changed to MemberEnd() now.
+ \note Linear time complexity.
+ */
+ MemberIterator FindMember(const Ch *name) {
+ GenericValue n(StringRef(name));
+ return FindMember(n);
+ }
+
+ ConstMemberIterator FindMember(const Ch *name) const {
+ return const_cast(*this).FindMember(name);
+ }
+
+ //! Find member by name.
+ /*!
+ This version is faster because it does not need a StrLen(). It can also
+ handle string with null character. \param name Member name to be searched.
+ \pre IsObject() == true
+ \return Iterator to member, if it exists.
+ Otherwise returns \ref MemberEnd().
+
+ \note Earlier versions of Rapidjson returned a \c NULL pointer, in case
+ the requested member doesn't exist. For consistency with e.g.
+ \c std::map, this has been changed to MemberEnd() now.
+ \note Linear time complexity.
+ */
+ template
+ MemberIterator FindMember(
+ const GenericValue &name) {
+ RAPIDJSON_ASSERT(IsObject());
+ RAPIDJSON_ASSERT(name.IsString());
+ MemberIterator member = MemberBegin();
+ for (; member != MemberEnd(); ++member)
+ if (name.StringEqual(member->name)) break;
+ return member;
+ }
+ template
+ ConstMemberIterator FindMember(
+ const GenericValue &name) const {
+ return const_cast(*this).FindMember(name);
+ }
+
+#if RAPIDJSON_HAS_STDSTRING
+ //! Find member by string object name.
+ /*!
+ \param name Member name to be searched.
+ \pre IsObject() == true
+ \return Iterator to member, if it exists.
+ Otherwise returns \ref MemberEnd().
+ */
+ MemberIterator FindMember(const std::basic_string &name) {
+ return FindMember(GenericValue(StringRef(name)));
+ }
+ ConstMemberIterator FindMember(const std::basic_string &name) const {
+ return FindMember(GenericValue(StringRef(name)));
+ }
+#endif
+
+ //! Add a member (name-value pair) to the object.
+ /*! \param name A string value as name of member.
+ \param value Value of any type.
+ \param allocator Allocator for reallocating memory. It must be the same
+ one as used before. Commonly use GenericDocument::GetAllocator(). \return
+ The value itself for fluent API. \note The ownership of \c name and \c
+ value will be transferred to this object on success. \pre IsObject() &&
+ name.IsString() \post name.IsNull() && value.IsNull() \note Amortized
+ Constant time complexity.
+ */
+ GenericValue &AddMember(GenericValue &name, GenericValue &value,
+ Allocator &allocator) {
+ RAPIDJSON_ASSERT(IsObject());
+ RAPIDJSON_ASSERT(name.IsString());
+
+ ObjectData &o = data_.o;
+ if (o.size >= o.capacity)
+ MemberReserve(o.capacity == 0 ? kDefaultObjectCapacity
+ : (o.capacity + (o.capacity + 1) / 2),
+ allocator);
+ Member *members = GetMembersPointer();
+ members[o.size].name.RawAssign(name);
+ members[o.size].value.RawAssign(value);
+ o.size++;
+ return *this;
+ }
+
+ //! Add a constant string value as member (name-value pair) to the object.
+ /*! \param name A string value as name of member.
+ \param value constant string reference as value of member.
+ \param allocator Allocator for reallocating memory. It must be the same
+ one as used before. Commonly use GenericDocument::GetAllocator(). \return
+ The value itself for fluent API. \pre IsObject() \note This overload is
+ needed to avoid clashes with the generic primitive type
+ AddMember(GenericValue&,T,Allocator&) overload below. \note Amortized
+ Constant time complexity.
+ */
+ GenericValue &AddMember(GenericValue &name, StringRefType value,
+ Allocator &allocator) {
+ GenericValue v(value);
+ return AddMember(name, v, allocator);
+ }
+
+#if RAPIDJSON_HAS_STDSTRING
+ //! Add a string object as member (name-value pair) to the object.
+ /*! \param name A string value as name of member.
+ \param value constant string reference as value of member.
+ \param allocator Allocator for reallocating memory. It must be the same
+ one as used before. Commonly use GenericDocument::GetAllocator(). \return
+ The value itself for fluent API. \pre IsObject() \note This overload is
+ needed to avoid clashes with the generic primitive type
+ AddMember(GenericValue&,T,Allocator&) overload below. \note Amortized
+ Constant time complexity.
+ */
+ GenericValue &AddMember(GenericValue &name, std::basic_string &value,
+ Allocator &allocator) {
+ GenericValue v(value, allocator);
+ return AddMember(name, v, allocator);
+ }
+#endif
+
+ //! Add any primitive value as member (name-value pair) to the object.
+ /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t
+ \param name A string value as name of member.
+ \param value Value of primitive type \c T as value of member
+ \param allocator Allocator for reallocating memory. Commonly use
+ GenericDocument::GetAllocator(). \return The value itself for fluent API.
+ \pre IsObject()
+
+ \note The source type \c T explicitly disallows all pointer types,
+ especially (\c const) \ref Ch*. This helps avoiding implicitly
+ referencing character strings with insufficient lifetime, use
+ \ref AddMember(StringRefType, GenericValue&, Allocator&) or \ref
+ AddMember(StringRefType, StringRefType, Allocator&).
+ All other pointer types would implicitly convert to \c bool,
+ use an explicit cast instead, if needed.
+ \note Amortized Constant time complexity.
+ */
+ template
+ RAPIDJSON_DISABLEIF_RETURN(
+ (internal::OrExpr, internal::IsGenericValue>),
+ (GenericValue &))
+ AddMember(GenericValue &name, T value, Allocator &allocator) {
+ GenericValue v(value);
+ return AddMember(name, v, allocator);
+ }
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+ GenericValue &AddMember(GenericValue &&name, GenericValue &&value,
+ Allocator &allocator) {
+ return AddMember(name, value, allocator);
+ }
+ GenericValue &AddMember(GenericValue &&name, GenericValue &value,
+ Allocator &allocator) {
+ return AddMember(name, value, allocator);
+ }
+ GenericValue &AddMember(GenericValue &name, GenericValue &&value,
+ Allocator &allocator) {
+ return AddMember(name, value, allocator);
+ }
+ GenericValue &AddMember(StringRefType name, GenericValue &&value,
+ Allocator &allocator) {
+ GenericValue n(name);
+ return AddMember(n, value, allocator);
+ }
+#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
+
+ //! Add a member (name-value pair) to the object.
+ /*! \param name A constant string reference as name of member.
+ \param value Value of any type.
+ \param allocator Allocator for reallocating memory. It must be the same
+ one as used before. Commonly use GenericDocument::GetAllocator(). \return
+ The value itself for fluent API. \note The ownership of \c value will be
+ transferred to this object on success. \pre IsObject() \post
+ value.IsNull() \note Amortized Constant time complexity.
+ */
+ GenericValue &AddMember(StringRefType name, GenericValue &value,
+ Allocator &allocator) {
+ GenericValue n(name);
+ return AddMember(n, value, allocator);
+ }
+
+ //! Add a constant string value as member (name-value pair) to the object.
+ /*! \param name A constant string reference as name of member.
+ \param value constant string reference as value of member.
+ \param allocator Allocator for reallocating memory. It must be the same
+ one as used before. Commonly use GenericDocument::GetAllocator(). \return
+ The value itself for fluent API. \pre IsObject() \note This overload is
+ needed to avoid clashes with the generic primitive type
+ AddMember(StringRefType,T,Allocator&) overload below. \note Amortized
+ Constant time complexity.
+ */
+ GenericValue &AddMember(StringRefType name, StringRefType value,
+ Allocator &allocator) {
+ GenericValue v(value);
+ return AddMember(name, v, allocator);
+ }
+
+ //! Add any primitive value as member (name-value pair) to the object.
+ /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t
+ \param name A constant string reference as name of member.
+ \param value Value of primitive type \c T as value of member
+ \param allocator Allocator for reallocating memory. Commonly use
+ GenericDocument::GetAllocator(). \return The value itself for fluent API.
+ \pre IsObject()
+
+ \note The source type \c T explicitly disallows all pointer types,
+ especially (\c const) \ref Ch*. This helps avoiding implicitly
+ referencing character strings with insufficient lifetime, use
+ \ref AddMember(StringRefType, GenericValue&, Allocator&) or \ref
+ AddMember(StringRefType, StringRefType, Allocator&).
+ All other pointer types would implicitly convert to \c bool,
+ use an explicit cast instead, if needed.
+ \note Amortized Constant time complexity.
+ */
+ template
+ RAPIDJSON_DISABLEIF_RETURN(
+ (internal::OrExpr, internal::IsGenericValue>),
+ (GenericValue &))
+ AddMember(StringRefType name, T value, Allocator &allocator) {
+ GenericValue n(name);
+ return AddMember(n, value, allocator);
+ }
+
+ //! Remove all members in the object.
+ /*! This function do not deallocate memory in the object, i.e. the capacity is
+ unchanged. \note Linear time complexity.
+ */
+ void RemoveAllMembers() {
+ RAPIDJSON_ASSERT(IsObject());
+ for (MemberIterator m = MemberBegin(); m != MemberEnd(); ++m) m->~Member();
+ data_.o.size = 0;
+ }
+
+ //! Remove a member in object by its name.
+ /*! \param name Name of member to be removed.
+ \return Whether the member existed.
+ \note This function may reorder the object members. Use \ref
+ EraseMember(ConstMemberIterator) if you need to preserve the
+ relative order of the remaining members.
+ \note Linear time complexity.
+ */
+ bool RemoveMember(const Ch *name) {
+ GenericValue n(StringRef(name));
+ return RemoveMember(n);
+ }
+
+#if RAPIDJSON_HAS_STDSTRING
+ bool RemoveMember(const std::basic_string &name) {
+ return RemoveMember(GenericValue(StringRef(name)));
+ }
+#endif
+
+ template
+ bool RemoveMember(const GenericValue &name) {
+ MemberIterator m = FindMember(name);
+ if (m != MemberEnd()) {
+ RemoveMember(m);
+ return true;
+ } else
+ return false;
+ }
+
+ //! Remove a member in object by iterator.
+ /*! \param m member iterator (obtained by FindMember() or MemberBegin()).
+ \return the new iterator after removal.
+ \note This function may reorder the object members. Use \ref
+ EraseMember(ConstMemberIterator) if you need to preserve the
+ relative order of the remaining members.
+ \note Constant time complexity.
+ */
+ MemberIterator RemoveMember(MemberIterator m) {
+ RAPIDJSON_ASSERT(IsObject());
+ RAPIDJSON_ASSERT(data_.o.size > 0);
+ RAPIDJSON_ASSERT(GetMembersPointer() != 0);
+ RAPIDJSON_ASSERT(m >= MemberBegin() && m < MemberEnd());
+
+ MemberIterator last(GetMembersPointer() + (data_.o.size - 1));
+ if (data_.o.size > 1 && m != last)
+ *m = *last; // Move the last one to this place
+ else
+ m->~Member(); // Only one left, just destroy
+ --data_.o.size;
+ return m;
+ }
+
+ //! Remove a member from an object by iterator.
+ /*! \param pos iterator to the member to remove
+ \pre IsObject() == true && \ref MemberBegin() <= \c pos < \ref MemberEnd()
+ \return Iterator following the removed element.
+ If the iterator \c pos refers to the last element, the \ref
+ MemberEnd() iterator is returned. \note This function preserves the
+ relative order of the remaining object members. If you do not need this,
+ use the more efficient \ref RemoveMember(MemberIterator). \note Linear time
+ complexity.
+ */
+ MemberIterator EraseMember(ConstMemberIterator pos) {
+ return EraseMember(pos, pos + 1);
+ }
+
+ //! Remove members in the range [first, last) from an object.
+ /*! \param first iterator to the first member to remove
+ \param last iterator following the last member to remove
+ \pre IsObject() == true && \ref MemberBegin() <= \c first <= \c last <=
+ \ref MemberEnd() \return Iterator following the last removed element. \note
+ This function preserves the relative order of the remaining object members.
+ \note Linear time complexity.
+ */
+ MemberIterator EraseMember(ConstMemberIterator first,
+ ConstMemberIterator last) {
+ RAPIDJSON_ASSERT(IsObject());
+ RAPIDJSON_ASSERT(data_.o.size > 0);
+ RAPIDJSON_ASSERT(GetMembersPointer() != 0);
+ RAPIDJSON_ASSERT(first >= MemberBegin());
+ RAPIDJSON_ASSERT(first <= last);
+ RAPIDJSON_ASSERT(last <= MemberEnd());
+
+ MemberIterator pos = MemberBegin() + (first - MemberBegin());
+ for (MemberIterator itr = pos; itr != last; ++itr) itr->~Member();
+ std::memmove(static_cast(&*pos), &*last,
+ static_cast(MemberEnd() - last) * sizeof(Member));
+ data_.o.size -= static_cast(last - first);
+ return pos;
+ }
+
+ //! Erase a member in object by its name.
+ /*! \param name Name of member to be removed.
+ \return Whether the member existed.
+ \note Linear time complexity.
+ */
+ bool EraseMember(const Ch *name) {
+ GenericValue n(StringRef(name));
+ return EraseMember(n);
+ }
+
+#if RAPIDJSON_HAS_STDSTRING
+ bool EraseMember(const std::basic_string &name) {
+ return EraseMember(GenericValue(StringRef(name)));
+ }
+#endif
+
+ template
+ bool EraseMember(const GenericValue &name) {
+ MemberIterator m = FindMember(name);
+ if (m != MemberEnd()) {
+ EraseMember(m);
+ return true;
+ } else
+ return false;
+ }
+
+ Object GetObject() {
+ RAPIDJSON_ASSERT(IsObject());
+ return Object(*this);
+ }
+ ConstObject GetObject() const {
+ RAPIDJSON_ASSERT(IsObject());
+ return ConstObject(*this);
+ }
+
+ //@}
+
+ //!@name Array
+ //@{
+
+ //! Set this value as an empty array.
+ /*! \post IsArray == true */
+ GenericValue &SetArray() {
+ this->~GenericValue();
+ new (this) GenericValue(kArrayType);
+ return *this;
+ }
+
+ //! Get the number of elements in array.
+ SizeType Size() const {
+ RAPIDJSON_ASSERT(IsArray());
+ return data_.a.size;
+ }
+
+ //! Get the capacity of array.
+ SizeType Capacity() const {
+ RAPIDJSON_ASSERT(IsArray());
+ return data_.a.capacity;
+ }
+
+ //! Check whether the array is empty.
+ bool Empty() const {
+ RAPIDJSON_ASSERT(IsArray());
+ return data_.a.size == 0;
+ }
+
+ //! Remove all elements in the array.
+ /*! This function do not deallocate memory in the array, i.e. the capacity is
+ unchanged. \note Linear time complexity.
+ */
+ void Clear() {
+ RAPIDJSON_ASSERT(IsArray());
+ GenericValue *e = GetElementsPointer();
+ for (GenericValue *v = e; v != e + data_.a.size; ++v) v->~GenericValue();
+ data_.a.size = 0;
+ }
+
+ //! Get an element from array by index.
+ /*! \pre IsArray() == true
+ \param index Zero-based index of element.
+ \see operator[](T*)
+ */
+ GenericValue &operator[](SizeType index) {
+ RAPIDJSON_ASSERT(IsArray());
+ RAPIDJSON_ASSERT(index < data_.a.size);
+ return GetElementsPointer()[index];
+ }
+ const GenericValue &operator[](SizeType index) const {
+ return const_cast(*this)[index];
+ }
+
+ //! Element iterator
+ /*! \pre IsArray() == true */
+ ValueIterator Begin() {
+ RAPIDJSON_ASSERT(IsArray());
+ return GetElementsPointer();
+ }
+ //! \em Past-the-end element iterator
+ /*! \pre IsArray() == true */
+ ValueIterator End() {
+ RAPIDJSON_ASSERT(IsArray());
+ return GetElementsPointer() + data_.a.size;
+ }
+ //! Constant element iterator
+ /*! \pre IsArray() == true */
+ ConstValueIterator Begin() const {
+ return const_cast(*this).Begin();
+ }
+ //! Constant \em past-the-end element iterator
+ /*! \pre IsArray() == true */
+ ConstValueIterator End() const {
+ return const_cast(*this).End();
+ }
+
+ //! Request the array to have enough capacity to store elements.
+ /*! \param newCapacity The capacity that the array at least need to have.
+ \param allocator Allocator for reallocating memory. It must be the same
+ one as used before. Commonly use GenericDocument::GetAllocator(). \return
+ The value itself for fluent API. \note Linear time complexity.
+ */
+ GenericValue &Reserve(SizeType newCapacity, Allocator &allocator) {
+ RAPIDJSON_ASSERT(IsArray());
+ if (newCapacity > data_.a.capacity) {
+ SetElementsPointer(reinterpret_cast(allocator.Realloc(
+ GetElementsPointer(), data_.a.capacity * sizeof(GenericValue),
+ newCapacity * sizeof(GenericValue))));
+ data_.a.capacity = newCapacity;
+ }
+ return *this;
+ }
+
+ //! Append a GenericValue at the end of the array.
+ /*! \param value Value to be appended.
+ \param allocator Allocator for reallocating memory. It must be the same
+ one as used before. Commonly use GenericDocument::GetAllocator(). \pre
+ IsArray() == true \post value.IsNull() == true \return The value itself for
+ fluent API. \note The ownership of \c value will be transferred to this
+ array on success. \note If the number of elements to be appended is known,
+ calls Reserve() once first may be more efficient. \note Amortized constant
+ time complexity.
+ */
+ GenericValue &PushBack(GenericValue &value, Allocator &allocator) {
+ RAPIDJSON_ASSERT(IsArray());
+ if (data_.a.size >= data_.a.capacity)
+ Reserve(data_.a.capacity == 0
+ ? kDefaultArrayCapacity
+ : (data_.a.capacity + (data_.a.capacity + 1) / 2),
+ allocator);
+ GetElementsPointer()[data_.a.size++].RawAssign(value);
+ return *this;
+ }
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+ GenericValue &PushBack(GenericValue &&value, Allocator &allocator) {
+ return PushBack(value, allocator);
+ }
+#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
+
+ //! Append a constant string reference at the end of the array.
+ /*! \param value Constant string reference to be appended.
+ \param allocator Allocator for reallocating memory. It must be the same
+ one used previously. Commonly use GenericDocument::GetAllocator(). \pre
+ IsArray() == true \return The value itself for fluent API. \note If the
+ number of elements to be appended is known, calls Reserve() once first may
+ be more efficient. \note Amortized constant time complexity. \see
+ GenericStringRef
+ */
+ GenericValue &PushBack(StringRefType value, Allocator &allocator) {
+ return (*this).template PushBack(value, allocator);
+ }
+
+ //! Append a primitive value at the end of the array.
+ /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t
+ \param value Value of primitive type T to be appended.
+ \param allocator Allocator for reallocating memory. It must be the same
+ one as used before. Commonly use GenericDocument::GetAllocator(). \pre
+ IsArray() == true \return The value itself for fluent API. \note If the
+ number of elements to be appended is known, calls Reserve() once first may
+ be more efficient.
+
+ \note The source type \c T explicitly disallows all pointer types,
+ especially (\c const) \ref Ch*. This helps avoiding implicitly
+ referencing character strings with insufficient lifetime, use
+ \ref PushBack(GenericValue&, Allocator&) or \ref
+ PushBack(StringRefType, Allocator&).
+ All other pointer types would implicitly convert to \c bool,
+ use an explicit cast instead, if needed.
+ \note Amortized constant time complexity.
+ */
+ template
+ RAPIDJSON_DISABLEIF_RETURN(
+ (internal::OrExpr, internal::IsGenericValue>),
+ (GenericValue &))
+ PushBack(T value, Allocator &allocator) {
+ GenericValue v(value);
+ return PushBack(v, allocator);
+ }
+
+ //! Remove the last element in the array.
+ /*!
+ \note Constant time complexity.
+ */
+ GenericValue &PopBack() {
+ RAPIDJSON_ASSERT(IsArray());
+ RAPIDJSON_ASSERT(!Empty());
+ GetElementsPointer()[--data_.a.size].~GenericValue();
+ return *this;
+ }
+
+ //! Remove an element of array by iterator.
+ /*!
+ \param pos iterator to the element to remove
+ \pre IsArray() == true && \ref Begin() <= \c pos < \ref End()
+ \return Iterator following the removed element. If the iterator pos refers
+ to the last element, the End() iterator is returned. \note Linear time
+ complexity.
+ */
+ ValueIterator Erase(ConstValueIterator pos) { return Erase(pos, pos + 1); }
+
+ //! Remove elements in the range [first, last) of the array.
+ /*!
+ \param first iterator to the first element to remove
+ \param last iterator following the last element to remove
+ \pre IsArray() == true && \ref Begin() <= \c first <= \c last <= \ref
+ End() \return Iterator following the last removed element. \note Linear
+ time complexity.
+ */
+ ValueIterator Erase(ConstValueIterator first, ConstValueIterator last) {
+ RAPIDJSON_ASSERT(IsArray());
+ RAPIDJSON_ASSERT(data_.a.size > 0);
+ RAPIDJSON_ASSERT(GetElementsPointer() != 0);
+ RAPIDJSON_ASSERT(first >= Begin());
+ RAPIDJSON_ASSERT(first <= last);
+ RAPIDJSON_ASSERT(last <= End());
+ ValueIterator pos = Begin() + (first - Begin());
+ for (ValueIterator itr = pos; itr != last; ++itr) itr->~GenericValue();
+ std::memmove(static_cast(pos), last,
+ static_cast(End() - last) * sizeof(GenericValue));
+ data_.a.size -= static_cast(last - first);
+ return pos;
+ }
+
+ Array GetArray() {
+ RAPIDJSON_ASSERT(IsArray());
+ return Array(*this);
+ }
+ ConstArray GetArray() const {
+ RAPIDJSON_ASSERT(IsArray());
+ return ConstArray(*this);
+ }
+
+ //@}
+
+ //!@name Number
+ //@{
+
+ int GetInt() const {
+ RAPIDJSON_ASSERT(data_.f.flags & kIntFlag);
+ return data_.n.i.i;
+ }
+ unsigned GetUint() const {
+ RAPIDJSON_ASSERT(data_.f.flags & kUintFlag);
+ return data_.n.u.u;
+ }
+ int64_t GetInt64() const {
+ RAPIDJSON_ASSERT(data_.f.flags & kInt64Flag);
+ return data_.n.i64;
+ }
+ uint64_t GetUint64() const {
+ RAPIDJSON_ASSERT(data_.f.flags & kUint64Flag);
+ return data_.n.u64;
+ }
+
+ //! Get the value as double type.
+ /*! \note If the value is 64-bit integer type, it may lose precision. Use \c
+ * IsLosslessDouble() to check whether the converison is lossless.
+ */
+ double GetDouble() const {
+ RAPIDJSON_ASSERT(IsNumber());
+ if ((data_.f.flags & kDoubleFlag) != 0)
+ return data_.n.d; // exact type, no conversion.
+ if ((data_.f.flags & kIntFlag) != 0) return data_.n.i.i; // int -> double
+ if ((data_.f.flags & kUintFlag) != 0)
+ return data_.n.u.u; // unsigned -> double
+ if ((data_.f.flags & kInt64Flag) != 0)
+ return static_cast(
+ data_.n.i64); // int64_t -> double (may lose precision)
+ RAPIDJSON_ASSERT((data_.f.flags & kUint64Flag) != 0);
+ return static_cast(
+ data_.n.u64); // uint64_t -> double (may lose precision)
+ }
+
+ //! Get the value as float type.
+ /*! \note If the value is 64-bit integer type, it may lose precision. Use \c
+ * IsLosslessFloat() to check whether the converison is lossless.
+ */
+ float GetFloat() const { return static_cast(GetDouble()); }
+
+ GenericValue &SetInt(int i) {
+ this->~GenericValue();
+ new (this) GenericValue(i);
+ return *this;
+ }
+ GenericValue &SetUint(unsigned u) {
+ this->~GenericValue();
+ new (this) GenericValue(u);
+ return *this;
+ }
+ GenericValue &SetInt64(int64_t i64) {
+ this->~GenericValue();
+ new (this) GenericValue(i64);
+ return *this;
+ }
+ GenericValue &SetUint64(uint64_t u64) {
+ this->~GenericValue();
+ new (this) GenericValue(u64);
+ return *this;
+ }
+ GenericValue &SetDouble(double d) {
+ this->~GenericValue();
+ new (this) GenericValue(d);
+ return *this;
+ }
+ GenericValue &SetFloat(float f) {
+ this->~GenericValue();
+ new (this) GenericValue(static_cast(f));
+ return *this;
+ }
+
+ //@}
+
+ //!@name String
+ //@{
+
+ const Ch *GetString() const {
+ RAPIDJSON_ASSERT(IsString());
+ return (data_.f.flags & kInlineStrFlag) ? data_.ss.str : GetStringPointer();
+ }
+
+ //! Get the length of string.
+ /*! Since rapidjson permits "\\u0000" in the json string,
+ * strlen(v.GetString()) may not equal to v.GetStringLength().
+ */
+ SizeType GetStringLength() const {
+ RAPIDJSON_ASSERT(IsString());
+ return ((data_.f.flags & kInlineStrFlag) ? (data_.ss.GetLength())
+ : data_.s.length);
+ }
+
+ //! Set this value as a string without copying source string.
+ /*! This version has better performance with supplied length, and also support
+ string containing null character. \param s source string pointer. \param
+ length The length of source string, excluding the trailing null terminator.
+ \return The value itself for fluent API.
+ \post IsString() == true && GetString() == s && GetStringLength() ==
+ length \see SetString(StringRefType)
+ */
+ GenericValue &SetString(const Ch *s, SizeType length) {
+ return SetString(StringRef(s, length));
+ }
+
+ //! Set this value as a string without copying source string.
+ /*! \param s source string reference
+ \return The value itself for fluent API.
+ \post IsString() == true && GetString() == s && GetStringLength() ==
+ s.length
+ */
+ GenericValue &SetString(StringRefType s) {
+ this->~GenericValue();
+ SetStringRaw(s);
+ return *this;
+ }
+
+ //! Set this value as a string by copying from source string.
+ /*! This version has better performance with supplied length, and also support
+ string containing null character. \param s source string. \param length The
+ length of source string, excluding the trailing null terminator. \param
+ allocator Allocator for allocating copied buffer. Commonly use
+ GenericDocument::GetAllocator(). \return The value itself for fluent API.
+ \post IsString() == true && GetString() != s && strcmp(GetString(),s) == 0
+ && GetStringLength() == length
+ */
+ GenericValue &SetString(const Ch *s, SizeType length, Allocator &allocator) {
+ return SetString(StringRef(s, length), allocator);
+ }
+
+ //! Set this value as a string by copying from source string.
+ /*! \param s source string.
+ \param allocator Allocator for allocating copied buffer. Commonly use
+ GenericDocument::GetAllocator(). \return The value itself for fluent API.
+ \post IsString() == true && GetString() != s && strcmp(GetString(),s) == 0
+ && GetStringLength() == length
+ */
+ GenericValue &SetString(const Ch *s, Allocator &allocator) {
+ return SetString(StringRef(s), allocator);
+ }
+
+ //! Set this value as a string by copying from source string.
+ /*! \param s source string reference
+ \param allocator Allocator for allocating copied buffer. Commonly use
+ GenericDocument::GetAllocator(). \return The value itself for fluent API.
+ \post IsString() == true && GetString() != s.s && strcmp(GetString(),s) ==
+ 0 && GetStringLength() == length
+ */
+ GenericValue &SetString(StringRefType s, Allocator &allocator) {
+ this->~GenericValue();
+ SetStringRaw(s, allocator);
+ return *this;
+ }
+
+#if RAPIDJSON_HAS_STDSTRING
+ //! Set this value as a string by copying from source string.
+ /*! \param s source string.
+ \param allocator Allocator for allocating copied buffer. Commonly use
+ GenericDocument::GetAllocator(). \return The value itself for fluent API.
+ \post IsString() == true && GetString() != s.data() &&
+ strcmp(GetString(),s.data() == 0 && GetStringLength() == s.size() \note
+ Requires the definition of the preprocessor symbol \ref
+ RAPIDJSON_HAS_STDSTRING.
+ */
+ GenericValue &SetString(const std::basic_string &s,
+ Allocator &allocator) {
+ return SetString(StringRef(s), allocator);
+ }
+#endif
+
+ //@}
+
+ //!@name Array
+ //@{
+
+ //! Templated version for checking whether this value is type T.
+ /*!
+ \tparam T Either \c bool, \c int, \c unsigned, \c int64_t, \c uint64_t, \c
+ double, \c float, \c const \c char*, \c std::basic_string
+ */
+ template
+ bool Is() const {
+ return internal::TypeHelper::Is(*this);
+ }
+
+ template
+ T Get() const {
+ return internal::TypeHelper::Get(*this);
+ }
+
+ template
+ T Get() {
+ return internal::TypeHelper::Get(*this);
+ }
+
+ template
+ ValueType &Set(const T &data) {
+ return internal::TypeHelper::Set(*this, data);
+ }
+
+ template
+ ValueType &Set(const T &data, AllocatorType &allocator) {
+ return internal::TypeHelper::Set(*this, data, allocator);
+ }
+
+ //@}
+
+ //! Generate events of this value to a Handler.
+ /*! This function adopts the GoF visitor pattern.
+ Typical usage is to output this JSON value as JSON text via Writer, which
+ is a Handler. It can also be used to deep clone this value via
+ GenericDocument, which is also a Handler. \tparam Handler type of handler.
+ \param handler An object implementing concept Handler.
+ */
+ template
+ bool Accept(Handler &handler) const {
+ switch (GetType()) {
+ case kNullType:
+ return handler.Null();
+ case kFalseType:
+ return handler.Bool(false);
+ case kTrueType:
+ return handler.Bool(true);
+
+ case kObjectType:
+ if (RAPIDJSON_UNLIKELY(!handler.StartObject())) return false;
+ for (ConstMemberIterator m = MemberBegin(); m != MemberEnd(); ++m) {
+ RAPIDJSON_ASSERT(m->name.IsString()); // User may change the type of
+ // name by MemberIterator.
+ if (RAPIDJSON_UNLIKELY(
+ !handler.Key(m->name.GetString(), m->name.GetStringLength(),
+ (m->name.data_.f.flags & kCopyFlag) != 0)))
+ return false;
+ if (RAPIDJSON_UNLIKELY(!m->value.Accept(handler))) return false;
+ }
+ return handler.EndObject(data_.o.size);
+
+ case kArrayType:
+ if (RAPIDJSON_UNLIKELY(!handler.StartArray())) return false;
+ for (const GenericValue *v = Begin(); v != End(); ++v)
+ if (RAPIDJSON_UNLIKELY(!v->Accept(handler))) return false;
+ return handler.EndArray(data_.a.size);
+
+ case kStringType:
+ return handler.String(GetString(), GetStringLength(),
+ (data_.f.flags & kCopyFlag) != 0);
+
+ default:
+ RAPIDJSON_ASSERT(GetType() == kNumberType);
+ if (IsDouble())
+ return handler.Double(data_.n.d);
+ else if (IsInt())
+ return handler.Int(data_.n.i.i);
+ else if (IsUint())
+ return handler.Uint(data_.n.u.u);
+ else if (IsInt64())
+ return handler.Int64(data_.n.i64);
+ else
+ return handler.Uint64(data_.n.u64);
+ }
+ }
+
+ private:
+ template
+ friend class GenericValue;
+ template
+ friend class GenericDocument;
+
+ enum {
+ kBoolFlag = 0x0008,
+ kNumberFlag = 0x0010,
+ kIntFlag = 0x0020,
+ kUintFlag = 0x0040,
+ kInt64Flag = 0x0080,
+ kUint64Flag = 0x0100,
+ kDoubleFlag = 0x0200,
+ kStringFlag = 0x0400,
+ kCopyFlag = 0x0800,
+ kInlineStrFlag = 0x1000,
+
+ // Initial flags of different types.
+ kNullFlag = kNullType,
+ kTrueFlag = kTrueType | kBoolFlag,
+ kFalseFlag = kFalseType | kBoolFlag,
+ kNumberIntFlag = kNumberType | kNumberFlag | kIntFlag | kInt64Flag,
+ kNumberUintFlag =
+ kNumberType | kNumberFlag | kUintFlag | kUint64Flag | kInt64Flag,
+ kNumberInt64Flag = kNumberType | kNumberFlag | kInt64Flag,
+ kNumberUint64Flag = kNumberType | kNumberFlag | kUint64Flag,
+ kNumberDoubleFlag = kNumberType | kNumberFlag | kDoubleFlag,
+ kNumberAnyFlag = kNumberType | kNumberFlag | kIntFlag | kInt64Flag |
+ kUintFlag | kUint64Flag | kDoubleFlag,
+ kConstStringFlag = kStringType | kStringFlag,
+ kCopyStringFlag = kStringType | kStringFlag | kCopyFlag,
+ kShortStringFlag = kStringType | kStringFlag | kCopyFlag | kInlineStrFlag,
+ kObjectFlag = kObjectType,
+ kArrayFlag = kArrayType,
+
+ kTypeMask = 0x07
+ };
+
+ static const SizeType kDefaultArrayCapacity = 16;
+ static const SizeType kDefaultObjectCapacity = 16;
+
+ struct Flag {
+#if RAPIDJSON_48BITPOINTER_OPTIMIZATION
+ char payload[sizeof(SizeType) * 2 +
+ 6]; // 2 x SizeType + lower 48-bit pointer
+#elif RAPIDJSON_64BIT
+ char payload[sizeof(SizeType) * 2 + sizeof(void *) + 6]; // 6 padding bytes
+#else
+ char payload[sizeof(SizeType) * 2 + sizeof(void *) +
+ 2]; // 2 padding bytes
+#endif
+ uint16_t flags;
+ };
+
+ struct String {
+ SizeType length;
+ SizeType hashcode; //!< reserved
+ const Ch *str;
+ }; // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode
+
+ // implementation detail: ShortString can represent zero-terminated strings up
+ // to MaxSize chars (excluding the terminating zero) and store a value to
+ // determine the length of the contained string in the last character
+ // str[LenPos] by storing "MaxSize - length" there. If the string to store has
+ // the maximal length of MaxSize then str[LenPos] will be 0 and therefore act
+ // as the string terminator as well. For getting the string length back from
+ // that value just use "MaxSize - str[LenPos]". This allows to store 13-chars
+ // strings in 32-bit mode, 21-chars strings in 64-bit mode, 13-chars strings
+ // for RAPIDJSON_48BITPOINTER_OPTIMIZATION=1 inline (for `UTF8`-encoded
+ // strings).
+ struct ShortString {
+ enum {
+ MaxChars = sizeof(static_cast(0)->payload) / sizeof(Ch),
+ MaxSize = MaxChars - 1,
+ LenPos = MaxSize
+ };
+ Ch str[MaxChars];
+
+ inline static bool Usable(SizeType len) { return (MaxSize >= len); }
+ inline void SetLength(SizeType len) {
+ str[LenPos] = static_cast(MaxSize - len);
+ }
+ inline SizeType GetLength() const {
+ return static_cast(MaxSize - str[LenPos]);
+ }
+ }; // at most as many bytes as "String" above => 12 bytes in 32-bit mode, 16
+ // bytes in 64-bit mode
+
+ // By using proper binary layout, retrieval of different integer types do not
+ // need conversions.
+ union Number {
+#if RAPIDJSON_ENDIAN == RAPIDJSON_LITTLEENDIAN
+ struct I {
+ int i;
+ char padding[4];
+ } i;
+ struct U {
+ unsigned u;
+ char padding2[4];
+ } u;
+#else
+ struct I {
+ char padding[4];
+ int i;
+ } i;
+ struct U {
+ char padding2[4];
+ unsigned u;
+ } u;
+#endif
+ int64_t i64;
+ uint64_t u64;
+ double d;
+ }; // 8 bytes
+
+ struct ObjectData {
+ SizeType size;
+ SizeType capacity;
+ Member *members;
+ }; // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode
+
+ struct ArrayData {
+ SizeType size;
+ SizeType capacity;
+ GenericValue *elements;
+ }; // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode
+
+ union Data {
+ String s;
+ ShortString ss;
+ Number n;
+ ObjectData o;
+ ArrayData a;
+ Flag f;
+ }; // 16 bytes in 32-bit mode, 24 bytes in 64-bit mode, 16 bytes in 64-bit
+ // with RAPIDJSON_48BITPOINTER_OPTIMIZATION
+
+ RAPIDJSON_FORCEINLINE const Ch *GetStringPointer() const {
+ return RAPIDJSON_GETPOINTER(Ch, data_.s.str);
+ }
+ RAPIDJSON_FORCEINLINE const Ch *SetStringPointer(const Ch *str) {
+ return RAPIDJSON_SETPOINTER(Ch, data_.s.str, str);
+ }
+ RAPIDJSON_FORCEINLINE GenericValue *GetElementsPointer() const {
+ return RAPIDJSON_GETPOINTER(GenericValue, data_.a.elements);
+ }
+ RAPIDJSON_FORCEINLINE GenericValue *SetElementsPointer(
+ GenericValue *elements) {
+ return RAPIDJSON_SETPOINTER(GenericValue, data_.a.elements, elements);
+ }
+ RAPIDJSON_FORCEINLINE Member *GetMembersPointer() const {
+ return RAPIDJSON_GETPOINTER(Member, data_.o.members);
+ }
+ RAPIDJSON_FORCEINLINE Member *SetMembersPointer(Member *members) {
+ return RAPIDJSON_SETPOINTER(Member, data_.o.members, members);
+ }
+
+ // Initialize this value as array with initial data, without calling
+ // destructor.
+ void SetArrayRaw(GenericValue *values, SizeType count, Allocator &allocator) {
+ data_.f.flags = kArrayFlag;
+ if (count) {
+ GenericValue *e = static_cast(
+ allocator.Malloc(count * sizeof(GenericValue)));
+ SetElementsPointer(e);
+ std::memcpy(static_cast(e), values, count * sizeof(GenericValue));
+ } else
+ SetElementsPointer(0);
+ data_.a.size = data_.a.capacity = count;
+ }
+
+ //! Initialize this value as object with initial data, without calling
+ //! destructor.
+ void SetObjectRaw(Member *members, SizeType count, Allocator &allocator) {
+ data_.f.flags = kObjectFlag;
+ if (count) {
+ Member *m =
+ static_cast(allocator.Malloc(count * sizeof(Member)));
+ SetMembersPointer(m);
+ std::memcpy(static_cast(m), members, count * sizeof(Member));
+ } else
+ SetMembersPointer(0);
+ data_.o.size = data_.o.capacity = count;
+ }
+
+ //! Initialize this value as constant string, without calling destructor.
+ void SetStringRaw(StringRefType s) RAPIDJSON_NOEXCEPT {
+ data_.f.flags = kConstStringFlag;
+ SetStringPointer(s);
+ data_.s.length = s.length;
+ }
+
+ //! Initialize this value as copy string with initial data, without calling
+ //! destructor.
+ void SetStringRaw(StringRefType s, Allocator &allocator) {
+ Ch *str = 0;
+ if (ShortString::Usable(s.length)) {
+ data_.f.flags = kShortStringFlag;
+ data_.ss.SetLength(s.length);
+ str = data_.ss.str;
+ } else {
+ data_.f.flags = kCopyStringFlag;
+ data_.s.length = s.length;
+ str = static_cast(allocator.Malloc((s.length + 1) * sizeof(Ch)));
+ SetStringPointer(str);
+ }
+ std::memcpy(str, s, s.length * sizeof(Ch));
+ str[s.length] = '\0';
+ }
+
+ //! Assignment without calling destructor
+ void RawAssign(GenericValue &rhs) RAPIDJSON_NOEXCEPT {
+ data_ = rhs.data_;
+ // data_.f.flags = rhs.data_.f.flags;
+ rhs.data_.f.flags = kNullFlag;
+ }
+
+ template
+ bool StringEqual(const GenericValue &rhs) const {
+ RAPIDJSON_ASSERT(IsString());
+ RAPIDJSON_ASSERT(rhs.IsString());
+
+ const SizeType len1 = GetStringLength();
+ const SizeType len2 = rhs.GetStringLength();
+ if (len1 != len2) {
+ return false;
+ }
+
+ const Ch *const str1 = GetString();
+ const Ch *const str2 = rhs.GetString();
+ if (str1 == str2) {
+ return true;
+ } // fast path for constant string
+
+ return (std::memcmp(str1, str2, sizeof(Ch) * len1) == 0);
+ }
+
+ Data data_;
+};
+
+//! GenericValue with UTF8 encoding
+typedef GenericValue> Value;
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericDocument
+
+//! A document for parsing JSON text as DOM.
+/*!
+ \note implements Handler concept
+ \tparam Encoding Encoding for both parsing and string storage.
+ \tparam Allocator Allocator for allocating memory for the DOM
+ \tparam StackAllocator Allocator for allocating memory for stack during
+ parsing. \warning Although GenericDocument inherits from GenericValue, the
+ API does \b not provide any virtual functions, especially no virtual
+ destructor. To avoid memory leaks, do not \c delete a GenericDocument object
+ via a pointer to a GenericValue.
+*/
+template ,
+ typename StackAllocator = CrtAllocator>
+class GenericDocument : public GenericValue {
+ public:
+ typedef typename Encoding::Ch Ch; //!< Character type derived from Encoding.
+ typedef GenericValue
+ ValueType; //!< Value type of the document.
+ typedef Allocator AllocatorType; //!< Allocator type from template parameter.
+
+ //! Constructor
+ /*! Creates an empty document of specified type.
+ \param type Mandatory type of object to create.
+ \param allocator Optional allocator for allocating memory.
+ \param stackCapacity Optional initial capacity of stack in bytes.
+ \param stackAllocator Optional allocator for allocating memory for
+ stack.
+ */
+ explicit GenericDocument(Type type, Allocator *allocator = 0,
+ size_t stackCapacity = kDefaultStackCapacity,
+ StackAllocator *stackAllocator = 0)
+ : GenericValue(type),
+ allocator_(allocator),
+ ownAllocator_(0),
+ stack_(stackAllocator, stackCapacity),
+ parseResult_() {
+ if (!allocator_) ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
+ }
+
+ //! Constructor
+ /*! Creates an empty document which type is Null.
+ \param allocator Optional allocator for allocating memory.
+ \param stackCapacity Optional initial capacity of stack in bytes.
+ \param stackAllocator Optional allocator for allocating memory for
+ stack.
+ */
+ GenericDocument(Allocator *allocator = 0,
+ size_t stackCapacity = kDefaultStackCapacity,
+ StackAllocator *stackAllocator = 0)
+ : allocator_(allocator),
+ ownAllocator_(0),
+ stack_(stackAllocator, stackCapacity),
+ parseResult_() {
+ if (!allocator_) ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
+ }
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+ //! Move constructor in C++11
+ GenericDocument(GenericDocument &&rhs) RAPIDJSON_NOEXCEPT
+ : ValueType(std::forward(
+ rhs)), // explicit cast to avoid prohibited move from Document
+ allocator_(rhs.allocator_),
+ ownAllocator_(rhs.ownAllocator_),
+ stack_(std::move(rhs.stack_)),
+ parseResult_(rhs.parseResult_) {
+ rhs.allocator_ = 0;
+ rhs.ownAllocator_ = 0;
+ rhs.parseResult_ = ParseResult();
+ }
+#endif
+
+ ~GenericDocument() { Destroy(); }
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+ //! Move assignment in C++11
+ GenericDocument &operator=(GenericDocument &&rhs) RAPIDJSON_NOEXCEPT {
+ // The cast to ValueType is necessary here, because otherwise it would
+ // attempt to call GenericValue's templated assignment operator.
+ ValueType::operator=(std::forward(rhs));
+
+ // Calling the destructor here would prematurely call stack_'s destructor
+ Destroy();
+
+ allocator_ = rhs.allocator_;
+ ownAllocator_ = rhs.ownAllocator_;
+ stack_ = std::move(rhs.stack_);
+ parseResult_ = rhs.parseResult_;
+
+ rhs.allocator_ = 0;
+ rhs.ownAllocator_ = 0;
+ rhs.parseResult_ = ParseResult();
+
+ return *this;
+ }
+#endif
+
+ //! Exchange the contents of this document with those of another.
+ /*!
+ \param rhs Another document.
+ \note Constant complexity.
+ \see GenericValue::Swap
+ */
+ GenericDocument &Swap(GenericDocument &rhs) RAPIDJSON_NOEXCEPT {
+ ValueType::Swap(rhs);
+ stack_.Swap(rhs.stack_);
+ internal::Swap(allocator_, rhs.allocator_);
+ internal::Swap(ownAllocator_, rhs.ownAllocator_);
+ internal::Swap(parseResult_, rhs.parseResult_);
+ return *this;
+ }
+
+ // Allow Swap with ValueType.
+ // Refer to Effective C++ 3rd Edition/Item 33: Avoid hiding inherited names.
+ using ValueType::Swap;
+
+ //! free-standing swap function helper
+ /*!
+ Helper function to enable support for common swap implementation pattern
+ based on \c std::swap: \code void swap(MyClass& a, MyClass& b) { using
+ std::swap; swap(a.doc, b.doc);
+ // ...
+ }
+ \endcode
+ \see Swap()
+ */
+ friend inline void swap(GenericDocument &a,
+ GenericDocument &b) RAPIDJSON_NOEXCEPT {
+ a.Swap(b);
+ }
+
+ //! Populate this document by a generator which produces SAX events.
+ /*! \tparam Generator A functor with bool f(Handler) prototype.
+ \param g Generator functor which sends SAX events to the parameter.
+ \return The document itself for fluent API.
+ */
+ template
+ GenericDocument &Populate(Generator &g) {
+ ClearStackOnExit scope(*this);
+ if (g(*this)) {
+ RAPIDJSON_ASSERT(stack_.GetSize() ==
+ sizeof(ValueType)); // Got one and only one root object
+ ValueType::operator=(*stack_.template Pop(
+ 1)); // Move value from stack to document
+ }
+ return *this;
+ }
+
+ //!@name Parse from stream
+ //!@{
+
+ //! Parse JSON text from an input stream (with Encoding conversion)
+ /*! \tparam parseFlags Combination of \ref ParseFlag.
+ \tparam SourceEncoding Encoding of input stream
+ \tparam InputStream Type of input stream, implementing Stream concept
+ \param is Input stream to be parsed.
+ \return The document itself for fluent API.
+ */
+ template
+ GenericDocument &ParseStream(InputStream &is) {
+ GenericReader reader(
+ stack_.HasAllocator() ? &stack_.GetAllocator() : 0);
+ ClearStackOnExit scope(*this);
+ parseResult_ = reader.template Parse(is, *this);
+ if (parseResult_) {
+ RAPIDJSON_ASSERT(stack_.GetSize() ==
+ sizeof(ValueType)); // Got one and only one root object
+ ValueType::operator=(*stack_.template Pop(
+ 1)); // Move value from stack to document
+ }
+ return *this;
+ }
+
+ //! Parse JSON text from an input stream
+ /*! \tparam parseFlags Combination of \ref ParseFlag.
+ \tparam InputStream Type of input stream, implementing Stream concept
+ \param is Input stream to be parsed.
+ \return The document itself for fluent API.
+ */
+ template
+ GenericDocument &ParseStream(InputStream &is) {
+ return ParseStream