./textproc/fmtlib, Formatting library

[ CVSweb ] [ Homepage ] [ RSS ] [ Required by ] [ Add to tracker ]


Branch: CURRENT, Version: 11.0.1, Package name: fmtlib-11.0.1, Maintainer: pkgsrc-users

fmt (formerly cppformat) is an open-source formatting library. It can be used
as a fast and safe alternative to printf and IOStreams.


Master sites:

Filesize: 682.522 KB

Version history: (Expand)


CVS history: (Expand)


   2024-01-04 19:42:57 by Adam Ciarcinski | Files touched by this commit (3) | Package updated
Log message:
fmtlib: updated to 10.2.1

10.2.1 - 2024-01-03

-   Fixed ABI compatibility with earlier 10.x versions

10.2.0 - 2024-01-01

-   Added support for the `%j` specifier (the number of days) for
    `std::chrono::duration`

-   Added support for the chrono suffix for days and changed
    the suffix for minutes from "m" to the correct "min"
    For example ([godbolt](https://godbolt.org/z/9KhMnq9ba)):

    ```c++
    #include <fmt/chrono.h>

    int main() {
      fmt::print("{}\n", std::chrono::days(42)); // prints "42d"
    }
    ```

-   Fixed an overflow in `std::chrono::time_point` formatting with large dates
-   Added a formatter for `std::source_location`
    For example ([godbolt](https://godbolt.org/z/YajfKjhhr)):

    ```c++
    #include <source_location>
    #include <fmt/std.h>

    int main() {
      fmt::print("{}\n", std::source_location::current());
    }
    ```

    prints

    ```
    /app/example.cpp:5:51: int main()
    ```

-   Added a formatter for `std::bitset`

    ```c++
    #include <bitset>
    #include <fmt/std.h>

    int main() {
      fmt::print("{}\n", std::bitset<6>(42)); // prints \ 
"101010"
    }
    ```

-   Added an experimental `nested_formatter` that provides an easy way of
    applying a formatter to one or more subobjects while automatically handling
    width, fill and alignment. For example:

    ```c++
    #include <fmt/format.h>

    struct point {
      double x, y;
    };

    template <>
    struct fmt::formatter<point> : nested_formatter<double> {
      auto format(point p, format_context& ctx) const {
        return write_padded(ctx, [=](auto out) {
          return format_to(out, "({}, {})", nested(p.x), nested(p.y));
        });
      }
    };

    int main() {
      fmt::print("[{:>20.2f}]", point{1, 2});
    }
    ```

    prints

    ```
    [          (1.00, 2.00)]
    ```

-   Added the generic representation (`g`) to `std::filesystem::path`

    ```c++
    #include <filesystem>
    #include <fmt/std.h>

    int main() {
      fmt::print("{:g}\n", std::filesystem::path("C:\\foo"));
    }
    ```

    prints `"C:/foo"` on Windows.

-   Made `format_as` work with references
-   Fixed formatting of invalid UTF-8 with precision
-   Fixed an inconsistency between `fmt::to_string` and `fmt::format`
-   Disallowed unsafe uses of `fmt::styled`

    ```c++
    auto s = fmt::styled(std::string("dangle"), fmt::emphasis::bold);
    fmt::print("{}\n", s); // compile error
    ```

    Pass `fmt::styled(...)` as a parameter instead.

-   Added a null check when formatting a C string with the `s` specifier
-   Disallowed the `c` specifier for `bool`
-   Made the default formatting unlocalized in `fmt::ostream_formatter` for
    consistency with the rest of the library
-   Fixed localized formatting in bases other than decimal
-   Fixed a performance regression in experimental `fmt::ostream::print`
-   Added synchronization with the underlying output stream when writing to
    the Windows console
-   Changed to only export `format_error` when {fmt} is built as a shared
    library
-   Made `fmt::streamed` `constexpr`.
-   Enabled `consteval` on older versions of MSVC
-   Added an option to build without `wchar_t` support on Windows
-   Improved build and CI configuration
-   Fixed various warnings, compilation and test issues
-   Improved documentation and README
-   Updated CI dependencies
   2023-08-29 09:08:09 by Adam Ciarcinski | Files touched by this commit (4) | Package updated
Log message:
fmtlib: updated to 10.1.1

10.1.1

Added formatters for std::atomic and atomic_flag
Fixed an error about partial specialization of formatter<string> after \ 
instantiation when compiled with gcc and C++20
Fixed compilation as a C++20 module with gcc and clang
Made fmt::to_string work with types that have format_as overloads
Made formatted_size work with integral format specifiers at compile time
Fixed a warning about the no_unique_address attribute on clang-cl
Improved compatibility with the legacy GBK encoding
Added OpenSSF Scorecard analysis
Updated CI dependencies
   2023-08-20 22:43:28 by Pierre Pronchery | Files touched by this commit (2) | Package updated
Log message:
fmtlib: update to 10.1.0

From the release information on GitHub:

  * Optimized format string compilation resulting in up to 40% speed up
    in compiled format_to and ~4x speed up in compiled format_to_n on a
    concatenation benchmark
  * Optimized storage of an empty allocator in basic_memory_buffer
  * Added formatters for proxy references to elements of
    std::vector<bool> and std::bitset<N>
  * Fixed an ambiguous formatter specialization for containers that look
    like container adaptors such as boost::flat_set
  * Fixed compilation when formatting durations not convertible from
    std::chrono::seconds
  * Made the formatter specialization for char* const-correct
  * Made {} and {:} handled consistently during compile-time checks
  * Disallowed passing temporaries to make_format_args to improve API
    safety by preventing dangling references
  * Improved the compile-time error for unformattable types
  * Improved the floating-point formatter
  * Fixed handling of precision for long double larger than 64 bits
  * Made floating-point and chrono tests less platform-dependent
  * Removed the remnants of the Grisu floating-point formatter that has
    been replaced by Dragonbox in earlier versions
  * Added throw_format_error to the public API
  * Made FMT_THROW assert even if assertions are disabled when compiling
    with exceptions disabled
  * Added support for the ? format specifier to std::filesystem::path
    and made the default unescaped for consistency with strings
  * Made format_as and std::filesystem::path formatter work with exotic
    code unit types
  * Deprecated the wide stream overload of printf
  * Removed unused basic_printf_parse_context.
  * Improved RTTI detection used when formatting exceptions
  * Improved compatibility with VxWorks7
  * Improved documentation
  * Improved build and CI configurations
  * Fixed various warnings and compilation issues
   2023-05-16 23:20:53 by Thomas Klausner | Files touched by this commit (38)
Log message:
*: PKGREVISION bump for fmtlib shlib major bump
   2023-05-16 23:16:08 by Thomas Klausner | Files touched by this commit (3) | Package updated
Log message:
fmtlib: update to 10.0.0.

10.0.0 - 2023-05-09
-------------------

* Replaced Grisu with a new floating-point formatting algorithm for given
  precision
  The new algorithm is based on Dragonbox already used for the
  shortest representation and gives substantial performance improvement:

* Replaced ``snprintf``-based hex float formatter with an internal
  implementation
  This removes the last usage of ``s(n)printf`` in {fmt}.

* Fixed alignment of floating-point numbers with localization

* Improved C++20 module support
  Switched to the `modules CMake library <https://github.com/vitaut/modules>`_
  which allows building {fmt} as a C++20 module with clang::

    CXX=clang++ cmake -DFMT_MODULE=ON .
    make

* Made ``format_as`` work with any user-defined type and not just enums.
  For example (`godbolt <https://godbolt.org/z/b7rqhq5Kh>`__):

  .. code:: c++

     #include <fmt/format.h>

     struct floaty_mc_floatface {
       double value;
     };

     auto format_as(floaty_mc_floatface f) { return f.value; }

     int main() {
       fmt::print("{:8}\n", floaty_mc_floatface{0.42}); // prints \ 
"    0.42"
     }

* Removed deprecated implicit conversions for enums and conversions to primitive
  types for compatibility with ``std::format`` and to prevent potential ODR
  violations. Use ``format_as`` instead.

* Added support for fill, align and width to the time point formatter

* Implemented formatting of subseconds

* Added precision support to ``%S``

* Added support for ``std::utc_time``

* Switched formatting of ``std::chrono::system_clock`` from local time to UTC
  for compatibility with the standard

* Added support for ``%Ez`` and ``%Oz`` to chrono formatters.

* Improved validation of format specifiers for ``std::chrono::duration``

* Fixed formatting of time points before the epoch

* Experimental: implemented glibc extension for padding seconds, minutes and
  hours

* Added a formatter for ``std::exception``

* Moved ``std::error_code`` formatter from ``fmt/os.h`` to ``fmt/std.h``.

* Added formatters for standard container adapters: ``std::priority_queue``,
  ``std::queue`` and ``std::stack``

* Added a formatter for ``std::optional`` to ``fmt/std.h``.

* Fixed formatting of valueless by exception variants

* Made ``fmt::ptr`` accept ``unique_ptr`` with a custom deleter

* Fixed formatting of noncopyable ranges and nested ranges of chars

* Fixed issues with formatting of paths and ranges of paths

* Improved handling of invalid Unicode in paths.

* Enabled compile-time checks on Apple clang 14 and later

* Improved compile-time checks of named arguments

* Fixed formatting when both alignment and ``0`` are given

* Improved Unicode support in the experimental file API on Windows

* Unified UTF transcoding

* Added support for UTF-8 digit separators via an experimental locale facet

* Added an overload of ``formatted_size`` that takes a locale

* Removed the deprecated ``FMT_DEPRECATED_OSTREAM``.

* Fixed a UB when using a null ``std::string_view`` with ``fmt::to_string``
  or format string compilation

* Added ``starts_with`` to the fallback ``string_view`` implementation

* Added ``fmt::basic_format_string::get()`` for compatibility with
  ``basic_format_string``

* Added ``println`` for compatibility with C++23

* Improved documentation

* Improved build configuration and tests

* Fixed a regression in handling empty format specifiers after a colon (``{:}``)

* Worked around a broken implementation of ``std::is_constant_evaluated`` in
  some versions of libstdc++ on clang

* Fixed formatting of volatile variables

* Fixed various warnings and compilation issues
   2023-01-24 19:36:36 by Thomas Klausner | Files touched by this commit (103)
Log message:
*: convert to cmake/build.mk
   2022-10-08 11:43:19 by Benny Siegert | Files touched by this commit (3) | Package updated
Log message:
fmtlib: update to 9.1.0

From Wongboo via Github pull request.

Closes NetBSD/pkgsrc#111.

9.1.0 - 2022-08-27
------------------

* ``fmt::formatted_size`` now works at compile time
  . For example
  (`godbolt <https://godbolt.org/z/1MW5rMdf8>`__):

  .. code:: c++

     #include <fmt/compile.h>

     int main() {
       using namespace fmt::literals;
       constexpr size_t n = fmt::formatted_size("{}"_cf, 42);
       fmt::print("{}\n", n); // prints 2
     }

* Fixed handling of invalid UTF-8.

* Improved Unicode support in ``ostream`` overloads of ``print``.

* Fixed handling of the sign specifier in localized formatting on systems with
  32-bit ``wchar_t`` .

* Added support for wide streams to ``fmt::streamed``.

* Added the ``n`` specifier that disables the output of delimiters when
  formatting ranges.
  For example (`godbolt <https://godbolt.org/z/roKqGdj8c>`__):

  .. code:: c++

     #include <fmt/ranges.h>
     #include <vector>

     int main() {
       auto v = std::vector{1, 2, 3};
       fmt::print("{:n}\n", v); // prints 1, 2, 3
     }

* Worked around problematic ``std::string_view`` constructors introduced in
  C++23

* Improve handling (exclusion) of recursive ranges

* Improved error reporting in format string compilation.

* Improved the implementation of
  `Dragonbox <https://github.com/jk-jeon/dragonbox>`_, the algorithm used for
  the default floating-point formatting.

* Fixed issues with floating-point formatting on exotic platforms.

* Improved the implementation of chrono formatting.

* Improved documentation.

* Improved build configuration.

* Fixed various warnings and compilation issues.

9.0.0 - 2022-07-04
------------------

* Switched to the internal floating point formatter for all decimal presentation
  formats. In particular this results in consistent rounding on all platforms
  and removing the ``s[n]printf`` fallback for decimal FP formatting.

* Compile-time floating point formatting no longer requires the header-only
  mode. For example (`godbolt <https://godbolt.org/z/G37PTeG3b>`__):

  .. code:: c++

     #include <array>
     #include <fmt/compile.h>

     consteval auto compile_time_dtoa(double value) -> std::array<char, \ 
10> {
       auto result = std::array<char, 10>();
       fmt::format_to(result.data(), FMT_COMPILE("{}"), value);
       return result;
     }

     constexpr auto answer = compile_time_dtoa(0.42);

  works with the default settings.

* Improved the implementation of
  `Dragonbox <https://github.com/jk-jeon/dragonbox>`_, the algorithm used for
  the default floating-point formatting.

* Made ``fmt::to_string`` work with ``__float128``. This uses the internal
  FP formatter and works even on system without ``__float128`` support in
  ``[s]printf``.

* Disabled automatic ``std::ostream`` insertion operator (``operator<<``)
  discovery when ``fmt/ostream.h`` is included to prevent ODR violations.
  You can get the old behavior by defining ``FMT_DEPRECATED_OSTREAM`` but this
  will be removed in the next major release. Use ``fmt::streamed`` or
  ``fmt::ostream_formatter`` to enable formatting via ``std::ostream`` instead.

* Added ``fmt::ostream_formatter`` that can be used to write ``formatter``
  specializations that perform formatting via ``std::ostream``.
  For example (`godbolt <https://godbolt.org/z/5sEc5qMsf>`__):

  .. code:: c++

     #include <fmt/ostream.h>

     struct date {
       int year, month, day;

       friend std::ostream& operator<<(std::ostream& os, const \ 
date& d) {
         return os << d.year << '-' << d.month << '-' \ 
<< d.day;
       }
     };

     template <> struct fmt::formatter<date> : ostream_formatter {};

     std::string s = fmt::format("The date is {}", date{2012, 12, 9});
     // s == "The date is 2012-12-9"

* Added the ``fmt::streamed`` function that takes an object and formats it
  via ``std::ostream``.
  For example (`godbolt <https://godbolt.org/z/5G3346G1f>`__):

  .. code:: c++

     #include <thread>
     #include <fmt/ostream.h>

     int main() {
       fmt::print("Current thread id: {}\n",
                  fmt::streamed(std::this_thread::get_id()));
     }

  Note that ``fmt/std.h`` provides a ``formatter`` specialization for
  ``std::thread::id`` so you don't need to format it via ``std::ostream``.

* Deprecated implicit conversions of unscoped enums to integers for consistency
  with scoped enums.

* Added an argument-dependent lookup based ``format_as`` extension API to
  simplify formatting of enums.

* Added experimental ``std::variant`` formatting support.
  For example (`godbolt <https://godbolt.org/z/KG9z6cq68>`__):

  .. code:: c++

     #include <variant>
     #include <fmt/std.h>

     int main() {
       auto v = std::variant<int, std::string>(42);
       fmt::print("{}\n", v);
     }

  prints::

     variant(42)

  Thanks `@jehelset <https://github.com/jehelset>`_.

* Added experimental ``std::filesystem::path`` formatting support
  (`#2865 <https://github.com/fmtlib/fmt/issues/2865>`_,
  `#2902 <https://github.com/fmtlib/fmt/pull/2902>`_,
  `#2917 <https://github.com/fmtlib/fmt/issues/2917>`_,
  `#2918 <https://github.com/fmtlib/fmt/pull/2918>`_).
  For example (`godbolt <https://godbolt.org/z/o44dMexEb>`__):

  .. code:: c++

     #include <filesystem>
     #include <fmt/std.h>

     int main() {
       fmt::print("There is no place like {}.", \ 
std::filesystem::path("/home"));
     }

  prints::

     There is no place like "/home".

* Added a ``std::thread::id`` formatter to ``fmt/std.h``.
  For example (`godbolt <https://godbolt.org/z/j1azbYf3E>`__):

  .. code:: c++

     #include <thread>
     #include <fmt/std.h>

     int main() {
       fmt::print("Current thread id: {}\n", std::this_thread::get_id());
     }

* Added ``fmt::styled`` that applies a text style to an individual argument.
  .
  For example (`godbolt <https://godbolt.org/z/vWGW7v5M6>`__):

  .. code:: c++

     #include <fmt/chrono.h>
     #include <fmt/color.h>

     int main() {
       auto now = std::chrono::system_clock::now();
       fmt::print(
         "[{}] {}: {}\n",
         fmt::styled(now, fmt::emphasis::bold),
         fmt::styled("error", fg(fmt::color::red)),
         "something went wrong");
     }

* Made ``fmt::print`` overload for text styles correctly handle UTF-8.

* Fixed Unicode handling when writing to an ostream.

* Added support for nested specifiers to range formatting:

  .. code:: c++

     #include <vector>
     #include <fmt/ranges.h>

     int main() {
       fmt::print("{::#x}\n", std::vector{10, 20, 30});
     }

  prints ``[0xa, 0x14, 0x1e]``.

* Implemented escaping of wide strings in ranges.

* Added support for ranges with ``begin`` / ``end`` found via the
  argument-dependent lookup.

* Fixed formatting of certain kinds of ranges of ranges.

* Fixed handling of maps with element types other than ``std::pair``.

* Made tuple formatter enabled only if elements are formattable.

* Made ``fmt::join`` compatible with format string compilation.

* Made compile-time checks work with named arguments of custom types and
  ``std::ostream`` ``print`` overloads.

* Removed ``make_args_checked`` because it is no longer needed for compile-time.

* Removed the following deprecated APIs: ``_format``, ``arg_join``,
  the ``format_to`` overload that takes a memory buffer,
  ``[v]fprintf`` that takes an ``ostream``.

* Removed the deprecated implicit conversion of ``[const] signed char*`` and
  ``[const] unsigned char*`` to C strings.

* Removed the deprecated ``fmt/locale.h``.

* Replaced the deprecated ``fileno()`` with ``descriptor()`` in
  ``buffered_file``.

* Moved ``to_string_view`` to the ``detail`` namespace since it's an
  implementation detail.

* Made access mode of a created file consistent with ``fopen`` by setting
  ``S_IWGRP`` and ``S_IWOTH``.

* Removed a redundant buffer resize when formatting to ``std::ostream``.

* Made precision computation for strings consistent with width.
  .

* Fixed handling of locale separators in floating point formatting.

* Made sign specifiers work with ``__int128_t``.

* Improved support for systems such as CHERI with extra data stored in pointers.

* Improved documentation.

* Improved build configuration.

* Fixed various warnings and compilation issues.
   2022-01-07 22:16:09 by Adam Ciarcinski | Files touched by this commit (2) | Package updated
Log message:
fmtlib: updated to 8.1.1

8.1.1 - 2022-01-06
------------------
* Restored ABI compatibility with version 8.0.x
* Fixed chorno formatting on big endian systems
* Fixed a linkage error with mingw

8.1.0 - 2022-01-02
------------------
* Optimized chrono formatting
  Processing of some specifiers such as ``%z`` and ``%Y`` is now up to 10-20
  times faster, for example on GCC 11 with libstdc++::

    ----------------------------------------------------------------------------
    Benchmark                                  Before             After
    ----------------------------------------------------------------------------
    FMTFormatter_z                             261 ns             26.3 ns
    FMTFormatterCompile_z                      246 ns             11.6 ns
    FMTFormatter_Y                             263 ns             26.1 ns
    FMTFormatterCompile_Y                      244 ns             10.5 ns
    ----------------------------------------------------------------------------
* Implemented subsecond formatting for chrono durations
  For example (`godbolt <https://godbolt.org/z/es7vWTETe>`__):

  .. code:: c++

     #include <fmt/chrono.h>

     int main() {
       fmt::print("{:%S}", std::chrono::milliseconds(1234));
     }

  prints "01.234".
* Fixed handling of precision 0 when formatting chrono durations
* Fixed an overflow on invalid inputs in the ``tm`` formatter
* Added ``fmt::group_digits`` that formats integers with a non-localized digit
  separator (comma) for groups of three digits.
  For example (`godbolt <https://godbolt.org/z/TxGxG9Poq>`__):

  .. code:: c++

     #include <fmt/format.h>

     int main() {
       fmt::print("{} dollars", fmt::group_digits(1000000));
     }

  prints "1,000,000 dollars".

* Added support for faint, conceal, reverse and blink text styles
* Added experimental support for compile-time floating point formatting
  It is currently limited to the header-only mode.
* Added UDL-based named argument support to compile-time format string checks
  For example (`godbolt <https://godbolt.org/z/ohGbbvonv>`__):

  .. code:: c++

     #include <fmt/format.h>

     int main() {
       using namespace fmt::literals;
       fmt::print("{answer:s}", "answer"_a=42);
     }

  gives a compile-time error on compilers with C++20 ``consteval`` and non-type
  template parameter support (gcc 10+) because ``s`` is not a valid format
  specifier for an integer.
* Implemented escaping of string range elements.
  For example (`godbolt <https://godbolt.org/z/rKvM1vKf3>`__):

  .. code:: c++

     #include <fmt/ranges.h>
     #include <vector>

     int main() {
       fmt::print("{}", std::vector<std::string>{"\naan"});
     }

  is now printed as::

    ["\naan"]

  instead of::

    ["
    aan"]

* Switched to JSON-like representation of maps and sets for consistency with
  Python's ``str.format``.
  For example (`godbolt <https://godbolt.org/z/seKjoY9W5>`__):

  .. code:: c++

     #include <fmt/ranges.h>
     #include <map>

     int main() {
       fmt::print("{}", std::map<std::string, \ 
int>{{"answer", 42}});
     }

  is now printed as::

    {"answer": 42}

* Extended ``fmt::join`` to support C++20-only ranges
* Optimized handling of non-const-iterable ranges and implemented initial
  support for non-const-formattable types.
* Disabled implicit conversions of scoped enums to integers that was
  accidentally introduced in earlier versions
* Deprecated implicit conversion of ``[const] signed char*`` and
  ``[const] unsigned char*`` to C strings.
* Deprecated ``_format``, a legacy UDL-based format API
* Marked ``format``, ``formatted_size`` and ``to_string`` as ``[[nodiscard]]``
* Added missing diagnostic when trying to format function and member pointers
  as well as objects convertible to pointers which is explicitly disallowed
* Optimized writing to a contiguous buffer with ``format_to_n``
* Optimized writing to non-``char`` buffers
* Decimal point is now localized when using the ``L`` specifier.
* Improved floating point formatter implementation
* Fixed handling of very large precision in fixed format
* Made a table of cached powers used in FP formatting static
* Resolved a lookup ambiguity with C++20 format-related functions due to ADL
* Removed unnecessary inline namespace qualification
* Implemented argument forwarding in ``format_to_n``
* Fixed handling of implicit conversions in ``fmt::to_string`` and format string
  compilation
* Changed the default access mode of files created by ``fmt::output_file`` to
  ``-rw-r--r--`` for consistency with ``fopen``
* Make ``fmt::ostream::flush`` public
* Improved C++14/17 attribute detection
* Improved documentation
* Improved fuzzers and added a fuzzer for chrono timepoint formatting
* Added the ``FMT_SYSTEM_HEADERS`` CMake option setting which marks {fmt}'s
  headers as system. It can be used to suppress warnings
* Added the Bazel build system support
* Improved build configuration and tests
* Fixed various warnings and compilation issues