std::string ws2s(const std::basic_string<WCHAR> & s) {
size_t slength = (int)s.length() + 1;
size_t len = WideCharToMultiByte(CP_ACP, 0, s.c_str(), slength, 0, 0, 0, 0);
std::string r(len, '\0');
WideCharToMultiByte(CP_ACP, 0, s.c_str(), slength, &r[0], len, 0, 0);
return r;
}
long CMetronomeDlg_RegPersist::OnExportPresetButton(unsigned long const nIgnore1, long const nIgnore2)
{
OPENFILENAME ofn;
TCHAR szE[] = _T("/e \"");
TCHAR szR[] = _T("\" \"HKEY_CURRENT_USER\\Software\\BHBSoftware\\Open Metronome\"");
TCHAR szWholeFile[MAX_PATH + sizeof(szE) + sizeof(szR)] = _T(""); // buffer for file name
TCHAR szFile[255]; // buffer for file name
TCHAR title[255]; //buffer for file title
ZeroMemory(&ofn, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = m_hWnd;
ofn.lpstrFile = szFile;
ofn.lpstrFileTitle = title;
//
// Set lpstrFile[0] to '\0' so that GetOpenFileName does not
// use the contents of szFile to initialize itself.
ofn.lpstrFile[0] = (TCHAR)'\0';
ofn.lpstrDefExt = _T("REG");
ofn.lpstrFileTitle[0] = (TCHAR)'\0';
ofn.nMaxFile = sizeof(szFile);
ofn.nMaxFileTitle = sizeof(title);
#ifdef USE_WEIRD_MIDI
ofn.lpstrFilter = _T("Registry Files (*.REG)\0*.REG\0\0");
#else //USE_WEIRD_WAV
ofn.lpstrFilter = _T("Wave Sound (*.WAV)\0*.WAV\0Registry Files (*.REG)\0*.REG\0\0");
#endif
ofn.nFilterIndex = 1;
ofn.Flags = OFN_OVERWRITEPROMPT;
if(GetSaveFileName(&ofn) == IDOK)
{
std::basic_string<TCHAR> const strFilename(ofn.lpstrFile);
if (_tcsstr(_tcsupr(ofn.lpstrFile), _T(".WAV"))-ofn.lpstrFile == strFilename.length()-4)
{
if (BuildPlayerInstance())
{
if (m_autopTicker.get())
{
m_autopTicker->Export(strFilename.c_str(), m_NumExp);
m_autopTicker = (std::auto_ptr<IBeatBox>) NULL;
}
}
}
#ifndef UNDER_CE
else
{
_tcscpy(szWholeFile, szE);
_tcscat(szWholeFile, strFilename.c_str());
_tcscat(szWholeFile, szR);
ShellExecute(this->m_hWnd, _T("open"), _T("regedit"), szWholeFile, 0, SW_SHOWNORMAL);
}
#endif
}
return 0;
}
void FromFile(const std::basic_string<WCHAR>& pathW)
{
DWORD wtf;
DWORD size;
Translations.clear();
size = GetFileVersionInfoSizeW(pathW.c_str(), &wtf);
if(!size)
return;
data.resize(size);
if(!GetFileVersionInfoW(pathW.c_str(), 0, size, data.data()))
return;
// fixed info (main shit)
VS_FIXEDFILEINFO* ffi = 0;
UINT ffilen = 0;
if(!VerQueryValueW(data.data(), L"\\", (void**)&ffi, &ffilen))
return;
m_a = HIWORD(ffi->dwFileVersionMS);
m_b = LOWORD(ffi->dwFileVersionMS);
m_c = HIWORD(ffi->dwProductVersionLS);
m_d = LOWORD(ffi->dwProductVersionLS);
// Read the list of languages and code pages.
LANGANDCODEPAGE* lpTranslate;
VerQueryValueW(data.data(), L"\\VarFileInfo\\Translation", (LPVOID*)&lpTranslate, &ffilen);
for(unsigned i = 0; i < (ffilen / sizeof(LANGANDCODEPAGE)); i++)
{
Translations.push_back(lpTranslate[i]);
}
}
std::basic_string< char > str_convert< char, wchar_t >( std::basic_string< wchar_t > const & src )
{
std::basic_string< char > dst;
if ( !src.empty() )
{
std::unique_lock< std::mutex > lock( g_conversionMutex );
char * szloc = setlocale( LC_CTYPE, "" );
size_t size = wcstombs( NULL, src.c_str(), 0 ) + 1;
char * buffer = NULL;
{
auto guard = make_block_guard( [&buffer, &size]()
{
buffer = new char[size + 1];
}, [&buffer]()
{
delete [] buffer;
} );
size = std::min( size, wcstombs( buffer, src.c_str(), size ) );
setlocale( LC_CTYPE, szloc );
dst.assign( buffer, buffer + size );
}
}
return dst;
}
inline button_type::type message_box(
HWND hwnd, const std::basic_string<T>& message,
const std::basic_string<T>& title, box_type::type box,
icon_type::type icon, unsigned int default_button, bool show_help)
{
unsigned int type = 0;
type |= detail::box_type_to_mb_box(box);
type |= detail::icon_type_to_mb_icon(icon);
unsigned int max_default_button = button_count_from_box_type(box);
if (show_help)
{
type |= MB_HELP;
max_default_button++;
}
if (default_button > max_default_button)
BOOST_THROW_EXCEPTION(
std::invalid_argument("Default button out-of-range"));
type |= default_to_mb_default(default_button);
int rc = native::message_box(
hwnd, message.c_str(), title.c_str(), type);
if (rc == 0)
BOOST_THROW_EXCEPTION(
boost::enable_error_info(washer::last_error()) <<
boost::errinfo_api_function("MessageBox"));
return detail::mb_button_to_button_type(rc);
}
void TokenizerTest()
{
const std::basic_string<utf16_t> xmlText =
Transcoder::UTF8toUTF16("<token1><token2 />\nhello world.\nhello xml.</token1>");
XMLParser<utf16_t>::Tokenizer tokenizer(xmlText.c_str(), xmlText.c_str() + xmlText.size());
std::basic_string<utf16_t> result = tokenizer.getToken();
CPPUNIT_ASSERT_MESSAGE(Transcoder::UTF16toUTF8(result),
result == Transcoder::UTF8toUTF16("<token1>"));
result = tokenizer.getToken();
CPPUNIT_ASSERT_MESSAGE(Transcoder::UTF16toUTF8(result),
result == Transcoder::UTF8toUTF16("<token2 />"));
result = tokenizer.getToken();
CPPUNIT_ASSERT_MESSAGE(Transcoder::UTF16toUTF8(result),
result == Transcoder::UTF8toUTF16("\nhello world.\nhello xml."));
result = tokenizer.getToken();
CPPUNIT_ASSERT_MESSAGE(Transcoder::UTF16toUTF8(result),
result == Transcoder::UTF8toUTF16("</token1>"));
CPPUNIT_ASSERT(tokenizer.isEof());
result = tokenizer.getToken();
CPPUNIT_ASSERT_MESSAGE(Transcoder::UTF16toUTF8(result),
result == Transcoder::UTF8toUTF16(""));
CPPUNIT_ASSERT(tokenizer.isEof());
}
void test_normc(std::basic_string<Char> orig,std::basic_string<Char> normal,boost::locale::norm_type type)
{
std::locale l = boost::locale::generator().generate("en_US.UTF-8");
TEST(boost::locale::normalize(orig,type,l)==normal);
TEST(boost::locale::normalize(orig.c_str(),type,l)==normal);
TEST(boost::locale::normalize(orig.c_str(),orig.c_str()+orig.size(),type,l)==normal);
}
// if TCHAR is defined as WCHAR, we have to do unicode conversion
void mv(std::string& lhs, const std::basic_string<WCHAR>& rhs) {
auto size_needed = WideCharToMultiByte(CP_UTF8, 0, rhs.c_str(),
static_cast<int>(rhs.size()),
nullptr, 0, nullptr, nullptr);
lhs.resize(size_needed);
WideCharToMultiByte(CP_UTF8, 0, rhs.c_str(), static_cast<int>(rhs.size()),
&lhs[0], size_needed, nullptr, nullptr);
}
/* ------------------------------------------------------------------------- */
void associate(const std::basic_string<TCHAR>& key, const std::basic_string<TCHAR>& value, bool flag) {
static const TCHAR* clsid_associate = _T("{F3DB85F4-4731-4e80-BC2E-754A7320D830}");
static const TCHAR* clsid_tooltip = _T("{00021500-0000-0000-C000-000000000046}");
HKEY subkey;
LONG status = RegOpenKeyEx(HKEY_CLASSES_ROOT, ( key + _T( "\\shellex" ) ).c_str(), 0, KEY_ALL_ACCESS, &subkey );
if( !status ) {
RegDeleteKeyNT( subkey, clsid_tooltip );
RegCloseKey( subkey );
}
if (flag) {
DWORD disposition = 0;
LONG status = RegCreateKeyEx(HKEY_CLASSES_ROOT, key.c_str(), 0, _T(""), REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &subkey, &disposition);
if (!status) {
TCHAR buffer[32] = {};
DWORD type = 0;
DWORD size = sizeof(buffer);
if (RegQueryValueEx(subkey, _T(""), NULL, &type, (LPBYTE)buffer, &size) == ERROR_SUCCESS && std::basic_string<TCHAR>(buffer) != value) {
RegSetValueEx(subkey, CUBEICE_REG_PREVARCHIVER, 0, REG_SZ, (CONST BYTE*)buffer, (_tcslen(buffer) + 1) * sizeof(TCHAR));
}
RegSetValueEx(subkey, _T(""), 0, REG_SZ, (CONST BYTE*)value.c_str(), (value.size() + 1) * sizeof(TCHAR));
disposition = 0;
status = RegCreateKeyEx(HKEY_CLASSES_ROOT, ( key + _T( "\\shellex\\") + clsid_tooltip ).c_str(), 0, _T(""), REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &subkey, &disposition);
if (!status) {
RegSetValueEx(subkey, _T(""), 0, REG_SZ, (CONST BYTE*)clsid_associate, (_tcslen(clsid_associate) + 1) * sizeof(TCHAR));
}
}
}
else {
LONG status = RegOpenKeyEx(HKEY_CLASSES_ROOT, key.c_str(), 0, KEY_ALL_ACCESS, &subkey);
if (!status) {
TCHAR buffer[32] = {};
DWORD type = 0;
DWORD size = sizeof(buffer);
if (RegQueryValueEx(subkey, _T(""), NULL, &type, (LPBYTE)buffer, &size) == ERROR_SUCCESS && std::basic_string<TCHAR>(buffer) == value) {
TCHAR prev[32] = {};
type = 0;
size = sizeof(prev);
if (RegQueryValueEx(subkey, CUBEICE_REG_PREVARCHIVER, NULL, &type, (LPBYTE)prev, &size) == ERROR_SUCCESS) {
RegSetValueEx(subkey, _T(""), 0, REG_SZ, (CONST BYTE*)prev, (_tcslen(prev) + 1) * sizeof(TCHAR));
}
else {
RegCloseKey(subkey);
RegDeleteKeyNT(HKEY_CLASSES_ROOT, key.c_str());
}
}
}
}
}
Error ShellExecute(const std::basic_string<charT, traits, Allocator>& fileName = std::basic_string<charT, traits, Allocator>(),
const std::basic_string<charT, traits, Allocator>& operation = std::basic_string<charT, traits, Allocator>(),
const std::basic_string<charT, traits, Allocator>& parameters = std::basic_string<charT, traits, Allocator>(),
const std::basic_string<charT, traits, Allocator>& directory = std::basic_string<charT, traits, Allocator>(),
HWND hwnd = HWND(NULL),
show_command showCmd = show_command_normal)
{
const charT * const file = fileName.c_str();
const charT * const op = operation.empty() ? NULL : operation.c_str();
const charT * const params = parameters.empty() ? NULL : parameters.c_str();
const charT * const dir = directory.empty() ? NULL : directory.c_str();
return ShellExecute(hwnd, op, file, params, dir, showCmd);
}
std::basic_string<CharType> parent_path(const std::basic_string<CharType>& path)
{
auto index = path.size();
if (index)
{
auto str = path.c_str();
for (--index; index > 0; --index)
{
auto c = str[index];
if (c != '\\' && c != '/')
break;
}
for (--index; index > 0; --index)
{
auto c = str[index];
if (c == '\\' || c == '/')
break;
}
}
return index ? path.substr(0, index + 1) : std::basic_string<CharType>();
}
void read_config
(
const std::basic_string<Ch>& a_filename,
basic_variant_tree<Ch>& a_tree,
const boost::function<bool (std::basic_string<Ch>& a_filename)>
a_resolver = inc_file_resolver<Ch>(),
int a_flags = 0,
const std::locale & a_loc = std::locale(),
config_format a_fmt = FORMAT_UNDEFINED
) {
std::basic_string<Ch> ext = boost::filesystem::extension(a_filename);
if (a_fmt == FORMAT_UNDEFINED) {
if (ext == ".config" || ext == ".conf" || ext == ".cfg" || ext == ".scon")
a_fmt = FORMAT_SCON;
else if (ext == ".ini")
a_fmt = FORMAT_INI;
else if (ext == ".xml")
a_fmt = FORMAT_XML;
else
throw std::runtime_error("Configuration file extension not supported!");
}
std::basic_ifstream<Ch> stream(a_filename.c_str());
if (!stream)
throw variant_tree_parser_error(
"cannot open file for reading", a_filename, 0);
stream.imbue(a_loc);
read_config(stream, a_tree, a_fmt, a_filename, a_resolver, a_flags);
}
inline bool string_generate(OutputIterator& sink
, std::basic_string<Char, Traits, Allocator> const& str
, CharEncoding, Tag)
{
return string_generate(sink, str.c_str()
, encoding_filter<CharEncoding, Tag>());
}
/*
* ReportError
*
* Report an error to the user
*/
void ReportError( std::basic_string<TCHAR> message,
DWORD reason)
{
LPTSTR error_string;
if (reason != ERROR_SUCCESS)
{
if (::FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
reason,
0,
(LPTSTR)&error_string,
0,
NULL) != 0)
{
LPTSTR p = _tcschr(error_string, _T('\r'));
if(p != NULL)
{
*p = _T('\0');
}
message += _T(":\n");
message += error_string;
::LocalFree(error_string);
}
}
::MessageBox(NULL,message.c_str(),_T("AES Crypt Error"), MB_OK);
}
inline bool unzip(const BufferT &inBuf, const std::basic_string<TCHAR> &path)
{
auto_zip hz = ::OpenZip(inBuf.first.get(), inBuf.second, ZIP_MEMORY, path.c_str());
if( !hz.IsValid() )
return false;
ZIPENTRYW ze = {0};
HRESULT hRes = ::GetZipItem(hz, -1 ,&ze);
if( hRes != S_OK )
return false;
int numitems = ze.index;
for(int i=0; i != numitems; ++i)
{
hRes = ::GetZipItem(hz,i, &ze);
if( hRes != S_OK )
return false;
hRes = ::UnzipItem(hz, i, ze.name, 0, ZIP_FILENAME);
if( hRes != S_OK )
return false;
}
return true;
}
inline proto::terminal<in_state_tag<char const*> >::type
in_state(std::basic_string<Char, Traits, Allocator> const& s)
{
typename proto::terminal<in_state_tag<Char const*> >::type that =
{{s.c_str()}};
return that;
}
void Build(const wxByte* pat, size_t len)
{
if(m_Pattern.length()==len && IsTheSame(m_Pattern.c_str(), pat, (int)len)) return;
m_Pattern.assign(pat, len);
for(size_t i=0; i<256; ++i) m_Table[i] = (int)len+1;
for(size_t i=0; i<len; ++i) m_Table[pat[i]] = (int)(len-i);
}
static bool IsWiimote(const std::basic_string<TCHAR>& device_path, WinWriteMethod& method)
{
HANDLE dev_handle = CreateFile(device_path.c_str(), GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING,
FILE_FLAG_OVERLAPPED, nullptr);
if (dev_handle == INVALID_HANDLE_VALUE)
return false;
u8 buf[MAX_PAYLOAD];
u8 const req_status_report[] = {WM_SET_REPORT | WM_BT_OUTPUT, WM_REQUEST_STATUS, 0};
int invalid_report_count = 0;
int rc = WriteToHandle(dev_handle, method, req_status_report, sizeof(req_status_report));
while (rc > 0)
{
rc = ReadFromHandle(dev_handle, buf);
if (rc <= 0)
break;
switch (buf[1])
{
case WM_STATUS_REPORT:
return true;
default:
WARN_LOG(WIIMOTE, "IsWiimote(): Received unexpected report %02x", buf[1]);
invalid_report_count++;
// If we receive over 15 invalid reports, then this is probably not a Wiimote.
if (invalid_report_count > 15)
return false;
}
}
return false;
}
/// <summary>
/// Grant current process arbitrary privilege
/// </summary>
/// <param name="name">Privilege name</param>
/// <returns>Status</returns>
NTSTATUS Process::GrantPriviledge( const std::basic_string<TCHAR>& name )
{
TOKEN_PRIVILEGES Priv, PrivOld;
DWORD cbPriv = sizeof(PrivOld);
HANDLE hToken;
if (!OpenThreadToken( GetCurrentThread(), TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES, FALSE, &hToken ))
{
if (GetLastError() != ERROR_NO_TOKEN)
return LastNtStatus();
if (!OpenProcessToken( GetCurrentProcess(), TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES, &hToken ))
return LastNtStatus();
}
Priv.PrivilegeCount = 1;
Priv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
LookupPrivilegeValue( NULL, name.c_str(), &Priv.Privileges[0].Luid );
if (!AdjustTokenPrivileges( hToken, FALSE, &Priv, sizeof(Priv), &PrivOld, &cbPriv ))
{
CloseHandle( hToken );
return LastNtStatus();
}
if (GetLastError() == ERROR_NOT_ALL_ASSIGNED)
{
CloseHandle( hToken );
return LastNtStatus();
}
return STATUS_SUCCESS;
}
int do_execute(const std::vector<std::basic_string<CharType>>& args, boost::system::error_code& ec)
{
if (args.empty())
{
ec = make_error_code(executeplus_error::external_process_failed);
return EXIT_FAILURE;
}
const std::basic_string<CharType> application = args.front();
std::basic_ostringstream<CharType> command_line_buffer;
for (auto it = args.begin(); it != args.end(); ++it)
{
if (it != args.begin())
{
command_line_buffer << " ";
}
command_line_buffer << escape_argument_if_needed(*it);
}
std::basic_string<CharType> command_line = command_line_buffer.str();
return create_process(application.c_str(), &command_line[0]);
}
void CPwQualityEst::_EnsureInitialized()
{
if(m_vCharTypes.size() == 0)
{
std::basic_string<WCHAR> strSpecial(PDCS_PRINTASCIISPEC);
if(strSpecial.find(L' ') != strSpecial.npos) { ASSERT(FALSE); }
else strSpecial += L' ';
const std::basic_string<WCHAR> strHigh =
PwCharSet::GetHighAnsiChars().ToString();
m_vCharTypes.push_back(boost::shared_ptr<CQeCharType>(
new CQeCharType(QE_PAT_LOWERALPHA, PDCS_LOWER_CASE, true)));
m_vCharTypes.push_back(boost::shared_ptr<CQeCharType>(
new CQeCharType(QE_PAT_UPPERALPHA, PDCS_UPPER_CASE, true)));
m_vCharTypes.push_back(boost::shared_ptr<CQeCharType>(
new CQeCharType(QE_PAT_DIGIT, PDCS_NUMERIC, true)));
m_vCharTypes.push_back(boost::shared_ptr<CQeCharType>(
new CQeCharType(QE_PAT_SPECIAL, strSpecial.c_str(), false)));
m_vCharTypes.push_back(boost::shared_ptr<CQeCharType>(
new CQeCharType(QE_PAT_HIGH, strHigh.c_str(), false)));
m_vCharTypes.push_back(boost::shared_ptr<CQeCharType>(
new CQeCharType(QE_PAT_OTHER, 0x10000U - (2U * 26U) - 10U -
strSpecial.size() - strHigh.size())));
}
}
void write(std::ostream& stream, const std::basic_string<T>& value)
{
StorageSize size = value.size();
write(stream, size);
stream.write(reinterpret_cast<const char*>(value.c_str()), value.size() * sizeof(T));
// for (auto const & i : value)
// stream << i;
}
STDMETHODIMP_(LPTSTR) CKpUtilitiesImpl::GetQuotedPath(LPCTSTR lpPath)
{
if(lpPath == NULL) return NULL;
const std::basic_string<TCHAR> str = lpPath;
const std::basic_string<TCHAR> strPath = SU_GetQuotedPath(str);
return _TcsSafeDupAlloc(strPath.c_str());
}
static bool matches(
std::basic_string< CharT, StringTraitsT, AllocatorT > const& str,
boost::basic_regex< CharT, ReTraitsT > const& expr,
boost::regex_constants::match_flag_type flags = boost::regex_constants::match_default)
{
const CharT* p = str.c_str();
return boost::regex_match(p, p + str.size(), expr, flags);
}
bool verify_event_log_registry(std::basic_string< CharT > const& reg_key, bool force, registry_params< CharT > const& params)
{
typedef std::basic_string< CharT > string_type;
typedef registry_traits< CharT > registry;
// Open the key
HKEY hkey = 0;
LSTATUS res = registry::open_key(
HKEY_LOCAL_MACHINE,
reg_key.c_str(),
REG_OPTION_NON_VOLATILE,
KEY_READ,
&hkey);
if (res != ERROR_SUCCESS)
return false;
auto_hkey_close hkey_guard(hkey);
if (force)
{
// Verify key values
if (!!params.event_message_file)
{
string_type module_name;
res = registry::get_value(hkey, registry::get_event_message_file_param_name(), module_name);
if (res != ERROR_SUCCESS || module_name != params.event_message_file.get())
return false;
}
if (!!params.category_message_file)
{
string_type module_name;
res = registry::get_value(hkey, registry::get_category_message_file_param_name(), module_name);
if (res != ERROR_SUCCESS || module_name != params.category_message_file.get())
return false;
}
if (!!params.category_count)
{
// Set number of categories
DWORD category_count = 0;
res = registry::get_value(hkey, registry::get_category_count_param_name(), category_count);
if (res != ERROR_SUCCESS || category_count != params.category_count.get())
return false;
}
if (!!params.types_supported)
{
// Set the supported event types
DWORD event_types = 0;
res = registry::get_value(hkey, registry::get_types_supported_param_name(), event_types);
if (res != ERROR_SUCCESS || event_types != params.types_supported.get())
return false;
}
}
return true;
}
inline void register_sink_factory(
std::basic_string< CharT, TraitsT, AllocatorT > const& sink_name,
function1<
shared_ptr< sinks::sink< CharT > >,
std::map< std::basic_string< CharT >, std::basic_string< CharT > > const&
> const& factory)
{
register_sink_factory(sink_name.c_str(), factory);
}
cstr(const std::basic_string<char_type, CharTraits, Allocator>& s)
{
if (s.empty()) {
clear();
} else {
buf_ = s.c_str();
size_ = s.size();
}
}
WinInet(const std::basic_string<TCHAR>& agent, DWORD accessType)
{
handle_ = InternetOpen(agent.c_str(), accessType, NULL, NULL, 0);
if(handle_ == NULL)
{
throw std::exception("InternetOpen failed!");
}
}
inline
void
teststreaming(std::string const& testname,
temporal_type value,
std::basic_string<charT> const& expected_result,
const std::locale& locale)
{
std::basic_stringstream<charT> ss;
ss.imbue(locale);
ss << value;
if (!check(testname, ss.str() == expected_result))
#if !defined(BOOST_NO_STD_WSTRING)
std::wcout << L"Expected: \"" << expected_result.c_str() << L"\"\nGot: \"" << ss.str().c_str() << L"\"" << std::endl;
#else
std::cout << "Expected: \"" << expected_result.c_str() << "\"\nGot: \"" << ss.str().c_str() << L"\"" << std::endl;
#endif
}
inline OutputIterator regex_merge(OutputIterator out,
Iterator first,
Iterator last,
const basic_regex<charT, traits>& e,
const std::basic_string<charT>& fmt,
match_flag_type flags = match_default)
{
return regex_merge(out, first, last, e, fmt.c_str(), flags);
}