mirror/fmt
1
0
Fork 0
mirror of https://github.com/fmtlib/fmt.git synced 2025-02-18 21:41:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove pad

Browse Source
This commit is contained in:
Victor Zverovich 2017-01-22 19:11:47 -08:00
parent aaa0fc396b
commit 4863730eca
2 changed files with 31 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
fmt/format.h
View File

@ -1741,7 +1741,8 @@ struct AlignTypeSpec : AlignSpec {
// A full format specifier.
class FormatSpec : public AlignSpec {
private:
void set(fill_spec<char> fill) {
template <typename Char>
void set(fill_spec<Char> fill) {
fill_ = fill.value();
}
@ -1829,24 +1830,6 @@ IntFormatSpec<int, TypeSpec<'x'> > hex(int value);
*/
IntFormatSpec<int, TypeSpec<'X'> > hexu(int value);
/**
\rst
Returns an integer format specifier to pad the formatted argument with the
fill character to the specified width using the default (right) numeric
alignment.
**Example**::
MemoryWriter out;
out << pad(hex(0xcafe), 8, '0');
// out.str() == "0000cafe"
\endrst
*/
template <char TYPE_CODE, typename Char>
IntFormatSpec<int, AlignTypeSpec<TYPE_CODE>, Char> pad(
int value, unsigned width, Char fill = ' ');
#define FMT_DEFINE_INT_FORMATTERS(TYPE) \
inline IntFormatSpec<TYPE, TypeSpec<'b'> > bin(TYPE value) { \
return IntFormatSpec<TYPE, TypeSpec<'b'> >(value, TypeSpec<'b'>()); \
@ -1862,31 +1845,6 @@ inline IntFormatSpec<TYPE, TypeSpec<'x'> > hex(TYPE value) { \
\
inline IntFormatSpec<TYPE, TypeSpec<'X'> > hexu(TYPE value) { \
return IntFormatSpec<TYPE, TypeSpec<'X'> >(value, TypeSpec<'X'>()); \
} \
\
template <char TYPE_CODE> \
inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> > pad( \
IntFormatSpec<TYPE, TypeSpec<TYPE_CODE> > f, unsigned width) { \
return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> >( \
f.value(), AlignTypeSpec<TYPE_CODE>(width, ' ')); \
} \
\
/* For compatibility with older compilers we provide two overloads for pad, */ \
/* one that takes a fill character and one that doesn't. In the future this */ \
/* can be replaced with one overload making the template argument Char */ \
/* default to char (C++11). */ \
template <char TYPE_CODE, typename Char> \
inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char> pad( \
IntFormatSpec<TYPE, TypeSpec<TYPE_CODE>, Char> f, \
unsigned width, Char fill) { \
return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char>( \
f.value(), AlignTypeSpec<TYPE_CODE>(width, fill)); \
} \
\
inline IntFormatSpec<TYPE, AlignTypeSpec<0> > pad( \
TYPE value, unsigned width) { \
return IntFormatSpec<TYPE, AlignTypeSpec<0> >( \
value, AlignTypeSpec<0>(width, ' ')); \
}
FMT_DEFINE_INT_FORMATTERS(int)
@ -1896,29 +1854,6 @@ FMT_DEFINE_INT_FORMATTERS(unsigned long)
FMT_DEFINE_INT_FORMATTERS(LongLong)
FMT_DEFINE_INT_FORMATTERS(ULongLong)
/**
\rst
Returns a string formatter that pads the formatted argument with the fill
character to the specified width using the default (left) string alignment.
**Example**::
std::string s = str(MemoryWriter() << pad("abc", 8));
// s == "abc "
\endrst
*/
template <typename Char>
inline StrFormatSpec<Char> pad(
const Char *str, unsigned width, Char fill = ' ') {
return StrFormatSpec<Char>(str, width, fill);
}
inline StrFormatSpec<wchar_t> pad(
const wchar_t *str, unsigned width, char fill = ' ') {
return StrFormatSpec<wchar_t>(str, width, fill);
}
namespace internal {
template <typename Context>
@ -2575,6 +2510,11 @@ class basic_writer {
buffer_.append(str, str + value.size());
}
template <typename... FormatSpecs>
void write(BasicStringRef<Char> str, FormatSpecs... specs) {
write_str(str, FormatSpec(specs...));
}
template <typename T, typename Spec, typename FillChar>
basic_writer &operator<<(IntFormatSpec<T, Spec, FillChar> spec) {
internal::CharTraits<Char>::convert(FillChar());

42
test/format-test.cc
View File

@ -77,7 +77,9 @@ using fmt::StringRef;
using fmt::CStringRef;
using fmt::MemoryWriter;
using fmt::WMemoryWriter;
using fmt::pad;
using fmt::fill;
using fmt::type;
using fmt::width;
namespace {
@ -418,7 +420,6 @@ public:
template <typename Char>
friend basic_writer<Char> &operator<<(
basic_writer<Char> &w, const ISO8601DateFormatter &d) {
using namespace fmt;
w.write(d.date_->year(), width=4, fill='0');
w.write('-');
w.write(d.date_->month(), width=2, fill='0');
@ -438,8 +439,15 @@ std::string write_str(T... args) {
return writer.str();
}
TEST(WriterTest, pad) {
template <typename... T>
std::wstring write_wstr(T... args) {
WMemoryWriter writer;
using namespace fmt;
writer.write(args...);
return writer.str();
}
TEST(WriterTest, pad) {
EXPECT_EQ(" cafe", write_str(0xcafe, width=8, type='x'));
EXPECT_EQ(" babe", write_str(0xbabeu, width=8, type='x'));
EXPECT_EQ(" dead", write_str(0xdeadl, width=8, type='x'));
@ -447,17 +455,16 @@ TEST(WriterTest, pad) {
EXPECT_EQ(" dead", write_str(0xdeadll, width=8, type='x'));
EXPECT_EQ(" beef", write_str(0xbeefull, width=8, type='x'));
EXPECT_EQ(" 11", (MemoryWriter() << pad(11, 7)).str());
EXPECT_EQ(" 22", (MemoryWriter() << pad(22u, 7)).str());
EXPECT_EQ(" 33", (MemoryWriter() << pad(33l, 7)).str());
EXPECT_EQ(" 44", (MemoryWriter() << pad(44ul, 7)).str());
EXPECT_EQ(" 33", (MemoryWriter() << pad(33ll, 7)).str());
EXPECT_EQ(" 44", (MemoryWriter() << pad(44ull, 7)).str());
EXPECT_EQ(" 11", write_str(11, width=7));
EXPECT_EQ(" 22", write_str(22u, width=7));
EXPECT_EQ(" 33", write_str(33l, width=7));
EXPECT_EQ(" 44", write_str(44ul, width=7));
EXPECT_EQ(" 33", write_str(33ll, width=7));
EXPECT_EQ(" 44", write_str(44ull, width=7));
MemoryWriter w;
w.clear();
using namespace fmt;
w.write(42, width=5, fill='0');
w.write(42, fmt::width=5, fmt::fill='0');
EXPECT_EQ("00042", w.str());
w.clear();
w << Date(2012, 12, 9);
@ -468,14 +475,14 @@ TEST(WriterTest, pad) {
}
TEST(WriterTest, PadString) {
EXPECT_EQ("test ", (MemoryWriter() << pad("test", 8)).str());
EXPECT_EQ("test******", (MemoryWriter() << pad("test", 10, '*')).str());
EXPECT_EQ("test ", write_str("test", width=8));
EXPECT_EQ("test******", write_str("test", width=10, fill='*'));
}
TEST(WriterTest, PadWString) {
EXPECT_EQ(L"test ", (WMemoryWriter() << pad(L"test", 8)).str());
EXPECT_EQ(L"test******", (WMemoryWriter() << pad(L"test", 10, '*')).str());
EXPECT_EQ(L"test******", (WMemoryWriter() << pad(L"test", 10, L'*')).str());
EXPECT_EQ(L"test ", write_wstr(L"test", width=8));
EXPECT_EQ(L"test******", write_wstr(L"test", width=10, fill='*'));
EXPECT_EQ(L"test******", write_wstr(L"test", width=10, fill=L'*'));
}
TEST(WriterTest, NoConflictWithIOManip) {
@ -1414,8 +1421,7 @@ TEST(FormatterTest, FormatStringFromSpeedTest) {
}
TEST(FormatterTest, FormatExamples) {
using fmt::hex;
EXPECT_EQ("0000cafe", (MemoryWriter() << pad(hex(0xcafe), 8, '0')).str());
EXPECT_EQ("0000cafe", write_str(0xcafe, width=8, fill='0', type='x'));
std::string message = format("The answer is {}", 42);
EXPECT_EQ("The answer is 42", message);