[#index]
= Global namespace
:mrdocs:

== Namespaces

[cols="1"]
|===
| Name
| xref:fmt.adoc[`fmt`] 
|===


== xref:fmt.adoc[fmt] namespace

=== Namespaces

[cols="1"]
|===
| Name
| xref:fmt/enums.adoc[`enums`] 
| xref:fmt/safe_duration_cast.adoc[`safe&lowbar;duration&lowbar;cast`] 
|===


=== Types

[cols="1,4"]
|===
| Name| Description
| xref:fmt/basic_appender.adoc[`basic&lowbar;appender`] 
| 
| xref:fmt/basic_cstring_view.adoc[`basic&lowbar;cstring&lowbar;view`] 
| A reference to a null&hyphen;terminated string&period; It can be constructed from a C string or `std&colon;&colon;string`&period;
| xref:fmt/basic_format_arg.adoc[`basic&lowbar;format&lowbar;arg`] 
| 
| xref:fmt/basic_format_args.adoc[`basic&lowbar;format&lowbar;args`] 
| A view of a collection of formatting arguments&period; To avoid lifetime issues it should only be used as a parameter type in type&hyphen;erased functions such as `vformat`&colon;
| xref:fmt/basic_fstring.adoc[`basic&lowbar;fstring`] 
| 
| xref:fmt/basic_memory_buffer.adoc[`basic&lowbar;memory&lowbar;buffer`] 
| A dynamically growing memory buffer for trivially copyable&sol;constructible types with the first `SIZE` elements stored in the object itself&period; Most commonly used via the `memory&lowbar;buffer` alias for `char`&period;
| xref:fmt/basic_ostream_formatter.adoc[`basic&lowbar;ostream&lowbar;formatter`] 
| 
| xref:fmt/basic_printf_context.adoc[`basic&lowbar;printf&lowbar;context`] 
| 
| xref:fmt/basic_specs.adoc[`basic&lowbar;specs`] 
| 
| xref:fmt/basic_string_view.adoc[`basic&lowbar;string&lowbar;view`] 
| An implementation of `std&colon;&colon;basic&lowbar;string&lowbar;view` for pre&hyphen;C&plus;&plus;17 providing a subset of the API&period; `fmt&colon;&colon;basic&lowbar;string&lowbar;view` is used in the public API even if `std&colon;&colon;basic&lowbar;string&lowbar;view` is available to prevent issues when a library is compiled with a different `&hyphen;std` option than the client code (which is not recommended)&period;
| xref:fmt/buffered_file.adoc[`buffered&lowbar;file`] 
| 
| xref:fmt/bytes.adoc[`bytes`] 
| 
| xref:fmt/compiled_string.adoc[`compiled&lowbar;string`] 
| 
| xref:fmt/conjunction-0d.adoc[`conjunction`] 
| 
| xref:fmt/context.adoc[`context`] 
| 
| xref:fmt/dynamic_format_arg_store.adoc[`dynamic&lowbar;format&lowbar;arg&lowbar;store`] 
| A dynamic list of formatting arguments with storage&period;
| xref:fmt/file.adoc[`file`] 
| 
| xref:fmt/format_error.adoc[`format&lowbar;error`] 
| An error reported from a formatting function&period;
| xref:fmt/format_facet-0c.adoc[`format&lowbar;facet`] 
| 
| xref:fmt/format_int.adoc[`format&lowbar;int`] 
| A fast integer formatter&period;
| xref:fmt/format_specs.adoc[`format&lowbar;specs`] 
| 
| xref:fmt/format_to_n_result.adoc[`format&lowbar;to&lowbar;n&lowbar;result`] 
| 
| xref:fmt/format_to_result.adoc[`format&lowbar;to&lowbar;result`] 
| 
| xref:fmt/formatter-02b.adoc[`formatter`] 
| 
| xref:fmt/fstring.adoc[`fstring`] 
| A compile&hyphen;time format string&period; Use `format&lowbar;string` in the public API to prevent type deduction&period;
| xref:fmt/generic_context.adoc[`generic&lowbar;context`] 
| 
| xref:fmt/group_digits_view.adoc[`group&lowbar;digits&lowbar;view`] 
| 
| xref:fmt/is_compiled_string.adoc[`is&lowbar;compiled&lowbar;string`] 
| 
| xref:fmt/is_container_adaptor.adoc[`is&lowbar;container&lowbar;adaptor`] 
| Specifies if `T` is a container adaptor (like `std&colon;&colon;stack`) that should be formatted as the underlying container&period;
| xref:fmt/is_contiguous-05.adoc[`is&lowbar;contiguous`] 
| 
| xref:fmt/is_range.adoc[`is&lowbar;range`] 
| 
| xref:fmt/is_tuple_formattable.adoc[`is&lowbar;tuple&lowbar;formattable`] 
| 
| xref:fmt/is_tuple_like-03.adoc[`is&lowbar;tuple&lowbar;like`] 
| 
| xref:fmt/is_variant_like.adoc[`is&lowbar;variant&lowbar;like`] 
| 
| xref:fmt/join_view.adoc[`join&lowbar;view`] 
| 
| xref:fmt/loc_value.adoc[`loc&lowbar;value`] 
| 
| xref:fmt/locale_ref.adoc[`locale&lowbar;ref`] 
| 
| xref:fmt/locking.adoc[`locking`] 
| 
| xref:fmt/monostate.adoc[`monostate`] 
| 
| xref:fmt/nested_formatter.adoc[`nested&lowbar;formatter`] 
| 
| xref:fmt/nested_view.adoc[`nested&lowbar;view`] 
| 
| xref:fmt/parse_context-0f.adoc[`parse&lowbar;context`] 
| Parsing context consisting of a format string range being parsed and an argument counter for automatic indexing&period;
| xref:fmt/path.adoc[`path`] 
| 
| xref:fmt/range_format_kind.adoc[`range&lowbar;format&lowbar;kind`] 
| 
| xref:fmt/range_formatter-00.adoc[`range&lowbar;formatter`] 
| 
| xref:fmt/rgb.adoc[`rgb`] 
| 
| xref:fmt/runtime_format_string.adoc[`runtime&lowbar;format&lowbar;string`] 
| 
| xref:fmt/static_format_result.adoc[`static&lowbar;format&lowbar;result`] 
| 
| xref:fmt/string_buffer.adoc[`string&lowbar;buffer`] 
| 
| xref:fmt/text_style.adoc[`text&lowbar;style`] 
| A text style consisting of foreground and background colors and emphasis&period;
| xref:fmt/tuple_join_view.adoc[`tuple&lowbar;join&lowbar;view`] 
| 
| xref:fmt/vprintf_args.adoc[`vprintf&lowbar;args`] 
| 
| xref:fmt/writer.adoc[`writer`] 
| 
|===


=== Type Aliases

[cols="1"]
|===
| Name
| xref:fmt/appender.adoc[`appender`] 
| xref:fmt/basic_format_context.adoc[`basic&lowbar;format&lowbar;context`] 
| xref:fmt/basic_format_parse_context.adoc[`basic&lowbar;format&lowbar;parse&lowbar;context`] 
| xref:fmt/basic_format_string.adoc[`basic&lowbar;format&lowbar;string`] 
| xref:fmt/bool_constant.adoc[`bool&lowbar;constant`] 
| xref:fmt/buffered_context.adoc[`buffered&lowbar;context`] 
| xref:fmt/conditional_t.adoc[`conditional&lowbar;t`] 
| xref:fmt/cstring_view.adoc[`cstring&lowbar;view`] 
| xref:fmt/day.adoc[`day`] 
| xref:fmt/decay_t.adoc[`decay&lowbar;t`] 
| xref:fmt/enable_if_t.adoc[`enable&lowbar;if&lowbar;t`] 
| xref:fmt/format_args.adoc[`format&lowbar;args`] 
| xref:fmt/format_context.adoc[`format&lowbar;context`] 
| xref:fmt/format_parse_context.adoc[`format&lowbar;parse&lowbar;context`] 
| xref:fmt/format_string.adoc[`format&lowbar;string`] 
| xref:fmt/is_formattable.adoc[`is&lowbar;formattable`] 
| xref:fmt/local_time.adoc[`local&lowbar;time`] 
| xref:fmt/make_unsigned_t.adoc[`make&lowbar;unsigned&lowbar;t`] 
| xref:fmt/memory_buffer.adoc[`memory&lowbar;buffer`] 
| xref:fmt/month.adoc[`month`] 
| xref:fmt/named_arg.adoc[`named&lowbar;arg`] 
| xref:fmt/nullptr_t.adoc[`nullptr&lowbar;t`] 
| xref:fmt/ostream_formatter.adoc[`ostream&lowbar;formatter`] 
| xref:fmt/printf_args.adoc[`printf&lowbar;args`] 
| xref:fmt/printf_context.adoc[`printf&lowbar;context`] 
| xref:fmt/remove_const_t.adoc[`remove&lowbar;const&lowbar;t`] 
| xref:fmt/remove_cvref_t.adoc[`remove&lowbar;cvref&lowbar;t`] 
| xref:fmt/remove_reference_t.adoc[`remove&lowbar;reference&lowbar;t`] 
| xref:fmt/string_view.adoc[`string&lowbar;view`] 
| xref:fmt/sys_time.adoc[`sys&lowbar;time`] 
| xref:fmt/ullong.adoc[`ullong`] 
| xref:fmt/underlying_t.adoc[`underlying&lowbar;t`] 
| xref:fmt/utc_time.adoc[`utc&lowbar;time`] 
| xref:fmt/vargs.adoc[`vargs`] 
| xref:fmt/void_t.adoc[`void&lowbar;t`] 
| xref:fmt/wcstring_view.adoc[`wcstring&lowbar;view`] 
| xref:fmt/weekday.adoc[`weekday`] 
| xref:fmt/wformat_args.adoc[`wformat&lowbar;args`] 
| xref:fmt/wformat_context.adoc[`wformat&lowbar;context`] 
| xref:fmt/wformat_parse_context.adoc[`wformat&lowbar;parse&lowbar;context`] 
| xref:fmt/wformat_string.adoc[`wformat&lowbar;string`] 
| xref:fmt/wmemory_buffer.adoc[`wmemory&lowbar;buffer`] 
| xref:fmt/wprintf_args.adoc[`wprintf&lowbar;args`] 
| xref:fmt/wprintf_context.adoc[`wprintf&lowbar;context`] 
| xref:fmt/wstring_view.adoc[`wstring&lowbar;view`] 
| xref:fmt/year.adoc[`year`] 
| xref:fmt/year_month_day.adoc[`year&lowbar;month&lowbar;day`] 
|===


=== Enums

[cols="1"]
|===
| Name
| xref:fmt/_04enum.adoc[`Unnamed enum`] 
| xref:fmt/align.adoc[`align`] 
| xref:fmt/arg_id_kind.adoc[`arg&lowbar;id&lowbar;kind`] 
| xref:fmt/color.adoc[`color`] 
| xref:fmt/emphasis.adoc[`emphasis`] 
| xref:fmt/presentation_type.adoc[`presentation&lowbar;type`] 
| xref:fmt/range_format.adoc[`range&lowbar;format`] 
| xref:fmt/sign.adoc[`sign`] 
| xref:fmt/terminal_color.adoc[`terminal&lowbar;color`] 
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:fmt/2function-0a.adoc[`Unnamed overloads`] 
| User&hyphen;defined literal equivalent of `fmt&colon;&colon;arg`, but with compile&hyphen;time checks&period;
| xref:fmt/arg-0e.adoc[`arg`] 
| Returns a named argument to be used in a formatting function&period; It should only be used in a call to a formatting function&period;
| xref:fmt/assert_fail.adoc[`assert&lowbar;fail`]  [.small]#[noreturn]#
| 
| xref:fmt/bg.adoc[`bg`] 
| Creates a text style from the background color&period;
| xref:fmt/fg.adoc[`fg`] 
| Creates a text style from the foreground (text) color&period;
| xref:fmt/format-021.adoc[`format`] 
| `format` overloads
| xref:fmt/format_system_error.adoc[`format&lowbar;system&lowbar;error`] 
| Formats an error message for an error returned by an operating system or a language runtime, for example a file opening error, and writes it to `out`&period; The format is the same as the one used by `std&colon;&colon;system&lowbar;error(ec, message)` where `ec` is `std&colon;&colon;error&lowbar;code(error&lowbar;code, std&colon;&colon;generic&lowbar;category())`&period; It is implementation&hyphen;defined but normally looks like&colon;
| xref:fmt/format_to-0da.adoc[`format&lowbar;to`] 
| `format&lowbar;to` overloads
| xref:fmt/format_to_n-0b.adoc[`format&lowbar;to&lowbar;n`] 
| Formats `args` according to specifications in `fmt`, writes up to `n` characters of the result to the output iterator `out` and returns the total (not truncated) output size and the iterator past the end of the output range&period; `format&lowbar;to&lowbar;n` does not append a terminating null character&period;
| xref:fmt/formatted_size-0e2.adoc[`formatted&lowbar;size`] 
| Returns the number of chars in the output of `format(fmt, args&period;&period;&period;)`&period;
| xref:fmt/fprintf-0b2f.adoc[`fprintf`] 
| Formats `args` according to specifications in `fmt` and writes the output to `f`&period;
| xref:fmt/gmtime-03.adoc[`gmtime`] 
| Converts given time since epoch as `std&colon;&colon;time&lowbar;t` value into calendar time, expressed in Coordinated Universal Time (UTC)&period; Unlike `std&colon;&colon;gmtime`, this function is thread&hyphen;safe on most platforms&period;
| xref:fmt/group_digits.adoc[`group&lowbar;digits`] 
| Returns a view that formats an integer value using &apos;,&apos; as a locale&hyphen;independent thousands separator&period;
| xref:fmt/join-038.adoc[`join`]  [.small]#[deprecated]#
| `join` overloads
| xref:fmt/make_format_args.adoc[`make&lowbar;format&lowbar;args`] 
| 
| xref:fmt/make_printf_args.adoc[`make&lowbar;printf&lowbar;args`] 
| Constructs an `format&lowbar;arg&lowbar;store` object that contains references to arguments and can be implicitly converted to `printf&lowbar;args`&period;
| xref:fmt/make_wformat_args.adoc[`make&lowbar;wformat&lowbar;args`] 
| 
| xref:fmt/max_of.adoc[`max&lowbar;of`] 
| 
| xref:fmt/min_of.adoc[`min&lowbar;of`] 
| 
| xref:fmt/operator_bitor-08.adoc[`operator&verbar;`] 
| Bitwise disjunction operators
| xref:fmt/print-02.adoc[`print`] 
| `print` overloads
| xref:fmt/printf.adoc[`printf`] 
| Formats `args` according to specifications in `fmt` and writes the output to `stdout`&period;
| xref:fmt/println-0d.adoc[`println`] 
| `println` overloads
| xref:fmt/ptr-06.adoc[`ptr`] 
| Converts `p` to `const void&ast;` for pointer formatting&period;
| xref:fmt/report_error.adoc[`report&lowbar;error`]  [.small]#[noreturn]#
| Reports a format error at compile time or, via a `format&lowbar;error` exception, at runtime&period;
| xref:fmt/report_system_error.adoc[`report&lowbar;system&lowbar;error`] 
| 
| xref:fmt/runtime-0c.adoc[`runtime`] 
| Creates a runtime format string&period;
| xref:fmt/sprintf-05.adoc[`sprintf`] 
| Formats `args` according to specifications in `fmt` and returns the result as string&period;
| xref:fmt/streamed.adoc[`streamed`] 
| Returns a view that formats `value` via an ostream `operator&lt;&lt;`&period;
| xref:fmt/styled.adoc[`styled`] 
| Returns an argument that will be formatted using ANSI escape sequences, to be used in a formatting function&period;
| xref:fmt/system_category.adoc[`system&lowbar;category`] 
| 
| xref:fmt/system_error.adoc[`system&lowbar;error`] 
| Constructs `std&colon;&colon;system&lowbar;error` with a message formatted with `fmt&colon;&colon;format(fmt, args&period;&period;&period;)`&period; `error&lowbar;code` is a system error code as given by `errno`&period;
| xref:fmt/to_string-0b.adoc[`to&lowbar;string`] 
| Converts `value` to `std&colon;&colon;string` using the default format for type `T`&period;
| xref:fmt/to_wstring.adoc[`to&lowbar;wstring`] 
| Converts `value` to `std&colon;&colon;wstring` using the default format for type `T`&period;
| xref:fmt/underlying.adoc[`underlying`] 
| Converts `e` to the underlying type&period;
| xref:fmt/vformat-02.adoc[`vformat`] 
| 
| xref:fmt/vformat_to-0b.adoc[`vformat&lowbar;to`]  [.small]#[deprecated]#
| `vformat&lowbar;to` overloads
| xref:fmt/vformat_to_n-01.adoc[`vformat&lowbar;to&lowbar;n`] 
| 
| xref:fmt/vfprintf.adoc[`vfprintf`] 
| 
| xref:fmt/vprint-00.adoc[`vprint`] 
| 
| xref:fmt/vprint_buffered.adoc[`vprint&lowbar;buffered`] 
| 
| xref:fmt/vprintln-08.adoc[`vprintln`] 
| 
| xref:fmt/vsprintf.adoc[`vsprintf`] 
| 
| xref:fmt/vsystem_error.adoc[`vsystem&lowbar;error`] 
| 
| xref:fmt/operator_eq.adoc[`operator&equals;&equals;`] 
| Equality operator
| xref:fmt/operator_not_eq.adoc[`operator!&equals;`] 
| Inequality operator
| xref:fmt/operator_lt.adoc[`operator&lt;`] 
| Less&hyphen;than operator
| xref:fmt/operator_le.adoc[`operator&lt;&equals;`] 
| Less&hyphen;than&hyphen;or&hyphen;equal operator
| xref:fmt/operator_gt.adoc[`operator&gt;`] 
| Greater&hyphen;than operator
| xref:fmt/operator_ge.adoc[`operator&gt;&equals;`] 
| Greater&hyphen;than&hyphen;or&hyphen;equal operator
|===


=== Concepts

[cols="1"]
|===
| Name
| xref:fmt/formattable.adoc[`formattable`] 
|===


== xref:fmt/enums.adoc[fmt::enums] namespace

=== Functions

[cols="1"]
|===
| Name
| xref:fmt/enums/format_as.adoc[`format&lowbar;as`] 
|===


== xref:fmt/safe_duration_cast.adoc[fmt::safe&lowbar;duration&lowbar;cast] namespace

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:fmt/safe_duration_cast/lossless_integral_conversion-02.adoc[`lossless&lowbar;integral&lowbar;conversion`] 
| Converts From to To, without loss&period; If the dynamic value of from can&apos;t be converted to To without loss, ec is set&period;
| xref:fmt/safe_duration_cast/safe_duration_cast.adoc[`safe&lowbar;duration&lowbar;cast`] 
| Safe duration&lowbar;cast between floating point durations
| xref:fmt/safe_duration_cast/safe_float_conversion-05.adoc[`safe&lowbar;float&lowbar;conversion`] 
| converts From to To if possible, otherwise ec is set&period;
|===



[.small]#Created with https://www.mrdocs.com[MrDocs]#
