/home/Boris/posix_boost_1_36_0/boost/process/detail/systembuf.hpp

Go to the documentation of this file.

// 
// Boost.Process 
// ~~~~~~~~~~~~~ 
// 
// Copyright (c) 2006, 2007 Julio M. Merino Vidal 
// Copyright (c) 2008 Boris Schaeling 
// 
// Distributed under the Boost Software License, Version 1.0. (See accompanying 
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 
// 

#ifndef BOOST_PROCESS_DETAIL_SYSTEMBUF_HPP 
#define BOOST_PROCESS_DETAIL_SYSTEMBUF_HPP 

#include <boost/process/config.hpp> 

#if defined(BOOST_POSIX_API) 
#  include <sys/types.h> 
#  include <unistd.h> 
#elif defined(BOOST_WINDOWS_API) 
#  include <windows.h> 
#else 
#  error "Unsupported platform." 
#endif 

#include <boost/noncopyable.hpp> 
#include <boost/scoped_array.hpp> 
#include <boost/assert.hpp> 
#include <streambuf> 
#include <cstddef> 

namespace boost { 
namespace process { 

class postream; 

namespace detail { 

class systembuf : public std::streambuf, public boost::noncopyable 
{ 
    friend class ::boost::process::postream; 

public: 
#if defined(BOOST_PROCESS_DOXYGEN) 

    typedef NativeHandleType handle_type; 
#elif defined(BOOST_POSIX_API) 
    typedef int handle_type; 
#elif defined(BOOST_WINDOWS_API) 
    typedef HANDLE handle_type; 
#endif 

    explicit systembuf(handle_type h, std::size_t bufsize = 8192) 
        : handle_(h), 
        bufsize_(bufsize), 
        read_buf_(new char[bufsize]), 
        write_buf_(new char[bufsize]) 
    { 
#if defined(BOOST_POSIX_API) 
        BOOST_ASSERT(handle_ >= 0); 
#elif defined(BOOST_WINDOWS_API) 
        BOOST_ASSERT(handle_ != INVALID_HANDLE_VALUE); 
#endif 
        BOOST_ASSERT(bufsize_ > 0); 

        setp(write_buf_.get(), write_buf_.get() + bufsize_); 
    } 

protected: 
    virtual int_type underflow() 
    { 
        BOOST_ASSERT(gptr() >= egptr()); 

        bool ok; 
#if defined(BOOST_POSIX_API) 
        ssize_t cnt = ::read(handle_, read_buf_.get(), bufsize_); 
        ok = (cnt != -1 && cnt != 0); 
#elif defined(BOOST_WINDOWS_API) 
        DWORD cnt; 
        BOOL res = ::ReadFile(handle_, read_buf_.get(), bufsize_, &cnt, NULL); 
        ok = (res && cnt > 0); 
#endif 

        if (!ok) 
            return traits_type::eof(); 
        else 
        { 
            setg(read_buf_.get(), read_buf_.get(), read_buf_.get() + cnt); 
            return traits_type::to_int_type(*gptr()); 
        } 
    } 

    virtual int_type overflow(int c) 
    { 
        BOOST_ASSERT(pptr() >= epptr()); 

        if (sync() == -1) 
            return traits_type::eof(); 

        if (!traits_type::eq_int_type(c, traits_type::eof())) 
        { 
            traits_type::assign(*pptr(), c); 
            pbump(1); 
        } 

        return traits_type::not_eof(c); 
    } 

    virtual int sync() 
    { 
#if defined(BOOST_POSIX_API) 
        ssize_t cnt = pptr() - pbase(); 
#elif defined(BOOST_WINDOWS_API) 
        long cnt = pptr() - pbase(); 
#endif 

        bool ok; 
#if defined(BOOST_POSIX_API) 
        ok = ::write(handle_, pbase(), cnt) == cnt; 
#elif defined(BOOST_WINDOWS_API) 
        DWORD rcnt; 
        BOOL res = ::WriteFile(handle_, pbase(), cnt, &rcnt, NULL); 
        ok = (res && static_cast<long>(rcnt) == cnt); 
#endif 

        if (ok) 
            pbump(-cnt); 
        return ok ? 0 : -1; 
    } 

private: 
    handle_type handle_; 

    std::size_t bufsize_; 

    boost::scoped_array<char> read_buf_; 

    boost::scoped_array<char> write_buf_; 
}; 

} 
} 
} 

#endif 

---