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

Remove deprecated code 🎆 🎆 🎆

Browse Source
This commit is contained in:
Victor Zverovich 2014-07-01 09:10:43 -07:00
parent ccf1dbb139
commit 2dc108b31f
3 changed files with 14 additions and 388 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
format.cc
View File

@ -1104,15 +1104,6 @@ void fmt::ReportWinError(
} }
#endif #endif
void fmt::ANSITerminalSink::operator()(
const fmt::BasicWriter<char> &w) const {
char escape[] = "\x1b[30m";
escape[3] = '0' + static_cast<char>(color_);
std::fputs(escape, file_);
std::fwrite(w.data(), 1, w.size(), file_);
std::fputs(RESET_COLOR, file_);
}
void fmt::print(StringRef format, const ArgList &args) { void fmt::print(StringRef format, const ArgList &args) {
Writer w; Writer w;
w.write(format, args); w.write(format, args);
@ -1125,6 +1116,14 @@ void fmt::print(std::FILE *f, StringRef format, const ArgList &args) {
std::fwrite(w.data(), 1, w.size(), f); std::fwrite(w.data(), 1, w.size(), f);
} }
void fmt::print_colored(Color c, StringRef format, const ArgList &args) {
char escape[] = "\x1b[30m";
escape[3] = '0' + static_cast<char>(c);
std::fputs(escape, stdout);
print(format, args);
std::fputs(RESET_COLOR, stdout);
}
void fmt::printf(StringRef format, const ArgList &args) { void fmt::printf(StringRef format, const ArgList &args) {
Writer w; Writer w;
printf(w, format, args); printf(w, format, args);

284
format.h
View File

@ -119,16 +119,7 @@
TypeName(const TypeName&); \ TypeName(const TypeName&); \
void operator=(const TypeName&) void operator=(const TypeName&)
#ifdef FMT_DEPRECATED // TODO: remove
// Do nothing.
#elif defined(__GNUC__)
# define FMT_DEPRECATED(func) func __attribute__((deprecated))
#elif defined(_MSC_VER)
# define FMT_DEPRECATED(func) __declspec(deprecated) func
#else
# define FMT_DEPRECATED(func) func
#endif
#if FMT_MSC_VER #if FMT_MSC_VER
# pragma warning(push) # pragma warning(push)
# pragma warning(disable: 4521) // 'class' : multiple copy constructors specified # pragma warning(disable: 4521) // 'class' : multiple copy constructors specified
@ -175,7 +166,7 @@ struct FormatSpec;
different types of strings to a function, for example:: different types of strings to a function, for example::
template<typename... Args> template<typename... Args>
Writer format(StringRef format, const Args & ... args); std::string format(StringRef format, const Args & ... args);
format("{}", 42); format("{}", 42);
format(std::string("{}"), 42); format(std::string("{}"), 42);
@ -1451,32 +1442,8 @@ class BasicWriter {
} }
void clear() { buffer_.clear(); } void clear() { buffer_.clear(); }
#if !defined(FMT_NO_DEPRECATED)
FMT_DEPRECATED(BasicFormatter<Char> Format(StringRef format));
#if FMT_USE_VARIADIC_TEMPLATES
// This function is deprecated. Use Writer::write instead.
template<typename... Args>
FMT_DEPRECATED(void Format(BasicStringRef<Char> format, const Args & ... args));
#endif
// This function is deprecated. Use Writer::write instead.
FMT_DEPRECATED(void Write(const std::basic_string<Char> &s, const FormatSpec &spec));
// This function is deprecated. Use Writer::clear instead.
FMT_DEPRECATED(void Clear());
#endif
}; };
template <typename Char>
inline void BasicWriter<Char>::Write(const std::basic_string<Char> &s, const FormatSpec &spec) {
write(s, spec);
}
template <typename Char>
inline void BasicWriter<Char>::Clear() { clear(); }
template <typename Char> template <typename Char>
template <typename StringChar> template <typename StringChar>
typename BasicWriter<Char>::CharPtr BasicWriter<Char>::write_str( typename BasicWriter<Char>::CharPtr BasicWriter<Char>::write_str(
@ -1645,12 +1612,6 @@ void BasicWriter<Char>::FormatInt(T value, const Spec &spec) {
} }
} }
template <typename Char>
BasicFormatter<Char> BasicWriter<Char>::Format(StringRef format) {
BasicFormatter<Char> f(*this, format.c_str());
return f;
}
// The default formatting function. // The default formatting function.
template <typename Char, typename T> template <typename Char, typename T>
void format(BasicWriter<Char> &w, const FormatSpec &spec, const T &value) { void format(BasicWriter<Char> &w, const FormatSpec &spec, const T &value) {
@ -1762,148 +1723,12 @@ class BasicFormatter {
} }
}; };
template <typename Char>
FMT_DEPRECATED(std::basic_string<Char> str(const BasicWriter<Char> &f));
// This function is deprecated. Use BasicWriter::str() instead.
template <typename Char>
inline std::basic_string<Char> str(const BasicWriter<Char> &f) {
return f.str();
}
template <typename Char>
FMT_DEPRECATED(const Char *c_str(const BasicWriter<Char> &f));
// This function is deprecated. Use BasicWriter::c_str() instead.
template <typename Char>
inline const Char *c_str(const BasicWriter<Char> &f) { return f.c_str(); }
FMT_DEPRECATED(std::string str(StringRef s));
/**
Converts a string reference to `std::string`.
*/
// This function is deprecated. Use StringRef::c_str() instead.
inline std::string str(StringRef s) {
return std::string(s.c_str(), s.size());
}
FMT_DEPRECATED(const char *c_str(StringRef s));
/**
Returns the pointer to a C string.
*/
// This function is deprecated. Use StringRef::c_str() instead.
inline const char *c_str(StringRef s) {
return s.c_str();
}
FMT_DEPRECATED(std::wstring str(WStringRef s));
// This function is deprecated. Use WStringRef::c_str() instead.
inline std::wstring str(WStringRef s) {
return std::wstring(s.c_str(), s.size());
}
FMT_DEPRECATED(const wchar_t *c_str(WStringRef s));
// This function is deprecated. Use WStringRef::c_str() instead.
inline const wchar_t *c_str(WStringRef s) {
return s.c_str();
}
// This class is deprecated. Use variadic functions instead of sinks.
class NullSink {
public:
template <typename Char>
void operator()(const BasicWriter<Char> &) const {}
};
// This class is deprecated. Use variadic functions instead.
template <typename Sink = NullSink, typename Char = char>
class Formatter : private Sink, public BasicFormatter<Char> {
private:
BasicWriter<Char> writer_;
bool inactive_;
FMT_DISALLOW_COPY_AND_ASSIGN(Formatter);
public:
explicit Formatter(BasicStringRef<Char> format, Sink s = Sink())
: Sink(s), BasicFormatter<Char>(writer_, format.c_str()),
inactive_(false) {
}
Formatter(Formatter &other)
: Sink(other), BasicFormatter<Char>(writer_, other.TakeFormatString()),
inactive_(false) {
other.inactive_ = true;
}
~Formatter() FMT_NOEXCEPT(false) {
if (!inactive_) {
this->CompleteFormatting();
(*this)(writer_);
}
}
};
#if !defined(FMT_NO_DEPRECATED)
// This function is deprecated. Use fmt::format instead.
FMT_DEPRECATED(Formatter<> Format(StringRef format));
inline Formatter<> Format(StringRef format) {
Formatter<> f(format);
return f;
}
// This function is deprecated. Use fmt::format instead.
Formatter<NullSink, wchar_t> FMT_DEPRECATED(Format(WStringRef format));
inline Formatter<NullSink, wchar_t> Format(WStringRef format) {
Formatter<NullSink, wchar_t> f(format);
return f;
}
// This class is deprecated. Use variadic functions instead of sinks.
class SystemErrorSink {
private:
int error_code_;
public:
explicit SystemErrorSink(int error_code) : error_code_(error_code) {}
void operator()(const Writer &w) const {
throw SystemError(error_code_, "{}", w.c_str());
}
};
#endif
FMT_DEPRECATED(Formatter<SystemErrorSink> ThrowSystemError(
int error_code, StringRef format));
// This function is deprecated. Use fmt::SystemError instead.
inline Formatter<SystemErrorSink> ThrowSystemError(
int error_code, StringRef format) {
Formatter<SystemErrorSink> f(format, SystemErrorSink(error_code));
return f;
}
// Reports a system error without throwing an exception. // Reports a system error without throwing an exception.
// Can be used to report errors from destructors. // Can be used to report errors from destructors.
void ReportSystemError(int error_code, StringRef message) FMT_NOEXCEPT(true); void ReportSystemError(int error_code, StringRef message) FMT_NOEXCEPT(true);
#ifdef _WIN32 #ifdef _WIN32
// This class is deprecated. Use variadic functions instead of sinks.
class WinErrorSink {
private:
int error_code_;
public:
explicit WinErrorSink(int error_code) : error_code_(error_code) {}
void operator()(const Writer &w) const;
};
/** /**
A Windows error. A Windows error.
*/ */
@ -1927,68 +1752,21 @@ class WindowsError : public SystemError {
FMT_VARIADIC_CTOR(WindowsError, init, int, StringRef) FMT_VARIADIC_CTOR(WindowsError, init, int, StringRef)
}; };
FMT_DEPRECATED(Formatter<WinErrorSink> ThrowWinError(int error_code, StringRef format));
// This function is deprecated. Use WindowsError instead.
inline Formatter<WinErrorSink> ThrowWinError(int error_code, StringRef format) {
Formatter<WinErrorSink> f(format, WinErrorSink(error_code));
return f;
}
// Reports a Windows error without throwing an exception. // Reports a Windows error without throwing an exception.
// Can be used to report errors from destructors. // Can be used to report errors from destructors.
void ReportWinError(int error_code, StringRef message) FMT_NOEXCEPT(true); void ReportWinError(int error_code, StringRef message) FMT_NOEXCEPT(true);
#endif #endif
// This class is deprecated. Use variadic functions instead of sinks.
class FileSink {
private:
std::FILE *file_;
public:
explicit FileSink(std::FILE *f) : file_(f) {}
void operator()(const BasicWriter<char> &w) const {
if (std::fwrite(w.data(), w.size(), 1, file_) == 0)
throw SystemError(errno, "cannot write to file");
}
};
inline Formatter<FileSink> Print(StringRef format) {
Formatter<FileSink> f(format, FileSink(stdout));
return f;
}
inline Formatter<FileSink> Print(std::FILE *file, StringRef format) {
Formatter<FileSink> f(format, FileSink(file));
return f;
}
enum Color { BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE }; enum Color { BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE };
// This class is deprecated. Use variadic functions instead of sinks.
class ANSITerminalSink {
private:
std::FILE *file_;
Color color_;
public:
ANSITerminalSink(std::FILE *f, Color c) : file_(f), color_(c) {}
void operator()(const BasicWriter<char> &w) const;
};
/** /**
Formats a string and prints it to stdout using ANSI escape sequences Formats a string and prints it to stdout using ANSI escape sequences
to specify color (experimental). to specify color (experimental).
Example: Example:
PrintColored(fmt::RED, "Elapsed time: {0:.2f} seconds") << 1.23; PrintColored(fmt::RED, "Elapsed time: {0:.2f} seconds") << 1.23;
*/ */
inline Formatter<ANSITerminalSink> PrintColored(Color c, StringRef format) { void print_colored(Color c, StringRef format, const ArgList &args);
Formatter<ANSITerminalSink> f(format, ANSITerminalSink(stdout, c));
return f;
}
/** /**
\rst \rst
@ -2051,61 +1829,6 @@ inline std::string sprintf(StringRef format, const ArgList &args) {
void printf(StringRef format, const ArgList &args); void printf(StringRef format, const ArgList &args);
#if !defined(FMT_NO_DEPRECATED) && FMT_USE_VARIADIC_TEMPLATES && FMT_USE_RVALUE_REFERENCES
template <typename Char>
template<typename... Args>
void BasicWriter<Char>::Format(
BasicStringRef<Char> format, const Args & ... args) {
this->format(format, args...);
}
// This function is deprecated. Use fmt::format instead.
template<typename... Args>
FMT_DEPRECATED(Writer Format(StringRef format, const Args & ... args));
template<typename... Args>
inline Writer Format(StringRef format, const Args & ... args) {
Writer w;
w.Format(format, args...);
return std::move(w);
}
// This function is deprecated. Use fmt::format instead.
template<typename... Args>
FMT_DEPRECATED(WWriter Format(WStringRef format, const Args & ... args));
template<typename... Args>
inline WWriter Format(WStringRef format, const Args & ... args) {
WWriter w;
w.Format(format, args...);
return std::move(w);
}
// This function is deprecated. Use fmt::print instead.
template<typename... Args>
FMT_DEPRECATED(void Print(StringRef format, const Args & ... args));
template<typename... Args>
void Print(StringRef format, const Args & ... args) {
Writer w;
w.write(format, args...);
std::fwrite(w.data(), 1, w.size(), stdout);
}
// This function is deprecated. Use fmt::print instead.
template<typename... Args>
FMT_DEPRECATED(void Print(std::FILE *f, StringRef format, const Args & ... args));
template<typename... Args>
void Print(std::FILE *f, StringRef format, const Args & ... args) {
Writer w;
w.Format(format, args...);
std::fwrite(w.data(), 1, w.size(), f);
}
#endif // FMT_USE_VARIADIC_TEMPLATES && FMT_USE_RVALUE_REFERENCES
/** /**
Fast integer formatter. Fast integer formatter.
*/ */
@ -2306,6 +2029,7 @@ FMT_VARIADIC(std::string, format, StringRef)
FMT_VARIADIC_W(std::wstring, format, WStringRef) FMT_VARIADIC_W(std::wstring, format, WStringRef)
FMT_VARIADIC(void, print, StringRef) FMT_VARIADIC(void, print, StringRef)
FMT_VARIADIC(void, print, std::FILE *, StringRef) FMT_VARIADIC(void, print, std::FILE *, StringRef)
FMT_VARIADIC(void, print_colored, Color, StringRef)
FMT_VARIADIC(std::string, sprintf, StringRef) FMT_VARIADIC(std::string, sprintf, StringRef)
FMT_VARIADIC(void, printf, StringRef) FMT_VARIADIC(void, printf, StringRef)
} }

