2012-12-07 16:31:09 +00:00
|
|
|
/*
|
2012-12-12 15:44:41 +00:00
|
|
|
String formatting library for C++
|
|
|
|
|
|
|
|
Copyright (c) 2012, Victor Zverovich
|
|
|
|
All rights reserved.
|
|
|
|
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
|
|
modification, are permitted provided that the following conditions are met:
|
|
|
|
|
|
|
|
1. Redistributions of source code must retain the above copyright notice, this
|
|
|
|
list of conditions and the following disclaimer.
|
|
|
|
2. Redistributions in binary form must reproduce the above copyright notice,
|
|
|
|
this list of conditions and the following disclaimer in the documentation
|
|
|
|
and/or other materials provided with the distribution.
|
|
|
|
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
|
|
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
|
|
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
|
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
|
|
|
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
|
|
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
|
|
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
|
|
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
|
|
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
2012-12-07 16:31:09 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef FORMAT_H_
|
|
|
|
#define FORMAT_H_
|
|
|
|
|
|
|
|
#include <cstddef>
|
|
|
|
#include <cstdio>
|
|
|
|
#include <stdexcept>
|
|
|
|
#include <string>
|
2012-12-09 17:03:47 +00:00
|
|
|
#include <sstream>
|
2012-12-07 16:31:09 +00:00
|
|
|
#include <vector>
|
|
|
|
|
|
|
|
namespace format {
|
|
|
|
|
2012-12-12 17:14:00 +00:00
|
|
|
namespace internal {
|
|
|
|
|
2012-12-11 20:23:52 +00:00
|
|
|
// A simple array for POD types with the first SIZE elements stored in
|
|
|
|
// the object itself. It supports a subset of std::vector's operations.
|
2012-12-11 01:16:08 +00:00
|
|
|
template <typename T, std::size_t SIZE>
|
2012-12-11 20:23:52 +00:00
|
|
|
class Array {
|
2012-12-11 01:16:08 +00:00
|
|
|
private:
|
|
|
|
std::size_t size_;
|
|
|
|
std::size_t capacity_;
|
|
|
|
T *ptr_;
|
|
|
|
T data_[SIZE];
|
|
|
|
|
2012-12-11 02:08:04 +00:00
|
|
|
void Grow(std::size_t size);
|
2012-12-11 01:16:08 +00:00
|
|
|
|
|
|
|
// Do not implement!
|
2012-12-11 20:23:52 +00:00
|
|
|
Array(const Array &);
|
|
|
|
void operator=(const Array &);
|
2012-12-11 01:16:08 +00:00
|
|
|
|
|
|
|
public:
|
2012-12-11 20:23:52 +00:00
|
|
|
Array() : size_(0), capacity_(SIZE), ptr_(data_) {}
|
|
|
|
~Array() {
|
2012-12-11 01:16:08 +00:00
|
|
|
if (ptr_ != data_) delete [] ptr_;
|
|
|
|
}
|
|
|
|
|
2012-12-11 20:23:52 +00:00
|
|
|
// Returns the size of this array.
|
2012-12-11 01:16:08 +00:00
|
|
|
std::size_t size() const { return size_; }
|
2012-12-11 04:37:35 +00:00
|
|
|
|
2012-12-11 20:23:52 +00:00
|
|
|
// Returns the capacity of this array.
|
2012-12-11 01:16:08 +00:00
|
|
|
std::size_t capacity() const { return capacity_; }
|
|
|
|
|
2012-12-11 20:23:52 +00:00
|
|
|
// Resizes the array. If T is a POD type new elements are not initialized.
|
2012-12-11 02:08:04 +00:00
|
|
|
void resize(std::size_t new_size) {
|
|
|
|
if (new_size > capacity_)
|
|
|
|
Grow(new_size);
|
|
|
|
size_ = new_size;
|
2012-12-11 01:16:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void reserve(std::size_t capacity) {
|
2012-12-11 02:08:04 +00:00
|
|
|
if (capacity > capacity_)
|
|
|
|
Grow(capacity);
|
2012-12-11 01:16:08 +00:00
|
|
|
}
|
|
|
|
|
2012-12-11 04:37:35 +00:00
|
|
|
void clear() { size_ = 0; }
|
|
|
|
|
2012-12-11 01:16:08 +00:00
|
|
|
void push_back(const T &value) {
|
|
|
|
if (size_ == capacity_)
|
|
|
|
Grow(size_ + 1);
|
|
|
|
ptr_[size_++] = value;
|
|
|
|
}
|
|
|
|
|
2012-12-11 20:23:52 +00:00
|
|
|
// Appends data to the end of the array.
|
2012-12-11 02:08:04 +00:00
|
|
|
void append(const T *begin, const T *end);
|
2012-12-11 01:16:08 +00:00
|
|
|
|
|
|
|
T &operator[](std::size_t index) { return ptr_[index]; }
|
|
|
|
const T &operator[](std::size_t index) const { return ptr_[index]; }
|
|
|
|
};
|
|
|
|
|
2012-12-11 02:08:04 +00:00
|
|
|
template <typename T, std::size_t SIZE>
|
2012-12-11 20:23:52 +00:00
|
|
|
void Array<T, SIZE>::Grow(std::size_t size) {
|
2012-12-11 02:08:04 +00:00
|
|
|
capacity_ = std::max(size, capacity_ + capacity_ / 2);
|
|
|
|
T *p = new T[capacity_];
|
|
|
|
std::copy(ptr_, ptr_ + size_, p);
|
|
|
|
if (ptr_ != data_)
|
|
|
|
delete [] ptr_;
|
|
|
|
ptr_ = p;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, std::size_t SIZE>
|
2012-12-11 20:23:52 +00:00
|
|
|
void Array<T, SIZE>::append(const T *begin, const T *end) {
|
2012-12-11 02:08:04 +00:00
|
|
|
std::ptrdiff_t num_elements = end - begin;
|
|
|
|
if (size_ + num_elements > capacity_)
|
|
|
|
Grow(num_elements);
|
|
|
|
std::copy(begin, end, ptr_ + size_);
|
|
|
|
size_ += num_elements;
|
|
|
|
}
|
|
|
|
|
2012-12-12 17:14:00 +00:00
|
|
|
class ArgInserter;
|
|
|
|
}
|
|
|
|
|
2012-12-11 18:27:13 +00:00
|
|
|
class FormatError : public std::runtime_error {
|
|
|
|
public:
|
2012-12-12 15:44:41 +00:00
|
|
|
explicit FormatError(const std::string &message)
|
|
|
|
: std::runtime_error(message) {}
|
2012-12-11 18:27:13 +00:00
|
|
|
};
|
|
|
|
|
2012-12-11 04:37:35 +00:00
|
|
|
// Formatter provides string formatting functionality similar to Python's
|
|
|
|
// str.format. The output is stored in a memory buffer that grows dynamically.
|
|
|
|
// Usage:
|
|
|
|
//
|
|
|
|
// Formatter out;
|
|
|
|
// out("Current point:\n");
|
|
|
|
// out("(-{:+f}, {:+f})") << 3.14 << -3.14;
|
|
|
|
//
|
|
|
|
// This will populate the buffer of the out object with the following output:
|
|
|
|
//
|
|
|
|
// Current point:
|
|
|
|
// (-3.140000, +3.140000)
|
|
|
|
//
|
|
|
|
// The buffer can be accessed using Formatter::data() or Formatter::c_str().
|
2012-12-07 16:31:09 +00:00
|
|
|
class Formatter {
|
|
|
|
private:
|
2012-12-11 04:37:35 +00:00
|
|
|
enum { INLINE_BUFFER_SIZE = 500 };
|
2012-12-12 17:14:00 +00:00
|
|
|
internal::Array<char, INLINE_BUFFER_SIZE> buffer_; // Output buffer.
|
2012-12-07 16:31:09 +00:00
|
|
|
|
|
|
|
enum Type {
|
2012-12-09 19:32:39 +00:00
|
|
|
// Numeric types should go first.
|
2012-12-09 22:13:23 +00:00
|
|
|
INT, UINT, LONG, ULONG, DOUBLE, LONG_DOUBLE,
|
|
|
|
LAST_NUMERIC_TYPE = LONG_DOUBLE,
|
|
|
|
CHAR, STRING, WSTRING, POINTER, CUSTOM
|
2012-12-07 16:31:09 +00:00
|
|
|
};
|
|
|
|
|
2012-12-09 19:32:39 +00:00
|
|
|
typedef void (Formatter::*FormatFunc)(const void *arg, int width);
|
|
|
|
|
2012-12-11 01:16:08 +00:00
|
|
|
// A format argument.
|
2012-12-11 18:27:13 +00:00
|
|
|
class Arg {
|
|
|
|
private:
|
|
|
|
// This method is private to disallow formatting of arbitrary pointers.
|
|
|
|
// If you want to output a pointer cast it to const void*. Do not implement!
|
|
|
|
template <typename T>
|
|
|
|
Arg(const T *value);
|
|
|
|
|
|
|
|
// This method is private to disallow formatting of arbitrary pointers.
|
|
|
|
// If you want to output a pointer cast it to void*. Do not implement!
|
|
|
|
template <typename T>
|
|
|
|
Arg(T *value);
|
|
|
|
|
|
|
|
// This method is private to disallow formatting of wide characters.
|
|
|
|
// If you want to output a wide character cast it to integer type.
|
|
|
|
// Do not implement!
|
|
|
|
Arg(wchar_t value);
|
|
|
|
|
|
|
|
public:
|
2012-12-07 16:31:09 +00:00
|
|
|
Type type;
|
|
|
|
union {
|
|
|
|
int int_value;
|
|
|
|
unsigned uint_value;
|
|
|
|
double double_value;
|
|
|
|
long long_value;
|
|
|
|
unsigned long ulong_value;
|
|
|
|
long double long_double_value;
|
2012-12-11 01:16:08 +00:00
|
|
|
const void *pointer_value;
|
2012-12-08 16:17:12 +00:00
|
|
|
struct {
|
2012-12-12 05:47:05 +00:00
|
|
|
const char *value;
|
2012-12-09 17:03:47 +00:00
|
|
|
std::size_t size;
|
2012-12-12 05:47:05 +00:00
|
|
|
} string;
|
2012-12-09 17:03:47 +00:00
|
|
|
struct {
|
2012-12-12 05:47:05 +00:00
|
|
|
const void *value;
|
2012-12-09 19:32:39 +00:00
|
|
|
FormatFunc format;
|
2012-12-12 05:47:05 +00:00
|
|
|
} custom;
|
2012-12-07 16:31:09 +00:00
|
|
|
};
|
2012-12-11 20:23:52 +00:00
|
|
|
mutable Formatter *formatter;
|
2012-12-11 18:27:13 +00:00
|
|
|
|
2012-12-12 05:47:05 +00:00
|
|
|
Arg(int value) : type(INT), int_value(value), formatter(0) {}
|
|
|
|
Arg(unsigned value) : type(UINT), uint_value(value), formatter(0) {}
|
|
|
|
Arg(long value) : type(LONG), long_value(value), formatter(0) {}
|
|
|
|
Arg(unsigned long value) : type(ULONG), ulong_value(value), formatter(0) {}
|
|
|
|
Arg(double value) : type(DOUBLE), double_value(value), formatter(0) {}
|
|
|
|
Arg(long double value)
|
|
|
|
: type(LONG_DOUBLE), long_double_value(value), formatter(0) {}
|
|
|
|
Arg(char value) : type(CHAR), int_value(value), formatter(0) {}
|
|
|
|
|
|
|
|
Arg(const char *value) : type(STRING), formatter(0) {
|
|
|
|
string.value = value;
|
|
|
|
string.size = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
Arg(char *value) : type(STRING), formatter(0) {
|
|
|
|
string.value = value;
|
|
|
|
string.size = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
Arg(const void *value)
|
|
|
|
: type(POINTER), pointer_value(value), formatter(0) {}
|
|
|
|
|
|
|
|
Arg(void *value) : type(POINTER), pointer_value(value), formatter(0) {}
|
|
|
|
|
|
|
|
Arg(const std::string &value) : type(STRING), formatter(0) {
|
|
|
|
string.value = value.c_str();
|
|
|
|
string.size = value.size();
|
|
|
|
}
|
2012-12-11 18:27:13 +00:00
|
|
|
|
|
|
|
template <typename T>
|
2012-12-12 05:47:05 +00:00
|
|
|
Arg(const T &value) : type(CUSTOM), formatter(0) {
|
|
|
|
custom.value = &value;
|
|
|
|
custom.format = &Formatter::FormatCustomArg<T>;
|
|
|
|
}
|
2012-12-11 18:27:13 +00:00
|
|
|
|
|
|
|
~Arg() {
|
2012-12-11 21:54:53 +00:00
|
|
|
// Format is called here to make sure that a referred object is
|
|
|
|
// still alive, for example:
|
2012-12-11 18:27:13 +00:00
|
|
|
//
|
|
|
|
// Print("{0}") << std::string("test");
|
|
|
|
//
|
|
|
|
// Here an Arg object refers to a temporary std::string which is
|
|
|
|
// destroyed at the end of the statement. Since the string object is
|
|
|
|
// constructed before the Arg object, it will be destroyed after,
|
2012-12-11 21:54:53 +00:00
|
|
|
// so it will be alive in the Arg's destructor where Format is called.
|
2012-12-11 18:27:13 +00:00
|
|
|
// Note that the string object will not necessarily be alive when
|
2012-12-12 00:26:04 +00:00
|
|
|
// the destructor of ArgInserter is called.
|
2012-12-11 20:23:52 +00:00
|
|
|
formatter->Format();
|
2012-12-11 18:27:13 +00:00
|
|
|
}
|
2012-12-07 16:31:09 +00:00
|
|
|
};
|
|
|
|
|
2012-12-11 04:37:35 +00:00
|
|
|
enum { NUM_INLINE_ARGS = 10 };
|
2012-12-12 17:14:00 +00:00
|
|
|
internal::Array<const Arg*, NUM_INLINE_ARGS> args_; // Format arguments.
|
2012-12-07 16:31:09 +00:00
|
|
|
|
2012-12-08 01:48:10 +00:00
|
|
|
const char *format_; // Format string.
|
2012-12-07 16:31:09 +00:00
|
|
|
|
2012-12-12 17:14:00 +00:00
|
|
|
friend class internal::ArgInserter;
|
2012-12-07 16:31:09 +00:00
|
|
|
|
|
|
|
void Add(const Arg &arg) {
|
2012-12-11 18:27:13 +00:00
|
|
|
args_.push_back(&arg);
|
2012-12-07 16:31:09 +00:00
|
|
|
}
|
|
|
|
|
2012-12-10 19:08:16 +00:00
|
|
|
// Formats an integer.
|
2012-12-07 16:31:09 +00:00
|
|
|
template <typename T>
|
2012-12-10 19:08:16 +00:00
|
|
|
void FormatInt(T value, unsigned flags, int width, char type);
|
|
|
|
|
2012-12-10 23:04:55 +00:00
|
|
|
// Formats a floating point number (double or long double).
|
2012-12-10 19:08:16 +00:00
|
|
|
template <typename T>
|
|
|
|
void FormatDouble(
|
|
|
|
T value, unsigned flags, int width, int precision, char type);
|
2012-12-07 16:31:09 +00:00
|
|
|
|
2012-12-09 17:03:47 +00:00
|
|
|
// Formats an argument of a custom type, such as a user-defined class.
|
2012-12-08 16:17:12 +00:00
|
|
|
template <typename T>
|
2012-12-09 19:32:39 +00:00
|
|
|
void FormatCustomArg(const void *arg, int width);
|
2012-12-08 16:17:12 +00:00
|
|
|
|
2012-12-11 20:23:52 +00:00
|
|
|
void DoFormat();
|
|
|
|
|
|
|
|
void Format() {
|
|
|
|
if (!format_) return;
|
|
|
|
DoFormat();
|
|
|
|
}
|
2012-12-07 16:31:09 +00:00
|
|
|
|
2012-12-11 02:08:04 +00:00
|
|
|
// Grows the buffer by n characters and returns a pointer to the newly
|
|
|
|
// allocated area.
|
|
|
|
char *GrowBuffer(std::size_t n) {
|
|
|
|
std::size_t size = buffer_.size();
|
|
|
|
buffer_.resize(size + n);
|
|
|
|
return &buffer_[size];
|
2012-12-11 01:16:08 +00:00
|
|
|
}
|
|
|
|
|
2012-12-07 16:31:09 +00:00
|
|
|
public:
|
2012-12-11 21:54:53 +00:00
|
|
|
Formatter() : format_(0) { buffer_[0] = 0; }
|
2012-12-07 16:31:09 +00:00
|
|
|
|
2012-12-11 16:41:06 +00:00
|
|
|
// Formats a string appending the output to the internal buffer.
|
2012-12-12 00:26:04 +00:00
|
|
|
// Arguments are accepted through the returned ArgInserter object
|
2012-12-11 16:41:06 +00:00
|
|
|
// using inserter operator<<.
|
2012-12-12 17:14:00 +00:00
|
|
|
internal::ArgInserter operator()(const char *format);
|
2012-12-07 16:31:09 +00:00
|
|
|
|
2012-12-09 17:03:47 +00:00
|
|
|
std::size_t size() const { return buffer_.size(); }
|
2012-12-08 16:17:12 +00:00
|
|
|
|
2012-12-11 01:16:08 +00:00
|
|
|
const char *data() const { return &buffer_[0]; }
|
|
|
|
const char *c_str() const { return &buffer_[0]; }
|
2012-12-11 21:54:53 +00:00
|
|
|
|
|
|
|
std::string str() const { return std::string(&buffer_[0], buffer_.size()); }
|
2012-12-07 16:31:09 +00:00
|
|
|
};
|
|
|
|
|
2012-12-12 17:14:00 +00:00
|
|
|
namespace internal {
|
|
|
|
|
|
|
|
// This is a transient object that normally exists only as a temporary
|
|
|
|
// returned by one of the formatting functions. It stores a reference
|
|
|
|
// to a formatter and provides operator<< that feeds arguments to the
|
|
|
|
// formatter.
|
|
|
|
class ArgInserter {
|
|
|
|
private:
|
|
|
|
mutable Formatter *formatter_;
|
|
|
|
|
|
|
|
friend class format::Formatter;
|
|
|
|
|
|
|
|
protected:
|
|
|
|
explicit ArgInserter(Formatter *f = 0) : formatter_(f) {}
|
|
|
|
|
|
|
|
ArgInserter(ArgInserter& other)
|
|
|
|
: formatter_(other.formatter_) {
|
|
|
|
other.formatter_ = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
ArgInserter& operator=(const ArgInserter& other) {
|
|
|
|
formatter_ = other.formatter_;
|
|
|
|
other.formatter_ = 0;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Formatter *Format() const {
|
|
|
|
Formatter *f = formatter_;
|
|
|
|
if (f) {
|
|
|
|
formatter_ = 0;
|
|
|
|
f->Format();
|
|
|
|
}
|
|
|
|
return f;
|
|
|
|
}
|
|
|
|
|
|
|
|
Formatter *formatter() const { return formatter_; }
|
|
|
|
const char *format() const { return formatter_->format_; }
|
|
|
|
|
|
|
|
void ResetFormatter() { formatter_ = 0; }
|
|
|
|
|
|
|
|
public:
|
|
|
|
~ArgInserter() {
|
|
|
|
if (formatter_)
|
|
|
|
formatter_->Format();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Feeds an argument to a formatter.
|
|
|
|
ArgInserter &operator<<(const Formatter::Arg &arg) {
|
|
|
|
arg.formatter = formatter_;
|
|
|
|
formatter_->Add(arg);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Performs formatting and returns a C string with the output.
|
|
|
|
friend const char *c_str(const ArgInserter &af) {
|
|
|
|
return af.Format()->c_str();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Performs formatting and returns a std::string with the output.
|
|
|
|
friend std::string str(const ArgInserter &af) {
|
|
|
|
return af.Format()->str();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2012-12-09 17:03:47 +00:00
|
|
|
template <typename T>
|
2012-12-09 19:32:39 +00:00
|
|
|
void Formatter::FormatCustomArg(const void *arg, int width) {
|
2012-12-09 17:03:47 +00:00
|
|
|
const T &value = *static_cast<const T*>(arg);
|
|
|
|
std::ostringstream os;
|
|
|
|
os << value;
|
|
|
|
std::string str(os.str());
|
2012-12-11 02:08:04 +00:00
|
|
|
char *out = GrowBuffer(std::max<std::size_t>(width, str.size()));
|
2012-12-11 01:16:08 +00:00
|
|
|
std::copy(str.begin(), str.end(), out);
|
2012-12-12 05:47:05 +00:00
|
|
|
if (static_cast<unsigned>(width) > str.size())
|
2012-12-11 01:16:08 +00:00
|
|
|
std::fill_n(out + str.size(), width - str.size(), ' ');
|
2012-12-09 17:03:47 +00:00
|
|
|
}
|
|
|
|
|
2012-12-12 17:14:00 +00:00
|
|
|
inline internal::ArgInserter Formatter::operator()(const char *format) {
|
|
|
|
internal::ArgInserter formatter(this);
|
2012-12-07 16:31:09 +00:00
|
|
|
format_ = format;
|
2012-12-11 01:16:08 +00:00
|
|
|
args_.clear();
|
2012-12-11 16:41:06 +00:00
|
|
|
return formatter;
|
2012-12-07 16:31:09 +00:00
|
|
|
}
|
|
|
|
|
2012-12-11 21:54:53 +00:00
|
|
|
// A formatter with an action performed when formatting is complete.
|
2012-12-12 04:49:01 +00:00
|
|
|
// This is a transient object that normally exists only as a temporary
|
|
|
|
// returned by one of the formatting functions.
|
2012-12-11 21:54:53 +00:00
|
|
|
template <typename Action>
|
2012-12-12 17:14:00 +00:00
|
|
|
class ActiveFormatter : public internal::ArgInserter {
|
2012-12-07 16:31:09 +00:00
|
|
|
private:
|
2012-12-12 00:26:04 +00:00
|
|
|
Formatter formatter_;
|
|
|
|
Action action_;
|
2012-12-07 16:31:09 +00:00
|
|
|
|
|
|
|
// Do not implement.
|
2012-12-11 21:54:53 +00:00
|
|
|
ActiveFormatter& operator=(const ActiveFormatter&);
|
2012-12-07 16:31:09 +00:00
|
|
|
|
|
|
|
public:
|
2012-12-12 00:26:04 +00:00
|
|
|
// Creates an active formatter with a format string and an action.
|
|
|
|
// Action should be an unary function object that takes a const
|
|
|
|
// reference to Formatter as an argument. See Ignore and Write
|
|
|
|
// for examples of action classes.
|
|
|
|
explicit ActiveFormatter(const char *format, Action a = Action())
|
|
|
|
: action_(a) {
|
|
|
|
ArgInserter::operator=(formatter_(format));
|
2012-12-07 16:31:09 +00:00
|
|
|
}
|
|
|
|
|
2012-12-12 04:49:01 +00:00
|
|
|
// Creates an active formatter with the same format string and action
|
|
|
|
// as other has and modifies other so that it doesn't call action in
|
|
|
|
// destructor. Note that the buffer content is not copied because the
|
|
|
|
// the buffer in ActiveFormatter is populated when all the arguments
|
|
|
|
// are provided.
|
2012-12-12 05:47:05 +00:00
|
|
|
ActiveFormatter(ActiveFormatter &other)
|
|
|
|
: ArgInserter(0), action_(other.action_) {
|
2012-12-12 17:14:00 +00:00
|
|
|
ArgInserter::operator=(formatter_(other.format()));
|
2012-12-12 04:49:01 +00:00
|
|
|
other.ResetFormatter();
|
|
|
|
}
|
2012-12-08 16:17:12 +00:00
|
|
|
|
2012-12-11 21:54:53 +00:00
|
|
|
~ActiveFormatter() {
|
2012-12-12 04:49:01 +00:00
|
|
|
if (formatter())
|
|
|
|
action_(*Format());
|
2012-12-07 16:31:09 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2012-12-12 00:26:04 +00:00
|
|
|
// A formatting action that does nothing.
|
2012-12-11 21:54:53 +00:00
|
|
|
struct Ignore {
|
2012-12-12 00:26:04 +00:00
|
|
|
void operator()(const Formatter &) const {}
|
2012-12-11 21:54:53 +00:00
|
|
|
};
|
2012-12-07 16:31:09 +00:00
|
|
|
|
2012-12-12 00:26:04 +00:00
|
|
|
// Formats a string.
|
|
|
|
// Example:
|
|
|
|
// std::string s = str(Format("Elapsed time: {0:.2f} seconds") << 1.23);
|
2012-12-11 21:54:53 +00:00
|
|
|
inline ActiveFormatter<Ignore> Format(const char *format) {
|
|
|
|
ActiveFormatter<Ignore> af(format);
|
|
|
|
return af;
|
|
|
|
}
|
2012-12-07 16:31:09 +00:00
|
|
|
|
2012-12-12 00:26:04 +00:00
|
|
|
// A formatting action that writes formatted output to stdout.
|
2012-12-11 21:54:53 +00:00
|
|
|
struct Write {
|
2012-12-12 00:26:04 +00:00
|
|
|
void operator()(const Formatter &f) const {
|
2012-12-11 21:54:53 +00:00
|
|
|
std::fwrite(f.data(), 1, f.size(), stdout);
|
2012-12-07 16:31:09 +00:00
|
|
|
}
|
|
|
|
};
|
2012-12-11 21:54:53 +00:00
|
|
|
|
2012-12-12 00:26:04 +00:00
|
|
|
// Formats a string and prints it to stdout.
|
|
|
|
// Example:
|
|
|
|
// Print("Elapsed time: {0:.2f} seconds") << 1.23;
|
2012-12-11 21:54:53 +00:00
|
|
|
inline ActiveFormatter<Write> Print(const char *format) {
|
|
|
|
ActiveFormatter<Write> af(format);
|
|
|
|
return af;
|
|
|
|
}
|
2012-12-07 16:31:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
namespace fmt = format;
|
|
|
|
|
|
|
|
#endif // FORMAT_H_
|