Beispiel #1
0
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);
  }
}
Beispiel #2
0
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('}');

        }

    }
Beispiel #4
0
 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);
     }
Beispiel #5
0
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 << '"';
}
Beispiel #6
0
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 << '"';
}
Beispiel #7
0
 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 );
 }
Beispiel #8
0
	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();
 }
Beispiel #10
0
 ///
 /// 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);
 }
Beispiel #11
0
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)
{}
Beispiel #12
0
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));
 }
Beispiel #15
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);
 }
Beispiel #19
0
	void put(CharT c)
	{
		if (p_ < end_buffer_)
		{
			*p_++ = c;
		}
		else
		{
			os_->write(begin_buffer_, (p_-begin_buffer_));
			p_ = begin_buffer_;
			*p_++ = c;
		}
	}
Beispiel #20
0
	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;
		}
	}
Beispiel #21
0
 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;
   }
 }
Beispiel #22
0
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;
}
Beispiel #23
0
 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);
         }
     }
Beispiel #24
0
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;
        }
    }
}
Beispiel #25
0
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;
    }
}
Beispiel #26
0
			explicit basic_obstream(std::basic_ostream<_CharT, _Traits> &out)
				: std::basic_ostream<_CharT, _Traits>(out.rdbuf())
				{  }
Beispiel #27
0
 void flush()
 {
     os_->write(begin_buffer_, (p_ - begin_buffer_));
     p_ = begin_buffer_;
     os_->flush();
 }
Beispiel #28
0
	~buffered_ostream()
	{
		os_->write(begin_buffer_, (p_ - begin_buffer_));
		os_->flush();
	}
Beispiel #29
0
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();
 }