stream.h
1 // Tencent is pleased to support the open source community by making RapidJSON available.
2 //
3 // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
4 //
5 // Licensed under the MIT License (the "License"); you may not use this file except
6 // in compliance with the License. You may obtain a copy of the License at
7 //
8 // http://opensource.org/licenses/MIT
9 //
10 // Unless required by applicable law or agreed to in writing, software distributed
11 // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
12 // CONDITIONS OF ANY KIND, either express or implied. See the License for the
13 // specific language governing permissions and limitations under the License.
14 
15 #include "rapidjson.h"
16 
17 #ifndef RAPIDJSON_STREAM_H_
18 #define RAPIDJSON_STREAM_H_
19 
20 #include "encodings.h"
21 
22 RAPIDJSON_NAMESPACE_BEGIN
23 
24 ///////////////////////////////////////////////////////////////////////////////
25 // Stream
26 
27 /*! \class rapidjson::Stream
28  \brief Concept for reading and writing characters.
29 
30  For read-only stream, no need to implement PutBegin(), Put(), Flush() and PutEnd().
31 
32  For write-only stream, only need to implement Put() and Flush().
33 
34 \code
35 concept Stream {
36  typename Ch; //!< Character type of the stream.
37 
38  //! Read the current character from stream without moving the read cursor.
39  Ch Peek() const;
40 
41  //! Read the current character from stream and moving the read cursor to next character.
42  Ch Take();
43 
44  //! Get the current read cursor.
45  //! \return Number of characters read from start.
46  size_t Tell();
47 
48  //! Begin writing operation at the current read pointer.
49  //! \return The begin writer pointer.
50  Ch* PutBegin();
51 
52  //! Write a character.
53  void Put(Ch c);
54 
55  //! Flush the buffer.
56  void Flush();
57 
58  //! End the writing operation.
59  //! \param begin The begin write pointer returned by PutBegin().
60  //! \return Number of characters written.
61  size_t PutEnd(Ch* begin);
62 }
63 \endcode
64 */
65 
66 //! Provides additional information for stream.
67 /*!
68  By using traits pattern, this type provides a default configuration for stream.
69  For custom stream, this type can be specialized for other configuration.
70  See TEST(Reader, CustomStringStream) in readertest.cpp for example.
71 */
72 template<typename Stream>
73 struct StreamTraits {
74  //! Whether to make local copy of stream for optimization during parsing.
75  /*!
76  By default, for safety, streams do not use local copy optimization.
77  Stream that can be copied fast should specialize this, like StreamTraits<StringStream>.
78  */
79  enum { copyOptimization = 0 };
80 };
81 
82 //! Reserve n characters for writing to a stream.
83 template<typename Stream>
84 inline void PutReserve(Stream& stream, size_t count) {
85  (void)stream;
86  (void)count;
87 }
88 
89 //! Write character to a stream, presuming buffer is reserved.
90 template<typename Stream>
91 inline void PutUnsafe(Stream& stream, typename Stream::Ch c) {
92  stream.Put(c);
93 }
94 
95 //! Put N copies of a character to a stream.
96 template<typename Stream, typename Ch>
97 inline void PutN(Stream& stream, Ch c, size_t n) {
98  PutReserve(stream, n);
99  for (size_t i = 0; i < n; i++)
100  PutUnsafe(stream, c);
101 }
102 
103 ///////////////////////////////////////////////////////////////////////////////
104 // GenericStreamWrapper
105 
106 //! A Stream Wrapper
107 /*! \tThis string stream is a wrapper for any stream by just forwarding any
108  \treceived message to the origin stream.
109  \note implements Stream concept
110 */
111 
112 #if defined(_MSC_VER) && _MSC_VER <= 1800
113 RAPIDJSON_DIAG_PUSH
114 RAPIDJSON_DIAG_OFF(4702) // unreachable code
115 RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
116 #endif
117 
118 template <typename InputStream, typename Encoding = UTF8<> >
120 public:
121  typedef typename Encoding::Ch Ch;
122  GenericStreamWrapper(InputStream& is): is_(is) {}
123 
124  Ch Peek() const { return is_.Peek(); }
125  Ch Take() { return is_.Take(); }
126  size_t Tell() { return is_.Tell(); }
127  Ch* PutBegin() { return is_.PutBegin(); }
128  void Put(Ch ch) { is_.Put(ch); }
129  void Flush() { is_.Flush(); }
130  size_t PutEnd(Ch* ch) { return is_.PutEnd(ch); }
131 
132  // wrapper for MemoryStream
133  const Ch* Peek4() const { return is_.Peek4(); }
134 
135  // wrapper for AutoUTFInputStream
136  UTFType GetType() const { return is_.GetType(); }
137  bool HasBOM() const { return is_.HasBOM(); }
138 
139 protected:
140  InputStream& is_;
141 };
142 
143 #if defined(_MSC_VER) && _MSC_VER <= 1800
144 RAPIDJSON_DIAG_POP
145 #endif
146 
147 ///////////////////////////////////////////////////////////////////////////////
148 // StringStream
149 
150 //! Read-only string stream.
151 /*! \note implements Stream concept
152 */
153 template <typename Encoding>
154 struct GenericStringStream {
155  typedef typename Encoding::Ch Ch;
156 
157  GenericStringStream(const Ch *src) : src_(src), head_(src) {}
158 
159  Ch Peek() const { return *src_; }
160  Ch Take() { return *src_++; }
161  size_t Tell() const { return static_cast<size_t>(src_ - head_); }
162 
163  Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
164  void Put(Ch) { RAPIDJSON_ASSERT(false); }
165  void Flush() { RAPIDJSON_ASSERT(false); }
166  size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
167 
168  const Ch* src_; //!< Current read position.
169  const Ch* head_; //!< Original head of the string.
170 };
171 
172 template <typename Encoding>
174  enum { copyOptimization = 1 };
175 };
176 
177 //! String stream with UTF8 encoding.
179 
180 ///////////////////////////////////////////////////////////////////////////////
181 // InsituStringStream
182 
183 //! A read-write string stream.
184 /*! This string stream is particularly designed for in-situ parsing.
185  \note implements Stream concept
186 */
187 template <typename Encoding>
189  typedef typename Encoding::Ch Ch;
190 
191  GenericInsituStringStream(Ch *src) : src_(src), dst_(0), head_(src) {}
192 
193  // Read
194  Ch Peek() { return *src_; }
195  Ch Take() { return *src_++; }
196  size_t Tell() { return static_cast<size_t>(src_ - head_); }
197 
198  // Write
199  void Put(Ch c) { RAPIDJSON_ASSERT(dst_ != 0); *dst_++ = c; }
200 
201  Ch* PutBegin() { return dst_ = src_; }
202  size_t PutEnd(Ch* begin) { return static_cast<size_t>(dst_ - begin); }
203  void Flush() {}
204 
205  Ch* Push(size_t count) { Ch* begin = dst_; dst_ += count; return begin; }
206  void Pop(size_t count) { dst_ -= count; }
207 
208  Ch* src_;
209  Ch* dst_;
210  Ch* head_;
211 };
212 
213 template <typename Encoding>
215  enum { copyOptimization = 1 };
216 };
217 
218 //! Insitu string stream with UTF8 encoding.
220 
221 RAPIDJSON_NAMESPACE_END
222 
223 #endif // RAPIDJSON_STREAM_H_
Read-only string stream.
Definition: fwd.h:47
void PutReserve(Stream &stream, size_t count)
Reserve n characters for writing to a stream.
Definition: stream.h:84
const Ch * head_
Original head of the string.
Definition: stream.h:169
const Ch * src_
Current read position.
Definition: stream.h:168
Concept for encoding of Unicode characters.
void PutN(FileWriteStream &stream, char c, size_t n)
Implement specialized version of PutN() with memset() for better performance.
Definition: filewritestream.h:94
Concept for reading and writing characters.
common definitions and configuration
A Stream Wrapper.
Definition: stream.h:119
void PutUnsafe(Stream &stream, typename Stream::Ch c)
Write character to a stream, presuming buffer is reserved.
Definition: stream.h:91
#define RAPIDJSON_ASSERT(x)
Assertion.
Definition: rapidjson.h:406
UTFType
Runtime-specified UTF encoding type of a stream.
Definition: encodings.h:603
Provides additional information for stream.
Definition: stream.h:73
A read-write string stream.
Definition: fwd.h:52