boostorg/io
1
0
Fork 1
mirror of https://github.com/boostorg/io.git synced 2025-06-25 03:51:36 +02:00
Code Issues Packages Projects Releases Wiki Activity

Update and release the quoted manipulators

Browse Source
This commit is contained in:
Glen Fernandes
2019-12-14 20:11:54 -05:00
parent f47bf89c19
commit 76ee346773
10 changed files with 286 additions and 327 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
doc/io.adoc
View File

@ -13,13 +13,12 @@ Daryle Walker, Beman Dawes, Glen Joseph Fernandes <glenjofe@gmail.com>
:source-language: cpp
:toc: left
The I/O sub-library of Boost helps segregate the large number of Boost headers.
This sub-library should contain various items to use with/for the standard I/O
library.
This library contains various utilities for the standard I/O library.
:leveloffset: +1
include::ios_state.adoc[]
include::quoted.adoc[]
include::ostream_joiner.adoc[]
:leveloffset: -1

2
doc/ios_state.adoc
View File

@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
////
# ios_state, <boost/io/ios_state.hpp>
# IO State Savers, <boost/io/ios_state.hpp>
:toc:
:toc-title:
:idprefix:

2
doc/ostream_joiner.adoc
View File

@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
////
# ostream_joiner, <boost/io/ostream_joiner.hpp>
# Delimited Iterators, <boost/io/ostream_joiner.hpp>
:toc:
:toc-title:
:idprefix:

5
doc/quoted.adoc
View File

@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
////
# quoted, <boost/io/quoted.hpp>
# Quoted Manipulators, <boost/io/quoted.hpp>
:toc:
:toc-title:
:idprefix:
@ -137,3 +137,6 @@ developers mailing list. Participants included Beman Dawes, Rob Stewart,
Alexander Lamaison, Eric Niebler, Vicente Botet, Andrey Semashev,
Phil Richards, and Rob Murray. Eric Niebler's suggestions provided the basis
for the name and form of the templates.
Beman Dawes started the implementation of `quoted()` as a private detail
header. Glen Fernandes updated the implementation and also made it public.

200
include/boost/io/detail/quoted_manip.hpp
View File

