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

Replace using with typedef for compatibility with gcc-4.6

Browse Source
This commit is contained in:
Victor Zverovich 2018-02-11 08:32:02 -08:00
parent 0b508fd29d
commit 522de7b55d
4 changed files with 103 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
include/fmt/core.h
View File

@ -168,8 +168,8 @@ class basic_string_view {
size_t size_;
public:
using char_type = Char;
using iterator = const Char *;
typedef Char char_type;
typedef const Char *iterator;
FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(0), size_(0) {}
@ -242,8 +242,8 @@ class basic_string_view {
#endif
namespace fmt {
using string_view = basic_string_view<char>;
using wstring_view = basic_string_view<wchar_t>;
typedef basic_string_view<char> string_view;
typedef basic_string_view<wchar_t> wstring_view;
template <typename Context>
class basic_arg;
@ -285,7 +285,7 @@ class basic_buffer {
virtual void grow(std::size_t capacity) = 0;
public:
using value_type = T;
typedef T value_type;
virtual ~basic_buffer() {}
@ -335,8 +335,8 @@ class basic_buffer {
const T &operator[](std::size_t index) const { return ptr_[index]; }
};
using buffer = basic_buffer<char>;
using wbuffer = basic_buffer<wchar_t>;
typedef basic_buffer<char> buffer;
typedef basic_buffer<wchar_t> wbuffer;
// A container-backed buffer.
template <typename Container>
@ -443,7 +443,7 @@ struct custom_value {
template <typename Context>
class value {
public:
using char_type = typename Context::char_type;
typedef typename Context::char_type char_type;
union {
int int_value;
@ -499,7 +499,7 @@ class value {
// Get the formatter type through the context to allow different contexts
// have different extension points, e.g. `formatter<T>` for `format` and
// `printf_formatter<T>` for `printf`.
typename Context::template formatter_type<T> f;
typename Context::template formatter_type<T>::type f;
auto &&parse_ctx = ctx.parse_context();
parse_ctx.advance_to(f.parse(parse_ctx));
ctx.advance_to(f.format(*static_cast<const T*>(arg), ctx));
@ -531,12 +531,11 @@ FMT_MAKE_VALUE(UINT, unsigned, unsigned)
// To minimize the number of types we need to deal with, long is translated
// either to int or to long long depending on its size.
using long_type =
std::conditional<sizeof(long) == sizeof(int), int, long long>::type;
typedef std::conditional<sizeof(long) == sizeof(int), int, long long>::type
long_type;
FMT_MAKE_VALUE((sizeof(long) == sizeof(int) ? INT : LONG_LONG), long, long_type)
using ulong_type =
std::conditional<sizeof(unsigned long) == sizeof(unsigned),
unsigned, unsigned long long>::type;
typedef std::conditional<sizeof(unsigned long) == sizeof(unsigned),
unsigned, unsigned long long>::type ulong_type;
FMT_MAKE_VALUE((sizeof(unsigned long) == sizeof(unsigned) ? UINT : ULONG_LONG),
unsigned long, ulong_type)
@ -628,7 +627,7 @@ class basic_arg {
friend class basic_format_args<Context>;
friend class internal::arg_map<Context>;
using char_type = typename Context::char_type;
typedef typename Context::char_type char_type;
public:
class handle {
@ -663,8 +662,8 @@ class basic_parse_context : private ErrorHandler {
int next_arg_id_;
public:
using char_type = Char;
using iterator = typename basic_string_view<Char>::iterator;
typedef Char char_type;
typedef typename basic_string_view<Char>::iterator iterator;
explicit FMT_CONSTEXPR basic_parse_context(
basic_string_view<Char> format_str, ErrorHandler eh = ErrorHandler())
@ -704,8 +703,8 @@ class basic_parse_context : private ErrorHandler {
FMT_CONSTEXPR ErrorHandler error_handler() const { return *this; }
};
using parse_context = basic_parse_context<char>;
using wparse_context = basic_parse_context<wchar_t>;
typedef basic_parse_context<char> parse_context;
typedef basic_parse_context<wchar_t> wparse_context;
namespace internal {
// A map from argument names to their values for named arguments.
@ -714,7 +713,7 @@ class arg_map {
private:
FMT_DISALLOW_COPY_AND_ASSIGN(arg_map);
using char_type = typename Context::char_type;
typedef typename Context::char_type char_type;
struct entry {
basic_string_view<char_type> name;
@ -748,7 +747,7 @@ class arg_map {
template <typename OutputIt, typename Context, typename Char>
class context_base {
public:
using iterator = OutputIt;
typedef OutputIt iterator;
private:
basic_parse_context<Char> parse_context_;
@ -756,8 +755,8 @@ class context_base {
basic_format_args<Context> args_;
protected:
using char_type = Char;
using format_arg = basic_arg<Context>;
typedef Char char_type;
typedef basic_arg<Context> format_arg;
context_base(OutputIt out, basic_string_view<char_type> format_str,
basic_format_args<Context> args)
@ -801,7 +800,7 @@ class context_base {
// Extracts a reference to the container from back_insert_iterator.
template <typename Container>
inline Container &get_container(std::back_insert_iterator<Container> it) {
using iterator = std::back_insert_iterator<Container>;
typedef std::back_insert_iterator<Container> iterator;
struct accessor: iterator {
accessor(iterator it) : iterator(it) {}
using iterator::container;
@ -816,11 +815,11 @@ class output_range {
OutputIt it_;
// Unused yet.
using sentinel = void;
typedef void sentinel;
sentinel end() const;
public:
using value_type = T;
typedef T value_type;
explicit output_range(OutputIt it): it_(it) {}
OutputIt begin() const { return it_; }
@ -832,18 +831,19 @@ class basic_context :
public internal::context_base<OutputIt, basic_context<OutputIt, Char>, Char> {
public:
/** The character type for the output. */
using char_type = Char;
typedef Char char_type;
// using formatter_type = formatter<T, char_type>;
template <typename T>
using formatter_type = formatter<T, char_type>;
struct formatter_type { typedef formatter<T, char_type> type; };
private:
internal::arg_map<basic_context> map_;
FMT_DISALLOW_COPY_AND_ASSIGN(basic_context);
using base = internal::context_base<OutputIt, basic_context, Char>;
using format_arg = typename base::format_arg;
typedef internal::context_base<OutputIt, basic_context, Char> base;
typedef typename base::format_arg format_arg;
using base::get_arg;
public:
@ -872,8 +872,8 @@ class basic_context :
template <typename Char>
using buffer_context_t = basic_context<
std::back_insert_iterator<internal::basic_buffer<Char>>, Char>;
using context = buffer_context_t<char>;
using wcontext = buffer_context_t<wchar_t>;
typedef buffer_context_t<char> context;
typedef buffer_context_t<wchar_t> wcontext;
namespace internal {
template <typename Context, typename T>
@ -882,7 +882,7 @@ class get_type {
static const T& val();
public:
using value_type = decltype(make_value<Context>(val()));
typedef decltype(make_value<Context>(val())) value_type;
static const type value = value_type::type_tag;
};
@ -923,8 +923,8 @@ class arg_store {
// Packed is a macro on MinGW so use IS_PACKED instead.
static const bool IS_PACKED = NUM_ARGS < internal::MAX_PACKED_ARGS;
using value_type = typename std::conditional<
IS_PACKED, internal::value<Context>, basic_arg<Context>>::type;
typedef typename std::conditional<
IS_PACKED, internal::value<Context>, basic_arg<Context>>::type value_type;
// If the arguments are not packed, add one more element to mark the end.
value_type data_[NUM_ARGS + (IS_PACKED && NUM_ARGS != 0 ? 0 : 1)];
@ -959,8 +959,8 @@ inline arg_store<context, Args...> make_args(const Args & ... args) {
template <typename Context>
class basic_format_args {
public:
using size_type = unsigned;
using format_arg = basic_arg<Context> ;
typedef unsigned size_type;
typedef basic_arg<Context> format_arg;
private:
// To reduce compiled code size per formatting function call, types of first
@ -1028,8 +1028,8 @@ class basic_format_args {
}
};
using format_args = basic_format_args<context>;
using wformat_args = basic_format_args<wcontext>;
typedef basic_format_args<context> format_args;
typedef basic_format_args<wcontext> wformat_args;
namespace internal {
template <typename Char>

106
include/fmt/format.h
View File

@ -575,11 +575,11 @@ FMT_CONSTEXPR const Char *pointer_from(null_terminating_iterator<Char> it);
template <typename Char>
class null_terminating_iterator {
public:
using difference_type = std::ptrdiff_t;
using value_type = Char;
using pointer = const Char*;
using reference = const Char&;
using iterator_category = std::random_access_iterator_tag;
typedef std::ptrdiff_t difference_type;
typedef Char value_type;
typedef const Char* pointer;
typedef const Char& reference;
typedef std::random_access_iterator_tag iterator_category;
null_terminating_iterator() : ptr_(0), end_(0) {}
@ -667,11 +667,11 @@ class counting_iterator {
mutable T blackhole_;
public:
using iterator_category = std::output_iterator_tag;
using value_type = T;
using difference_type = std::ptrdiff_t;
using pointer = T*;
using reference = T&;
typedef std::output_iterator_tag iterator_category;
typedef T value_type;
typedef std::ptrdiff_t difference_type;
typedef T* pointer;
typedef T& reference;
explicit counting_iterator(std::size_t &count): count_(count) {}
counting_iterator(const counting_iterator &other): count_(other.count_) {}
@ -998,7 +998,7 @@ struct monostate {};
template <typename Visitor, typename Context>
FMT_CONSTEXPR typename std::result_of<Visitor(int)>::type
visit(Visitor &&vis, basic_arg<Context> arg) {
using char_type = typename Context::char_type;
typedef typename Context::char_type char_type;
switch (arg.type_) {
case internal::NONE:
return vis(monostate());
@ -1058,7 +1058,7 @@ class format_spec {
};
// template <typename Char>
// using fill_spec = format_spec<Char, fill_tag>;
// typedef format_spec<Char, fill_tag> fill_spec;
template <typename Char>
class fill_spec : public format_spec<Char, fill_tag> {
public:
@ -1323,11 +1323,11 @@ void arg_map<Context>::init(const basic_format_args<Context> &args) {
template <typename Range>
class arg_formatter_base {
public:
using char_type = typename Range::value_type;
using format_specs = basic_format_specs<char_type>;
typedef typename Range::value_type char_type;
typedef basic_format_specs<char_type> format_specs;
private:
using writer_type = basic_writer<Range>;
typedef basic_writer<Range> writer_type;
writer_type writer_;
format_specs &specs_;
@ -1717,7 +1717,7 @@ template <typename ParseContext>
class dynamic_specs_handler :
public specs_setter<typename ParseContext::char_type> {
public:
using char_type = typename ParseContext::char_type;
typedef typename ParseContext::char_type char_type;
FMT_CONSTEXPR dynamic_specs_handler(
dynamic_format_specs<char_type> &specs, ParseContext &ctx)
@ -1742,7 +1742,7 @@ class dynamic_specs_handler :
}
private:
using arg_ref_type = arg_ref<char_type>;
typedef arg_ref<char_type> arg_ref_type;
template <typename Id>
FMT_CONSTEXPR arg_ref_type make_arg_ref(Id arg_id) {
@ -1760,7 +1760,7 @@ class dynamic_specs_handler :
template <typename Iterator, typename IDHandler>
FMT_CONSTEXPR Iterator parse_arg_id(Iterator it, IDHandler &&handler) {
using char_type = typename std::iterator_traits<Iterator>::value_type;
typedef typename std::iterator_traits<Iterator>::value_type char_type;
char_type c = *it;
if (c == '}' || c == ':') {
handler();
@ -1830,7 +1830,7 @@ struct precision_adapter {
// format specifiers.
template <typename Iterator, typename SpecHandler>
FMT_CONSTEXPR Iterator parse_format_specs(Iterator it, SpecHandler &&handler) {
using char_type = typename std::iterator_traits<Iterator>::value_type;
typedef typename std::iterator_traits<Iterator>::value_type char_type;
// Parse fill and alignment.
if (char_type c = *it) {
alignment align = ALIGN_DEFAULT;
@ -1949,7 +1949,7 @@ struct id_adapter {
template <typename Iterator, typename Handler>
FMT_CONSTEXPR void parse_format_string(Iterator it, Handler &&handler) {
using char_type = typename std::iterator_traits<Iterator>::value_type;
typedef typename std::iterator_traits<Iterator>::value_type char_type;
auto start = it;
while (*it) {
char_type ch = *it++;
@ -2025,7 +2025,7 @@ class format_string_checker {
}
private:
using parse_context_type = basic_parse_context<Char, ErrorHandler>;
typedef basic_parse_context<Char, ErrorHandler> parse_context_type;
enum { NUM_ARGS = sizeof...(Args) };
FMT_CONSTEXPR void check_arg_id() {
@ -2034,7 +2034,7 @@ class format_string_checker {
}
// Format specifier parsing function.
using parse_func = const Char *(*)(parse_context_type &);
typedef const Char *(*parse_func)(parse_context_type &);
int arg_id_ = -1;
parse_context_type context_;
@ -2065,7 +2065,7 @@ struct format_enum : std::integral_constant<bool, std::is_enum<T>::value> {};
template <template <typename> class Handler, typename Spec, typename Context>
void handle_dynamic_spec(
Spec &value, arg_ref<typename Context::char_type> ref, Context &ctx) {
using char_type = typename Context::char_type;
typedef typename Context::char_type char_type;
switch (ref.kind) {
case arg_ref<char_type>::NONE:
break;
@ -2085,16 +2085,16 @@ void handle_dynamic_spec(
template <typename Range>
class arg_formatter: public internal::arg_formatter_base<Range> {
private:
using char_type = typename Range::value_type;
using iterator = decltype(std::declval<Range>().begin());
using base = internal::arg_formatter_base<Range>;
using context_type = basic_context<iterator, char_type>;
typedef typename Range::value_type char_type;
typedef decltype(std::declval<Range>().begin()) iterator;
typedef internal::arg_formatter_base<Range> base;
typedef basic_context<iterator, char_type> context_type;
context_type &ctx_;
public:
using range = Range;
using format_specs = typename base::format_specs;
typedef Range range;
typedef typename base::format_specs format_specs;
/**
\rst
@ -2183,9 +2183,9 @@ FMT_API void format_system_error(fmt::internal::buffer &out, int error_code,
template <typename Range>
class basic_writer {
public:
using char_type = typename Range::value_type;
using iterator = decltype(std::declval<Range>().begin());
using format_specs = basic_format_specs<char_type>;
typedef typename Range::value_type char_type;
typedef decltype(std::declval<Range>().begin()) iterator;
typedef basic_format_specs<char_type> format_specs;
private:
// Output iterator.
@ -2196,11 +2196,11 @@ class basic_writer {
FMT_DISALLOW_COPY_AND_ASSIGN(basic_writer);
#if FMT_SECURE_SCL
using pointer_type = stdext::checked_array_iterator<char_type*>;
typedef stdext::checked_array_iterator<char_type*> pointer_type;
// Returns pointer value.
static char_type *get(pointer_type p) { return p.base(); }
#else
using pointer_type = char_type*;
typedef char_type* pointer_type;
static char_type *get(char_type *p) { return p; }
#endif
@ -2260,7 +2260,7 @@ class basic_writer {
// Writes a decimal integer.
template <typename Int>
void write_decimal(Int value) {
using main_type = typename internal::int_traits<Int>::main_type;
typedef typename internal::int_traits<Int>::main_type main_type;
main_type abs_value = static_cast<main_type>(value);
bool is_negative = internal::is_negative(value);
if (is_negative)
@ -2275,7 +2275,7 @@ class basic_writer {
// The handle_int_type_spec handler that writes an integer.
template <typename Int, typename Spec>
struct int_writer {
using unsigned_type = typename internal::int_traits<Int>::main_type;
typedef typename internal::int_traits<Int>::main_type unsigned_type;
basic_writer<Range> &writer;
const Spec &spec;
@ -2731,16 +2731,16 @@ void basic_writer<Range>::write_double(T value, const format_specs &spec) {
template <typename Container>
class back_insert_range:
public output_range<std::back_insert_iterator<Container>> {
using base = output_range<std::back_insert_iterator<Container>>;
typedef output_range<std::back_insert_iterator<Container>> base;
public:
using value_type = typename Container::value_type;
typedef typename Container::value_type value_type;
using base::base;
back_insert_range(Container &c): base(std::back_inserter(c)) {}
};
using writer = basic_writer<back_insert_range<internal::buffer>>;
using wwriter = basic_writer<back_insert_range<internal::wbuffer>>;
typedef basic_writer<back_insert_range<internal::buffer>> writer;
typedef basic_writer<back_insert_range<internal::wbuffer>> wwriter;
// Reports a system error without throwing an exception.
// Can be used to report errors from destructors.
@ -2878,7 +2878,7 @@ class FormatInt {
// write a terminating null character.
template <typename T>
inline void format_decimal(char *&buffer, T value) {
using main_type = typename internal::int_traits<T>::main_type;
typedef typename internal::int_traits<T>::main_type main_type;
main_type abs_value = static_cast<main_type>(value);
if (internal::is_negative(value)) {
*buffer++ = '-';
@ -2911,7 +2911,7 @@ struct formatter<
template <typename ParseContext>
FMT_CONSTEXPR typename ParseContext::iterator parse(ParseContext &ctx) {
auto it = internal::null_terminating_iterator<Char>(ctx);
using handler_type = internal::dynamic_specs_handler<ParseContext>;
typedef internal::dynamic_specs_handler<ParseContext> handler_type;
auto type = internal::get_type<buffer_context_t<Char>, T>::value;
internal::specs_checker<handler_type>
handler(handler_type(specs_, ctx), type);
@ -2964,8 +2964,8 @@ struct formatter<
specs_.width_, specs_.width_ref, ctx);
internal::handle_dynamic_spec<internal::precision_checker>(
specs_.precision_, specs_.precision_ref, ctx);
using range = output_range<
typename FormatContext::iterator, typename FormatContext::char_type>;
typedef output_range<typename FormatContext::iterator,
typename FormatContext::char_type> range;
visit(arg_formatter<range>(ctx, specs_),
internal::make_arg<FormatContext>(val));
return ctx.begin();
@ -2988,7 +2988,7 @@ struct formatter<T, Char,
// A formatter for types known only at run time such as variant alternatives.
//
// Usage:
// using variant = std::variant<int, std::string>;
// typedef std::variant<int, std::string> variant;
// template <>
// struct formatter<variant>: dynamic_formatter<> {
// void format(buffer &buf, const variant &v, context &ctx) {
@ -3033,8 +3033,8 @@ struct dynamic_formatter {
}
if (specs_.precision_ != -1)
checker.end_precision();
using range = output_range<
typename FormatContext::iterator, typename FormatContext::char_type>;
typedef output_range<typename FormatContext::iterator,
typename FormatContext::char_type> range;
visit(arg_formatter<range>(ctx, specs_),
internal::make_arg<FormatContext>(val));
return ctx.begin();
@ -3067,8 +3067,8 @@ template <typename ArgFormatter, typename Char, typename Context>
typename Context::iterator do_vformat_to(typename ArgFormatter::range out,
basic_string_view<Char> format_str,
basic_format_args<Context> args) {
using iterator = internal::null_terminating_iterator<Char>;
using range = typename ArgFormatter::range;
typedef internal::null_terminating_iterator<Char> iterator;
typedef typename ArgFormatter::range range;
struct handler : internal::error_handler {
handler(range r, basic_string_view<Char> str,
@ -3171,7 +3171,7 @@ struct formatter<arg_join<It, Char>, Char>:
formatter<typename std::iterator_traits<It>::value_type, Char> {
template <typename FormatContext>
auto format(const arg_join<It, Char> &value, FormatContext &ctx) {
using base = formatter<typename std::iterator_traits<It>::value_type, Char>;
typedef formatter<typename std::iterator_traits<It>::value_type, Char> base;
auto it = value.begin;
auto out = ctx.begin();
if (it != value.end) {
@ -3244,13 +3244,13 @@ std::basic_string<Char> to_string(const basic_memory_buffer<Char> &buffer) {
inline void vformat_to(internal::buffer &buf, string_view format_str,
format_args args) {
using range = back_insert_range<internal::buffer>;
typedef back_insert_range<internal::buffer> range;
do_vformat_to<arg_formatter<range>>(buf, format_str, args);
}
inline void vformat_to(internal::wbuffer &buf, wstring_view format_str,
wformat_args args) {
using range = back_insert_range<internal::wbuffer>;
typedef back_insert_range<internal::wbuffer> range;
do_vformat_to<arg_formatter<range>>(buf, format_str, args);
}
@ -3275,7 +3275,7 @@ using format_args_t = basic_format_args<context_t<OutputIt, Char>>;
template <typename OutputIt, typename... Args>
inline OutputIt vformat_to(OutputIt out, string_view format_str,
format_args_t<OutputIt> args) {
using range = output_range<OutputIt, char>;
typedef output_range<OutputIt, char> range;
return do_vformat_to<arg_formatter<range>>(range(out), format_str, args);
}

2
include/fmt/printf.h
View File

@ -309,7 +309,7 @@ class basic_printf_context :
using char_type = Char;
template <typename T>
using formatter_type = printf_formatter<T>;
struct formatter_type { typedef printf_formatter<T> type; };
private:
using base = internal::context_base<OutputIt, basic_printf_context, Char>;

18
test/util-test.cc
View File

@ -440,15 +440,17 @@ struct custom_context {
template <typename T>
struct formatter_type {
template <typename ParseContext>
auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
return ctx.begin();
}
struct type {
template <typename ParseContext>
auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
return ctx.begin();
}
const char *format(const T &, custom_context& ctx) {
ctx.called = true;
return 0;
}
const char *format(const T &, custom_context& ctx) {
ctx.called = true;
return 0;
}
};
};
bool called;