From 6e568f3a08c9a62edcb61cd39b6656c0de78bede Mon Sep 17 00:00:00 2001 From: Victor Zverovich Date: Tue, 14 Feb 2017 12:08:37 -0500 Subject: [PATCH] buffer -> basic_buffer --- fmt/format.h | 24 ++++++++++++------------ fmt/ostream.h | 4 ++-- fmt/string.h | 2 +- fmt/time.h | 2 +- test/ostream-test.cc | 2 +- test/util-test.cc | 22 +++++++++++----------- 6 files changed, 28 insertions(+), 28 deletions(-) diff --git a/fmt/format.h b/fmt/format.h index 6de92b0c..3857a11e 100644 --- a/fmt/format.h +++ b/fmt/format.h @@ -587,16 +587,16 @@ inline T *make_ptr(T *ptr, std::size_t) { return ptr; } \endrst */ template -class buffer { +class basic_buffer { private: - FMT_DISALLOW_COPY_AND_ASSIGN(buffer); + FMT_DISALLOW_COPY_AND_ASSIGN(basic_buffer); protected: T *ptr_; std::size_t size_; std::size_t capacity_; - buffer(T *ptr = 0, std::size_t capacity = 0) + basic_buffer(T *ptr = 0, std::size_t capacity = 0) : ptr_(ptr), size_(0), capacity_(capacity) {} /** @@ -608,7 +608,7 @@ class buffer { virtual void grow(std::size_t size) = 0; public: - virtual ~buffer() {} + virtual ~basic_buffer() {} /** Returns the size of this buffer. */ std::size_t size() const { return size_; } @@ -653,7 +653,7 @@ class buffer { template template -void buffer::append(const U *begin, const U *end) { +void basic_buffer::append(const U *begin, const U *end) { std::size_t new_size = size_ + internal::to_unsigned(end - begin); if (new_size > capacity_) grow(new_size); @@ -667,7 +667,7 @@ namespace internal { // A memory buffer for trivially copyable/constructible types with the first // SIZE elements stored in the object itself. template > -class MemoryBuffer : private Allocator, public buffer { +class MemoryBuffer : private Allocator, public basic_buffer { private: T data_[SIZE]; @@ -681,7 +681,7 @@ class MemoryBuffer : private Allocator, public buffer { public: explicit MemoryBuffer(const Allocator &alloc = Allocator()) - : Allocator(alloc), buffer(data_, SIZE) {} + : Allocator(alloc), basic_buffer(data_, SIZE) {} ~MemoryBuffer() { deallocate(); } #if FMT_USE_RVALUE_REFERENCES @@ -743,10 +743,10 @@ void MemoryBuffer::grow(std::size_t size) { // A fixed-size buffer. template -class FixedBuffer : public fmt::buffer { +class FixedBuffer : public fmt::basic_buffer { public: FixedBuffer(Char *array, std::size_t size) - : fmt::buffer(array, size) {} + : fmt::basic_buffer(array, size) {} protected: FMT_API void grow(std::size_t size); @@ -2199,7 +2199,7 @@ class basic_writer { private: // Output buffer. - fmt::buffer &buffer_; + basic_buffer &buffer_; FMT_DISALLOW_COPY_AND_ASSIGN(basic_writer); @@ -2302,7 +2302,7 @@ class basic_writer { /** Constructs a ``basic_writer`` object. */ - explicit basic_writer(fmt::buffer &b) : buffer_(b) {} + explicit basic_writer(basic_buffer &b) : buffer_(b) {} public: /** @@ -2443,7 +2443,7 @@ class basic_writer { void clear() FMT_NOEXCEPT { buffer_.clear(); } - fmt::buffer &buffer() FMT_NOEXCEPT { return buffer_; } + basic_buffer &buffer() FMT_NOEXCEPT { return buffer_; } }; template diff --git a/fmt/ostream.h b/fmt/ostream.h index 4db6f9c4..f3780354 100644 --- a/fmt/ostream.h +++ b/fmt/ostream.h @@ -23,11 +23,11 @@ class FormatBuf : public std::basic_streambuf { typedef typename std::basic_streambuf::int_type int_type; typedef typename std::basic_streambuf::traits_type traits_type; - buffer &buffer_; + basic_buffer &buffer_; Char *start_; public: - FormatBuf(buffer &buffer) : buffer_(buffer), start_(&buffer[0]) { + FormatBuf(basic_buffer &buffer) : buffer_(buffer), start_(&buffer[0]) { this->setp(start_, start_ + buffer_.capacity()); } diff --git a/fmt/string.h b/fmt/string.h index acb399b6..35154f47 100644 --- a/fmt/string.h +++ b/fmt/string.h @@ -18,7 +18,7 @@ namespace internal { // A buffer that stores data in ``std::string``. template -class StringBuffer : public buffer { +class StringBuffer : public basic_buffer { private: std::basic_string data_; diff --git a/fmt/time.h b/fmt/time.h index 4f07fd00..b5482e73 100644 --- a/fmt/time.h +++ b/fmt/time.h @@ -27,7 +27,7 @@ void format_value(writer &w, const std::tm &tm, context &ctx) { internal::MemoryBuffer format; format.append(s, end + 1); format[format.size() - 1] = '\0'; - buffer &buffer = w.buffer(); + basic_buffer &buffer = w.buffer(); std::size_t start = buffer.size(); for (;;) { std::size_t size = buffer.capacity() - start; diff --git a/test/ostream-test.cc b/test/ostream-test.cc index 6eab45a6..eea803df 100644 --- a/test/ostream-test.cc +++ b/test/ostream-test.cc @@ -135,7 +135,7 @@ TEST(OStreamTest, WriteToOStreamMaxSize) { class TestWriter : public fmt::basic_writer { private: - struct TestBuffer : fmt::buffer { + struct TestBuffer : fmt::basic_buffer { explicit TestBuffer(std::size_t size) { size_ = size; } void grow(std::size_t) {} } buffer_; diff --git a/test/util-test.cc b/test/util-test.cc index 19cbcb8f..84ba407f 100644 --- a/test/util-test.cc +++ b/test/util-test.cc @@ -53,7 +53,7 @@ #undef max using fmt::basic_arg; -using fmt::buffer; +using fmt::basic_buffer; using fmt::StringRef; using fmt::internal::MemoryBuffer; using fmt::internal::value; @@ -106,24 +106,24 @@ TEST(AllocatorTest, AllocatorRef) { #if FMT_USE_TYPE_TRAITS TEST(BufferTest, Noncopyable) { - EXPECT_FALSE(std::is_copy_constructible >::value); - EXPECT_FALSE(std::is_copy_assignable >::value); + EXPECT_FALSE(std::is_copy_constructible >::value); + EXPECT_FALSE(std::is_copy_assignable >::value); } TEST(BufferTest, Nonmoveable) { - EXPECT_FALSE(std::is_move_constructible >::value); - EXPECT_FALSE(std::is_move_assignable >::value); + EXPECT_FALSE(std::is_move_constructible >::value); + EXPECT_FALSE(std::is_move_assignable >::value); } #endif // A test buffer with a dummy grow method. template -struct TestBuffer : buffer { +struct TestBuffer : basic_buffer { void grow(std::size_t size) { this->capacity_ = size; } }; template -struct MockBuffer : buffer { +struct MockBuffer : basic_buffer { MOCK_METHOD1(do_grow, void (std::size_t size)); void grow(std::size_t size) { @@ -132,8 +132,8 @@ struct MockBuffer : buffer { } MockBuffer() {} - MockBuffer(T *ptr) : buffer(ptr) {} - MockBuffer(T *ptr, std::size_t capacity) : buffer(ptr, capacity) {} + MockBuffer(T *ptr) : basic_buffer(ptr) {} + MockBuffer(T *ptr, std::size_t capacity) : basic_buffer(ptr, capacity) {} }; TEST(BufferTest, Ctor) { @@ -169,7 +169,7 @@ TEST(BufferTest, VirtualDtor) { typedef StrictMock StictMockBuffer; StictMockBuffer *mock_buffer = new StictMockBuffer(); EXPECT_CALL(*mock_buffer, die()); - buffer *buffer = mock_buffer; + basic_buffer *buffer = mock_buffer; delete buffer; } @@ -180,7 +180,7 @@ TEST(BufferTest, Access) { EXPECT_EQ(11, buffer[0]); buffer[3] = 42; EXPECT_EQ(42, *(&buffer[0] + 3)); - const fmt::buffer &const_buffer = buffer; + const fmt::basic_buffer &const_buffer = buffer; EXPECT_EQ(42, const_buffer[3]); }