gvsafronov/rapidjson
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add fwd.h and extract stream.h

Browse Source
This commit is contained in:
Milo Yip 2016-02-02 18:20:36 +08:00
parent 0cf064422a
commit 8cb978dc15
19 changed files with 550 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/rapidjson/encodedstream.h
View File

@ -15,7 +15,7 @@
#ifndef RAPIDJSON_ENCODEDSTREAM_H_
#define RAPIDJSON_ENCODEDSTREAM_H_
#include "rapidjson.h"
#include "stream.h"
#ifdef __GNUC__
RAPIDJSON_DIAG_PUSH

2
include/rapidjson/filereadstream.h
View File

@ -15,7 +15,7 @@
#ifndef RAPIDJSON_FILEREADSTREAM_H_
#define RAPIDJSON_FILEREADSTREAM_H_
#include "rapidjson.h"
#include "stream.h"
#include <cstdio>
#ifdef __clang__

2
include/rapidjson/filewritestream.h
View File

@ -15,7 +15,7 @@
#ifndef RAPIDJSON_FILEWRITESTREAM_H_
#define RAPIDJSON_FILEWRITESTREAM_H_
#include "rapidjson.h"
#include "stream.h"
#include <cstdio>
#ifdef __clang__

146
include/rapidjson/fwd.h Normal file
View File

@ -0,0 +1,146 @@
// 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_FWD_H_
#define RAPIDJSON_FWD_H_
#include "rapidjson.h"
RAPIDJSON_NAMESPACE_BEGIN
// encodings.h
template<typename CharType> struct UTF8;
template<typename CharType> struct UTF16;
template<typename CharType> struct UTF16BE;
template<typename CharType> struct UTF16LE;
template<typename CharType> struct UTF32;
template<typename CharType> struct UTF32BE;
template<typename CharType> struct UTF32LE;
template<typename CharType> struct ASCII;
template<typename CharType> struct AutoUTF;
template<typename SourceEncoding, typename TargetEncoding>
struct Transcoder;
// allocators.h
class CrtAllocator;
template <typename BaseAllocator>
class MemoryPoolAllocator;
// stream.h
template <typename Encoding>
struct GenericStringStream;
typedef GenericStringStream<UTF8<char> > StringStream;
template <typename Encoding>
struct GenericInsituStringStream;
typedef GenericInsituStringStream<UTF8<char> > InsituStringStream;
// stringbuffer.h
template <typename Encoding, typename Allocator>
class GenericStringBuffer;
typedef GenericStringBuffer<UTF8<char>, CrtAllocator> StringBuffer;
// filereadstream.h
class FileReadStream;
// filewritestream.h
class FileWriteStream;
// memorybuffer.h
template <typename Allocator>
struct GenericMemoryBuffer;
typedef GenericMemoryBuffer<CrtAllocator> MemoryBuffer;
// memorystream.h
struct MemoryStream;
// reader.h
template<typename Encoding, typename Derived>
struct BaseReaderHandler;
template <typename SourceEncoding, typename TargetEncoding, typename StackAllocator>
class GenericReader;
typedef GenericReader<UTF8<char>, UTF8<char>, CrtAllocator> Reader;
// writer.h
template<typename OutputStream, typename SourceEncoding, typename TargetEncoding, typename StackAllocator>
class Writer;
// document.h
template <typename Encoding, typename Allocator>
struct GenericMember;
template <bool Const, typename Encoding, typename Allocator>
class GenericMemberIterator;
template<typename CharType>
struct GenericStringRef;
template <typename Encoding, typename Allocator>
class GenericValue;
typedef GenericValue<UTF8<char>, MemoryPoolAllocator<CrtAllocator> > Value;
template <typename Encoding, typename Allocator, typename StackAllocator>
class GenericDocument;
typedef GenericDocument<UTF8<char>, MemoryPoolAllocator<CrtAllocator>, CrtAllocator> Document;
// pointer.h
template <typename ValueType, typename Allocator>
class GenericPointer;
typedef GenericPointer<Value, CrtAllocator> Pointer;
// schema.h
template <typename SchemaDocumentType>
class IGenericRemoteSchemaDocumentProvider;
template <typename ValueT, typename Allocator>
class GenericSchemaDocument;
typedef GenericSchemaDocument<Value, CrtAllocator> SchemaDocument;
typedef IGenericRemoteSchemaDocumentProvider<SchemaDocument> IRemoteSchemaDocumentProvider;
template <
typename SchemaDocumentType,
typename OutputHandler,
typename StateAllocator>
class GenericSchemaValidator;
typedef GenericSchemaValidator<SchemaDocument, BaseReaderHandler<UTF8<char>, void>, CrtAllocator> SchemaValidator;
RAPIDJSON_NAMESPACE_END
#endif // RAPIDJSON_RAPIDJSONFWD_H_

