stream.h Source File

stream.h Source File#

Composable Kernel: stream.h Source 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
    Ch Peek() const;
    Ch Take();
    size_t Tell();
    Ch* PutBegin();
    void Put(Ch c);
    void Flush();
    size_t PutEnd(Ch* begin);
}
\endcode
*/
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_