@ -1,190 +1,18 @@
// boost/io/quoted_manip.hpp ---------------------------------------------------------//
/*
Copyright 2010 Beman Dawes
// Copyright Beman Dawes 2010
Copyright 2019 Glen Joseph Fernandes
(glenjofe@gmail.com)
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_IO_DETAIL_QUOTED_MANIP_HPP
#define BOOST_IO_DETAIL_QUOTED_MANIP_HPP
// Library home page http://www.boost.org/libs/io
/*
The new implemenation is public in <boost/io/quoted.hpp>
*/
#include <boost/io/quoted.hpp>
//--------------------------------------------------------------------------------------//
#ifndef BOOST_IO_QUOTED_MANIP
#define BOOST_IO_QUOTED_MANIP
#include <iosfwd>
#include <ios>
#include <string>
#include <iterator>
#include <boost/io/ios_state.hpp>
namespace boost
{
namespace io
{
namespace detail { template <class String, class Char> struct quoted_proxy; }
// ------------ public interface ------------------------------------------------//
// manipulator for const std::basic_string&
template <class Char, class Traits, class Alloc>
detail::quoted_proxy<std::basic_string<Char, Traits, Alloc> const &, Char>
quoted(const std::basic_string<Char, Traits, Alloc>& s,
Char escape='\\', Char delim='\"');
// manipulator for non-const std::basic_string&
template <class Char, class Traits, class Alloc>
detail::quoted_proxy<std::basic_string<Char, Traits, Alloc> &, Char>
quoted(std::basic_string<Char, Traits, Alloc>& s,
Char escape='\\', Char delim='\"');
// manipulator for const C-string*
template <class Char>
detail::quoted_proxy<const Char*, Char>
quoted(const Char* s, Char escape='\\', Char delim='\"');
// ----------- implementation details -------------------------------------------//
namespace detail
{
// proxy used as an argument pack
template <class String, class Char>
struct quoted_proxy
{
String string;
Char escape;
Char delim;
quoted_proxy(String s_, Char escape_, Char delim_)
: string(s_), escape(escape_), delim(delim_) {}
private:
// String may be a const type, so disable the assignment operator
quoted_proxy& operator=(const quoted_proxy&); // = deleted
};
// abstract away difference between proxies with const or non-const basic_strings
template <class Char, class Traits, class Alloc>
std::basic_ostream<Char, Traits>&
basic_string_inserter_imp(std::basic_ostream<Char, Traits>& os,
std::basic_string<Char, Traits, Alloc> const & string, Char escape, Char delim)
{
os << delim;
typename std::basic_string<Char, Traits, Alloc>::const_iterator
end_it = string.end();
for (typename std::basic_string<Char, Traits, Alloc>::const_iterator
it = string.begin();
it != end_it;
++it )
{
if (*it == delim || *it == escape)
os << escape;
os << *it;
}
os << delim;
return os;
}
// inserter for const std::basic_string& proxies
template <class Char, class Traits, class Alloc>
inline
std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os,
const quoted_proxy<std::basic_string<Char, Traits, Alloc> const &, Char>& proxy)
{
return basic_string_inserter_imp(os, proxy.string, proxy.escape, proxy.delim);
}
// inserter for non-const std::basic_string& proxies
template <class Char, class Traits, class Alloc>
inline
std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os,
const quoted_proxy<std::basic_string<Char, Traits, Alloc>&, Char>& proxy)
{
return basic_string_inserter_imp(os, proxy.string, proxy.escape, proxy.delim);
}
// inserter for const C-string* proxies
template <class Char, class Traits>
std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os,
const quoted_proxy<const Char*, Char>& proxy)
{
os << proxy.delim;
for (const Char* it = proxy.string;
*it;
++it )
{
if (*it == proxy.delim || *it == proxy.escape)
os << proxy.escape;
os << *it;
}
os << proxy.delim;
return os;
}
// extractor for non-const std::basic_string& proxies
template <class Char, class Traits, class Alloc>
std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& is,
const quoted_proxy<std::basic_string<Char, Traits, Alloc>&, Char>& proxy)
{
proxy.string.clear();
Char c;
is >> c;
if (c != proxy.delim)
{
is.unget();
is >> proxy.string;
return is;
}
{
boost::io::ios_flags_saver ifs(is);
is >> std::noskipws;
for (;;)
{
is >> c;
if (!is.good()) // cope with I/O errors or end-of-file
break;
if (c == proxy.escape)
{
is >> c;
if (!is.good()) // cope with I/O errors or end-of-file
break;
}
else if (c == proxy.delim)
break;
proxy.string += c;
}
}
return is;
}
} // namespace detail
// manipulator implementation for const std::basic_string&
template <class Char, class Traits, class Alloc>
inline detail::quoted_proxy<std::basic_string<Char, Traits, Alloc> const &, Char>
quoted(const std::basic_string<Char, Traits, Alloc>& s, Char escape, Char delim)
{
return detail::quoted_proxy<std::basic_string<Char, Traits, Alloc> const &, Char>
(s, escape, delim);
}
// manipulator implementation for non-const std::basic_string&
template <class Char, class Traits, class Alloc>
inline detail::quoted_proxy<std::basic_string<Char, Traits, Alloc> &, Char>
quoted(std::basic_string<Char, Traits, Alloc>& s, Char escape, Char delim)
{
return detail::quoted_proxy<std::basic_string<Char, Traits, Alloc>&, Char>
(s, escape, delim);
}
// manipulator implementation for const C-string*
template <class Char>
inline detail::quoted_proxy<const Char*, Char>
quoted(const Char* s, Char escape, Char delim)
{
return detail::quoted_proxy<const Char*, Char> (s, escape, delim);
}
} // namespace io
} // namespace boost
#endif // BOOST_IO_QUOTED_MANIP
#endif

152
include/boost/io/quoted.hpp Normal file
View File

