/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-composable-kernel/checkouts/develop/include/rapidjson/stream.h Source File

/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-composable-kernel/checkouts/develop/include/rapidjson/stream.h Source File#

Composable Kernel: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-composable-kernel/checkouts/develop/include/rapidjson/stream.h Source File

Go to the documentation of this file.

 // 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.
 //
 // 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
  
  
  
  
  
  
  
  
  
 template <typename Stream>
 struct StreamTraits
 {
  
     enum
     {
         copyOptimization = 0
     };
 };
  
 template <typename Stream>
 inline void PutReserve(Stream& stream, size_t count)
 {
     (void)stream;
     (void)count;
 }
  
 template <typename Stream>
 inline void PutUnsafe(Stream& stream, typename Stream::Ch c)
 {
     stream.Put(c);
 }
  
 template <typename Stream, typename Ch>
 inline void PutN(Stream& stream, Ch c, size_t n)
 {
     PutReserve(stream, n);
     for(size_t i = 0; i < n; i++)
         PutUnsafe(stream, c);
 }
  
 // GenericStreamWrapper
  
  
 #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
  
 template <typename InputStream, typename Encoding = UTF8<>>
 class GenericStreamWrapper
 {
     public:
     typedef typename Encoding::Ch Ch;
     GenericStreamWrapper(InputStream& is) : is_(is) {}
  
     Ch Peek() const { return is_.Peek(); }
     Ch Take() { return is_.Take(); }
     size_t Tell() { return is_.Tell(); }
     Ch* PutBegin() { return is_.PutBegin(); }
     void Put(Ch ch) { is_.Put(ch); }
     void Flush() { is_.Flush(); }
     size_t PutEnd(Ch* ch) { return is_.PutEnd(ch); }
  
     // wrapper for MemoryStream
     const Ch* Peek4() const { return is_.Peek4(); }
  
     // wrapper for AutoUTFInputStream
     UTFType GetType() const { return is_.GetType(); }
     bool HasBOM() const { return is_.HasBOM(); }
  
     protected:
     InputStream& is_;
 };
  
 #if defined(_MSC_VER) && _MSC_VER <= 1800
 RAPIDJSON_DIAG_POP
 #endif
  
 // StringStream
  
  
 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_;  
     const Ch* head_; 
 };
  
 template <typename Encoding>
 struct StreamTraits<GenericStringStream<Encoding>>
 {
     enum
     {
         copyOptimization = 1
     };
 };
  
 typedef GenericStringStream<UTF8<>> StringStream;
  
 // InsituStringStream
  
  
 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
     };
 };
  
 typedef GenericInsituStringStream<UTF8<>> InsituStringStream;
  
 RAPIDJSON_NAMESPACE_END
  
 #endif // RAPIDJSON_STREAM_H_