inline void out_quote(std::basic_ostream<Ch, Tr> &out, const C& data, IsSpecial is_special = IsSpecial(), char quote_char='"', char escape_char='\\') {
std::basic_stringstream<Ch, Tr> s;
s << data;
or_true_for_chars<IsSpecial> needs_quote(quote_char, escape_char, is_special);
typedef std::istreambuf_iterator<Ch, Tr> i_iter;
typedef std::ostream_iterator<Ch, Tr> o_iter;
i_iter i(s), end;
bool quote = (std::find_if (i, end, needs_quote) != end);
rewind(s);
if (quote) {
out << quote_char;
for (i_iter i(s); i!=end; ++i) {
Ch c=*i;
if (c == quote_char || c== escape_char)
out.put(escape_char);
out.put(c);
}
out << quote_char;
} else {
// std::copy(i_iter(s),end,o_iter(out));
/*
for (i_iter i(s);i!=end;++i)
out.put(*i);
*/
Ch c;
while (s.get(c))
out.put(c);
}
}
void
print(
std::basic_ostream<
Ch,
Traits
> &_stream,
fcppt::container::tree::object<
Value
> const &_tree,
unsigned const _indent
)
{
for(
unsigned index = 0;
index < _indent;
++index
)
_stream
<< _stream.widen('\t');
_stream
<< _tree.value()
<< _stream.widen('\n');
for(
auto child : _tree
)
fcppt::container::tree::detail::print(
_stream,
child,
_indent + 1u
);
}
void write_json_helper(std::basic_ostream<typename Ptree::char_type> &stream,
const Ptree &pt,
int indent)
{
typedef typename Ptree::char_type Ch;
typedef typename std::basic_string<Ch> Str;
// Value or object or array
if (indent > 0 && pt.empty())
{
// Write value
Str data = create_escapes(pt.template get_own<Str>(), stream.getloc());
stream << Ch('"') << data << Ch('"');
}
else if (indent > 0 && pt.count(Str()) == pt.size())
{
// Write array
stream << Ch('[') << Ch('\n');
typename Ptree::const_iterator it = pt.begin();
for (; it != pt.end(); ++it)
{
stream << Str(4 * (indent + 1), Ch(' '));
write_json_helper(stream, it->second, indent + 1);
if (boost::next(it) != pt.end())
stream << Ch(',');
stream << Ch('\n');
}
stream << Str(4 * indent, Ch(' ')) << Ch(']');
}
else
{
// Write object
stream << Ch('{') << Ch('\n');
typename Ptree::const_iterator it = pt.begin();
for (; it != pt.end(); ++it)
{
stream << Str(4 * (indent + 1), Ch(' '));
stream << Ch('"') << create_escapes(it->first, stream.getloc()) << Ch('"') << Ch(':');
if (it->second.empty())
stream << Ch(' ');
else
stream << Ch('\n') << Str(4 * (indent + 1), Ch(' '));
write_json_helper(stream, it->second, indent + 1);
if (boost::next(it) != pt.end())
stream << Ch(',');
stream << Ch('\n');
}
stream << Str(4 * indent, Ch(' ')) << Ch('}');
}
}
inline void insert_fill_chars(std::basic_ostream<charT, traits>& os, std::size_t n) {
enum { chunk_size = 8 };
charT fill_chars[chunk_size];
std::fill_n(fill_chars, static_cast< std::size_t >(chunk_size), os.fill());
for (; n >= chunk_size && os.good(); n -= chunk_size)
os.write(fill_chars, static_cast< std::size_t >(chunk_size));
if (n > 0 && os.good())
os.write(fill_chars, n);
}
inline void out_string_always_quote(std::basic_ostream<Ch, Tr> &out, S const& s)
{
out << '"';
for (typename S::const_iterator i = s.begin(), e = s.end(); i!=e; ++i) {
char c=*i;
if (c == '"' || c== '\\')
out.put('\\');
out.put(c);
}
out << '"';
}
inline void out_always_quote(std::basic_ostream<Ch, Tr> &out, const C& data) {
std::basic_stringstream<Ch, Tr> s;
s << data;
char c;
out << '"';
while (s.get(c)) {
if (c == '"' || c== '\\')
out.put('\\');
out.put(c);
}
out << '"';
}
void write_ascii(std::basic_ostream<charT, traits>& os) const {
typename std::basic_ostream<charT, traits>::fmtflags save = os.flags();
size_t index_size = (size_t)1 << (num_indexed_chars*2);
for (size_t i = 0; i != index_size; ++i) {
for (index_type j = index[i]; j != index[i+1]; ++j) {
addr_type a = addr[j];
os << "[" << a << " " << string->substr(a, num_indexed_chars) << "]";
}
os << "\n";
}
os.setstate( save );
}
void write(const CharT* s, size_t length)
{
size_t diff = end_buffer_ - p_;
if (diff >= length)
{
std::memcpy(p_, s, length*sizeof(CharT));
p_ += length;
}
else
{
os_->write(begin_buffer_, (p_ - begin_buffer_));
os_->write(s, length);
p_ = begin_buffer_;
}
}
void operator () (T1 x1, T2 x2, T3 x3) const
{
*stream << x1 << separator
<< x2 << separator
<< x3 << '\n';
stream->flush();
}
///
/// Translate message and write to stream \a out, using imbued locale and domain set to the
/// stream
///
void write(std::basic_ostream<char_type> &out) const
{
std::locale const &loc = out.getloc();
int id = ios_info::get(out).domain_id();
string_type buffer;
out << write(loc,id,buffer);
}
basic_csv_ostream<Char, Traits>::basic_csv_ostream
(std::basic_ostream<Char, Traits> & os)
: os_(os)
, delim_(os.widen(COMMA))
, quote_(os.widen(QUOTE))
, first_(true)
{}
basic_csv_ostream<Char, Traits>::basic_csv_ostream
(std::basic_ostream<Char, Traits> & os, char_type delimiter)
: os_(os)
, delim_(delimiter)
, quote_(os.widen(QUOTE))
, first_(true)
{}
void write_info_internal(std::basic_ostream<typename Ptree::char_type> &stream,
const Ptree &pt,
const std::string &filename)
{
write_info_helper(stream, pt, -1);
if (!stream.good())
throw info_parser_error("write error", filename, 0);
}
void write_info_internal(std::basic_ostream<typename Ptree::key_type::value_type> &stream,
const Ptree &pt,
const std::string &filename,
const info_writer_settings<typename Ptree::key_type::value_type> &settings)
{
write_info_helper(stream, pt, -1, settings);
if (!stream.good())
BOOST_PROPERTY_TREE_THROW(info_parser_error("write error", filename, 0));
}
bool validate(std::basic_ostream<Char>& out) const {
typename std::basic_ostream<Char>::streampos current =
out.tellp();
out.seekp(0, std::ios::end);
uint32_t file_size = static_cast<uint32_t>(out.tellp());
out.seekp(current, std::ios::beg);
uint32_t supposed_size =
data_subchunk.size + sizeof(header_type);
if (file_size != supposed_size) {
DBGLOG("There is a difference between the wav file size"
" and the size of data that is written in the"
" header: "
<< file_size << " != " << supposed_size);
return false;
}
return true;
}
void write_json_internal(std::basic_ostream<typename Ptree::char_type> &stream,
const Ptree &pt,
const std::string &filename)
{
if (!verify_json(pt, 0))
throw json_parser_error("ptree contains data that cannot be represented in JSON format", filename, 0);
write_json_helper(stream, pt, 0);
stream << std::endl;
if (!stream.good())
throw json_parser_error("write error", filename, 0);
}
void write_json_internal(std::basic_ostream<typename Ptree::key_type::value_type> &stream,
const Ptree &pt,
const std::string &filename,
bool pretty)
{
if (!verify_json(pt, 0))
BOOST_PROPERTY_TREE_THROW(json_parser_error("ptree contains data that cannot be represented in JSON format", filename, 0));
write_json_helper(stream, pt, 0, pretty);
stream << std::endl;
if (!stream.good())
BOOST_PROPERTY_TREE_THROW(json_parser_error("write error", filename, 0));
}
binary_oarchive_impl(
std::basic_ostream<Elem, Tr> & os,
unsigned int flags
) :
basic_binary_oprimitive<Archive, Elem, Tr>(
* os.rdbuf(),
0 != (flags & no_codecvt)
),
basic_binary_oarchive<Archive>(flags)
{
init(flags);
}
void put(CharT c)
{
if (p_ < end_buffer_)
{
*p_++ = c;
}
else
{
os_->write(begin_buffer_, (p_-begin_buffer_));
p_ = begin_buffer_;
*p_++ = c;
}
}
inline void hex_dump(const void* aData, std::size_t aLength, std::basic_ostream<Elem, Traits>& aStream, std::size_t aWidth = 16)
{
const char* const start = static_cast<const char*>(aData);
const char* const end = start + aLength;
const char* line = start;
while (line != end)
{
aStream.width(4);
aStream.fill('0');
aStream << std::hex << line - start << " : ";
std::size_t lineLength = std::min(aWidth, static_cast<std::size_t>(end - line));
for (std::size_t pass = 1; pass <= 2; ++pass)
{
for (const char* next = line; next != end && next != line + aWidth; ++next)
{
char ch = *next;
switch(pass)
{
case 1:
aStream << (ch < 32 ? '.' : ch);
break;
case 2:
if (next != line)
aStream << " ";
aStream.width(2);
aStream.fill('0');
aStream << std::hex << std::uppercase << static_cast<int>(static_cast<unsigned char>(ch));
break;
}
}
if (pass == 1 && lineLength != aWidth)
aStream << std::string(aWidth - lineLength, ' ');
aStream << " ";
}
aStream << std::endl;
line = line + lineLength;
}
}
void escape_char(std::basic_ostream<Char, Traits> &os, Char c, Char delim) {
const char escape = '\\';
if(c < 32 || c == 0x7f) {
os << escape;
switch(c) {
case '\0': os << os.widen('0'); break;
case '\a': os << os.widen('a'); break;
case '\b': os << os.widen('b'); break;
case '\f': os << os.widen('f'); break;
case '\n': os << os.widen('n'); break;
case '\r': os << os.widen('r'); break;
case '\t': os << os.widen('t'); break;
case '\v': os << os.widen('v'); break;
default: os << os.widen('x') << static_cast<unsigned long>(c);
}
}
else if(c == delim || c == escape) {
os << escape << c;
}
else {
os << c;
}
}
inline bool handle_width(std::basic_ostream<CharT, Traits>& o, const T& t) {
std::streamsize width = o.width();
if(width == 0) return false;
std::basic_ostringstream<CharT, Traits> ss;
ss.copyfmt(o);
ss.tie(0);
ss.width(0);
ss << t;
o << ss.str();
return true;
}
void insert_aligned(std::basic_ostream<charT, traits>& os, const basic_string_ref<charT,traits>& str) {
const std::size_t size = str.size();
const std::size_t alignment_size = static_cast< std::size_t >(os.width()) - size;
const bool align_left = (os.flags() & std::basic_ostream<charT, traits>::adjustfield) == std::basic_ostream<charT, traits>::left;
if (!align_left) {
detail::insert_fill_chars(os, alignment_size);
if (os.good())
os.write(str.data(), size);
}
else {
os.write(str.data(), size);
if (os.good())
detail::insert_fill_chars(os, alignment_size);
}
}
inline void fprint(std::basic_ostream<Elem, Traits>& out, const std::basic_string<Elem, Traits>& str, Args&&... arguments) {
if(sizeof...(arguments) < 1) {
out << str;
return;
}
auto args = std::make_tuple(std::forward<Args>(arguments)...);
string::is_digit cmp;
auto&& length = str.size();
auto&& original_width = out.width();
std::ios_base::fmtflags original_format = out.flags();
auto&& original_precision = out.precision();
for(decltype(str.size()) i = 0; i < length; ++i) {
auto&& c = str[i];
// doesn't start with { so just print it and continue
if(c != out.widen('{')) {
out << c;
continue;
}
// at this point, the character c points to {
// check if we're done printing
if(i + 1 > length) {
out << c;
break;
}
// check the next characters
auto j = i + 1;
unsigned index = 0;
decltype(out.width()) width = 0;
decltype(out.precision()) precision = 0;
auto format = original_format;
// escaped character
if(str[j] == out.widen('{')) {
out << str[i];
i = j;
continue;
}
// now we're at a sane point where we can work with the format string
// check if the next character is a digit
if(cmp(str[j])) {
do {
// since it is, multiply the index
index = (index * 10) + (str[j++] - out.widen('0'));
}
while(j < length && cmp(str[j]));
}
else {
// since it isn't a digit, it doesn't match our format string
throw std::runtime_error("invalid format string specified");
}
// check if alignment argument exists
if(str[j] == out.widen(',')) {
// check if the next character is valid
if(j + 1 < length) {
// check if the alignment is left or right
if(str[j + 1] == out.widen('-')) {
format |= out.left;
// increment by two to get to the numerical section
j += 2;
}
else {
format |= out.right;
++j;
}
// check if the next character is a digit
if(j < length && cmp(str[j])) {
do {
// since it is, multiply the width
width = (width * 10) + (str[j++] - out.widen('0'));
}
while(j < length && cmp(str[j]));
}
else {
// invalid format string found
throw std::runtime_error("invalid format string specified");
}
}
}
// check if format specifier exists
if(str[j] == out.widen(':')) {
// check if the character is valid
if(j + 1 < length) {
auto&& specifier = str[j + 1];
switch(specifier) {
case 'F':
format |= out.fixed;
break;
case 'O':
format = (format & ~out.basefield) | out.oct;
break;
case 'x':
format = (format & ~out.basefield) | out.hex;
break;
case 'X':
format = (format & ~out.basefield) | out.hex | out.uppercase;
break;
case 'E':
format |= out.scientific | out.uppercase;
break;
case 'e':
format |= out.scientific;
break;
case 'B':
format |= out.boolalpha;
break;
case 'S':
format |= out.showpos;
break;
default:
throw std::runtime_error("no such format specifier found");
break;
}
j += 2;
// handle precision specifier
if(j < length && cmp(str[j])) {
do {
precision = (precision * 10) + (str[j++] - out.widen('0'));
}
while(j < length && cmp(str[j]));
}
}
}
// now that we're done processing, handle the results
if(str[j] == out.widen('}')) {
out.flags(format);
out.width(width);
out.precision(precision);
detail::index_printer(out, index, args);
out.width(original_width);
out.flags(original_format);
out.precision(original_precision);
i = j;
}
}
}
inline void fprint(std::basic_ostream<Char, Trait>& out, const Char* str, Args&&... arguments) {
// %[parameter][flags][width][.precision]verb
// if it's *n$ instead of %n$ then it'll use the specific parameter number
// n starts at 1 to sizeof...(Args)
// at the moment I'm too lazy to do * at all.
auto&& args = std::make_tuple(std::forward<Args>(arguments)...);
stream_state<Char, Trait> original{out};
stream_state<Char, Trait> changed;
printer<Char, Trait> func(out);
const Char percent = out.widen('%');
const Char zero = out.widen('0');
auto&& loc = out.getloc();
size_t index = 0;
size_t position = 0;
bool has_positional = false;
while(*str != 0) {
// not a %
if(!Trait::eq(*str, percent)) {
out << *str++;
continue;
}
// at this point -- *str == '%'
// so just increment it to get to the format-spec
++str;
// escaped %
if(*str && Trait::eq(*str, percent)) {
out << percent;
++str;
continue;
}
// beginning of format-spec
changed = original;
// check for [parameter], i.e. n$
// or a numeric value for [width]
position = parse_integer(str, zero, loc);
// check if it's [parameter] rather than [width]
if(Trait::eq(*str, out.widen('$'))) {
has_positional = true;
++str;
}
// check for [flags]
// they are as follows:
// + - equivalent to std::showpos
// - - left aligns instead of right align, i.e. std::left
// 0 - pad with 0s instead of spaces
// '[char] - pad with [char] instead of spaces
while(*str) {
if(Trait::eq(*str, out.widen('+'))) {
changed.flags |= out.showpos;
}
else if(Trait::eq(*str, out.widen('-'))) {
changed.flags |= out.left;
}
else if(Trait::eq(*str, out.widen('0'))) {
changed.fill = out.widen('0');
}
else if(Trait::eq(*str, out.widen('\''))) {
// the next character is unconditionally the fill character
changed.fill = *(++str);
}
else {
// unknown flag, so just exit
break;
}
++str;
}
// check for [width]
changed.width = parse_integer(str, zero, loc);
// check for [precision]
if(Trait::eq(*str, out.widen('.'))) {
changed.precision = parse_integer(++str, zero, loc);
}
size_t final_index = has_positional ? position - 1 : index++;
// check for verb
if(Trait::eq(*str, out.widen('s')) || Trait::eq(*str, out.widen('c'))) {
// do nothing since these don't add any extra format specifiers.
// many of these are provided as a thin compatibility layer for
// the original printf -- albeit strict compatibility is not a requirement here.
}
else if(Trait::eq(*str, out.widen('f')) || Trait::eq(*str, out.widen('F'))) {
changed.flags |= out.fixed;
}
else if(Trait::eq(*str, out.widen('e'))) {
changed.flags |= out.scientific;
}
else if(Trait::eq(*str, out.widen('E'))) {
changed.flags |= out.scientific;
changed.flags |= out.uppercase;
}
else if(Trait::eq(*str, out.widen('g'))) {
changed.flags &= ~out.floatfield;
}
else if(Trait::eq(*str, out.widen('G'))) {
changed.flags &= ~out.floatfield;
changed.flags |= out.uppercase;
}
else if(Trait::eq(*str, out.widen('x')) || Trait::eq(*str, out.widen('p'))) {
changed.flags |= out.hex;
}
else if(Trait::eq(*str, out.widen('X'))) {
changed.flags |= out.hex;
changed.flags |= out.uppercase;
}
else if(Trait::eq(*str, out.widen('d')) || Trait::eq(*str, out.widen('i')) || Trait::eq(*str, out.widen('u'))) {
changed.flags |= out.dec;
}
else if(Trait::eq(*str, out.widen('o'))) {
changed.flags |= out.oct;
}
else {
std::string error = "invalid verb given ";
auto narrowed = out.narrow(*str, 0x00);
if(narrowed == 0x00) {
error.push_back('\'');
error.push_back(narrowed);
error.push_back('\'');
}
else {
error.append(" (unable to convert to char)");
}
throw std::runtime_error(error);
}
changed.apply(out);
apply(args, final_index, func);
original.apply(out);
++str;
}
}
explicit basic_obstream(std::basic_ostream<_CharT, _Traits> &out)
: std::basic_ostream<_CharT, _Traits>(out.rdbuf())
{ }
void flush()
{
os_->write(begin_buffer_, (p_ - begin_buffer_));
p_ = begin_buffer_;
os_->flush();
}
~buffered_ostream()
{
os_->write(begin_buffer_, (p_ - begin_buffer_));
os_->flush();
}
typename
std::enable_if<
mizuiro::color::is_color<
Color
>::value,
std::basic_ostream<
Ch,
Traits
> &
>::type
operator<<(
std::basic_ostream<
Ch,
Traits
> &_stream,
Color const &_color
)
{
_stream
<< _stream.widen('(');
mizuiro::color::for_each_channel(
_color,
[
&_color,
&_stream
](
auto const _channel
)
{
_stream
<<
static_cast<
mizuiro::detail::promote_type<
mizuiro::color::types::channel_value<
mizuiro::color::format::get<
Color
>,
std::remove_const_t<
decltype(
_channel
)
>
>
>
>(
_color.get(
_channel
)
)
<<
// FIXME
_stream.widen(',');
}
);
_stream
<< _stream.widen(')');
return
_stream;
}
void operator () (T1 x1) const
{
*stream << x1 << '\n';
stream->flush();
}