stream.h

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









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_