From e0243000deaec6c12b56fd53a9d405ecd996b6af Mon Sep 17 00:00:00 2001 From: Victor Zverovich Date: Sun, 26 Nov 2017 09:29:55 -0800 Subject: [PATCH] arg_index -> arg_id --- include/fmt/format.h | 59 ++++++++++++++++++++------------------------ include/fmt/printf.h | 2 +- test/format-test.cc | 2 +- 3 files changed, 29 insertions(+), 34 deletions(-) diff --git a/include/fmt/format.h b/include/fmt/format.h index 49b82bf0..036921a7 100644 --- a/include/fmt/format.h +++ b/include/fmt/format.h @@ -1710,15 +1710,15 @@ template class basic_parse_context : private ErrorHandler { private: basic_string_view format_str_; - int next_arg_index_; + int next_arg_id_; protected: constexpr bool check_no_auto_index() { - if (next_arg_index_ > 0) { + if (next_arg_id_ > 0) { on_error("cannot switch from automatic to manual argument indexing"); return false; } - next_arg_index_ = -1; + next_arg_id_ = -1; return true; } @@ -1728,14 +1728,14 @@ class basic_parse_context : private ErrorHandler { explicit constexpr basic_parse_context( basic_string_view format_str, ErrorHandler eh = ErrorHandler()) - : ErrorHandler(eh), format_str_(format_str), next_arg_index_(0) {} + : ErrorHandler(eh), format_str_(format_str), next_arg_id_(0) {} // Returns an iterator to the beginning of the format string range being // parsed. - constexpr iterator begin() const { return format_str_.begin(); } + constexpr iterator begin() const FMT_NOEXCEPT { return format_str_.begin(); } // Returns an iterator past the end of the format string range being parsed. - constexpr iterator end() const { return format_str_.end(); } + constexpr iterator end() const FMT_NOEXCEPT { return format_str_.end(); } // Advances the begin iterator to ``it``. constexpr void advance_to(iterator it) { @@ -1743,9 +1743,9 @@ class basic_parse_context : private ErrorHandler { } // Returns the next argument index. - constexpr unsigned next_arg_index() { - if (next_arg_index_ >= 0) - return internal::to_unsigned(next_arg_index_++); + constexpr unsigned next_arg_id() { + if (next_arg_id_ >= 0) + return internal::to_unsigned(next_arg_id_++); on_error("cannot switch from manual to automatic argument indexing"); return 0; } @@ -2099,8 +2099,8 @@ class context_base : public basic_parse_context{ basic_args args() const { return args_; } // Returns the argument with specified index. - format_arg do_get_arg(unsigned arg_index) { - format_arg arg = args_[arg_index]; + format_arg do_get_arg(unsigned arg_id) { + format_arg arg = args_[arg_id]; if (!arg) this->on_error("argument index out of range"); return arg; @@ -2108,9 +2108,9 @@ class context_base : public basic_parse_context{ // Checks if manual indexing is used and returns the argument with // specified index. - format_arg get_arg(unsigned arg_index) { + format_arg get_arg(unsigned arg_id) { return this->check_no_auto_index() ? - this->do_get_arg(arg_index) : format_arg(); + this->do_get_arg(arg_id) : format_arg(); } public: @@ -2445,7 +2445,7 @@ class dynamic_specs_handler : } constexpr arg_ref_type make_arg_ref(auto_id) { - return arg_ref_type(context_.next_arg_index()); + return arg_ref_type(context_.next_arg_id()); } dynamic_format_specs &specs_; @@ -2692,13 +2692,13 @@ class format_string_checker { constexpr void on_text(const Char *, const Char *) {} constexpr void on_arg_id() { - arg_index_ = context_.next_arg_index(); - check_arg_index(); + arg_id_ = context_.next_arg_id(); + check_arg_id(); } - constexpr void on_arg_id(unsigned index) { - arg_index_ = index; - context_.check_arg_id(index); - check_arg_index(); + constexpr void on_arg_id(unsigned id) { + arg_id_ = id; + context_.check_arg_id(id); + check_arg_id(); } constexpr void on_arg_id(basic_string_view) {} @@ -2706,8 +2706,8 @@ class format_string_checker { constexpr const Char *on_format_specs(const Char *s) { context_.advance_to(s); - return to_unsigned(arg_index_) < NUM_ARGS ? - parse_funcs_[arg_index_](context_) : s; + return to_unsigned(arg_id_) < NUM_ARGS ? + parse_funcs_[arg_id_](context_) : s; } constexpr void on_error(const char *message) { @@ -2718,15 +2718,15 @@ class format_string_checker { using parse_context_type = basic_parse_context; constexpr static size_t NUM_ARGS = sizeof...(Args); - constexpr void check_arg_index() { - if (internal::to_unsigned(arg_index_) >= NUM_ARGS) + constexpr void check_arg_id() { + if (internal::to_unsigned(arg_id_) >= NUM_ARGS) context_.on_error("argument index out of range"); } // Format specifier parsing function. using parse_func = const Char *(*)(parse_context_type &); - int arg_index_ = -1; + int arg_id_ = -1; parse_context_type context_; parse_func parse_funcs_[NUM_ARGS > 0 ? NUM_ARGS : 1] = { &parse_format_specs... @@ -2831,13 +2831,8 @@ class basic_context : basic_string_view format_str, basic_args args) : Base(format_str, args) {} - format_arg next_arg() { - return this->do_get_arg(this->next_arg_index()); - } - - format_arg get_arg(unsigned arg_index) { - return this->do_get_arg(arg_index); - } + format_arg next_arg() { return this->do_get_arg(this->next_arg_id()); } + format_arg get_arg(unsigned arg_id) { return this->do_get_arg(arg_id); } // Checks if manual indexing is used and returns the argument with // specified name. diff --git a/include/fmt/printf.h b/include/fmt/printf.h index b68d991f..e6e76296 100644 --- a/include/fmt/printf.h +++ b/include/fmt/printf.h @@ -368,7 +368,7 @@ typename printf_context::format_arg printf_context::get_arg( iterator it, unsigned arg_index) { (void)it; if (arg_index == std::numeric_limits::max()) - return this->do_get_arg(this->next_arg_index()); + return this->do_get_arg(this->next_arg_id()); return Base::get_arg(arg_index - 1); } diff --git a/test/format-test.cc b/test/format-test.cc index 26d07d27..64f95382 100644 --- a/test/format-test.cc +++ b/test/format-test.cc @@ -1696,7 +1696,7 @@ struct test_context { template constexpr void check_arg_id(Id) {} - constexpr unsigned next_arg_index() { return 33; } + constexpr unsigned next_arg_id() { return 33; } void on_error(const char *) {}