/usr/include/boost/process/detail
Edit: /usr/include/boost/process/detail/basic_cmd.hpp (8074B)
// Copyright (c) 2016 Klemens D. Morgenstern
//
// 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_BASIC_CMD_HPP_
#define BOOST_PROCESS_DETAIL_BASIC_CMD_HPP_
#include
#include
#include
#include
#if defined( BOOST_WINDOWS_API )
#include
#include
#elif defined( BOOST_POSIX_API )
#include
#include
#endif
#include
#include
namespace boost { namespace process { namespace detail {
template
struct exe_setter_
{
typedef Char value_type;
typedef std::basic_string string_type;
string_type exe_;
exe_setter_(string_type && str) : exe_(std::move(str)) {}
exe_setter_(const string_type & str) : exe_(str) {}
};
template<> struct is_wchar_t> : std::true_type {};
template<>
struct char_converter>
{
static exe_setter_ conv(const exe_setter_ & in)
{
return {::boost::process::detail::convert(in.exe_)};
}
};
template<>
struct char_converter>
{
static exe_setter_ conv(const exe_setter_ & in)
{
return {::boost::process::detail::convert(in.exe_)};
}
};
template
struct arg_setter_
{
using value_type = Char;
using string_type = std::basic_string;
std::vector _args;
typedef typename std::vector::iterator iterator;
typedef typename std::vector::const_iterator const_iterator;
template
arg_setter_(Iterator && begin, Iterator && end) : _args(begin, end) {}
template
arg_setter_(Range && str) :
_args(std::begin(str),
std::end(str)) {}
iterator begin() {return _args.begin();}
iterator end() {return _args.end();}
const_iterator begin() const {return _args.begin();}
const_iterator end() const {return _args.end();}
arg_setter_(string_type & str) : _args{{str}} {}
arg_setter_(string_type && s) : _args({std::move(s)}) {}
arg_setter_(const string_type & s) : _args({s}) {}
arg_setter_(const value_type* s) : _args({std::move(s)}) {}
template
arg_setter_(const value_type (&s) [Size]) : _args({s}) {}
};
template<> struct is_wchar_t> : std::true_type {};
template<> struct is_wchar_t> : std::true_type {};
template<>
struct char_converter>
{
static arg_setter_ conv(const arg_setter_ & in)
{
std::vector vec(in._args.size());
std::transform(in._args.begin(), in._args.end(), vec.begin(),
[](const std::wstring & ws)
{
return ::boost::process::detail::convert(ws);
});
return {vec};
}
};
template<>
struct char_converter>
{
static arg_setter_ conv(const arg_setter_ & in)
{
std::vector vec(in._args.size());
std::transform(in._args.begin(), in._args.end(), vec.begin(),
[](const std::string & ws)
{
return ::boost::process::detail::convert(ws);
});
return {vec};
}
};
template<>
struct char_converter>
{
static arg_setter_ conv(const arg_setter_ & in)
{
std::vector vec(in._args.size());
std::transform(in._args.begin(), in._args.end(), vec.begin(),
[](const std::wstring & ws)
{
return ::boost::process::detail::convert(ws);
});
return {vec}; }
};
template<>
struct char_converter>
{
static arg_setter_ conv(const arg_setter_ & in)
{
std::vector vec(in._args.size());
std::transform(in._args.begin(), in._args.end(), vec.begin(),
[](const std::string & ws)
{
return ::boost::process::detail::convert(ws);
});
return {vec};
}
};
using api::exe_cmd_init;
template
struct exe_builder
{
//set by path, because that will not be interpreted as a cmd
bool not_cmd = false;
bool shell = false;
using string_type = std::basic_string;
string_type exe;
std::vector args;
void operator()(const boost::filesystem::path & data)
{
not_cmd = true;
if (exe.empty())
exe = data.native();
else
args.push_back(data.native());
}
void operator()(const string_type & data)
{
if (exe.empty())
exe = data;
else
args.push_back(data);
}
void operator()(const Char* data)
{
if (exe.empty())
exe = data;
else
args.push_back(data);
}
void operator()(shell_) {shell = true;}
void operator()(std::vector && data)
{
if (data.empty())
return;
auto itr = std::make_move_iterator(data.begin());
auto end = std::make_move_iterator(data.end());
if (exe.empty())
{
exe = *itr;
itr++;
}
args.insert(args.end(), itr, end);
}
void operator()(const std::vector & data)
{
if (data.empty())
return;
auto itr = data.begin();
auto end = data.end();
if (exe.empty())
{
exe = *itr;
itr++;
}
args.insert(args.end(), itr, end);
}
void operator()(exe_setter_ && data)
{
not_cmd = true;
exe = std::move(data.exe_);
}
void operator()(const exe_setter_ & data)
{
not_cmd = true;
exe = data.exe_;
}
void operator()(arg_setter_ && data)
{
args.assign(
std::make_move_iterator(data._args.begin()),
std::make_move_iterator(data._args.end()));
}
void operator()(arg_setter_ && data)
{
args.insert(args.end(),
std::make_move_iterator(data._args.begin()),
std::make_move_iterator(data._args.end()));
}
void operator()(const arg_setter_ & data)
{
args.assign(data._args.begin(), data._args.end());
}
void operator()(const arg_setter_ & data)
{
args.insert(args.end(), data._args.begin(), data._args.end());
}
api::exe_cmd_init get_initializer()
{
if (not_cmd || !args.empty())
{
if (shell)
return api::exe_cmd_init::exe_args_shell(std::move(exe), std::move(args));
else
return api::exe_cmd_init::exe_args(std::move(exe), std::move(args));
}
else
if (shell)
return api::exe_cmd_init::cmd_shell(std::move(exe));
else
return api::exe_cmd_init::cmd(std::move(exe));
}
typedef api::exe_cmd_init result_type;
};
template<>
struct initializer_builder>
{
typedef exe_builder type;
};
template<>
struct initializer_builder>
{
typedef exe_builder type;
};
}}}
#endif /* BOOST_PROCESS_DETAIL_EXE_BUILDER_HPP_ */