/home/Boris/posix_boost_1_36_0/boost/process/posix_child.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_POSIX_CHILD_HPP 
#define BOOST_PROCESS_POSIX_CHILD_HPP 

#include <boost/process/child.hpp> 
#include <boost/process/pistream.hpp> 
#include <boost/process/postream.hpp> 
#include <boost/process/detail/pipe.hpp> 
#include <boost/process/detail/posix_ops.hpp> 
#include <boost/process/detail/stream_info.hpp> 
#include <boost/shared_ptr.hpp> 
#include <boost/assert.hpp> 
#include <map> 
#include <unistd.h> 

namespace boost { 
namespace process { 

class posix_child : public child 
{ 
public: 
    postream &get_input(int desc) const 
    { 
        if (desc == STDIN_FILENO) 
            return posix_child::get_stdin(); 
        else 
        { 
            input_map_t::const_iterator it = input_map_.find(desc); 
            BOOST_ASSERT(it != input_map_.end()); 
            return *it->second; 
        } 
    } 

    pistream &get_output(int desc) const 
    { 
        if (desc == STDOUT_FILENO) 
            return posix_child::get_stdout(); 
        else if (desc == STDERR_FILENO) 
            return posix_child::get_stderr(); 
        else 
        { 
            output_map_t::const_iterator it = output_map_.find(desc); 
            BOOST_ASSERT(it != output_map_.end()); 
            return *it->second; 
        } 
    } 

    posix_child(id_type id, detail::info_map &infoin, detail::info_map &infoout) 
        : child(id, 
        detail::posix_info_locate_pipe(infoin, STDIN_FILENO, false), 
        detail::posix_info_locate_pipe(infoout, STDOUT_FILENO, true), 
        detail::posix_info_locate_pipe(infoout, STDERR_FILENO, true)) 
    { 
        for (detail::info_map::iterator it = infoin.begin(); it != infoin.end(); ++it) 
        { 
            detail::stream_info &si = it->second; 
            if (si.type_ == detail::stream_info::use_pipe) 
            { 
                BOOST_ASSERT(si.pipe_->wend().valid()); 
                boost::shared_ptr<postream> st(new postream(si.pipe_->wend())); 
                input_map_.insert(input_map_t::value_type(it->first, st)); 
            } 
        } 

        for (detail::info_map::iterator it = infoout.begin(); it != infoout.end(); ++it) 
        { 
            detail::stream_info &si = it->second; 
            if (si.type_ == detail::stream_info::use_pipe) 
            { 
                BOOST_ASSERT(si.pipe_->rend().valid()); 
                boost::shared_ptr<pistream> st(new pistream(si.pipe_->rend())); 
                output_map_.insert(output_map_t::value_type(it->first, st)); 
            } 
        } 
    } 

private: 
    typedef std::map<int, boost::shared_ptr<postream> > input_map_t; 

    input_map_t input_map_; 

    typedef std::map<int, boost::shared_ptr<pistream> > output_map_t; 

    output_map_t output_map_; 
}; 

} 
} 

#endif 

---