3
include/rapidjson/internal/regex.h
View File

@ -15,7 +15,8 @@
#ifndef RAPIDJSON_INTERNAL_REGEX_H_
#define RAPIDJSON_INTERNAL_REGEX_H_
#include "../rapidjson.h"
#include "../allocators.h"
#include "../stream.h"
#include "stack.h"
#ifdef __clang__

2
include/rapidjson/internal/stack.h
View File

@ -15,7 +15,7 @@
#ifndef RAPIDJSON_INTERNAL_STACK_H_
#define RAPIDJSON_INTERNAL_STACK_H_
#include "../rapidjson.h"
#include "../allocators.h"
#include "swap.h"
#if defined(__clang__)

2
include/rapidjson/internal/strfunc.h
View File

@ -15,7 +15,7 @@
#ifndef RAPIDJSON_INTERNAL_STRFUNC_H_
#define RAPIDJSON_INTERNAL_STRFUNC_H_
#include "../rapidjson.h"
#include "../stream.h"
RAPIDJSON_NAMESPACE_BEGIN
namespace internal {

1
include/rapidjson/internal/strtod.h
View File

@ -15,7 +15,6 @@
#ifndef RAPIDJSON_STRTOD_
#define RAPIDJSON_STRTOD_
#include "../rapidjson.h"
#include "ieee754.h"
#include "biginteger.h"
#include "diyfp.h"

2
include/rapidjson/memorybuffer.h
View File

@ -15,7 +15,7 @@
#ifndef RAPIDJSON_MEMORYBUFFER_H_
#define RAPIDJSON_MEMORYBUFFER_H_
#include "rapidjson.h"
#include "stream.h"
#include "internal/stack.h"
RAPIDJSON_NAMESPACE_BEGIN

2
include/rapidjson/memorystream.h
View File

@ -15,7 +15,7 @@
#ifndef RAPIDJSON_MEMORYSTREAM_H_
#define RAPIDJSON_MEMORYSTREAM_H_
#include "rapidjson.h"
#include "stream.h"
#ifdef __clang__
RAPIDJSON_DIAG_PUSH

161
include/rapidjson/rapidjson.h
View File

@ -545,10 +545,7 @@ RAPIDJSON_NAMESPACE_END
#endif
///////////////////////////////////////////////////////////////////////////////
// Allocators and Encodings
#include "allocators.h"
#include "encodings.h"
// Type
/*! \namespace rapidjson
\brief main RapidJSON namespace
@ -556,162 +553,6 @@ RAPIDJSON_NAMESPACE_END
*/
RAPIDJSON_NAMESPACE_BEGIN
///////////////////////////////////////////////////////////////////////////////
// Stream
/*! \class rapidjson::Stream
\brief Concept for reading and writing characters.
For read-only stream, no need to implement PutBegin(), Put(), Flush() and PutEnd().
For write-only stream, only need to implement Put() and Flush().
\code
concept Stream {
typename Ch; //!< Character type of the stream.
//! Read the current character from stream without moving the read cursor.
Ch Peek() const;
//! Read the current character from stream and moving the read cursor to next character.
Ch Take();
//! Get the current read cursor.
//! \return Number of characters read from start.
size_t Tell();
//! Begin writing operation at the current read pointer.
//! \return The begin writer pointer.
Ch* PutBegin();
//! Write a character.
void Put(Ch c);
//! Flush the buffer.
void Flush();
//! End the writing operation.
//! \param begin The begin write pointer returned by PutBegin().
//! \return Number of characters written.
size_t PutEnd(Ch* begin);
}
\endcode
*/
//! Provides additional information for stream.
/*!
By using traits pattern, this type provides a default configuration for stream.
For custom stream, this type can be specialized for other configuration.
See TEST(Reader, CustomStringStream) in readertest.cpp for example.
*/
template<typename Stream>
struct StreamTraits {
//! Whether to make local copy of stream for optimization during parsing.
/*!
By default, for safety, streams do not use local copy optimization.
Stream that can be copied fast should specialize this, like StreamTraits<StringStream>.
*/
enum { copyOptimization = 0 };
};
//! Reserve n characters for writing to a stream.
template<typename Stream>
inline void PutReserve(Stream& stream, size_t count) {
(void)stream;
(void)count;
}
//! Write character to a stream, presuming buffer is reserved.
template<typename Stream>
inline void PutUnsafe(Stream& stream, typename Stream::Ch c) {
stream.Put(c);
}
//! Put N copies of a character to a stream.
template<typename Stream, typename Ch>
inline void PutN(Stream& stream, Ch c, size_t n) {
PutReserve<Stream>(stream, n);
for (size_t i = 0; i < n; i++)
PutUnsafe(stream, c);
}
///////////////////////////////////////////////////////////////////////////////
// StringStream
//! Read-only string stream.
/*! \note implements Stream concept
*/
template <typename Encoding>
struct GenericStringStream {
typedef typename Encoding::Ch Ch;
GenericStringStream(const Ch *src) : src_(src), head_(src) {}
Ch Peek() const { return *src_; }
Ch Take() { return *src_++; }
size_t Tell() const { return static_cast<size_t>(src_ - head_); }
Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
void Put(Ch) { RAPIDJSON_ASSERT(false); }
void Flush() { RAPIDJSON_ASSERT(false); }
size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
const Ch* src_; //!< Current read position.
const Ch* head_; //!< Original head of the string.
};
template <typename Encoding>
struct StreamTraits<GenericStringStream<Encoding> > {
enum { copyOptimization = 1 };
};
//! String stream with UTF8 encoding.
typedef GenericStringStream<UTF8<> > StringStream;
///////////////////////////////////////////////////////////////////////////////
// InsituStringStream
//! A read-write string stream.
/*! This string stream is particularly designed for in-situ parsing.
\note implements Stream concept
*/
template <typename Encoding>
struct GenericInsituStringStream {
typedef typename Encoding::Ch Ch;
GenericInsituStringStream(Ch *src) : src_(src), dst_(0), head_(src) {}
// Read
Ch Peek() { return *src_; }
Ch Take() { return *src_++; }
size_t Tell() { return static_cast<size_t>(src_ - head_); }
// Write
void Put(Ch c) { RAPIDJSON_ASSERT(dst_ != 0); *dst_++ = c; }
Ch* PutBegin() { return dst_ = src_; }
size_t PutEnd(Ch* begin) { return static_cast<size_t>(dst_ - begin); }
void Flush() {}
Ch* Push(size_t count) { Ch* begin = dst_; dst_ += count; return begin; }
void Pop(size_t count) { dst_ -= count; }
Ch* src_;
Ch* dst_;
Ch* head_;
};
template <typename Encoding>
struct StreamTraits<GenericInsituStringStream<Encoding> > {
enum { copyOptimization = 1 };
};
//! Insitu string stream with UTF8 encoding.
typedef GenericInsituStringStream<UTF8<> > InsituStringStream;
///////////////////////////////////////////////////////////////////////////////
// Type
//! Type of JSON value
enum Type {
kNullType = 0, //!< null

4
include/rapidjson/reader.h
View File

@ -17,8 +17,8 @@
/*! \file reader.h */
#include "rapidjson.h"
#include "encodings.h"
#include "allocators.h"
#include "stream.h"
#include "internal/meta.h"
#include "internal/stack.h"
#include "internal/strtod.h"

2
include/rapidjson/schema.h
View File

@ -17,7 +17,7 @@
#include "document.h"
#include "pointer.h"
#include <cmath> // HUGE_VAL, abs, floor
#include <cmath> // abs, floor
#ifdef __clang__
RAPIDJSON_DIAG_PUSH

179
include/rapidjson/stream.h Normal file
View File

@ -0,0 +1,179 @@
// 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.
#include "rapidjson.h"
#ifndef RAPIDJSON_STREAM_H_
#define RAPIDJSON_STREAM_H_
#include "encodings.h"
RAPIDJSON_NAMESPACE_BEGIN
///////////////////////////////////////////////////////////////////////////////
// Stream
/*! \class rapidjson::Stream
\brief Concept for reading and writing characters.
For read-only stream, no need to implement PutBegin(), Put(), Flush() and PutEnd().
For write-only stream, only need to implement Put() and Flush().
\code
concept Stream {
typename Ch; //!< Character type of the stream.
//! Read the current character from stream without moving the read cursor.
Ch Peek() const;
//! Read the current character from stream and moving the read cursor to next character.
Ch Take();
//! Get the current read cursor.
//! \return Number of characters read from start.
size_t Tell();
//! Begin writing operation at the current read pointer.
//! \return The begin writer pointer.
Ch* PutBegin();
//! Write a character.
void Put(Ch c);
//! Flush the buffer.
void Flush();
//! End the writing operation.
//! \param begin The begin write pointer returned by PutBegin().
//! \return Number of characters written.
size_t PutEnd(Ch* begin);
}
\endcode
*/
//! Provides additional information for stream.
/*!
By using traits pattern, this type provides a default configuration for stream.
For custom stream, this type can be specialized for other configuration.
See TEST(Reader, CustomStringStream) in readertest.cpp for example.
*/
template<typename Stream>
struct StreamTraits {
//! Whether to make local copy of stream for optimization during parsing.
/*!
By default, for safety, streams do not use local copy optimization.
Stream that can be copied fast should specialize this, like StreamTraits<StringStream>.
*/
enum { copyOptimization = 0 };
};
//! Reserve n characters for writing to a stream.
template<typename Stream>
inline void PutReserve(Stream& stream, size_t count) {
(void)stream;
(void)count;
}
//! Write character to a stream, presuming buffer is reserved.
template<typename Stream>
inline void PutUnsafe(Stream& stream, typename Stream::Ch c) {
stream.Put(c);
}
//! Put N copies of a character to a stream.
template<typename Stream, typename Ch>
inline void PutN(Stream& stream, Ch c, size_t n) {
PutReserve<Stream>(stream, n);
for (size_t i = 0; i < n; i++)
PutUnsafe(stream, c);
}
///////////////////////////////////////////////////////////////////////////////
// StringStream
//! Read-only string stream.
/*! \note implements Stream concept
*/
template <typename Encoding>
struct GenericStringStream {
typedef typename Encoding::Ch Ch;
GenericStringStream(const Ch *src) : src_(src), head_(src) {}
Ch Peek() const { return *src_; }
Ch Take() { return *src_++; }
size_t Tell() const { return static_cast<size_t>(src_ - head_); }
Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
void Put(Ch) { RAPIDJSON_ASSERT(false); }
void Flush() { RAPIDJSON_ASSERT(false); }
size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
const Ch* src_; //!< Current read position.
const Ch* head_; //!< Original head of the string.
};
template <typename Encoding>
struct StreamTraits<GenericStringStream<Encoding> > {
enum { copyOptimization = 1 };
};
//! String stream with UTF8 encoding.
typedef GenericStringStream<UTF8<> > StringStream;
///////////////////////////////////////////////////////////////////////////////
// InsituStringStream
//! A read-write string stream.
/*! This string stream is particularly designed for in-situ parsing.
\note implements Stream concept
*/
template <typename Encoding>
struct GenericInsituStringStream {
typedef typename Encoding::Ch Ch;
GenericInsituStringStream(Ch *src) : src_(src), dst_(0), head_(src) {}
// Read
Ch Peek() { return *src_; }
Ch Take() { return *src_++; }
size_t Tell() { return static_cast<size_t>(src_ - head_); }
// Write
void Put(Ch c) { RAPIDJSON_ASSERT(dst_ != 0); *dst_++ = c; }
Ch* PutBegin() { return dst_ = src_; }
size_t PutEnd(Ch* begin) { return static_cast<size_t>(dst_ - begin); }
void Flush() {}
Ch* Push(size_t count) { Ch* begin = dst_; dst_ += count; return begin; }
void Pop(size_t count) { dst_ -= count; }
Ch* src_;
Ch* dst_;
Ch* head_;
};
template <typename Encoding>
struct StreamTraits<GenericInsituStringStream<Encoding> > {
enum { copyOptimization = 1 };
};
//! Insitu string stream with UTF8 encoding.
typedef GenericInsituStringStream<UTF8<> > InsituStringStream;
RAPIDJSON_NAMESPACE_END
#endif // RAPIDJSON_STREAM_H_

3
include/rapidjson/stringbuffer.h
View File

@ -15,7 +15,8 @@
#ifndef RAPIDJSON_STRINGBUFFER_H_
#define RAPIDJSON_STRINGBUFFER_H_
#include "rapidjson.h"
#include "stream.h"
#include "internal/stack.h"
#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
#include <utility> // std::move

2
include/rapidjson/writer.h
View File

@ -15,7 +15,7 @@
#ifndef RAPIDJSON_WRITER_H_
#define RAPIDJSON_WRITER_H_
#include "rapidjson.h"
#include "stream.h"
#include "internal/stack.h"
#include "internal/strfunc.h"
#include "internal/dtoa.h"

1
test/unittest/CMakeLists.txt
View File

@ -4,6 +4,7 @@ set(UNITTEST_SOURCES
documenttest.cpp
encodedstreamtest.cpp
encodingstest.cpp
fwdtest.cpp
filestreamtest.cpp
itoatest.cpp
jsoncheckertest.cpp

208
test/unittest/fwdtest.cpp Normal file
View File

@ -0,0 +1,208 @@
// 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.
#include "unittest.h"
// Using forward declared types here.
#include "rapidjson/fwd.h"
using namespace rapidjson;
struct Foo {
Foo();
~Foo();
// encodings.h
UTF8<char>* utf8;
UTF16<wchar_t>* utf16;
UTF16BE<wchar_t>* utf16be;
UTF16LE<wchar_t>* utf16le;
UTF32<unsigned>* utf32;
UTF32BE<unsigned>* utf32be;
UTF32LE<unsigned>* utf32le;
ASCII<char>* ascii;
AutoUTF<unsigned>* autoutf;
Transcoder<UTF8<char>, UTF8<char> >* transcoder;
// allocators.h
CrtAllocator* crtallocator;
MemoryPoolAllocator<CrtAllocator>* memorypoolallocator;
// stream.h
StringStream* stringstream;
InsituStringStream* insitustringstream;
// stringbuffer.h
StringBuffer* stringbuffer;
// filereadstream.h
FileReadStream* filereadstream;
// filewritestream.h
FileWriteStream* filewritestream;
// memorybuffer.h
MemoryBuffer* memorybuffer;
// memorystream.h
MemoryStream* memorystream;
// reader.h
BaseReaderHandler<UTF8<char>, void>* basereaderhandler;
Reader* reader;
// writer.h
Writer<StringBuffer, UTF8<char>, UTF8<char>, CrtAllocator>* writer;
// document.h
Value* value;
Document* document;
// pointer.h
Pointer* pointer;
// schema.h
SchemaDocument* schemadocument;
SchemaValidator* schemavalidator;
char buffer[16];
};
// Using type definitions here.
#include "rapidjson/stringbuffer.h"
#include "rapidjson/filereadstream.h"
#include "rapidjson/filewritestream.h"
#include "rapidjson/memorybuffer.h"
#include "rapidjson/memorystream.h"
#include "rapidjson/document.h" // -> reader.h
#include "rapidjson/writer.h"
#include "rapidjson/schema.h" // -> pointer.h
Foo::Foo() :
// encodings.h
utf8(RAPIDJSON_NEW(UTF8<>)),
utf16(RAPIDJSON_NEW(UTF16<>)),
utf16be(RAPIDJSON_NEW(UTF16BE<>)),
utf16le(RAPIDJSON_NEW(UTF16LE<>)),
utf32(RAPIDJSON_NEW(UTF32<>)),
utf32be(RAPIDJSON_NEW(UTF32BE<>)),
utf32le(RAPIDJSON_NEW(UTF32LE<>)),
ascii(RAPIDJSON_NEW(ASCII<>)),
autoutf(RAPIDJSON_NEW(AutoUTF<unsigned>)),
transcoder(RAPIDJSON_NEW((Transcoder<UTF8<>, UTF8<> >))),
// allocators.h
crtallocator(RAPIDJSON_NEW(CrtAllocator)),
memorypoolallocator(RAPIDJSON_NEW(MemoryPoolAllocator<>)),
// stream.h
stringstream(RAPIDJSON_NEW(StringStream(0))),
insitustringstream(RAPIDJSON_NEW(InsituStringStream(0))),
// stringbuffer.h
stringbuffer(RAPIDJSON_NEW(StringBuffer)),
// filereadstream.h
filereadstream(RAPIDJSON_NEW(FileReadStream(stdout, buffer, sizeof(buffer)))),
// filewritestream.h
filewritestream(RAPIDJSON_NEW(FileWriteStream(stdout, buffer, sizeof(buffer)))),
// memorybuffer.h
memorybuffer(RAPIDJSON_NEW(MemoryBuffer)),
// memorystream.h
memorystream(RAPIDJSON_NEW(MemoryStream(0, 0))),
// reader.h
basereaderhandler(RAPIDJSON_NEW((BaseReaderHandler<UTF8<>, void>))),
reader(RAPIDJSON_NEW(Reader)),
// writer.h
writer(RAPIDJSON_NEW((Writer<StringBuffer>))),
// document.h
value(RAPIDJSON_NEW(Value)),
document(RAPIDJSON_NEW(Document)),
// pointer.h
pointer(RAPIDJSON_NEW(Pointer)),
// schema.h
schemadocument(RAPIDJSON_NEW(SchemaDocument(*document))),
schemavalidator(RAPIDJSON_NEW(SchemaValidator(*schemadocument)))
{
}
Foo::~Foo() {
// encodings.h
RAPIDJSON_DELETE(utf8);
RAPIDJSON_DELETE(utf16);
RAPIDJSON_DELETE(utf16be);
RAPIDJSON_DELETE(utf16le);
RAPIDJSON_DELETE(utf32);
RAPIDJSON_DELETE(utf32be);
RAPIDJSON_DELETE(utf32le);
RAPIDJSON_DELETE(ascii);
RAPIDJSON_DELETE(autoutf);
RAPIDJSON_DELETE(transcoder);
// allocators.h
RAPIDJSON_DELETE(crtallocator);
RAPIDJSON_DELETE(memorypoolallocator);
// stream.h
RAPIDJSON_DELETE(stringstream);
RAPIDJSON_DELETE(insitustringstream);
// stringbuffer.h
RAPIDJSON_DELETE(stringbuffer);
// filereadstream.h
RAPIDJSON_DELETE(filereadstream);
// filewritestream.h
RAPIDJSON_DELETE(filewritestream);
// memorybuffer.h
RAPIDJSON_DELETE(memorybuffer);
// memorystream.h
RAPIDJSON_DELETE(memorystream);
// reader.h
RAPIDJSON_DELETE(basereaderhandler);
RAPIDJSON_DELETE(reader);
// writer.h
RAPIDJSON_DELETE(writer);
// document.h
RAPIDJSON_DELETE(value);
RAPIDJSON_DELETE(document);
// pointer.h
RAPIDJSON_DELETE(pointer);
// schema.h
RAPIDJSON_DELETE(schemadocument);
RAPIDJSON_DELETE(schemavalidator);
}
TEST(Fwd, Fwd) {
Foo f;
}

1
test/unittest/strfunctest.cpp
View File

@ -13,7 +13,6 @@
// specific language governing permissions and limitations under the License.
#include "unittest.h"
#include "rapidjson/internal/strfunc.h"
using namespace rapidjson;