Function fill_buffer

include/jsoncons/source.hpp:80–416

    template <typename CharT,typename Allocator = std::allocator<CharT>>
    class stream_source
    {
    public:
        using value_type = CharT;
        static constexpr std::size_t default_max_buffer_size = 16384;
    private:
        using char_type = typename std::conditional<sizeof(CharT) == sizeof(char),char,CharT>::type;
        using char_allocator_type = typename std::allocator_traits<Allocator>:: template rebind_alloc<value_type>;

        Allocator alloc_;
        basic_null_istream<char_type> null_is_;
        std::basic_istream<char_type>* stream_ptr_;
        std::basic_streambuf<char_type>* sbuf_;
        std::size_t position_{0};
        value_type* buffer_{nullptr};
        std::size_t buffer_size_{0};
        value_type* data_{nullptr};
        std::size_t length_{0};
    public:

        const Allocator& get_allocator() const
        {
            return alloc_;
        }

        stream_source(const Allocator& alloc = Allocator())
            : alloc_(alloc), stream_ptr_(&null_is_), sbuf_(null_is_.rdbuf())
        {
        }

        // Noncopyable 
        stream_source(const stream_source&) = delete;

        stream_source(stream_source&& other) noexcept
            : alloc_(other.alloc_), stream_ptr_(&null_is_), sbuf_(null_is_.rdbuf())
        {
            buffer_ = other.buffer_;
            data_ = other.data_;
            buffer_size_ = other.buffer_size_;
            length_ = other.length_;
            other.buffer_ = nullptr;
            other.data_ = nullptr;
            other.buffer_size_ = 0;
            other.length_ = 0;

            if (other.stream_ptr_ != &other.null_is_)
            {
                stream_ptr_ = other.stream_ptr_;
                sbuf_ = other.sbuf_;
                position_ = other.position_;
                other.stream_ptr_ = &other.null_is_;
                other.sbuf_ = other.null_is_.rdbuf();
                other.position_ = 0;
            }
        }

        stream_source(stream_source&& other, const Allocator& alloc) noexcept
            : alloc_(alloc), stream_ptr_(&null_is_), sbuf_(null_is_.rdbuf()),