@ -0,0 +1,152 @@
/*
Copyright 2010 Beman Dawes
Copyright 2019 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_IO_QUOTED_HPP
#define BOOST_IO_QUOTED_HPP
#include <boost/io/ios_state.hpp>
#include <ios>
#include <iterator>
#include <string>
namespace boost {
namespace io {
namespace detail {
template<class String, class Char>
class quoted_proxy {
public:
quoted_proxy(String string_, Char escape_, Char delim_)
: string(string_)
, escape(escape_)
, delim(delim_) { }
String string;
Char escape;
Char delim;
private:
quoted_proxy& operator=(const quoted_proxy&);
};
template<class Char, class Traits>
inline std::basic_ostream<Char, Traits>&
operator<<(std::basic_ostream<Char, Traits>& os,
const quoted_proxy<const Char*, Char>& proxy)
{
os << proxy.delim;
for (const Char* it = proxy.string; *it; ++it) {
if (*it == proxy.delim || *it == proxy.escape) {
os << proxy.escape;
}
os << *it;
}
os << proxy.delim;
return os;
}
template<class Char, class Traits, class Alloc>
inline std::basic_ostream<Char, Traits>&
quoted_output(std::basic_ostream<Char, Traits>& os,
const std::basic_string<Char, Traits, Alloc>& string, Char escape,
Char delim)
{
os << delim;
typename std::basic_string<Char, Traits,
Alloc>::const_iterator end = string.end();
for (typename std::basic_string<Char, Traits,
Alloc>::const_iterator it = string.begin(); it != end; ++it) {
if (*it == delim || *it == escape) {
os << escape;
}
os << *it;
}
os << delim;
return os;
}
template <class Char, class Traits, class Alloc>
inline std::basic_ostream<Char, Traits>&
operator<<(std::basic_ostream<Char, Traits>& os,
const quoted_proxy<const std::basic_string<Char, Traits, Alloc>&,
Char>& proxy)
{
return boost::io::detail::quoted_output(os, proxy.string, proxy.escape,
proxy.delim);
}
template<class Char, class Traits, class Alloc>
inline std::basic_ostream<Char, Traits>&
operator<<(std::basic_ostream<Char, Traits>& os,
const quoted_proxy<std::basic_string<Char, Traits, Alloc>&, Char>& proxy)
{
return boost::io::detail::quoted_output(os, proxy.string, proxy.escape,
proxy.delim);
}
template<class Char, class Traits, class Alloc>
inline std::basic_istream<Char, Traits>&
operator>>(std::basic_istream<Char, Traits>& is,
const quoted_proxy<std::basic_string<Char, Traits, Alloc>&, Char>& proxy)
{
proxy.string.clear();
Char ch;
if (!(is >> ch).good()) {
return is;
}
if (ch != proxy.delim) {
is.unget();
is >> proxy.string;
return is;
}
{
boost::io::ios_flags_saver ifs(is);
std::noskipws(is);
while ((is >> ch).good() && ch != proxy.delim) {
if (ch == proxy.escape && !(is >> ch).good()) {
break;
}
proxy.string.push_back(ch);
}
}
return is;
}
} /* detail */
template<class Char, class Traits, class Alloc>
inline detail::quoted_proxy<const std::basic_string<Char, Traits, Alloc>&,
Char>
quoted(const std::basic_string<Char, Traits, Alloc>& s, Char escape='\\',
Char delim='\"')
{
return detail::quoted_proxy<const std::basic_string<Char, Traits, Alloc>&,
Char>(s, escape, delim);
}
template<class Char, class Traits, class Alloc>
inline detail::quoted_proxy<std::basic_string<Char, Traits, Alloc>&, Char>
quoted(std::basic_string<Char, Traits, Alloc>& s, Char escape='\\',
Char delim='\"')
{
return detail::quoted_proxy<std::basic_string<Char, Traits, Alloc>&,
Char>(s, escape, delim);
}
template<class Char>
inline detail::quoted_proxy<const Char*, Char>
quoted(const Char* s, Char escape='\\', Char delim='\"')
{
return detail::quoted_proxy<const Char*, Char>(s, escape, delim);
}
} /* io */
} /* boost */
#endif

2
meta/libraries.json
View File

