stream.h

// 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

    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_