AuroraMiddleware/fmtlegacy
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Produce a compile error when using wide fill character on a narrow stream.

Browse Source
This commit is contained in:
Victor Zverovich 2014-01-08 08:17:38 -08:00
parent fa3efb1330
commit a1bd3358bb
3 changed files with 64 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
format-test.cc
View File

@ -1227,7 +1227,7 @@ TEST(FormatterTest, FormatUsingIOStreams) {
class Answer {};
template <typename Char>
void Format(BasicWriter<Char> &f, const fmt::FormatSpec &spec, Answer) {
void Format(BasicWriter<Char> &f, const fmt::FormatSpec<Char> &spec, Answer) {
f.Write("42", spec);
}

19
format.cc
View File

@ -170,7 +170,7 @@ void fmt::BasicWriter<Char>::FormatDecimal(
template <typename Char>
typename fmt::BasicWriter<Char>::CharPtr
fmt::BasicWriter<Char>::PrepareFilledBuffer(
unsigned size, const AlignSpec &spec, char sign) {
unsigned size, const AlignSpec<Char> &spec, char sign) {
unsigned width = spec.width();
if (width <= size) {
CharPtr p = GrowBuffer(size);
@ -180,6 +180,7 @@ typename fmt::BasicWriter<Char>::CharPtr
CharPtr p = GrowBuffer(width);
CharPtr end = p + width;
Alignment align = spec.align();
// TODO: error if fill is not convertible to Char
Char fill = static_cast<Char>(spec.fill());
if (align == ALIGN_LEFT) {
*p = sign;
@ -207,7 +208,7 @@ typename fmt::BasicWriter<Char>::CharPtr
template <typename Char>
template <typename T>
void fmt::BasicWriter<Char>::FormatDouble(
T value, const FormatSpec &spec, int precision) {
T value, const FormatSpec<Char> &spec, int precision) {
// Check type.
char type = spec.type();
bool upper = false;
@ -437,7 +438,7 @@ void fmt::BasicFormatter<Char>::DoFormat() {
const Arg &arg = ParseArgIndex(s);
FormatSpec spec;
FormatSpec<Char> spec;
int precision = -1;
if (*s == ':') {
++s;
@ -665,10 +666,10 @@ void fmt::BasicFormatter<Char>::DoFormat() {
// Explicit instantiations for char.
template void fmt::BasicWriter<char>::FormatDouble<double>(
double value, const FormatSpec &spec, int precision);
double value, const FormatSpec<char> &spec, int precision);
template void fmt::BasicWriter<char>::FormatDouble<long double>(
long double value, const FormatSpec &spec, int precision);
long double value, const FormatSpec<char> &spec, int precision);
template fmt::BasicWriter<char>::CharPtr
fmt::BasicWriter<char>::FillPadding(CharPtr buffer,
@ -679,7 +680,7 @@ template void fmt::BasicWriter<char>::FormatDecimal(
template fmt::BasicWriter<char>::CharPtr
fmt::BasicWriter<char>::PrepareFilledBuffer(
unsigned size, const AlignSpec &spec, char sign);
unsigned size, const AlignSpec<char> &spec, char sign);
template void fmt::BasicFormatter<char>::ReportError(
const char *s, StringRef message) const;
@ -697,10 +698,10 @@ template void fmt::BasicFormatter<char>::DoFormat();
// Explicit instantiations for wchar_t.
template void fmt::BasicWriter<wchar_t>::FormatDouble<double>(
double value, const FormatSpec &spec, int precision);
double value, const FormatSpec<wchar_t> &spec, int precision);
template void fmt::BasicWriter<wchar_t>::FormatDouble<long double>(
long double value, const FormatSpec &spec, int precision);
long double value, const FormatSpec<wchar_t> &spec, int precision);
template fmt::BasicWriter<wchar_t>::CharPtr
fmt::BasicWriter<wchar_t>::FillPadding(CharPtr buffer,
@ -711,7 +712,7 @@ template void fmt::BasicWriter<wchar_t>::FormatDecimal(
template fmt::BasicWriter<wchar_t>::CharPtr
fmt::BasicWriter<wchar_t>::PrepareFilledBuffer(
unsigned size, const AlignSpec &spec, char sign);
unsigned size, const AlignSpec<wchar_t> &spec, char sign);
template void fmt::BasicFormatter<wchar_t>::ReportError(
const wchar_t *s, StringRef message) const;

84
format.h
View File

@ -353,6 +353,7 @@ struct WidthSpec {
};
// An alignment specifier.
template <typename Char>
struct AlignSpec : WidthSpec {
Alignment align_;
@ -363,9 +364,9 @@ struct AlignSpec : WidthSpec {
};
// An alignment and type specifier.
template <char TYPE>
struct AlignTypeSpec : AlignSpec {
AlignTypeSpec(unsigned width, wchar_t fill) : AlignSpec(width, fill) {}
template <typename Char, char TYPE>
struct AlignTypeSpec : AlignSpec<Char> {
AlignTypeSpec(unsigned width, wchar_t fill) : AlignSpec<Char>(width, fill) {}
bool sign_flag() const { return false; }
bool plus_flag() const { return false; }
@ -375,12 +376,13 @@ struct AlignTypeSpec : AlignSpec {
};
// A full format specifier.
struct FormatSpec : AlignSpec {
template <typename Char>
struct FormatSpec : AlignSpec<Char> {
unsigned flags_;
char type_;
FormatSpec(unsigned width = 0, char type = 0, wchar_t fill = ' ')
: AlignSpec(width, fill), flags_(0), type_(type) {}
: AlignSpec<Char>(width, fill), flags_(0), type_(type) {}
bool sign_flag() const { return (flags_ & SIGN_FLAG) != 0; }
bool plus_flag() const { return (flags_ & PLUS_FLAG) != 0; }
@ -390,6 +392,7 @@ struct FormatSpec : AlignSpec {
};
// An integer format specifier.
// TODO: additional argument typename Char = char
template <typename T, typename SpecT>
class IntFormatSpec : public SpecT {
private:
@ -404,13 +407,13 @@ class IntFormatSpec : public SpecT {
// A string format specifier.
template <typename T>
class StrFormatSpec : public AlignSpec {
class StrFormatSpec : public AlignSpec<T> {
private:
const T *str_;
public:
StrFormatSpec(const T *str, unsigned width, wchar_t fill)
: AlignSpec(width, fill), str_(str) {}
: AlignSpec<T>(width, fill), str_(str) {}
const T *str() const { return str_; }
};
@ -450,9 +453,9 @@ IntFormatSpec<int, TypeSpec<'X'> > hexu(int value);
\endrst
*/
template <char TYPE_CODE>
IntFormatSpec<int, AlignTypeSpec<TYPE_CODE> > pad(
int value, unsigned width, wchar_t fill = ' ');
template <typename Char, char TYPE_CODE>
IntFormatSpec<int, AlignTypeSpec<Char, TYPE_CODE> > pad(
int value, unsigned width, Char fill = ' ');
#define DEFINE_INT_FORMATTERS(TYPE) \
inline IntFormatSpec<TYPE, TypeSpec<'b'> > bin(TYPE value) { \
@ -472,17 +475,35 @@ inline IntFormatSpec<TYPE, TypeSpec<'X'> > hexu(TYPE value) { \
} \
\
template <char TYPE_CODE> \
inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> > pad( \
IntFormatSpec<TYPE, TypeSpec<TYPE_CODE> > f, \
unsigned width, wchar_t fill = ' ') { \
return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> >( \
f.value(), AlignTypeSpec<TYPE_CODE>(width, fill)); \
inline IntFormatSpec<TYPE, AlignTypeSpec<char, TYPE_CODE> > pad( \
IntFormatSpec<TYPE, TypeSpec<TYPE_CODE> > f, unsigned width) { \
return IntFormatSpec<TYPE, AlignTypeSpec<char, TYPE_CODE> >( \
f.value(), AlignTypeSpec<char, TYPE_CODE>(width, ' ')); \
} \
\
inline IntFormatSpec<TYPE, AlignTypeSpec<0> > pad( \
TYPE value, unsigned width, wchar_t fill = ' ') { \
return IntFormatSpec<TYPE, AlignTypeSpec<0> >( \
value, AlignTypeSpec<0>(width, fill)); \
/* 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 and making the template argument Char */ \
/* default to char (C++11). */ \
template <char TYPE_CODE, typename Char> \
inline IntFormatSpec<TYPE, AlignTypeSpec<Char, TYPE_CODE> > pad( \
IntFormatSpec<TYPE, TypeSpec<TYPE_CODE> > f, \
unsigned width, Char fill) { \
return IntFormatSpec<TYPE, AlignTypeSpec<Char, TYPE_CODE> >( \
f.value(), AlignTypeSpec<Char, TYPE_CODE>(width, fill)); \
} \
\
inline IntFormatSpec<TYPE, AlignTypeSpec<char, 0> > pad( \
TYPE value, unsigned width) { \
return IntFormatSpec<TYPE, AlignTypeSpec<char, 0> >( \
value, AlignTypeSpec<char, 0>(width, ' ')); \
} \
\
template <typename Char> \
inline IntFormatSpec<TYPE, AlignTypeSpec<Char, 0> > pad( \
TYPE value, unsigned width, Char fill) { \
return IntFormatSpec<TYPE, AlignTypeSpec<Char, 0> >( \
value, AlignTypeSpec<Char, 0>(width, fill)); \
}
DEFINE_INT_FORMATTERS(int)
@ -587,16 +608,17 @@ class BasicWriter {
return p + size - 1;
}
CharPtr PrepareFilledBuffer(unsigned size, const AlignSpec &spec, char sign);
CharPtr PrepareFilledBuffer(
unsigned size, const AlignSpec<Char> &spec, char sign);
// Formats a floating-point number (double or long double).
template <typename T>
void FormatDouble(T value, const FormatSpec &spec, int precision);
void FormatDouble(T value, const FormatSpec<Char> &spec, int precision);
// Formats a string.
template <typename StringChar>
CharPtr FormatString(
const StringChar *s, std::size_t size, const AlignSpec &spec);
const StringChar *s, std::size_t size, const AlignSpec<Char> &spec);
// This method is private to disallow writing a wide string to a
// char stream and vice versa. If you want to print a wide string
@ -687,7 +709,7 @@ class BasicWriter {
}
BasicWriter &operator<<(double value) {
FormatDouble(value, FormatSpec(), -1);
FormatDouble(value, FormatSpec<Char>(), -1);
return *this;
}
@ -696,7 +718,7 @@ class BasicWriter {
(``'g'``) and writes it to the stream.
*/
BasicWriter &operator<<(long double value) {
FormatDouble(value, FormatSpec(), -1);
FormatDouble(value, FormatSpec<Char>(), -1);
return *this;
}
@ -733,7 +755,7 @@ class BasicWriter {
return *this;
}
void Write(const std::basic_string<char> &s, const FormatSpec &spec) {
void Write(const std::basic_string<char> &s, const FormatSpec<Char> &spec) {
FormatString(s.data(), s.size(), spec);
}
@ -745,7 +767,7 @@ class BasicWriter {
template <typename Char>
template <typename StringChar>
typename BasicWriter<Char>::CharPtr BasicWriter<Char>::FormatString(
const StringChar *s, std::size_t size, const AlignSpec &spec) {
const StringChar *s, std::size_t size, const AlignSpec<Char> &spec) {
CharPtr out = CharPtr();
if (spec.width() > size) {
out = GrowBuffer(spec.width());
@ -862,7 +884,7 @@ typedef BasicWriter<wchar_t> WWriter;
// The default formatting function.
template <typename Char, typename T>
void Format(BasicWriter<Char> &w, const FormatSpec &spec, const T &value) {
void Format(BasicWriter<Char> &w, const FormatSpec<Char> &spec, const T &value) {
std::basic_ostringstream<Char> os;
os << value;
w.Write(os.str(), spec);
@ -872,7 +894,7 @@ namespace internal {
// Formats an argument of a custom type, such as a user-defined class.
template <typename Char, typename T>
void FormatCustomArg(
BasicWriter<Char> &w, const void *arg, const FormatSpec &spec) {
BasicWriter<Char> &w, const void *arg, const FormatSpec<Char> &spec) {
Format(w, spec, *static_cast<const T*>(arg));
}
}
@ -899,7 +921,7 @@ class BasicFormatter {
};
typedef void (*FormatFunc)(
BasicWriter<Char> &w, const void *arg, const FormatSpec &spec);
BasicWriter<Char> &w, const void *arg, const FormatSpec<Char> &spec);
// A format argument.
class Arg {
@ -1042,8 +1064,8 @@ class BasicFormatter {
// Formats an integer.
template <typename T>
void FormatInt(T value, const FormatSpec &spec) {
*writer_ << IntFormatSpec<T, FormatSpec>(value, spec);
void FormatInt(T value, const FormatSpec<Char> &spec) {
*writer_ << IntFormatSpec<T, FormatSpec<Char> >(value, spec);
}
struct Proxy {