@ -6,7 +6,7 @@
"Beman Dawes",
"Glen Fernandes"
],
"description": "Utilities for using the standard I/O library.",
"description": "Utilities for the standard I/O library.",
"documentation": "doc/html/io.html",
"category": [
"IO"

2
test/Jamfile.v2
View File

@ -10,6 +10,6 @@ import testing ;
run ios_state_unit_test.cpp ;
run ios_state_test.cpp ;
run quoted_manip_test.cpp ;
run quoted_test.cpp ;
run ostream_joiner_test.cpp ;
run make_ostream_joiner_test.cpp ;

133
test/quoted_manip_test.cpp
View File

@ -1,133 +0,0 @@
// libs/io/test/quote_manip_test.cpp ----------------------------------------------- //
// Copyright Beman Dawes 2010
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// Library home page: http://www.boost.org/libs/io
// ---------------------------------------------------------------------------------- //
#include <boost/io/detail/quoted_manip.hpp>
#include <boost/core/lightweight_test.hpp>
#include <iostream>
#include <sstream>
using boost::io::quoted;
using std::string;
using std::wstring;
int main()
{
std::wstringstream wss;
string r; // test results
const string s0("foo");
{
std::stringstream ss;
ss << quoted(s0);
ss >> r;
BOOST_TEST(r == "\"foo\"");
}
{
std::stringstream ss;
ss << quoted(s0);
ss >> quoted(r);
BOOST_TEST(r == "foo");
}
const string s0s("foo bar");
{
std::stringstream ss;
ss << quoted(s0s);
ss >> r;
BOOST_TEST(r == "\"foo");
}
{
std::stringstream ss;
ss << quoted(s0s);
ss >> quoted(r);
BOOST_TEST(r == "foo bar");
}
const string s1("foo\\bar, \" *");
{
std::stringstream ss;
ss << quoted(s1);
ss >> r;
BOOST_TEST(r == "\"foo\\\\bar,");
}
{
std::stringstream ss;
ss << quoted("foo\\bar, \" *");
ss >> r;
BOOST_TEST(r == "\"foo\\\\bar,");
}
{
std::stringstream ss;
ss << quoted(s1);
ss >> quoted(r);
BOOST_TEST(r == s1);
}
{
std::stringstream ss;
ss << quoted(s1.c_str());
ss >> quoted(r);
BOOST_TEST(r == s1);
}
string s2("'Jack & Jill'");
{
std::stringstream ss;
ss << quoted(s2, '&', '\'');
ss >> quoted(r, '&', '\'');
BOOST_TEST(r == s2);
}
wstring ws1(L"foo$bar, \" *");
wstring wr; // test results
{
std::wstringstream wss;
wss << quoted(ws1, L'$');
wss >> quoted(wr, L'$');
BOOST_TEST(wr == ws1);
}
const string s3("const string");
{
std::stringstream ss;
ss << quoted(s3);
ss >> quoted(r);
BOOST_TEST(r == s3);
}
{
// missing end delimiter test
std::stringstream ss;
ss << "\"abc"; // load ss with faulty quoting
ss >> quoted(r); // this loops if istream error/eof not detected
BOOST_TEST(r == "abc");
}
{
// no initial delmiter test
std::stringstream ss;
ss << "abc";
ss >> quoted(r);
BOOST_TEST(r == "abc");
}
{
// no initial delmiter, space in ss
std::stringstream ss;
ss << "abc def";
ss >> quoted(r);
BOOST_TEST(r == "abc");
}
// these should fail to compile because the arguments are const:
// ss >> quoted(s1);
// ss >> quoted("foo");
return boost::report_errors();
}

110
test/quoted_test.cpp Normal file
View File

@ -0,0 +1,110 @@
/*
Copyright 2010 Beman Dawes
Copyright 2019 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#include <boost/io/quoted.hpp>
#include <boost/core/lightweight_test.hpp>
#include <iostream>
#include <sstream>
int main()
{
const std::string s0("foo");
std::string r;
{
std::stringstream ss;
ss << boost::io::quoted(s0);
ss >> r;
BOOST_TEST(r == "\"foo\"");
}
{
std::stringstream ss;
ss << boost::io::quoted(s0);
ss >> boost::io::quoted(r);
BOOST_TEST(r == "foo");
}
const std::string s0s("foo bar");
{
std::stringstream ss;
ss << boost::io::quoted(s0s);
ss >> r;
BOOST_TEST(r == "\"foo");
}
{
std::stringstream ss;
ss << boost::io::quoted(s0s);
ss >> boost::io::quoted(r);
BOOST_TEST(r == "foo bar");
}
const std::string s1("foo\\bar, \" *");
{
std::stringstream ss;
ss << boost::io::quoted(s1);
ss >> r;
BOOST_TEST(r == "\"foo\\\\bar,");
}
{
std::stringstream ss;
ss << boost::io::quoted("foo\\bar, \" *");
ss >> r;
BOOST_TEST(r == "\"foo\\\\bar,");
}
{
std::stringstream ss;
ss << boost::io::quoted(s1);
ss >> boost::io::quoted(r);
BOOST_TEST(r == s1);
}
{
std::stringstream ss;
ss << boost::io::quoted(s1.c_str());
ss >> boost::io::quoted(r);
BOOST_TEST(r == s1);
}
std::string s2("'Jack & Jill'");
{
std::stringstream ss;
ss << boost::io::quoted(s2, '&', '\'');
ss >> boost::io::quoted(r, '&', '\'');
BOOST_TEST(r == s2);
}
const std::wstring ws1(L"foo$bar, \" *");
std::wstring wr;
{
std::wstringstream wss;
wss << boost::io::quoted(ws1, L'$');
wss >> boost::io::quoted(wr, L'$');
BOOST_TEST(wr == ws1);
}
const std::string s3("const string");
{
std::stringstream ss;
ss << boost::io::quoted(s3);
ss >> boost::io::quoted(r);
BOOST_TEST(r == s3);
}
{
std::stringstream ss;
ss << "\"abc";
ss >> boost::io::quoted(r);
BOOST_TEST(r == "abc");
}
{
std::stringstream ss;
ss << "abc";
ss >> boost::io::quoted(r);
BOOST_TEST(r == "abc");
}
{
std::stringstream ss;
ss << "abc def";
ss >> boost::io::quoted(r);
BOOST_TEST(r == "abc");
}
return boost::report_errors();
}