101
test/format-test.cc
View File

@ -1232,7 +1232,7 @@ TEST(FormatterTest, FormatNaN) {
if (fmt::internal::SignBitNoInline(-nan)) if (fmt::internal::SignBitNoInline(-nan))
EXPECT_EQ("-nan", format("{}", -nan)); EXPECT_EQ("-nan", format("{}", -nan));
else else
fmt::Print("Warning: compiler doesn't handle negative NaN correctly"); fmt::print("Warning: compiler doesn't handle negative NaN correctly");
EXPECT_EQ(" nan", format("{: }", nan)); EXPECT_EQ(" nan", format("{: }", nan));
EXPECT_EQ("NAN", format("{:F}", nan)); EXPECT_EQ("NAN", format("{:F}", nan));
EXPECT_EQ("nan ", format("{:<7}", nan)); EXPECT_EQ("nan ", format("{:<7}", nan));
@ -1386,100 +1386,6 @@ TEST(StringRefTest, ConvertToString) {
EXPECT_EQ("abc", s); EXPECT_EQ("abc", s);
} }
TEST(FormatterTest, Ctor) {
fmt::Formatter<> f1("test");
fmt::Formatter<> f1copy(f1);
fmt::Formatter<> f2("test", fmt::NullSink());
fmt::Formatter<fmt::NullSink> f3("test");
fmt::Formatter<fmt::NullSink, wchar_t> f4(L"test");
fmt::Formatter<fmt::NullSink, wchar_t> f4copy(f4);
fmt::Formatter<fmt::NullSink, wchar_t> f5(L"test", fmt::NullSink());
}
// A sink that counts the number of times the output is written to it.
struct CountingSink {
int &num_writes;
explicit CountingSink(int &num_writes) : num_writes(num_writes) {}
void operator()(const Writer &) const {
++num_writes;
}
};
TEST(FormatterTest, Sink) {
int num_writes = 0;
{
fmt::Formatter<CountingSink> f("test", CountingSink(num_writes));
EXPECT_EQ(0, num_writes);
}
EXPECT_EQ(1, num_writes);
}
TEST(FormatterTest, Move) {
// Test if formatting is performed once if we "move" a formatter.
int num_writes = 0;
{
typedef fmt::Formatter<CountingSink> TestFormatter;
TestFormatter *f = new TestFormatter("test", CountingSink(num_writes));
TestFormatter f2(*f);
delete f;
EXPECT_EQ(0, num_writes);
}
EXPECT_EQ(1, num_writes);
}
TEST(FormatterTest, OutputNotWrittenOnError) {
int num_writes = 0;
{
typedef fmt::Formatter<CountingSink> TestFormatter;
EXPECT_THROW(TestFormatter f("{0", CountingSink(num_writes)), FormatError);
}
EXPECT_EQ(0, num_writes);
}
#if FMT_USE_FILE_DESCRIPTORS
using fmt::BufferedFile;
using fmt::File;
TEST(FormatterTest, FileSink) {
File read_end, write_end;
File::pipe(read_end, write_end);
BufferedFile f = write_end.fdopen("w");
EXPECT_WRITE(f.get(), {
fmt::FileSink fs(f.get());
fs(Writer() << "test");
}, "test");
}
TEST(FormatterTest, FileSinkWriteError) {
File read_end, write_end;
File::pipe(read_end, write_end);
BufferedFile f = read_end.fdopen("r");
fmt::FileSink fs(f.get());
std::size_t result = std::fwrite(" ", 1, 1, f.get());
int error_code = errno;
EXPECT_EQ(0u, result);
EXPECT_SYSTEM_ERROR(
fs(Writer() << "test"), error_code, "cannot write to file");
}
#else
# pragma message "warning: some tests are disabled"
#endif
struct PrintError {
void operator()(const fmt::Writer &w) const {
std::cerr << "Error: " << w.str() << std::endl;
}
};
fmt::Formatter<PrintError> ReportError(const char *format) {
fmt::Formatter<PrintError> f(format);
return f;
}
TEST(FormatterTest, Examples) { TEST(FormatterTest, Examples) {
EXPECT_EQ("First, thou shalt count to three", EXPECT_EQ("First, thou shalt count to three",
format("First, thou shalt count to {0}", "three")); format("First, thou shalt count to {0}", "three"));
@ -1517,9 +1423,6 @@ TEST(FormatterTest, Examples) {
EXPECT_EQ("int: 42; hex: 0x2a; oct: 052", EXPECT_EQ("int: 42; hex: 0x2a; oct: 052",
format("int: {0:d}; hex: {0:#x}; oct: {0:#o}", 42)); format("int: {0:d}; hex: {0:#x}; oct: {0:#o}", 42));
std::string path = "somefile";
ReportError("File not found: {0}") << path;
EXPECT_EQ("The answer is 42", format("The answer is {}", 42)); EXPECT_EQ("The answer is 42", format("The answer is {}", 42));
EXPECT_THROW_MSG( EXPECT_THROW_MSG(
format("The answer is {:d}", "forty-two"), FormatError, format("The answer is {:d}", "forty-two"), FormatError,
@ -1584,7 +1487,7 @@ TEST(FormatTest, Print) {
} }
TEST(FormatTest, PrintColored) { TEST(FormatTest, PrintColored) {
EXPECT_WRITE(stdout, fmt::PrintColored(fmt::RED, "Hello, {}!\n") << "world", EXPECT_WRITE(stdout, fmt::print_colored(fmt::RED, "Hello, {}!\n", "world"),
"\x1b[31mHello, world!\n\x1b[0m"); "\x1b[31mHello, world!\n\x1b[0m");
} }