sl@0: // (C) Copyright Jonathan Turkanis 2003-5.
sl@0: // Distributed under the Boost Software License, Version 1.0. (See accompanying
sl@0: // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt.)
sl@0: 
sl@0: // See http://www.boost.org/libs/iostreams for documentation.
sl@0: 
sl@0: #ifndef BOOST_IOSTREAMS_DETAIL_BUFFERS_HPP_INCLUDED
sl@0: #define BOOST_IOSTREAMS_DETAIL_BUFFERS_HPP_INCLUDED
sl@0: 
sl@0: #if defined(_MSC_VER) && (_MSC_VER >= 1020)
sl@0: # pragma once
sl@0: #endif              
sl@0: 
sl@0: #include <algorithm>                           // swap.
sl@0: #include <memory>                              // allocator.
sl@0: #include <boost/config.hpp>                    // member templates.
sl@0: #include <boost/iostreams/char_traits.hpp>
sl@0: #include <boost/iostreams/detail/ios.hpp>      // streamsize.
sl@0: #include <boost/iostreams/read.hpp>
sl@0: #include <boost/iostreams/traits.hpp>          // int_type_of.
sl@0: #include <boost/iostreams/checked_operations.hpp>
sl@0: #include <boost/mpl/if.hpp>
sl@0: #include <boost/type_traits/is_same.hpp>
sl@0: 
sl@0: namespace boost { namespace iostreams { namespace detail {
sl@0: 
sl@0: //----------------Buffers-----------------------------------------------------//
sl@0: 
sl@0: //
sl@0: // Template name: buffer
sl@0: // Description: Character buffer.
sl@0: // Template paramters:
sl@0: //     Ch - The character type.
sl@0: //     Alloc - The Allocator type.
sl@0: //
sl@0: template< typename Ch,
sl@0:           typename Alloc = std::allocator<Ch> >
sl@0: class basic_buffer {
sl@0: private:
sl@0: #ifndef BOOST_NO_STD_ALLOCATOR
sl@0:     typedef typename Alloc::template rebind<Ch>::other allocator_type;
sl@0: #else
sl@0:     typedef std::allocator<Ch> allocator_type;
sl@0: #endif
sl@0: public:
sl@0:     basic_buffer();
sl@0:     basic_buffer(int buffer_size);
sl@0:     ~basic_buffer();
sl@0:     void resize(int buffer_size);
sl@0:     Ch* begin() const { return buf_; }
sl@0:     Ch* end() const { return buf_ + size_; }
sl@0:     Ch* data() const { return buf_; }
sl@0:     std::streamsize size() const { return size_; }
sl@0:     void swap(basic_buffer& rhs);
sl@0: private:
sl@0:     // Disallow copying and assignment.
sl@0:     basic_buffer(const basic_buffer&);
sl@0:     basic_buffer& operator=(const basic_buffer&);
sl@0:     Ch*              buf_;
sl@0:     std::streamsize  size_;
sl@0: };
sl@0: 
sl@0: template<typename Ch, typename Alloc>
sl@0: void swap(basic_buffer<Ch, Alloc>& lhs, basic_buffer<Ch, Alloc>& rhs)
sl@0: { lhs.swap(rhs); }
sl@0: 
sl@0: //
sl@0: // Template name: buffer
sl@0: // Description: Character buffer with two pointers accessible via ptr() and
sl@0: //      eptr().
sl@0: // Template paramters:
sl@0: //     Ch - A character type.
sl@0: //
sl@0: template< typename Ch,
sl@0:           typename Alloc = std::allocator<Ch> >
sl@0: class buffer : public basic_buffer<Ch, Alloc> {
sl@0: private:
sl@0:     typedef basic_buffer<Ch, Alloc> base;
sl@0: public:
sl@0:     typedef iostreams::char_traits<Ch> traits_type;
sl@0:     using base::resize; 
sl@0:     using base::data; 
sl@0:     using base::size;
sl@0:     typedef Ch* const const_pointer;
sl@0:     buffer(int buffer_size);
sl@0:     Ch* & ptr() { return ptr_; }
sl@0:     const_pointer& ptr() const { return ptr_; }
sl@0:     Ch* & eptr() { return eptr_; }
sl@0:     const_pointer& eptr() const { return eptr_; }
sl@0:     void set(std::streamsize ptr, std::streamsize end);
sl@0:     void swap(buffer& rhs);
sl@0: 
sl@0:     // Returns an int_type as a status code.
sl@0:     template<typename Source>
sl@0:     typename int_type_of<Source>::type fill(Source& src) 
sl@0:     {
sl@0:         using namespace std;
sl@0:         streamsize keep;
sl@0:         if ((keep = static_cast<streamsize>(eptr_ - ptr_)) > 0)
sl@0:             traits_type::move(this->data(), ptr_, keep);
sl@0:         set(0, keep);
sl@0:         streamsize result = 
sl@0:             iostreams::read(src, this->data() + keep, this->size() - keep);
sl@0:         if (result != -1)
sl@0:             this->set(0, keep + result);
sl@0:         //return result == this->size() - keep ?
sl@0:         //    traits_type::good() :
sl@0:         //    keep == -1 ?
sl@0:         //        traits_type::eof() :
sl@0:         //        traits_type::would_block();
sl@0:         return result == -1 ?
sl@0:             traits_type::eof() :
sl@0:                 result == 0 ?
sl@0:                     traits_type::would_block() :
sl@0:                     traits_type::good();
sl@0: 
sl@0:     }
sl@0: 
sl@0:     // Returns true if one or more characters were written.
sl@0:     template<typename Sink>
sl@0:     bool flush(Sink& dest) 
sl@0:     {
sl@0:         using namespace std;
sl@0:         streamsize amt = static_cast<std::streamsize>(eptr_ - ptr_);
sl@0:         streamsize result = iostreams::write_if(dest, ptr_, amt);
sl@0:         if (result < amt) {
sl@0:             traits_type::move( this->data(), 
sl@0:                                ptr_ + result, 
sl@0:                                amt - result );
sl@0:         }
sl@0:         this->set(0, amt - result);
sl@0:         return result != 0;
sl@0:     }
sl@0: private:
sl@0:     Ch *ptr_, *eptr_;
sl@0: };
sl@0: 
sl@0: template<typename Ch, typename Alloc>
sl@0: void swap(buffer<Ch, Alloc>& lhs, buffer<Ch, Alloc>& rhs)
sl@0: { lhs.swap(rhs); }
sl@0: 
sl@0: //--------------Implementation of basic_buffer--------------------------------//
sl@0: 
sl@0: template<typename Ch, typename Alloc>
sl@0: basic_buffer<Ch, Alloc>::basic_buffer() : buf_(0), size_(0) { }
sl@0: 
sl@0: template<typename Ch, typename Alloc>
sl@0: basic_buffer<Ch, Alloc>::basic_buffer(int buffer_size)
sl@0:     : buf_(static_cast<Ch*>(allocator_type().allocate(buffer_size, 0))), 
sl@0:       size_(buffer_size) // Cast for SunPro 5.3.
sl@0:     { }
sl@0: 
sl@0: template<typename Ch, typename Alloc>
sl@0: inline basic_buffer<Ch, Alloc>::~basic_buffer()
sl@0: { if (buf_) allocator_type().deallocate(buf_, size_); }
sl@0: 
sl@0: template<typename Ch, typename Alloc>
sl@0: inline void basic_buffer<Ch, Alloc>::resize(int buffer_size)
sl@0: {
sl@0:     if (size_ != buffer_size) {
sl@0:         basic_buffer<Ch, Alloc> temp(buffer_size);
sl@0:         std::swap(size_, temp.size_);
sl@0:         std::swap(buf_, temp.buf_);
sl@0:     }
sl@0: }
sl@0: 
sl@0: template<typename Ch, typename Alloc>
sl@0: void basic_buffer<Ch, Alloc>::swap(basic_buffer& rhs) 
sl@0: { 
sl@0:     std::swap(buf_, rhs.buf_); 
sl@0:     std::swap(size_, rhs.size_); 
sl@0: }
sl@0: 
sl@0: //--------------Implementation of buffer--------------------------------------//
sl@0: 
sl@0: template<typename Ch, typename Alloc>
sl@0: buffer<Ch, Alloc>::buffer(int buffer_size)
sl@0:     : basic_buffer<Ch, Alloc>(buffer_size) { }
sl@0: 
sl@0: template<typename Ch, typename Alloc>
sl@0: inline void buffer<Ch, Alloc>::set(std::streamsize ptr, std::streamsize end)
sl@0: { 
sl@0:     ptr_ = data() + ptr; 
sl@0:     eptr_ = data() + end; 
sl@0: }
sl@0: 
sl@0: template<typename Ch, typename Alloc>
sl@0: inline void buffer<Ch, Alloc>::swap(buffer& rhs) 
sl@0: { 
sl@0:     base::swap(rhs); 
sl@0:     std::swap(ptr_, rhs.ptr_); 
sl@0:     std::swap(eptr_, rhs.eptr_); 
sl@0: }
sl@0: 
sl@0: //----------------------------------------------------------------------------//
sl@0: 
sl@0: } } } // End namespaces detail, iostreams, boost.
sl@0: 
sl@0: #endif // #ifndef BOOST_IOSTREAMS_DETAIL_BUFFERS_HPP_INCLUDED