internal::MemoryBuffer -> basic_memory_buffer

This commit is contained in:
Victor Zverovich 2017-02-18 09:13:12 -08:00
parent 4ec8860783
commit eedfd07f8b
13 changed files with 173 additions and 275 deletions

View File

@ -205,7 +205,7 @@ void format_error_code(buffer &out, int error_code,
void report_error(FormatFunc func, int error_code,
string_view message) FMT_NOEXCEPT {
internal::MemoryBuffer<char> full_message;
memory_buffer full_message;
func(full_message, error_code, message);
// Use Writer::data instead of Writer::c_str to avoid potential memory
// allocation.
@ -217,10 +217,10 @@ void report_error(FormatFunc func, int error_code,
FMT_FUNC void SystemError::init(
int err_code, CStringRef format_str, args args) {
error_code_ = err_code;
internal::MemoryBuffer<char> buf;
format_system_error(buf, err_code, vformat(format_str, args));
memory_buffer buffer;
format_system_error(buffer, err_code, vformat(format_str, args));
std::runtime_error &base = *this;
base = std::runtime_error(to_string(buf));
base = std::runtime_error(to_string(buffer));
}
template <typename T>
@ -382,7 +382,7 @@ FMT_FUNC void internal::format_windows_error(
FMT_FUNC void format_system_error(
buffer &out, int error_code, string_view message) FMT_NOEXCEPT {
FMT_TRY {
internal::MemoryBuffer<char, internal::INLINE_BUFFER_SIZE> buffer;
memory_buffer buffer;
buffer.resize(internal::INLINE_BUFFER_SIZE);
for (;;) {
char *system_message = &buffer[0];
@ -422,7 +422,7 @@ FMT_FUNC void report_windows_error(
#endif
FMT_FUNC void vprint(std::FILE *f, CStringRef format_str, args args) {
internal::MemoryBuffer<char> buffer;
memory_buffer buffer;
vformat_to(buffer, format_str, args);
std::fwrite(buffer.data(), 1, buffer.size(), f);
}
@ -444,7 +444,7 @@ void printf(basic_writer<Char> &w, BasicCStringRef<Char> format,
args args);
FMT_FUNC int vfprintf(std::FILE *f, CStringRef format, printf_args args) {
internal::MemoryBuffer<char> buffer;
memory_buffer buffer;
printf(buffer, format, args);
std::size_t size = buffer.size();
return std::fwrite(

View File

@ -659,13 +659,39 @@ inline std::basic_string<Char> to_string(const basic_buffer<Char>& buffer) {
return std::basic_string<Char>(buffer.data(), buffer.size());
}
namespace internal {
/**
\rst
A dynamically growing memory buffer for trivially copyable/constructible types
with the first SIZE elements stored in the object itself.
// A memory buffer for trivially copyable/constructible types with the first
// SIZE elements stored in the object itself.
template <typename T, std::size_t SIZE = INLINE_BUFFER_SIZE,
You can use one of the following typedefs for common character types:
+----------------+------------------------------+
| Type | Definition |
+================+==============================+
| memory_buffer | basic_memory_buffer<char> |
+----------------+------------------------------+
| wmemory_buffer | basic_memory_buffer<wchar_t> |
+----------------+------------------------------+
**Example**::
memory_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 converted to an ``std::string`` with ``to_string(out)``.
\endrst
*/
//
template <typename T, std::size_t SIZE = internal::INLINE_BUFFER_SIZE,
typename Allocator = std::allocator<T> >
class MemoryBuffer : private Allocator, public basic_buffer<T> {
class basic_memory_buffer : private Allocator, public basic_buffer<T> {
private:
T data_[SIZE];
@ -678,14 +704,14 @@ class MemoryBuffer : private Allocator, public basic_buffer<T> {
void grow(std::size_t size);
public:
explicit MemoryBuffer(const Allocator &alloc = Allocator())
explicit basic_memory_buffer(const Allocator &alloc = Allocator())
: Allocator(alloc), basic_buffer<T>(data_, SIZE) {}
~MemoryBuffer() { deallocate(); }
~basic_memory_buffer() { deallocate(); }
#if FMT_USE_RVALUE_REFERENCES
private:
// Move data from other to this buffer.
void move(MemoryBuffer &other) {
void move(basic_memory_buffer &other) {
Allocator &this_alloc = *this, &other_alloc = other;
this_alloc = std::move(other_alloc);
this->size_ = other.size_;
@ -693,7 +719,7 @@ class MemoryBuffer : private Allocator, public basic_buffer<T> {
if (other.ptr_ == other.data_) {
this->ptr_ = data_;
std::uninitialized_copy(other.data_, other.data_ + this->size_,
make_ptr(data_, this->capacity_));
internal::make_ptr(data_, this->capacity_));
} else {
this->ptr_ = other.ptr_;
// Set pointer to the inline array so that delete is not called
@ -703,11 +729,22 @@ class MemoryBuffer : private Allocator, public basic_buffer<T> {
}
public:
MemoryBuffer(MemoryBuffer &&other) {
/**
\rst
Constructs a :class:`fmt::basic_memory_buffer` object moving the content
of the other object to it.
\endrst
*/
basic_memory_buffer(basic_memory_buffer &&other) {
move(other);
}
MemoryBuffer &operator=(MemoryBuffer &&other) {
/**
\rst
Moves the content of the other ``basic_memory_buffer`` object to this one.
\endrst
*/
basic_memory_buffer &operator=(basic_memory_buffer &&other) {
assert(this != &other);
deallocate();
move(other);
@ -720,14 +757,14 @@ class MemoryBuffer : private Allocator, public basic_buffer<T> {
};
template <typename T, std::size_t SIZE, typename Allocator>
void MemoryBuffer<T, SIZE, Allocator>::grow(std::size_t size) {
void basic_memory_buffer<T, SIZE, Allocator>::grow(std::size_t size) {
std::size_t new_capacity = this->capacity_ + this->capacity_ / 2;
if (size > new_capacity)
new_capacity = size;
T *new_ptr = this->allocate(new_capacity);
// The following code doesn't throw, so the raw pointer above doesn't leak.
std::uninitialized_copy(this->ptr_, this->ptr_ + this->size_,
make_ptr(new_ptr, new_capacity));
internal::make_ptr(new_ptr, new_capacity));
std::size_t old_capacity = this->capacity_;
T *old_ptr = this->ptr_;
this->capacity_ = new_capacity;
@ -739,6 +776,45 @@ void MemoryBuffer<T, SIZE, Allocator>::grow(std::size_t size) {
Allocator::deallocate(old_ptr, old_capacity);
}
typedef basic_memory_buffer<char> memory_buffer;
typedef basic_memory_buffer<wchar_t> wmemory_buffer;
/**
\rst
A fixed-size memory buffer. For a dynamically growing buffer use
:class:`fmt::basic_memory_buffer`.
Trying to increase the buffer size past the initial capacity will throw
``std::runtime_error``.
\endrst
*/
template <typename Char>
class FixedBuffer : public basic_buffer<Char> {
public:
/**
\rst
Constructs a :class:`fmt::FixedBuffer` object for *array* of the
given size.
\endrst
*/
FixedBuffer(Char *array, std::size_t size)
: basic_buffer<Char>(array, size) {}
/**
\rst
Constructs a :class:`fmt::FixedBuffer` object for *array* of the
size known at compile time.
\endrst
*/
template <std::size_t SIZE>
explicit FixedBuffer(Char (&array)[SIZE]) : basic_buffer<Char>(array, SIZE) {}
protected:
FMT_API void grow(std::size_t size);
};
namespace internal {
template <typename Char>
class BasicCharTraits {
public:
@ -1047,7 +1123,7 @@ struct ConvertToInt {
#define FMT_DISABLE_CONVERSION_TO_INT(Type) \
template <> \
struct ConvertToInt<Type> { enum { value = 0 }; }
struct ConvertToInt<Type> { enum { value = 0 }; }
// Silence warnings about convering float to int.
FMT_DISABLE_CONVERSION_TO_INT(float);
@ -2762,108 +2838,6 @@ void basic_writer<Char>::write_double(T value, const format_specs &spec) {
grow_buffer(n);
}
/**
\rst
This class template provides operations for formatting and writing data
into a memory buffer that grows dynamically.
You can use one of the following typedefs for common character types
and the standard allocator:
+---------------+-----------------------------------------------------+
| Type | Definition |
+===============+=====================================================+
| MemoryWriter | BasicMemoryWriter<char, std::allocator<char>> |
+---------------+-----------------------------------------------------+
| WMemoryWriter | BasicMemoryWriter<wchar_t, std::allocator<wchar_t>> |
+---------------+-----------------------------------------------------+
**Example**::
MemoryWriter out;
out << "The answer is " << 42 << "\n";
out.write("({:+f}, {:+f})", -3.14, 3.14);
This will write the following output to the ``out`` object:
.. code-block:: none
The answer is 42
(-3.140000, +3.140000)
The output can be converted to an ``std::string`` with ``out.str()`` or
accessed as a C string with ``out.c_str()``.
\endrst
*/
template <typename Char, typename Allocator = std::allocator<Char> >
class BasicMemoryWriter : public basic_writer<Char> {
private:
internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE, Allocator> buffer_;
public:
explicit BasicMemoryWriter(const Allocator& alloc = Allocator())
: basic_writer<Char>(buffer_), buffer_(alloc) {}
#if FMT_USE_RVALUE_REFERENCES
/**
\rst
Constructs a :class:`fmt::BasicMemoryWriter` object moving the content
of the other object to it.
\endrst
*/
BasicMemoryWriter(BasicMemoryWriter &&other)
: basic_writer<Char>(buffer_), buffer_(std::move(other.buffer_)) {
}
/**
\rst
Moves the content of the other ``BasicMemoryWriter`` object to this one.
\endrst
*/
BasicMemoryWriter &operator=(BasicMemoryWriter &&other) {
buffer_ = std::move(other.buffer_);
return *this;
}
#endif
};
typedef BasicMemoryWriter<char> MemoryWriter;
typedef BasicMemoryWriter<wchar_t> WMemoryWriter;
/**
\rst
A fixed-size memory buffer. For a dynamically growing buffer use
:class:`fmt::internal::MemoryBuffer`.
Trying to increase the buffer size past the initial capacity will throw
``std::runtime_error``.
\endrst
*/
template <typename Char>
class FixedBuffer : public basic_buffer<Char> {
public:
/**
\rst
Constructs a :class:`fmt::FixedBuffer` object for *array* of the
given size.
\endrst
*/
FixedBuffer(Char *array, std::size_t size)
: basic_buffer<Char>(array, size) {}
/**
\rst
Constructs a :class:`fmt::FixedBuffer` object for *array* of the
size known at compile time.
\endrst
*/
template <std::size_t SIZE>
explicit FixedBuffer(Char (&array)[SIZE]) : basic_buffer<Char>(array, SIZE) {}
protected:
FMT_API void grow(std::size_t size);
};
// Reports a system error without throwing an exception.
// Can be used to report errors from destructors.
FMT_API void report_system_error(int error_code,
@ -2959,7 +2933,7 @@ inline void format_to(wbuffer &buf, WCStringRef format_str,
}
inline std::string vformat(CStringRef format_str, args args) {
internal::MemoryBuffer<char> buffer;
memory_buffer buffer;
vformat_to(buffer, format_str, args);
return to_string(buffer);
}
@ -2979,7 +2953,7 @@ inline std::string format(CStringRef format_str, const Args & ... args) {
}
inline std::wstring vformat(WCStringRef format_str, wargs args) {
internal::MemoryBuffer<wchar_t> buffer;
wmemory_buffer buffer;
vformat_to(buffer, format_str, args);
return to_string(buffer);
}

View File

@ -28,7 +28,7 @@ FMT_FUNC void write(std::ostream &os, buffer &buf) {
}
FMT_FUNC void vprint(std::ostream &os, CStringRef format_str, args args) {
internal::MemoryBuffer<char> buffer;
memory_buffer buffer;
vformat_to(buffer, format_str, args);
internal::write(os, buffer);
}

View File

@ -83,7 +83,7 @@ void format_value(basic_buffer<Char> &buffer, const T &value) {
template <typename Char, typename T>
void format_value(basic_buffer<Char> &buf, const T &value,
basic_context<Char> &ctx) {
internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer;
basic_memory_buffer<Char> buffer;
internal::format_value(buffer, value);
basic_string_view<Char> str(buffer.data(), buffer.size());
do_format_arg< arg_formatter<Char> >(

View File

@ -522,7 +522,7 @@ void printf(basic_buffer<Char> &buf, BasicCStringRef<Char> format,
typedef basic_args<printf_context<char>> printf_args;
inline std::string vsprintf(CStringRef format, printf_args args) {
internal::MemoryBuffer<char> buffer;
memory_buffer buffer;
printf(buffer, format, args);
return to_string(buffer);
}
@ -543,7 +543,7 @@ inline std::string sprintf(CStringRef format_str, const Args & ... args) {
inline std::wstring vsprintf(
WCStringRef format, basic_args<printf_context<wchar_t>> args) {
internal::MemoryBuffer<wchar_t> buffer;
wmemory_buffer buffer;
printf(buffer, format, args);
return to_string(buffer);
}
@ -590,7 +590,7 @@ inline int printf(CStringRef format_str, const Args & ... args) {
}
inline int vfprintf(std::ostream &os, CStringRef format_str, printf_args args) {
internal::MemoryBuffer<char> buffer;
memory_buffer buffer;
printf(buffer, format_str, args);
internal::write(os, buffer);
return static_cast<int>(buffer.size());

View File

@ -24,7 +24,7 @@ void format_value(buffer &buf, const std::tm &tm, context &ctx) {
++end;
if (*end != '}')
FMT_THROW(format_error("missing '}' in format string"));
internal::MemoryBuffer<char, internal::INLINE_BUFFER_SIZE> format;
memory_buffer format;
format.append(s, end + 1);
format[format.size() - 1] = '\0';
std::size_t start = buf.size();

View File

@ -46,7 +46,7 @@ class CustomPrintfArgFormatter : public printf_arg_formatter<char> {
};
std::string custom_vformat(fmt::CStringRef format_str, fmt::args args) {
fmt::internal::MemoryBuffer<char> buffer;
fmt::memory_buffer buffer;
// Pass custom argument formatter as a template arg to vwrite.
fmt::vformat_to<CustomArgFormatter>(buffer, format_str, args);
return std::string(buffer.data(), buffer.size());
@ -64,7 +64,7 @@ typedef fmt::printf_context<char, CustomPrintfArgFormatter>
std::string custom_vsprintf(
const char* format_str,
fmt::basic_args<CustomPrintfFormatter> args) {
fmt::internal::MemoryBuffer<char> buffer;
fmt::memory_buffer buffer;
CustomPrintfFormatter formatter(format_str, args);
formatter.format(buffer);
return std::string(buffer.data(), buffer.size());

View File

@ -105,33 +105,33 @@ TEST(FormatTest, StrError) {
TEST(FormatTest, FormatErrorCode) {
std::string msg = "error 42", sep = ": ";
{
fmt::MemoryWriter w;
w.write("garbage");
fmt::format_error_code(w.buffer(), 42, "test");
EXPECT_EQ("test: " + msg, w.str());
fmt::memory_buffer buffer;
format_to(buffer, "garbage");
fmt::format_error_code(buffer, 42, "test");
EXPECT_EQ("test: " + msg, to_string(buffer));
}
{
fmt::MemoryWriter w;
fmt::memory_buffer buffer;
std::string prefix(
fmt::internal::INLINE_BUFFER_SIZE - msg.size() - sep.size() + 1, 'x');
fmt::format_error_code(w.buffer(), 42, prefix);
EXPECT_EQ(msg, w.str());
fmt::format_error_code(buffer, 42, prefix);
EXPECT_EQ(msg, to_string(buffer));
}
int codes[] = {42, -1};
for (std::size_t i = 0, n = sizeof(codes) / sizeof(*codes); i < n; ++i) {
// Test maximum buffer size.
msg = fmt::format("error {}", codes[i]);
fmt::MemoryWriter w;
fmt::memory_buffer buffer;
std::string prefix(
fmt::internal::INLINE_BUFFER_SIZE - msg.size() - sep.size(), 'x');
fmt::format_error_code(w.buffer(), codes[i], prefix);
EXPECT_EQ(prefix + sep + msg, w.str());
fmt::format_error_code(buffer, codes[i], prefix);
EXPECT_EQ(prefix + sep + msg, to_string(buffer));
std::size_t size = fmt::internal::INLINE_BUFFER_SIZE;
EXPECT_EQ(size, w.size());
w.clear();
EXPECT_EQ(size, buffer.size());
buffer.clear();
// Test with a message that doesn't fit into the buffer.
prefix += 'x';
fmt::format_error_code(w.buffer(), codes[i], prefix);
EXPECT_EQ(msg, w.str());
fmt::format_error_code(buffer, codes[i], prefix);
EXPECT_EQ(msg, to_string(buffer));
}
}

View File

@ -75,8 +75,8 @@ using fmt::format;
using fmt::format_error;
using fmt::string_view;
using fmt::CStringRef;
using fmt::MemoryWriter;
using fmt::WMemoryWriter;
using fmt::memory_buffer;
using fmt::wmemory_buffer;
using fmt::fill;
using fmt::type;
using fmt::width;
@ -109,7 +109,8 @@ void std_format(long double value, std::wstring &result) {
// as writing it to std::basic_ostringstream<Char>.
template <typename Char, typename T>
::testing::AssertionResult check_write(const T &value, const char *type) {
fmt::BasicMemoryWriter<Char> writer;
fmt::basic_memory_buffer<Char> buffer;
fmt::basic_writer<Char> writer(buffer);
writer.write(value);
std::basic_string<Char> actual = writer.str();
std::basic_string<Char> expected;
@ -177,90 +178,16 @@ TEST(WriterTest, NotCopyAssignable) {
#endif
TEST(WriterTest, Ctor) {
MemoryWriter w;
memory_buffer buf;
fmt::basic_writer<char> w(buf);
EXPECT_EQ(0u, w.size());
EXPECT_STREQ("", w.c_str());
EXPECT_EQ("", w.str());
}
#if FMT_USE_RVALUE_REFERENCES
void check_move_writer(const std::string &str, MemoryWriter &w) {
MemoryWriter w2(std::move(w));
// Move shouldn't destroy the inline content of the first writer.
EXPECT_EQ(str, w.str());
EXPECT_EQ(str, w2.str());
}
TEST(WriterTest, MoveCtor) {
MemoryWriter w;
w.write("test");
check_move_writer("test", w);
// This fills the inline buffer, but doesn't cause dynamic allocation.
std::string s;
for (int i = 0; i < fmt::internal::INLINE_BUFFER_SIZE; ++i)
s += '*';
w.clear();
w.write(s);
check_move_writer(s, w);
const char *inline_buffer_ptr = w.data();
// Adding one more character causes the content to move from the inline to
// a dynamically allocated buffer.
w.write('*');
MemoryWriter w2(std::move(w));
// Move should rip the guts of the first writer.
EXPECT_EQ(inline_buffer_ptr, w.data());
EXPECT_EQ(s + '*', w2.str());
}
void CheckMoveAssignWriter(const std::string &str, MemoryWriter &w) {
MemoryWriter w2;
w2 = std::move(w);
// Move shouldn't destroy the inline content of the first writer.
EXPECT_EQ(str, w.str());
EXPECT_EQ(str, w2.str());
}
TEST(WriterTest, MoveAssignment) {
MemoryWriter w;
w.write("test");
CheckMoveAssignWriter("test", w);
// This fills the inline buffer, but doesn't cause dynamic allocation.
std::string s;
for (int i = 0; i < fmt::internal::INLINE_BUFFER_SIZE; ++i)
s += '*';
w.clear();
w.write(s);
CheckMoveAssignWriter(s, w);
const char *inline_buffer_ptr = w.data();
// Adding one more character causes the content to move from the inline to
// a dynamically allocated buffer.
w.write('*');
MemoryWriter w2;
w2 = std::move(w);
// Move should rip the guts of the first writer.
EXPECT_EQ(inline_buffer_ptr, w.data());
EXPECT_EQ(s + '*', w2.str());
}
#endif // FMT_USE_RVALUE_REFERENCES
TEST(WriterTest, Allocator) {
typedef testing::StrictMock< MockAllocator<char> > MockAllocator;
typedef AllocatorRef<MockAllocator> TestAllocator;
MockAllocator alloc;
fmt::BasicMemoryWriter<char, TestAllocator> w((TestAllocator(&alloc)));
std::size_t size =
static_cast<std::size_t>(1.5 * fmt::internal::INLINE_BUFFER_SIZE);
std::vector<char> mem(size);
EXPECT_CALL(alloc, allocate(size)).WillOnce(testing::Return(&mem[0]));
for (int i = 0; i < fmt::internal::INLINE_BUFFER_SIZE + 1; ++i)
w.write('*');
EXPECT_CALL(alloc, deallocate(&mem[0], size));
}
TEST(WriterTest, Data) {
MemoryWriter w;
memory_buffer buf;
fmt::basic_writer<char> w(buf);
w.write(42);
EXPECT_EQ("42", std::string(w.data(), w.size()));
}
@ -312,13 +239,15 @@ TEST(WriterTest, WriteLongDouble) {
}
TEST(WriterTest, WriteDoubleAtBufferBoundary) {
MemoryWriter writer;
memory_buffer buf;
fmt::basic_writer<char> writer(buf);
for (int i = 0; i < 100; ++i)
writer.write(1.23456789);
}
TEST(WriterTest, WriteDoubleWithFilledBuffer) {
MemoryWriter writer;
memory_buffer buf;
fmt::basic_writer<char> writer(buf);
// Fill the buffer.
for (int i = 0; i < fmt::internal::INLINE_BUFFER_SIZE; ++i)
writer.write(' ');
@ -349,7 +278,8 @@ TEST(WriterTest, WriteWideString) {
template <typename... T>
std::string write_str(T... args) {
MemoryWriter writer;
memory_buffer buf;
fmt::basic_writer<char> writer(buf);
using namespace fmt;
writer.write(args...);
return writer.str();
@ -357,7 +287,8 @@ std::string write_str(T... args) {
template <typename... T>
std::wstring write_wstr(T... args) {
WMemoryWriter writer;
wmemory_buffer buf;
fmt::basic_writer<wchar_t> writer(buf);
using namespace fmt;
writer.write(args...);
return writer.str();
@ -447,7 +378,8 @@ TEST(WriterTest, pad) {
EXPECT_EQ(" 33", write_str(33ll, width=7));
EXPECT_EQ(" 44", write_str(44ull, width=7));
MemoryWriter w;
memory_buffer buf;
fmt::basic_writer<char> w(buf);
w.clear();
w.write(42, fmt::width=5, fmt::fill='0');
EXPECT_EQ("00042", w.str());
@ -475,13 +407,13 @@ TEST(WriterTest, WWriter) {
}
TEST(FormatToTest, FormatWithoutArgs) {
fmt::internal::MemoryBuffer<char> buffer;
fmt::memory_buffer buffer;
format_to(buffer, "test");
EXPECT_EQ("test", std::string(buffer.data(), buffer.size()));
}
TEST(FormatToTest, Format) {
fmt::internal::MemoryBuffer<char> buffer;
fmt::memory_buffer buffer;
format_to(buffer, "part{0}", 1);
EXPECT_EQ(strlen("part1"), buffer.size());
EXPECT_EQ("part1", std::string(buffer.data(), buffer.size()));
@ -1370,18 +1302,9 @@ TEST(FormatterTest, FormatExamples) {
EXPECT_EQ("42", format("{}", 42));
EXPECT_EQ("42", format(std::string("{}"), 42));
MemoryWriter out;
out.write("The answer is ");
out.write(42);
out.write("\n");
{
MemoryWriter writer;
for (int i = 0; i < 10; i++)
format_to(writer.buffer(), "{}", i);
std::string s = writer.str(); // s == 0123456789
EXPECT_EQ("0123456789", s);
}
memory_buffer out;
format_to(out, "The answer is {}.", 42);
EXPECT_EQ("The answer is 42.", to_string(out));
const char *filename = "nonexistent";
FILE *ftest = safe_fopen(filename, "r");
@ -1522,7 +1445,7 @@ TEST(StrTest, Convert) {
}
std::string vformat_message(int id, const char *format, fmt::args args) {
fmt::internal::MemoryBuffer<char> buffer;
fmt::memory_buffer buffer;
format_to(buffer, "[{}] ", id);
vformat_to(buffer, format, args);
return to_string(buffer);
@ -1612,7 +1535,7 @@ class MockArgFormatter : public fmt::internal::ArgFormatterBase<char> {
};
void custom_vformat(fmt::CStringRef format_str, fmt::args args) {
fmt::internal::MemoryBuffer<char> buffer;
fmt::memory_buffer buffer;
fmt::vformat_to<MockArgFormatter>(buffer, format_str, args);
}

View File

@ -319,9 +319,9 @@ TEST(StreamingAssertionsTest, EXPECT_WRITE) {
}
TEST(UtilTest, FormatSystemError) {
fmt::MemoryWriter out;
fmt::format_system_error(out.buffer(), EDOM, "test message");
EXPECT_EQ(out.str(), format_system_error(EDOM, "test message"));
fmt::memory_buffer out;
fmt::format_system_error(out, EDOM, "test message");
EXPECT_EQ(to_string(out), format_system_error(EDOM, "test message"));
}
#if FMT_USE_FILE_DESCRIPTORS

View File

@ -104,7 +104,7 @@ std::string read(File &f, std::size_t count) {
#endif // FMT_USE_FILE_DESCRIPTORS
std::string format_system_error(int error_code, fmt::string_view message) {
fmt::internal::MemoryBuffer<char> out;
fmt::format_system_error(out, error_code, message);
fmt::memory_buffer out;
format_system_error(out, error_code, message);
return to_string(out);
}

View File

@ -64,7 +64,7 @@ struct TestArgFormatter : fmt::arg_formatter<char> {
};
TEST(OStreamTest, CustomArg) {
fmt::internal::MemoryBuffer<char> buffer;
fmt::memory_buffer buffer;
fmt::context ctx("}", fmt::args());
fmt::format_specs spec;
TestArgFormatter af(buffer, ctx, spec);
@ -121,7 +121,7 @@ TEST(OStreamTest, Print) {
TEST(OStreamTest, WriteToOStream) {
std::ostringstream os;
fmt::internal::MemoryBuffer<char> buffer;
fmt::memory_buffer buffer;
const char *foo = "foo";
buffer.append(foo, foo + std::strlen(foo));
fmt::internal::write(os, buffer);

View File

@ -54,8 +54,8 @@
using fmt::basic_arg;
using fmt::basic_buffer;
using fmt::basic_memory_buffer;
using fmt::string_view;
using fmt::internal::MemoryBuffer;
using fmt::internal::value;
using testing::_;
@ -238,7 +238,7 @@ TEST(BufferTest, AppendAllocatesEnoughStorage) {
}
TEST(MemoryBufferTest, Ctor) {
MemoryBuffer<char, 123> buffer;
basic_memory_buffer<char, 123> buffer;
EXPECT_EQ(0u, buffer.size());
EXPECT_EQ(123u, buffer.capacity());
}
@ -248,9 +248,9 @@ TEST(MemoryBufferTest, Ctor) {
typedef AllocatorRef< std::allocator<char> > TestAllocator;
void check_move_buffer(const char *str,
MemoryBuffer<char, 5, TestAllocator> &buffer) {
basic_memory_buffer<char, 5, TestAllocator> &buffer) {
std::allocator<char> *alloc = buffer.get_allocator().get();
MemoryBuffer<char, 5, TestAllocator> buffer2(std::move(buffer));
basic_memory_buffer<char, 5, TestAllocator> buffer2(std::move(buffer));
// Move shouldn't destroy the inline content of the first buffer.
EXPECT_EQ(str, std::string(&buffer[0], buffer.size()));
EXPECT_EQ(str, std::string(&buffer2[0], buffer2.size()));
@ -262,7 +262,7 @@ void check_move_buffer(const char *str,
TEST(MemoryBufferTest, MoveCtor) {
std::allocator<char> alloc;
MemoryBuffer<char, 5, TestAllocator> buffer((TestAllocator(&alloc)));
basic_memory_buffer<char, 5, TestAllocator> buffer((TestAllocator(&alloc)));
const char test[] = "test";
buffer.append(test, test + 4);
check_move_buffer("test", buffer);
@ -274,15 +274,16 @@ TEST(MemoryBufferTest, MoveCtor) {
// Adding one more character causes the content to move from the inline to
// a dynamically allocated buffer.
buffer.push_back('b');
MemoryBuffer<char, 5, TestAllocator> buffer2(std::move(buffer));
basic_memory_buffer<char, 5, TestAllocator> buffer2(std::move(buffer));
// Move should rip the guts of the first buffer.
EXPECT_EQ(inline_buffer_ptr, &buffer[0]);
EXPECT_EQ("testab", std::string(&buffer2[0], buffer2.size()));
EXPECT_GT(buffer2.capacity(), 5u);
}
void check_move_assign_buffer(const char *str, MemoryBuffer<char, 5> &buffer) {
MemoryBuffer<char, 5> buffer2;
void check_move_assign_buffer(
const char *str, basic_memory_buffer<char, 5> &buffer) {
basic_memory_buffer<char, 5> buffer2;
buffer2 = std::move(buffer);
// Move shouldn't destroy the inline content of the first buffer.
EXPECT_EQ(str, std::string(&buffer[0], buffer.size()));
@ -291,7 +292,7 @@ void check_move_assign_buffer(const char *str, MemoryBuffer<char, 5> &buffer) {
}
TEST(MemoryBufferTest, MoveAssignment) {
MemoryBuffer<char, 5> buffer;
basic_memory_buffer<char, 5> buffer;
const char test[] = "test";
buffer.append(test, test + 4);
check_move_assign_buffer("test", buffer);
@ -303,7 +304,7 @@ TEST(MemoryBufferTest, MoveAssignment) {
// Adding one more character causes the content to move from the inline to
// a dynamically allocated buffer.
buffer.push_back('b');
MemoryBuffer<char, 5> buffer2;
basic_memory_buffer<char, 5> buffer2;
buffer2 = std::move(buffer);
// Move should rip the guts of the first buffer.
EXPECT_EQ(inline_buffer_ptr, &buffer[0]);
@ -315,7 +316,7 @@ TEST(MemoryBufferTest, MoveAssignment) {
TEST(MemoryBufferTest, Grow) {
typedef AllocatorRef< MockAllocator<int> > Allocator;
typedef MemoryBuffer<int, 10, Allocator> Base;
typedef basic_memory_buffer<int, 10, Allocator> Base;
MockAllocator<int> alloc;
struct TestMemoryBuffer : Base {
TestMemoryBuffer(Allocator alloc) : Base(alloc) {}
@ -341,12 +342,12 @@ TEST(MemoryBufferTest, Grow) {
TEST(MemoryBufferTest, Allocator) {
typedef AllocatorRef< MockAllocator<char> > TestAllocator;
MemoryBuffer<char, 10, TestAllocator> buffer;
basic_memory_buffer<char, 10, TestAllocator> buffer;
EXPECT_EQ(0, buffer.get_allocator().get());
StrictMock< MockAllocator<char> > alloc;
char mem;
{
MemoryBuffer<char, 10, TestAllocator> buffer2((TestAllocator(&alloc)));
basic_memory_buffer<char, 10, TestAllocator> buffer2((TestAllocator(&alloc)));
EXPECT_EQ(&alloc, buffer2.get_allocator().get());
std::size_t size = 2 * fmt::internal::INLINE_BUFFER_SIZE;
EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem));
@ -358,7 +359,7 @@ TEST(MemoryBufferTest, Allocator) {
TEST(MemoryBufferTest, ExceptionInDeallocate) {
typedef AllocatorRef< MockAllocator<char> > TestAllocator;
StrictMock< MockAllocator<char> > alloc;
MemoryBuffer<char, 10, TestAllocator> buffer((TestAllocator(&alloc)));
basic_memory_buffer<char, 10, TestAllocator> buffer((TestAllocator(&alloc)));
std::size_t size = 2 * fmt::internal::INLINE_BUFFER_SIZE;
std::vector<char> mem(size);
{
@ -435,7 +436,7 @@ TEST(UtilTest, MakeValueWithCustomFormatter) {
::Test t;
fmt::internal::value<CustomContext> arg(t);
CustomContext ctx = {false};
fmt::internal::MemoryBuffer<char> buffer;
fmt::memory_buffer buffer;
arg.custom.format(buffer, &t, &ctx);
EXPECT_TRUE(ctx.called);
}
@ -579,7 +580,7 @@ TEST(UtilTest, CustomArg) {
EXPECT_CALL(visitor, visit(_)).WillOnce(
testing::Invoke([&](fmt::internal::CustomValue<char> custom) {
EXPECT_EQ(&test, custom.value);
fmt::internal::MemoryBuffer<char> buffer;
fmt::memory_buffer buffer;
fmt::context ctx("}", fmt::args());
custom.format(buffer, &test, &ctx);
EXPECT_EQ("test", std::string(buffer.data(), buffer.size()));
@ -710,14 +711,14 @@ void check_throw_error(int error_code, FormatErrorMessage format) {
} catch (const fmt::SystemError &e) {
error = e;
}
fmt::internal::MemoryBuffer<char> message;
fmt::memory_buffer message;
format(message, error_code, "test error");
EXPECT_EQ(to_string(message), error.what());
EXPECT_EQ(error_code, error.error_code());
}
TEST(UtilTest, FormatSystemError) {
fmt::internal::MemoryBuffer<char> message;
fmt::memory_buffer message;
fmt::format_system_error(message, EDOM, "test");
EXPECT_EQ(fmt::format("test: {}", get_system_error(EDOM)),
to_string(message));
@ -735,7 +736,7 @@ TEST(UtilTest, SystemError) {
}
TEST(UtilTest, ReportSystemError) {
fmt::internal::MemoryBuffer<char> out;
fmt::memory_buffer out;
fmt::format_system_error(out, EDOM, "test error");
out.push_back('\n');
EXPECT_WRITE(stderr, fmt::report_system_error(EDOM, "test error"),