bson_streambuf.hpp

// Copyright 2016 MongoDB Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 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.

#pragma once

#include <boson/config/prelude.hpp>

#include <istream>
#include <ostream>
#include <streambuf>

#include <bsoncxx/builder/stream/document.hpp>
#include <bsoncxx/json.hpp>

namespace boson {
BOSON_INLINE_NAMESPACE_BEGIN

class BOSON_API bson_output_streambuf : public std::streambuf {
   public:
    using document_callback = std::function<void(bsoncxx::document::value)>;

    bson_output_streambuf(document_callback cb);

    int overflow(int ch) override;

    virtual int underflow() override;

   private:
    BOSON_PRIVATE int insert(int ch);
    // A callback that accepts a document::value and returns void.
    document_callback _cb;
    std::unique_ptr<uint8_t, void (*)(std::uint8_t *)> _data;
    size_t _len = 0;
    size_t _bytes_read = 0;
};

class BOSON_API bson_ostream : public std::ostream {
   public:
    bson_ostream(bson_output_streambuf::document_callback cb) : std::ostream(0), bs_buf(cb) {
        this->rdbuf(&bs_buf);
    }

   private:
    // TODO somehow set rdbuf(*sb) to private so people can't change the streambuffer?
    bson_output_streambuf bs_buf;
};

class BOSON_API char_array_streambuf : public std::streambuf {
   public:
    char_array_streambuf(const char *data, size_t len);

   private:
    int underflow() final override;

    // These are necessary since the buffer is not writeable, and thus we cannot call setg()
    int uflow() final override;
    int pbackfail(int ch) final override;
    std::streamsize showmanyc() final override;

    std::streampos seekpos(std::streampos sp,
                           std::ios_base::openmode which = std::ios_base::in |
                                                           std::ios_base::out) final override;

    std::streampos seekoff(std::streamoff off, std::ios_base::seekdir way,
                           std::ios_base::openmode which = std::ios_base::in |
                                                           std::ios_base::out) final override;
    // Pointers to the data buffer.
    const char *const _begin;
    const char *const _end;
    const char *_current;
};

class BOSON_API bson_input_streambuf : public char_array_streambuf {
   public:
    bson_input_streambuf(const bsoncxx::document::view &v);
};

class BOSON_API bson_istream : public std::istream {
   public:
    bson_istream(const bsoncxx::document::view &v) : std::istream(0), bs_buf(v) {
        this->rdbuf(&bs_buf);
    }

   private:
    // TODO somehow set rdbuf(*sb) to private so people can't change the streambuffer?
    bson_input_streambuf bs_buf;
};

BOSON_INLINE_NAMESPACE_END
}  // namespace boson

#include <boson/config/postlude.hpp>