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_
|
|
|
|
|
2013-01-08 17:56:05 +00:00
|
|
|
#include <stdint.h>
|
|
|
|
|
2012-12-07 16:31:09 +00:00
|
|
|
#include <cstddef>
|
2012-12-18 23:50:14 +00:00
|
|
|
#include <cstdio>
|
2012-12-18 23:39:42 +00:00
|
|
|
#include <cstring>
|
2012-12-07 16:31:09 +00:00
|
|
|
#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;
|
|
|
|
}
|
|
|
|
|
2013-01-08 17:56:05 +00:00
|
|
|
// Information about an integer type.
|
2013-01-13 15:14:54 +00:00
|
|
|
// IntTraits is not specialized for integer types smaller than int,
|
|
|
|
// since these are promoted to int.
|
2013-01-08 17:56:05 +00:00
|
|
|
template <typename T>
|
2013-01-13 15:14:54 +00:00
|
|
|
struct IntTraits {};
|
|
|
|
|
|
|
|
template <typename T, typename UnsignedT>
|
|
|
|
struct SignedIntTraits {
|
|
|
|
typedef T Type;
|
|
|
|
typedef UnsignedT UnsignedType;
|
|
|
|
static bool IsNegative(T value) { return value < 0; }
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
struct UnsignedIntTraits {
|
|
|
|
typedef T Type;
|
2013-01-08 17:56:05 +00:00
|
|
|
typedef T UnsignedType;
|
|
|
|
static bool IsNegative(T) { return false; }
|
|
|
|
};
|
|
|
|
|
|
|
|
template <>
|
2013-01-13 15:14:54 +00:00
|
|
|
struct IntTraits<int> : SignedIntTraits<int, unsigned> {};
|
2013-01-08 17:56:05 +00:00
|
|
|
|
|
|
|
template <>
|
2013-01-13 15:14:54 +00:00
|
|
|
struct IntTraits<unsigned> : UnsignedIntTraits<unsigned> {};
|
|
|
|
|
|
|
|
template <>
|
|
|
|
struct IntTraits<long> : SignedIntTraits<long, unsigned long> {};
|
|
|
|
|
|
|
|
template <>
|
|
|
|
struct IntTraits<unsigned long> : UnsignedIntTraits<unsigned long> {};
|
2013-01-08 17:56:05 +00:00
|
|
|
|
2012-12-12 17:14:00 +00:00
|
|
|
class ArgInserter;
|
|
|
|
}
|
|
|
|
|
2013-01-04 15:04:35 +00:00
|
|
|
/**
|
|
|
|
\rst
|
|
|
|
A string reference. It can be constructed from a C string, ``std::string``
|
|
|
|
or as a result of a formatting operation. It is most useful as a parameter
|
|
|
|
type to allow passing different types of strings in a function, for example::
|
|
|
|
|
|
|
|
TempFormatter<> Format(StringRef format);
|
2013-01-04 17:14:34 +00:00
|
|
|
|
|
|
|
Format("{}") << 42;
|
|
|
|
Format(std::string("{}")) << 42;
|
|
|
|
Format(Format("{{}}")) << 42;
|
2013-01-04 15:04:35 +00:00
|
|
|
\endrst
|
|
|
|
*/
|
2012-12-25 21:25:14 +00:00
|
|
|
class StringRef {
|
|
|
|
private:
|
|
|
|
const char *data_;
|
|
|
|
mutable std::size_t size_;
|
|
|
|
|
|
|
|
public:
|
2013-01-13 15:14:54 +00:00
|
|
|
/**
|
|
|
|
Constructs a string reference object from a C string and a size.
|
|
|
|
If `size` is zero, which is the default, the size is computed with
|
|
|
|
`strlen`.
|
|
|
|
*/
|
2012-12-25 21:25:14 +00:00
|
|
|
StringRef(const char *s, std::size_t size = 0) : data_(s), size_(size) {}
|
2013-01-13 15:14:54 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
Constructs a string reference from an `std::string` object.
|
|
|
|
*/
|
2012-12-25 21:25:14 +00:00
|
|
|
StringRef(const std::string &s) : data_(s.c_str()), size_(s.size()) {}
|
|
|
|
|
2013-01-13 15:14:54 +00:00
|
|
|
/**
|
|
|
|
Converts a string reference to an `std::string` object.
|
|
|
|
*/
|
2012-12-25 21:25:14 +00:00
|
|
|
operator std::string() const { return std::string(data_, size()); }
|
|
|
|
|
2013-01-13 15:14:54 +00:00
|
|
|
/**
|
|
|
|
Returns the pointer to a C string.
|
|
|
|
*/
|
2012-12-25 21:25:14 +00:00
|
|
|
const char *c_str() const { return data_; }
|
|
|
|
|
2013-01-13 15:14:54 +00:00
|
|
|
/**
|
|
|
|
Returns the string size.
|
|
|
|
*/
|
2012-12-25 21:25:14 +00:00
|
|
|
std::size_t size() const {
|
|
|
|
if (size_ == 0) size_ = std::strlen(data_);
|
|
|
|
return size_;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
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-22 22:05:56 +00:00
|
|
|
enum Alignment {
|
|
|
|
ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC
|
|
|
|
};
|
|
|
|
|
2013-01-08 17:56:05 +00:00
|
|
|
// Flags.
|
|
|
|
enum { SIGN_FLAG = 1, PLUS_FLAG = 2, HASH_FLAG = 4 };
|
|
|
|
|
|
|
|
struct Spec {};
|
|
|
|
|
|
|
|
template <char TYPE>
|
|
|
|
struct TypeSpec : Spec {
|
|
|
|
Alignment align() const { return ALIGN_DEFAULT; }
|
|
|
|
unsigned width() const { return 0; }
|
|
|
|
|
|
|
|
bool sign_flag() const { return false; }
|
|
|
|
bool plus_flag() const { return false; }
|
|
|
|
bool hash_flag() const { return false; }
|
|
|
|
|
|
|
|
char type() const { return TYPE; }
|
|
|
|
char fill() const { return ' '; }
|
|
|
|
};
|
|
|
|
|
|
|
|
struct WidthSpec {
|
|
|
|
unsigned width_;
|
|
|
|
char fill_;
|
|
|
|
|
|
|
|
WidthSpec(unsigned width, char fill) : width_(width), fill_(fill) {}
|
|
|
|
|
|
|
|
unsigned width() const { return width_; }
|
|
|
|
char fill() const { return fill_; }
|
|
|
|
};
|
|
|
|
|
|
|
|
struct AlignSpec : WidthSpec {
|
|
|
|
Alignment align_;
|
|
|
|
|
|
|
|
AlignSpec(unsigned width, char fill)
|
|
|
|
: WidthSpec(width, fill), align_(ALIGN_DEFAULT) {}
|
|
|
|
|
|
|
|
Alignment align() const { return align_; }
|
|
|
|
};
|
|
|
|
|
|
|
|
template <char TYPE>
|
|
|
|
struct AlignTypeSpec : AlignSpec {
|
|
|
|
AlignTypeSpec(unsigned width, char fill) : AlignSpec(width, fill) {}
|
|
|
|
|
|
|
|
bool sign_flag() const { return false; }
|
|
|
|
bool plus_flag() const { return false; }
|
|
|
|
bool hash_flag() const { return false; }
|
|
|
|
|
|
|
|
char type() const { return TYPE; }
|
|
|
|
};
|
|
|
|
|
|
|
|
struct FormatSpec : AlignSpec {
|
|
|
|
unsigned flags_;
|
|
|
|
char type_;
|
2012-12-21 17:12:04 +00:00
|
|
|
|
2013-01-04 17:14:34 +00:00
|
|
|
FormatSpec(unsigned width = 0, char type = 0, char fill = ' ')
|
2013-01-08 17:56:05 +00:00
|
|
|
: AlignSpec(width, fill), flags_(0), type_(type) {}
|
|
|
|
|
|
|
|
Alignment align() const { return align_; }
|
|
|
|
|
|
|
|
bool sign_flag() const { return (flags_ & SIGN_FLAG) != 0; }
|
|
|
|
bool plus_flag() const { return (flags_ & PLUS_FLAG) != 0; }
|
|
|
|
bool hash_flag() const { return (flags_ & HASH_FLAG) != 0; }
|
|
|
|
|
|
|
|
char type() const { return type_; }
|
|
|
|
};
|
|
|
|
|
2013-01-12 18:17:56 +00:00
|
|
|
template <typename T, typename SpecT>
|
|
|
|
class IntFormatter : public SpecT {
|
2013-01-08 17:56:05 +00:00
|
|
|
private:
|
|
|
|
T value_;
|
|
|
|
|
|
|
|
public:
|
2013-01-12 18:17:56 +00:00
|
|
|
IntFormatter(T value, const SpecT &spec = SpecT())
|
|
|
|
: SpecT(spec), value_(value) {}
|
2013-01-08 17:56:05 +00:00
|
|
|
|
|
|
|
T value() const { return value_; }
|
2012-12-21 04:10:55 +00:00
|
|
|
};
|
|
|
|
|
2013-01-13 15:14:54 +00:00
|
|
|
// internal::IntTraits<T>::Type is used instead of T to avoid instantiating
|
|
|
|
// the function for types smaller than int similarly to enable_if.
|
|
|
|
template <typename T>
|
|
|
|
inline IntFormatter<
|
|
|
|
typename internal::IntTraits<T>::Type, TypeSpec<'o'> > oct(T value) {
|
|
|
|
return IntFormatter<T, TypeSpec<'o'> >(value, TypeSpec<'o'>());
|
2013-01-08 17:56:05 +00:00
|
|
|
}
|
|
|
|
|
2013-01-13 15:14:54 +00:00
|
|
|
template <typename T>
|
|
|
|
inline IntFormatter<
|
|
|
|
typename internal::IntTraits<T>::Type, TypeSpec<'x'> > hex(T value) {
|
|
|
|
return IntFormatter<T, TypeSpec<'x'> >(value, TypeSpec<'x'>());
|
2013-01-08 17:56:05 +00:00
|
|
|
}
|
|
|
|
|
2013-01-13 15:14:54 +00:00
|
|
|
template <typename T>
|
|
|
|
inline IntFormatter<
|
|
|
|
typename internal::IntTraits<T>::Type, TypeSpec<'X'> > hexu(T value) {
|
|
|
|
return IntFormatter<T, TypeSpec<'X'> >(value, TypeSpec<'X'>());
|
2013-01-08 17:56:05 +00:00
|
|
|
}
|
|
|
|
|
2013-01-13 15:14:54 +00:00
|
|
|
template <typename T, char TYPE>
|
|
|
|
inline IntFormatter<
|
|
|
|
typename internal::IntTraits<T>::Type, AlignTypeSpec<TYPE> > pad(
|
|
|
|
IntFormatter<T, TypeSpec<TYPE> > f, unsigned width, char fill = ' ') {
|
|
|
|
return IntFormatter<T, AlignTypeSpec<TYPE> >(
|
2013-01-08 17:56:05 +00:00
|
|
|
f.value(), AlignTypeSpec<TYPE>(width, fill));
|
|
|
|
}
|
|
|
|
|
2013-01-13 15:14:54 +00:00
|
|
|
template <typename T>
|
|
|
|
inline IntFormatter<
|
|
|
|
typename internal::IntTraits<T>::Type, AlignTypeSpec<0> > pad(
|
|
|
|
T value, unsigned width, char fill = ' ') {
|
|
|
|
return IntFormatter<T, AlignTypeSpec<0> >(
|
2013-01-08 17:56:05 +00:00
|
|
|
value, AlignTypeSpec<0>(width, fill));
|
|
|
|
}
|
|
|
|
|
2012-12-26 01:55:41 +00:00
|
|
|
class BasicFormatter {
|
2013-01-08 17:56:05 +00:00
|
|
|
private:
|
|
|
|
static unsigned CountDigits(uint64_t n) {
|
|
|
|
unsigned count = 1;
|
|
|
|
for (;;) {
|
|
|
|
// Integer division is slow so do it for a group of four digits instead
|
|
|
|
// of for every digit. The idea comes from the talk by Alexandrescu
|
|
|
|
// "Three Optimization Tips for C++". See speed-test for a comparison.
|
|
|
|
if (n < 10) return count;
|
|
|
|
if (n < 100) return count + 1;
|
|
|
|
if (n < 1000) return count + 2;
|
|
|
|
if (n < 10000) return count + 3;
|
|
|
|
n /= 10000u;
|
|
|
|
count += 4;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void FormatDecimal(char *buffer, uint64_t value, unsigned num_digits);
|
|
|
|
|
2012-12-26 01:55:41 +00:00
|
|
|
protected:
|
2013-01-08 17:56:05 +00:00
|
|
|
static void ReportUnknownType(char code, const char *type);
|
|
|
|
|
2012-12-26 01:55:41 +00:00
|
|
|
enum { INLINE_BUFFER_SIZE = 500 };
|
2013-01-04 17:14:34 +00:00
|
|
|
mutable internal::Array<char, INLINE_BUFFER_SIZE> buffer_; // Output buffer.
|
2012-12-26 01:55:41 +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];
|
|
|
|
}
|
|
|
|
|
2013-01-08 17:56:05 +00:00
|
|
|
char *PrepareFilledBuffer(unsigned size, const Spec &, char sign) {
|
|
|
|
char *p = GrowBuffer(size);
|
|
|
|
*p = sign;
|
|
|
|
return p + size - 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
char *PrepareFilledBuffer(unsigned size, const AlignSpec &spec, char sign);
|
2013-01-04 17:14:34 +00:00
|
|
|
|
|
|
|
// Formats an integer.
|
|
|
|
template <typename T>
|
2013-01-08 17:56:05 +00:00
|
|
|
void FormatInt(T value, const FormatSpec &spec) {
|
|
|
|
*this << IntFormatter<T, FormatSpec>(value, spec);
|
|
|
|
}
|
2013-01-04 17:14:34 +00:00
|
|
|
|
|
|
|
// Formats a floating point number (double or long double).
|
|
|
|
template <typename T>
|
|
|
|
void FormatDouble(T value, const FormatSpec &spec, int precision);
|
|
|
|
|
|
|
|
char *FormatString(const char *s, std::size_t size, const FormatSpec &spec);
|
|
|
|
|
2012-12-26 01:55:41 +00:00
|
|
|
public:
|
2013-01-04 17:14:34 +00:00
|
|
|
/**
|
|
|
|
Returns the number of characters written to the output buffer.
|
|
|
|
*/
|
|
|
|
std::size_t size() const { return buffer_.size(); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
Returns a pointer to the output buffer content. No terminating null
|
|
|
|
character is appended.
|
|
|
|
*/
|
|
|
|
const char *data() const { return &buffer_[0]; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
Returns a pointer to the output buffer content with terminating null
|
|
|
|
character appended.
|
|
|
|
*/
|
|
|
|
const char *c_str() const {
|
|
|
|
std::size_t size = buffer_.size();
|
|
|
|
buffer_.reserve(size + 1);
|
|
|
|
buffer_[size] = '\0';
|
|
|
|
return &buffer_[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2013-01-13 15:14:54 +00:00
|
|
|
Returns the content of the output buffer as an `std::string`.
|
2013-01-04 17:14:34 +00:00
|
|
|
*/
|
|
|
|
std::string str() const { return std::string(&buffer_[0], buffer_.size()); }
|
|
|
|
|
2013-01-08 17:56:05 +00:00
|
|
|
BasicFormatter &operator<<(int value) {
|
|
|
|
return *this << IntFormatter<int, TypeSpec<0> >(value, TypeSpec<0>());
|
|
|
|
}
|
|
|
|
BasicFormatter &operator<<(unsigned value) {
|
|
|
|
return *this << IntFormatter<unsigned, TypeSpec<0> >(value, TypeSpec<0>());
|
|
|
|
}
|
2013-01-04 17:14:34 +00:00
|
|
|
|
2013-01-08 17:56:05 +00:00
|
|
|
BasicFormatter &operator<<(char value) {
|
2013-01-04 17:14:34 +00:00
|
|
|
*GrowBuffer(1) = value;
|
2013-01-08 17:56:05 +00:00
|
|
|
return *this;
|
2013-01-04 17:14:34 +00:00
|
|
|
}
|
|
|
|
|
2013-01-08 17:56:05 +00:00
|
|
|
BasicFormatter &operator<<(const char *value) {
|
2013-01-04 17:14:34 +00:00
|
|
|
std::size_t size = std::strlen(value);
|
|
|
|
std::strncpy(GrowBuffer(size), value, size);
|
2013-01-08 17:56:05 +00:00
|
|
|
return *this;
|
2013-01-04 17:14:34 +00:00
|
|
|
}
|
|
|
|
|
2013-01-08 17:56:05 +00:00
|
|
|
template <typename T, typename Spec>
|
|
|
|
BasicFormatter &operator<<(const IntFormatter<T, Spec> &f);
|
|
|
|
|
|
|
|
void Write(const std::string &s, const FormatSpec &spec) {
|
|
|
|
FormatString(s.data(), s.size(), spec);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Clear() {
|
|
|
|
buffer_.clear();
|
2013-01-04 17:14:34 +00:00
|
|
|
}
|
2012-12-26 01:55:41 +00:00
|
|
|
};
|
|
|
|
|
2013-01-08 17:56:05 +00:00
|
|
|
template <typename T, typename Spec>
|
|
|
|
BasicFormatter &BasicFormatter::operator<<(const IntFormatter<T, Spec> &f) {
|
|
|
|
T value = f.value();
|
|
|
|
unsigned size = 0;
|
|
|
|
char sign = 0;
|
|
|
|
typedef typename internal::IntTraits<T>::UnsignedType UnsignedType;
|
|
|
|
UnsignedType abs_value = value;
|
|
|
|
if (internal::IntTraits<T>::IsNegative(value)) {
|
|
|
|
sign = '-';
|
|
|
|
++size;
|
|
|
|
abs_value = 0 - abs_value;
|
|
|
|
} else if (f.sign_flag()) {
|
|
|
|
sign = f.plus_flag() ? '+' : ' ';
|
|
|
|
++size;
|
|
|
|
}
|
|
|
|
switch (f.type()) {
|
|
|
|
case 0: case 'd': {
|
|
|
|
unsigned num_digits = BasicFormatter::CountDigits(abs_value);
|
|
|
|
char *p = PrepareFilledBuffer(size + num_digits, f, sign)
|
|
|
|
- num_digits + 1;
|
|
|
|
BasicFormatter::FormatDecimal(p, abs_value, num_digits);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case 'x': case 'X': {
|
|
|
|
UnsignedType n = abs_value;
|
|
|
|
bool print_prefix = f.hash_flag();
|
|
|
|
if (print_prefix) size += 2;
|
|
|
|
do {
|
|
|
|
++size;
|
|
|
|
} while ((n >>= 4) != 0);
|
|
|
|
char *p = PrepareFilledBuffer(size, f, sign);
|
|
|
|
n = abs_value;
|
|
|
|
const char *digits = f.type() == 'x' ?
|
|
|
|
"0123456789abcdef" : "0123456789ABCDEF";
|
|
|
|
do {
|
|
|
|
*p-- = digits[n & 0xf];
|
|
|
|
} while ((n >>= 4) != 0);
|
|
|
|
if (print_prefix) {
|
|
|
|
*p-- = f.type();
|
|
|
|
*p = '0';
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case 'o': {
|
|
|
|
UnsignedType n = abs_value;
|
|
|
|
bool print_prefix = f.hash_flag();
|
|
|
|
if (print_prefix) ++size;
|
|
|
|
do {
|
|
|
|
++size;
|
|
|
|
} while ((n >>= 3) != 0);
|
|
|
|
char *p = PrepareFilledBuffer(size, f, sign);
|
|
|
|
n = abs_value;
|
|
|
|
do {
|
|
|
|
*p-- = '0' + (n & 7);
|
|
|
|
} while ((n >>= 3) != 0);
|
|
|
|
if (print_prefix)
|
|
|
|
*p = '0';
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
BasicFormatter::ReportUnknownType(f.type(), "integer");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-12-29 17:27:26 +00:00
|
|
|
/**
|
|
|
|
\rst
|
2013-01-03 16:57:34 +00:00
|
|
|
The :cpp:class:`format::Formatter` class provides string formatting
|
2012-12-29 17:27:26 +00:00
|
|
|
functionality similar to Python's `str.format
|
|
|
|
<http://docs.python.org/3/library/stdtypes.html#str.format>`__.
|
|
|
|
The output is stored in a memory buffer that grows dynamically.
|
|
|
|
|
2013-01-03 16:57:34 +00:00
|
|
|
**Example**::
|
2012-12-29 17:27:26 +00:00
|
|
|
|
|
|
|
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:
|
|
|
|
|
|
|
|
.. code-block:: none
|
|
|
|
|
|
|
|
Current point:
|
|
|
|
(-3.140000, +3.140000)
|
|
|
|
|
|
|
|
The buffer can be accessed using :meth:`data` or :meth:`c_str`.
|
|
|
|
\endrst
|
|
|
|
*/
|
2012-12-26 01:55:41 +00:00
|
|
|
class Formatter : public BasicFormatter {
|
2012-12-29 17:27:26 +00:00
|
|
|
private:
|
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-21 04:10:55 +00:00
|
|
|
typedef void (Formatter::*FormatFunc)(
|
|
|
|
const void *arg, const FormatSpec &spec);
|
2012-12-09 19:32:39 +00:00
|
|
|
|
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-17 22:56:44 +00:00
|
|
|
formatter->CompleteFormatting();
|
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-12 23:21:11 +00:00
|
|
|
int num_open_braces_;
|
2012-12-27 14:56:55 +00:00
|
|
|
int next_arg_index_;
|
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-25 21:25:14 +00:00
|
|
|
void ReportError(const char *s, StringRef message) const;
|
2012-12-12 23:21:11 +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-21 04:10:55 +00:00
|
|
|
void FormatCustomArg(const void *arg, const FormatSpec &spec);
|
2012-12-08 16:17:12 +00:00
|
|
|
|
2012-12-12 23:21:11 +00:00
|
|
|
unsigned ParseUInt(const char *&s) const;
|
|
|
|
|
|
|
|
// Parses argument index and returns an argument with this index.
|
2012-12-27 14:56:55 +00:00
|
|
|
const Arg &ParseArgIndex(const char *&s);
|
2012-12-12 23:21:11 +00:00
|
|
|
|
2012-12-25 21:45:12 +00:00
|
|
|
void CheckSign(const char *&s, const Arg &arg);
|
|
|
|
|
2012-12-11 20:23:52 +00:00
|
|
|
void DoFormat();
|
|
|
|
|
2012-12-17 22:56:44 +00:00
|
|
|
void CompleteFormatting() {
|
2012-12-11 20:23:52 +00:00
|
|
|
if (!format_) return;
|
|
|
|
DoFormat();
|
|
|
|
}
|
2012-12-07 16:31:09 +00:00
|
|
|
|
|
|
|
public:
|
2013-01-04 15:04:35 +00:00
|
|
|
/**
|
|
|
|
Constructs a formatter with an empty output buffer.
|
|
|
|
*/
|
2013-01-04 17:14:34 +00:00
|
|
|
Formatter() : format_(0) {}
|
2012-12-07 16:31:09 +00:00
|
|
|
|
2013-01-04 15:04:35 +00:00
|
|
|
/**
|
|
|
|
Formats a string appending the output to the internal buffer.
|
2013-01-13 15:14:54 +00:00
|
|
|
Arguments are accepted through the returned `ArgInserter` object
|
|
|
|
using inserter operator `<<`.
|
2013-01-04 15:04:35 +00:00
|
|
|
*/
|
2012-12-29 17:27:26 +00:00
|
|
|
internal::ArgInserter operator()(StringRef format);
|
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;
|
2012-12-18 23:39:42 +00:00
|
|
|
friend class format::StringRef;
|
2012-12-12 17:14:00 +00:00
|
|
|
|
2012-12-15 03:01:48 +00:00
|
|
|
// Do not implement.
|
|
|
|
void operator=(const ArgInserter& other);
|
|
|
|
|
2012-12-12 17:14:00 +00:00
|
|
|
protected:
|
|
|
|
explicit ArgInserter(Formatter *f = 0) : formatter_(f) {}
|
|
|
|
|
2012-12-15 03:01:48 +00:00
|
|
|
void Init(Formatter &f, const char *format) {
|
|
|
|
const ArgInserter &other = f(format);
|
|
|
|
formatter_ = other.formatter_;
|
2012-12-12 17:14:00 +00:00
|
|
|
other.formatter_ = 0;
|
|
|
|
}
|
|
|
|
|
2012-12-15 03:01:48 +00:00
|
|
|
ArgInserter(const ArgInserter& other)
|
|
|
|
: formatter_(other.formatter_) {
|
2012-12-12 17:14:00 +00:00
|
|
|
other.formatter_ = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Formatter *Format() const {
|
|
|
|
Formatter *f = formatter_;
|
|
|
|
if (f) {
|
|
|
|
formatter_ = 0;
|
2012-12-17 22:56:44 +00:00
|
|
|
f->CompleteFormatting();
|
2012-12-12 17:14:00 +00:00
|
|
|
}
|
|
|
|
return f;
|
|
|
|
}
|
|
|
|
|
|
|
|
Formatter *formatter() const { return formatter_; }
|
|
|
|
const char *format() const { return formatter_->format_; }
|
|
|
|
|
2012-12-15 03:01:48 +00:00
|
|
|
void ResetFormatter() const { formatter_ = 0; }
|
2012-12-12 17:14:00 +00:00
|
|
|
|
2012-12-16 18:03:19 +00:00
|
|
|
struct Proxy {
|
|
|
|
Formatter *formatter;
|
|
|
|
explicit Proxy(Formatter *f) : formatter(f) {}
|
|
|
|
|
2012-12-18 23:39:42 +00:00
|
|
|
Formatter *Format() {
|
|
|
|
formatter->CompleteFormatting();
|
|
|
|
return formatter;
|
|
|
|
}
|
|
|
|
};
|
2012-12-16 18:03:19 +00:00
|
|
|
|
2012-12-12 17:14:00 +00:00
|
|
|
public:
|
|
|
|
~ArgInserter() {
|
|
|
|
if (formatter_)
|
2012-12-17 22:56:44 +00:00
|
|
|
formatter_->CompleteFormatting();
|
2012-12-12 17:14:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Feeds an argument to a formatter.
|
|
|
|
ArgInserter &operator<<(const Formatter::Arg &arg) {
|
|
|
|
arg.formatter = formatter_;
|
|
|
|
formatter_->Add(arg);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2012-12-16 18:03:19 +00:00
|
|
|
operator Proxy() {
|
|
|
|
Formatter *f = formatter_;
|
|
|
|
formatter_ = 0;
|
|
|
|
return Proxy(f);
|
|
|
|
}
|
|
|
|
|
2012-12-19 18:47:00 +00:00
|
|
|
operator StringRef() {
|
|
|
|
const Formatter *f = Format();
|
|
|
|
return StringRef(f->c_str(), f->size());
|
|
|
|
}
|
|
|
|
|
2012-12-18 22:38:03 +00:00
|
|
|
// Performs formatting and returns a std::string with the output.
|
|
|
|
friend std::string str(Proxy p) {
|
2012-12-18 23:39:42 +00:00
|
|
|
return p.Format()->str();
|
2012-12-18 22:38:03 +00:00
|
|
|
}
|
2012-12-18 05:13:54 +00:00
|
|
|
|
2012-12-12 17:14:00 +00:00
|
|
|
// Performs formatting and returns a C string with the output.
|
2012-12-16 18:03:19 +00:00
|
|
|
friend const char *c_str(Proxy p) {
|
2012-12-18 23:39:42 +00:00
|
|
|
return p.Format()->c_str();
|
2012-12-12 17:14:00 +00:00
|
|
|
}
|
|
|
|
};
|
2012-12-18 22:38:03 +00:00
|
|
|
|
|
|
|
std::string str(ArgInserter::Proxy p);
|
2012-12-18 23:39:42 +00:00
|
|
|
const char *c_str(ArgInserter::Proxy p);
|
2012-12-12 17:14:00 +00:00
|
|
|
}
|
|
|
|
|
2012-12-18 22:38:03 +00:00
|
|
|
using format::internal::str;
|
2012-12-18 23:39:42 +00:00
|
|
|
using format::internal::c_str;
|
|
|
|
|
2012-12-17 22:56:44 +00:00
|
|
|
// The default formatting function.
|
2012-12-09 17:03:47 +00:00
|
|
|
template <typename T>
|
2013-01-08 17:56:05 +00:00
|
|
|
void Format(BasicFormatter &f, const FormatSpec &spec, const T &value) {
|
2012-12-09 17:03:47 +00:00
|
|
|
std::ostringstream os;
|
|
|
|
os << value;
|
2013-01-08 17:56:05 +00:00
|
|
|
f.Write(os.str(), spec);
|
2012-12-17 22:56:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
2012-12-21 04:10:55 +00:00
|
|
|
void Formatter::FormatCustomArg(const void *arg, const FormatSpec &spec) {
|
2013-01-08 17:56:05 +00:00
|
|
|
BasicFormatter &f = *this;
|
|
|
|
Format(f, spec, *static_cast<const T*>(arg));
|
2012-12-09 17:03:47 +00:00
|
|
|
}
|
|
|
|
|
2012-12-29 17:27:26 +00:00
|
|
|
inline internal::ArgInserter Formatter::operator()(StringRef format) {
|
2012-12-12 17:14:00 +00:00
|
|
|
internal::ArgInserter formatter(this);
|
2012-12-29 17:27:26 +00:00
|
|
|
format_ = format.c_str();
|
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
|
|
|
}
|
|
|
|
|
2013-01-12 18:08:39 +00:00
|
|
|
/**
|
|
|
|
A formatting action that does nothing.
|
|
|
|
*/
|
2013-01-13 15:14:54 +00:00
|
|
|
class NoAction {
|
|
|
|
public:
|
2013-01-12 18:08:39 +00:00
|
|
|
/** Does nothing. */
|
2013-01-03 16:57:34 +00:00
|
|
|
void operator()(const Formatter &) const {}
|
|
|
|
};
|
|
|
|
|
2013-01-04 17:14:34 +00:00
|
|
|
/**
|
|
|
|
A formatter with an action performed when formatting is complete.
|
|
|
|
Objects of this class normally exist only as temporaries returned
|
|
|
|
by one of the formatting functions which explains the name.
|
|
|
|
*/
|
2013-01-03 16:57:34 +00:00
|
|
|
template <typename Action = NoAction>
|
2012-12-17 04:57:35 +00:00
|
|
|
class TempFormatter : 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
|
|
|
|
2012-12-16 04:17:03 +00:00
|
|
|
// Forbid copying other than from a temporary. Do not implement.
|
2012-12-17 04:57:35 +00:00
|
|
|
TempFormatter(TempFormatter &);
|
2012-12-16 04:17:03 +00:00
|
|
|
|
2012-12-07 16:31:09 +00:00
|
|
|
// Do not implement.
|
2012-12-17 04:57:35 +00:00
|
|
|
TempFormatter& operator=(const TempFormatter &);
|
2012-12-16 04:17:03 +00:00
|
|
|
|
|
|
|
struct Proxy {
|
|
|
|
const char *format;
|
|
|
|
Action action;
|
|
|
|
|
|
|
|
Proxy(const char *fmt, Action a) : format(fmt), action(a) {}
|
|
|
|
};
|
2012-12-07 16:31:09 +00:00
|
|
|
|
|
|
|
public:
|
2013-01-12 18:08:39 +00:00
|
|
|
/**
|
|
|
|
\rst
|
|
|
|
Constructs a temporary formatter with a format string and an action.
|
|
|
|
The action should be an unary function object that takes a const
|
|
|
|
reference to :cpp:class:`format::Formatter` as an argument.
|
|
|
|
See :cpp:class:`format::NoAction` and :cpp:class:`format::Write` for
|
|
|
|
examples of action classes.
|
|
|
|
\endrst
|
|
|
|
*/
|
2013-01-03 16:57:34 +00:00
|
|
|
explicit TempFormatter(StringRef format, Action a = Action())
|
2012-12-12 00:26:04 +00:00
|
|
|
: action_(a) {
|
2013-01-03 16:57:34 +00:00
|
|
|
Init(formatter_, format.c_str());
|
2012-12-07 16:31:09 +00:00
|
|
|
}
|
|
|
|
|
2013-01-12 18:08:39 +00:00
|
|
|
/**
|
|
|
|
Constructs a temporary formatter from a proxy object.
|
|
|
|
*/
|
2012-12-17 04:57:35 +00:00
|
|
|
TempFormatter(const Proxy &p)
|
2012-12-16 04:17:03 +00:00
|
|
|
: ArgInserter(0), action_(p.action) {
|
|
|
|
Init(formatter_, p.format);
|
2012-12-12 04:49:01 +00:00
|
|
|
}
|
2012-12-08 16:17:12 +00:00
|
|
|
|
2013-01-12 18:08:39 +00:00
|
|
|
/**
|
|
|
|
Performs the actual formatting, invokes the action and destroys the object.
|
|
|
|
*/
|
2012-12-17 04:57:35 +00:00
|
|
|
~TempFormatter() {
|
2012-12-12 04:49:01 +00:00
|
|
|
if (formatter())
|
|
|
|
action_(*Format());
|
2012-12-07 16:31:09 +00:00
|
|
|
}
|
2012-12-16 04:17:03 +00:00
|
|
|
|
2013-01-12 18:08:39 +00:00
|
|
|
/**
|
|
|
|
Converts a temporary formatter into a proxy object.
|
|
|
|
*/
|
2012-12-16 04:17:03 +00:00
|
|
|
operator Proxy() {
|
|
|
|
const char *fmt = format();
|
|
|
|
ResetFormatter();
|
|
|
|
return Proxy(fmt, action_);
|
|
|
|
}
|
2012-12-07 16:31:09 +00:00
|
|
|
};
|
|
|
|
|
2013-01-03 16:57:34 +00:00
|
|
|
/**
|
|
|
|
\rst
|
|
|
|
Formats a string. Returns a temporary formatter object that accepts
|
|
|
|
arguments via operator ``<<``. *format* is a format string that contains
|
|
|
|
literal text and replacement fields surrounded by braces ``{}``.
|
|
|
|
The formatter object replaces the fields with formatted arguments
|
|
|
|
and stores the output in a memory buffer. The content of the buffer can
|
|
|
|
be converted to ``std::string`` with :meth:`str` or accessed as a C string
|
|
|
|
with :meth:`c_str`.
|
2012-12-07 16:31:09 +00:00
|
|
|
|
2013-01-03 16:57:34 +00:00
|
|
|
**Example**::
|
|
|
|
|
2013-01-12 18:08:39 +00:00
|
|
|
std::string message = str(Format("The answer is {}") << 42);
|
2013-01-03 16:57:34 +00:00
|
|
|
|
|
|
|
See also `Format String Syntax`_.
|
|
|
|
\endrst
|
|
|
|
*/
|
|
|
|
inline TempFormatter<> Format(StringRef format) {
|
|
|
|
return TempFormatter<>(format);
|
2012-12-11 21:54:53 +00:00
|
|
|
}
|
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;
|
2013-01-03 16:57:34 +00:00
|
|
|
inline TempFormatter<Write> Print(StringRef format) {
|
2012-12-17 04:57:35 +00:00
|
|
|
return TempFormatter<Write>(format);
|
2012-12-11 21:54:53 +00:00
|
|
|
}
|
2012-12-07 16:31:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
namespace fmt = format;
|
|
|
|
|
|
|
|
#endif // FORMAT_H_
|