External/fmt
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add support for back_insert_iterator

Browse Source
This commit is contained in:
Victor Zverovich 2018-01-14 12:25:03 -08:00
parent 91ee9c9acd
commit 9a53a706fc
11 changed files with 124 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -83,7 +83,7 @@ endfunction()
# Define the fmt library, its includes and the needed defines.
# format.cc is added to FMT_HEADERS for the header-only configuration.
add_headers(FMT_HEADERS core.h format.h format.cc locale.h ostream.h printf.h
string.h time.h)
time.h)
if (HAVE_OPEN)
add_headers(FMT_HEADERS posix.h)
add_headers(FMT_SOURCES posix.cc)

34
include/fmt/core.h
View File

@ -176,6 +176,18 @@ class basic_string_view {
using string_view = basic_string_view<char>;
using wstring_view = basic_string_view<wchar_t>;
template <typename Context>
class basic_arg;
template <typename Context>
class basic_format_args;
// A formatter for objects of type T.
template <typename T, typename Char = char, typename Enable = void>
struct formatter;
namespace internal {
/** A contiguous memory buffer with an optional growing ability. */
template <typename T>
class basic_buffer {
@ -253,21 +265,6 @@ class basic_buffer {
const T &operator[](std::size_t index) const { return ptr_[index]; }
};
using buffer = basic_buffer<char>;
using wbuffer = basic_buffer<wchar_t>;
template <typename Context>
class basic_arg;
template <typename Context>
class basic_format_args;
// A formatter for objects of type T.
template <typename T, typename Char = char, typename Enable = void>
struct formatter;
namespace internal {
// A helper function to suppress bogus "conditional expression is constant"
// warnings.
template <typename T>
@ -583,7 +580,7 @@ class value {
typename Context::template formatter_type<T> f;
auto &&parse_ctx = ctx.parse_context();
parse_ctx.advance_to(f.parse(parse_ctx));
ctx.advance_to(f.format(*static_cast<const T*>(arg), ctx));
f.format(*static_cast<const T*>(arg), ctx);
}
};
@ -797,7 +794,7 @@ class context_base {
Range range() { return range_; }
// Returns an iterator to the beginning of the output range.
iterator begin() { return out_; }
auto begin() { return std::back_inserter(range_.container()); }
// Advances the begin iterator to ``it``.
void advance_to(iterator it) { out_ = it; }
@ -878,6 +875,9 @@ class basic_context :
format_arg get_arg(basic_string_view<char_type> name);
};
using buffer = internal::basic_buffer<char>;
using wbuffer = internal::basic_buffer<wchar_t>;
using context = basic_context<internal::dynamic_range<buffer>>;
using wcontext = basic_context<internal::dynamic_range<wbuffer>>;

106
include/fmt/format.h
View File

@ -31,6 +31,7 @@
#include <cassert>
#include <cmath>
#include <cstring>
#include <iterator>
#include <limits>
#include <memory>
#include <stdexcept>
@ -296,17 +297,6 @@ inline stdext::checked_array_iterator<T*> make_ptr(T *ptr, std::size_t size) {
template <typename T>
inline T *make_ptr(T *ptr, std::size_t) { return ptr; }
#endif
} // namespace internal
// A wrapper around std::locale used to reduce compile times since <locale>
// is very heavy.
class locale;
class locale_provider {
public:
virtual ~locale_provider() {}
virtual fmt::locale locale();
};
template <typename T>
template <typename U>
@ -318,10 +308,32 @@ void basic_buffer<T>::append(const U *begin, const U *end) {
size_ = new_size;
}
template <typename Char>
inline std::basic_string<Char> to_string(const basic_buffer<Char>& buffer) {
return std::basic_string<Char>(buffer.data(), buffer.size());
}
template <typename Container>
class container_buffer
: public internal::basic_buffer<typename Container::value_type> {
private:
Container &container_;
protected:
virtual void grow(std::size_t capacity) {
container_.resize(capacity);
this->set(&container_[0], capacity);
}
public:
explicit container_buffer(Container &c) : container_(c) {}
};
} // namespace internal
// A wrapper around std::locale used to reduce compile times since <locale>
// is very heavy.
class locale;
class locale_provider {
public:
virtual ~locale_provider() {}
virtual fmt::locale locale();
};
/**
\rst
@ -354,7 +366,7 @@ inline std::basic_string<Char> to_string(const basic_buffer<Char>& buffer) {
*/
template <typename T, std::size_t SIZE = internal::INLINE_BUFFER_SIZE,
typename Allocator = std::allocator<T> >
class basic_memory_buffer : private Allocator, public basic_buffer<T> {
class basic_memory_buffer: private Allocator, public internal::basic_buffer<T> {
private:
T store_[SIZE];
@ -453,7 +465,7 @@ typedef basic_memory_buffer<wchar_t> wmemory_buffer;
\endrst
*/
template <typename Char>
class basic_fixed_buffer : public basic_buffer<Char> {
class basic_fixed_buffer : public internal::basic_buffer<Char> {
public:
/**
\rst
@ -2790,7 +2802,7 @@ struct formatter<
}
template <typename FormatContext>
typename FormatContext::iterator format(const T &val, FormatContext &ctx) {
auto format(const T &val, FormatContext &ctx) -> decltype(ctx.begin()) {
internal::handle_dynamic_spec<internal::width_checker>(
specs_.width_, specs_.width_ref, ctx);
internal::handle_dynamic_spec<internal::precision_checker>(
@ -2893,9 +2905,9 @@ typename basic_context<Range>::format_arg
/** Formats arguments and writes the output to the buffer. */
template <typename ArgFormatter, typename Char, typename Context>
void vformat_to(typename ArgFormatter::range out,
basic_string_view<Char> format_str,
basic_format_args<Context> args) {
void do_vformat_to(typename ArgFormatter::range out,
basic_string_view<Char> format_str,
basic_format_args<Context> args) {
using iterator = internal::null_terminating_iterator<Char>;
using range = typename ArgFormatter::range;
@ -2983,32 +2995,64 @@ constexpr fill_spec_factory fill;
constexpr format_spec_factory<width_spec> width;
constexpr format_spec_factory<type_spec> type;
template <typename Range>
inline void vformat_range(Range out, string_view format_str, format_args args) {
vformat_to<arg_formatter<Range>>(out, format_str, args);
/**
\rst
Converts *value* to ``std::string`` using the default format for type *T*.
**Example**::
#include "fmt/string.h"
std::string answer = fmt::to_string(42);
\endrst
*/
template <typename T>
std::string to_string(const T &value) {
std::string str;
internal::container_buffer<std::string> buf(str);
writer(buf).write(value);
return str;
}
template <typename Range, typename... Args>
inline void format_range(Range out, string_view format_str,
const Args & ... args) {
vformat_range(out, format_str, make_args(args...));
template <typename Char>
std::basic_string<Char> to_string(const basic_memory_buffer<Char> &buffer) {
return std::basic_string<Char>(buffer.data(), buffer.size());
}
inline void vformat_to(buffer &buf, string_view format_str, format_args args) {
using range = internal::dynamic_range<buffer>;
vformat_to<arg_formatter<range>>(buf, format_str, args);
do_vformat_to<arg_formatter<range>>(buf, format_str, args);
}
inline void vformat_to(wbuffer &buf, wstring_view format_str,
wformat_args args) {
using range = internal::dynamic_range<wbuffer>;
vformat_to<arg_formatter<range>>(buf, format_str, args);
do_vformat_to<arg_formatter<range>>(buf, format_str, args);
}
template <typename Container>
void vformat_to(std::back_insert_iterator<Container> out,
string_view format_str, format_args args) {
using iterator = std::back_insert_iterator<Container>;
struct container_extractor : iterator {
container_extractor(iterator it) : iterator(it) {}
using iterator::container;
} extractor(out);
internal::container_buffer<Container> buf(*extractor.container);
vformat_to(buf, format_str, args);
}
template <typename Container, typename... Args>
inline void format_to(std::back_insert_iterator<Container> out,
string_view format_str,
const Args & ... args) {
vformat_to(out, format_str, make_args(args...));
}
inline std::string vformat(string_view format_str, format_args args) {
memory_buffer buffer;
vformat_to(buffer, format_str, args);
return to_string(buffer);
return fmt::to_string(buffer);
}
inline std::wstring vformat(wstring_view format_str, wformat_args args) {

6
include/fmt/printf.h
View File

@ -232,8 +232,8 @@ class printf_arg_formatter : public internal::arg_formatter_base<Range> {
specifier information for standard argument types.
\endrst
*/
printf_arg_formatter(basic_buffer<char_type> &buffer, format_specs &spec,
basic_printf_context<Range> &ctx)
printf_arg_formatter(internal::basic_buffer<char_type> &buffer,
format_specs &spec, basic_printf_context<Range> &ctx)
: base(buffer, spec), context_(ctx) {}
using base::operator();
@ -522,7 +522,7 @@ void basic_printf_context<Range, AF>::format() {
}
template <typename Char, typename Context>
void printf(basic_buffer<Char> &buf, basic_string_view<Char> format,
void printf(internal::basic_buffer<Char> &buf, basic_string_view<Char> format,
basic_format_args<Context> args) {
Context(buf, format, args).format();
}

92
include/fmt/string.h
View File

@ -1,92 +0,0 @@
// Formatting library for C++ - string utilities
//
// Copyright (c) 2012 - 2016, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.
#ifndef FMT_STRING_H_
#define FMT_STRING_H_
#include "fmt/format.h"
namespace fmt {
/**
\rst
This class template represents a character buffer backed by std::string.
You can use one of the following typedefs for common character types
and the standard allocator:
+----------------+------------------------------+
| Type | Definition |
+================+==============================+
| string_buffer | basic_string_buffer<char> |
+----------------+------------------------------+
| wstring_buffer | basic_string_buffer<wchar_t> |
+----------------+------------------------------+
**Example**::
string_buffer out;
format_to(out, "The answer is {}", 42);
This will write the following output to the ``out`` object:
.. code-block:: none
The answer is 42
The output can be moved to an ``std::string`` with ``out.move_to()``.
\endrst
*/template <typename Char>
class basic_string_buffer : public basic_buffer<Char> {
private:
std::basic_string<Char> str_;
protected:
virtual void grow(std::size_t capacity) {
str_.resize(capacity);
this->set(&str_[0], capacity);
}
public:
/**
\rst
Moves the buffer content to *str* clearing the buffer.
\endrst
*/
void move_to(std::basic_string<Char> &str) {
str_.resize(this->size());
str.swap(str_);
this->resize(0);
this->set(0, 0);
}
};
typedef basic_string_buffer<char> string_buffer;
typedef basic_string_buffer<wchar_t> wstring_buffer;
/**
\rst
Converts *value* to ``std::string`` using the default format for type *T*.
**Example**::
#include "fmt/string.h"
std::string answer = fmt::to_string(42);
\endrst
*/
template <typename T>
std::string to_string(const T &value) {
string_buffer buf;
writer(buf).write(value);
std::string str;
buf.move_to(str);
return str;
}
}
#endif // FMT_STRING_H_

1
test/CMakeLists.txt
View File

@ -85,7 +85,6 @@ add_fmt_test(format-test)
add_fmt_test(format-impl-test)
add_fmt_test(ostream-test)
add_fmt_test(printf-test)
add_fmt_test(string-test)
add_fmt_test(time-test)
add_fmt_test(util-test mock-allocator.h)
add_fmt_test(custom-formatter-test)

2
test/custom-formatter-test.cc
View File

@ -36,7 +36,7 @@ class CustomArgFormatter :
std::string custom_vformat(fmt::string_view format_str, fmt::format_args args) {
fmt::memory_buffer buffer;
// Pass custom argument formatter as a template arg to vwrite.
fmt::vformat_to<CustomArgFormatter>(buffer, format_str, args);
fmt::do_vformat_to<CustomArgFormatter>(buffer, format_str, args);
return std::string(buffer.data(), buffer.size());
}

21
test/format-test.cc
View File

@ -88,7 +88,7 @@ void std_format(long double value, std::wstring &result) {
template <typename Char, typename T>
::testing::AssertionResult check_write(const T &value, const char *type) {
fmt::basic_memory_buffer<Char> buffer;
using range = fmt::internal::dynamic_range<fmt::basic_buffer<Char>>;
using range = fmt::internal::dynamic_range<fmt::internal::basic_buffer<Char>>;
fmt::basic_writer<range> writer(buffer);
writer.write(value);
std::basic_string<Char> actual = to_string(buffer);
@ -1224,7 +1224,7 @@ struct formatter<Date> {
}
auto format(const Date &d, context &ctx) {
format_range(ctx.range(), "{}-{}-{}", d.year(), d.month(), d.day());
format_to(ctx.begin(), "{}-{}-{}", d.year(), d.month(), d.day());
return ctx.begin();
}
};
@ -1509,7 +1509,7 @@ class mock_arg_formatter :
void custom_vformat(fmt::string_view format_str, fmt::format_args args) {
fmt::memory_buffer buffer;
fmt::vformat_to<mock_arg_formatter>(buffer, format_str, args);
fmt::do_vformat_to<mock_arg_formatter>(buffer, format_str, args);
}
template <typename... Args>
@ -1907,3 +1907,18 @@ TEST(FormatTest, FormatStringErrors) {
"cannot switch from automatic to manual argument indexing",
int, int);
}
TEST(FormatTest, OutputIterator) {
std::string s;
fmt::format_to(std::back_inserter(s), "{}", 42);
std::vector<char> v;
fmt::format_to(std::back_inserter(v), "{}", 42);
EXPECT_EQ("42", s);
EXPECT_EQ("42", std::string(v.begin(), v.end()));
}
TEST(StringTest, ToString) {
EXPECT_EQ("42", fmt::to_string(42));
}

14
test/ostream-test.cc
View File

@ -136,12 +136,12 @@ TEST(OStreamTest, WriteToOStreamMaxSize) {
if (max_size <= fmt::internal::to_unsigned(max_streamsize))
return;
struct TestBuffer : fmt::basic_buffer<char> {
explicit TestBuffer(std::size_t size) { resize(size); }
struct test_buffer : fmt::buffer {
explicit test_buffer(std::size_t size) { resize(size); }
void grow(std::size_t) {}
} buffer(max_size);
struct MockStreamBuf : std::streambuf {
struct mock_streambuf : std::streambuf {
MOCK_METHOD2(xsputn, std::streamsize (const void *s, std::streamsize n));
std::streamsize xsputn(const char *s, std::streamsize n) {
const void *v = s;
@ -149,16 +149,16 @@ TEST(OStreamTest, WriteToOStreamMaxSize) {
}
} streambuf;
struct TestOStream : std::ostream {
explicit TestOStream(MockStreamBuf &buffer) : std::ostream(&buffer) {}
struct test_ostream : std::ostream {
explicit test_ostream(mock_streambuf &buffer) : std::ostream(&buffer) {}
} os(streambuf);
testing::InSequence sequence;
const char *data = 0;
std::size_t size = max_size;
do {
typedef std::make_unsigned<std::streamsize>::type UStreamSize;
UStreamSize n = std::min<UStreamSize>(
typedef std::make_unsigned<std::streamsize>::type ustreamsize;
ustreamsize n = std::min<ustreamsize>(
size, fmt::internal::to_unsigned(max_streamsize));
EXPECT_CALL(streambuf, xsputn(data, static_cast<std::streamsize>(n)))
.WillOnce(testing::Return(max_streamsize));

71
test/string-test.cc
View File

@ -1,71 +0,0 @@
/*
Tests of string utilities
Copyright (c) 2012 - 2016, Victor Zverovich
All rights reserved.
For the license information refer to format.h.
*/
#include "fmt/string.h"
#include "gtest/gtest.h"
using fmt::string_buffer;
TEST(StringBufferTest, Empty) {
string_buffer buffer;
EXPECT_EQ(0u, buffer.size());
EXPECT_EQ(0u, buffer.capacity());
std::string data;
// std::string may have initial capacity.
std::size_t capacity = data.capacity();
buffer.move_to(data);
EXPECT_EQ("", data);
EXPECT_EQ(capacity, data.capacity());
}
TEST(StringBufferTest, Reserve) {
string_buffer buffer;
std::size_t capacity = std::string().capacity() + 10;
buffer.reserve(capacity);
EXPECT_EQ(0u, buffer.size());
EXPECT_EQ(capacity, buffer.capacity());
std::string data;
buffer.move_to(data);
EXPECT_EQ("", data);
}
TEST(StringBufferTest, Resize) {
string_buffer buffer;
std::size_t size = std::string().capacity() + 10;
buffer.resize(size);
EXPECT_EQ(size, buffer.size());
EXPECT_EQ(size, buffer.capacity());
std::string data;
buffer.move_to(data);
EXPECT_EQ(size, data.size());
}
TEST(StringBufferTest, MoveTo) {
string_buffer buffer;
std::size_t size = std::string().capacity() + 10;
buffer.resize(size);
const char *p = &buffer[0];
std::string data;
buffer.move_to(data);
EXPECT_EQ(p, &data[0]);
EXPECT_EQ(0u, buffer.size());
EXPECT_EQ(0u, buffer.capacity());
}
TEST(StringBufferTest, WString) {
fmt::wstring_buffer out;
out.push_back(L'x');
std::wstring s;
out.move_to(s);
EXPECT_EQ(L"x", s);
}
TEST(StringTest, ToString) {
EXPECT_EQ("42", fmt::to_string(42));
}

4
test/util-test.cc
View File

@ -54,7 +54,7 @@
#undef max
using fmt::basic_arg;
using fmt::basic_buffer;
using fmt::internal::basic_buffer;
using fmt::basic_memory_buffer;
using fmt::string_view;
using fmt::internal::value;
@ -192,7 +192,7 @@ TEST(BufferTest, Access) {
EXPECT_EQ(11, buffer[0]);
buffer[3] = 42;
EXPECT_EQ(42, *(&buffer[0] + 3));
const fmt::basic_buffer<char> &const_buffer = buffer;
const basic_buffer<char> &const_buffer = buffer;
EXPECT_EQ(42, const_buffer[3]);
}