RcppSpdlog/0000755000176200001440000000000014612660532012334 5ustar liggesusersRcppSpdlog/NAMESPACE0000644000176200001440000000024214350723170013546 0ustar liggesusersuseDynLib(RcppSpdlog, .registration=TRUE) importFrom(Rcpp, evalCpp) exportPattern("^[[:alpha:]]+") S3method("format", "stopwatch") S3method("print", "stopwatch") RcppSpdlog/ChangeLog0000644000176200001440000002534414612606320014111 0ustar liggesusers2024-04-25 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Version 0.0.17 * inst/include/spdlog/*: New upstream release spdlog 1.14.0 2024-04-02 Dirk Eddelbuettel * .github/workflows/ci.yaml (jobs): Update to actions/checkout@v4, add r-ci-setup actions 2024-01-12 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Version 0.0.16 * inst/include/spdlog/*: New upstream release spdlog 1.13.0 2023-11-29 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Version 0.0.15 * src/RcppExports.cpp: Regenerated under updated Rcpp to address format string issue reported by R-devel * man/RcppSpdlog-package.Rd: Remove some empty default entries 2023-07-09 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Version 0.0.14 2023-07-08 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll micro release version * inst/include/spdlog/*: New upstream release spdlog 1.12.0 2023-06-28 Dirk Eddelbuettel * README.md: Add r-universe badge 2023-06-17 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Version 0.0.13 2023-06-13 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll micro release version * src/interface.cpp (log_init): Add a simple convenience wrapper to log_setup() which omits the first 'logger name' argument * inst/include/spdl.h: Define convenience wrappers init() and log() 2023-03-19 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll micro release version * src/Makevars: No longer set a C++ standard * R/RcppExports.R (setLoadAction): Updated .Call using backticks 2023-01-17 Dirk Eddelbuettel * inst/include/spdlog_stopwatch.h: Define stopwatch without fmt.h header * inst/include/RcppSpdlog_types.h: Use spdlog_stopwatch if #define set 2023-01-07 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Version 0.0.12 2022-12-27 Dirk Eddelbuettel * src/interface.cpp: Add documentation reference for format pattern * man/log_setup.Rd: Idem * R/RcppExports.R: Idem 2022-12-25 Dirk Eddelbuettel * inst/include/spdl.h: Wrap three RcppSpdlog::*_stopwatch() functions 2022-12-23 Dirk Eddelbuettel * src/interface.cpp: Split stopwatch documentation off * man/get_stopwatch.Rd: Idem * man/log_setup.Rd: Idem * src/RcppExports.cpp: Idem * R/RcppExports.R: Idem 2022-12-22 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll micro release version * src/interface.cpp: Define and document three new functions for stopwatch * R/RcppExports.R: Export new functions * src/RcppExports.cpp: Idem * inst/include/RcppSpdlog_RcppExports.h: Idem * inst/include/RcppSpdlog_types.h: Include stopwatch, add XPtr template * inst/include/RcppSpdlog: Use new header * man/log_setup.Rd: Add documentation * R/stopwatch.R: Add two S3 methods for stopwatch objects * NAMESPACE: Export methods * inst/include/rcpp_sink.h: Use lighter Rcpp interface 2022-12-13 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Version 0.0.11 * vignettes/introduction.md: Microedit 2022-12-12 Dirk Eddelbuettel * src/interface.cpp (log_filesetup): Setup (simple) file-based logger * R/RcppExports.R: R accessor * src/RcppExports.cpp: Autogenerated export for C level access * inst/include/RcppSpdlog_RcppExports.h: Idem * inst/include/rcpp_sink.h: Added #include * man/log_setup.Rd: Added documentation * inst/include/spdl.h: Added in spdl namespace 2022-12-02 Dirk Eddelbuettel * README.md: Mention the new spdl package 2022-11-18 Dirk Eddelbuettel * src/formatter.cpp: Export to C++ to make formatter() callable * src/RcppExports.cpp: Autogenerated export for C level access * inst/include/RcppSpdlog_RcppExports.h: Idem 2022-11-17 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Version 0.0.10 * vignettes/introduction.md: More edits 2022-11-15 Dirk Eddelbuettel * src/formatter.cpp (formatter): Add formatting helper which passes logging string to fmt::format() enable fmt's "format" from R * src/RcppExports.cpp: Ditto * R/RcppExports.R (formatter): Ditto * man/formatter.Rd: Docs * inst/include/spdl.h: Include fmtlib::fmt via spdlog 2022-11-14 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll micro release version * inst/include/spdl.h: Use variadic templates to fmt::format 2022-11-04 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Version 0.0.9 2022-11-03 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll micro release version * inst/include/spdlog/*: New upstream release spdlog 1.11.0 * vignettes/introduction.md: Small edits 2022-11-02 Dirk Eddelbuettel * vignettes/introduction.md: New sections for access from R and C++ 2022-11-01 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll micro release version * inst/include/RcppSpdlog: Ad second shorter namespace 'spdl' with shorter (inlined) function names as simpler accessors * vignettes/introduction.md: Two new sections on access from R and C++, respectively 2022-10-31 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll micro release version 2022-10-30 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll micro release version * src/interface.cpp: Add R interface to spdlog * man/log_setup.Rd: Documentation * .github/workflows/ci.yaml (jobs): Update to actions/checkout@v3 * src/interface.cpp: Activate R and C++ interface generation * R/RcppExports.R: Updated accordingly * src/RcppExports.cpp: Idem * inst/include/RcppSpdlog.h: Generated * inst/include/RcppSpdlog_RcppExports.h: Idem 2022-04-04 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Version 0.0.8 * inst/include/spdlog/*: New upstream release spdlog 1.10.0 2021-12-05 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Version 0.0.7 2021-11-20 Dirk Eddelbuettel * vignettes/water.css: Added css file 2021-11-19 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version * vignettes/introduction.md: Converted from Rmd to simplermarkdown * DESCRIPTION: Switched VignetteBuilder: to simplermarkdown 2021-08-12 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version * inst/include/spdlog/*: New upstream release spdlog 1.9.2 2021-07-27 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version * inst/include/spdlog/*: New upstream release spdlog 1.9.1 2021-07-21 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Version 0.0.6 * inst/include/spdlog/*: New upstream spdlog 1.9.0 (with fmt 8.x) 2021-03-28 Dirk Eddelbuettel * docs/mkdmt-src/: Moved mkdocs-material input 2021-03-27 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Version 0.0.5 2021-03-25 Dirk Eddelbuettel * inst/include/spdlog/*: New upstream release spdlog 1.8.4 + 1.8.5 2021-03-24 Dirk Eddelbuettel * DESCRIPTION (Description): Mention Gabi explicitly (URL): List GitHub repo and package pages (BugReports): List GitHub issues pages * inst/include/spdlog/*: New upstream release spdlog 1.8.3 2020-12-25 Dirk Eddelbuettel * .github/workflows/ci.yaml: Small tweaks to CI YAML file 2020-12-11 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Version 0.0.4 * inst/include/spdlog/*: New upstream release spdlog 1.8.2 * .github/workflows/ci.yaml: Add CI runner using r-ci 2020-10-23 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Version 0.0.3 * docs/: Added package website * docs-src/: Added package website inputs 2020-10-19 Dirk Eddelbuettel * README.md: Updated example 2020-10-08 Dirk Eddelbuettel * vignettes/introduction.Rmd (vignette): Compile-time example added 2020-10-04 Dirk Eddelbuettel * vignettes/introduction.Rmd (vignette): New (draft) vignette * DESCRIPTION (VignetteBuilder): Add knitr (Suggests): Add knitr, rmarkdown, minidown * inst/examples/exampleTwo.cpp (exampleTwo): Added cleanup at end with logger removal to permit multiple calls to example function * inst/examples/exampleThree.cpp (exampleThree): Idem 2020-10-01 Dirk Eddelbuettel * inst/include/spdlog/*: Upgraded to upstream release 1.8.1 2020-09-30 Dirk Eddelbuettel * src/exampleRsink.cpp (exampleRsink): Use default logger instance 2020-09-29 Dirk Eddelbuettel * src/exampleRsink.cpp (setLogLevel): New function * R/RcppExports.R (exampleRsink): R accessor * man/setLogLevel.Rd: Documentation 2020-09-28 Dirk Eddelbuettel * inst/include/spdlog/logger-inl.h: Synchronised with our PR #1685 switching to REprintf() if R_R_H and USING_R defined * inst/include/RcppSpdlog: Include R.h so that R_R_H and USING_R defined, define SPDLOG_DISABLE_DEFAULT_LOGGER here * src/exampleRsink.cpp: Removed SPDLOG_DISABLE_DEFAULT_LOGGER def. 2020-09-17 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Version 0.0.2 * inst/include/spdlog/*: Upgraded to upstream release 1.8.0 * inst/include/spdlog/logger-inl.h: Switch to REprintf as before * .travis.yml: Use BSPM, turn os macOS * src/exampleRsink.cpp (exampleRsink): Add 'stopwatch' demo 2020-09-08 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Version 0.0.1 2020-08-21 Dirk Eddelbuettel * src/exampleRsink.cpp: Renamed from exampleFour() * man/exampleRsink.Rd: Idem * src/RcppExports.cpp: Updated * R/RcppExports.R: Idem * README.md: Some more edits 2020-08-20 Dirk Eddelbuettel * inst/include/RcppSpdlog: Easy wrapper for spdlog and R sink * inst/include/rcpp_sink.h: A sink for R using Rcpp::Rcout * src/exampleFour.cpp: Rewritten and now R CMD check clean * inst/examples/examplesFour.cpp: Now in src/, R sink in its header * README.md: Edited, added two badges * cleanup: Added * .editorconfig: Idem 2020-08-19 Dirk Eddelbuettel * inst/include/spdlog/*: Using spdlog version 1.7 * inst/examples/*: Four simple usage examples * .travis.yml: Added though no real tests present * src/exampleFour.cpp (exampleFour): Simple wrapper around simple Rcpp logger class which still triggers R warnings * man/exampleFour.Rd: Basic help page * src/RcppExports.cpp: Generated * src/Makevars: Added * R/RcppExports.R: Idem * NAMESPACE: Added * DESCRIPTION: Added Imports: and LinkingTo: for Rcpp RcppSpdlog/README.md0000644000176200001440000001702714447170526013627 0ustar liggesusers ## RcppSpdlog: Bundling of spdlog for use from R and Rcpp [![CI](https://github.com/eddelbuettel/rcppspdlog/actions/workflows/ci.yaml/badge.svg)](https://github.com/eddelbuettel/rcppspdlog/actions/workflows/ci.yaml) [![License](https://img.shields.io/badge/license-GPL%20%28%3E=%202%29-brightgreen.svg?style=flat)](https://www.gnu.org/licenses/gpl-2.0.html) [![CRAN](https://www.r-pkg.org/badges/version/RcppSpdlog)](https://cran.r-project.org/package=RcppSpdlog) [![r-universe](https://eddelbuettel.r-universe.dev/badges/RcppSpdlog)](https://eddelbuettel.r-universe.dev/RcppSpdlog) [![Dependencies](https://tinyverse.netlify.com/badge/RcppSpdlog)](https://cran.r-project.org/package=RcppSpdlog) [![Downloads](https://cranlogs.r-pkg.org/badges/RcppSpdlog?color=brightgreen)](https://www.r-pkg.org/pkg/RcppSpdlog) [![Last Commit](https://img.shields.io/github/last-commit/eddelbuettel/rcppspdlog)](https://github.com/eddelbuettel/rcppspdlog) [![Documentation](https://img.shields.io/badge/documentation-is_here-blue)](https://eddelbuettel.github.io/rcppspdlog/) ### About The [spdlog](https://github.com/gabime/spdlog) library is a widely-used and very capable header-only C++ library for logging. This package includes its headers as an R package to permit other R packages to deploy it via a simple `LinkingTo: RcppSpdlog` as described in [Section 1.1.3 of WRE](https://cran.r-project.org/doc/manuals/r-release/R-exts.html#Package-Dependencies). As of version 0.0.9, it also provides both simple R logging functions and compiled functions callable by other packages as described in [Section 5.4.3 of WRE](https://cran.r-project.org/doc/manuals/r-release/R-exts.html#Linking-to-native-routines-in-other-packages). ### Example A simple first example, following the upstream examples: ```sh edd@rob:~$ Rscript -e 'Rcpp::sourceCpp("inst/examples/exampleOne.cpp")' R> exampleOne() [07:45:57.168673] [I] [thread 1500593] Welcome to spdlog! [07:45:57.168704] [E] [thread 1500593] Some error message with arg: 1 [07:45:57.168707] [W] [thread 1500593] Easy padding in numbers like 00000012 [07:45:57.168710] [C] [thread 1500593] Support for int: 42; hex: 2a; oct: 52; bin: 101010 [07:45:57.168728] [I] [thread 1500593] Support for floats 1.23 [07:45:57.168731] [I] [thread 1500593] Positional args are supported too.. [07:45:57.168734] [I] [thread 1500593] left aligned [07:45:57.168737] [D] [thread 1500593] This message should be displayed.. edd@rob:~$ ``` This logs the hour, minute, second, microsecond followed by a one-char code for info, error, warning or critical followed by the thread id and the actual loggable message. The code, apart from the included headers and more, is simply ```c++ // [[Rcpp::export]] void exampleOne() { // change log pattern (changed from [%H:%M:%S %z] [%n] [%^---%L---%$] ) spdlog::set_pattern("[%H:%M:%S.%f] [%L] [thread %t] %v"); spdlog::info("Welcome to spdlog!"); spdlog::error("Some error message with arg: {}", 1); spdlog::warn("Easy padding in numbers like {:08d}", 12); spdlog::critical("Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}", 42); spdlog::info("Support for floats {:03.2f}", 1.23456); spdlog::info("Positional args are {1} {0}..", "too", "supported"); spdlog::info("{:<30}", "left aligned"); spdlog::set_level(spdlog::level::debug); // Set global log level to debug spdlog::debug("This message should be displayed.."); // Compile time log levels // define SPDLOG_ACTIVE_LEVEL to desired level SPDLOG_TRACE("Some trace message with param {}", {}); SPDLOG_DEBUG("Some debug message"); } ``` Many other customizations are possible, see the [spdlog wiki](https://github.com/gabime/spdlog/wiki). Note that using `spdlog` examples directly _may_ well trigger warning from R during package checking as `stdout` and/or `stderr` may be used. See the included example function described in the next section which uses a derived class to pass logging output explicitly to the R input/output stream as per the R coding requirements, see [Section 1.3.1 (and others) of WRE](https://cran.r-project.org/doc/manuals/r-release/R-exts.html#Checking-packages). ### Use in R Packages and Warnings As shipped, both [spdlog](https://github.com/gabime/spdlog) and the embedded [fmt](https://github.com/fmtlib/fmt) use `stdout` and `stderr` in ways that may make it non-trivial to fully replace them with R input/output as required by [Section 1.3.1 (and others) of WRE](https://cran.r-project.org/doc/manuals/r-release/R-exts.html#Checking-packages). However, based on some initial trials and some excellent help from upstream we have defined a specific sink for R in the header [`rcpp_sink.h`](https://github.com/eddelbuettel/rcppspdlog/blob/master/inst/include/rcpp_sink.h), corrected one `stderr` use and added one `#define`. That combination now passes as can be seen in checks of the package `RcppSpdlog` and the included function `exampleRsink()` whose complete source code is included here: ```c++ // this portmanteau include also defines the r_sink we use below, and which // diverts all logging to R via the Rcpp::Rcout replacement for std::cout #include //' spdlog Example using a sink for R //' //' A simple example invoking a derived R/Rcpp logger. Also demonstrates the //' stopwatch feature. For more features see the 'spdlog' documnetation. //' //' Note that this no longer triggers R warnings thanks to excellent help by //' Gabi Melman. //' @return None //' @examples //' exampleRsink() // [[Rcpp::export]] void exampleRsink() { std::string logname = "fromR"; // fix a name for this logger auto sp = spdlog::get(logname); // retrieve existing one if (sp == nullptr) sp = spdlog::r_sink_mt(logname); // or create new one if needed spdlog::stopwatch sw; // instantiate a stop watch // change log pattern (changed from [%H:%M:%S %z] [%n] [%^---%L---%$] ) spdlog::set_pattern("[%H:%M:%S.%f] [%n] [%^%L%$] [thread %t] %v"); spdlog::info("Welcome to spdlog!"); spdlog::error("Some error message with arg: {}", 1); spdlog::info("Elapsed time: {}", sw); spdlog::warn("Easy padding in numbers like {:08d}", 12); spdlog::critical("Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}", 42); spdlog::info("Support for floats {:03.2f}", 1.23456); spdlog::info("Positional args are {1} {0}..", "too", "supported"); spdlog::info("{:<30}", "left aligned"); spdlog::info("Elapsed time: {}", sw); } ``` Note that it is deliberately similar in use to the example above. A new instance of the logger is instantiated as a shared pointer `sp` to a `spdlog` object. Similarly, a stopwatch is instantiated used simply by referring to it. We may make additional package features available in the future. ### See Also The [spdl](https://github.com/eddelbuettel/spdl) package, now also on CRAN, wraps around this package to provide a _uniform and consistent_ logging interface from both R _and_ C++. It defines a new C++ namespace `spdl` along with matching R functions. ### Author [Gabi Melman](https://github.com/gabime) is the main author of [spdlog](https://github.com/gabime/spdlog). [Victor Zverovich](https://github.com/vitaut) is the main author of the embedded [fmt](https://github.com/fmtlib/fmt) library. [Dirk Eddelbuettel](https://dirk.eddelbuettel.com) is author of this package and the R integration. ### License [spdlog](https://github.com/gabime/spdlog) and [fmt](https://github.com/fmtlib/fmt) are under the MIT license. RcppSpdlog is released under the GNU GPL, version 2 or later, just like R and Rcpp. RcppSpdlog/man/0000755000176200001440000000000014351373041013103 5ustar liggesusersRcppSpdlog/man/exampleRsink.Rd0000644000176200001440000000076313730663451016051 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/RcppExports.R \name{exampleRsink} \alias{exampleRsink} \title{spdlog Example using a sink for R} \usage{ exampleRsink() } \value{ None } \description{ A simple example invoking a derived R/Rcpp logger. Also demonstrates the stopwatch feature. For more features see the 'spdlog' documnetation. } \details{ Note that this no longer triggers R warnings thanks to excellent help by Gabi Melman. } \examples{ exampleRsink() } RcppSpdlog/man/log_setup.Rd0000644000176200001440000000543414442072327015405 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/RcppExports.R \name{log_setup} \alias{log_setup} \alias{log_init} \alias{log_filesetup} \alias{log_drop} \alias{log_set_pattern} \alias{log_set_level} \alias{log_trace} \alias{log_debug} \alias{log_info} \alias{log_warn} \alias{log_error} \alias{log_critical} \title{R Accessor Functions for spdlog Logger} \usage{ log_setup(name = "default", level = "warn") log_init(level = "warn") log_filesetup(filename, name = "default", level = "warn") log_drop(name) log_set_pattern(s) log_set_level(s) log_trace(s) log_debug(s) log_info(s) log_warn(s) log_error(s) log_critical(s) } \arguments{ \item{name}{A character variable with the logging instance name, default value is \sQuote{default}.} \item{level}{A character variable with the default logging level, default value is \sQuote{warn}.} \item{filename}{A character variable with the logging filename if a file-based logger is instantiated.} \item{s}{A character variable with the logging pattern, level or message.} } \value{ Nothing is returned from these functions as they are invoked for their side-effects. } \description{ Several R-level functions can access the \code{spdlog} logging facilties. As \code{spdlog} is a C++-level logging library, these are R function permit concurrent logging from both R and C++. } \details{ Several functions are provided: \describe{ \item{\code{log_setup}}{Initializes a logger (which becomes the default logger).} \item{\code{log_filesetup}}{Initializes a file-based logger (which becomes the default).} \item{\code{log_drop}}{Removes logger (which in general should not be needed).} \item{\code{log_set_pattern}}{Changes the default logging message pattern.} \item{\code{log_set_level}}{Sets the logging level threshold.} \item{\code{log_trace}}{Logs a trace-level message.} \item{\code{log_debug}}{Logs a debug-level message.} \item{\code{log_info}}{Logs a info-level message.} \item{\code{log_warn}}{Logs a warn-level message.} \item{\code{log_error}}{Logs a error-level message.} \item{\code{log_critical}}{Logs a critical-level message.} } Supported logging levels are, in order of increasing threshold values, \sQuote{trace}, \sQuote{debug}, \sQuote{warn}, \sQuote{info}, \sQuote{warn}, \sQuote{error}, and \sQuote{critical}. A message issued below the current threshold is not displayed whereas a message at or above the current threshold is displayed. The default level is \sQuote{warn}. } \examples{ log_setup("demo") # at default level 'warn' log_info("this message is NOT seen") log_set_level("debug") log_info("this message is seen") log_warn("as is this message") } \seealso{ The logging pattern format is described in at the repo in the page \url{https://github.com/gabime/spdlog/wiki/3.-Custom-formatting}. } RcppSpdlog/man/get_stopwatch.Rd0000644000176200001440000000311114351375031016242 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/RcppExports.R, R/stopwatch.R \name{get_stopwatch} \alias{get_stopwatch} \alias{elapsed_stopwatch} \alias{format_stopwatch} \alias{print.stopwatch} \alias{format.stopwatch} \title{R Accessor Functions for spdlog Stopwatch} \usage{ get_stopwatch() elapsed_stopwatch(sw) format_stopwatch(sw) \method{print}{stopwatch}(x, ...) \method{format}{stopwatch}(x, ...) } \arguments{ \item{sw}{An S3 object of type \code{stopwatch}.} \item{x}{An S3 object of type \code{stopwatch}.} \item{...}{Dotted argument required by generic, unused here.} } \value{ The desired object is returned: respectively, a stopwatch object as an external pointer in an S3 class, the elapsed time in seconds as a double, or formatted as a character variable. } \description{ A set of functions provides access to the \code{spdlog} stopwatch facilty. As \code{stopwatch} object is a simple container around a C++ \code{std::chrono} object which (essentially) reports elapsed-time since creation. The object is exported to R via an external pointer permitting use from both R and C++. } \details{ Several functions are provided: \describe{ \item{\code{get_stopwatch}}{Returns a stopwatch object (as an S3 object).} \item{\code{elapsed_stopwatch}}{Returns elapsed time for stopwatch in seconds.} \item{\code{format_stopwatch}}{Returns elapsed time for stopwatch as character variable.} } The \code{stopwatch} object has \code{print} and \code{format} methods. } \examples{ w <- get_stopwatch() Sys.sleep(0.2) elapsed_stopwatch(w) format_stopwatch(w) } RcppSpdlog/man/setLogLevel.Rd0000644000176200001440000000113613735165211015623 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/RcppExports.R \name{setLogLevel} \alias{setLogLevel} \title{spdlog Logging Lever Setter} \usage{ setLogLevel(name) } \arguments{ \item{name}{A string with the logging level. Value understood are, in decreasing verbosity \sQuote{trace}, \sQuote{debug}, \sQuote{info}, \sQuote{warning}, \sQuote{error}, \sQuote{critical}, and \sQuote{off}. Unrecognised names are equivalent to \sQuote{off}.} } \value{ Nothing is returned. } \description{ A helper function to turn a logging level given as string into the current logging level } RcppSpdlog/man/RcppSpdlog-package.Rd0000644000176200001440000000112614531532357017047 0ustar liggesusers\name{RcppSpdlog-package} \alias{RcppSpdlog-package} \alias{RcppSpdlog} \docType{package} \title{\packageTitle{RcppSpdlog}} \description{\packageDescription{RcppSpdlog}} \details{ The DESCRIPTION file: \packageDESCRIPTION{RcppSpdlog} \packageIndices{RcppSpdlog} This section should provide a more detailed overview of how to use the package, including the most important functions. } \author{ \packageAuthor{RcppSpdlog} Maintainer: \packageMaintainer{RcppSpdlog} } % Optionally other standard keywords, one per line, % from the file KEYWORDS in the R documentation. \keyword{package} RcppSpdlog/man/formatter.Rd0000644000176200001440000000221714345741570015410 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/RcppExports.R \name{formatter} \alias{formatter} \title{Simple Pass-Through Formatter to \code{fmt::format()}} \usage{ formatter(s, v) } \arguments{ \item{s}{A character variable with a format string for \sQuote{fmtlib::fmt}} \item{v}{A character vector with the logging string arguments.} } \value{ A single (formatted) string } \description{ The C-level interface of R does not make it easy to pass \code{...} arguments. This helper function assumes it has already been called with \code{format()} on each argument (as a wrapper can do) so it just spreads out the class to \code{fmt::format{}} which, being C++, uses variadic templates to receive the arguments. The main motivation for this function to able to format string as use by the \sQuote{fmtlib::fmt} library included in \sQuote{spdlog} to write similar debug strings in both R and C++. This function permits R calls with multiple arguments of different types which (by being formatted on the R side) are handled as strings (whereas C++ logging has access to the templating logic). } \seealso{ https://github.com/fmtlib/fmt } RcppSpdlog/DESCRIPTION0000644000176200001440000000174714612660532014053 0ustar liggesusersPackage: RcppSpdlog Type: Package Title: R and C++ Interfaces to 'spdlog' C++ Header Library for Logging Version: 0.0.17 Date: 2024-04-25 License: GPL (>= 2) Author: Dirk Eddelbuettel Maintainer: Dirk Eddelbuettel Description: The mature and widely-used C++ logging library 'spdlog' by Gabi Melman provides many desirable features. This package bundles these header files for easy use by R packages from both their R and C or C++ code. Explicit use via 'LinkingTo:' is also supported. Also see the 'spdl' package which enhanced this package with a consistent R and C++ interface. URL: https://github.com/eddelbuettel/rcppspdlog, https://dirk.eddelbuettel.com/code/rcpp.spdlog.html BugReports: https://github.com/eddelbuettel/rcppspdlog/issues LinkingTo: Rcpp Imports: Rcpp Suggests: simplermarkdown VignetteBuilder: simplermarkdown RoxygenNote: 6.0.1 NeedsCompilation: yes Packaged: 2024-04-26 02:10:52 UTC; edd Repository: CRAN Date/Publication: 2024-04-26 08:10:02 UTC RcppSpdlog/build/0000755000176200001440000000000014612606453013435 5ustar liggesusersRcppSpdlog/build/vignette.rds0000644000176200001440000000032214612606453015771 0ustar liggesusersb```b`a@&0`b fd`ay%E)%yz)hRH % A)9h*Q (ASr0&$yּb4M.y) 3GZY_Ӄ -3'foHf e2|s mMI,F(WJbI^ZP?% NRcppSpdlog/build/partial.rdb0000644000176200001440000000711114612606453015562 0ustar liggesusersVF66&K&g6Kb6M|@n7"KZx9w[fg=Fea|j~ϝh6H$Rt#9+HxwӉI gKa YyC:L$)c$:,c"S2a 8Cr{KLP8O&]5EфelS|g?e&鲢M&- %6 %ra>ČRo[o%µ_4 }<+ZMhKU[Qڊ\}*UamQG)jŠv %M@upT{Tg?aV8Pҏ\>ʍ$xc/vYt2BGB %=9XKuGtGqATϠCĤ=e~uj pgiI-'JQdQx֯Ħ RebYj"M!Jg#ǜr9T(C Z)/Q8̏Ghmm g T,R n.7mybA,vMQ2u@Y8yV&_~ 4 5QX:XDoΥ?BQ&Vh@Mu^wr4Ka(ln,MnI  "Rr6:*o3w!LŰ] HD/EQ˔c3.3HT[i@-ۄ?(2T[yA7TځJ=Z*`8[Q'%"EG1Ū A :,4@d}"9EXْwӐ(7AU|4L8J<4TER,}Eۊ5Z" 0tӂr㿇b[k Ej5DMfj=PVT>a!hنO'A\wXb*fӳ C+Y`2B^g#QƎ/)InAZ$c {YmU6ౢq/H? 8b5`LQܢY%hjMY@qE5/2z%|K 8se;j6ӏ 0@Z"~ɹDՃ |xr"Ή'-vy3Ǻ9ntawiy}RD)5OG܎}9$pQ̒ AA;!mxMՕ; ^TqX8ES{u2Z/ko'B*i铌;luQ٫unBD҅˴ /K믝y?pIۅR[d<=+ұ 6#*Y";da*` //' Simple Pass-Through Formatter to \code{fmt::format()} //' //' The C-level interface of R does not make it easy to pass \code{...} arguments. //' This helper function assumes it has already been called with \code{format()} //' on each argument (as a wrapper can do) so it just spreads out the class to //' \code{fmt::format{}} which, being C++, uses variadic templates to receive the //' arguments. The main motivation for this function to able to format string as //' use by the \sQuote{fmtlib::fmt} library included in \sQuote{spdlog} to write //' similar debug strings in both R and C++. This function permits R calls with //' multiple arguments of different types which (by being formatted on the R side) //' are handled as strings (whereas C++ logging has access to the templating logic). //' //' @param s A character variable with a format string for \sQuote{fmtlib::fmt} //' @param v A character vector with the logging string arguments. //' @return A single (formatted) string //' @seealso https://github.com/fmtlib/fmt // [[Rcpp::export]] std::string formatter(const std::string s, std::vector v) { size_t n = v.size(); switch (n) { case 0: return fmt::format(s); case 1: return fmt::format(s, std::string(v[0])); case 2: return fmt::format(s, std::string(v[0]), std::string(v[1])); case 3: return fmt::format(s, std::string(v[0]), std::string(v[1]), std::string(v[2])); case 4: return fmt::format(s, std::string(v[0]), std::string(v[1]), std::string(v[2]), std::string(v[3])); case 5: return fmt::format(s, std::string(v[0]), std::string(v[1]), std::string(v[2]), std::string(v[3]), std::string(v[4])); case 6: return fmt::format(s, std::string(v[0]), std::string(v[1]), std::string(v[2]), std::string(v[3]), std::string(v[4]), std::string(v[5])); case 7: return fmt::format(s, std::string(v[0]), std::string(v[1]), std::string(v[2]), std::string(v[3]), std::string(v[4]), std::string(v[5]), std::string(v[6])); case 8: return fmt::format(s, std::string(v[0]), std::string(v[1]), std::string(v[2]), std::string(v[3]), std::string(v[4]), std::string(v[5]), std::string(v[6]), std::string(v[7])); case 9: return fmt::format(s, std::string(v[0]), std::string(v[1]), std::string(v[2]), std::string(v[3]), std::string(v[4]), std::string(v[5]), std::string(v[6]), std::string(v[7]), std::string(v[8])); case 10: return fmt::format(s, std::string(v[0]), std::string(v[1]), std::string(v[2]), std::string(v[3]), std::string(v[4]), std::string(v[5]), std::string(v[6]), std::string(v[7]), std::string(v[8]), std::string(v[9])); case 11: return fmt::format(s, std::string(v[0]), std::string(v[1]), std::string(v[2]), std::string(v[3]), std::string(v[4]), std::string(v[5]), std::string(v[6]), std::string(v[7]), std::string(v[8]), std::string(v[9]), std::string(v[10])); case 12: return fmt::format(s, std::string(v[0]), std::string(v[1]), std::string(v[2]), std::string(v[3]), std::string(v[4]), std::string(v[5]), std::string(v[6]), std::string(v[7]), std::string(v[8]), std::string(v[9]), std::string(v[10]), std::string(v[11])); case 13: return fmt::format(s, std::string(v[0]), std::string(v[1]), std::string(v[2]), std::string(v[3]), std::string(v[4]), std::string(v[5]), std::string(v[6]), std::string(v[7]), std::string(v[8]), std::string(v[9]), std::string(v[10]), std::string(v[11]), std::string(v[12])); case 14: return fmt::format(s, std::string(v[0]), std::string(v[1]), std::string(v[2]), std::string(v[3]), std::string(v[4]), std::string(v[5]), std::string(v[6]), std::string(v[7]), std::string(v[8]), std::string(v[9]), std::string(v[10]), std::string(v[11]), std::string(v[12]), std::string(v[13])); case 15: return fmt::format(s, std::string(v[0]), std::string(v[1]), std::string(v[2]), std::string(v[3]), std::string(v[4]), std::string(v[5]), std::string(v[6]), std::string(v[7]), std::string(v[8]), std::string(v[9]), std::string(v[10]), std::string(v[11]), std::string(v[12]), std::string(v[13]), std::string(v[14])); default: { Rcpp::warning("Only up to fifteen arguments support for now."); return fmt::format(s, std::string(v[0]), std::string(v[1]), std::string(v[2]), std::string(v[3]), std::string(v[4]), std::string(v[5]), std::string(v[6]), std::string(v[7]), std::string(v[8]), std::string(v[9]), std::string(v[10]), std::string(v[11])); } } } RcppSpdlog/src/interface.cpp0000644000176200001440000001666314442072207015600 0ustar liggesusers // [[Rcpp::interfaces(r, cpp)]] // This portmanteau include also defines the r_sink we use below, and which // diverts all logging to R via the Rcpp::Rcout replacement for std::cout #include static std::shared_ptr logger_ = nullptr; // See eg https://spdlog.docsforge.com/v1.x/3.custom-formatting/#pattern-flags or // https://github.com/gabime/spdlog/wiki/3.-Custom-formatting const std::string default_log_pattern = "[%Y-%m-%d %H:%M:%S.%e] [%n] [Process: %P] [%l] %v"; //' R Accessor Functions for spdlog Logger //' //' Several R-level functions can access the \code{spdlog} logging facilties. As \code{spdlog} //' is a C++-level logging library, these are R function permit concurrent logging from both //' R and C++. //' //' Several functions are provided: //' \describe{ //' \item{\code{log_setup}}{Initializes a logger (which becomes the default logger).} //' \item{\code{log_filesetup}}{Initializes a file-based logger (which becomes the default).} //' \item{\code{log_drop}}{Removes logger (which in general should not be needed).} //' \item{\code{log_set_pattern}}{Changes the default logging message pattern.} //' \item{\code{log_set_level}}{Sets the logging level threshold.} //' \item{\code{log_trace}}{Logs a trace-level message.} //' \item{\code{log_debug}}{Logs a debug-level message.} //' \item{\code{log_info}}{Logs a info-level message.} //' \item{\code{log_warn}}{Logs a warn-level message.} //' \item{\code{log_error}}{Logs a error-level message.} //' \item{\code{log_critical}}{Logs a critical-level message.} //' } //' //' Supported logging levels are, in order of increasing threshold values, \sQuote{trace}, //' \sQuote{debug}, \sQuote{warn}, \sQuote{info}, \sQuote{warn}, \sQuote{error}, and //' \sQuote{critical}. A message issued below the current threshold is not displayed whereas //' a message at or above the current threshold is displayed. The default level is \sQuote{warn}. //' //' @seealso The logging pattern format is described in at the repo in the page //' \url{https://github.com/gabime/spdlog/wiki/3.-Custom-formatting}. //' //' @param name A character variable with the logging instance name, default value is \sQuote{default}. //' @param level A character variable with the default logging level, default value is \sQuote{warn}. //' @param s A character variable with the logging pattern, level or message. //' @param filename A character variable with the logging filename if a file-based logger is //' instantiated. //' //' @return Nothing is returned from these functions as they are invoked for their side-effects. //' //' @examples //' log_setup("demo") # at default level 'warn' //' log_info("this message is NOT seen") //' log_set_level("debug") //' log_info("this message is seen") //' log_warn("as is this message") //' // [[Rcpp::export]] void log_setup(const std::string& name = "default", const std::string& level = "warn") { // If a logger exists and has non-default name, remove it if (logger_ != nullptr && name != "default") { spdlog::drop(name); } // Get the named logger, creating it if needed logger_ = spdlog::get(name); if (logger_ == nullptr) { logger_ = spdlog::r_sink_mt(name); spdlog::set_default_logger(logger_); } // Setting default pattern and chosen (or default) level spdlog::set_pattern(default_log_pattern); spdlog::set_level(spdlog::level::from_str(level)); } //' @rdname log_setup // [[Rcpp::export]] void log_init(const std::string& level = "warn") { log_setup("r", level); } //' @rdname log_setup // [[Rcpp::export]] void log_filesetup(const std::string& filename, const std::string &name = "default", const std::string& level = "warn") { // If a logger exists and has non-default name, remove it if (logger_ != nullptr && name != "default") { spdlog::drop(name); } // Get the named logger, creating it if needed logger_ = spdlog::get(name); if (logger_ == nullptr) { logger_ = spdlog::basic_logger_mt(name, filename); spdlog::set_default_logger(logger_); } // Setting default pattern and chosen (or default) level spdlog::set_pattern(default_log_pattern); spdlog::set_level(spdlog::level::from_str(level)); } void assert_and_setup_if_needed(void) { if (logger_ == nullptr) log_setup(); } //' @rdname log_setup // [[Rcpp::export]] void log_drop(const std::string &name) { assert_and_setup_if_needed(); spdlog::drop(name); } //' @rdname log_setup // [[Rcpp::export]] void log_set_pattern(const std::string &s) { assert_and_setup_if_needed(); spdlog::set_pattern(s); } //' @rdname log_setup // [[Rcpp::export]] void log_set_level(const std::string &s) { assert_and_setup_if_needed(); spdlog::set_level(spdlog::level::from_str(s)); } //' @rdname log_setup // [[Rcpp::export]] void log_trace(const std::string &s) { assert_and_setup_if_needed(); spdlog::trace(s); } //' @rdname log_setup // [[Rcpp::export]] void log_debug(const std::string &s) { assert_and_setup_if_needed(); spdlog::debug(s); } //' @rdname log_setup // [[Rcpp::export]] void log_info(const std::string& s) { assert_and_setup_if_needed(); spdlog::info(s); } //' @rdname log_setup // [[Rcpp::export]] void log_warn(const std::string& s) { assert_and_setup_if_needed(); spdlog::warn(s); } //' @rdname log_setup // [[Rcpp::export]] void log_error(const std::string& s) { assert_and_setup_if_needed(); spdlog::error(s); } //' @rdname log_setup // [[Rcpp::export]] void log_critical(const std::string& s) { assert_and_setup_if_needed(); spdlog::critical(s); } template Rcpp::XPtr make_xptr(T* p) { return Rcpp::XPtr(p); } //' R Accessor Functions for spdlog Stopwatch //' //' A set of functions provides access to the \code{spdlog} stopwatch facilty. As \code{stopwatch} //' object is a simple container around a C++ \code{std::chrono} object which (essentially) reports //' elapsed-time since creation. The object is exported to R via an external pointer permitting use //' from both R and C++. //' //' Several functions are provided: //' \describe{ //' \item{\code{get_stopwatch}}{Returns a stopwatch object (as an S3 object).} //' \item{\code{elapsed_stopwatch}}{Returns elapsed time for stopwatch in seconds.} //' \item{\code{format_stopwatch}}{Returns elapsed time for stopwatch as character variable.} //' } //' The \code{stopwatch} object has \code{print} and \code{format} methods. //' //' @param sw An S3 object of type \code{stopwatch}. //' @param x An S3 object of type \code{stopwatch}. //' @param ... Dotted argument required by generic, unused here. //' //' @return The desired object is returned: respectively, a stopwatch object as an external pointer //' in an S3 class, the elapsed time in seconds as a double, or formatted as a character variable. //' //' @examples //' w <- get_stopwatch() //' Sys.sleep(0.2) //' elapsed_stopwatch(w) //' format_stopwatch(w) //' @rdname get_stopwatch // [[Rcpp::export]] Rcpp::XPtr get_stopwatch() { auto sw = make_xptr(new spdlog::stopwatch()); sw.attr("class") = Rcpp::CharacterVector::create("stopwatch", "externalptr"); return sw; } //' @rdname get_stopwatch // [[Rcpp::export]] double elapsed_stopwatch(Rcpp::XPtr sw) { return sw->elapsed().count(); } //' @rdname get_stopwatch // [[Rcpp::export]] std::string format_stopwatch(Rcpp::XPtr sw) { return std::to_string(elapsed_stopwatch(sw)); } RcppSpdlog/src/exampleRsink.cpp0000644000176200001440000000427214361641471016300 0ustar liggesusers // this portmanteau include also defines the r_sink we use below, and which // diverts all logging to R via the Rcpp::Rcout replacement for std::cout #include #include // also support stopwatch feature //' spdlog Example using a sink for R //' //' A simple example invoking a derived R/Rcpp logger. Also demonstrates the //' stopwatch feature. For more features see the 'spdlog' documnetation. //' //' Note that this no longer triggers R warnings thanks to excellent help by //' Gabi Melman. //' @return None //' @examples //' exampleRsink() // [[Rcpp::export]] void exampleRsink() { std::string logname = "fromR"; // fix a name for this logger auto sp = spdlog::get(logname); // retrieve existing one if (sp == nullptr) sp = spdlog::r_sink_mt(logname); // or create new one if needed spdlog::set_default_logger(sp); // and set as default spdlog::stopwatch sw; // instantiate a stop watch // change log pattern (changed from [%H:%M:%S %z] [%n] [%^---%L---%$] ) spdlog::set_pattern("[%H:%M:%S.%f] [%n] [%^%L%$] [thread %t] %v"); spdlog::info("Welcome to spdlog!"); spdlog::error("Some error message with arg: {}", 1); spdlog::info("Elapsed time: {}", sw); spdlog::warn("Easy padding in numbers like {:08d}", 12); spdlog::critical("Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}", 42); spdlog::info("Support for floats {:03.2f}", 1.23456); spdlog::info("Positional args are {1} {0}..", "too", "supported"); spdlog::info("{:<30}", "left aligned"); spdlog::info("Elapsed time: {}", sw); } //' spdlog Logging Lever Setter //' //' A helper function to turn a logging level given as string //' into the current logging level //' //' @param name A string with the logging level. Value understood are, //' in decreasing verbosity \sQuote{trace}, \sQuote{debug}, \sQuote{info}, //' \sQuote{warning}, \sQuote{error}, \sQuote{critical}, and \sQuote{off}. //' Unrecognised names are equivalent to \sQuote{off}. //' @return Nothing is returned. // [[Rcpp::export]] void setLogLevel(const std::string &name) { spdlog::set_level(spdlog::level::from_str(name)); } RcppSpdlog/src/Makevars0000644000176200001440000000010114405612700014601 0ustar liggesusers ## We need the spdlog headers PKG_CPPFLAGS = -I../inst/include/ RcppSpdlog/src/RcppExports.cpp0000644000176200001440000005762214531532127016132 0ustar liggesusers// Generated by using Rcpp::compileAttributes() -> do not edit by hand // Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 #include "../inst/include/RcppSpdlog.h" #include "../inst/include/RcppSpdlog_types.h" #include #include #include using namespace Rcpp; #ifdef RCPP_USE_GLOBAL_ROSTREAM Rcpp::Rostream& Rcpp::Rcout = Rcpp::Rcpp_cout_get(); Rcpp::Rostream& Rcpp::Rcerr = Rcpp::Rcpp_cerr_get(); #endif // exampleRsink void exampleRsink(); RcppExport SEXP _RcppSpdlog_exampleRsink() { BEGIN_RCPP Rcpp::RNGScope rcpp_rngScope_gen; exampleRsink(); return R_NilValue; END_RCPP } // setLogLevel void setLogLevel(const std::string& name); RcppExport SEXP _RcppSpdlog_setLogLevel(SEXP nameSEXP) { BEGIN_RCPP Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const std::string& >::type name(nameSEXP); setLogLevel(name); return R_NilValue; END_RCPP } // formatter std::string formatter(const std::string s, std::vector v); static SEXP _RcppSpdlog_formatter_try(SEXP sSEXP, SEXP vSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::traits::input_parameter< const std::string >::type s(sSEXP); Rcpp::traits::input_parameter< std::vector >::type v(vSEXP); rcpp_result_gen = Rcpp::wrap(formatter(s, v)); return rcpp_result_gen; END_RCPP_RETURN_ERROR } RcppExport SEXP _RcppSpdlog_formatter(SEXP sSEXP, SEXP vSEXP) { SEXP rcpp_result_gen; { Rcpp::RNGScope rcpp_rngScope_gen; rcpp_result_gen = PROTECT(_RcppSpdlog_formatter_try(sSEXP, vSEXP)); } Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error"); if (rcpp_isInterrupt_gen) { UNPROTECT(1); Rf_onintr(); } bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen); if (rcpp_isLongjump_gen) { Rcpp::internal::resumeJump(rcpp_result_gen); } Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error"); if (rcpp_isError_gen) { SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen); UNPROTECT(1); Rf_error("%s", CHAR(rcpp_msgSEXP_gen)); } UNPROTECT(1); return rcpp_result_gen; } // log_setup void log_setup(const std::string& name, const std::string& level); static SEXP _RcppSpdlog_log_setup_try(SEXP nameSEXP, SEXP levelSEXP) { BEGIN_RCPP Rcpp::traits::input_parameter< const std::string& >::type name(nameSEXP); Rcpp::traits::input_parameter< const std::string& >::type level(levelSEXP); log_setup(name, level); return R_NilValue; END_RCPP_RETURN_ERROR } RcppExport SEXP _RcppSpdlog_log_setup(SEXP nameSEXP, SEXP levelSEXP) { SEXP rcpp_result_gen; { Rcpp::RNGScope rcpp_rngScope_gen; rcpp_result_gen = PROTECT(_RcppSpdlog_log_setup_try(nameSEXP, levelSEXP)); } Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error"); if (rcpp_isInterrupt_gen) { UNPROTECT(1); Rf_onintr(); } bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen); if (rcpp_isLongjump_gen) { Rcpp::internal::resumeJump(rcpp_result_gen); } Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error"); if (rcpp_isError_gen) { SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen); UNPROTECT(1); Rf_error("%s", CHAR(rcpp_msgSEXP_gen)); } UNPROTECT(1); return rcpp_result_gen; } // log_init void log_init(const std::string& level); static SEXP _RcppSpdlog_log_init_try(SEXP levelSEXP) { BEGIN_RCPP Rcpp::traits::input_parameter< const std::string& >::type level(levelSEXP); log_init(level); return R_NilValue; END_RCPP_RETURN_ERROR } RcppExport SEXP _RcppSpdlog_log_init(SEXP levelSEXP) { SEXP rcpp_result_gen; { Rcpp::RNGScope rcpp_rngScope_gen; rcpp_result_gen = PROTECT(_RcppSpdlog_log_init_try(levelSEXP)); } Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error"); if (rcpp_isInterrupt_gen) { UNPROTECT(1); Rf_onintr(); } bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen); if (rcpp_isLongjump_gen) { Rcpp::internal::resumeJump(rcpp_result_gen); } Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error"); if (rcpp_isError_gen) { SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen); UNPROTECT(1); Rf_error("%s", CHAR(rcpp_msgSEXP_gen)); } UNPROTECT(1); return rcpp_result_gen; } // log_filesetup void log_filesetup(const std::string& filename, const std::string& name, const std::string& level); static SEXP _RcppSpdlog_log_filesetup_try(SEXP filenameSEXP, SEXP nameSEXP, SEXP levelSEXP) { BEGIN_RCPP Rcpp::traits::input_parameter< const std::string& >::type filename(filenameSEXP); Rcpp::traits::input_parameter< const std::string& >::type name(nameSEXP); Rcpp::traits::input_parameter< const std::string& >::type level(levelSEXP); log_filesetup(filename, name, level); return R_NilValue; END_RCPP_RETURN_ERROR } RcppExport SEXP _RcppSpdlog_log_filesetup(SEXP filenameSEXP, SEXP nameSEXP, SEXP levelSEXP) { SEXP rcpp_result_gen; { Rcpp::RNGScope rcpp_rngScope_gen; rcpp_result_gen = PROTECT(_RcppSpdlog_log_filesetup_try(filenameSEXP, nameSEXP, levelSEXP)); } Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error"); if (rcpp_isInterrupt_gen) { UNPROTECT(1); Rf_onintr(); } bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen); if (rcpp_isLongjump_gen) { Rcpp::internal::resumeJump(rcpp_result_gen); } Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error"); if (rcpp_isError_gen) { SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen); UNPROTECT(1); Rf_error("%s", CHAR(rcpp_msgSEXP_gen)); } UNPROTECT(1); return rcpp_result_gen; } // log_drop void log_drop(const std::string& name); static SEXP _RcppSpdlog_log_drop_try(SEXP nameSEXP) { BEGIN_RCPP Rcpp::traits::input_parameter< const std::string& >::type name(nameSEXP); log_drop(name); return R_NilValue; END_RCPP_RETURN_ERROR } RcppExport SEXP _RcppSpdlog_log_drop(SEXP nameSEXP) { SEXP rcpp_result_gen; { Rcpp::RNGScope rcpp_rngScope_gen; rcpp_result_gen = PROTECT(_RcppSpdlog_log_drop_try(nameSEXP)); } Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error"); if (rcpp_isInterrupt_gen) { UNPROTECT(1); Rf_onintr(); } bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen); if (rcpp_isLongjump_gen) { Rcpp::internal::resumeJump(rcpp_result_gen); } Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error"); if (rcpp_isError_gen) { SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen); UNPROTECT(1); Rf_error("%s", CHAR(rcpp_msgSEXP_gen)); } UNPROTECT(1); return rcpp_result_gen; } // log_set_pattern void log_set_pattern(const std::string& s); static SEXP _RcppSpdlog_log_set_pattern_try(SEXP sSEXP) { BEGIN_RCPP Rcpp::traits::input_parameter< const std::string& >::type s(sSEXP); log_set_pattern(s); return R_NilValue; END_RCPP_RETURN_ERROR } RcppExport SEXP _RcppSpdlog_log_set_pattern(SEXP sSEXP) { SEXP rcpp_result_gen; { Rcpp::RNGScope rcpp_rngScope_gen; rcpp_result_gen = PROTECT(_RcppSpdlog_log_set_pattern_try(sSEXP)); } Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error"); if (rcpp_isInterrupt_gen) { UNPROTECT(1); Rf_onintr(); } bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen); if (rcpp_isLongjump_gen) { Rcpp::internal::resumeJump(rcpp_result_gen); } Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error"); if (rcpp_isError_gen) { SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen); UNPROTECT(1); Rf_error("%s", CHAR(rcpp_msgSEXP_gen)); } UNPROTECT(1); return rcpp_result_gen; } // log_set_level void log_set_level(const std::string& s); static SEXP _RcppSpdlog_log_set_level_try(SEXP sSEXP) { BEGIN_RCPP Rcpp::traits::input_parameter< const std::string& >::type s(sSEXP); log_set_level(s); return R_NilValue; END_RCPP_RETURN_ERROR } RcppExport SEXP _RcppSpdlog_log_set_level(SEXP sSEXP) { SEXP rcpp_result_gen; { Rcpp::RNGScope rcpp_rngScope_gen; rcpp_result_gen = PROTECT(_RcppSpdlog_log_set_level_try(sSEXP)); } Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error"); if (rcpp_isInterrupt_gen) { UNPROTECT(1); Rf_onintr(); } bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen); if (rcpp_isLongjump_gen) { Rcpp::internal::resumeJump(rcpp_result_gen); } Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error"); if (rcpp_isError_gen) { SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen); UNPROTECT(1); Rf_error("%s", CHAR(rcpp_msgSEXP_gen)); } UNPROTECT(1); return rcpp_result_gen; } // log_trace void log_trace(const std::string& s); static SEXP _RcppSpdlog_log_trace_try(SEXP sSEXP) { BEGIN_RCPP Rcpp::traits::input_parameter< const std::string& >::type s(sSEXP); log_trace(s); return R_NilValue; END_RCPP_RETURN_ERROR } RcppExport SEXP _RcppSpdlog_log_trace(SEXP sSEXP) { SEXP rcpp_result_gen; { Rcpp::RNGScope rcpp_rngScope_gen; rcpp_result_gen = PROTECT(_RcppSpdlog_log_trace_try(sSEXP)); } Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error"); if (rcpp_isInterrupt_gen) { UNPROTECT(1); Rf_onintr(); } bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen); if (rcpp_isLongjump_gen) { Rcpp::internal::resumeJump(rcpp_result_gen); } Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error"); if (rcpp_isError_gen) { SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen); UNPROTECT(1); Rf_error("%s", CHAR(rcpp_msgSEXP_gen)); } UNPROTECT(1); return rcpp_result_gen; } // log_debug void log_debug(const std::string& s); static SEXP _RcppSpdlog_log_debug_try(SEXP sSEXP) { BEGIN_RCPP Rcpp::traits::input_parameter< const std::string& >::type s(sSEXP); log_debug(s); return R_NilValue; END_RCPP_RETURN_ERROR } RcppExport SEXP _RcppSpdlog_log_debug(SEXP sSEXP) { SEXP rcpp_result_gen; { Rcpp::RNGScope rcpp_rngScope_gen; rcpp_result_gen = PROTECT(_RcppSpdlog_log_debug_try(sSEXP)); } Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error"); if (rcpp_isInterrupt_gen) { UNPROTECT(1); Rf_onintr(); } bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen); if (rcpp_isLongjump_gen) { Rcpp::internal::resumeJump(rcpp_result_gen); } Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error"); if (rcpp_isError_gen) { SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen); UNPROTECT(1); Rf_error("%s", CHAR(rcpp_msgSEXP_gen)); } UNPROTECT(1); return rcpp_result_gen; } // log_info void log_info(const std::string& s); static SEXP _RcppSpdlog_log_info_try(SEXP sSEXP) { BEGIN_RCPP Rcpp::traits::input_parameter< const std::string& >::type s(sSEXP); log_info(s); return R_NilValue; END_RCPP_RETURN_ERROR } RcppExport SEXP _RcppSpdlog_log_info(SEXP sSEXP) { SEXP rcpp_result_gen; { Rcpp::RNGScope rcpp_rngScope_gen; rcpp_result_gen = PROTECT(_RcppSpdlog_log_info_try(sSEXP)); } Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error"); if (rcpp_isInterrupt_gen) { UNPROTECT(1); Rf_onintr(); } bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen); if (rcpp_isLongjump_gen) { Rcpp::internal::resumeJump(rcpp_result_gen); } Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error"); if (rcpp_isError_gen) { SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen); UNPROTECT(1); Rf_error("%s", CHAR(rcpp_msgSEXP_gen)); } UNPROTECT(1); return rcpp_result_gen; } // log_warn void log_warn(const std::string& s); static SEXP _RcppSpdlog_log_warn_try(SEXP sSEXP) { BEGIN_RCPP Rcpp::traits::input_parameter< const std::string& >::type s(sSEXP); log_warn(s); return R_NilValue; END_RCPP_RETURN_ERROR } RcppExport SEXP _RcppSpdlog_log_warn(SEXP sSEXP) { SEXP rcpp_result_gen; { Rcpp::RNGScope rcpp_rngScope_gen; rcpp_result_gen = PROTECT(_RcppSpdlog_log_warn_try(sSEXP)); } Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error"); if (rcpp_isInterrupt_gen) { UNPROTECT(1); Rf_onintr(); } bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen); if (rcpp_isLongjump_gen) { Rcpp::internal::resumeJump(rcpp_result_gen); } Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error"); if (rcpp_isError_gen) { SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen); UNPROTECT(1); Rf_error("%s", CHAR(rcpp_msgSEXP_gen)); } UNPROTECT(1); return rcpp_result_gen; } // log_error void log_error(const std::string& s); static SEXP _RcppSpdlog_log_error_try(SEXP sSEXP) { BEGIN_RCPP Rcpp::traits::input_parameter< const std::string& >::type s(sSEXP); log_error(s); return R_NilValue; END_RCPP_RETURN_ERROR } RcppExport SEXP _RcppSpdlog_log_error(SEXP sSEXP) { SEXP rcpp_result_gen; { Rcpp::RNGScope rcpp_rngScope_gen; rcpp_result_gen = PROTECT(_RcppSpdlog_log_error_try(sSEXP)); } Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error"); if (rcpp_isInterrupt_gen) { UNPROTECT(1); Rf_onintr(); } bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen); if (rcpp_isLongjump_gen) { Rcpp::internal::resumeJump(rcpp_result_gen); } Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error"); if (rcpp_isError_gen) { SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen); UNPROTECT(1); Rf_error("%s", CHAR(rcpp_msgSEXP_gen)); } UNPROTECT(1); return rcpp_result_gen; } // log_critical void log_critical(const std::string& s); static SEXP _RcppSpdlog_log_critical_try(SEXP sSEXP) { BEGIN_RCPP Rcpp::traits::input_parameter< const std::string& >::type s(sSEXP); log_critical(s); return R_NilValue; END_RCPP_RETURN_ERROR } RcppExport SEXP _RcppSpdlog_log_critical(SEXP sSEXP) { SEXP rcpp_result_gen; { Rcpp::RNGScope rcpp_rngScope_gen; rcpp_result_gen = PROTECT(_RcppSpdlog_log_critical_try(sSEXP)); } Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error"); if (rcpp_isInterrupt_gen) { UNPROTECT(1); Rf_onintr(); } bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen); if (rcpp_isLongjump_gen) { Rcpp::internal::resumeJump(rcpp_result_gen); } Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error"); if (rcpp_isError_gen) { SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen); UNPROTECT(1); Rf_error("%s", CHAR(rcpp_msgSEXP_gen)); } UNPROTECT(1); return rcpp_result_gen; } // get_stopwatch Rcpp::XPtr get_stopwatch(); static SEXP _RcppSpdlog_get_stopwatch_try() { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; rcpp_result_gen = Rcpp::wrap(get_stopwatch()); return rcpp_result_gen; END_RCPP_RETURN_ERROR } RcppExport SEXP _RcppSpdlog_get_stopwatch() { SEXP rcpp_result_gen; { Rcpp::RNGScope rcpp_rngScope_gen; rcpp_result_gen = PROTECT(_RcppSpdlog_get_stopwatch_try()); } Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error"); if (rcpp_isInterrupt_gen) { UNPROTECT(1); Rf_onintr(); } bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen); if (rcpp_isLongjump_gen) { Rcpp::internal::resumeJump(rcpp_result_gen); } Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error"); if (rcpp_isError_gen) { SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen); UNPROTECT(1); Rf_error("%s", CHAR(rcpp_msgSEXP_gen)); } UNPROTECT(1); return rcpp_result_gen; } // elapsed_stopwatch double elapsed_stopwatch(Rcpp::XPtr sw); static SEXP _RcppSpdlog_elapsed_stopwatch_try(SEXP swSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::traits::input_parameter< Rcpp::XPtr >::type sw(swSEXP); rcpp_result_gen = Rcpp::wrap(elapsed_stopwatch(sw)); return rcpp_result_gen; END_RCPP_RETURN_ERROR } RcppExport SEXP _RcppSpdlog_elapsed_stopwatch(SEXP swSEXP) { SEXP rcpp_result_gen; { Rcpp::RNGScope rcpp_rngScope_gen; rcpp_result_gen = PROTECT(_RcppSpdlog_elapsed_stopwatch_try(swSEXP)); } Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error"); if (rcpp_isInterrupt_gen) { UNPROTECT(1); Rf_onintr(); } bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen); if (rcpp_isLongjump_gen) { Rcpp::internal::resumeJump(rcpp_result_gen); } Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error"); if (rcpp_isError_gen) { SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen); UNPROTECT(1); Rf_error("%s", CHAR(rcpp_msgSEXP_gen)); } UNPROTECT(1); return rcpp_result_gen; } // format_stopwatch std::string format_stopwatch(Rcpp::XPtr sw); static SEXP _RcppSpdlog_format_stopwatch_try(SEXP swSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::traits::input_parameter< Rcpp::XPtr >::type sw(swSEXP); rcpp_result_gen = Rcpp::wrap(format_stopwatch(sw)); return rcpp_result_gen; END_RCPP_RETURN_ERROR } RcppExport SEXP _RcppSpdlog_format_stopwatch(SEXP swSEXP) { SEXP rcpp_result_gen; { Rcpp::RNGScope rcpp_rngScope_gen; rcpp_result_gen = PROTECT(_RcppSpdlog_format_stopwatch_try(swSEXP)); } Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error"); if (rcpp_isInterrupt_gen) { UNPROTECT(1); Rf_onintr(); } bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen); if (rcpp_isLongjump_gen) { Rcpp::internal::resumeJump(rcpp_result_gen); } Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error"); if (rcpp_isError_gen) { SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen); UNPROTECT(1); Rf_error("%s", CHAR(rcpp_msgSEXP_gen)); } UNPROTECT(1); return rcpp_result_gen; } // validate (ensure exported C++ functions exist before calling them) static int _RcppSpdlog_RcppExport_validate(const char* sig) { static std::set signatures; if (signatures.empty()) { signatures.insert("std::string(*formatter)(const std::string,std::vector)"); signatures.insert("void(*log_setup)(const std::string&,const std::string&)"); signatures.insert("void(*log_init)(const std::string&)"); signatures.insert("void(*log_filesetup)(const std::string&,const std::string&,const std::string&)"); signatures.insert("void(*log_drop)(const std::string&)"); signatures.insert("void(*log_set_pattern)(const std::string&)"); signatures.insert("void(*log_set_level)(const std::string&)"); signatures.insert("void(*log_trace)(const std::string&)"); signatures.insert("void(*log_debug)(const std::string&)"); signatures.insert("void(*log_info)(const std::string&)"); signatures.insert("void(*log_warn)(const std::string&)"); signatures.insert("void(*log_error)(const std::string&)"); signatures.insert("void(*log_critical)(const std::string&)"); signatures.insert("Rcpp::XPtr(*get_stopwatch)()"); signatures.insert("double(*elapsed_stopwatch)(Rcpp::XPtr)"); signatures.insert("std::string(*format_stopwatch)(Rcpp::XPtr)"); } return signatures.find(sig) != signatures.end(); } // registerCCallable (register entry points for exported C++ functions) RcppExport SEXP _RcppSpdlog_RcppExport_registerCCallable() { R_RegisterCCallable("RcppSpdlog", "_RcppSpdlog_formatter", (DL_FUNC)_RcppSpdlog_formatter_try); R_RegisterCCallable("RcppSpdlog", "_RcppSpdlog_log_setup", (DL_FUNC)_RcppSpdlog_log_setup_try); R_RegisterCCallable("RcppSpdlog", "_RcppSpdlog_log_init", (DL_FUNC)_RcppSpdlog_log_init_try); R_RegisterCCallable("RcppSpdlog", "_RcppSpdlog_log_filesetup", (DL_FUNC)_RcppSpdlog_log_filesetup_try); R_RegisterCCallable("RcppSpdlog", "_RcppSpdlog_log_drop", (DL_FUNC)_RcppSpdlog_log_drop_try); R_RegisterCCallable("RcppSpdlog", "_RcppSpdlog_log_set_pattern", (DL_FUNC)_RcppSpdlog_log_set_pattern_try); R_RegisterCCallable("RcppSpdlog", "_RcppSpdlog_log_set_level", (DL_FUNC)_RcppSpdlog_log_set_level_try); R_RegisterCCallable("RcppSpdlog", "_RcppSpdlog_log_trace", (DL_FUNC)_RcppSpdlog_log_trace_try); R_RegisterCCallable("RcppSpdlog", "_RcppSpdlog_log_debug", (DL_FUNC)_RcppSpdlog_log_debug_try); R_RegisterCCallable("RcppSpdlog", "_RcppSpdlog_log_info", (DL_FUNC)_RcppSpdlog_log_info_try); R_RegisterCCallable("RcppSpdlog", "_RcppSpdlog_log_warn", (DL_FUNC)_RcppSpdlog_log_warn_try); R_RegisterCCallable("RcppSpdlog", "_RcppSpdlog_log_error", (DL_FUNC)_RcppSpdlog_log_error_try); R_RegisterCCallable("RcppSpdlog", "_RcppSpdlog_log_critical", (DL_FUNC)_RcppSpdlog_log_critical_try); R_RegisterCCallable("RcppSpdlog", "_RcppSpdlog_get_stopwatch", (DL_FUNC)_RcppSpdlog_get_stopwatch_try); R_RegisterCCallable("RcppSpdlog", "_RcppSpdlog_elapsed_stopwatch", (DL_FUNC)_RcppSpdlog_elapsed_stopwatch_try); R_RegisterCCallable("RcppSpdlog", "_RcppSpdlog_format_stopwatch", (DL_FUNC)_RcppSpdlog_format_stopwatch_try); R_RegisterCCallable("RcppSpdlog", "_RcppSpdlog_RcppExport_validate", (DL_FUNC)_RcppSpdlog_RcppExport_validate); return R_NilValue; } static const R_CallMethodDef CallEntries[] = { {"_RcppSpdlog_exampleRsink", (DL_FUNC) &_RcppSpdlog_exampleRsink, 0}, {"_RcppSpdlog_setLogLevel", (DL_FUNC) &_RcppSpdlog_setLogLevel, 1}, {"_RcppSpdlog_formatter", (DL_FUNC) &_RcppSpdlog_formatter, 2}, {"_RcppSpdlog_log_setup", (DL_FUNC) &_RcppSpdlog_log_setup, 2}, {"_RcppSpdlog_log_init", (DL_FUNC) &_RcppSpdlog_log_init, 1}, {"_RcppSpdlog_log_filesetup", (DL_FUNC) &_RcppSpdlog_log_filesetup, 3}, {"_RcppSpdlog_log_drop", (DL_FUNC) &_RcppSpdlog_log_drop, 1}, {"_RcppSpdlog_log_set_pattern", (DL_FUNC) &_RcppSpdlog_log_set_pattern, 1}, {"_RcppSpdlog_log_set_level", (DL_FUNC) &_RcppSpdlog_log_set_level, 1}, {"_RcppSpdlog_log_trace", (DL_FUNC) &_RcppSpdlog_log_trace, 1}, {"_RcppSpdlog_log_debug", (DL_FUNC) &_RcppSpdlog_log_debug, 1}, {"_RcppSpdlog_log_info", (DL_FUNC) &_RcppSpdlog_log_info, 1}, {"_RcppSpdlog_log_warn", (DL_FUNC) &_RcppSpdlog_log_warn, 1}, {"_RcppSpdlog_log_error", (DL_FUNC) &_RcppSpdlog_log_error, 1}, {"_RcppSpdlog_log_critical", (DL_FUNC) &_RcppSpdlog_log_critical, 1}, {"_RcppSpdlog_get_stopwatch", (DL_FUNC) &_RcppSpdlog_get_stopwatch, 0}, {"_RcppSpdlog_elapsed_stopwatch", (DL_FUNC) &_RcppSpdlog_elapsed_stopwatch, 1}, {"_RcppSpdlog_format_stopwatch", (DL_FUNC) &_RcppSpdlog_format_stopwatch, 1}, {"_RcppSpdlog_RcppExport_registerCCallable", (DL_FUNC) &_RcppSpdlog_RcppExport_registerCCallable, 0}, {NULL, NULL, 0} }; RcppExport void R_init_RcppSpdlog(DllInfo *dll) { R_registerRoutines(dll, NULL, CallEntries, NULL, NULL); R_useDynamicSymbols(dll, FALSE); } RcppSpdlog/vignettes/0000755000176200001440000000000014612606453014346 5ustar liggesusersRcppSpdlog/vignettes/introduction.md0000644000176200001440000007372514356333446017433 0ustar liggesusers --- title: "Introduction to RcppSpdlog" author: "Dirk Eddelbuettel" date: "Initial version dated October 2020. Expanded November 2022." css: "water.css" --- ## Introducing RcppSpdlog [spdlog](https://github.com/gabime/spdlog) is a widely-used and very capable header-only C++ library for logging. The [RcppSpdlog](https://github.com/eddelbuettel/rcppspdlog) package provides R users with easy-to-use customized access to the [spdlog](https://github.com/gabime/spdlog) logging library by including its headers in an R package which permit other R packages to deploy it via a simple `LinkingTo: RcppSpdlog` as described in [Section 1.1.3 of WRE](https://cran.r-project.org/doc/manuals/r-release/R-exts.html#Package-Dependencies). [spdlog](https://github.com/gabime/spdlog) is mature and widely deployed. It also has a very rich set of features described at [the repository wiki](https://github.com/gabime/spdlog/wiki). This vignette will highlight a few first use cases. Note that in order to use [RcppSpdlog](https://github.com/eddelbuettel/rcppspdlog) in an R package that might get distributed to [CRAN](https://cran.r-project.org), the code should follow the example R and C++ code in function `exampleRsink()` as described below. We will however start with some simpler examples. _Do not copy those into your R package._ The package checks used by R test for use of `stdout` and `stderr` which is why the customized setup described later is preferable. ## Initial example: Basics This example follows the simplest and initial example in the [spdlog](https://github.com/gabime/spdlog). It is also included in the [RcppSpdlog](https://github.com/eddelbuettel/rcppspdlog) package as [examples/exampleOne.cpp](https://github.com/eddelbuettel/rcppspdlog/blob/master/inst/examples/exampleOne.cpp). As discussed above, do not use this example as a starting point in an R package. ```c++ // based on the 'basic usage' example in the README.md at https://github.com/gabime/spdlog #include "spdlog/spdlog.h" #include // [[Rcpp::depends(RcppSpdlog)]] // [[Rcpp::export]] void exampleOne() { // change log pattern (changed from [%H:%M:%S %z] [%n] [%^---%L---%$] ) spdlog::set_pattern("[%H:%M:%S.%f] [%L] [thread %t] %v"); spdlog::info("Welcome to spdlog!"); spdlog::error("Some error message with arg: {}", 1); spdlog::warn("Easy padding in numbers like {:08d}", 12); spdlog::critical("Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}", 42); spdlog::info("Support for floats {:03.2f}", 1.23456); spdlog::info("Positional args are {1} {0}..", "too", "supported"); spdlog::info("{:<30}", "left aligned"); spdlog::set_level(spdlog::level::debug); // Set global log level to debug spdlog::debug("This message should be displayed.."); // Compile time log levels // define SPDLOG_ACTIVE_LEVEL to desired level SPDLOG_TRACE("Some trace message with param {}", {}); SPDLOG_DEBUG("Some debug message"); } /*** R exampleOne() */ ``` When built, which is easiest via `Rcpp::sourceCpp()`, the final block ensures that the created function `exampleOne()` is executed. In one previous run, the following output was produded: ```sh R> exampleOne() [14:25:03.362024] [I] [thread 2453030] Welcome to spdlog! [14:25:03.362047] [E] [thread 2453030] Some error message with arg: 1 [14:25:03.362051] [W] [thread 2453030] Easy padding in numbers like 00000012 [14:25:03.362053] [C] [thread 2453030] Support for int: 42; hex: 2a; oct: 52; bin: 101010 [14:25:03.362056] [I] [thread 2453030] Support for floats 1.23 [14:25:03.362058] [I] [thread 2453030] Positional args are supported too.. [14:25:03.362060] [I] [thread 2453030] left aligned [14:25:03.362061] [D] [thread 2453030] This message should be displayed.. R> ``` We note the easy-to-formatting in the source which benefits from the embedded [fmt](https://github.com/fmtlib/fmt) package for easy-to-use variable expansion. We also notice the different logging "levels" indicated by single letters: _info_, _errror_, _warning_, _critical_ and _debug_. More on this below. ## Second example: Showcase This second example follows a more complete example in the [spdlog](https://github.com/gabime/spdlog) documention and highlights numerous features of the library. As before, this example is also included in the [RcppSpdlog](https://github.com/eddelbuettel/rcppspdlog) package as [examples/exampleTwo.cpp](https://github.com/eddelbuettel/rcppspdlog/blob/master/inst/examples/exampleTwo.cpp). And as before, do not use this example as a starting point in an R package. ```c++ #include "spdlog/spdlog.h" #include void stdout_logger_example(); void basic_example(); void rotating_example(); void daily_example(); void async_example(); void binary_example(); void trace_example(); void multi_sink_example(); void user_defined_example(); void err_handler_example(); void syslog_example(); void clone_example(); #include "spdlog/spdlog.h" // [[Rcpp::depends(RcppSpdlog)]] // [[Rcpp::export]] void exampleTwo() { spdlog::info("Welcome to spdlog version {}.{}.{} !", SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR, SPDLOG_VER_PATCH); spdlog::warn("Easy padding in numbers like {:08d}", 12); spdlog::critical("Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}", 42); spdlog::info("Support for floats {:03.2f}", 1.23456); spdlog::info("Positional args are {1} {0}..", "too", "supported"); spdlog::info("{:>8} aligned, {:<8} aligned", "right", "left"); // Runtime log levels spdlog::set_level(spdlog::level::info); // Set global log level to info spdlog::debug("This message should not be displayed!"); spdlog::set_level(spdlog::level::trace); // Set specific logger's log level spdlog::debug("This message should be displayed.."); // Customize msg format for all loggers spdlog::set_pattern("[%H:%M:%S %z] [%^%L%$] [thread %t] %v"); spdlog::info("This an info message with custom format"); spdlog::set_pattern("%+"); // back to default format try { stdout_logger_example(); basic_example(); rotating_example(); daily_example(); clone_example(); async_example(); binary_example(); multi_sink_example(); user_defined_example(); err_handler_example(); trace_example(); // Flush all *registered* loggers using a worker thread every 3 seconds. // note: registered loggers *must* be thread safe for this to work correctly! spdlog::flush_every(std::chrono::seconds(3)); // Apply some function on all registered loggers spdlog::apply_all([&](std::shared_ptr l) { l->info("End of example."); }); // Release all spdlog resources, and drop all loggers in the registry. // This is optional (only mandatory if using windows + async log). //spdlog::shutdown(); } // Exceptions will only be thrown upon failed logger or sink construction (not during logging). catch (const spdlog::spdlog_ex &ex) { std::printf("Log initialization failed: %s\n", ex.what()); return; } // added to this example file allow multiple runs of function spdlog::drop("console"); spdlog::drop("file_logger"); spdlog::drop("some_logger_name"); spdlog::drop("daily_logger"); spdlog::drop("async_file_logger"); } #include "spdlog/sinks/stdout_color_sinks.h" // or #include "spdlog/sinks/stdout_sinks.h" if no colors needed. void stdout_logger_example() { // Create color multi threaded logger. auto console = spdlog::stdout_color_mt("console"); // or for stderr: // auto console = spdlog::stderr_color_mt("error-logger"); } #include "spdlog/sinks/basic_file_sink.h" void basic_example() { // Create basic file logger (not rotated). auto my_logger = spdlog::basic_logger_mt("file_logger", "logs/basic-log.txt"); } #include "spdlog/sinks/rotating_file_sink.h" void rotating_example() { // Create a file rotating logger with 5mb size max and 3 rotated files. auto rotating_logger = spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3); } #include "spdlog/sinks/daily_file_sink.h" void daily_example() { // Create a daily logger - a new file is created every day on 2:30am. auto daily_logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30); } // Clone a logger and give it new name. // Useful for creating component/subsystem loggers from some "root" logger. void clone_example() { auto network_logger = spdlog::default_logger()->clone("network"); network_logger->info("Logging network stuff.."); } #include "spdlog/async.h" void async_example() { // Default thread pool settings can be modified *before* creating the async logger: // spdlog::init_thread_pool(32768, 1); // queue with max 32k items 1 backing thread. auto async_file = spdlog::basic_logger_mt("async_file_logger", "logs/async_log.txt"); // alternatively: // auto async_file = // spdlog::create_async("async_file_logger", // "logs/async_log.txt"); for (int i = 1; i < 101; ++i) { async_file->info("Async message #{}", i); } } // Log binary data as hex. // Many types of std::container types can be used. // Iterator ranges are supported too. // Format flags: // {:X} - print in uppercase. // {:s} - don't separate each byte with space. // {:p} - don't print the position on each line start. // {:n} - don't split the output to lines. #include "spdlog/fmt/bin_to_hex.h" void binary_example() { std::vector buf; for (int i = 0; i < 80; i++) { buf.push_back(static_cast(i & 0xff)); } spdlog::info("Binary example: {}", spdlog::to_hex(buf)); spdlog::info("Another binary example:{:n}", spdlog::to_hex(std::begin(buf), std::begin(buf) + 10)); // more examples: // logger->info("uppercase: {:X}", spdlog::to_hex(buf)); // logger->info("uppercase, no delimiters: {:Xs}", spdlog::to_hex(buf)); // logger->info("uppercase, no delimiters, no position info: {:Xsp}", spdlog::to_hex(buf)); } // Compile time log levels. // define SPDLOG_ACTIVE_LEVEL to required level (e.g. SPDLOG_LEVEL_TRACE) void trace_example() { // trace from default logger SPDLOG_TRACE("Some trace message.. {} ,{}", 1, 3.23); // debug from default logger SPDLOG_DEBUG("Some debug message.. {} ,{}", 1, 3.23); // trace from logger object auto logger = spdlog::get("file_logger"); SPDLOG_LOGGER_TRACE(logger, "another trace message"); } // A logger with multiple sinks (stdout and file) - each with a different format and log level. void multi_sink_example() { auto console_sink = std::make_shared(); console_sink->set_level(spdlog::level::warn); console_sink->set_pattern("[multi_sink_example] [%^%l%$] %v"); auto file_sink = std::make_shared("logs/multisink.txt", true); file_sink->set_level(spdlog::level::trace); spdlog::logger logger("multi_sink", {console_sink, file_sink}); logger.set_level(spdlog::level::debug); logger.warn("this should appear in both console and file"); logger.info("this message should not appear in the console, only in the file"); } // User defined types logging by implementing operator<< #include "spdlog/fmt/ostr.h" // must be included struct my_type { int i; template friend OStream &operator<<(OStream &os, const my_type &c) { return os << "[my_type i=" << c.i << "]"; } }; void user_defined_example() { spdlog::info("user defined type: {}", my_type{14}); } // Custom error handler. Will be triggered on log failure. void err_handler_example() { // can be set globally or per logger(logger->set_error_handler(..)) spdlog::set_error_handler([](const std::string &msg) { printf("*** Custom log error handler: %s ***\n", msg.c_str()); }); } // syslog example (linux/osx/freebsd) #ifndef _WIN32 #include "spdlog/sinks/syslog_sink.h" void syslog_example() { std::string ident = "spdlog-example"; auto syslog_logger = spdlog::syslog_logger_mt("syslog", ident, LOG_PID); syslog_logger->warn("This is warning that will end up in syslog."); } #endif // Android example. #if defined(__ANDROID__) #include "spdlog/sinks/android_sink.h" void android_example() { std::string tag = "spdlog-android"; auto android_logger = spdlog::android_logger_mt("android", tag); android_logger->critical("Use \"adb shell logcat\" to view this message."); } #endif /*** R exampleTwo() */ ``` We are not showing the output here; it can be compiled, linked, loaded and run just as above by simply passing the filename to `Rcpp::sourceCpp()`. Note that is will create a few demonstration logfiles so you may want to run the example from a temporary directory. ## Third example: Colour The next example highlights a colour 'sink' for the logger. Again, do not use this as a starting point for your package as `R CMD check` will protest about use of `stdout`. ```c++ #include "spdlog/spdlog.h" #include "spdlog/sinks/stdout_color_sinks.h" #include // [[Rcpp::depends(RcppSpdlog)]] // [[Rcpp::export]] void exampleThree() { auto console = spdlog::stdout_color_mt("console"); // change log pattern (changed from [%H:%M:%S %z] [%n] [%^---%L---%$] ) spdlog::set_pattern("[%H:%M:%S.%f] [%^%L%$] [thread %t] %v"); spdlog::info("This an info message with custom format"); //spdlog::set_pattern("%+"); // back to default format spdlog::info("Welcome to spdlog!"); spdlog::error("Some error message with arg: {}", 1); spdlog::warn("Easy padding in numbers like {:08d}", 12); spdlog::critical("Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}", 42); spdlog::info("Support for floats {:03.2f}", 1.23456); spdlog::info("Positional args are {1} {0}..", "too", "supported"); spdlog::info("{:<30}", "left aligned"); // added to this example file allow multiple runs of different package functions spdlog::drop("console"); } /*** R exampleThree() */ ``` When running this example in a terminal capable of displaying colour escape sequence, the logging levels are distinguished by colour. This ranges from green ("info") to yellow ("warning") to red ("error") and white-on-red ("critical"). Not that in this vignette color from standard output does how not show (in the keep-it-simple-mode we are using here). ```sh R> exampleThree() [14:47:52.260692] [I] [thread 2502026] This an info message with custom format [14:47:52.260715] [I] [thread 2502026] Welcome to spdlog! [14:47:52.260732] [E] [thread 2502026] Some error message with arg: 1 [14:47:52.260734] [W] [thread 2502026] Easy padding in numbers like 00000012 [14:47:52.260736] [C] [thread 2502026] Support for int: 42; hex: 2a; oct: 52; bin: 101010 [14:47:52.260739] [I] [thread 2502026] Support for floats 1.23 [14:47:52.260741] [I] [thread 2502026] Positional args are supported too.. [14:47:52.260743] [I] [thread 2502026] left aligned R> ``` ## Fourth Example: Dedicated R Logger The next example is suitable for use in R packages, and in fact included as an example in the package. We include the source file [src/exampleRsink.cpp](https://github.com/eddelbuettel/rcppspdlog/blob/master/src/exampleRsink.cpp). ```c++ // this portmanteau include also defines the r_sink we use below, and which // diverts all logging to R via the Rcpp::Rcout replacement for std::cout #include #include // also support stopwatch feature //' spdlog Example using a sink for R //' //' A simple example invoking a derived R/Rcpp logger. Also demonstrates the //' stopwatch feature. For more features see the 'spdlog' documnetation. //' //' Note that this no longer triggers R warnings thanks to excellent help by //' Gabi Melman. //' @return None //' @examples //' exampleRsink() // [[Rcpp::export]] void exampleRsink() { std::string logname = "fromR"; // fix a name for this logger auto sp = spdlog::get(logname); // retrieve existing one if (sp == nullptr) sp = spdlog::r_sink_mt(logname); // or create new one if needed spdlog::set_default_logger(sp); // and set as default spdlog::stopwatch sw; // instantiate a stop watch // change log pattern (changed from [%H:%M:%S %z] [%n] [%^---%L---%$] ) spdlog::set_pattern("[%H:%M:%S.%f] [%n] [%^%L%$] [thread %t] %v"); spdlog::info("Welcome to spdlog!"); spdlog::error("Some error message with arg: {}", 1); spdlog::info("Elapsed time: {}", sw); spdlog::warn("Easy padding in numbers like {:08d}", 12); spdlog::critical("Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}", 42); spdlog::info("Support for floats {:03.2f}", 1.23456); spdlog::info("Positional args are {1} {0}..", "too", "supported"); spdlog::info("{:<30}", "left aligned"); spdlog::info("Elapsed time: {}", sw); } //' spdlog Logging Lever Setter //' //' A helper function to turn a logging level given as string //' into the current logging level //' //' @param name A string with the logging level. Value understood are, //' in decreasing verbosity \sQuote{trace}, \sQuote{debug}, \sQuote{info}, //' \sQuote{warning}, \sQuote{error}, \sQuote{critical}, and \sQuote{off}. //' Unrecognised names are equivalent to \sQuote{off}. //' @return Nothing is returned. // [[Rcpp::export]] void setLogLevel(const std::string &name) { spdlog::set_level(spdlog::level::from_str(name)); } ``` The example file contains three key aspects to highlight: - use of the `r_sink_mt()` class for R-specific logger sink - use of the very convenient `stopwatch` object - use of logging levels We highlight these below after first showing the relevant output: ```sh R> exampleRsink() [16:52:12.076751] [fromR] [I] [thread 2453030] Welcome to spdlog! [16:52:12.076809] [fromR] [E] [thread 2453030] Some error message with arg: 1 [16:52:12.076823] [fromR] [I] [thread 2453030] Elapsed time: 9.6104e-05 [16:52:12.076833] [fromR] [W] [thread 2453030] Easy padding in numbers like 00000012 [16:52:12.076844] [fromR] [C] [thread 2453030] Support for int: 42; hex: 2a; oct: 52; bin: 101010 [16:52:12.076853] [fromR] [I] [thread 2453030] Support for floats 1.23 [16:52:12.076871] [fromR] [I] [thread 2453030] Positional args are supported too.. [16:52:12.076879] [fromR] [I] [thread 2453030] left aligned [16:52:12.076892] [fromR] [I] [thread 2453030] Elapsed time: 0.000167057 R> ``` #### R-specific sink [spdlog](https://github.com/gabime/spdlog) has the ability to derive and sub-class sinks for logger. The [RcppSpdlog](https://github.com/eddelbuettel/rcppspdlog) package uses this feature to implement a sink using the Rcpp conduit `Rcpp::Rcout` instead of `std::cout` as it conveniently redirects to the R output stream. This class should be the default one for any R packages wanting to use [spdlog](https://github.com/gabime/spdlog) while also passing `R CMD check`. A second important aspect of the initial code in function `exampleRsink()` is how a named logging instance is requested. If none is found, a new one is instantiated. Next, this logger is made the default logger permitting convenient programmatic access via `spdlog::`. #### Stopwatch A powerful (recent) feature of the include [fmt](https://github.com/fmtlib/fmt) library is the automatic formatting of timestamps and interval. As the code example shows, simply instantianting an object, here called `sw`, and referring to it later is all that takes. #### Log-Level A second utility function `setLogLevel()` is also provided. Usage is simple: after calling it with a given level, only message equal to it or higher are shown as the next example shows. ```sh R> setLogLevel("error") R> exampleRsink() [16:54:12.666261] [fromR] [E] [thread 2453030] Some error message with arg: 1 [16:54:12.666286] [fromR] [C] [thread 2453030] Support for int: 42; hex: 2a; oct: 52; bin: 101010 R> ``` By requestion level 'error', message of level 'info', 'warning' or 'debug' are suppressed but messages levels 'error' or 'critical' as shown as desired. ## Fifth Example: Initialization Package desiring to use [RcppSpdlog](https://github.com/eddelbuettel/rcppspdlog) can initialize its facilities during startup. For that we first define a setup function ```c++ // this portmanteau include also defines the r_sink we use below, and which // diverts all logging to R via the Rcpp::Rcout replacement for std::cout #include //' Set a new default logger for R //' // [[Rcpp::export]] void setDefault() { std::string logname = "fromR"; // fix a name for this logger auto sp = spdlog::get(logname); // retrieve existing one if (sp == nullptr) sp = spdlog::r_sink_mt(logname); // or create new one if needed sp->set_pattern("[%H:%M:%S.%f] [%^%L%$] %v"); spdlog::set_default_logger(sp); } ``` We can then call this function during startup: ```r .onLoad <- function(libname, pkgname) { setDefault(); } ``` ## Sixth Example: Compile-time Selection Of course, [spdlog](https://github.com/gabime/spdlog) also supports a common usage paradigm with loggers in which the decision of whether to log or not is _compile-time_ rather than run time. As this is typically implemented via macros, usage is via upper-case macros as well. The following example shows a function with three different logging-level statements as well as a `#define` set such one and only one is shown. Similarly, code can contain debug or trace or info or ... statements which would _not_ appear in the actually loaded "production code" (or CRAN version) if the compile-time logging level define is set high enough. ```c++ // this portmanteau include also defines the r_sink we use below, and which // diverts all logging to R via the Rcpp::Rcout replacement for std::cout #include // A define such as this could also be set in src/Makevars via a -D flag #define SPDLOG_LOG_LEVEL SPDLOG_LEVEL_CRITICAL // [[Rcpp::export]] void demoInvisible() { Rcpp::Rcout << "Hello from demoInvisible, just to show we're being called...\n"; // trace message via default logger SPDLOG_TRACE("Some trace message.. {} ,{}", 1, 3.23); // debug message via default logger SPDLOG_DEBUG("Some debug message.. {} ,{}", 1, 3.23); // debug message via default logger SPDLOG_CRITICAL("Some critical message.. {} ,{}", 1, 3.23); } ``` When a piece of code with such compile-time defines is used, we see the expected outcome. The following example uses default logger, and as the preceding section showed this can be set up to be the custom R sink: ```r R> Rcpp::sourceCpp("/tmp/rcppspdlog.cpp") # plus a '// [[Rcpp:depends("RcppSpdlog")' R> demoInvisible() Hello from demoInvisible, just to show we're being called... [08:44:48.198075] [fromR] [C] [thread 2453030] Some critical message.. 1 ,3.23 R> ``` ## Seventh Example: Access From R As of package 0.0.9, [RcppSpdlog](https://github.com/eddelbuettel/rcppspdlog) supports two new modes. The first is direct logging support from R and described in this section; the second is access from another R package and described thereafter. A number of basic functions are exported using Rcpp. These include `log_setup(name, level)` to instantiate a named logger at a given level (instead of an unnamed default at level 'warn'), `log_filesetup(filename, name, level)` (same using the named file as logging destination), a helper `log_drop(name)` to drop a named logger, two setters `log_set_pattern()` and `log_set_level()` to set, respectively, the displayed log pattern and the level. This is complemented by the actual loggers ranging from `log_trace()` and `log_debug()` to `log_info()`, `log_warn()`, `log_error()` and finally `log_critical()`. The following example (also the example in the manual page) illustrates. ```r > library(RcppSpdlog) > log_setup("demo") # default level 'warn' is used > log_info("this message is NOT seen") > log_set_level("debug") > log_set_pattern("%^[%H:%M:%S.%e] [%n] [%l] %v%$") # set a pattern w/o process id > log_info("this message is seen") [15:55:34.150] [demo] [info] this message is seen > log_warn("as is this message") [ 15:55:37.513] [demo] [warning] as is this message > ``` The interface expects a character value so use from either `sprintf()` or a string-interpolating helper such as `glue::glue` can be used: ```r > log_info(sprintf("We can %s a %s with values %d", "build", "text", 42L)) [16:03:37.728] [demo] [info] We can build a text with values 42 > log_info(glue::glue("We can {a} a {b} with values {v}", a="build", b="text", v=42L)) [16:03:46.395] [demo] [info] We can build a text with values 42 > ``` ## Eight Example: Access From Another R Package As of package 0.0.9, another package can use the C++ level functions (either with or without the R functions) by importing the `RcppSpdlog` while ensuring at least one function from the package is imported (so that the C-level interface functions are instantiated by R). This is time-honoured mechanism long-used by `lme4` to access (compiled) functions from `Matrix` as well as by `xts` to access code from `zoo`, and others. To properly import the package, add just one import, for example `importFrom((RcppSpdlog, log_setup)` to the `NAMESPACE` file of your package, along with the required `Imports: RcppSpdlog` in the `DESCRIPTION` file. The available functions are the same as the ones described in the previous section, but now available at the C++ level in the `RcppSpdlog` namespace. So for example ```c++ #include RcppSpdlog::log_setup("demoLogger", "info"); // create logger at info level RcppSpdlog::log_info("logger created"); ``` will work. ## Nineth Example: More compact C++ Access As the (auto-generated, thanks to `Rcpp`) interface described in the previous section is a little "wordy", we added a simple aliasing wrapping in a new namespace `spdl` and, given the protection from naming collisions offered by the namespace, shortened the accessor function names. So the previous example can also be used via ```c++ #include spdl::setup("demoLogger", "info"); // create logger at info level spdl::info("logger created"); ``` The logger interface takes a simple string. Two easy options exist for formatting such as string. First, one can rely on the [tinyformat](https://github.com/c42f/tinyformat) version included with `Rcpp` and use `tfm::format()` which works with standard `printf()` operators. Second, one can use the `fmt` library included with `spdlog` via an explicit call. ```c++ # using tfm::format spdl::info(tfm::format("We %s values %d and %f", "log", 42, 1.23)); # using fmt::format spdl::info(fmt::format("We {} values {} and {}", "log", 42, 1.23)); ``` Here both formatters have to be called explicitly as we use a simple one-function signature (per logging function) to the underlying C language implementation without the fuller flexibility of variadic arguments. As C++11 can be assumed, we can also offers a variadic template expansion for `fmt::format()` and the second example simply becomes ```c++ spdl::info("We {} values {} and {}", "log", 42, 1.23); ``` ## Tenth Example: More compact R Access As the more compact access in the previous section is quite compelling we also created a sibbling R package [spd](https://github.com/eddelbuettel/spdl) providing a `spdl` namespace in R allowing _the exact same format strings too`. So ```r spdl::info("We {} values {} and {}", "log", 42L, 1.23); ``` now also works from R using the same formatting string. We inted to upload `spdl` to CRAN too. Note that other all other formatting options are supported from R: the first argument is a character variable which can be constructed using `paste`, `sprintf`, or any of the string-interpolating packages. But as none of those methods works like [fmt](https://github.com/fmtlib/fmt) (which we have come to like a lot) we added support for it too. ## Eleventh Example: Stopwatch Support in R and C++ As shown above, [spdlog](https://github.com/gabime/spdlog) supports a 'stopwatch' in C++. Usage is straightforward: one first instantiates an object of type `stopwatch` (make sure to first include the appropriate header too!) and then reports elapsed time by including the `stopwatch` object in the logger. We wrap this `spdlog::stopwatch` object in an external pointer to make it accessible from R. Moreover, by creating it as a S3 object we can add a `format()` method to make the usage pattern identical to the use in C++. So in R we now have ```r sw <- RcppSpdlog::get_stopwatch() Sys.sleep(0.2) RcppSpdlog::log_warn("Elapsed time via stopwatch: {}", sw) ``` This also works in C++. ```c++ auto sw = RcppSpdlog::get_stopwatch(); // returns XPtrcode { white-space: pre; overflow: visible; background-color: unset; padding: 0; } pre.sourceCode.numberSource { overflow-x: visible; } pre.sourceCode.numberSource>code { white-space: pre-wrap } pre.sourceCode.numberSource>code>span { left: 8px; text-indent: -4.6em; } /* code folding */ .chunk-summary { text-align: right; } .chunk-summary+pre, .chunk-summary+div.sourceCode { margin-top: 2px; } /* TOC */ nav > ul { border: .0625rem solid #444; border-radius: 4px; margin: 5px; padding: 5px; } nav ul { list-style-type: none; padding-inline-start: 1rem; } nav ul li { padding: 0; } nav ul ul { margin-top: 0; margin-bottom: 0; padding-top: 0; padding-bottom: 0; } nav code { background-color: unset; color: unset; } RcppSpdlog/R/0000755000176200001440000000000014531532127012533 5ustar liggesusersRcppSpdlog/R/RcppExports.R0000644000176200001440000001646514531532127015163 0ustar liggesusers# Generated by using Rcpp::compileAttributes() -> do not edit by hand # Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 #' spdlog Example using a sink for R #' #' A simple example invoking a derived R/Rcpp logger. Also demonstrates the #' stopwatch feature. For more features see the 'spdlog' documnetation. #' #' Note that this no longer triggers R warnings thanks to excellent help by #' Gabi Melman. #' @return None #' @examples #' exampleRsink() exampleRsink <- function() { invisible(.Call(`_RcppSpdlog_exampleRsink`)) } #' spdlog Logging Lever Setter #' #' A helper function to turn a logging level given as string #' into the current logging level #' #' @param name A string with the logging level. Value understood are, #' in decreasing verbosity \sQuote{trace}, \sQuote{debug}, \sQuote{info}, #' \sQuote{warning}, \sQuote{error}, \sQuote{critical}, and \sQuote{off}. #' Unrecognised names are equivalent to \sQuote{off}. #' @return Nothing is returned. setLogLevel <- function(name) { invisible(.Call(`_RcppSpdlog_setLogLevel`, name)) } #' Simple Pass-Through Formatter to \code{fmt::format()} #' #' The C-level interface of R does not make it easy to pass \code{...} arguments. #' This helper function assumes it has already been called with \code{format()} #' on each argument (as a wrapper can do) so it just spreads out the class to #' \code{fmt::format{}} which, being C++, uses variadic templates to receive the #' arguments. The main motivation for this function to able to format string as #' use by the \sQuote{fmtlib::fmt} library included in \sQuote{spdlog} to write #' similar debug strings in both R and C++. This function permits R calls with #' multiple arguments of different types which (by being formatted on the R side) #' are handled as strings (whereas C++ logging has access to the templating logic). #' #' @param s A character variable with a format string for \sQuote{fmtlib::fmt} #' @param v A character vector with the logging string arguments. #' @return A single (formatted) string #' @seealso https://github.com/fmtlib/fmt formatter <- function(s, v) { .Call(`_RcppSpdlog_formatter`, s, v) } #' R Accessor Functions for spdlog Logger #' #' Several R-level functions can access the \code{spdlog} logging facilties. As \code{spdlog} #' is a C++-level logging library, these are R function permit concurrent logging from both #' R and C++. #' #' Several functions are provided: #' \describe{ #' \item{\code{log_setup}}{Initializes a logger (which becomes the default logger).} #' \item{\code{log_filesetup}}{Initializes a file-based logger (which becomes the default).} #' \item{\code{log_drop}}{Removes logger (which in general should not be needed).} #' \item{\code{log_set_pattern}}{Changes the default logging message pattern.} #' \item{\code{log_set_level}}{Sets the logging level threshold.} #' \item{\code{log_trace}}{Logs a trace-level message.} #' \item{\code{log_debug}}{Logs a debug-level message.} #' \item{\code{log_info}}{Logs a info-level message.} #' \item{\code{log_warn}}{Logs a warn-level message.} #' \item{\code{log_error}}{Logs a error-level message.} #' \item{\code{log_critical}}{Logs a critical-level message.} #' } #' #' Supported logging levels are, in order of increasing threshold values, \sQuote{trace}, #' \sQuote{debug}, \sQuote{warn}, \sQuote{info}, \sQuote{warn}, \sQuote{error}, and #' \sQuote{critical}. A message issued below the current threshold is not displayed whereas #' a message at or above the current threshold is displayed. The default level is \sQuote{warn}. #' #' @seealso The logging pattern format is described in at the repo in the page #' \url{https://github.com/gabime/spdlog/wiki/3.-Custom-formatting}. #' #' @param name A character variable with the logging instance name, default value is \sQuote{default}. #' @param level A character variable with the default logging level, default value is \sQuote{warn}. #' @param s A character variable with the logging pattern, level or message. #' @param filename A character variable with the logging filename if a file-based logger is #' instantiated. #' #' @return Nothing is returned from these functions as they are invoked for their side-effects. #' #' @examples #' log_setup("demo") # at default level 'warn' #' log_info("this message is NOT seen") #' log_set_level("debug") #' log_info("this message is seen") #' log_warn("as is this message") #' log_setup <- function(name = "default", level = "warn") { invisible(.Call(`_RcppSpdlog_log_setup`, name, level)) } #' @rdname log_setup log_init <- function(level = "warn") { invisible(.Call(`_RcppSpdlog_log_init`, level)) } #' @rdname log_setup log_filesetup <- function(filename, name = "default", level = "warn") { invisible(.Call(`_RcppSpdlog_log_filesetup`, filename, name, level)) } #' @rdname log_setup log_drop <- function(name) { invisible(.Call(`_RcppSpdlog_log_drop`, name)) } #' @rdname log_setup log_set_pattern <- function(s) { invisible(.Call(`_RcppSpdlog_log_set_pattern`, s)) } #' @rdname log_setup log_set_level <- function(s) { invisible(.Call(`_RcppSpdlog_log_set_level`, s)) } #' @rdname log_setup log_trace <- function(s) { invisible(.Call(`_RcppSpdlog_log_trace`, s)) } #' @rdname log_setup log_debug <- function(s) { invisible(.Call(`_RcppSpdlog_log_debug`, s)) } #' @rdname log_setup log_info <- function(s) { invisible(.Call(`_RcppSpdlog_log_info`, s)) } #' @rdname log_setup log_warn <- function(s) { invisible(.Call(`_RcppSpdlog_log_warn`, s)) } #' @rdname log_setup log_error <- function(s) { invisible(.Call(`_RcppSpdlog_log_error`, s)) } #' @rdname log_setup log_critical <- function(s) { invisible(.Call(`_RcppSpdlog_log_critical`, s)) } #' R Accessor Functions for spdlog Stopwatch #' #' A set of functions provides access to the \code{spdlog} stopwatch facilty. As \code{stopwatch} #' object is a simple container around a C++ \code{std::chrono} object which (essentially) reports #' elapsed-time since creation. The object is exported to R via an external pointer permitting use #' from both R and C++. #' #' Several functions are provided: #' \describe{ #' \item{\code{get_stopwatch}}{Returns a stopwatch object (as an S3 object).} #' \item{\code{elapsed_stopwatch}}{Returns elapsed time for stopwatch in seconds.} #' \item{\code{format_stopwatch}}{Returns elapsed time for stopwatch as character variable.} #' } #' The \code{stopwatch} object has \code{print} and \code{format} methods. #' #' @param sw An S3 object of type \code{stopwatch}. #' @param x An S3 object of type \code{stopwatch}. #' @param ... Dotted argument required by generic, unused here. #' #' @return The desired object is returned: respectively, a stopwatch object as an external pointer #' in an S3 class, the elapsed time in seconds as a double, or formatted as a character variable. #' #' @examples #' w <- get_stopwatch() #' Sys.sleep(0.2) #' elapsed_stopwatch(w) #' format_stopwatch(w) #' @rdname get_stopwatch get_stopwatch <- function() { .Call(`_RcppSpdlog_get_stopwatch`) } #' @rdname get_stopwatch elapsed_stopwatch <- function(sw) { .Call(`_RcppSpdlog_elapsed_stopwatch`, sw) } #' @rdname get_stopwatch format_stopwatch <- function(sw) { .Call(`_RcppSpdlog_format_stopwatch`, sw) } # Register entry points for exported C++ functions methods::setLoadAction(function(ns) { .Call(`_RcppSpdlog_RcppExport_registerCCallable`) }) RcppSpdlog/R/stopwatch.R0000644000176200001440000000042114351375022014666 0ustar liggesusers##' @rdname get_stopwatch print.stopwatch <- function(x, ...) { cat(RcppSpdlog::format_stopwatch(x), "\n") invisible(x) } ##' @rdname get_stopwatch format.stopwatch <- function(x, ...) { xx <- RcppSpdlog::format_stopwatch(x) names(xx) <- names(x) xx } RcppSpdlog/MD50000644000176200001440000002310614612660532012646 0ustar liggesusers4af3c7f3c53e5ea53dd302232efaf991 *ChangeLog 602f397c4ff4e5e69c75aa9583066641 *DESCRIPTION c46c5820371c6a714067c2572061e64a *NAMESPACE 30f84c9bd98db0266231121080e5abdf *R/RcppExports.R 2ae3d258444ab4c38a71ba99276cd3a9 *R/stopwatch.R 5ebc2a6fa26929a6674cff0ec4736c90 *README.md 6df5b328ffaebb7ec1fd7b3927220509 *build/partial.rdb f52a1ae1faff0c1ff9e587ba109e82c7 *build/vignette.rds 87c92bd52eb970c53e5006cdb3fb093d *cleanup 9757d633b341be4d649d5671a48ca208 *inst/AUTHORS 21abd8dfed73283e13f84d25982e2472 *inst/COPYRIGHTS 05153cd90a485757b488bbca1168c1e7 *inst/NEWS.Rd a9f93e3d39b8333438fd5f4a4dd80b14 *inst/doc/introduction.html 0aaf84178d2b802cc2d4009deba39744 *inst/doc/introduction.md 222438c270ac069c195531bf7d270175 *inst/examples/exampleOne.cpp 1277947a40e0ecd4d2c456761cd87577 *inst/examples/exampleThree.cpp 4680162ce96e299f7d15705229135154 *inst/examples/exampleTwo.cpp 322b9cc315662bca46ce9d501bbe4e29 *inst/include/RcppSpdlog e21920e2678c2c55e7e8548448cbacf8 *inst/include/RcppSpdlog.h 1905a5d6208ecc9d80e610642938ec07 *inst/include/RcppSpdlog_RcppExports.h 778beb12ecdf4ba4f0aa7498bd17acf4 *inst/include/RcppSpdlog_types.h d3455af09d9bfb70bce9e3bb5f93385d *inst/include/rcpp_sink.h 88b39d98beaf84c6ccda4d133045cf85 *inst/include/spdl.h c697412b7425861a91ed46b7d7a3792a *inst/include/spdlog/async.h b06a223d29ff385a46e1a238fa3a8edb *inst/include/spdlog/async_logger-inl.h ad2d926b87a4310daf410cb584d1ef76 *inst/include/spdlog/async_logger.h e4be25b39f75efd8e958adb572e04b99 *inst/include/spdlog/cfg/argv.h c8ad1c7dd7b0634940aaf1ae73a97618 *inst/include/spdlog/cfg/env.h 5a085df9b9d577026b152b455a3ab948 *inst/include/spdlog/cfg/helpers-inl.h d03cc340472e1c4e4e10d718d2bf319e *inst/include/spdlog/cfg/helpers.h 15bb50c4e7044385ad6c66b4b3cb019d *inst/include/spdlog/common-inl.h 8ac45431ef5bde6dceb8c1aef4182d41 *inst/include/spdlog/common.h dc7a53629829b391b5508a27ad007418 *inst/include/spdlog/details/backtracer-inl.h 08afd4b18d15ce318f94f885b567e5b5 *inst/include/spdlog/details/backtracer.h 34065e19a0eeb6618a6670774123bc68 *inst/include/spdlog/details/circular_q.h 5a10b8a898a2cc609393fa6c71ef01f0 *inst/include/spdlog/details/console_globals.h dd317ea528e3deaffcaa9ebab2698e2e *inst/include/spdlog/details/file_helper-inl.h c986d4e323f65c1557dfb6ea30c9d20b *inst/include/spdlog/details/file_helper.h 167c9f3ff90dc214ea67a7e27f8132c9 *inst/include/spdlog/details/fmt_helper.h 781b915e9c3732bb3ff6e6585bdab47f *inst/include/spdlog/details/log_msg-inl.h 3f2569e666f7ba1f8ead651a55a5f04b *inst/include/spdlog/details/log_msg.h db30aed09c6c209732e3eb940ca966b5 *inst/include/spdlog/details/log_msg_buffer-inl.h ca0560cfa72bc63556fa0995cbcbda7e *inst/include/spdlog/details/log_msg_buffer.h d3742a459c38257755224dd412eb9e7c *inst/include/spdlog/details/mpmc_blocking_q.h 7d9b1a33832b3670e18de41f1a2bd79b *inst/include/spdlog/details/null_mutex.h decc3f640786e59169552e65ea16eabf *inst/include/spdlog/details/os-inl.h c1944a9b2d5c5329b9d59e4e42628e5f *inst/include/spdlog/details/os.h 646a3cb29d1e49e3ab7da823640c3e35 *inst/include/spdlog/details/periodic_worker-inl.h f93ea1414cc0087904c59696a7a39f6b *inst/include/spdlog/details/periodic_worker.h f513e1435a3f7512b0cf6afb5a790d54 *inst/include/spdlog/details/registry-inl.h 846ac38e78d463fdca42ce8b9a63150d *inst/include/spdlog/details/registry.h 9887cefa5eafc87fb54e1c702ac08788 *inst/include/spdlog/details/synchronous_factory.h 1719f9ec9cdc0afbbe5ffa893a40ae34 *inst/include/spdlog/details/tcp_client-windows.h 70347e70040f296da4a17c1622926b48 *inst/include/spdlog/details/tcp_client.h a971096ab6b8352688760968bb7aa9b9 *inst/include/spdlog/details/thread_pool-inl.h fa59a8eb855a36d14fff82f7bf4a3b53 *inst/include/spdlog/details/thread_pool.h c4d1d1ba1265be759997c12ad60d1136 *inst/include/spdlog/details/udp_client-windows.h e64b24aaead752fc8053ffc8caac6bc4 *inst/include/spdlog/details/udp_client.h 5e5e051284aaa70a268ce7ff2bea1554 *inst/include/spdlog/details/windows_include.h 88f6797ac41e603276635c847eec906b *inst/include/spdlog/fmt/bin_to_hex.h 4ab93e57fef06e77e062929df6fe09b9 *inst/include/spdlog/fmt/bundled/args.h e75bc16059a23f2592df80ed3761408f *inst/include/spdlog/fmt/bundled/chrono.h 5097b557b591acf775755bd1e901639a *inst/include/spdlog/fmt/bundled/color.h f9bcf13304dcc2e9a72c6b988a307424 *inst/include/spdlog/fmt/bundled/compile.h 6088b900427ad35accaebf25cb77e272 *inst/include/spdlog/fmt/bundled/core.h af88d758f75f3c5c48a967501f24384b *inst/include/spdlog/fmt/bundled/fmt.license.rst 99ad6bd222ba04daa3afbdf526834c49 *inst/include/spdlog/fmt/bundled/format-inl.h c02d5c52e0486001a7cf1cf64ea770e5 *inst/include/spdlog/fmt/bundled/format.h 158e8bd0cdf18513a53e8b435e6a703c *inst/include/spdlog/fmt/bundled/locale.h ecfce270d9f2dbe1237366987e1deaba *inst/include/spdlog/fmt/bundled/os.h 36fd6492e78c05bb0624d11ed7974e63 *inst/include/spdlog/fmt/bundled/ostream.h 4510b5dbcca5d8ce2df279efe7aa30c3 *inst/include/spdlog/fmt/bundled/printf.h 9e7ed69387e08f75805c4e36a53260e7 *inst/include/spdlog/fmt/bundled/ranges.h a5291e97e5f2fdb653812bf85560f39a *inst/include/spdlog/fmt/bundled/std.h 5fdca12bac3735687802ce0725197c55 *inst/include/spdlog/fmt/bundled/xchar.h 6cc3090a994fa6400011096a4574537c *inst/include/spdlog/fmt/chrono.h 9f7a4463f5fb434791cd6d3d854c63c8 *inst/include/spdlog/fmt/compile.h 9eddacb20001af383b68de66c87b5110 *inst/include/spdlog/fmt/fmt.h 39ebf98df5098abc6348df9e233e496b *inst/include/spdlog/fmt/ostr.h 7ca0808e4a9f5e7d8e3c40032ef83c22 *inst/include/spdlog/fmt/ranges.h 6859d95e1c192b017ae5809ec4a9f8aa *inst/include/spdlog/fmt/std.h 16f070a2da96ff865cc5a09e0d0f416a *inst/include/spdlog/fmt/xchar.h f144fcc94d4aeffc506a5ed11cfd2b0c *inst/include/spdlog/formatter.h 99dc2eb976d56f52faaff57c1b0cf780 *inst/include/spdlog/fwd.h 27f9b9b1875730bfbad486fa8c7aa46e *inst/include/spdlog/logger-inl.h c7ec3fd4ee69cefece86a1cf334b44b7 *inst/include/spdlog/logger.h fbb79767df11a0165fff3c8ef2997d96 *inst/include/spdlog/mdc.h d8e18b027c1e1deff319aa81bc1dbf5a *inst/include/spdlog/pattern_formatter-inl.h 30ade8a01a8e9ee7b7165ec0ba7d9bde *inst/include/spdlog/pattern_formatter.h 9fb134af8cb09d9fcaa2fa59d61c756a *inst/include/spdlog/sinks/android_sink.h 086ff22475b69ba9caa859cc603a1363 *inst/include/spdlog/sinks/ansicolor_sink-inl.h a8987e8eb707a9989c2e5188c794bd9d *inst/include/spdlog/sinks/ansicolor_sink.h ce20484cff3e0b96b5eb08955fbe5d5e *inst/include/spdlog/sinks/base_sink-inl.h 6b47b05edf65e177411cb3cf0677afc4 *inst/include/spdlog/sinks/base_sink.h dbcfbcdb161ef4e5d0d288c4b989e54f *inst/include/spdlog/sinks/basic_file_sink-inl.h 5a56544975033a25204846a55394d71a *inst/include/spdlog/sinks/basic_file_sink.h 02df7a367ece356333dfe1b07ca6a6aa *inst/include/spdlog/sinks/callback_sink.h 3c321bcb62dadea329e3be4fa3bb9d5f *inst/include/spdlog/sinks/daily_file_sink.h c01d1cb4b6112ea37b9c7ba968fc4e37 *inst/include/spdlog/sinks/dist_sink.h 596da3543e0845a5fdfc8329cf01ade3 *inst/include/spdlog/sinks/dup_filter_sink.h 3ea0d93cf9401247635c950bc68c84e2 *inst/include/spdlog/sinks/hourly_file_sink.h 36c8501dc10c23104ee145db4ad6f270 *inst/include/spdlog/sinks/kafka_sink.h 848c7cb468e687e1f9004385914396f5 *inst/include/spdlog/sinks/mongo_sink.h 67d1e5770e74f27c8b3a50a24c2ec95e *inst/include/spdlog/sinks/msvc_sink.h 3596f3a95472b29d2ca4d63496a32f9b *inst/include/spdlog/sinks/null_sink.h 713338288b750013c9225324dec5dcc1 *inst/include/spdlog/sinks/ostream_sink.h 771f37150e8443d41479e838fcfc0050 *inst/include/spdlog/sinks/qt_sinks.h dc218cea3ecc0165bbb7c10deea03334 *inst/include/spdlog/sinks/ringbuffer_sink.h 48eb5c8a2bfe501922f5fd897eea2685 *inst/include/spdlog/sinks/rotating_file_sink-inl.h 7ec61e61e26fa48bff6102937d4c6ce2 *inst/include/spdlog/sinks/rotating_file_sink.h 89fd162ca938159a419b713ceacce1cd *inst/include/spdlog/sinks/sink-inl.h 61e98489d85be5755052bfd4364487e3 *inst/include/spdlog/sinks/sink.h 8044debbe09c4778261eb317bdf25b2d *inst/include/spdlog/sinks/stdout_color_sinks-inl.h 9401b52bd4d61d4a831aaee8538140c6 *inst/include/spdlog/sinks/stdout_color_sinks.h 2aa9c3f855d8c73c90a5c9d412cf1ab3 *inst/include/spdlog/sinks/stdout_sinks-inl.h a05d7c39808e60680eff8c61d09052c2 *inst/include/spdlog/sinks/stdout_sinks.h 23421783e2f7641056bf95b2859f87d9 *inst/include/spdlog/sinks/syslog_sink.h e2d3c94e9235adfe5d4086ae931afa4a *inst/include/spdlog/sinks/systemd_sink.h 2888fe3c276df3f2dc46ef8471fa2c52 *inst/include/spdlog/sinks/tcp_sink.h 4efa105337fb1c2dd41282ae789a32ff *inst/include/spdlog/sinks/udp_sink.h 6300a4249320beda969882af0d8b5c89 *inst/include/spdlog/sinks/win_eventlog_sink.h 9fe9479ec90fc363b24c248c2088e289 *inst/include/spdlog/sinks/wincolor_sink-inl.h 82b9d7bdb0301d940ec4ccd389db547b *inst/include/spdlog/sinks/wincolor_sink.h 723db4fca9d7a102b25b2b6331d77fb4 *inst/include/spdlog/spdlog-inl.h 7afecb7ff04fdba816130070741907ec *inst/include/spdlog/spdlog.h fe2aa12b003fbf41d39386b926305f24 *inst/include/spdlog/stopwatch.h f56767b14e0d9f798e7962ab0dac51c5 *inst/include/spdlog/tweakme.h e4284e0290023e60c4892c0913cd37f9 *inst/include/spdlog/version.h c851cde430d920b87781927b016ff5a8 *inst/include/spdlog_stopwatch.h 346eb5456550f5aacf6c56360c8d2041 *man/RcppSpdlog-package.Rd 6bcb50fdd388e53b542b335934ad5abf *man/exampleRsink.Rd de5dccf3b272b1359a590e86d5239fc2 *man/formatter.Rd eba360966785b29107b0a86036972b45 *man/get_stopwatch.Rd 94a017087f08e879acda57af6464088a *man/log_setup.Rd 0dd8ebcb380b0c3a1a8628f3f25a270e *man/setLogLevel.Rd 5c42424676b675fab5435cfc162e5861 *src/Makevars f33e06159234d24143cb4712887129ba *src/RcppExports.cpp 4eb7e3b32d8414ecf6179a8508fd9244 *src/exampleRsink.cpp 24bf65c9770c5a2f4f914c260ad069cc *src/formatter.cpp b3b388655dbd3ce295c2eed5edce5973 *src/interface.cpp 3b49ef6b0f915852b2cc8ce744e2faa9 *tests/simpleTest.R 0aaf84178d2b802cc2d4009deba39744 *vignettes/introduction.md c337c0e0c1e0c0dd67a87649ff442d9f *vignettes/water.css RcppSpdlog/inst/0000755000176200001440000000000014612606453013313 5ustar liggesusersRcppSpdlog/inst/examples/0000755000176200001440000000000013736372222015131 5ustar liggesusersRcppSpdlog/inst/examples/exampleTwo.cpp0000644000176200001440000001764613736367311020003 0ustar liggesusers #include "spdlog/spdlog.h" #include void stdout_logger_example(); void basic_example(); void rotating_example(); void daily_example(); void async_example(); void binary_example(); void trace_example(); void multi_sink_example(); void user_defined_example(); void err_handler_example(); void syslog_example(); void clone_example(); #include "spdlog/spdlog.h" // [[Rcpp::depends(RcppSpdlog)]] // [[Rcpp::export]] void exampleTwo() { spdlog::info("Welcome to spdlog version {}.{}.{} !", SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR, SPDLOG_VER_PATCH); spdlog::warn("Easy padding in numbers like {:08d}", 12); spdlog::critical("Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}", 42); spdlog::info("Support for floats {:03.2f}", 1.23456); spdlog::info("Positional args are {1} {0}..", "too", "supported"); spdlog::info("{:>8} aligned, {:<8} aligned", "right", "left"); // Runtime log levels spdlog::set_level(spdlog::level::info); // Set global log level to info spdlog::debug("This message should not be displayed!"); spdlog::set_level(spdlog::level::trace); // Set specific logger's log level spdlog::debug("This message should be displayed.."); // Customize msg format for all loggers spdlog::set_pattern("[%H:%M:%S %z] [%^%L%$] [thread %t] %v"); spdlog::info("This an info message with custom format"); spdlog::set_pattern("%+"); // back to default format try { stdout_logger_example(); basic_example(); rotating_example(); daily_example(); clone_example(); async_example(); binary_example(); multi_sink_example(); user_defined_example(); err_handler_example(); trace_example(); // Flush all *registered* loggers using a worker thread every 3 seconds. // note: registered loggers *must* be thread safe for this to work correctly! spdlog::flush_every(std::chrono::seconds(3)); // Apply some function on all registered loggers spdlog::apply_all([&](std::shared_ptr l) { l->info("End of example."); }); // Release all spdlog resources, and drop all loggers in the registry. // This is optional (only mandatory if using windows + async log). //spdlog::shutdown(); } // Exceptions will only be thrown upon failed logger or sink construction (not during logging). catch (const spdlog::spdlog_ex &ex) { std::printf("Log initialization failed: %s\n", ex.what()); return; } // added to this example file allow multiple runs of function spdlog::drop("console"); spdlog::drop("file_logger"); spdlog::drop("some_logger_name"); spdlog::drop("daily_logger"); spdlog::drop("async_file_logger"); } #include "spdlog/sinks/stdout_color_sinks.h" // or #include "spdlog/sinks/stdout_sinks.h" if no colors needed. void stdout_logger_example() { // Create color multi threaded logger. auto console = spdlog::stdout_color_mt("console"); // or for stderr: // auto console = spdlog::stderr_color_mt("error-logger"); } #include "spdlog/sinks/basic_file_sink.h" void basic_example() { // Create basic file logger (not rotated). auto my_logger = spdlog::basic_logger_mt("file_logger", "logs/basic-log.txt"); } #include "spdlog/sinks/rotating_file_sink.h" void rotating_example() { // Create a file rotating logger with 5mb size max and 3 rotated files. auto rotating_logger = spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3); } #include "spdlog/sinks/daily_file_sink.h" void daily_example() { // Create a daily logger - a new file is created every day on 2:30am. auto daily_logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30); } // Clone a logger and give it new name. // Useful for creating component/subsystem loggers from some "root" logger. void clone_example() { auto network_logger = spdlog::default_logger()->clone("network"); network_logger->info("Logging network stuff.."); } #include "spdlog/async.h" void async_example() { // Default thread pool settings can be modified *before* creating the async logger: // spdlog::init_thread_pool(32768, 1); // queue with max 32k items 1 backing thread. auto async_file = spdlog::basic_logger_mt("async_file_logger", "logs/async_log.txt"); // alternatively: // auto async_file = spdlog::create_async("async_file_logger", "logs/async_log.txt"); for (int i = 1; i < 101; ++i) { async_file->info("Async message #{}", i); } } // Log binary data as hex. // Many types of std::container types can be used. // Iterator ranges are supported too. // Format flags: // {:X} - print in uppercase. // {:s} - don't separate each byte with space. // {:p} - don't print the position on each line start. // {:n} - don't split the output to lines. #include "spdlog/fmt/bin_to_hex.h" void binary_example() { std::vector buf; for (int i = 0; i < 80; i++) { buf.push_back(static_cast(i & 0xff)); } spdlog::info("Binary example: {}", spdlog::to_hex(buf)); spdlog::info("Another binary example:{:n}", spdlog::to_hex(std::begin(buf), std::begin(buf) + 10)); // more examples: // logger->info("uppercase: {:X}", spdlog::to_hex(buf)); // logger->info("uppercase, no delimiters: {:Xs}", spdlog::to_hex(buf)); // logger->info("uppercase, no delimiters, no position info: {:Xsp}", spdlog::to_hex(buf)); } // Compile time log levels. // define SPDLOG_ACTIVE_LEVEL to required level (e.g. SPDLOG_LEVEL_TRACE) void trace_example() { // trace from default logger SPDLOG_TRACE("Some trace message.. {} ,{}", 1, 3.23); // debug from default logger SPDLOG_DEBUG("Some debug message.. {} ,{}", 1, 3.23); // trace from logger object auto logger = spdlog::get("file_logger"); SPDLOG_LOGGER_TRACE(logger, "another trace message"); } // A logger with multiple sinks (stdout and file) - each with a different format and log level. void multi_sink_example() { auto console_sink = std::make_shared(); console_sink->set_level(spdlog::level::warn); console_sink->set_pattern("[multi_sink_example] [%^%l%$] %v"); auto file_sink = std::make_shared("logs/multisink.txt", true); file_sink->set_level(spdlog::level::trace); spdlog::logger logger("multi_sink", {console_sink, file_sink}); logger.set_level(spdlog::level::debug); logger.warn("this should appear in both console and file"); logger.info("this message should not appear in the console, only in the file"); } // User defined types logging by implementing operator<< #include "spdlog/fmt/ostr.h" // must be included struct my_type { int i; template friend OStream &operator<<(OStream &os, const my_type &c) { return os << "[my_type i=" << c.i << "]"; } }; void user_defined_example() { spdlog::info("user defined type: {}", my_type{14}); } // Custom error handler. Will be triggered on log failure. void err_handler_example() { // can be set globally or per logger(logger->set_error_handler(..)) spdlog::set_error_handler([](const std::string &msg) { printf("*** Custom log error handler: %s ***\n", msg.c_str()); }); } // syslog example (linux/osx/freebsd) #ifndef _WIN32 #include "spdlog/sinks/syslog_sink.h" void syslog_example() { std::string ident = "spdlog-example"; auto syslog_logger = spdlog::syslog_logger_mt("syslog", ident, LOG_PID); syslog_logger->warn("This is warning that will end up in syslog."); } #endif // Android example. #if defined(__ANDROID__) #include "spdlog/sinks/android_sink.h" void android_example() { std::string tag = "spdlog-android"; auto android_logger = spdlog::android_logger_mt("android", tag); android_logger->critical("Use \"adb shell logcat\" to view this message."); } #endif /*** R exampleTwo() */ RcppSpdlog/inst/examples/exampleThree.cpp0000644000176200001440000000200413736367504020263 0ustar liggesusers #include "spdlog/spdlog.h" #include "spdlog/sinks/stdout_color_sinks.h" #include // [[Rcpp::depends(RcppSpdlog)]] // [[Rcpp::export]] void exampleThree() { auto console = spdlog::stdout_color_mt("console"); // change log pattern (changed from [%H:%M:%S %z] [%n] [%^---%L---%$] ) spdlog::set_pattern("[%H:%M:%S.%f] [%^%L%$] [thread %t] %v"); spdlog::info("This an info message with custom format"); //spdlog::set_pattern("%+"); // back to default format spdlog::info("Welcome to spdlog!"); spdlog::error("Some error message with arg: {}", 1); spdlog::warn("Easy padding in numbers like {:08d}", 12); spdlog::critical("Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}", 42); spdlog::info("Support for floats {:03.2f}", 1.23456); spdlog::info("Positional args are {1} {0}..", "too", "supported"); spdlog::info("{:<30}", "left aligned"); // added to this example file allow multiple runs of different package functions spdlog::drop("console"); } /*** R exampleThree() */ RcppSpdlog/inst/examples/exampleOne.cpp0000644000176200001440000000210213736367471017737 0ustar liggesusers // based on the 'basic usage' example in the README.md at https://github.com/gabime/spdlog #include "spdlog/spdlog.h" #include // [[Rcpp::depends(RcppSpdlog)]] // [[Rcpp::export]] void exampleOne() { // change log pattern (changed from [%H:%M:%S %z] [%n] [%^---%L---%$] ) spdlog::set_pattern("[%H:%M:%S.%f] [%L] [thread %t] %v"); spdlog::info("Welcome to spdlog!"); spdlog::error("Some error message with arg: {}", 1); spdlog::warn("Easy padding in numbers like {:08d}", 12); spdlog::critical("Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}", 42); spdlog::info("Support for floats {:03.2f}", 1.23456); spdlog::info("Positional args are {1} {0}..", "too", "supported"); spdlog::info("{:<30}", "left aligned"); spdlog::set_level(spdlog::level::debug); // Set global log level to debug spdlog::debug("This message should be displayed.."); // Compile time log levels // define SPDLOG_ACTIVE_LEVEL to desired level SPDLOG_TRACE("Some trace message with param {}", {}); SPDLOG_DEBUG("Some debug message"); } /*** R exampleOne() */ RcppSpdlog/inst/doc/0000755000176200001440000000000014612606453014060 5ustar liggesusersRcppSpdlog/inst/doc/introduction.md0000644000176200001440000007372514356333446017145 0ustar liggesusers --- title: "Introduction to RcppSpdlog" author: "Dirk Eddelbuettel" date: "Initial version dated October 2020. Expanded November 2022." css: "water.css" --- ## Introducing RcppSpdlog [spdlog](https://github.com/gabime/spdlog) is a widely-used and very capable header-only C++ library for logging. The [RcppSpdlog](https://github.com/eddelbuettel/rcppspdlog) package provides R users with easy-to-use customized access to the [spdlog](https://github.com/gabime/spdlog) logging library by including its headers in an R package which permit other R packages to deploy it via a simple `LinkingTo: RcppSpdlog` as described in [Section 1.1.3 of WRE](https://cran.r-project.org/doc/manuals/r-release/R-exts.html#Package-Dependencies). [spdlog](https://github.com/gabime/spdlog) is mature and widely deployed. It also has a very rich set of features described at [the repository wiki](https://github.com/gabime/spdlog/wiki). This vignette will highlight a few first use cases. Note that in order to use [RcppSpdlog](https://github.com/eddelbuettel/rcppspdlog) in an R package that might get distributed to [CRAN](https://cran.r-project.org), the code should follow the example R and C++ code in function `exampleRsink()` as described below. We will however start with some simpler examples. _Do not copy those into your R package._ The package checks used by R test for use of `stdout` and `stderr` which is why the customized setup described later is preferable. ## Initial example: Basics This example follows the simplest and initial example in the [spdlog](https://github.com/gabime/spdlog). It is also included in the [RcppSpdlog](https://github.com/eddelbuettel/rcppspdlog) package as [examples/exampleOne.cpp](https://github.com/eddelbuettel/rcppspdlog/blob/master/inst/examples/exampleOne.cpp). As discussed above, do not use this example as a starting point in an R package. ```c++ // based on the 'basic usage' example in the README.md at https://github.com/gabime/spdlog #include "spdlog/spdlog.h" #include // [[Rcpp::depends(RcppSpdlog)]] // [[Rcpp::export]] void exampleOne() { // change log pattern (changed from [%H:%M:%S %z] [%n] [%^---%L---%$] ) spdlog::set_pattern("[%H:%M:%S.%f] [%L] [thread %t] %v"); spdlog::info("Welcome to spdlog!"); spdlog::error("Some error message with arg: {}", 1); spdlog::warn("Easy padding in numbers like {:08d}", 12); spdlog::critical("Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}", 42); spdlog::info("Support for floats {:03.2f}", 1.23456); spdlog::info("Positional args are {1} {0}..", "too", "supported"); spdlog::info("{:<30}", "left aligned"); spdlog::set_level(spdlog::level::debug); // Set global log level to debug spdlog::debug("This message should be displayed.."); // Compile time log levels // define SPDLOG_ACTIVE_LEVEL to desired level SPDLOG_TRACE("Some trace message with param {}", {}); SPDLOG_DEBUG("Some debug message"); } /*** R exampleOne() */ ``` When built, which is easiest via `Rcpp::sourceCpp()`, the final block ensures that the created function `exampleOne()` is executed. In one previous run, the following output was produded: ```sh R> exampleOne() [14:25:03.362024] [I] [thread 2453030] Welcome to spdlog! [14:25:03.362047] [E] [thread 2453030] Some error message with arg: 1 [14:25:03.362051] [W] [thread 2453030] Easy padding in numbers like 00000012 [14:25:03.362053] [C] [thread 2453030] Support for int: 42; hex: 2a; oct: 52; bin: 101010 [14:25:03.362056] [I] [thread 2453030] Support for floats 1.23 [14:25:03.362058] [I] [thread 2453030] Positional args are supported too.. [14:25:03.362060] [I] [thread 2453030] left aligned [14:25:03.362061] [D] [thread 2453030] This message should be displayed.. R> ``` We note the easy-to-formatting in the source which benefits from the embedded [fmt](https://github.com/fmtlib/fmt) package for easy-to-use variable expansion. We also notice the different logging "levels" indicated by single letters: _info_, _errror_, _warning_, _critical_ and _debug_. More on this below. ## Second example: Showcase This second example follows a more complete example in the [spdlog](https://github.com/gabime/spdlog) documention and highlights numerous features of the library. As before, this example is also included in the [RcppSpdlog](https://github.com/eddelbuettel/rcppspdlog) package as [examples/exampleTwo.cpp](https://github.com/eddelbuettel/rcppspdlog/blob/master/inst/examples/exampleTwo.cpp). And as before, do not use this example as a starting point in an R package. ```c++ #include "spdlog/spdlog.h" #include void stdout_logger_example(); void basic_example(); void rotating_example(); void daily_example(); void async_example(); void binary_example(); void trace_example(); void multi_sink_example(); void user_defined_example(); void err_handler_example(); void syslog_example(); void clone_example(); #include "spdlog/spdlog.h" // [[Rcpp::depends(RcppSpdlog)]] // [[Rcpp::export]] void exampleTwo() { spdlog::info("Welcome to spdlog version {}.{}.{} !", SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR, SPDLOG_VER_PATCH); spdlog::warn("Easy padding in numbers like {:08d}", 12); spdlog::critical("Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}", 42); spdlog::info("Support for floats {:03.2f}", 1.23456); spdlog::info("Positional args are {1} {0}..", "too", "supported"); spdlog::info("{:>8} aligned, {:<8} aligned", "right", "left"); // Runtime log levels spdlog::set_level(spdlog::level::info); // Set global log level to info spdlog::debug("This message should not be displayed!"); spdlog::set_level(spdlog::level::trace); // Set specific logger's log level spdlog::debug("This message should be displayed.."); // Customize msg format for all loggers spdlog::set_pattern("[%H:%M:%S %z] [%^%L%$] [thread %t] %v"); spdlog::info("This an info message with custom format"); spdlog::set_pattern("%+"); // back to default format try { stdout_logger_example(); basic_example(); rotating_example(); daily_example(); clone_example(); async_example(); binary_example(); multi_sink_example(); user_defined_example(); err_handler_example(); trace_example(); // Flush all *registered* loggers using a worker thread every 3 seconds. // note: registered loggers *must* be thread safe for this to work correctly! spdlog::flush_every(std::chrono::seconds(3)); // Apply some function on all registered loggers spdlog::apply_all([&](std::shared_ptr l) { l->info("End of example."); }); // Release all spdlog resources, and drop all loggers in the registry. // This is optional (only mandatory if using windows + async log). //spdlog::shutdown(); } // Exceptions will only be thrown upon failed logger or sink construction (not during logging). catch (const spdlog::spdlog_ex &ex) { std::printf("Log initialization failed: %s\n", ex.what()); return; } // added to this example file allow multiple runs of function spdlog::drop("console"); spdlog::drop("file_logger"); spdlog::drop("some_logger_name"); spdlog::drop("daily_logger"); spdlog::drop("async_file_logger"); } #include "spdlog/sinks/stdout_color_sinks.h" // or #include "spdlog/sinks/stdout_sinks.h" if no colors needed. void stdout_logger_example() { // Create color multi threaded logger. auto console = spdlog::stdout_color_mt("console"); // or for stderr: // auto console = spdlog::stderr_color_mt("error-logger"); } #include "spdlog/sinks/basic_file_sink.h" void basic_example() { // Create basic file logger (not rotated). auto my_logger = spdlog::basic_logger_mt("file_logger", "logs/basic-log.txt"); } #include "spdlog/sinks/rotating_file_sink.h" void rotating_example() { // Create a file rotating logger with 5mb size max and 3 rotated files. auto rotating_logger = spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3); } #include "spdlog/sinks/daily_file_sink.h" void daily_example() { // Create a daily logger - a new file is created every day on 2:30am. auto daily_logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30); } // Clone a logger and give it new name. // Useful for creating component/subsystem loggers from some "root" logger. void clone_example() { auto network_logger = spdlog::default_logger()->clone("network"); network_logger->info("Logging network stuff.."); } #include "spdlog/async.h" void async_example() { // Default thread pool settings can be modified *before* creating the async logger: // spdlog::init_thread_pool(32768, 1); // queue with max 32k items 1 backing thread. auto async_file = spdlog::basic_logger_mt("async_file_logger", "logs/async_log.txt"); // alternatively: // auto async_file = // spdlog::create_async("async_file_logger", // "logs/async_log.txt"); for (int i = 1; i < 101; ++i) { async_file->info("Async message #{}", i); } } // Log binary data as hex. // Many types of std::container types can be used. // Iterator ranges are supported too. // Format flags: // {:X} - print in uppercase. // {:s} - don't separate each byte with space. // {:p} - don't print the position on each line start. // {:n} - don't split the output to lines. #include "spdlog/fmt/bin_to_hex.h" void binary_example() { std::vector buf; for (int i = 0; i < 80; i++) { buf.push_back(static_cast(i & 0xff)); } spdlog::info("Binary example: {}", spdlog::to_hex(buf)); spdlog::info("Another binary example:{:n}", spdlog::to_hex(std::begin(buf), std::begin(buf) + 10)); // more examples: // logger->info("uppercase: {:X}", spdlog::to_hex(buf)); // logger->info("uppercase, no delimiters: {:Xs}", spdlog::to_hex(buf)); // logger->info("uppercase, no delimiters, no position info: {:Xsp}", spdlog::to_hex(buf)); } // Compile time log levels. // define SPDLOG_ACTIVE_LEVEL to required level (e.g. SPDLOG_LEVEL_TRACE) void trace_example() { // trace from default logger SPDLOG_TRACE("Some trace message.. {} ,{}", 1, 3.23); // debug from default logger SPDLOG_DEBUG("Some debug message.. {} ,{}", 1, 3.23); // trace from logger object auto logger = spdlog::get("file_logger"); SPDLOG_LOGGER_TRACE(logger, "another trace message"); } // A logger with multiple sinks (stdout and file) - each with a different format and log level. void multi_sink_example() { auto console_sink = std::make_shared(); console_sink->set_level(spdlog::level::warn); console_sink->set_pattern("[multi_sink_example] [%^%l%$] %v"); auto file_sink = std::make_shared("logs/multisink.txt", true); file_sink->set_level(spdlog::level::trace); spdlog::logger logger("multi_sink", {console_sink, file_sink}); logger.set_level(spdlog::level::debug); logger.warn("this should appear in both console and file"); logger.info("this message should not appear in the console, only in the file"); } // User defined types logging by implementing operator<< #include "spdlog/fmt/ostr.h" // must be included struct my_type { int i; template friend OStream &operator<<(OStream &os, const my_type &c) { return os << "[my_type i=" << c.i << "]"; } }; void user_defined_example() { spdlog::info("user defined type: {}", my_type{14}); } // Custom error handler. Will be triggered on log failure. void err_handler_example() { // can be set globally or per logger(logger->set_error_handler(..)) spdlog::set_error_handler([](const std::string &msg) { printf("*** Custom log error handler: %s ***\n", msg.c_str()); }); } // syslog example (linux/osx/freebsd) #ifndef _WIN32 #include "spdlog/sinks/syslog_sink.h" void syslog_example() { std::string ident = "spdlog-example"; auto syslog_logger = spdlog::syslog_logger_mt("syslog", ident, LOG_PID); syslog_logger->warn("This is warning that will end up in syslog."); } #endif // Android example. #if defined(__ANDROID__) #include "spdlog/sinks/android_sink.h" void android_example() { std::string tag = "spdlog-android"; auto android_logger = spdlog::android_logger_mt("android", tag); android_logger->critical("Use \"adb shell logcat\" to view this message."); } #endif /*** R exampleTwo() */ ``` We are not showing the output here; it can be compiled, linked, loaded and run just as above by simply passing the filename to `Rcpp::sourceCpp()`. Note that is will create a few demonstration logfiles so you may want to run the example from a temporary directory. ## Third example: Colour The next example highlights a colour 'sink' for the logger. Again, do not use this as a starting point for your package as `R CMD check` will protest about use of `stdout`. ```c++ #include "spdlog/spdlog.h" #include "spdlog/sinks/stdout_color_sinks.h" #include // [[Rcpp::depends(RcppSpdlog)]] // [[Rcpp::export]] void exampleThree() { auto console = spdlog::stdout_color_mt("console"); // change log pattern (changed from [%H:%M:%S %z] [%n] [%^---%L---%$] ) spdlog::set_pattern("[%H:%M:%S.%f] [%^%L%$] [thread %t] %v"); spdlog::info("This an info message with custom format"); //spdlog::set_pattern("%+"); // back to default format spdlog::info("Welcome to spdlog!"); spdlog::error("Some error message with arg: {}", 1); spdlog::warn("Easy padding in numbers like {:08d}", 12); spdlog::critical("Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}", 42); spdlog::info("Support for floats {:03.2f}", 1.23456); spdlog::info("Positional args are {1} {0}..", "too", "supported"); spdlog::info("{:<30}", "left aligned"); // added to this example file allow multiple runs of different package functions spdlog::drop("console"); } /*** R exampleThree() */ ``` When running this example in a terminal capable of displaying colour escape sequence, the logging levels are distinguished by colour. This ranges from green ("info") to yellow ("warning") to red ("error") and white-on-red ("critical"). Not that in this vignette color from standard output does how not show (in the keep-it-simple-mode we are using here). ```sh R> exampleThree() [14:47:52.260692] [I] [thread 2502026] This an info message with custom format [14:47:52.260715] [I] [thread 2502026] Welcome to spdlog! [14:47:52.260732] [E] [thread 2502026] Some error message with arg: 1 [14:47:52.260734] [W] [thread 2502026] Easy padding in numbers like 00000012 [14:47:52.260736] [C] [thread 2502026] Support for int: 42; hex: 2a; oct: 52; bin: 101010 [14:47:52.260739] [I] [thread 2502026] Support for floats 1.23 [14:47:52.260741] [I] [thread 2502026] Positional args are supported too.. [14:47:52.260743] [I] [thread 2502026] left aligned R> ``` ## Fourth Example: Dedicated R Logger The next example is suitable for use in R packages, and in fact included as an example in the package. We include the source file [src/exampleRsink.cpp](https://github.com/eddelbuettel/rcppspdlog/blob/master/src/exampleRsink.cpp). ```c++ // this portmanteau include also defines the r_sink we use below, and which // diverts all logging to R via the Rcpp::Rcout replacement for std::cout #include #include // also support stopwatch feature //' spdlog Example using a sink for R //' //' A simple example invoking a derived R/Rcpp logger. Also demonstrates the //' stopwatch feature. For more features see the 'spdlog' documnetation. //' //' Note that this no longer triggers R warnings thanks to excellent help by //' Gabi Melman. //' @return None //' @examples //' exampleRsink() // [[Rcpp::export]] void exampleRsink() { std::string logname = "fromR"; // fix a name for this logger auto sp = spdlog::get(logname); // retrieve existing one if (sp == nullptr) sp = spdlog::r_sink_mt(logname); // or create new one if needed spdlog::set_default_logger(sp); // and set as default spdlog::stopwatch sw; // instantiate a stop watch // change log pattern (changed from [%H:%M:%S %z] [%n] [%^---%L---%$] ) spdlog::set_pattern("[%H:%M:%S.%f] [%n] [%^%L%$] [thread %t] %v"); spdlog::info("Welcome to spdlog!"); spdlog::error("Some error message with arg: {}", 1); spdlog::info("Elapsed time: {}", sw); spdlog::warn("Easy padding in numbers like {:08d}", 12); spdlog::critical("Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}", 42); spdlog::info("Support for floats {:03.2f}", 1.23456); spdlog::info("Positional args are {1} {0}..", "too", "supported"); spdlog::info("{:<30}", "left aligned"); spdlog::info("Elapsed time: {}", sw); } //' spdlog Logging Lever Setter //' //' A helper function to turn a logging level given as string //' into the current logging level //' //' @param name A string with the logging level. Value understood are, //' in decreasing verbosity \sQuote{trace}, \sQuote{debug}, \sQuote{info}, //' \sQuote{warning}, \sQuote{error}, \sQuote{critical}, and \sQuote{off}. //' Unrecognised names are equivalent to \sQuote{off}. //' @return Nothing is returned. // [[Rcpp::export]] void setLogLevel(const std::string &name) { spdlog::set_level(spdlog::level::from_str(name)); } ``` The example file contains three key aspects to highlight: - use of the `r_sink_mt()` class for R-specific logger sink - use of the very convenient `stopwatch` object - use of logging levels We highlight these below after first showing the relevant output: ```sh R> exampleRsink() [16:52:12.076751] [fromR] [I] [thread 2453030] Welcome to spdlog! [16:52:12.076809] [fromR] [E] [thread 2453030] Some error message with arg: 1 [16:52:12.076823] [fromR] [I] [thread 2453030] Elapsed time: 9.6104e-05 [16:52:12.076833] [fromR] [W] [thread 2453030] Easy padding in numbers like 00000012 [16:52:12.076844] [fromR] [C] [thread 2453030] Support for int: 42; hex: 2a; oct: 52; bin: 101010 [16:52:12.076853] [fromR] [I] [thread 2453030] Support for floats 1.23 [16:52:12.076871] [fromR] [I] [thread 2453030] Positional args are supported too.. [16:52:12.076879] [fromR] [I] [thread 2453030] left aligned [16:52:12.076892] [fromR] [I] [thread 2453030] Elapsed time: 0.000167057 R> ``` #### R-specific sink [spdlog](https://github.com/gabime/spdlog) has the ability to derive and sub-class sinks for logger. The [RcppSpdlog](https://github.com/eddelbuettel/rcppspdlog) package uses this feature to implement a sink using the Rcpp conduit `Rcpp::Rcout` instead of `std::cout` as it conveniently redirects to the R output stream. This class should be the default one for any R packages wanting to use [spdlog](https://github.com/gabime/spdlog) while also passing `R CMD check`. A second important aspect of the initial code in function `exampleRsink()` is how a named logging instance is requested. If none is found, a new one is instantiated. Next, this logger is made the default logger permitting convenient programmatic access via `spdlog::`. #### Stopwatch A powerful (recent) feature of the include [fmt](https://github.com/fmtlib/fmt) library is the automatic formatting of timestamps and interval. As the code example shows, simply instantianting an object, here called `sw`, and referring to it later is all that takes. #### Log-Level A second utility function `setLogLevel()` is also provided. Usage is simple: after calling it with a given level, only message equal to it or higher are shown as the next example shows. ```sh R> setLogLevel("error") R> exampleRsink() [16:54:12.666261] [fromR] [E] [thread 2453030] Some error message with arg: 1 [16:54:12.666286] [fromR] [C] [thread 2453030] Support for int: 42; hex: 2a; oct: 52; bin: 101010 R> ``` By requestion level 'error', message of level 'info', 'warning' or 'debug' are suppressed but messages levels 'error' or 'critical' as shown as desired. ## Fifth Example: Initialization Package desiring to use [RcppSpdlog](https://github.com/eddelbuettel/rcppspdlog) can initialize its facilities during startup. For that we first define a setup function ```c++ // this portmanteau include also defines the r_sink we use below, and which // diverts all logging to R via the Rcpp::Rcout replacement for std::cout #include //' Set a new default logger for R //' // [[Rcpp::export]] void setDefault() { std::string logname = "fromR"; // fix a name for this logger auto sp = spdlog::get(logname); // retrieve existing one if (sp == nullptr) sp = spdlog::r_sink_mt(logname); // or create new one if needed sp->set_pattern("[%H:%M:%S.%f] [%^%L%$] %v"); spdlog::set_default_logger(sp); } ``` We can then call this function during startup: ```r .onLoad <- function(libname, pkgname) { setDefault(); } ``` ## Sixth Example: Compile-time Selection Of course, [spdlog](https://github.com/gabime/spdlog) also supports a common usage paradigm with loggers in which the decision of whether to log or not is _compile-time_ rather than run time. As this is typically implemented via macros, usage is via upper-case macros as well. The following example shows a function with three different logging-level statements as well as a `#define` set such one and only one is shown. Similarly, code can contain debug or trace or info or ... statements which would _not_ appear in the actually loaded "production code" (or CRAN version) if the compile-time logging level define is set high enough. ```c++ // this portmanteau include also defines the r_sink we use below, and which // diverts all logging to R via the Rcpp::Rcout replacement for std::cout #include // A define such as this could also be set in src/Makevars via a -D flag #define SPDLOG_LOG_LEVEL SPDLOG_LEVEL_CRITICAL // [[Rcpp::export]] void demoInvisible() { Rcpp::Rcout << "Hello from demoInvisible, just to show we're being called...\n"; // trace message via default logger SPDLOG_TRACE("Some trace message.. {} ,{}", 1, 3.23); // debug message via default logger SPDLOG_DEBUG("Some debug message.. {} ,{}", 1, 3.23); // debug message via default logger SPDLOG_CRITICAL("Some critical message.. {} ,{}", 1, 3.23); } ``` When a piece of code with such compile-time defines is used, we see the expected outcome. The following example uses default logger, and as the preceding section showed this can be set up to be the custom R sink: ```r R> Rcpp::sourceCpp("/tmp/rcppspdlog.cpp") # plus a '// [[Rcpp:depends("RcppSpdlog")' R> demoInvisible() Hello from demoInvisible, just to show we're being called... [08:44:48.198075] [fromR] [C] [thread 2453030] Some critical message.. 1 ,3.23 R> ``` ## Seventh Example: Access From R As of package 0.0.9, [RcppSpdlog](https://github.com/eddelbuettel/rcppspdlog) supports two new modes. The first is direct logging support from R and described in this section; the second is access from another R package and described thereafter. A number of basic functions are exported using Rcpp. These include `log_setup(name, level)` to instantiate a named logger at a given level (instead of an unnamed default at level 'warn'), `log_filesetup(filename, name, level)` (same using the named file as logging destination), a helper `log_drop(name)` to drop a named logger, two setters `log_set_pattern()` and `log_set_level()` to set, respectively, the displayed log pattern and the level. This is complemented by the actual loggers ranging from `log_trace()` and `log_debug()` to `log_info()`, `log_warn()`, `log_error()` and finally `log_critical()`. The following example (also the example in the manual page) illustrates. ```r > library(RcppSpdlog) > log_setup("demo") # default level 'warn' is used > log_info("this message is NOT seen") > log_set_level("debug") > log_set_pattern("%^[%H:%M:%S.%e] [%n] [%l] %v%$") # set a pattern w/o process id > log_info("this message is seen") [15:55:34.150] [demo] [info] this message is seen > log_warn("as is this message") [ 15:55:37.513] [demo] [warning] as is this message > ``` The interface expects a character value so use from either `sprintf()` or a string-interpolating helper such as `glue::glue` can be used: ```r > log_info(sprintf("We can %s a %s with values %d", "build", "text", 42L)) [16:03:37.728] [demo] [info] We can build a text with values 42 > log_info(glue::glue("We can {a} a {b} with values {v}", a="build", b="text", v=42L)) [16:03:46.395] [demo] [info] We can build a text with values 42 > ``` ## Eight Example: Access From Another R Package As of package 0.0.9, another package can use the C++ level functions (either with or without the R functions) by importing the `RcppSpdlog` while ensuring at least one function from the package is imported (so that the C-level interface functions are instantiated by R). This is time-honoured mechanism long-used by `lme4` to access (compiled) functions from `Matrix` as well as by `xts` to access code from `zoo`, and others. To properly import the package, add just one import, for example `importFrom((RcppSpdlog, log_setup)` to the `NAMESPACE` file of your package, along with the required `Imports: RcppSpdlog` in the `DESCRIPTION` file. The available functions are the same as the ones described in the previous section, but now available at the C++ level in the `RcppSpdlog` namespace. So for example ```c++ #include RcppSpdlog::log_setup("demoLogger", "info"); // create logger at info level RcppSpdlog::log_info("logger created"); ``` will work. ## Nineth Example: More compact C++ Access As the (auto-generated, thanks to `Rcpp`) interface described in the previous section is a little "wordy", we added a simple aliasing wrapping in a new namespace `spdl` and, given the protection from naming collisions offered by the namespace, shortened the accessor function names. So the previous example can also be used via ```c++ #include spdl::setup("demoLogger", "info"); // create logger at info level spdl::info("logger created"); ``` The logger interface takes a simple string. Two easy options exist for formatting such as string. First, one can rely on the [tinyformat](https://github.com/c42f/tinyformat) version included with `Rcpp` and use `tfm::format()` which works with standard `printf()` operators. Second, one can use the `fmt` library included with `spdlog` via an explicit call. ```c++ # using tfm::format spdl::info(tfm::format("We %s values %d and %f", "log", 42, 1.23)); # using fmt::format spdl::info(fmt::format("We {} values {} and {}", "log", 42, 1.23)); ``` Here both formatters have to be called explicitly as we use a simple one-function signature (per logging function) to the underlying C language implementation without the fuller flexibility of variadic arguments. As C++11 can be assumed, we can also offers a variadic template expansion for `fmt::format()` and the second example simply becomes ```c++ spdl::info("We {} values {} and {}", "log", 42, 1.23); ``` ## Tenth Example: More compact R Access As the more compact access in the previous section is quite compelling we also created a sibbling R package [spd](https://github.com/eddelbuettel/spdl) providing a `spdl` namespace in R allowing _the exact same format strings too`. So ```r spdl::info("We {} values {} and {}", "log", 42L, 1.23); ``` now also works from R using the same formatting string. We inted to upload `spdl` to CRAN too. Note that other all other formatting options are supported from R: the first argument is a character variable which can be constructed using `paste`, `sprintf`, or any of the string-interpolating packages. But as none of those methods works like [fmt](https://github.com/fmtlib/fmt) (which we have come to like a lot) we added support for it too. ## Eleventh Example: Stopwatch Support in R and C++ As shown above, [spdlog](https://github.com/gabime/spdlog) supports a 'stopwatch' in C++. Usage is straightforward: one first instantiates an object of type `stopwatch` (make sure to first include the appropriate header too!) and then reports elapsed time by including the `stopwatch` object in the logger. We wrap this `spdlog::stopwatch` object in an external pointer to make it accessible from R. Moreover, by creating it as a S3 object we can add a `format()` method to make the usage pattern identical to the use in C++. So in R we now have ```r sw <- RcppSpdlog::get_stopwatch() Sys.sleep(0.2) RcppSpdlog::log_warn("Elapsed time via stopwatch: {}", sw) ``` This also works in C++. ```c++ auto sw = RcppSpdlog::get_stopwatch(); // returns XPtr Introduction to RcppSpdlog

Introduction to RcppSpdlog

Dirk Eddelbuettel

Initial version dated October 2020. Expanded November 2022.

Introducing RcppSpdlog

spdlog is a widely-used and very capable header-only C++ library for logging. The RcppSpdlog package provides R users with easy-to-use customized access to the spdlog logging library by including its headers in an R package which permit other R packages to deploy it via a simple LinkingTo: RcppSpdlog as described in Section 1.1.3 of WRE.

spdlog is mature and widely deployed. It also has a very rich set of features described at the repository wiki. This vignette will highlight a few first use cases.

Note that in order to use RcppSpdlog in an R package that might get distributed to CRAN, the code should follow the example R and C++ code in function exampleRsink() as described below.

We will however start with some simpler examples. Do not copy those into your R package. The package checks used by R test for use of stdout and stderr which is why the customized setup described later is preferable.

Initial example: Basics

This example follows the simplest and initial example in the spdlog. It is also included in the RcppSpdlog package as examples/exampleOne.cpp. As discussed above, do not use this example as a starting point in an R package.

// based on the 'basic usage' example in the README.md at https://github.com/gabime/spdlog

#include "spdlog/spdlog.h"

#include <Rcpp.h>

// [[Rcpp::depends(RcppSpdlog)]]

// [[Rcpp::export]]
void exampleOne() {

  // change log pattern (changed from [%H:%M:%S %z] [%n] [%^---%L---%$] )
  spdlog::set_pattern("[%H:%M:%S.%f] [%L] [thread %t] %v");

  spdlog::info("Welcome to spdlog!");
  spdlog::error("Some error message with arg: {}", 1);

  spdlog::warn("Easy padding in numbers like {:08d}", 12);
  spdlog::critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
  spdlog::info("Support for floats {:03.2f}", 1.23456);
  spdlog::info("Positional args are {1} {0}..", "too", "supported");
  spdlog::info("{:<30}", "left aligned");

  spdlog::set_level(spdlog::level::debug); // Set global log level to debug
  spdlog::debug("This message should be displayed..");

  // Compile time log levels
  // define SPDLOG_ACTIVE_LEVEL to desired level
  SPDLOG_TRACE("Some trace message with param {}", {});
  SPDLOG_DEBUG("Some debug message");

}

/*** R
exampleOne()
*/

When built, which is easiest via Rcpp::sourceCpp(), the final block ensures that the created function exampleOne() is executed. In one previous run, the following output was produded:

R> exampleOne()
[14:25:03.362024] [I] [thread 2453030] Welcome to spdlog!
[14:25:03.362047] [E] [thread 2453030] Some error message with arg: 1
[14:25:03.362051] [W] [thread 2453030] Easy padding in numbers like 00000012
[14:25:03.362053] [C] [thread 2453030] Support for int: 42;  hex: 2a;  oct: 52; bin: 101010
[14:25:03.362056] [I] [thread 2453030] Support for floats 1.23
[14:25:03.362058] [I] [thread 2453030] Positional args are supported too..
[14:25:03.362060] [I] [thread 2453030] left aligned
[14:25:03.362061] [D] [thread 2453030] This message should be displayed..
R>

We note the easy-to-formatting in the source which benefits from the embedded fmt package for easy-to-use variable expansion. We also notice the different logging “levels” indicated by single letters: info, errror, warning, critical and debug. More on this below.

Second example: Showcase

This second example follows a more complete example in the spdlog documention and highlights numerous features of the library. As before, this example is also included in the RcppSpdlog package as examples/exampleTwo.cpp. And as before, do not use this example as a starting point in an R package.

#include "spdlog/spdlog.h"

#include <Rcpp.h>

void stdout_logger_example();
void basic_example();
void rotating_example();
void daily_example();
void async_example();
void binary_example();
void trace_example();
void multi_sink_example();
void user_defined_example();
void err_handler_example();
void syslog_example();
void clone_example();

#include "spdlog/spdlog.h"

// [[Rcpp::depends(RcppSpdlog)]]

// [[Rcpp::export]]
void exampleTwo() {

    spdlog::info("Welcome to spdlog version {}.{}.{} !",
                 SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR, SPDLOG_VER_PATCH);
    spdlog::warn("Easy padding in numbers like {:08d}", 12);
    spdlog::critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
    spdlog::info("Support for floats {:03.2f}", 1.23456);
    spdlog::info("Positional args are {1} {0}..", "too", "supported");
    spdlog::info("{:>8} aligned, {:<8} aligned", "right", "left");

    // Runtime log levels
    spdlog::set_level(spdlog::level::info); // Set global log level to info
    spdlog::debug("This message should not be displayed!");
    spdlog::set_level(spdlog::level::trace); // Set specific logger's log level
    spdlog::debug("This message should be displayed..");

    // Customize msg format for all loggers
    spdlog::set_pattern("[%H:%M:%S %z] [%^%L%$] [thread %t] %v");
    spdlog::info("This an info message with custom format");
    spdlog::set_pattern("%+"); // back to default format

    try
    {
        stdout_logger_example();
        basic_example();
        rotating_example();
        daily_example();
        clone_example();
        async_example();
        binary_example();
        multi_sink_example();
        user_defined_example();
        err_handler_example();
        trace_example();

        // Flush all *registered* loggers using a worker thread every 3 seconds.
        // note: registered loggers *must* be thread safe for this to work correctly!
        spdlog::flush_every(std::chrono::seconds(3));

        // Apply some function on all registered loggers
        spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) { l->info("End of example."); });

        // Release all spdlog resources, and drop all loggers in the registry.
        // This is optional (only mandatory if using windows + async log).
        //spdlog::shutdown();
    }

    // Exceptions will only be thrown upon failed logger or sink construction (not during logging).
    catch (const spdlog::spdlog_ex &ex)
    {
        std::printf("Log initialization failed: %s\n", ex.what());
        return;
    }

    // added to this example file allow multiple runs of function
    spdlog::drop("console");
    spdlog::drop("file_logger");
    spdlog::drop("some_logger_name");
    spdlog::drop("daily_logger");
    spdlog::drop("async_file_logger");
}


#include "spdlog/sinks/stdout_color_sinks.h"
// or #include "spdlog/sinks/stdout_sinks.h" if no colors needed.
void stdout_logger_example()
{
    // Create color multi threaded logger.
    auto console = spdlog::stdout_color_mt("console");
    // or for stderr:
    // auto console = spdlog::stderr_color_mt("error-logger");
}

#include "spdlog/sinks/basic_file_sink.h"
void basic_example()
{
    // Create basic file logger (not rotated).
    auto my_logger = spdlog::basic_logger_mt("file_logger", "logs/basic-log.txt");
}

#include "spdlog/sinks/rotating_file_sink.h"
void rotating_example()
{
    // Create a file rotating logger with 5mb size max and 3 rotated files.
    auto rotating_logger =
        spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3);
}

#include "spdlog/sinks/daily_file_sink.h"
void daily_example()
{
    // Create a daily logger - a new file is created every day on 2:30am.
    auto daily_logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
}

// Clone a logger and give it new name.
// Useful for creating component/subsystem loggers from some "root" logger.
void clone_example()
{
    auto network_logger = spdlog::default_logger()->clone("network");
    network_logger->info("Logging network stuff..");
}

#include "spdlog/async.h"
void async_example()
{
    // Default thread pool settings can be modified *before* creating the async logger:
    // spdlog::init_thread_pool(32768, 1); // queue with max 32k items 1 backing thread.
    auto async_file =
        spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt");
    // alternatively:
    // auto async_file =
    //     spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("async_file_logger",
    //     "logs/async_log.txt");

    for (int i = 1; i < 101; ++i)
    {
        async_file->info("Async message #{}", i);
    }
}

// Log binary data as hex.
// Many types of std::container<char> types can be used.
// Iterator ranges are supported too.
// Format flags:
// {:X} - print in uppercase.
// {:s} - don't separate each byte with space.
// {:p} - don't print the position on each line start.
// {:n} - don't split the output to lines.

#include "spdlog/fmt/bin_to_hex.h"
void binary_example()
{
    std::vector<char> buf;
    for (int i = 0; i < 80; i++)
    {
        buf.push_back(static_cast<char>(i & 0xff));
    }
    spdlog::info("Binary example: {}", spdlog::to_hex(buf));
    spdlog::info("Another binary example:{:n}",
                 spdlog::to_hex(std::begin(buf), std::begin(buf) + 10));
    // more examples:
    // logger->info("uppercase: {:X}", spdlog::to_hex(buf));
    // logger->info("uppercase, no delimiters: {:Xs}", spdlog::to_hex(buf));
    // logger->info("uppercase, no delimiters, no position info: {:Xsp}", spdlog::to_hex(buf));
}

// Compile time log levels.
// define SPDLOG_ACTIVE_LEVEL to required level (e.g. SPDLOG_LEVEL_TRACE)
void trace_example()
{
    // trace from default logger
    SPDLOG_TRACE("Some trace message.. {} ,{}", 1, 3.23);
    // debug from default logger
    SPDLOG_DEBUG("Some debug message.. {} ,{}", 1, 3.23);

    // trace from logger object
    auto logger = spdlog::get("file_logger");
    SPDLOG_LOGGER_TRACE(logger, "another trace message");
}

// A logger with multiple sinks (stdout and file) - each with a different format and log level.
void multi_sink_example()
{
    auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
    console_sink->set_level(spdlog::level::warn);
    console_sink->set_pattern("[multi_sink_example] [%^%l%$] %v");

    auto file_sink =
        std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/multisink.txt", true);
    file_sink->set_level(spdlog::level::trace);

    spdlog::logger logger("multi_sink", {console_sink, file_sink});
    logger.set_level(spdlog::level::debug);
    logger.warn("this should appear in both console and file");
    logger.info("this message should not appear in the console, only in the file");
}

// User defined types logging by implementing operator<<
#include "spdlog/fmt/ostr.h" // must be included
struct my_type
{
    int i;
    template<typename OStream>
    friend OStream &operator<<(OStream &os, const my_type &c)
    {
        return os << "[my_type i=" << c.i << "]";
    }
};

void user_defined_example()
{
    spdlog::info("user defined type: {}", my_type{14});
}

// Custom error handler. Will be triggered on log failure.
void err_handler_example()
{
    // can be set globally or per logger(logger->set_error_handler(..))
    spdlog::set_error_handler([](const std::string &msg) {
         printf("*** Custom log error handler: %s ***\n", msg.c_str()); });
}

// syslog example (linux/osx/freebsd)
#ifndef _WIN32
#include "spdlog/sinks/syslog_sink.h"
void syslog_example()
{
    std::string ident = "spdlog-example";
    auto syslog_logger = spdlog::syslog_logger_mt("syslog", ident, LOG_PID);
    syslog_logger->warn("This is warning that will end up in syslog.");
}
#endif

// Android example.
#if defined(__ANDROID__)
#include "spdlog/sinks/android_sink.h"
void android_example()
{
    std::string tag = "spdlog-android";
    auto android_logger = spdlog::android_logger_mt("android", tag);
    android_logger->critical("Use \"adb shell logcat\" to view this message.");
}

#endif


/*** R
exampleTwo()
*/

We are not showing the output here; it can be compiled, linked, loaded and run just as above by simply passing the filename to Rcpp::sourceCpp(). Note that is will create a few demonstration logfiles so you may want to run the example from a temporary directory.

Third example: Colour

The next example highlights a colour ‘sink’ for the logger. Again, do not use this as a starting point for your package as R CMD check will protest about use of stdout.

#include "spdlog/spdlog.h"
#include "spdlog/sinks/stdout_color_sinks.h"

#include <Rcpp.h>

// [[Rcpp::depends(RcppSpdlog)]]

// [[Rcpp::export]]
void exampleThree() {

  auto console = spdlog::stdout_color_mt("console");

  // change log pattern (changed from [%H:%M:%S %z] [%n] [%^---%L---%$] )
  spdlog::set_pattern("[%H:%M:%S.%f] [%^%L%$] [thread %t] %v");
  spdlog::info("This an info message with custom format");
  //spdlog::set_pattern("%+"); // back to default format

  spdlog::info("Welcome to spdlog!");
  spdlog::error("Some error message with arg: {}", 1);

  spdlog::warn("Easy padding in numbers like {:08d}", 12);
  spdlog::critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
  spdlog::info("Support for floats {:03.2f}", 1.23456);
  spdlog::info("Positional args are {1} {0}..", "too", "supported");
  spdlog::info("{:<30}", "left aligned");


  // added to this example file allow multiple runs of different package functions
  spdlog::drop("console");

}

/*** R
exampleThree()
*/

When running this example in a terminal capable of displaying colour escape sequence, the logging levels are distinguished by colour. This ranges from green (“info”) to yellow (“warning”) to red (“error”) and white-on-red (“critical”). Not that in this vignette color from standard output does how not show (in the keep-it-simple-mode we are using here).

R> exampleThree()
[14:47:52.260692] [I] [thread 2502026] This an info message with custom format
[14:47:52.260715] [I] [thread 2502026] Welcome to spdlog!
[14:47:52.260732] [E] [thread 2502026] Some error message with arg: 1
[14:47:52.260734] [W] [thread 2502026] Easy padding in numbers like 00000012
[14:47:52.260736] [C] [thread 2502026] Support for int: 42;  hex: 2a;  oct: 52; bin: 101010
[14:47:52.260739] [I] [thread 2502026] Support for floats 1.23
[14:47:52.260741] [I] [thread 2502026] Positional args are supported too..
[14:47:52.260743] [I] [thread 2502026] left aligned
R>

Fourth Example: Dedicated R Logger

The next example is suitable for use in R packages, and in fact included as an example in the package. We include the source file src/exampleRsink.cpp.

// this portmanteau include also defines the r_sink we use below, and which
// diverts all logging to R via the Rcpp::Rcout replacement for std::cout
#include <RcppSpdlog>
#include <spdlog/stopwatch.h>           // also support stopwatch feature

//' spdlog Example using a sink for R
//'
//' A simple example invoking a derived R/Rcpp logger. Also demonstrates the
//' stopwatch feature. For more features see the 'spdlog' documnetation.
//'
//' Note that this no longer triggers R warnings thanks to excellent help by
//' Gabi Melman.
//' @return None
//' @examples
//' exampleRsink()
// [[Rcpp::export]]
void exampleRsink() {

    std::string logname = "fromR";                          // fix a name for this logger
    auto sp = spdlog::get(logname);                         // retrieve existing one
    if (sp == nullptr) sp = spdlog::r_sink_mt(logname);     // or create new one if needed
    spdlog::set_default_logger(sp);                         // and set as default

    spdlog::stopwatch sw;                                   // instantiate a stop watch

    // change log pattern (changed from [%H:%M:%S %z] [%n] [%^---%L---%$] )
    spdlog::set_pattern("[%H:%M:%S.%f] [%n] [%^%L%$] [thread %t] %v");

    spdlog::info("Welcome to spdlog!");
    spdlog::error("Some error message with arg: {}", 1);
    spdlog::info("Elapsed time: {}", sw);

    spdlog::warn("Easy padding in numbers like {:08d}", 12);
    spdlog::critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
    spdlog::info("Support for floats {:03.2f}", 1.23456);
    spdlog::info("Positional args are {1} {0}..", "too", "supported");
    spdlog::info("{:<30}", "left aligned");
    spdlog::info("Elapsed time: {}", sw);

}

//' spdlog Logging Lever Setter
//'
//' A helper function to turn a logging level given as string
//' into the current logging level
//'
//' @param name A string with the logging level. Value understood are,
//' in decreasing verbosity \sQuote{trace}, \sQuote{debug}, \sQuote{info},
//' \sQuote{warning}, \sQuote{error}, \sQuote{critical}, and \sQuote{off}.
//' Unrecognised names are equivalent to \sQuote{off}.
//' @return Nothing is returned.
// [[Rcpp::export]]
void setLogLevel(const std::string &name) {
    spdlog::set_level(spdlog::level::from_str(name));
}

The example file contains three key aspects to highlight: - use of the r_sink_mt() class for R-specific logger sink - use of the very convenient stopwatch object - use of logging levels

We highlight these below after first showing the relevant output:

R> exampleRsink()
[16:52:12.076751] [fromR] [I] [thread 2453030] Welcome to spdlog!
[16:52:12.076809] [fromR] [E] [thread 2453030] Some error message with arg: 1
[16:52:12.076823] [fromR] [I] [thread 2453030] Elapsed time: 9.6104e-05
[16:52:12.076833] [fromR] [W] [thread 2453030] Easy padding in numbers like 00000012
[16:52:12.076844] [fromR] [C] [thread 2453030] Support for int: 42;  hex: 2a;  oct: 52; bin: 101010
[16:52:12.076853] [fromR] [I] [thread 2453030] Support for floats 1.23
[16:52:12.076871] [fromR] [I] [thread 2453030] Positional args are supported too..
[16:52:12.076879] [fromR] [I] [thread 2453030] left aligned
[16:52:12.076892] [fromR] [I] [thread 2453030] Elapsed time: 0.000167057
R>

R-specific sink

spdlog has the ability to derive and sub-class sinks for logger. The RcppSpdlog package uses this feature to implement a sink using the Rcpp conduit Rcpp::Rcout instead of std::cout as it conveniently redirects to the R output stream. This class should be the default one for any R packages wanting to use spdlog while also passing R CMD check.

A second important aspect of the initial code in function exampleRsink() is how a named logging instance is requested. If none is found, a new one is instantiated. Next, this logger is made the default logger permitting convenient programmatic access via spdlog::.

Stopwatch

A powerful (recent) feature of the include fmt library is the automatic formatting of timestamps and interval. As the code example shows, simply instantianting an object, here called sw, and referring to it later is all that takes.

Log-Level

A second utility function setLogLevel() is also provided. Usage is simple: after calling it with a given level, only message equal to it or higher are shown as the next example shows.

R> setLogLevel("error")
R> exampleRsink()
[16:54:12.666261] [fromR] [E] [thread 2453030] Some error message with arg: 1
[16:54:12.666286] [fromR] [C] [thread 2453030] Support for int: 42;  hex: 2a;  oct: 52; bin: 101010
R>

By requestion level ‘error’, message of level ‘info’, ‘warning’ or ‘debug’ are suppressed but messages levels ‘error’ or ‘critical’ as shown as desired.

Fifth Example: Initialization

Package desiring to use RcppSpdlog can initialize its facilities during startup.

For that we first define a setup function

// this portmanteau include also defines the r_sink we use below, and which
// diverts all logging to R via the Rcpp::Rcout replacement for std::cout
#include <RcppSpdlog>

//' Set a new default logger for R
//'
// [[Rcpp::export]]
void setDefault() {
    std::string logname = "fromR";                          // fix a name for this logger
    auto sp = spdlog::get(logname);                         // retrieve existing one
    if (sp == nullptr) sp = spdlog::r_sink_mt(logname);     // or create new one if needed
    sp->set_pattern("[%H:%M:%S.%f] [%^%L%$] %v");
    spdlog::set_default_logger(sp);
}

We can then call this function during startup:

.onLoad <- function(libname, pkgname) {
    setDefault();
}

Sixth Example: Compile-time Selection

Of course, spdlog also supports a common usage paradigm with loggers in which the decision of whether to log or not is compile-time rather than run time. As this is typically implemented via macros, usage is via upper-case macros as well.

The following example shows a function with three different logging-level statements as well as a #define set such one and only one is shown. Similarly, code can contain debug or trace or info or … statements which would not appear in the actually loaded “production code” (or CRAN version) if the compile-time logging level define is set high enough.

// this portmanteau include also defines the r_sink we use below, and which
// diverts all logging to R via the Rcpp::Rcout replacement for std::cout
#include <RcppSpdlog>

// A define such as this could also be set in src/Makevars via a -D flag
#define SPDLOG_LOG_LEVEL  SPDLOG_LEVEL_CRITICAL

// [[Rcpp::export]]
void demoInvisible() {
    Rcpp::Rcout << "Hello from demoInvisible, just to show we're being called...\n";

    // trace message via default logger
    SPDLOG_TRACE("Some trace message.. {} ,{}", 1, 3.23);
    // debug message via default logger
    SPDLOG_DEBUG("Some debug message.. {} ,{}", 1, 3.23);
    // debug message via default logger
    SPDLOG_CRITICAL("Some critical message.. {} ,{}", 1, 3.23);
}

When a piece of code with such compile-time defines is used, we see the expected outcome. The following example uses default logger, and as the preceding section showed this can be set up to be the custom R sink:

R> Rcpp::sourceCpp("/tmp/rcppspdlog.cpp")  # plus a '// [[Rcpp:depends("RcppSpdlog")'
R> demoInvisible()
Hello from demoInvisible, just to show we're being called...
[08:44:48.198075] [fromR] [C] [thread 2453030] Some critical message.. 1 ,3.23
R>

Seventh Example: Access From R

As of package 0.0.9, RcppSpdlog supports two new modes. The first is direct logging support from R and described in this section; the second is access from another R package and described thereafter. A number of basic functions are exported using Rcpp. These include log_setup(name, level) to instantiate a named logger at a given level (instead of an unnamed default at level ‘warn’), log_filesetup(filename, name, level) (same using the named file as logging destination), a helper log_drop(name) to drop a named logger, two setters log_set_pattern() and log_set_level() to set, respectively, the displayed log pattern and the level. This is complemented by the actual loggers ranging from log_trace() and log_debug() to log_info(), log_warn(), log_error() and finally log_critical().

The following example (also the example in the manual page) illustrates.

> library(RcppSpdlog)
> log_setup("demo")                     # default level 'warn' is used
> log_info("this message is NOT seen")
> log_set_level("debug")
> log_set_pattern("%^[%H:%M:%S.%e] [%n] [%l] %v%$")  # set a pattern w/o process id
> log_info("this message is seen")
[15:55:34.150] [demo] [info] this message is seen
> log_warn("as is this message")
[ 15:55:37.513] [demo] [warning] as is this message
>

The interface expects a character value so use from either sprintf() or a string-interpolating helper such as glue::glue can be used:

> log_info(sprintf("We can %s a %s with values %d", "build", "text", 42L))
[16:03:37.728] [demo] [info] We can build a text with values 42
> log_info(glue::glue("We can {a} a {b} with values {v}", a="build", b="text", v=42L))
[16:03:46.395] [demo] [info] We can build a text with values 42
>

Eight Example: Access From Another R Package

As of package 0.0.9, another package can use the C++ level functions (either with or without the R functions) by importing the RcppSpdlog while ensuring at least one function from the package is imported (so that the C-level interface functions are instantiated by R). This is time-honoured mechanism long-used by lme4 to access (compiled) functions from Matrix as well as by xts to access code from zoo, and others.

To properly import the package, add just one import, for example importFrom((RcppSpdlog, log_setup) to the NAMESPACE file of your package, along with the required Imports: RcppSpdlog in the DESCRIPTION file. The available functions are the same as the ones described in the previous section, but now available at the C++ level in the RcppSpdlog namespace. So for example

#include <RcppSpdlog.h>

RcppSpdlog::log_setup("demoLogger", "info");    // create logger at info level
RcppSpdlog::log_info("logger created");

will work.

Nineth Example: More compact C++ Access

As the (auto-generated, thanks to Rcpp) interface described in the previous section is a little “wordy”, we added a simple aliasing wrapping in a new namespace spdl and, given the protection from naming collisions offered by the namespace, shortened the accessor function names. So the previous example can also be used via

#include <spdl.h>

spdl::setup("demoLogger", "info");  // create logger at info level
spdl::info("logger created");

The logger interface takes a simple string. Two easy options exist for formatting such as string. First, one can rely on the tinyformat version included with Rcpp and use tfm::format() which works with standard printf() operators. Second, one can use the fmt library included with spdlog via an explicit call.

# using tfm::format
spdl::info(tfm::format("We %s values %d and %f", "log", 42, 1.23));
# using fmt::format
spdl::info(fmt::format("We {} values {} and {}", "log", 42, 1.23));

Here both formatters have to be called explicitly as we use a simple one-function signature (per logging function) to the underlying C language implementation without the fuller flexibility of variadic arguments.

As C++11 can be assumed, we can also offers a variadic template expansion for fmt::format() and the second example simply becomes

spdl::info("We {} values {} and {}", "log", 42, 1.23);

Tenth Example: More compact R Access

As the more compact access in the previous section is quite compelling we also created a sibbling R package spd providing a spdl namespace in R allowing _the exact same format strings too`.

So

spdl::info("We {} values {} and {}", "log", 42L, 1.23);

now also works from R using the same formatting string. We inted to upload spdl to CRAN too.

Note that other all other formatting options are supported from R: the first argument is a character variable which can be constructed using paste, sprintf, or any of the string-interpolating packages. But as none of those methods works like fmt (which we have come to like a lot) we added support for it too.

Eleventh Example: Stopwatch Support in R and C++

As shown above, spdlog supports a ‘stopwatch’ in C++. Usage is straightforward: one first instantiates an object of type stopwatch (make sure to first include the appropriate header too!) and then reports elapsed time by including the stopwatch object in the logger.

We wrap this spdlog::stopwatch object in an external pointer to make it accessible from R. Moreover, by creating it as a S3 object we can add a format() method to make the usage pattern identical to the use in C++. So in R we now have

sw <- RcppSpdlog::get_stopwatch()
Sys.sleep(0.2)
RcppSpdlog::log_warn("Elapsed time via stopwatch: {}", sw)

This also works in C++.

auto sw = RcppSpdlog::get_stopwatch();  // returns XPtr<spdlog::stopwatch
usleep(200);                            // from unistd.h
RcppSpdlog::log_warn("Elapsed", RcppSpdlog::format_stopwatch(sw));

Note that in that last line we need to explicitly call a formatter as we do not get the templated formatter from spdlog as our object is an external-pointer wrapped object.

We also export this via the spdl.h wrapper. So the same C++ functionality is also available as

auto sw = spdl::stopwatch();  // returns XPtr<spdlog::stopwatch
usleep(200);                  // from unistd.h
spdl::warn("Elapsed", spdl::format(sw));

And because the spdl package wraps this for R, we can do the same in R:

sw <- spdl::stopwatch()
Sys.sleep(0.2)
spdl::warn("Elapsed: {}", sw)

which once again takes advantage of the S3 class and its format() method.

Conclusion

spdlog and the included fmt are two very powerful and widely used C++ libraries. The RcppSpdlog package adds to them to the set of packages R users can deploy. The spd package makes access even easier and more consistent. It is our hope that the examples shown here are of interest to R users who are looking for effortless, performant and flexible logging solutions for their R packages.

RcppSpdlog/inst/COPYRIGHTS0000644000176200001440000000641013723456442014735 0ustar liggesusersOverall license: ================ The aggregation, integration and packaging work is released under the GNU GPL (>= 2) Details: ======== Files: inst/include/spdlog/* Copyright: (c) 2014-2020 Gabi Melman Copyright: (c) 2015-present, Gabi Melman & spdlog contributors The MIT License (MIT) Copyright (c) 2016 Gabi Melman. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -- NOTE: Third party dependency used by this software -- This software depends on the fmt lib (MIT License), and users must comply to its license: https://github.com/fmtlib/fmt/blob/master/LICENSE.rst Files: inst/include/spdlog/fmt/bundled/* Copyright: (c) 2012 - present, Victor Zverovic Copyright (c) 2012 - present, Victor Zverovich Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. --- Optional exception to the license --- As an exception, if, as a result of your compiling your source code, portions of this Software are embedded into a machine-executable object form of such source code, you may redistribute such embedded portions in such object form without including the above copyright and permission notices. Other included files also carry the MIT License (http://opensource.org/licenses/MIT) RcppSpdlog/inst/include/0000755000176200001440000000000014442073414014732 5ustar liggesusersRcppSpdlog/inst/include/spdlog/0000755000176200001440000000000014612660532016224 5ustar liggesusersRcppSpdlog/inst/include/spdlog/async_logger-inl.h0000644000176200001440000000564214612604314021634 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifndef SPDLOG_HEADER_ONLY #include #endif #include #include #include #include SPDLOG_INLINE spdlog::async_logger::async_logger(std::string logger_name, sinks_init_list sinks_list, std::weak_ptr tp, async_overflow_policy overflow_policy) : async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(), std::move(tp), overflow_policy) {} SPDLOG_INLINE spdlog::async_logger::async_logger(std::string logger_name, sink_ptr single_sink, std::weak_ptr tp, async_overflow_policy overflow_policy) : async_logger( std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy) {} // send the log message to the thread pool SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg){ SPDLOG_TRY{if (auto pool_ptr = thread_pool_.lock()){ pool_ptr->post_log(shared_from_this(), msg, overflow_policy_); } else { throw_spdlog_ex("async log: thread pool doesn't exist anymore"); } } SPDLOG_LOGGER_CATCH(msg.source) } // send flush request to the thread pool SPDLOG_INLINE void spdlog::async_logger::flush_(){SPDLOG_TRY{auto pool_ptr = thread_pool_.lock(); if (!pool_ptr) { throw_spdlog_ex("async flush: thread pool doesn't exist anymore"); } std::future future = pool_ptr->post_flush(shared_from_this(), overflow_policy_); // Wait for the flush operation to complete. // This might throw exception if the flush message get dropped because of overflow. future.get(); } SPDLOG_LOGGER_CATCH(source_loc()) } // // backend functions - called from the thread pool to do the actual job // SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg) { for (auto &sink : sinks_) { if (sink->should_log(msg.level)) { SPDLOG_TRY { sink->log(msg); } SPDLOG_LOGGER_CATCH(msg.source) } } if (should_flush_(msg)) { backend_flush_(); } } SPDLOG_INLINE void spdlog::async_logger::backend_flush_() { for (auto &sink : sinks_) { SPDLOG_TRY { sink->flush(); } SPDLOG_LOGGER_CATCH(source_loc()) } } SPDLOG_INLINE std::shared_ptr spdlog::async_logger::clone(std::string new_name) { auto cloned = std::make_shared(*this); cloned->name_ = std::move(new_name); return cloned; } RcppSpdlog/inst/include/spdlog/formatter.h0000644000176200001440000000071714550234366020410 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include namespace spdlog { class formatter { public: virtual ~formatter() = default; virtual void format(const details::log_msg &msg, memory_buf_t &dest) = 0; virtual std::unique_ptr clone() const = 0; }; } // namespace spdlog RcppSpdlog/inst/include/spdlog/details/0000755000176200001440000000000014612604314017645 5ustar liggesusersRcppSpdlog/inst/include/spdlog/details/null_mutex.h0000644000176200001440000000164214550234366022224 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include // null, no cost dummy "mutex" and dummy "atomic" int namespace spdlog { namespace details { struct null_mutex { void lock() const {} void unlock() const {} }; struct null_atomic_int { int value; null_atomic_int() = default; explicit null_atomic_int(int new_value) : value(new_value) {} int load(std::memory_order = std::memory_order_relaxed) const { return value; } void store(int new_value, std::memory_order = std::memory_order_relaxed) { value = new_value; } int exchange(int new_value, std::memory_order = std::memory_order_relaxed) { std::swap(new_value, value); return new_value; // return value before the call } }; } // namespace details } // namespace spdlog RcppSpdlog/inst/include/spdlog/details/udp_client-windows.h0000644000176200001440000000607614550234366023654 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once // Helper RAII over winsock udp client socket. // Will throw on construction if socket creation failed. #include #include #include #include #include #include #include #include #if defined(_MSC_VER) #pragma comment(lib, "Ws2_32.lib") #pragma comment(lib, "Mswsock.lib") #pragma comment(lib, "AdvApi32.lib") #endif namespace spdlog { namespace details { class udp_client { static constexpr int TX_BUFFER_SIZE = 1024 * 10; SOCKET socket_ = INVALID_SOCKET; sockaddr_in addr_ = {}; static void init_winsock_() { WSADATA wsaData; auto rv = ::WSAStartup(MAKEWORD(2, 2), &wsaData); if (rv != 0) { throw_winsock_error_("WSAStartup failed", ::WSAGetLastError()); } } static void throw_winsock_error_(const std::string &msg, int last_error) { char buf[512]; ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, last_error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL); throw_spdlog_ex(fmt_lib::format("udp_sink - {}: {}", msg, buf)); } void cleanup_() { if (socket_ != INVALID_SOCKET) { ::closesocket(socket_); } socket_ = INVALID_SOCKET; ::WSACleanup(); } public: udp_client(const std::string &host, uint16_t port) { init_winsock_(); addr_.sin_family = PF_INET; addr_.sin_port = htons(port); addr_.sin_addr.s_addr = INADDR_ANY; if (InetPtonA(PF_INET, host.c_str(), &addr_.sin_addr.s_addr) != 1) { int last_error = ::WSAGetLastError(); ::WSACleanup(); throw_winsock_error_("error: Invalid address!", last_error); } socket_ = ::socket(PF_INET, SOCK_DGRAM, 0); if (socket_ == INVALID_SOCKET) { int last_error = ::WSAGetLastError(); ::WSACleanup(); throw_winsock_error_("error: Create Socket failed", last_error); } int option_value = TX_BUFFER_SIZE; if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF, reinterpret_cast(&option_value), sizeof(option_value)) < 0) { int last_error = ::WSAGetLastError(); cleanup_(); throw_winsock_error_("error: setsockopt(SO_SNDBUF) Failed!", last_error); } } ~udp_client() { cleanup_(); } SOCKET fd() const { return socket_; } void send(const char *data, size_t n_bytes) { socklen_t tolen = sizeof(struct sockaddr); if (::sendto(socket_, data, static_cast(n_bytes), 0, (struct sockaddr *)&addr_, tolen) == -1) { throw_spdlog_ex("sendto(2) failed", errno); } } }; } // namespace details } // namespace spdlog RcppSpdlog/inst/include/spdlog/details/registry.h0000644000176200001440000001072314612604314021671 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once // Loggers registry of unique name->logger pointer // An attempt to create a logger with an already existing name will result with spdlog_ex exception. // If user requests a non existing logger, nullptr will be returned // This class is thread safe #include #include #include #include #include #include #include #include #if __cplusplus >= 201703L // C++17 #include #endif namespace spdlog { class logger; namespace details { class thread_pool; class SPDLOG_API registry { public: using log_levels = std::unordered_map; registry(const registry &) = delete; registry &operator=(const registry &) = delete; void register_logger(std::shared_ptr new_logger); void initialize_logger(std::shared_ptr new_logger); std::shared_ptr get(const std::string &logger_name); #if __cplusplus >= 201703L // C++17 std::shared_ptr get(std::string_view logger_name); std::shared_ptr get(const char *logger_name); #endif std::shared_ptr default_logger(); // Return raw ptr to the default logger. // To be used directly by the spdlog default api (e.g. spdlog::info) // This make the default API faster, but cannot be used concurrently with set_default_logger(). // e.g do not call set_default_logger() from one thread while calling spdlog::info() from // another. logger *get_default_raw(); // set default logger and add it to the registry if not registered already. // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map. // Note: Make sure to unregister it when no longer needed or before calling again with a new logger. void set_default_logger(std::shared_ptr new_default_logger); void set_tp(std::shared_ptr tp); std::shared_ptr get_tp(); // Set global formatter. Each sink in each logger will get a clone of this object void set_formatter(std::unique_ptr formatter); void enable_backtrace(size_t n_messages); void disable_backtrace(); void set_level(level::level_enum log_level); void flush_on(level::level_enum log_level); template void flush_every(std::chrono::duration interval) { std::lock_guard lock(flusher_mutex_); auto clbk = [this]() { this->flush_all(); }; periodic_flusher_ = details::make_unique(clbk, interval); } std::unique_ptr &get_flusher() { std::lock_guard lock(flusher_mutex_); return periodic_flusher_; } void set_error_handler(err_handler handler); void apply_all(const std::function)> &fun); void flush_all(); void drop(const std::string &logger_name); void drop_all(); // clean all resources and threads started by the registry void shutdown(); std::recursive_mutex &tp_mutex(); void set_automatic_registration(bool automatic_registration); // set levels for all existing/future loggers. global_level can be null if should not set. void set_levels(log_levels levels, level::level_enum *global_level); static registry &instance(); void apply_logger_env_levels(std::shared_ptr new_logger); private: registry(); ~registry(); void throw_if_exists_(const std::string &logger_name); void register_logger_(std::shared_ptr new_logger); bool set_level_from_cfg_(logger *logger); std::mutex logger_map_mutex_, flusher_mutex_; std::recursive_mutex tp_mutex_; std::unordered_map> loggers_; log_levels log_levels_; std::unique_ptr formatter_; spdlog::level::level_enum global_log_level_ = level::info; level::level_enum flush_level_ = level::off; err_handler err_handler_; std::shared_ptr tp_; std::unique_ptr periodic_flusher_; std::shared_ptr default_logger_; bool automatic_registration_ = true; size_t backtrace_n_messages_ = 0; }; } // namespace details } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY #include "registry-inl.h" #endif RcppSpdlog/inst/include/spdlog/details/windows_include.h0000644000176200001440000000027414550234366023225 0ustar liggesusers#pragma once #ifndef NOMINMAX #define NOMINMAX // prevent windows redefining min/max #endif #ifndef WIN32_LEAN_AND_MEAN #define WIN32_LEAN_AND_MEAN #endif #include RcppSpdlog/inst/include/spdlog/details/file_helper-inl.h0000644000176200001440000001114314550234366023063 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifndef SPDLOG_HEADER_ONLY #include #endif #include #include #include #include #include #include #include #include namespace spdlog { namespace details { SPDLOG_INLINE file_helper::file_helper(const file_event_handlers &event_handlers) : event_handlers_(event_handlers) {} SPDLOG_INLINE file_helper::~file_helper() { close(); } SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate) { close(); filename_ = fname; auto *mode = SPDLOG_FILENAME_T("ab"); auto *trunc_mode = SPDLOG_FILENAME_T("wb"); if (event_handlers_.before_open) { event_handlers_.before_open(filename_); } for (int tries = 0; tries < open_tries_; ++tries) { // create containing folder if not exists already. os::create_dir(os::dir_name(fname)); if (truncate) { // Truncate by opening-and-closing a tmp file in "wb" mode, always // opening the actual log-we-write-to in "ab" mode, since that // interacts more politely with eternal processes that might // rotate/truncate the file underneath us. std::FILE *tmp; if (os::fopen_s(&tmp, fname, trunc_mode)) { continue; } std::fclose(tmp); } if (!os::fopen_s(&fd_, fname, mode)) { if (event_handlers_.after_open) { event_handlers_.after_open(filename_, fd_); } return; } details::os::sleep_for_millis(open_interval_); } throw_spdlog_ex("Failed opening file " + os::filename_to_str(filename_) + " for writing", errno); } SPDLOG_INLINE void file_helper::reopen(bool truncate) { if (filename_.empty()) { throw_spdlog_ex("Failed re opening file - was not opened before"); } this->open(filename_, truncate); } SPDLOG_INLINE void file_helper::flush() { if (std::fflush(fd_) != 0) { throw_spdlog_ex("Failed flush to file " + os::filename_to_str(filename_), errno); } } SPDLOG_INLINE void file_helper::sync() { if (!os::fsync(fd_)) { throw_spdlog_ex("Failed to fsync file " + os::filename_to_str(filename_), errno); } } SPDLOG_INLINE void file_helper::close() { if (fd_ != nullptr) { if (event_handlers_.before_close) { event_handlers_.before_close(filename_, fd_); } std::fclose(fd_); fd_ = nullptr; if (event_handlers_.after_close) { event_handlers_.after_close(filename_); } } } SPDLOG_INLINE void file_helper::write(const memory_buf_t &buf) { if(fd_ == nullptr) return; size_t msg_size = buf.size(); auto data = buf.data(); if (std::fwrite(data, 1, msg_size, fd_) != msg_size) { throw_spdlog_ex("Failed writing to file " + os::filename_to_str(filename_), errno); } } SPDLOG_INLINE size_t file_helper::size() const { if (fd_ == nullptr) { throw_spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(filename_)); } return os::filesize(fd_); } SPDLOG_INLINE const filename_t &file_helper::filename() const { return filename_; } // // return file path and its extension: // // "mylog.txt" => ("mylog", ".txt") // "mylog" => ("mylog", "") // "mylog." => ("mylog.", "") // "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt") // // the starting dot in filenames is ignored (hidden files): // // ".mylog" => (".mylog". "") // "my_folder/.mylog" => ("my_folder/.mylog", "") // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt") SPDLOG_INLINE std::tuple file_helper::split_by_extension( const filename_t &fname) { auto ext_index = fname.rfind('.'); // no valid extension found - return whole path and empty string as // extension if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1) { return std::make_tuple(fname, filename_t()); } // treat cases like "/etc/rc.d/somelogfile or "/abc/.hiddenfile" auto folder_index = fname.find_last_of(details::os::folder_seps_filename); if (folder_index != filename_t::npos && folder_index >= ext_index - 1) { return std::make_tuple(fname, filename_t()); } // finally - return a valid base and extension tuple return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index)); } } // namespace details } // namespace spdlog RcppSpdlog/inst/include/spdlog/details/log_msg.h0000644000176200001440000000226414550234366021460 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include namespace spdlog { namespace details { struct SPDLOG_API log_msg { log_msg() = default; log_msg(log_clock::time_point log_time, source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg); log_msg(source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg); log_msg(string_view_t logger_name, level::level_enum lvl, string_view_t msg); log_msg(const log_msg &other) = default; log_msg &operator=(const log_msg &other) = default; string_view_t logger_name; level::level_enum level{level::off}; log_clock::time_point time; size_t thread_id{0}; // wrapping the formatted text with color (updated by pattern_formatter). mutable size_t color_range_start{0}; mutable size_t color_range_end{0}; source_loc source; string_view_t payload; }; } // namespace details } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY #include "log_msg-inl.h" #endif RcppSpdlog/inst/include/spdlog/details/thread_pool-inl.h0000644000176200001440000001062714612604314023104 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifndef SPDLOG_HEADER_ONLY #include #endif #include #include namespace spdlog { namespace details { SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function on_thread_start, std::function on_thread_stop) : q_(q_max_items) { if (threads_n == 0 || threads_n > 1000) { throw_spdlog_ex( "spdlog::thread_pool(): invalid threads_n param (valid " "range is 1-1000)"); } for (size_t i = 0; i < threads_n; i++) { threads_.emplace_back([this, on_thread_start, on_thread_stop] { on_thread_start(); this->thread_pool::worker_loop_(); on_thread_stop(); }); } } SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function on_thread_start) : thread_pool(q_max_items, threads_n, on_thread_start, [] {}) {} SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n) : thread_pool( q_max_items, threads_n, [] {}, [] {}) {} // message all threads to terminate gracefully join them SPDLOG_INLINE thread_pool::~thread_pool() { SPDLOG_TRY { for (size_t i = 0; i < threads_.size(); i++) { post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block); } for (auto &t : threads_) { t.join(); } } SPDLOG_CATCH_STD } void SPDLOG_INLINE thread_pool::post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy) { async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg); post_async_msg_(std::move(async_m), overflow_policy); } std::future SPDLOG_INLINE thread_pool::post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy) { std::promise promise; std::future future = promise.get_future(); post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush, std::move(promise)), overflow_policy); return future; } size_t SPDLOG_INLINE thread_pool::overrun_counter() { return q_.overrun_counter(); } void SPDLOG_INLINE thread_pool::reset_overrun_counter() { q_.reset_overrun_counter(); } size_t SPDLOG_INLINE thread_pool::discard_counter() { return q_.discard_counter(); } void SPDLOG_INLINE thread_pool::reset_discard_counter() { q_.reset_discard_counter(); } size_t SPDLOG_INLINE thread_pool::queue_size() { return q_.size(); } void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy) { if (overflow_policy == async_overflow_policy::block) { q_.enqueue(std::move(new_msg)); } else if (overflow_policy == async_overflow_policy::overrun_oldest) { q_.enqueue_nowait(std::move(new_msg)); } else { assert(overflow_policy == async_overflow_policy::discard_new); q_.enqueue_if_have_room(std::move(new_msg)); } } void SPDLOG_INLINE thread_pool::worker_loop_() { while (process_next_msg_()) { } } // process next message in the queue // return true if this thread should still be active (while no terminate msg // was received) bool SPDLOG_INLINE thread_pool::process_next_msg_() { async_msg incoming_async_msg; q_.dequeue(incoming_async_msg); switch (incoming_async_msg.msg_type) { case async_msg_type::log: { incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg); return true; } case async_msg_type::flush: { incoming_async_msg.worker_ptr->backend_flush_(); incoming_async_msg.flush_promise.set_value(); return true; } case async_msg_type::terminate: { return false; } default: { assert(false); } } return true; } } // namespace details } // namespace spdlog RcppSpdlog/inst/include/spdlog/details/log_msg_buffer-inl.h0000644000176200001440000000320414550234366023564 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifndef SPDLOG_HEADER_ONLY #include #endif namespace spdlog { namespace details { SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg &orig_msg) : log_msg{orig_msg} { buffer.append(logger_name.begin(), logger_name.end()); buffer.append(payload.begin(), payload.end()); update_string_views(); } SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg_buffer &other) : log_msg{other} { buffer.append(logger_name.begin(), logger_name.end()); buffer.append(payload.begin(), payload.end()); update_string_views(); } SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT : log_msg{other}, buffer{std::move(other.buffer)} { update_string_views(); } SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other) { log_msg::operator=(other); buffer.clear(); buffer.append(other.buffer.data(), other.buffer.data() + other.buffer.size()); update_string_views(); return *this; } SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT { log_msg::operator=(other); buffer = std::move(other.buffer); update_string_views(); return *this; } SPDLOG_INLINE void log_msg_buffer::update_string_views() { logger_name = string_view_t{buffer.data(), logger_name.size()}; payload = string_view_t{buffer.data() + logger_name.size(), payload.size()}; } } // namespace details } // namespace spdlog RcppSpdlog/inst/include/spdlog/details/thread_pool.h0000644000176200001440000000755214612604314022327 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include #include #include #include #include #include #include #include namespace spdlog { class async_logger; namespace details { using async_logger_ptr = std::shared_ptr; enum class async_msg_type { log, flush, terminate }; // Async msg to move to/from the queue // Movable only. should never be copied struct async_msg : log_msg_buffer { async_msg_type msg_type{async_msg_type::log}; async_logger_ptr worker_ptr; std::promise flush_promise; async_msg() = default; ~async_msg() = default; // should only be moved in or out of the queue.. async_msg(const async_msg &) = delete; // support for vs2013 move #if defined(_MSC_VER) && _MSC_VER <= 1800 async_msg(async_msg &&other) : log_msg_buffer(std::move(other)), msg_type(other.msg_type), worker_ptr(std::move(other.worker_ptr)) {} async_msg &operator=(async_msg &&other) { *static_cast(this) = std::move(other); msg_type = other.msg_type; worker_ptr = std::move(other.worker_ptr); return *this; } #else // (_MSC_VER) && _MSC_VER <= 1800 async_msg(async_msg &&) = default; async_msg &operator=(async_msg &&) = default; #endif // construct from log_msg with given type async_msg(async_logger_ptr &&worker, async_msg_type the_type, const details::log_msg &m) : log_msg_buffer{m}, msg_type{the_type}, worker_ptr{std::move(worker)}, flush_promise{} {} async_msg(async_logger_ptr &&worker, async_msg_type the_type) : log_msg_buffer{}, msg_type{the_type}, worker_ptr{std::move(worker)}, flush_promise{} {} async_msg(async_logger_ptr &&worker, async_msg_type the_type, std::promise &&promise) : log_msg_buffer{}, msg_type{the_type}, worker_ptr{std::move(worker)}, flush_promise{std::move(promise)} {} explicit async_msg(async_msg_type the_type) : async_msg{nullptr, the_type} {} }; class SPDLOG_API thread_pool { public: using item_type = async_msg; using q_type = details::mpmc_blocking_queue; thread_pool(size_t q_max_items, size_t threads_n, std::function on_thread_start, std::function on_thread_stop); thread_pool(size_t q_max_items, size_t threads_n, std::function on_thread_start); thread_pool(size_t q_max_items, size_t threads_n); // message all threads to terminate gracefully and join them ~thread_pool(); thread_pool(const thread_pool &) = delete; thread_pool &operator=(thread_pool &&) = delete; void post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy); std::future post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy); size_t overrun_counter(); void reset_overrun_counter(); size_t discard_counter(); void reset_discard_counter(); size_t queue_size(); private: q_type q_; std::vector threads_; void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy); void worker_loop_(); // process next message in the queue // return true if this thread should still be active (while no terminate msg // was received) bool process_next_msg_(); }; } // namespace details } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY #include "thread_pool-inl.h" #endif RcppSpdlog/inst/include/spdlog/details/tcp_client.h0000644000176200001440000000745514550234366022164 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifdef _WIN32 #error include tcp_client-windows.h instead #endif // tcp client helper #include #include #include #include #include #include #include #include #include namespace spdlog { namespace details { class tcp_client { int socket_ = -1; public: bool is_connected() const { return socket_ != -1; } void close() { if (is_connected()) { ::close(socket_); socket_ = -1; } } int fd() const { return socket_; } ~tcp_client() { close(); } // try to connect or throw on failure void connect(const std::string &host, int port) { close(); struct addrinfo hints {}; memset(&hints, 0, sizeof(struct addrinfo)); hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on hints.ai_socktype = SOCK_STREAM; // TCP hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value hints.ai_protocol = 0; auto port_str = std::to_string(port); struct addrinfo *addrinfo_result; auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result); if (rv != 0) { throw_spdlog_ex(fmt_lib::format("::getaddrinfo failed: {}", gai_strerror(rv))); } // Try each address until we successfully connect(2). int last_errno = 0; for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next) { #if defined(SOCK_CLOEXEC) const int flags = SOCK_CLOEXEC; #else const int flags = 0; #endif socket_ = ::socket(rp->ai_family, rp->ai_socktype | flags, rp->ai_protocol); if (socket_ == -1) { last_errno = errno; continue; } rv = ::connect(socket_, rp->ai_addr, rp->ai_addrlen); if (rv == 0) { break; } last_errno = errno; ::close(socket_); socket_ = -1; } ::freeaddrinfo(addrinfo_result); if (socket_ == -1) { throw_spdlog_ex("::connect failed", last_errno); } // set TCP_NODELAY int enable_flag = 1; ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast(&enable_flag), sizeof(enable_flag)); // prevent sigpipe on systems where MSG_NOSIGNAL is not available #if defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL) ::setsockopt(socket_, SOL_SOCKET, SO_NOSIGPIPE, reinterpret_cast(&enable_flag), sizeof(enable_flag)); #endif #if !defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL) #error "tcp_sink would raise SIGPIPE since neither SO_NOSIGPIPE nor MSG_NOSIGNAL are available" #endif } // Send exactly n_bytes of the given data. // On error close the connection and throw. void send(const char *data, size_t n_bytes) { size_t bytes_sent = 0; while (bytes_sent < n_bytes) { #if defined(MSG_NOSIGNAL) const int send_flags = MSG_NOSIGNAL; #else const int send_flags = 0; #endif auto write_result = ::send(socket_, data + bytes_sent, n_bytes - bytes_sent, send_flags); if (write_result < 0) { close(); throw_spdlog_ex("write(2) failed", errno); } if (write_result == 0) // (probably should not happen but in any case..) { break; } bytes_sent += static_cast(write_result); } } }; } // namespace details } // namespace spdlog RcppSpdlog/inst/include/spdlog/details/backtracer-inl.h0000644000176200001440000000372414550234366022714 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifndef SPDLOG_HEADER_ONLY #include #endif namespace spdlog { namespace details { SPDLOG_INLINE backtracer::backtracer(const backtracer &other) { std::lock_guard lock(other.mutex_); enabled_ = other.enabled(); messages_ = other.messages_; } SPDLOG_INLINE backtracer::backtracer(backtracer &&other) SPDLOG_NOEXCEPT { std::lock_guard lock(other.mutex_); enabled_ = other.enabled(); messages_ = std::move(other.messages_); } SPDLOG_INLINE backtracer &backtracer::operator=(backtracer other) { std::lock_guard lock(mutex_); enabled_ = other.enabled(); messages_ = std::move(other.messages_); return *this; } SPDLOG_INLINE void backtracer::enable(size_t size) { std::lock_guard lock{mutex_}; enabled_.store(true, std::memory_order_relaxed); messages_ = circular_q{size}; } SPDLOG_INLINE void backtracer::disable() { std::lock_guard lock{mutex_}; enabled_.store(false, std::memory_order_relaxed); } SPDLOG_INLINE bool backtracer::enabled() const { return enabled_.load(std::memory_order_relaxed); } SPDLOG_INLINE void backtracer::push_back(const log_msg &msg) { std::lock_guard lock{mutex_}; messages_.push_back(log_msg_buffer{msg}); } SPDLOG_INLINE bool backtracer::empty() const { std::lock_guard lock{mutex_}; return messages_.empty(); } // pop all items in the q and apply the given fun on each of them. SPDLOG_INLINE void backtracer::foreach_pop(std::function fun) { std::lock_guard lock{mutex_}; while (!messages_.empty()) { auto &front_msg = messages_.front(); fun(front_msg); messages_.pop_front(); } } } // namespace details } // namespace spdlog RcppSpdlog/inst/include/spdlog/details/circular_q.h0000644000176200001440000000646114612604314022151 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) // circular q view of std::vector. #pragma once #include #include #include "spdlog/common.h" namespace spdlog { namespace details { template class circular_q { size_t max_items_ = 0; typename std::vector::size_type head_ = 0; typename std::vector::size_type tail_ = 0; size_t overrun_counter_ = 0; std::vector v_; public: using value_type = T; // empty ctor - create a disabled queue with no elements allocated at all circular_q() = default; explicit circular_q(size_t max_items) : max_items_(max_items + 1) // one item is reserved as marker for full q , v_(max_items_) {} circular_q(const circular_q &) = default; circular_q &operator=(const circular_q &) = default; // move cannot be default, // since we need to reset head_, tail_, etc to zero in the moved object circular_q(circular_q &&other) SPDLOG_NOEXCEPT { copy_moveable(std::move(other)); } circular_q &operator=(circular_q &&other) SPDLOG_NOEXCEPT { copy_moveable(std::move(other)); return *this; } // push back, overrun (oldest) item if no room left void push_back(T &&item) { if (max_items_ > 0) { v_[tail_] = std::move(item); tail_ = (tail_ + 1) % max_items_; if (tail_ == head_) // overrun last item if full { head_ = (head_ + 1) % max_items_; ++overrun_counter_; } } } // Return reference to the front item. // If there are no elements in the container, the behavior is undefined. const T &front() const { return v_[head_]; } T &front() { return v_[head_]; } // Return number of elements actually stored size_t size() const { if (tail_ >= head_) { return tail_ - head_; } else { return max_items_ - (head_ - tail_); } } // Return const reference to item by index. // If index is out of range 0…size()-1, the behavior is undefined. const T &at(size_t i) const { assert(i < size()); return v_[(head_ + i) % max_items_]; } // Pop item from front. // If there are no elements in the container, the behavior is undefined. void pop_front() { head_ = (head_ + 1) % max_items_; } bool empty() const { return tail_ == head_; } bool full() const { // head is ahead of the tail by 1 if (max_items_ > 0) { return ((tail_ + 1) % max_items_) == head_; } return false; } size_t overrun_counter() const { return overrun_counter_; } void reset_overrun_counter() { overrun_counter_ = 0; } private: // copy from other&& and reset it to disabled state void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT { max_items_ = other.max_items_; head_ = other.head_; tail_ = other.tail_; overrun_counter_ = other.overrun_counter_; v_ = std::move(other.v_); // put &&other in disabled, but valid state other.max_items_ = 0; other.head_ = other.tail_ = 0; other.overrun_counter_ = 0; } }; } // namespace details } // namespace spdlog RcppSpdlog/inst/include/spdlog/details/periodic_worker.h0000644000176200001440000000342514612604314023211 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once // periodic worker thread - periodically executes the given callback function. // // RAII over the owned thread: // creates the thread on construction. // stops and joins the thread on destruction (if the thread is executing a callback, wait for it // to finish first). #include #include #include #include #include namespace spdlog { namespace details { class SPDLOG_API periodic_worker { public: template periodic_worker(const std::function &callback_fun, std::chrono::duration interval) { active_ = (interval > std::chrono::duration::zero()); if (!active_) { return; } worker_thread_ = std::thread([this, callback_fun, interval]() { for (;;) { std::unique_lock lock(this->mutex_); if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; })) { return; // active_ == false, so exit this thread } callback_fun(); } }); } std::thread &get_thread() { return worker_thread_; } periodic_worker(const periodic_worker &) = delete; periodic_worker &operator=(const periodic_worker &) = delete; // stop the worker thread and join it ~periodic_worker(); private: bool active_; std::thread worker_thread_; std::mutex mutex_; std::condition_variable cv_; }; } // namespace details } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY #include "periodic_worker-inl.h" #endif RcppSpdlog/inst/include/spdlog/details/registry-inl.h0000644000176200001440000002226114612604314022451 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifndef SPDLOG_HEADER_ONLY #include #endif #include #include #include #include #ifndef SPDLOG_DISABLE_DEFAULT_LOGGER // support for the default stdout color logger #ifdef _WIN32 #include #else #include #endif #endif // SPDLOG_DISABLE_DEFAULT_LOGGER #include #include #include #include #include namespace spdlog { namespace details { SPDLOG_INLINE registry::registry() : formatter_(new pattern_formatter()) { #ifndef SPDLOG_DISABLE_DEFAULT_LOGGER // create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows). #ifdef _WIN32 auto color_sink = std::make_shared(); #else auto color_sink = std::make_shared(); #endif const char *default_logger_name = ""; default_logger_ = std::make_shared(default_logger_name, std::move(color_sink)); loggers_[default_logger_name] = default_logger_; #endif // SPDLOG_DISABLE_DEFAULT_LOGGER } SPDLOG_INLINE registry::~registry() = default; SPDLOG_INLINE void registry::register_logger(std::shared_ptr new_logger) { std::lock_guard lock(logger_map_mutex_); register_logger_(std::move(new_logger)); } SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr new_logger) { std::lock_guard lock(logger_map_mutex_); new_logger->set_formatter(formatter_->clone()); if (err_handler_) { new_logger->set_error_handler(err_handler_); } // set new level according to previously configured level or default level auto it = log_levels_.find(new_logger->name()); auto new_level = it != log_levels_.end() ? it->second : global_log_level_; new_logger->set_level(new_level); new_logger->flush_on(flush_level_); if (backtrace_n_messages_ > 0) { new_logger->enable_backtrace(backtrace_n_messages_); } if (automatic_registration_) { register_logger_(std::move(new_logger)); } } SPDLOG_INLINE std::shared_ptr registry::get(const std::string &logger_name) { std::lock_guard lock(logger_map_mutex_); auto found = loggers_.find(logger_name); return found == loggers_.end() ? nullptr : found->second; } #if __cplusplus >= 201703L // C++17 // if the map is small do a sequential search and avoid creating string for find(logger_name) // otherwise use the standard find() SPDLOG_INLINE std::shared_ptr registry::get(std::string_view logger_name) { std::lock_guard lock(logger_map_mutex_); if (loggers_.size() <= 10) { for (const auto &[key, val]: loggers_) { if (logger_name == key) { return val; } } return nullptr; } // otherwise use the normal map lookup else { auto found = loggers_.find(std::string(logger_name)); return found == loggers_.end() ? nullptr : found->second; } } SPDLOG_INLINE std::shared_ptr registry::get(const char *logger_name) { return get(std::string_view(logger_name)); } #endif SPDLOG_INLINE std::shared_ptr registry::default_logger() { std::lock_guard lock(logger_map_mutex_); return default_logger_; } // Return raw ptr to the default logger. // To be used directly by the spdlog default api (e.g. spdlog::info) // This make the default API faster, but cannot be used concurrently with set_default_logger(). // e.g do not call set_default_logger() from one thread while calling spdlog::info() from another. SPDLOG_INLINE logger *registry::get_default_raw() { return default_logger_.get(); } // set default logger. // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map. SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr new_default_logger) { std::lock_guard lock(logger_map_mutex_); if (new_default_logger != nullptr) { loggers_[new_default_logger->name()] = new_default_logger; } default_logger_ = std::move(new_default_logger); } SPDLOG_INLINE void registry::set_tp(std::shared_ptr tp) { std::lock_guard lock(tp_mutex_); tp_ = std::move(tp); } SPDLOG_INLINE std::shared_ptr registry::get_tp() { std::lock_guard lock(tp_mutex_); return tp_; } // Set global formatter. Each sink in each logger will get a clone of this object SPDLOG_INLINE void registry::set_formatter(std::unique_ptr formatter) { std::lock_guard lock(logger_map_mutex_); formatter_ = std::move(formatter); for (auto &l : loggers_) { l.second->set_formatter(formatter_->clone()); } } SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages) { std::lock_guard lock(logger_map_mutex_); backtrace_n_messages_ = n_messages; for (auto &l : loggers_) { l.second->enable_backtrace(n_messages); } } SPDLOG_INLINE void registry::disable_backtrace() { std::lock_guard lock(logger_map_mutex_); backtrace_n_messages_ = 0; for (auto &l : loggers_) { l.second->disable_backtrace(); } } SPDLOG_INLINE void registry::set_level(level::level_enum log_level) { std::lock_guard lock(logger_map_mutex_); for (auto &l : loggers_) { l.second->set_level(log_level); } global_log_level_ = log_level; } SPDLOG_INLINE void registry::flush_on(level::level_enum log_level) { std::lock_guard lock(logger_map_mutex_); for (auto &l : loggers_) { l.second->flush_on(log_level); } flush_level_ = log_level; } SPDLOG_INLINE void registry::set_error_handler(err_handler handler) { std::lock_guard lock(logger_map_mutex_); for (auto &l : loggers_) { l.second->set_error_handler(handler); } err_handler_ = std::move(handler); } SPDLOG_INLINE void registry::apply_all( const std::function)> &fun) { std::lock_guard lock(logger_map_mutex_); for (auto &l : loggers_) { fun(l.second); } } SPDLOG_INLINE void registry::flush_all() { std::lock_guard lock(logger_map_mutex_); for (auto &l : loggers_) { l.second->flush(); } } SPDLOG_INLINE void registry::drop(const std::string &logger_name) { std::lock_guard lock(logger_map_mutex_); auto is_default_logger = default_logger_ && default_logger_->name() == logger_name; loggers_.erase(logger_name); if (is_default_logger) { default_logger_.reset(); } } SPDLOG_INLINE void registry::drop_all() { std::lock_guard lock(logger_map_mutex_); loggers_.clear(); default_logger_.reset(); } // clean all resources and threads started by the registry SPDLOG_INLINE void registry::shutdown() { { std::lock_guard lock(flusher_mutex_); periodic_flusher_.reset(); } drop_all(); { std::lock_guard lock(tp_mutex_); tp_.reset(); } } SPDLOG_INLINE std::recursive_mutex ®istry::tp_mutex() { return tp_mutex_; } SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registration) { std::lock_guard lock(logger_map_mutex_); automatic_registration_ = automatic_registration; } SPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum *global_level) { std::lock_guard lock(logger_map_mutex_); log_levels_ = std::move(levels); auto global_level_requested = global_level != nullptr; global_log_level_ = global_level_requested ? *global_level : global_log_level_; for (auto &logger : loggers_) { auto logger_entry = log_levels_.find(logger.first); if (logger_entry != log_levels_.end()) { logger.second->set_level(logger_entry->second); } else if (global_level_requested) { logger.second->set_level(*global_level); } } } SPDLOG_INLINE registry ®istry::instance() { static registry s_instance; return s_instance; } SPDLOG_INLINE void registry::apply_logger_env_levels(std::shared_ptr new_logger) { std::lock_guard lock(logger_map_mutex_); auto it = log_levels_.find(new_logger->name()); auto new_level = it != log_levels_.end() ? it->second : global_log_level_; new_logger->set_level(new_level); } SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name) { if (loggers_.find(logger_name) != loggers_.end()) { throw_spdlog_ex("logger with name '" + logger_name + "' already exists"); } } SPDLOG_INLINE void registry::register_logger_(std::shared_ptr new_logger) { auto logger_name = new_logger->name(); throw_if_exists_(logger_name); loggers_[logger_name] = std::move(new_logger); } } // namespace details } // namespace spdlog RcppSpdlog/inst/include/spdlog/details/os-inl.h0000644000176200001440000004275114612604314021230 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifndef SPDLOG_HEADER_ONLY #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #ifdef _WIN32 #include #include // for FlushFileBuffers #include // for _get_osfhandle, _isatty, _fileno #include // for _get_pid #ifdef __MINGW32__ #include #endif #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES) #include #include #endif #include // for _mkdir/_wmkdir #else // unix #include #include #ifdef __linux__ #include //Use gettid() syscall under linux to get thread id #elif defined(_AIX) #include // for pthread_getthrds_np #elif defined(__DragonFly__) || defined(__FreeBSD__) #include // for pthread_getthreadid_np #elif defined(__NetBSD__) #include // for _lwp_self #elif defined(__sun) #include // for thr_self #endif #endif // unix #if defined __APPLE__ #include #endif #ifndef __has_feature // Clang - feature checking macros. #define __has_feature(x) 0 // Compatibility with non-clang compilers. #endif namespace spdlog { namespace details { namespace os { SPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT { #if defined __linux__ && defined SPDLOG_CLOCK_COARSE timespec ts; ::clock_gettime(CLOCK_REALTIME_COARSE, &ts); return std::chrono::time_point( std::chrono::duration_cast( std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec))); #else return log_clock::now(); #endif } SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT { #ifdef _WIN32 std::tm tm; ::localtime_s(&tm, &time_tt); #else std::tm tm; ::localtime_r(&time_tt, &tm); #endif return tm; } SPDLOG_INLINE std::tm localtime() SPDLOG_NOEXCEPT { std::time_t now_t = ::time(nullptr); return localtime(now_t); } SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT { #ifdef _WIN32 std::tm tm; ::gmtime_s(&tm, &time_tt); #else std::tm tm; ::gmtime_r(&time_tt, &tm); #endif return tm; } SPDLOG_INLINE std::tm gmtime() SPDLOG_NOEXCEPT { std::time_t now_t = ::time(nullptr); return gmtime(now_t); } // fopen_s on non windows for writing SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode) { #ifdef _WIN32 #ifdef SPDLOG_WCHAR_FILENAMES *fp = ::_wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO); #else *fp = ::_fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO); #endif #if defined(SPDLOG_PREVENT_CHILD_FD) if (*fp != nullptr) { auto file_handle = reinterpret_cast(_get_osfhandle(::_fileno(*fp))); if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0)) { ::fclose(*fp); *fp = nullptr; } } #endif #else // unix #if defined(SPDLOG_PREVENT_CHILD_FD) const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC; const int fd = ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644)); if (fd == -1) { return true; } *fp = ::fdopen(fd, mode.c_str()); if (*fp == nullptr) { ::close(fd); } #else *fp = ::fopen((filename.c_str()), mode.c_str()); #endif #endif return *fp == nullptr; } SPDLOG_INLINE int remove(const filename_t &filename) SPDLOG_NOEXCEPT { #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) return ::_wremove(filename.c_str()); #else return std::remove(filename.c_str()); #endif } SPDLOG_INLINE int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT { return path_exists(filename) ? remove(filename) : 0; } SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT { #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) return ::_wrename(filename1.c_str(), filename2.c_str()); #else return std::rename(filename1.c_str(), filename2.c_str()); #endif } // Return true if path exists (file or directory) SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT { #ifdef _WIN32 struct _stat buffer; #ifdef SPDLOG_WCHAR_FILENAMES return (::_wstat(filename.c_str(), &buffer) == 0); #else return (::_stat(filename.c_str(), &buffer) == 0); #endif #else // common linux/unix all have the stat system call struct stat buffer; return (::stat(filename.c_str(), &buffer) == 0); #endif } #ifdef _MSC_VER // avoid warning about unreachable statement at the end of filesize() #pragma warning(push) #pragma warning(disable : 4702) #endif // Return file size according to open FILE* object SPDLOG_INLINE size_t filesize(FILE *f) { if (f == nullptr) { throw_spdlog_ex("Failed getting file size. fd is null"); } #if defined(_WIN32) && !defined(__CYGWIN__) int fd = ::_fileno(f); #if defined(_WIN64) // 64 bits __int64 ret = ::_filelengthi64(fd); if (ret >= 0) { return static_cast(ret); } #else // windows 32 bits long ret = ::_filelength(fd); if (ret >= 0) { return static_cast(ret); } #endif #else // unix // OpenBSD and AIX doesn't compile with :: before the fileno(..) #if defined(__OpenBSD__) || defined(_AIX) int fd = fileno(f); #else int fd = ::fileno(f); #endif // 64 bits(but not in osx, linux/musl or cygwin, where fstat64 is deprecated) #if ((defined(__linux__) && defined(__GLIBC__)) || defined(__sun) || defined(_AIX)) && \ (defined(__LP64__) || defined(_LP64)) struct stat64 st; if (::fstat64(fd, &st) == 0) { return static_cast(st.st_size); } #else // other unix or linux 32 bits or cygwin struct stat st; if (::fstat(fd, &st) == 0) { return static_cast(st.st_size); } #endif #endif throw_spdlog_ex("Failed getting file size from fd", errno); return 0; // will not be reached. } #ifdef _MSC_VER #pragma warning(pop) #endif // Return utc offset in minutes or throw spdlog_ex on failure SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) { #ifdef _WIN32 #if _WIN32_WINNT < _WIN32_WINNT_WS08 TIME_ZONE_INFORMATION tzinfo; auto rv = ::GetTimeZoneInformation(&tzinfo); #else DYNAMIC_TIME_ZONE_INFORMATION tzinfo; auto rv = ::GetDynamicTimeZoneInformation(&tzinfo); #endif if (rv == TIME_ZONE_ID_INVALID) throw_spdlog_ex("Failed getting timezone info. ", errno); int offset = -tzinfo.Bias; if (tm.tm_isdst) { offset -= tzinfo.DaylightBias; } else { offset -= tzinfo.StandardBias; } return offset; #else #if defined(sun) || defined(__sun) || defined(_AIX) || \ (defined(__NEWLIB__) && !defined(__TM_GMTOFF)) || \ (!defined(_BSD_SOURCE) && !defined(_GNU_SOURCE)) // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris struct helper { static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(), const std::tm &gmtm = details::os::gmtime()) { int local_year = localtm.tm_year + (1900 - 1); int gmt_year = gmtm.tm_year + (1900 - 1); long int days = ( // difference in day of year localtm.tm_yday - gmtm.tm_yday // + intervening leap days + ((local_year >> 2) - (gmt_year >> 2)) - (local_year / 100 - gmt_year / 100) + ((local_year / 100 >> 2) - (gmt_year / 100 >> 2)) // + difference in years * 365 */ + static_cast(local_year - gmt_year) * 365); long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour); long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min); long int secs = (60 * mins) + (localtm.tm_sec - gmtm.tm_sec); return secs; } }; auto offset_seconds = helper::calculate_gmt_offset(tm); #else auto offset_seconds = tm.tm_gmtoff; #endif return static_cast(offset_seconds / 60); #endif } // Return current thread id as size_t // It exists because the std::this_thread::get_id() is much slower(especially // under VS 2013) SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT { #ifdef _WIN32 return static_cast(::GetCurrentThreadId()); #elif defined(__linux__) #if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21) #define SYS_gettid __NR_gettid #endif return static_cast(::syscall(SYS_gettid)); #elif defined(_AIX) struct __pthrdsinfo buf; int reg_size = 0; pthread_t pt = pthread_self(); int retval = pthread_getthrds_np(&pt, PTHRDSINFO_QUERY_TID, &buf, sizeof(buf), NULL, ®_size); int tid = (!retval) ? buf.__pi_tid : 0; return static_cast(tid); #elif defined(__DragonFly__) || defined(__FreeBSD__) return static_cast(::pthread_getthreadid_np()); #elif defined(__NetBSD__) return static_cast(::_lwp_self()); #elif defined(__OpenBSD__) return static_cast(::getthrid()); #elif defined(__sun) return static_cast(::thr_self()); #elif __APPLE__ uint64_t tid; // There is no pthread_threadid_np prior to Mac OS X 10.6, and it is not supported on any PPC, // including 10.6.8 Rosetta. __POWERPC__ is Apple-specific define encompassing ppc and ppc64. #ifdef MAC_OS_X_VERSION_MAX_ALLOWED { #if (MAC_OS_X_VERSION_MAX_ALLOWED < 1060) || defined(__POWERPC__) tid = pthread_mach_thread_np(pthread_self()); #elif MAC_OS_X_VERSION_MIN_REQUIRED < 1060 if (&pthread_threadid_np) { pthread_threadid_np(nullptr, &tid); } else { tid = pthread_mach_thread_np(pthread_self()); } #else pthread_threadid_np(nullptr, &tid); #endif } #else pthread_threadid_np(nullptr, &tid); #endif return static_cast(tid); #else // Default to standard C++11 (other Unix) return static_cast(std::hash()(std::this_thread::get_id())); #endif } // Return current thread id as size_t (from thread local storage) SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT { #if defined(SPDLOG_NO_TLS) return _thread_id(); #else // cache thread id in tls static thread_local const size_t tid = _thread_id(); return tid; #endif } // This is avoid msvc issue in sleep_for that happens if the clock changes. // See https://github.com/gabime/spdlog/issues/609 SPDLOG_INLINE void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT { #if defined(_WIN32) ::Sleep(milliseconds); #else std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds)); #endif } // wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined) #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) { memory_buf_t buf; wstr_to_utf8buf(filename, buf); return SPDLOG_BUF_TO_STRING(buf); } #else SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) { return filename; } #endif SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT { #ifdef _WIN32 return conditional_static_cast(::GetCurrentProcessId()); #else return conditional_static_cast(::getpid()); #endif } // Determine if the terminal supports colors // Based on: https://github.com/agauniyal/rang/ SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT { #ifdef _WIN32 return true; #else static const bool result = []() { const char *env_colorterm_p = std::getenv("COLORTERM"); if (env_colorterm_p != nullptr) { return true; } static constexpr std::array terms = { {"ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux", "msys", "putty", "rxvt", "screen", "vt100", "xterm", "alacritty", "vt102"}}; const char *env_term_p = std::getenv("TERM"); if (env_term_p == nullptr) { return false; } return std::any_of(terms.begin(), terms.end(), [&](const char *term) { return std::strstr(env_term_p, term) != nullptr; }); }(); return result; #endif } // Determine if the terminal attached // Source: https://github.com/agauniyal/rang/ SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT { #ifdef _WIN32 return ::_isatty(_fileno(file)) != 0; #else return ::isatty(fileno(file)) != 0; #endif } #if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32) SPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target) { if (wstr.size() > static_cast((std::numeric_limits::max)()) / 4 - 1) { throw_spdlog_ex("UTF-16 string is too big to be converted to UTF-8"); } int wstr_size = static_cast(wstr.size()); if (wstr_size == 0) { target.resize(0); return; } int result_size = static_cast(target.capacity()); if ((wstr_size + 1) * 4 > result_size) { result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, NULL, 0, NULL, NULL); } if (result_size > 0) { target.resize(result_size); result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, target.data(), result_size, NULL, NULL); if (result_size > 0) { target.resize(result_size); return; } } throw_spdlog_ex( fmt_lib::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError())); } SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target) { if (str.size() > static_cast((std::numeric_limits::max)()) - 1) { throw_spdlog_ex("UTF-8 string is too big to be converted to UTF-16"); } int str_size = static_cast(str.size()); if (str_size == 0) { target.resize(0); return; } // find the size to allocate for the result buffer int result_size = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, NULL, 0); if (result_size > 0) { target.resize(result_size); result_size = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, target.data(), result_size); if (result_size > 0) { assert(result_size == target.size()); return; } } throw_spdlog_ex( fmt_lib::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError())); } #endif // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && // defined(_WIN32) // return true on success static SPDLOG_INLINE bool mkdir_(const filename_t &path) { #ifdef _WIN32 #ifdef SPDLOG_WCHAR_FILENAMES return ::_wmkdir(path.c_str()) == 0; #else return ::_mkdir(path.c_str()) == 0; #endif #else return ::mkdir(path.c_str(), mode_t(0755)) == 0; #endif } // create the given directory - and all directories leading to it // return true on success or if the directory already exists SPDLOG_INLINE bool create_dir(const filename_t &path) { if (path_exists(path)) { return true; } if (path.empty()) { return false; } size_t search_offset = 0; do { auto token_pos = path.find_first_of(folder_seps_filename, search_offset); // treat the entire path as a folder if no folder separator not found if (token_pos == filename_t::npos) { token_pos = path.size(); } auto subdir = path.substr(0, token_pos); if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir)) { return false; // return error if failed creating dir } search_offset = token_pos + 1; } while (search_offset < path.size()); return true; } // Return directory name from given path or empty string // "abc/file" => "abc" // "abc/" => "abc" // "abc" => "" // "abc///" => "abc//" SPDLOG_INLINE filename_t dir_name(const filename_t &path) { auto pos = path.find_last_of(folder_seps_filename); return pos != filename_t::npos ? path.substr(0, pos) : filename_t{}; } std::string SPDLOG_INLINE getenv(const char *field) { #if defined(_MSC_VER) #if defined(__cplusplus_winrt) return std::string{}; // not supported under uwp #else size_t len = 0; char buf[128]; bool ok = ::getenv_s(&len, buf, sizeof(buf), field) == 0; return ok ? buf : std::string{}; #endif #else // revert to getenv char *buf = ::getenv(field); return buf ? buf : std::string{}; #endif } // Do fsync by FILE handlerpointer // Return true on success SPDLOG_INLINE bool fsync(FILE *fp) { #ifdef _WIN32 return FlushFileBuffers(reinterpret_cast(_get_osfhandle(_fileno(fp)))) != 0; #else return ::fsync(fileno(fp)) == 0; #endif } } // namespace os } // namespace details } // namespace spdlog RcppSpdlog/inst/include/spdlog/details/fmt_helper.h0000644000176200001440000001056714550234366022163 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include #include #include #include #ifdef SPDLOG_USE_STD_FORMAT #include #include #endif // Some fmt helpers to efficiently format and pad ints and strings namespace spdlog { namespace details { namespace fmt_helper { inline void append_string_view(spdlog::string_view_t view, memory_buf_t &dest) { auto *buf_ptr = view.data(); dest.append(buf_ptr, buf_ptr + view.size()); } #ifdef SPDLOG_USE_STD_FORMAT template inline void append_int(T n, memory_buf_t &dest) { // Buffer should be large enough to hold all digits (digits10 + 1) and a sign SPDLOG_CONSTEXPR const auto BUF_SIZE = std::numeric_limits::digits10 + 2; char buf[BUF_SIZE]; auto [ptr, ec] = std::to_chars(buf, buf + BUF_SIZE, n, 10); if (ec == std::errc()) { dest.append(buf, ptr); } else { throw_spdlog_ex("Failed to format int", static_cast(ec)); } } #else template inline void append_int(T n, memory_buf_t &dest) { fmt::format_int i(n); dest.append(i.data(), i.data() + i.size()); } #endif template SPDLOG_CONSTEXPR_FUNC unsigned int count_digits_fallback(T n) { // taken from fmt: https://github.com/fmtlib/fmt/blob/8.0.1/include/fmt/format.h#L899-L912 unsigned int 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; } } template inline unsigned int count_digits(T n) { using count_type = typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type; #ifdef SPDLOG_USE_STD_FORMAT return count_digits_fallback(static_cast(n)); #else return static_cast(fmt:: // fmt 7.0.0 renamed the internal namespace to detail. // See: https://github.com/fmtlib/fmt/issues/1538 #if FMT_VERSION < 70000 internal #else detail #endif ::count_digits(static_cast(n))); #endif } inline void pad2(int n, memory_buf_t &dest) { if (n >= 0 && n < 100) // 0-99 { dest.push_back(static_cast('0' + n / 10)); dest.push_back(static_cast('0' + n % 10)); } else // unlikely, but just in case, let fmt deal with it { fmt_lib::format_to(std::back_inserter(dest), SPDLOG_FMT_STRING("{:02}"), n); } } template inline void pad_uint(T n, unsigned int width, memory_buf_t &dest) { static_assert(std::is_unsigned::value, "pad_uint must get unsigned T"); for (auto digits = count_digits(n); digits < width; digits++) { dest.push_back('0'); } append_int(n, dest); } template inline void pad3(T n, memory_buf_t &dest) { static_assert(std::is_unsigned::value, "pad3 must get unsigned T"); if (n < 1000) { dest.push_back(static_cast(n / 100 + '0')); n = n % 100; dest.push_back(static_cast((n / 10) + '0')); dest.push_back(static_cast((n % 10) + '0')); } else { append_int(n, dest); } } template inline void pad6(T n, memory_buf_t &dest) { pad_uint(n, 6, dest); } template inline void pad9(T n, memory_buf_t &dest) { pad_uint(n, 9, dest); } // return fraction of a second of the given time_point. // e.g. // fraction(tp) -> will return the millis part of the second template inline ToDuration time_fraction(log_clock::time_point tp) { using std::chrono::duration_cast; using std::chrono::seconds; auto duration = tp.time_since_epoch(); auto secs = duration_cast(duration); return duration_cast(duration) - duration_cast(secs); } } // namespace fmt_helper } // namespace details } // namespace spdlog RcppSpdlog/inst/include/spdlog/details/console_globals.h0000644000176200001440000000113314550234366023170 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include namespace spdlog { namespace details { struct console_mutex { using mutex_t = std::mutex; static mutex_t &mutex() { static mutex_t s_mutex; return s_mutex; } }; struct console_nullmutex { using mutex_t = null_mutex; static mutex_t &mutex() { static mutex_t s_mutex; return s_mutex; } }; } // namespace details } // namespace spdlog RcppSpdlog/inst/include/spdlog/details/file_helper.h0000644000176200001440000000333614550234366022310 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include namespace spdlog { namespace details { // Helper class for file sinks. // When failing to open a file, retry several times(5) with a delay interval(10 ms). // Throw spdlog_ex exception on errors. class SPDLOG_API file_helper { public: file_helper() = default; explicit file_helper(const file_event_handlers &event_handlers); file_helper(const file_helper &) = delete; file_helper &operator=(const file_helper &) = delete; ~file_helper(); void open(const filename_t &fname, bool truncate = false); void reopen(bool truncate); void flush(); void sync(); void close(); void write(const memory_buf_t &buf); size_t size() const; const filename_t &filename() const; // // return file path and its extension: // // "mylog.txt" => ("mylog", ".txt") // "mylog" => ("mylog", "") // "mylog." => ("mylog.", "") // "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt") // // the starting dot in filenames is ignored (hidden files): // // ".mylog" => (".mylog". "") // "my_folder/.mylog" => ("my_folder/.mylog", "") // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt") static std::tuple split_by_extension(const filename_t &fname); private: const int open_tries_ = 5; const unsigned int open_interval_ = 10; std::FILE *fd_{nullptr}; filename_t filename_; file_event_handlers event_handlers_; }; } // namespace details } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY #include "file_helper-inl.h" #endif RcppSpdlog/inst/include/spdlog/details/backtracer.h0000644000176200001440000000221514550234366022126 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include #include #include #include // Store log messages in circular buffer. // Useful for storing debug data in case of error/warning happens. namespace spdlog { namespace details { class SPDLOG_API backtracer { mutable std::mutex mutex_; std::atomic enabled_{false}; circular_q messages_; public: backtracer() = default; backtracer(const backtracer &other); backtracer(backtracer &&other) SPDLOG_NOEXCEPT; backtracer &operator=(backtracer other); void enable(size_t size); void disable(); bool enabled() const; void push_back(const log_msg &msg); bool empty() const; // pop all items in the q and apply the given fun on each of them. void foreach_pop(std::function fun); }; } // namespace details } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY #include "backtracer-inl.h" #endif RcppSpdlog/inst/include/spdlog/details/log_msg_buffer.h0000644000176200001440000000164714550234366023015 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include namespace spdlog { namespace details { // Extend log_msg with internal buffer to store its payload. // This is needed since log_msg holds string_views that points to stack data. class SPDLOG_API log_msg_buffer : public log_msg { memory_buf_t buffer; void update_string_views(); public: log_msg_buffer() = default; explicit log_msg_buffer(const log_msg &orig_msg); log_msg_buffer(const log_msg_buffer &other); log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT; log_msg_buffer &operator=(const log_msg_buffer &other); log_msg_buffer &operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT; }; } // namespace details } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY #include "log_msg_buffer-inl.h" #endif RcppSpdlog/inst/include/spdlog/details/log_msg-inl.h0000644000176200001440000000256414550234366022243 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifndef SPDLOG_HEADER_ONLY #include #endif #include namespace spdlog { namespace details { SPDLOG_INLINE log_msg::log_msg(spdlog::log_clock::time_point log_time, spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg) : logger_name(a_logger_name), level(lvl), time(log_time) #ifndef SPDLOG_NO_THREAD_ID , thread_id(os::thread_id()) #endif , source(loc), payload(msg) { } SPDLOG_INLINE log_msg::log_msg(spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg) : log_msg(os::now(), loc, a_logger_name, lvl, msg) {} SPDLOG_INLINE log_msg::log_msg(string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg) : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg) {} } // namespace details } // namespace spdlog RcppSpdlog/inst/include/spdlog/details/udp_client.h0000644000176200001440000000427514550234366022163 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once // Helper RAII over unix udp client socket. // Will throw on construction if the socket creation failed. #ifdef _WIN32 #error "include udp_client-windows.h instead" #endif #include #include #include #include #include #include #include #include #include #include namespace spdlog { namespace details { class udp_client { static constexpr int TX_BUFFER_SIZE = 1024 * 10; int socket_ = -1; struct sockaddr_in sockAddr_; void cleanup_() { if (socket_ != -1) { ::close(socket_); socket_ = -1; } } public: udp_client(const std::string &host, uint16_t port) { socket_ = ::socket(PF_INET, SOCK_DGRAM, 0); if (socket_ < 0) { throw_spdlog_ex("error: Create Socket Failed!"); } int option_value = TX_BUFFER_SIZE; if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF, reinterpret_cast(&option_value), sizeof(option_value)) < 0) { cleanup_(); throw_spdlog_ex("error: setsockopt(SO_SNDBUF) Failed!"); } sockAddr_.sin_family = AF_INET; sockAddr_.sin_port = htons(port); if (::inet_aton(host.c_str(), &sockAddr_.sin_addr) == 0) { cleanup_(); throw_spdlog_ex("error: Invalid address!"); } ::memset(sockAddr_.sin_zero, 0x00, sizeof(sockAddr_.sin_zero)); } ~udp_client() { cleanup_(); } int fd() const { return socket_; } // Send exactly n_bytes of the given data. // On error close the connection and throw. void send(const char *data, size_t n_bytes) { ssize_t toslen = 0; socklen_t tolen = sizeof(struct sockaddr); if ((toslen = ::sendto(socket_, data, n_bytes, 0, (struct sockaddr *)&sockAddr_, tolen)) == -1) { throw_spdlog_ex("sendto(2) failed", errno); } } }; } // namespace details } // namespace spdlog RcppSpdlog/inst/include/spdlog/details/os.h0000644000176200001440000000752214550234366020454 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include // std::time_t #include namespace spdlog { namespace details { namespace os { SPDLOG_API spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT; SPDLOG_API std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT; SPDLOG_API std::tm localtime() SPDLOG_NOEXCEPT; SPDLOG_API std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT; SPDLOG_API std::tm gmtime() SPDLOG_NOEXCEPT; // eol definition #if !defined(SPDLOG_EOL) #ifdef _WIN32 #define SPDLOG_EOL "\r\n" #else #define SPDLOG_EOL "\n" #endif #endif SPDLOG_CONSTEXPR static const char *default_eol = SPDLOG_EOL; // folder separator #if !defined(SPDLOG_FOLDER_SEPS) #ifdef _WIN32 #define SPDLOG_FOLDER_SEPS "\\/" #else #define SPDLOG_FOLDER_SEPS "/" #endif #endif SPDLOG_CONSTEXPR static const char folder_seps[] = SPDLOG_FOLDER_SEPS; SPDLOG_CONSTEXPR static const filename_t::value_type folder_seps_filename[] = SPDLOG_FILENAME_T(SPDLOG_FOLDER_SEPS); // fopen_s on non windows for writing SPDLOG_API bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode); // Remove filename. return 0 on success SPDLOG_API int remove(const filename_t &filename) SPDLOG_NOEXCEPT; // Remove file if exists. return 0 on success // Note: Non atomic (might return failure to delete if concurrently deleted by other process/thread) SPDLOG_API int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT; SPDLOG_API int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT; // Return if file exists. SPDLOG_API bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT; // Return file size according to open FILE* object SPDLOG_API size_t filesize(FILE *f); // Return utc offset in minutes or throw spdlog_ex on failure SPDLOG_API int utc_minutes_offset(const std::tm &tm = details::os::localtime()); // Return current thread id as size_t // It exists because the std::this_thread::get_id() is much slower(especially // under VS 2013) SPDLOG_API size_t _thread_id() SPDLOG_NOEXCEPT; // Return current thread id as size_t (from thread local storage) SPDLOG_API size_t thread_id() SPDLOG_NOEXCEPT; // This is avoid msvc issue in sleep_for that happens if the clock changes. // See https://github.com/gabime/spdlog/issues/609 SPDLOG_API void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT; SPDLOG_API std::string filename_to_str(const filename_t &filename); SPDLOG_API int pid() SPDLOG_NOEXCEPT; // Determine if the terminal supports colors // Source: https://github.com/agauniyal/rang/ SPDLOG_API bool is_color_terminal() SPDLOG_NOEXCEPT; // Determine if the terminal attached // Source: https://github.com/agauniyal/rang/ SPDLOG_API bool in_terminal(FILE *file) SPDLOG_NOEXCEPT; #if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32) SPDLOG_API void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target); SPDLOG_API void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target); #endif // Return directory name from given path or empty string // "abc/file" => "abc" // "abc/" => "abc" // "abc" => "" // "abc///" => "abc//" SPDLOG_API filename_t dir_name(const filename_t &path); // Create a dir from the given path. // Return true if succeeded or if this dir already exists. SPDLOG_API bool create_dir(const filename_t &path); // non thread safe, cross platform getenv/getenv_s // return empty string if field not found SPDLOG_API std::string getenv(const char *field); // Do fsync by FILE objectpointer. // Return true on success. SPDLOG_API bool fsync(FILE *fp); } // namespace os } // namespace details } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY #include "os-inl.h" #endif RcppSpdlog/inst/include/spdlog/details/mpmc_blocking_q.h0000644000176200001440000001224514550234366023155 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once // multi producer-multi consumer blocking queue. // enqueue(..) - will block until room found to put the new message. // enqueue_nowait(..) - will return immediately with false if no room left in // the queue. // dequeue_for(..) - will block until the queue is not empty or timeout have // passed. #include #include #include #include namespace spdlog { namespace details { template class mpmc_blocking_queue { public: using item_type = T; explicit mpmc_blocking_queue(size_t max_items) : q_(max_items) {} #ifndef __MINGW32__ // try to enqueue and block if no room left void enqueue(T &&item) { { std::unique_lock lock(queue_mutex_); pop_cv_.wait(lock, [this] { return !this->q_.full(); }); q_.push_back(std::move(item)); } push_cv_.notify_one(); } // enqueue immediately. overrun oldest message in the queue if no room left. void enqueue_nowait(T &&item) { { std::unique_lock lock(queue_mutex_); q_.push_back(std::move(item)); } push_cv_.notify_one(); } void enqueue_if_have_room(T &&item) { bool pushed = false; { std::unique_lock lock(queue_mutex_); if (!q_.full()) { q_.push_back(std::move(item)); pushed = true; } } if (pushed) { push_cv_.notify_one(); } else { ++discard_counter_; } } // dequeue with a timeout. // Return true, if succeeded dequeue item, false otherwise bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) { { std::unique_lock lock(queue_mutex_); if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) { return false; } popped_item = std::move(q_.front()); q_.pop_front(); } pop_cv_.notify_one(); return true; } // blocking dequeue without a timeout. void dequeue(T &popped_item) { { std::unique_lock lock(queue_mutex_); push_cv_.wait(lock, [this] { return !this->q_.empty(); }); popped_item = std::move(q_.front()); q_.pop_front(); } pop_cv_.notify_one(); } #else // apparently mingw deadlocks if the mutex is released before cv.notify_one(), // so release the mutex at the very end each function. // try to enqueue and block if no room left void enqueue(T &&item) { std::unique_lock lock(queue_mutex_); pop_cv_.wait(lock, [this] { return !this->q_.full(); }); q_.push_back(std::move(item)); push_cv_.notify_one(); } // enqueue immediately. overrun oldest message in the queue if no room left. void enqueue_nowait(T &&item) { std::unique_lock lock(queue_mutex_); q_.push_back(std::move(item)); push_cv_.notify_one(); } void enqueue_if_have_room(T &&item) { bool pushed = false; std::unique_lock lock(queue_mutex_); if (!q_.full()) { q_.push_back(std::move(item)); pushed = true; } if (pushed) { push_cv_.notify_one(); } else { ++discard_counter_; } } // dequeue with a timeout. // Return true, if succeeded dequeue item, false otherwise bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) { std::unique_lock lock(queue_mutex_); if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) { return false; } popped_item = std::move(q_.front()); q_.pop_front(); pop_cv_.notify_one(); return true; } // blocking dequeue without a timeout. void dequeue(T &popped_item) { std::unique_lock lock(queue_mutex_); push_cv_.wait(lock, [this] { return !this->q_.empty(); }); popped_item = std::move(q_.front()); q_.pop_front(); pop_cv_.notify_one(); } #endif size_t overrun_counter() { std::unique_lock lock(queue_mutex_); return q_.overrun_counter(); } size_t discard_counter() { return discard_counter_.load(std::memory_order_relaxed); } size_t size() { std::unique_lock lock(queue_mutex_); return q_.size(); } void reset_overrun_counter() { std::unique_lock lock(queue_mutex_); q_.reset_overrun_counter(); } void reset_discard_counter() { discard_counter_.store(0, std::memory_order_relaxed); } private: std::mutex queue_mutex_; std::condition_variable push_cv_; std::condition_variable pop_cv_; spdlog::details::circular_q q_; std::atomic discard_counter_{0}; }; } // namespace details } // namespace spdlog RcppSpdlog/inst/include/spdlog/details/tcp_client-windows.h0000644000176200001440000001023414550234366023641 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #define WIN32_LEAN_AND_MEAN // tcp client helper #include #include #include #include #include #include #include #include #pragma comment(lib, "Ws2_32.lib") #pragma comment(lib, "Mswsock.lib") #pragma comment(lib, "AdvApi32.lib") namespace spdlog { namespace details { class tcp_client { SOCKET socket_ = INVALID_SOCKET; static void init_winsock_() { WSADATA wsaData; auto rv = WSAStartup(MAKEWORD(2, 2), &wsaData); if (rv != 0) { throw_winsock_error_("WSAStartup failed", ::WSAGetLastError()); } } static void throw_winsock_error_(const std::string &msg, int last_error) { char buf[512]; ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, last_error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL); throw_spdlog_ex(fmt_lib::format("tcp_sink - {}: {}", msg, buf)); } public: tcp_client() { init_winsock_(); } ~tcp_client() { close(); ::WSACleanup(); } bool is_connected() const { return socket_ != INVALID_SOCKET; } void close() { ::closesocket(socket_); socket_ = INVALID_SOCKET; } SOCKET fd() const { return socket_; } // try to connect or throw on failure void connect(const std::string &host, int port) { if (is_connected()) { close(); } struct addrinfo hints {}; ZeroMemory(&hints, sizeof(hints)); hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on hints.ai_socktype = SOCK_STREAM; // TCP hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value hints.ai_protocol = 0; auto port_str = std::to_string(port); struct addrinfo *addrinfo_result; auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result); int last_error = 0; if (rv != 0) { last_error = ::WSAGetLastError(); WSACleanup(); throw_winsock_error_("getaddrinfo failed", last_error); } // Try each address until we successfully connect(2). for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next) { socket_ = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol); if (socket_ == INVALID_SOCKET) { last_error = ::WSAGetLastError(); WSACleanup(); continue; } if (::connect(socket_, rp->ai_addr, (int)rp->ai_addrlen) == 0) { break; } else { last_error = ::WSAGetLastError(); close(); } } ::freeaddrinfo(addrinfo_result); if (socket_ == INVALID_SOCKET) { WSACleanup(); throw_winsock_error_("connect failed", last_error); } // set TCP_NODELAY int enable_flag = 1; ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast(&enable_flag), sizeof(enable_flag)); } // Send exactly n_bytes of the given data. // On error close the connection and throw. void send(const char *data, size_t n_bytes) { size_t bytes_sent = 0; while (bytes_sent < n_bytes) { const int send_flags = 0; auto write_result = ::send(socket_, data + bytes_sent, (int)(n_bytes - bytes_sent), send_flags); if (write_result == SOCKET_ERROR) { int last_error = ::WSAGetLastError(); close(); throw_winsock_error_("send failed", last_error); } if (write_result == 0) // (probably should not happen but in any case..) { break; } bytes_sent += static_cast(write_result); } } }; } // namespace details } // namespace spdlog RcppSpdlog/inst/include/spdlog/details/periodic_worker-inl.h0000644000176200001440000000115414550234366023775 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifndef SPDLOG_HEADER_ONLY #include #endif namespace spdlog { namespace details { // stop the worker thread and join it SPDLOG_INLINE periodic_worker::~periodic_worker() { if (worker_thread_.joinable()) { { std::lock_guard lock(mutex_); active_ = false; } cv_.notify_one(); worker_thread_.join(); } } } // namespace details } // namespace spdlog RcppSpdlog/inst/include/spdlog/details/synchronous_factory.h0000644000176200001440000000135714550234366024154 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include "registry.h" namespace spdlog { // Default logger factory- creates synchronous loggers class logger; struct synchronous_factory { template static std::shared_ptr create(std::string logger_name, SinkArgs &&...args) { auto sink = std::make_shared(std::forward(args)...); auto new_logger = std::make_shared(std::move(logger_name), std::move(sink)); details::registry::instance().initialize_logger(new_logger); return new_logger; } }; } // namespace spdlog RcppSpdlog/inst/include/spdlog/mdc.h0000644000176200001440000000156714612604314017145 0ustar liggesusers#pragma once #include #include #include namespace spdlog { class SPDLOG_API mdc { public: using mdc_map_t = std::map; static void put(const std::string &key, const std::string &value) { get_context()[key] = value; } static std::string get(const std::string &key) { auto &context = get_context(); auto it = context.find(key); if (it != context.end()) { return it->second; } return ""; } static void remove(const std::string &key) { get_context().erase(key); } static void clear() { get_context().clear(); } static mdc_map_t &get_context() { static thread_local mdc_map_t context; return context; } }; } // namespace spdlog RcppSpdlog/inst/include/spdlog/stopwatch.h0000644000176200001440000000351114612604314020405 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include // Stopwatch support for spdlog (using std::chrono::steady_clock). // Displays elapsed seconds since construction as double. // // Usage: // // spdlog::stopwatch sw; // ... // spdlog::debug("Elapsed: {} seconds", sw); => "Elapsed 0.005116733 seconds" // spdlog::info("Elapsed: {:.6} seconds", sw); => "Elapsed 0.005163 seconds" // // // If other units are needed (e.g. millis instead of double), include "fmt/chrono.h" and use // "duration_cast<..>(sw.elapsed())": // // #include //.. // using std::chrono::duration_cast; // using std::chrono::milliseconds; // spdlog::info("Elapsed {}", duration_cast(sw.elapsed())); => "Elapsed 5ms" namespace spdlog { class stopwatch { using clock = std::chrono::steady_clock; std::chrono::time_point start_tp_; public: stopwatch() : start_tp_{clock::now()} {} std::chrono::duration elapsed() const { return std::chrono::duration(clock::now() - start_tp_); } std::chrono::milliseconds elapsed_ms() const { return std::chrono::duration_cast(clock::now() - start_tp_); } void reset() { start_tp_ = clock::now(); } }; } // namespace spdlog // Support for fmt formatting (e.g. "{:012.9}" or just "{}") namespace #ifdef SPDLOG_USE_STD_FORMAT std #else fmt #endif { template <> struct formatter : formatter { template auto format(const spdlog::stopwatch &sw, FormatContext &ctx) const -> decltype(ctx.out()) { return formatter::format(sw.elapsed().count(), ctx); } }; } // namespace std RcppSpdlog/inst/include/spdlog/tweakme.h0000644000176200001440000001433014550234366020036 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once /////////////////////////////////////////////////////////////////////////////// // // Edit this file to squeeze more performance, and to customize supported // features // /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// // Under Linux, the much faster CLOCK_REALTIME_COARSE clock can be used. // This clock is less accurate - can be off by dozens of millis - depending on // the kernel HZ. // Uncomment to use it instead of the regular clock. // // #define SPDLOG_CLOCK_COARSE /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// // Uncomment if source location logging is not needed. // This will prevent spdlog from using __FILE__, __LINE__ and SPDLOG_FUNCTION // // #define SPDLOG_NO_SOURCE_LOC /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// // Uncomment if thread id logging is not needed (i.e. no %t in the log pattern). // This will prevent spdlog from querying the thread id on each log call. // // WARNING: If the log pattern contains thread id (i.e, %t) while this flag is // on, zero will be logged as thread id. // // #define SPDLOG_NO_THREAD_ID /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// // Uncomment to prevent spdlog from using thread local storage. // // WARNING: if your program forks, UNCOMMENT this flag to prevent undefined // thread ids in the children logs. // // #define SPDLOG_NO_TLS /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// // Uncomment to avoid spdlog's usage of atomic log levels // Use only if your code never modifies a logger's log levels concurrently by // different threads. // // #define SPDLOG_NO_ATOMIC_LEVELS /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// // Uncomment to enable usage of wchar_t for file names on Windows. // // #define SPDLOG_WCHAR_FILENAMES /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// // Uncomment to override default eol ("\n" or "\r\n" under Linux/Windows) // // #define SPDLOG_EOL ";-)\n" /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// // Uncomment to override default folder separators ("/" or "\\/" under // Linux/Windows). Each character in the string is treated as a different // separator. // // #define SPDLOG_FOLDER_SEPS "\\" /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// // Uncomment to use your own copy of the fmt library instead of spdlog's copy. // In this case spdlog will try to include so set your -I flag // accordingly. // // #define SPDLOG_FMT_EXTERNAL /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// // Uncomment to use C++20 std::format instead of fmt. // // #define SPDLOG_USE_STD_FORMAT /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// // Uncomment to enable wchar_t support (convert to utf8) // // #define SPDLOG_WCHAR_TO_UTF8_SUPPORT /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// // Uncomment to prevent child processes from inheriting log file descriptors // // #define SPDLOG_PREVENT_CHILD_FD /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// // Uncomment to customize level names (e.g. "MY TRACE") // // #define SPDLOG_LEVEL_NAMES { "MY TRACE", "MY DEBUG", "MY INFO", "MY WARNING", "MY ERROR", "MY // CRITICAL", "OFF" } /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// // Uncomment to customize short level names (e.g. "MT") // These can be longer than one character. // // #define SPDLOG_SHORT_LEVEL_NAMES { "T", "D", "I", "W", "E", "C", "O" } /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// // Uncomment to disable default logger creation. // This might save some (very) small initialization time if no default logger is needed. // // #define SPDLOG_DISABLE_DEFAULT_LOGGER /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// // Uncomment and set to compile time level with zero cost (default is INFO). // Macros like SPDLOG_DEBUG(..), SPDLOG_INFO(..) will expand to empty statements if not enabled // // #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// // Uncomment (and change if desired) macro to use for function names. // This is compiler dependent. // __PRETTY_FUNCTION__ might be nicer in clang/gcc, and __FUNCTION__ in msvc. // Defaults to __FUNCTION__ (should work on all compilers) if not defined. // // #ifdef __PRETTY_FUNCTION__ // # define SPDLOG_FUNCTION __PRETTY_FUNCTION__ // #else // # define SPDLOG_FUNCTION __FUNCTION__ // #endif /////////////////////////////////////////////////////////////////////////////// RcppSpdlog/inst/include/spdlog/pattern_formatter.h0000644000176200001440000000725614550234366022152 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include #include #include #include #include #include #include #include #include namespace spdlog { namespace details { // padding information. struct padding_info { enum class pad_side { left, right, center }; padding_info() = default; padding_info(size_t width, padding_info::pad_side side, bool truncate) : width_(width), side_(side), truncate_(truncate), enabled_(true) {} bool enabled() const { return enabled_; } size_t width_ = 0; pad_side side_ = pad_side::left; bool truncate_ = false; bool enabled_ = false; }; class SPDLOG_API flag_formatter { public: explicit flag_formatter(padding_info padinfo) : padinfo_(padinfo) {} flag_formatter() = default; virtual ~flag_formatter() = default; virtual void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) = 0; protected: padding_info padinfo_; }; } // namespace details class SPDLOG_API custom_flag_formatter : public details::flag_formatter { public: virtual std::unique_ptr clone() const = 0; void set_padding_info(const details::padding_info &padding) { flag_formatter::padinfo_ = padding; } }; class SPDLOG_API pattern_formatter final : public formatter { public: using custom_flags = std::unordered_map>; explicit pattern_formatter(std::string pattern, pattern_time_type time_type = pattern_time_type::local, std::string eol = spdlog::details::os::default_eol, custom_flags custom_user_flags = custom_flags()); // use default pattern is not given explicit pattern_formatter(pattern_time_type time_type = pattern_time_type::local, std::string eol = spdlog::details::os::default_eol); pattern_formatter(const pattern_formatter &other) = delete; pattern_formatter &operator=(const pattern_formatter &other) = delete; std::unique_ptr clone() const override; void format(const details::log_msg &msg, memory_buf_t &dest) override; template pattern_formatter &add_flag(char flag, Args &&...args) { custom_handlers_[flag] = details::make_unique(std::forward(args)...); return *this; } void set_pattern(std::string pattern); void need_localtime(bool need = true); private: std::string pattern_; std::string eol_; pattern_time_type pattern_time_type_; bool need_localtime_; std::tm cached_tm_; std::chrono::seconds last_log_secs_; std::vector> formatters_; custom_flags custom_handlers_; std::tm get_time_(const details::log_msg &msg); template void handle_flag_(char flag, details::padding_info padding); // Extract given pad spec (e.g. %8X) // Advance the given it pass the end of the padding spec found (if any) // Return padding. static details::padding_info handle_padspec_(std::string::const_iterator &it, std::string::const_iterator end); void compile_pattern_(const std::string &pattern); }; } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY #include "pattern_formatter-inl.h" #endif RcppSpdlog/inst/include/spdlog/fmt/0000755000176200001440000000000014612604314017006 5ustar liggesusersRcppSpdlog/inst/include/spdlog/fmt/ostr.h0000644000176200001440000000105214550234366020153 0ustar liggesusers// // Copyright(c) 2016 Gabi Melman. // Distributed under the MIT License (http://opensource.org/licenses/MIT) // #pragma once // // include bundled or external copy of fmtlib's ostream support // #include #if !defined(SPDLOG_USE_STD_FORMAT) #if !defined(SPDLOG_FMT_EXTERNAL) #ifdef SPDLOG_HEADER_ONLY #ifndef FMT_HEADER_ONLY #define FMT_HEADER_ONLY #endif #endif #include #else #include #endif #endif RcppSpdlog/inst/include/spdlog/fmt/bundled/0000755000176200001440000000000014612604314020423 5ustar liggesusersRcppSpdlog/inst/include/spdlog/fmt/bundled/compile.h0000644000176200001440000004503614612604314022234 0ustar liggesusers// Formatting library for C++ - experimental format string compilation // // Copyright (c) 2012 - present, Victor Zverovich and fmt contributors // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_COMPILE_H_ #define FMT_COMPILE_H_ #include "format.h" FMT_BEGIN_NAMESPACE namespace detail { template FMT_CONSTEXPR inline auto copy_str(InputIt begin, InputIt end, counting_iterator it) -> counting_iterator { return it + (end - begin); } // A compile-time string which is compiled into fast formatting code. class compiled_string {}; template struct is_compiled_string : std::is_base_of {}; /** \rst Converts a string literal *s* into a format string that will be parsed at compile time and converted into efficient formatting code. Requires C++17 ``constexpr if`` compiler support. **Example**:: // Converts 42 into std::string using the most efficient method and no // runtime format string processing. std::string s = fmt::format(FMT_COMPILE("{}"), 42); \endrst */ #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) # define FMT_COMPILE(s) \ FMT_STRING_IMPL(s, fmt::detail::compiled_string, explicit) #else # define FMT_COMPILE(s) FMT_STRING(s) #endif #if FMT_USE_NONTYPE_TEMPLATE_ARGS template Str> struct udl_compiled_string : compiled_string { using char_type = Char; explicit constexpr operator basic_string_view() const { return {Str.data, N - 1}; } }; #endif template auto first(const T& value, const Tail&...) -> const T& { return value; } #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) template struct type_list {}; // Returns a reference to the argument at index N from [first, rest...]. template constexpr const auto& get([[maybe_unused]] const T& first, [[maybe_unused]] const Args&... rest) { static_assert(N < 1 + sizeof...(Args), "index is out of bounds"); if constexpr (N == 0) return first; else return detail::get(rest...); } template constexpr int get_arg_index_by_name(basic_string_view name, type_list) { return get_arg_index_by_name(name); } template struct get_type_impl; template struct get_type_impl> { using type = remove_cvref_t(std::declval()...))>; }; template using get_type = typename get_type_impl::type; template struct is_compiled_format : std::false_type {}; template struct text { basic_string_view data; using char_type = Char; template constexpr OutputIt format(OutputIt out, const Args&...) const { return write(out, data); } }; template struct is_compiled_format> : std::true_type {}; template constexpr text make_text(basic_string_view s, size_t pos, size_t size) { return {{&s[pos], size}}; } template struct code_unit { Char value; using char_type = Char; template constexpr OutputIt format(OutputIt out, const Args&...) const { *out++ = value; return out; } }; // This ensures that the argument type is convertible to `const T&`. template constexpr const T& get_arg_checked(const Args&... args) { const auto& arg = detail::get(args...); if constexpr (detail::is_named_arg>()) { return arg.value; } else { return arg; } } template struct is_compiled_format> : std::true_type {}; // A replacement field that refers to argument N. template struct field { using char_type = Char; template constexpr OutputIt format(OutputIt out, const Args&... args) const { const T& arg = get_arg_checked(args...); if constexpr (std::is_convertible_v>) { auto s = basic_string_view(arg); return copy_str(s.begin(), s.end(), out); } return write(out, arg); } }; template struct is_compiled_format> : std::true_type {}; // A replacement field that refers to argument with name. template struct runtime_named_field { using char_type = Char; basic_string_view name; template constexpr static bool try_format_argument( OutputIt& out, // [[maybe_unused]] due to unused-but-set-parameter warning in GCC 7,8,9 [[maybe_unused]] basic_string_view arg_name, const T& arg) { if constexpr (is_named_arg::type>::value) { if (arg_name == arg.name) { out = write(out, arg.value); return true; } } return false; } template constexpr OutputIt format(OutputIt out, const Args&... args) const { bool found = (try_format_argument(out, name, args) || ...); if (!found) { FMT_THROW(format_error("argument with specified name is not found")); } return out; } }; template struct is_compiled_format> : std::true_type {}; // A replacement field that refers to argument N and has format specifiers. template struct spec_field { using char_type = Char; formatter fmt; template constexpr FMT_INLINE OutputIt format(OutputIt out, const Args&... args) const { const auto& vargs = fmt::make_format_args>(args...); basic_format_context ctx(out, vargs); return fmt.format(get_arg_checked(args...), ctx); } }; template struct is_compiled_format> : std::true_type {}; template struct concat { L lhs; R rhs; using char_type = typename L::char_type; template constexpr OutputIt format(OutputIt out, const Args&... args) const { out = lhs.format(out, args...); return rhs.format(out, args...); } }; template struct is_compiled_format> : std::true_type {}; template constexpr concat make_concat(L lhs, R rhs) { return {lhs, rhs}; } struct unknown_format {}; template constexpr size_t parse_text(basic_string_view str, size_t pos) { for (size_t size = str.size(); pos != size; ++pos) { if (str[pos] == '{' || str[pos] == '}') break; } return pos; } template constexpr auto compile_format_string(S format_str); template constexpr auto parse_tail(T head, S format_str) { if constexpr (POS != basic_string_view(format_str).size()) { constexpr auto tail = compile_format_string(format_str); if constexpr (std::is_same, unknown_format>()) return tail; else return make_concat(head, tail); } else { return head; } } template struct parse_specs_result { formatter fmt; size_t end; int next_arg_id; }; enum { manual_indexing_id = -1 }; template constexpr parse_specs_result parse_specs(basic_string_view str, size_t pos, int next_arg_id) { str.remove_prefix(pos); auto ctx = compile_parse_context(str, max_value(), nullptr, next_arg_id); auto f = formatter(); auto end = f.parse(ctx); return {f, pos + fmt::detail::to_unsigned(end - str.data()), next_arg_id == 0 ? manual_indexing_id : ctx.next_arg_id()}; } template struct arg_id_handler { arg_ref arg_id; constexpr int on_auto() { FMT_ASSERT(false, "handler cannot be used with automatic indexing"); return 0; } constexpr int on_index(int id) { arg_id = arg_ref(id); return 0; } constexpr int on_name(basic_string_view id) { arg_id = arg_ref(id); return 0; } }; template struct parse_arg_id_result { arg_ref arg_id; const Char* arg_id_end; }; template constexpr auto parse_arg_id(const Char* begin, const Char* end) { auto handler = arg_id_handler{arg_ref{}}; auto arg_id_end = parse_arg_id(begin, end, handler); return parse_arg_id_result{handler.arg_id, arg_id_end}; } template struct field_type { using type = remove_cvref_t; }; template struct field_type::value>> { using type = remove_cvref_t; }; template constexpr auto parse_replacement_field_then_tail(S format_str) { using char_type = typename S::char_type; constexpr auto str = basic_string_view(format_str); constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type(); if constexpr (c == '}') { return parse_tail( field::type, ARG_INDEX>(), format_str); } else if constexpr (c != ':') { FMT_THROW(format_error("expected ':'")); } else { constexpr auto result = parse_specs::type>( str, END_POS + 1, NEXT_ID == manual_indexing_id ? 0 : NEXT_ID); if constexpr (result.end >= str.size() || str[result.end] != '}') { FMT_THROW(format_error("expected '}'")); return 0; } else { return parse_tail( spec_field::type, ARG_INDEX>{ result.fmt}, format_str); } } } // Compiles a non-empty format string and returns the compiled representation // or unknown_format() on unrecognized input. template constexpr auto compile_format_string(S format_str) { using char_type = typename S::char_type; constexpr auto str = basic_string_view(format_str); if constexpr (str[POS] == '{') { if constexpr (POS + 1 == str.size()) FMT_THROW(format_error("unmatched '{' in format string")); if constexpr (str[POS + 1] == '{') { return parse_tail(make_text(str, POS, 1), format_str); } else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') { static_assert(ID != manual_indexing_id, "cannot switch from manual to automatic argument indexing"); constexpr auto next_id = ID != manual_indexing_id ? ID + 1 : manual_indexing_id; return parse_replacement_field_then_tail, Args, POS + 1, ID, next_id>( format_str); } else { constexpr auto arg_id_result = parse_arg_id(str.data() + POS + 1, str.data() + str.size()); constexpr auto arg_id_end_pos = arg_id_result.arg_id_end - str.data(); constexpr char_type c = arg_id_end_pos != str.size() ? str[arg_id_end_pos] : char_type(); static_assert(c == '}' || c == ':', "missing '}' in format string"); if constexpr (arg_id_result.arg_id.kind == arg_id_kind::index) { static_assert( ID == manual_indexing_id || ID == 0, "cannot switch from automatic to manual argument indexing"); constexpr auto arg_index = arg_id_result.arg_id.val.index; return parse_replacement_field_then_tail, Args, arg_id_end_pos, arg_index, manual_indexing_id>( format_str); } else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) { constexpr auto arg_index = get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{}); if constexpr (arg_index >= 0) { constexpr auto next_id = ID != manual_indexing_id ? ID + 1 : manual_indexing_id; return parse_replacement_field_then_tail< decltype(get_type::value), Args, arg_id_end_pos, arg_index, next_id>(format_str); } else if constexpr (c == '}') { return parse_tail( runtime_named_field{arg_id_result.arg_id.val.name}, format_str); } else if constexpr (c == ':') { return unknown_format(); // no type info for specs parsing } } } } else if constexpr (str[POS] == '}') { if constexpr (POS + 1 == str.size()) FMT_THROW(format_error("unmatched '}' in format string")); return parse_tail(make_text(str, POS, 1), format_str); } else { constexpr auto end = parse_text(str, POS + 1); if constexpr (end - POS > 1) { return parse_tail(make_text(str, POS, end - POS), format_str); } else { return parse_tail(code_unit{str[POS]}, format_str); } } } template ::value)> constexpr auto compile(S format_str) { constexpr auto str = basic_string_view(format_str); if constexpr (str.size() == 0) { return detail::make_text(str, 0, 0); } else { constexpr auto result = detail::compile_format_string, 0, 0>( format_str); return result; } } #endif // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) } // namespace detail FMT_BEGIN_EXPORT #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) template ::value)> FMT_INLINE std::basic_string format(const CompiledFormat& cf, const Args&... args) { auto s = std::basic_string(); cf.format(std::back_inserter(s), args...); return s; } template ::value)> constexpr FMT_INLINE OutputIt format_to(OutputIt out, const CompiledFormat& cf, const Args&... args) { return cf.format(out, args...); } template ::value)> FMT_INLINE std::basic_string format(const S&, Args&&... args) { if constexpr (std::is_same::value) { constexpr auto str = basic_string_view(S()); if constexpr (str.size() == 2 && str[0] == '{' && str[1] == '}') { const auto& first = detail::first(args...); if constexpr (detail::is_named_arg< remove_cvref_t>::value) { return fmt::to_string(first.value); } else { return fmt::to_string(first); } } } constexpr auto compiled = detail::compile(S()); if constexpr (std::is_same, detail::unknown_format>()) { return fmt::format( static_cast>(S()), std::forward(args)...); } else { return fmt::format(compiled, std::forward(args)...); } } template ::value)> FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) { constexpr auto compiled = detail::compile(S()); if constexpr (std::is_same, detail::unknown_format>()) { return fmt::format_to( out, static_cast>(S()), std::forward(args)...); } else { return fmt::format_to(out, compiled, std::forward(args)...); } } #endif template ::value)> auto format_to_n(OutputIt out, size_t n, const S& format_str, Args&&... args) -> format_to_n_result { using traits = detail::fixed_buffer_traits; auto buf = detail::iterator_buffer(out, n); fmt::format_to(std::back_inserter(buf), format_str, std::forward(args)...); return {buf.out(), buf.count()}; } template ::value)> FMT_CONSTEXPR20 auto formatted_size(const S& format_str, const Args&... args) -> size_t { return fmt::format_to(detail::counting_iterator(), format_str, args...) .count(); } template ::value)> void print(std::FILE* f, const S& format_str, const Args&... args) { memory_buffer buffer; fmt::format_to(std::back_inserter(buffer), format_str, args...); detail::print(f, {buffer.data(), buffer.size()}); } template ::value)> void print(const S& format_str, const Args&... args) { print(stdout, format_str, args...); } #if FMT_USE_NONTYPE_TEMPLATE_ARGS inline namespace literals { template constexpr auto operator""_cf() { using char_t = remove_cvref_t; return detail::udl_compiled_string(); } } // namespace literals #endif FMT_END_EXPORT FMT_END_NAMESPACE #endif // FMT_COMPILE_H_ RcppSpdlog/inst/include/spdlog/fmt/bundled/locale.h0000644000176200001440000000014414065412366022040 0ustar liggesusers#include "xchar.h" #warning fmt/locale.h is deprecated, include fmt/format.h or fmt/xchar.h instead RcppSpdlog/inst/include/spdlog/fmt/bundled/printf.h0000644000176200001440000005054514612604314022107 0ustar liggesusers// Formatting library for C++ - legacy printf implementation // // Copyright (c) 2012 - 2016, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_PRINTF_H_ #define FMT_PRINTF_H_ #include // std::max #include // std::numeric_limits #include "format.h" FMT_BEGIN_NAMESPACE FMT_BEGIN_EXPORT template struct printf_formatter { printf_formatter() = delete; }; template class basic_printf_context { private: detail::buffer_appender out_; basic_format_args args_; static_assert(std::is_same::value || std::is_same::value, "Unsupported code unit type."); public: using char_type = Char; using parse_context_type = basic_format_parse_context; template using formatter_type = printf_formatter; /** \rst Constructs a ``printf_context`` object. References to the arguments are stored in the context object so make sure they have appropriate lifetimes. \endrst */ basic_printf_context(detail::buffer_appender out, basic_format_args args) : out_(out), args_(args) {} auto out() -> detail::buffer_appender { return out_; } void advance_to(detail::buffer_appender) {} auto locale() -> detail::locale_ref { return {}; } auto arg(int id) const -> basic_format_arg { return args_.get(id); } FMT_CONSTEXPR void on_error(const char* message) { detail::error_handler().on_error(message); } }; namespace detail { // Checks if a value fits in int - used to avoid warnings about comparing // signed and unsigned integers. template struct int_checker { template static auto fits_in_int(T value) -> bool { unsigned max = max_value(); return value <= max; } static auto fits_in_int(bool) -> bool { return true; } }; template <> struct int_checker { template static auto fits_in_int(T value) -> bool { return value >= (std::numeric_limits::min)() && value <= max_value(); } static auto fits_in_int(int) -> bool { return true; } }; struct printf_precision_handler { template ::value)> auto operator()(T value) -> int { if (!int_checker::is_signed>::fits_in_int(value)) throw_format_error("number is too big"); return (std::max)(static_cast(value), 0); } template ::value)> auto operator()(T) -> int { throw_format_error("precision is not integer"); return 0; } }; // An argument visitor that returns true iff arg is a zero integer. struct is_zero_int { template ::value)> auto operator()(T value) -> bool { return value == 0; } template ::value)> auto operator()(T) -> bool { return false; } }; template struct make_unsigned_or_bool : std::make_unsigned {}; template <> struct make_unsigned_or_bool { using type = bool; }; template class arg_converter { private: using char_type = typename Context::char_type; basic_format_arg& arg_; char_type type_; public: arg_converter(basic_format_arg& arg, char_type type) : arg_(arg), type_(type) {} void operator()(bool value) { if (type_ != 's') operator()(value); } template ::value)> void operator()(U value) { bool is_signed = type_ == 'd' || type_ == 'i'; using target_type = conditional_t::value, U, T>; if (const_check(sizeof(target_type) <= sizeof(int))) { // Extra casts are used to silence warnings. if (is_signed) { auto n = static_cast(static_cast(value)); arg_ = detail::make_arg(n); } else { using unsigned_type = typename make_unsigned_or_bool::type; auto n = static_cast(static_cast(value)); arg_ = detail::make_arg(n); } } else { if (is_signed) { // glibc's printf doesn't sign extend arguments of smaller types: // std::printf("%lld", -42); // prints "4294967254" // but we don't have to do the same because it's a UB. auto n = static_cast(value); arg_ = detail::make_arg(n); } else { auto n = static_cast::type>(value); arg_ = detail::make_arg(n); } } } template ::value)> void operator()(U) {} // No conversion needed for non-integral types. }; // Converts an integer argument to T for printf, if T is an integral type. // If T is void, the argument is converted to corresponding signed or unsigned // type depending on the type specifier: 'd' and 'i' - signed, other - // unsigned). template void convert_arg(basic_format_arg& arg, Char type) { visit_format_arg(arg_converter(arg, type), arg); } // Converts an integer argument to char for printf. template class char_converter { private: basic_format_arg& arg_; public: explicit char_converter(basic_format_arg& arg) : arg_(arg) {} template ::value)> void operator()(T value) { auto c = static_cast(value); arg_ = detail::make_arg(c); } template ::value)> void operator()(T) {} // No conversion needed for non-integral types. }; // An argument visitor that return a pointer to a C string if argument is a // string or null otherwise. template struct get_cstring { template auto operator()(T) -> const Char* { return nullptr; } auto operator()(const Char* s) -> const Char* { return s; } }; // Checks if an argument is a valid printf width specifier and sets // left alignment if it is negative. template class printf_width_handler { private: format_specs& specs_; public: explicit printf_width_handler(format_specs& specs) : specs_(specs) {} template ::value)> auto operator()(T value) -> unsigned { auto width = static_cast>(value); if (detail::is_negative(value)) { specs_.align = align::left; width = 0 - width; } unsigned int_max = max_value(); if (width > int_max) throw_format_error("number is too big"); return static_cast(width); } template ::value)> auto operator()(T) -> unsigned { throw_format_error("width is not integer"); return 0; } }; // Workaround for a bug with the XL compiler when initializing // printf_arg_formatter's base class. template auto make_arg_formatter(buffer_appender iter, format_specs& s) -> arg_formatter { return {iter, s, locale_ref()}; } // The ``printf`` argument formatter. template class printf_arg_formatter : public arg_formatter { private: using base = arg_formatter; using context_type = basic_printf_context; context_type& context_; void write_null_pointer(bool is_string = false) { auto s = this->specs; s.type = presentation_type::none; write_bytes(this->out, is_string ? "(null)" : "(nil)", s); } public: printf_arg_formatter(buffer_appender iter, format_specs& s, context_type& ctx) : base(make_arg_formatter(iter, s)), context_(ctx) {} void operator()(monostate value) { base::operator()(value); } template ::value)> void operator()(T value) { // MSVC2013 fails to compile separate overloads for bool and Char so use // std::is_same instead. if (!std::is_same::value) { base::operator()(value); return; } format_specs fmt_specs = this->specs; if (fmt_specs.type != presentation_type::none && fmt_specs.type != presentation_type::chr) { return (*this)(static_cast(value)); } fmt_specs.sign = sign::none; fmt_specs.alt = false; fmt_specs.fill[0] = ' '; // Ignore '0' flag for char types. // align::numeric needs to be overwritten here since the '0' flag is // ignored for non-numeric types if (fmt_specs.align == align::none || fmt_specs.align == align::numeric) fmt_specs.align = align::right; write(this->out, static_cast(value), fmt_specs); } template ::value)> void operator()(T value) { base::operator()(value); } /** Formats a null-terminated C string. */ void operator()(const char* value) { if (value) base::operator()(value); else write_null_pointer(this->specs.type != presentation_type::pointer); } /** Formats a null-terminated wide C string. */ void operator()(const wchar_t* value) { if (value) base::operator()(value); else write_null_pointer(this->specs.type != presentation_type::pointer); } void operator()(basic_string_view value) { base::operator()(value); } /** Formats a pointer. */ void operator()(const void* value) { if (value) base::operator()(value); else write_null_pointer(); } /** Formats an argument of a custom (user-defined) type. */ void operator()(typename basic_format_arg::handle handle) { auto parse_ctx = basic_format_parse_context({}); handle.format(parse_ctx, context_); } }; template void parse_flags(format_specs& specs, const Char*& it, const Char* end) { for (; it != end; ++it) { switch (*it) { case '-': specs.align = align::left; break; case '+': specs.sign = sign::plus; break; case '0': specs.fill[0] = '0'; break; case ' ': if (specs.sign != sign::plus) specs.sign = sign::space; break; case '#': specs.alt = true; break; default: return; } } } template auto parse_header(const Char*& it, const Char* end, format_specs& specs, GetArg get_arg) -> int { int arg_index = -1; Char c = *it; if (c >= '0' && c <= '9') { // Parse an argument index (if followed by '$') or a width possibly // preceded with '0' flag(s). int value = parse_nonnegative_int(it, end, -1); if (it != end && *it == '$') { // value is an argument index ++it; arg_index = value != -1 ? value : max_value(); } else { if (c == '0') specs.fill[0] = '0'; if (value != 0) { // Nonzero value means that we parsed width and don't need to // parse it or flags again, so return now. if (value == -1) throw_format_error("number is too big"); specs.width = value; return arg_index; } } } parse_flags(specs, it, end); // Parse width. if (it != end) { if (*it >= '0' && *it <= '9') { specs.width = parse_nonnegative_int(it, end, -1); if (specs.width == -1) throw_format_error("number is too big"); } else if (*it == '*') { ++it; specs.width = static_cast(visit_format_arg( detail::printf_width_handler(specs), get_arg(-1))); } } return arg_index; } inline auto parse_printf_presentation_type(char c, type t) -> presentation_type { using pt = presentation_type; constexpr auto integral_set = sint_set | uint_set | bool_set | char_set; switch (c) { case 'd': return in(t, integral_set) ? pt::dec : pt::none; case 'o': return in(t, integral_set) ? pt::oct : pt::none; case 'x': return in(t, integral_set) ? pt::hex_lower : pt::none; case 'X': return in(t, integral_set) ? pt::hex_upper : pt::none; case 'a': return in(t, float_set) ? pt::hexfloat_lower : pt::none; case 'A': return in(t, float_set) ? pt::hexfloat_upper : pt::none; case 'e': return in(t, float_set) ? pt::exp_lower : pt::none; case 'E': return in(t, float_set) ? pt::exp_upper : pt::none; case 'f': return in(t, float_set) ? pt::fixed_lower : pt::none; case 'F': return in(t, float_set) ? pt::fixed_upper : pt::none; case 'g': return in(t, float_set) ? pt::general_lower : pt::none; case 'G': return in(t, float_set) ? pt::general_upper : pt::none; case 'c': return in(t, integral_set) ? pt::chr : pt::none; case 's': return in(t, string_set | cstring_set) ? pt::string : pt::none; case 'p': return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none; default: return pt::none; } } template void vprintf(buffer& buf, basic_string_view format, basic_format_args args) { using iterator = buffer_appender; auto out = iterator(buf); auto context = basic_printf_context(out, args); auto parse_ctx = basic_format_parse_context(format); // Returns the argument with specified index or, if arg_index is -1, the next // argument. auto get_arg = [&](int arg_index) { if (arg_index < 0) arg_index = parse_ctx.next_arg_id(); else parse_ctx.check_arg_id(--arg_index); return detail::get_arg(context, arg_index); }; const Char* start = parse_ctx.begin(); const Char* end = parse_ctx.end(); auto it = start; while (it != end) { if (!find(it, end, '%', it)) { it = end; // find leaves it == nullptr if it doesn't find '%'. break; } Char c = *it++; if (it != end && *it == c) { write(out, basic_string_view(start, to_unsigned(it - start))); start = ++it; continue; } write(out, basic_string_view(start, to_unsigned(it - 1 - start))); auto specs = format_specs(); specs.align = align::right; // Parse argument index, flags and width. int arg_index = parse_header(it, end, specs, get_arg); if (arg_index == 0) throw_format_error("argument not found"); // Parse precision. if (it != end && *it == '.') { ++it; c = it != end ? *it : 0; if ('0' <= c && c <= '9') { specs.precision = parse_nonnegative_int(it, end, 0); } else if (c == '*') { ++it; specs.precision = static_cast( visit_format_arg(printf_precision_handler(), get_arg(-1))); } else { specs.precision = 0; } } auto arg = get_arg(arg_index); // For d, i, o, u, x, and X conversion specifiers, if a precision is // specified, the '0' flag is ignored if (specs.precision >= 0 && arg.is_integral()) { // Ignore '0' for non-numeric types or if '-' present. specs.fill[0] = ' '; } if (specs.precision >= 0 && arg.type() == type::cstring_type) { auto str = visit_format_arg(get_cstring(), arg); auto str_end = str + specs.precision; auto nul = std::find(str, str_end, Char()); auto sv = basic_string_view( str, to_unsigned(nul != str_end ? nul - str : specs.precision)); arg = make_arg>(sv); } if (specs.alt && visit_format_arg(is_zero_int(), arg)) specs.alt = false; if (specs.fill[0] == '0') { if (arg.is_arithmetic() && specs.align != align::left) specs.align = align::numeric; else specs.fill[0] = ' '; // Ignore '0' flag for non-numeric types or if '-' // flag is also present. } // Parse length and convert the argument to the required type. c = it != end ? *it++ : 0; Char t = it != end ? *it : 0; switch (c) { case 'h': if (t == 'h') { ++it; t = it != end ? *it : 0; convert_arg(arg, t); } else { convert_arg(arg, t); } break; case 'l': if (t == 'l') { ++it; t = it != end ? *it : 0; convert_arg(arg, t); } else { convert_arg(arg, t); } break; case 'j': convert_arg(arg, t); break; case 'z': convert_arg(arg, t); break; case 't': convert_arg(arg, t); break; case 'L': // printf produces garbage when 'L' is omitted for long double, no // need to do the same. break; default: --it; convert_arg(arg, c); } // Parse type. if (it == end) throw_format_error("invalid format string"); char type = static_cast(*it++); if (arg.is_integral()) { // Normalize type. switch (type) { case 'i': case 'u': type = 'd'; break; case 'c': visit_format_arg(char_converter>(arg), arg); break; } } specs.type = parse_printf_presentation_type(type, arg.type()); if (specs.type == presentation_type::none) throw_format_error("invalid format specifier"); start = it; // Format argument. visit_format_arg(printf_arg_formatter(out, specs, context), arg); } write(out, basic_string_view(start, to_unsigned(it - start))); } } // namespace detail using printf_context = basic_printf_context; using wprintf_context = basic_printf_context; using printf_args = basic_format_args; using wprintf_args = basic_format_args; /** \rst Constructs an `~fmt::format_arg_store` object that contains references to arguments and can be implicitly converted to `~fmt::printf_args`. \endrst */ template inline auto make_printf_args(const T&... args) -> format_arg_store { return {args...}; } // DEPRECATED! template inline auto make_wprintf_args(const T&... args) -> format_arg_store { return {args...}; } template inline auto vsprintf( basic_string_view fmt, basic_format_args>> args) -> std::basic_string { auto buf = basic_memory_buffer(); detail::vprintf(buf, fmt, args); return to_string(buf); } /** \rst Formats arguments and returns the result as a string. **Example**:: std::string message = fmt::sprintf("The answer is %d", 42); \endrst */ template ::value, char_t>> inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string { return vsprintf(detail::to_string_view(fmt), fmt::make_format_args>(args...)); } template inline auto vfprintf( std::FILE* f, basic_string_view fmt, basic_format_args>> args) -> int { auto buf = basic_memory_buffer(); detail::vprintf(buf, fmt, args); size_t size = buf.size(); return std::fwrite(buf.data(), sizeof(Char), size, f) < size ? -1 : static_cast(size); } /** \rst Prints formatted data to the file *f*. **Example**:: fmt::fprintf(stderr, "Don't %s!", "panic"); \endrst */ template > inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int { return vfprintf(f, detail::to_string_view(fmt), fmt::make_format_args>(args...)); } template FMT_DEPRECATED inline auto vprintf( basic_string_view fmt, basic_format_args>> args) -> int { return vfprintf(stdout, fmt, args); } /** \rst Prints formatted data to ``stdout``. **Example**:: fmt::printf("Elapsed time: %.2f seconds", 1.23); \endrst */ template inline auto printf(string_view fmt, const T&... args) -> int { return vfprintf(stdout, fmt, make_printf_args(args...)); } template FMT_DEPRECATED inline auto printf(basic_string_view fmt, const T&... args) -> int { return vfprintf(stdout, fmt, make_wprintf_args(args...)); } FMT_END_EXPORT FMT_END_NAMESPACE #endif // FMT_PRINTF_H_ RcppSpdlog/inst/include/spdlog/fmt/bundled/color.h0000644000176200001440000005772314612604314021730 0ustar liggesusers// Formatting library for C++ - color support // // Copyright (c) 2018 - present, Victor Zverovich and fmt contributors // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_COLOR_H_ #define FMT_COLOR_H_ #include "format.h" FMT_BEGIN_NAMESPACE FMT_BEGIN_EXPORT enum class color : uint32_t { alice_blue = 0xF0F8FF, // rgb(240,248,255) antique_white = 0xFAEBD7, // rgb(250,235,215) aqua = 0x00FFFF, // rgb(0,255,255) aquamarine = 0x7FFFD4, // rgb(127,255,212) azure = 0xF0FFFF, // rgb(240,255,255) beige = 0xF5F5DC, // rgb(245,245,220) bisque = 0xFFE4C4, // rgb(255,228,196) black = 0x000000, // rgb(0,0,0) blanched_almond = 0xFFEBCD, // rgb(255,235,205) blue = 0x0000FF, // rgb(0,0,255) blue_violet = 0x8A2BE2, // rgb(138,43,226) brown = 0xA52A2A, // rgb(165,42,42) burly_wood = 0xDEB887, // rgb(222,184,135) cadet_blue = 0x5F9EA0, // rgb(95,158,160) chartreuse = 0x7FFF00, // rgb(127,255,0) chocolate = 0xD2691E, // rgb(210,105,30) coral = 0xFF7F50, // rgb(255,127,80) cornflower_blue = 0x6495ED, // rgb(100,149,237) cornsilk = 0xFFF8DC, // rgb(255,248,220) crimson = 0xDC143C, // rgb(220,20,60) cyan = 0x00FFFF, // rgb(0,255,255) dark_blue = 0x00008B, // rgb(0,0,139) dark_cyan = 0x008B8B, // rgb(0,139,139) dark_golden_rod = 0xB8860B, // rgb(184,134,11) dark_gray = 0xA9A9A9, // rgb(169,169,169) dark_green = 0x006400, // rgb(0,100,0) dark_khaki = 0xBDB76B, // rgb(189,183,107) dark_magenta = 0x8B008B, // rgb(139,0,139) dark_olive_green = 0x556B2F, // rgb(85,107,47) dark_orange = 0xFF8C00, // rgb(255,140,0) dark_orchid = 0x9932CC, // rgb(153,50,204) dark_red = 0x8B0000, // rgb(139,0,0) dark_salmon = 0xE9967A, // rgb(233,150,122) dark_sea_green = 0x8FBC8F, // rgb(143,188,143) dark_slate_blue = 0x483D8B, // rgb(72,61,139) dark_slate_gray = 0x2F4F4F, // rgb(47,79,79) dark_turquoise = 0x00CED1, // rgb(0,206,209) dark_violet = 0x9400D3, // rgb(148,0,211) deep_pink = 0xFF1493, // rgb(255,20,147) deep_sky_blue = 0x00BFFF, // rgb(0,191,255) dim_gray = 0x696969, // rgb(105,105,105) dodger_blue = 0x1E90FF, // rgb(30,144,255) fire_brick = 0xB22222, // rgb(178,34,34) floral_white = 0xFFFAF0, // rgb(255,250,240) forest_green = 0x228B22, // rgb(34,139,34) fuchsia = 0xFF00FF, // rgb(255,0,255) gainsboro = 0xDCDCDC, // rgb(220,220,220) ghost_white = 0xF8F8FF, // rgb(248,248,255) gold = 0xFFD700, // rgb(255,215,0) golden_rod = 0xDAA520, // rgb(218,165,32) gray = 0x808080, // rgb(128,128,128) green = 0x008000, // rgb(0,128,0) green_yellow = 0xADFF2F, // rgb(173,255,47) honey_dew = 0xF0FFF0, // rgb(240,255,240) hot_pink = 0xFF69B4, // rgb(255,105,180) indian_red = 0xCD5C5C, // rgb(205,92,92) indigo = 0x4B0082, // rgb(75,0,130) ivory = 0xFFFFF0, // rgb(255,255,240) khaki = 0xF0E68C, // rgb(240,230,140) lavender = 0xE6E6FA, // rgb(230,230,250) lavender_blush = 0xFFF0F5, // rgb(255,240,245) lawn_green = 0x7CFC00, // rgb(124,252,0) lemon_chiffon = 0xFFFACD, // rgb(255,250,205) light_blue = 0xADD8E6, // rgb(173,216,230) light_coral = 0xF08080, // rgb(240,128,128) light_cyan = 0xE0FFFF, // rgb(224,255,255) light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210) light_gray = 0xD3D3D3, // rgb(211,211,211) light_green = 0x90EE90, // rgb(144,238,144) light_pink = 0xFFB6C1, // rgb(255,182,193) light_salmon = 0xFFA07A, // rgb(255,160,122) light_sea_green = 0x20B2AA, // rgb(32,178,170) light_sky_blue = 0x87CEFA, // rgb(135,206,250) light_slate_gray = 0x778899, // rgb(119,136,153) light_steel_blue = 0xB0C4DE, // rgb(176,196,222) light_yellow = 0xFFFFE0, // rgb(255,255,224) lime = 0x00FF00, // rgb(0,255,0) lime_green = 0x32CD32, // rgb(50,205,50) linen = 0xFAF0E6, // rgb(250,240,230) magenta = 0xFF00FF, // rgb(255,0,255) maroon = 0x800000, // rgb(128,0,0) medium_aquamarine = 0x66CDAA, // rgb(102,205,170) medium_blue = 0x0000CD, // rgb(0,0,205) medium_orchid = 0xBA55D3, // rgb(186,85,211) medium_purple = 0x9370DB, // rgb(147,112,219) medium_sea_green = 0x3CB371, // rgb(60,179,113) medium_slate_blue = 0x7B68EE, // rgb(123,104,238) medium_spring_green = 0x00FA9A, // rgb(0,250,154) medium_turquoise = 0x48D1CC, // rgb(72,209,204) medium_violet_red = 0xC71585, // rgb(199,21,133) midnight_blue = 0x191970, // rgb(25,25,112) mint_cream = 0xF5FFFA, // rgb(245,255,250) misty_rose = 0xFFE4E1, // rgb(255,228,225) moccasin = 0xFFE4B5, // rgb(255,228,181) navajo_white = 0xFFDEAD, // rgb(255,222,173) navy = 0x000080, // rgb(0,0,128) old_lace = 0xFDF5E6, // rgb(253,245,230) olive = 0x808000, // rgb(128,128,0) olive_drab = 0x6B8E23, // rgb(107,142,35) orange = 0xFFA500, // rgb(255,165,0) orange_red = 0xFF4500, // rgb(255,69,0) orchid = 0xDA70D6, // rgb(218,112,214) pale_golden_rod = 0xEEE8AA, // rgb(238,232,170) pale_green = 0x98FB98, // rgb(152,251,152) pale_turquoise = 0xAFEEEE, // rgb(175,238,238) pale_violet_red = 0xDB7093, // rgb(219,112,147) papaya_whip = 0xFFEFD5, // rgb(255,239,213) peach_puff = 0xFFDAB9, // rgb(255,218,185) peru = 0xCD853F, // rgb(205,133,63) pink = 0xFFC0CB, // rgb(255,192,203) plum = 0xDDA0DD, // rgb(221,160,221) powder_blue = 0xB0E0E6, // rgb(176,224,230) purple = 0x800080, // rgb(128,0,128) rebecca_purple = 0x663399, // rgb(102,51,153) red = 0xFF0000, // rgb(255,0,0) rosy_brown = 0xBC8F8F, // rgb(188,143,143) royal_blue = 0x4169E1, // rgb(65,105,225) saddle_brown = 0x8B4513, // rgb(139,69,19) salmon = 0xFA8072, // rgb(250,128,114) sandy_brown = 0xF4A460, // rgb(244,164,96) sea_green = 0x2E8B57, // rgb(46,139,87) sea_shell = 0xFFF5EE, // rgb(255,245,238) sienna = 0xA0522D, // rgb(160,82,45) silver = 0xC0C0C0, // rgb(192,192,192) sky_blue = 0x87CEEB, // rgb(135,206,235) slate_blue = 0x6A5ACD, // rgb(106,90,205) slate_gray = 0x708090, // rgb(112,128,144) snow = 0xFFFAFA, // rgb(255,250,250) spring_green = 0x00FF7F, // rgb(0,255,127) steel_blue = 0x4682B4, // rgb(70,130,180) tan = 0xD2B48C, // rgb(210,180,140) teal = 0x008080, // rgb(0,128,128) thistle = 0xD8BFD8, // rgb(216,191,216) tomato = 0xFF6347, // rgb(255,99,71) turquoise = 0x40E0D0, // rgb(64,224,208) violet = 0xEE82EE, // rgb(238,130,238) wheat = 0xF5DEB3, // rgb(245,222,179) white = 0xFFFFFF, // rgb(255,255,255) white_smoke = 0xF5F5F5, // rgb(245,245,245) yellow = 0xFFFF00, // rgb(255,255,0) yellow_green = 0x9ACD32 // rgb(154,205,50) }; // enum class color enum class terminal_color : uint8_t { black = 30, red, green, yellow, blue, magenta, cyan, white, bright_black = 90, bright_red, bright_green, bright_yellow, bright_blue, bright_magenta, bright_cyan, bright_white }; enum class emphasis : uint8_t { bold = 1, faint = 1 << 1, italic = 1 << 2, underline = 1 << 3, blink = 1 << 4, reverse = 1 << 5, conceal = 1 << 6, strikethrough = 1 << 7, }; // rgb is a struct for red, green and blue colors. // Using the name "rgb" makes some editors show the color in a tooltip. struct rgb { FMT_CONSTEXPR rgb() : r(0), g(0), b(0) {} FMT_CONSTEXPR rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {} FMT_CONSTEXPR rgb(uint32_t hex) : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {} FMT_CONSTEXPR rgb(color hex) : r((uint32_t(hex) >> 16) & 0xFF), g((uint32_t(hex) >> 8) & 0xFF), b(uint32_t(hex) & 0xFF) {} uint8_t r; uint8_t g; uint8_t b; }; namespace detail { // color is a struct of either a rgb color or a terminal color. struct color_type { FMT_CONSTEXPR color_type() noexcept : is_rgb(), value{} {} FMT_CONSTEXPR color_type(color rgb_color) noexcept : is_rgb(true), value{} { value.rgb_color = static_cast(rgb_color); } FMT_CONSTEXPR color_type(rgb rgb_color) noexcept : is_rgb(true), value{} { value.rgb_color = (static_cast(rgb_color.r) << 16) | (static_cast(rgb_color.g) << 8) | rgb_color.b; } FMT_CONSTEXPR color_type(terminal_color term_color) noexcept : is_rgb(), value{} { value.term_color = static_cast(term_color); } bool is_rgb; union color_union { uint8_t term_color; uint32_t rgb_color; } value; }; } // namespace detail /** A text style consisting of foreground and background colors and emphasis. */ class text_style { public: FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept : set_foreground_color(), set_background_color(), ems(em) {} FMT_CONSTEXPR auto operator|=(const text_style& rhs) -> text_style& { if (!set_foreground_color) { set_foreground_color = rhs.set_foreground_color; foreground_color = rhs.foreground_color; } else if (rhs.set_foreground_color) { if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb) FMT_THROW(format_error("can't OR a terminal color")); foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color; } if (!set_background_color) { set_background_color = rhs.set_background_color; background_color = rhs.background_color; } else if (rhs.set_background_color) { if (!background_color.is_rgb || !rhs.background_color.is_rgb) FMT_THROW(format_error("can't OR a terminal color")); background_color.value.rgb_color |= rhs.background_color.value.rgb_color; } ems = static_cast(static_cast(ems) | static_cast(rhs.ems)); return *this; } friend FMT_CONSTEXPR auto operator|(text_style lhs, const text_style& rhs) -> text_style { return lhs |= rhs; } FMT_CONSTEXPR auto has_foreground() const noexcept -> bool { return set_foreground_color; } FMT_CONSTEXPR auto has_background() const noexcept -> bool { return set_background_color; } FMT_CONSTEXPR auto has_emphasis() const noexcept -> bool { return static_cast(ems) != 0; } FMT_CONSTEXPR auto get_foreground() const noexcept -> detail::color_type { FMT_ASSERT(has_foreground(), "no foreground specified for this style"); return foreground_color; } FMT_CONSTEXPR auto get_background() const noexcept -> detail::color_type { FMT_ASSERT(has_background(), "no background specified for this style"); return background_color; } FMT_CONSTEXPR auto get_emphasis() const noexcept -> emphasis { FMT_ASSERT(has_emphasis(), "no emphasis specified for this style"); return ems; } private: FMT_CONSTEXPR text_style(bool is_foreground, detail::color_type text_color) noexcept : set_foreground_color(), set_background_color(), ems() { if (is_foreground) { foreground_color = text_color; set_foreground_color = true; } else { background_color = text_color; set_background_color = true; } } friend FMT_CONSTEXPR auto fg(detail::color_type foreground) noexcept -> text_style; friend FMT_CONSTEXPR auto bg(detail::color_type background) noexcept -> text_style; detail::color_type foreground_color; detail::color_type background_color; bool set_foreground_color; bool set_background_color; emphasis ems; }; /** Creates a text style from the foreground (text) color. */ FMT_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept -> text_style { return text_style(true, foreground); } /** Creates a text style from the background color. */ FMT_CONSTEXPR inline auto bg(detail::color_type background) noexcept -> text_style { return text_style(false, background); } FMT_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept -> text_style { return text_style(lhs) | rhs; } namespace detail { template struct ansi_color_escape { FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color, const char* esc) noexcept { // If we have a terminal color, we need to output another escape code // sequence. if (!text_color.is_rgb) { bool is_background = esc == string_view("\x1b[48;2;"); uint32_t value = text_color.value.term_color; // Background ASCII codes are the same as the foreground ones but with // 10 more. if (is_background) value += 10u; size_t index = 0; buffer[index++] = static_cast('\x1b'); buffer[index++] = static_cast('['); if (value >= 100u) { buffer[index++] = static_cast('1'); value %= 100u; } buffer[index++] = static_cast('0' + value / 10u); buffer[index++] = static_cast('0' + value % 10u); buffer[index++] = static_cast('m'); buffer[index++] = static_cast('\0'); return; } for (int i = 0; i < 7; i++) { buffer[i] = static_cast(esc[i]); } rgb color(text_color.value.rgb_color); to_esc(color.r, buffer + 7, ';'); to_esc(color.g, buffer + 11, ';'); to_esc(color.b, buffer + 15, 'm'); buffer[19] = static_cast(0); } FMT_CONSTEXPR ansi_color_escape(emphasis em) noexcept { uint8_t em_codes[num_emphases] = {}; if (has_emphasis(em, emphasis::bold)) em_codes[0] = 1; if (has_emphasis(em, emphasis::faint)) em_codes[1] = 2; if (has_emphasis(em, emphasis::italic)) em_codes[2] = 3; if (has_emphasis(em, emphasis::underline)) em_codes[3] = 4; if (has_emphasis(em, emphasis::blink)) em_codes[4] = 5; if (has_emphasis(em, emphasis::reverse)) em_codes[5] = 7; if (has_emphasis(em, emphasis::conceal)) em_codes[6] = 8; if (has_emphasis(em, emphasis::strikethrough)) em_codes[7] = 9; size_t index = 0; for (size_t i = 0; i < num_emphases; ++i) { if (!em_codes[i]) continue; buffer[index++] = static_cast('\x1b'); buffer[index++] = static_cast('['); buffer[index++] = static_cast('0' + em_codes[i]); buffer[index++] = static_cast('m'); } buffer[index++] = static_cast(0); } FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; } FMT_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; } FMT_CONSTEXPR_CHAR_TRAITS auto end() const noexcept -> const Char* { return buffer + std::char_traits::length(buffer); } private: static constexpr size_t num_emphases = 8; Char buffer[7u + 3u * num_emphases + 1u]; static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out, char delimiter) noexcept { out[0] = static_cast('0' + c / 100); out[1] = static_cast('0' + c / 10 % 10); out[2] = static_cast('0' + c % 10); out[3] = static_cast(delimiter); } static FMT_CONSTEXPR auto has_emphasis(emphasis em, emphasis mask) noexcept -> bool { return static_cast(em) & static_cast(mask); } }; template FMT_CONSTEXPR auto make_foreground_color(detail::color_type foreground) noexcept -> ansi_color_escape { return ansi_color_escape(foreground, "\x1b[38;2;"); } template FMT_CONSTEXPR auto make_background_color(detail::color_type background) noexcept -> ansi_color_escape { return ansi_color_escape(background, "\x1b[48;2;"); } template FMT_CONSTEXPR auto make_emphasis(emphasis em) noexcept -> ansi_color_escape { return ansi_color_escape(em); } template inline void reset_color(buffer& buffer) { auto reset_color = string_view("\x1b[0m"); buffer.append(reset_color.begin(), reset_color.end()); } template struct styled_arg : detail::view { const T& value; text_style style; styled_arg(const T& v, text_style s) : value(v), style(s) {} }; template void vformat_to(buffer& buf, const text_style& ts, basic_string_view format_str, basic_format_args>> args) { bool has_style = false; if (ts.has_emphasis()) { has_style = true; auto emphasis = detail::make_emphasis(ts.get_emphasis()); buf.append(emphasis.begin(), emphasis.end()); } if (ts.has_foreground()) { has_style = true; auto foreground = detail::make_foreground_color(ts.get_foreground()); buf.append(foreground.begin(), foreground.end()); } if (ts.has_background()) { has_style = true; auto background = detail::make_background_color(ts.get_background()); buf.append(background.begin(), background.end()); } detail::vformat_to(buf, format_str, args, {}); if (has_style) detail::reset_color(buf); } } // namespace detail inline void vprint(std::FILE* f, const text_style& ts, string_view fmt, format_args args) { // Legacy wide streams are not supported. auto buf = memory_buffer(); detail::vformat_to(buf, ts, fmt, args); if (detail::is_utf8()) { detail::print(f, string_view(buf.begin(), buf.size())); return; } buf.push_back('\0'); int result = std::fputs(buf.data(), f); if (result < 0) FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); } /** \rst Formats a string and prints it to the specified file stream using ANSI escape sequences to specify text formatting. **Example**:: fmt::print(fmt::emphasis::bold | fg(fmt::color::red), "Elapsed time: {0:.2f} seconds", 1.23); \endrst */ template ::value)> void print(std::FILE* f, const text_style& ts, const S& format_str, const Args&... args) { vprint(f, ts, format_str, fmt::make_format_args>>(args...)); } /** \rst Formats a string and prints it to stdout using ANSI escape sequences to specify text formatting. **Example**:: fmt::print(fmt::emphasis::bold | fg(fmt::color::red), "Elapsed time: {0:.2f} seconds", 1.23); \endrst */ template ::value)> void print(const text_style& ts, const S& format_str, const Args&... args) { return print(stdout, ts, format_str, args...); } template > inline auto vformat( const text_style& ts, const S& format_str, basic_format_args>> args) -> std::basic_string { basic_memory_buffer buf; detail::vformat_to(buf, ts, detail::to_string_view(format_str), args); return fmt::to_string(buf); } /** \rst Formats arguments and returns the result as a string using ANSI escape sequences to specify text formatting. **Example**:: #include std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red), "The answer is {}", 42); \endrst */ template > inline auto format(const text_style& ts, const S& format_str, const Args&... args) -> std::basic_string { return fmt::vformat(ts, detail::to_string_view(format_str), fmt::make_format_args>(args...)); } /** Formats a string with the given text_style and writes the output to ``out``. */ template ::value)> auto vformat_to(OutputIt out, const text_style& ts, basic_string_view format_str, basic_format_args>> args) -> OutputIt { auto&& buf = detail::get_buffer(out); detail::vformat_to(buf, ts, format_str, args); return detail::get_iterator(buf, out); } /** \rst Formats arguments with the given text_style, writes the result to the output iterator ``out`` and returns the iterator past the end of the output range. **Example**:: std::vector out; fmt::format_to(std::back_inserter(out), fmt::emphasis::bold | fg(fmt::color::red), "{}", 42); \endrst */ template < typename OutputIt, typename S, typename... Args, bool enable = detail::is_output_iterator>::value && detail::is_string::value> inline auto format_to(OutputIt out, const text_style& ts, const S& format_str, Args&&... args) -> typename std::enable_if::type { return vformat_to(out, ts, detail::to_string_view(format_str), fmt::make_format_args>>(args...)); } template struct formatter, Char> : formatter { template auto format(const detail::styled_arg& arg, FormatContext& ctx) const -> decltype(ctx.out()) { const auto& ts = arg.style; const auto& value = arg.value; auto out = ctx.out(); bool has_style = false; if (ts.has_emphasis()) { has_style = true; auto emphasis = detail::make_emphasis(ts.get_emphasis()); out = std::copy(emphasis.begin(), emphasis.end(), out); } if (ts.has_foreground()) { has_style = true; auto foreground = detail::make_foreground_color(ts.get_foreground()); out = std::copy(foreground.begin(), foreground.end(), out); } if (ts.has_background()) { has_style = true; auto background = detail::make_background_color(ts.get_background()); out = std::copy(background.begin(), background.end(), out); } out = formatter::format(value, ctx); if (has_style) { auto reset_color = string_view("\x1b[0m"); out = std::copy(reset_color.begin(), reset_color.end(), out); } return out; } }; /** \rst Returns an argument that will be formatted using ANSI escape sequences, to be used in a formatting function. **Example**:: fmt::print("Elapsed time: {0:.2f} seconds", fmt::styled(1.23, fmt::fg(fmt::color::green) | fmt::bg(fmt::color::blue))); \endrst */ template FMT_CONSTEXPR auto styled(const T& value, text_style ts) -> detail::styled_arg> { return detail::styled_arg>{value, ts}; } FMT_END_EXPORT FMT_END_NAMESPACE #endif // FMT_COLOR_H_ RcppSpdlog/inst/include/spdlog/fmt/bundled/fmt.license.rst0000644000176200001440000000260014222664566023376 0ustar liggesusersCopyright (c) 2012 - present, Victor Zverovich Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. --- Optional exception to the license --- As an exception, if, as a result of your compiling your source code, portions of this Software are embedded into a machine-executable object form of such source code, you may redistribute such embedded portions in such object form without including the above copyright and permission notices. RcppSpdlog/inst/include/spdlog/fmt/bundled/chrono.h0000644000176200001440000022043314612604314022070 0ustar liggesusers// Formatting library for C++ - chrono support // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_CHRONO_H_ #define FMT_CHRONO_H_ #include #include #include // std::isfinite #include // std::memcpy #include #include #include #include #include #include "ostream.h" // formatbuf FMT_BEGIN_NAMESPACE // Check if std::chrono::local_t is available. #ifndef FMT_USE_LOCAL_TIME # ifdef __cpp_lib_chrono # define FMT_USE_LOCAL_TIME (__cpp_lib_chrono >= 201907L) # else # define FMT_USE_LOCAL_TIME 0 # endif #endif // Check if std::chrono::utc_timestamp is available. #ifndef FMT_USE_UTC_TIME # ifdef __cpp_lib_chrono # define FMT_USE_UTC_TIME (__cpp_lib_chrono >= 201907L) # else # define FMT_USE_UTC_TIME 0 # endif #endif // Enable tzset. #ifndef FMT_USE_TZSET // UWP doesn't provide _tzset. # if FMT_HAS_INCLUDE("winapifamily.h") # include # endif # if defined(_WIN32) && (!defined(WINAPI_FAMILY) || \ (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP)) # define FMT_USE_TZSET 1 # else # define FMT_USE_TZSET 0 # endif #endif // Enable safe chrono durations, unless explicitly disabled. #ifndef FMT_SAFE_DURATION_CAST # define FMT_SAFE_DURATION_CAST 1 #endif #if FMT_SAFE_DURATION_CAST // For conversion between std::chrono::durations without undefined // behaviour or erroneous results. // This is a stripped down version of duration_cast, for inclusion in fmt. // See https://github.com/pauldreik/safe_duration_cast // // Copyright Paul Dreik 2019 namespace safe_duration_cast { template ::value && std::numeric_limits::is_signed == std::numeric_limits::is_signed)> FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec) -> To { ec = 0; using F = std::numeric_limits; using T = std::numeric_limits; static_assert(F::is_integer, "From must be integral"); static_assert(T::is_integer, "To must be integral"); // A and B are both signed, or both unsigned. if (detail::const_check(F::digits <= T::digits)) { // From fits in To without any problem. } else { // From does not always fit in To, resort to a dynamic check. if (from < (T::min)() || from > (T::max)()) { // outside range. ec = 1; return {}; } } return static_cast(from); } /** * converts From to To, without loss. If the dynamic value of from * can't be converted to To without loss, ec is set. */ template ::value && std::numeric_limits::is_signed != std::numeric_limits::is_signed)> FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec) -> To { ec = 0; using F = std::numeric_limits; using T = std::numeric_limits; static_assert(F::is_integer, "From must be integral"); static_assert(T::is_integer, "To must be integral"); if (detail::const_check(F::is_signed && !T::is_signed)) { // From may be negative, not allowed! if (fmt::detail::is_negative(from)) { ec = 1; return {}; } // From is positive. Can it always fit in To? if (detail::const_check(F::digits > T::digits) && from > static_cast(detail::max_value())) { ec = 1; return {}; } } if (detail::const_check(!F::is_signed && T::is_signed && F::digits >= T::digits) && from > static_cast(detail::max_value())) { ec = 1; return {}; } return static_cast(from); // Lossless conversion. } template ::value)> FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec) -> To { ec = 0; return from; } // function // clang-format off /** * converts From to To if possible, otherwise ec is set. * * input | output * ---------------------------------|--------------- * NaN | NaN * Inf | Inf * normal, fits in output | converted (possibly lossy) * normal, does not fit in output | ec is set * subnormal | best effort * -Inf | -Inf */ // clang-format on template ::value)> FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To { ec = 0; using T = std::numeric_limits; static_assert(std::is_floating_point::value, "From must be floating"); static_assert(std::is_floating_point::value, "To must be floating"); // catch the only happy case if (std::isfinite(from)) { if (from >= T::lowest() && from <= (T::max)()) { return static_cast(from); } // not within range. ec = 1; return {}; } // nan and inf will be preserved return static_cast(from); } // function template ::value)> FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To { ec = 0; static_assert(std::is_floating_point::value, "From must be floating"); return from; } /** * safe duration cast between integral durations */ template ::value), FMT_ENABLE_IF(std::is_integral::value)> auto safe_duration_cast(std::chrono::duration from, int& ec) -> To { using From = std::chrono::duration; ec = 0; // the basic idea is that we need to convert from count() in the from type // to count() in the To type, by multiplying it with this: struct Factor : std::ratio_divide {}; static_assert(Factor::num > 0, "num must be positive"); static_assert(Factor::den > 0, "den must be positive"); // the conversion is like this: multiply from.count() with Factor::num // /Factor::den and convert it to To::rep, all this without // overflow/underflow. let's start by finding a suitable type that can hold // both To, From and Factor::num using IntermediateRep = typename std::common_type::type; // safe conversion to IntermediateRep IntermediateRep count = lossless_integral_conversion(from.count(), ec); if (ec) return {}; // multiply with Factor::num without overflow or underflow if (detail::const_check(Factor::num != 1)) { const auto max1 = detail::max_value() / Factor::num; if (count > max1) { ec = 1; return {}; } const auto min1 = (std::numeric_limits::min)() / Factor::num; if (detail::const_check(!std::is_unsigned::value) && count < min1) { ec = 1; return {}; } count *= Factor::num; } if (detail::const_check(Factor::den != 1)) count /= Factor::den; auto tocount = lossless_integral_conversion(count, ec); return ec ? To() : To(tocount); } /** * safe duration_cast between floating point durations */ template ::value), FMT_ENABLE_IF(std::is_floating_point::value)> auto safe_duration_cast(std::chrono::duration from, int& ec) -> To { using From = std::chrono::duration; ec = 0; if (std::isnan(from.count())) { // nan in, gives nan out. easy. return To{std::numeric_limits::quiet_NaN()}; } // maybe we should also check if from is denormal, and decide what to do about // it. // +-inf should be preserved. if (std::isinf(from.count())) { return To{from.count()}; } // the basic idea is that we need to convert from count() in the from type // to count() in the To type, by multiplying it with this: struct Factor : std::ratio_divide {}; static_assert(Factor::num > 0, "num must be positive"); static_assert(Factor::den > 0, "den must be positive"); // the conversion is like this: multiply from.count() with Factor::num // /Factor::den and convert it to To::rep, all this without // overflow/underflow. let's start by finding a suitable type that can hold // both To, From and Factor::num using IntermediateRep = typename std::common_type::type; // force conversion of From::rep -> IntermediateRep to be safe, // even if it will never happen be narrowing in this context. IntermediateRep count = safe_float_conversion(from.count(), ec); if (ec) { return {}; } // multiply with Factor::num without overflow or underflow if (detail::const_check(Factor::num != 1)) { constexpr auto max1 = detail::max_value() / static_cast(Factor::num); if (count > max1) { ec = 1; return {}; } constexpr auto min1 = std::numeric_limits::lowest() / static_cast(Factor::num); if (count < min1) { ec = 1; return {}; } count *= static_cast(Factor::num); } // this can't go wrong, right? den>0 is checked earlier. if (detail::const_check(Factor::den != 1)) { using common_t = typename std::common_type::type; count /= static_cast(Factor::den); } // convert to the to type, safely using ToRep = typename To::rep; const ToRep tocount = safe_float_conversion(count, ec); if (ec) { return {}; } return To{tocount}; } } // namespace safe_duration_cast #endif // Prevents expansion of a preceding token as a function-style macro. // Usage: f FMT_NOMACRO() #define FMT_NOMACRO namespace detail { template struct null {}; inline auto localtime_r FMT_NOMACRO(...) -> null<> { return null<>(); } inline auto localtime_s(...) -> null<> { return null<>(); } inline auto gmtime_r(...) -> null<> { return null<>(); } inline auto gmtime_s(...) -> null<> { return null<>(); } inline auto get_classic_locale() -> const std::locale& { static const auto& locale = std::locale::classic(); return locale; } template struct codecvt_result { static constexpr const size_t max_size = 32; CodeUnit buf[max_size]; CodeUnit* end; }; template void write_codecvt(codecvt_result& out, string_view in_buf, const std::locale& loc) { #if FMT_CLANG_VERSION # pragma clang diagnostic push # pragma clang diagnostic ignored "-Wdeprecated" auto& f = std::use_facet>(loc); # pragma clang diagnostic pop #else auto& f = std::use_facet>(loc); #endif auto mb = std::mbstate_t(); const char* from_next = nullptr; auto result = f.in(mb, in_buf.begin(), in_buf.end(), from_next, std::begin(out.buf), std::end(out.buf), out.end); if (result != std::codecvt_base::ok) FMT_THROW(format_error("failed to format time")); } template auto write_encoded_tm_str(OutputIt out, string_view in, const std::locale& loc) -> OutputIt { if (detail::is_utf8() && loc != get_classic_locale()) { // char16_t and char32_t codecvts are broken in MSVC (linkage errors) and // gcc-4. #if FMT_MSC_VERSION != 0 || \ (defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI)) // The _GLIBCXX_USE_DUAL_ABI macro is always defined in libstdc++ from gcc-5 // and newer. using code_unit = wchar_t; #else using code_unit = char32_t; #endif using unit_t = codecvt_result; unit_t unit; write_codecvt(unit, in, loc); // In UTF-8 is used one to four one-byte code units. auto u = to_utf8>(); if (!u.convert({unit.buf, to_unsigned(unit.end - unit.buf)})) FMT_THROW(format_error("failed to format time")); return copy_str(u.c_str(), u.c_str() + u.size(), out); } return copy_str(in.data(), in.data() + in.size(), out); } template ::value)> auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc) -> OutputIt { codecvt_result unit; write_codecvt(unit, sv, loc); return copy_str(unit.buf, unit.end, out); } template ::value)> auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc) -> OutputIt { return write_encoded_tm_str(out, sv, loc); } template inline void do_write(buffer& buf, const std::tm& time, const std::locale& loc, char format, char modifier) { auto&& format_buf = formatbuf>(buf); auto&& os = std::basic_ostream(&format_buf); os.imbue(loc); const auto& facet = std::use_facet>(loc); auto end = facet.put(os, os, Char(' '), &time, format, modifier); if (end.failed()) FMT_THROW(format_error("failed to format time")); } template ::value)> auto write(OutputIt out, const std::tm& time, const std::locale& loc, char format, char modifier = 0) -> OutputIt { auto&& buf = get_buffer(out); do_write(buf, time, loc, format, modifier); return get_iterator(buf, out); } template ::value)> auto write(OutputIt out, const std::tm& time, const std::locale& loc, char format, char modifier = 0) -> OutputIt { auto&& buf = basic_memory_buffer(); do_write(buf, time, loc, format, modifier); return write_encoded_tm_str(out, string_view(buf.data(), buf.size()), loc); } template struct is_same_arithmetic_type : public std::integral_constant::value && std::is_integral::value) || (std::is_floating_point::value && std::is_floating_point::value)> { }; template < typename To, typename FromRep, typename FromPeriod, FMT_ENABLE_IF(is_same_arithmetic_type::value)> auto fmt_duration_cast(std::chrono::duration from) -> To { #if FMT_SAFE_DURATION_CAST // Throwing version of safe_duration_cast is only available for // integer to integer or float to float casts. int ec; To to = safe_duration_cast::safe_duration_cast(from, ec); if (ec) FMT_THROW(format_error("cannot format duration")); return to; #else // Standard duration cast, may overflow. return std::chrono::duration_cast(from); #endif } template < typename To, typename FromRep, typename FromPeriod, FMT_ENABLE_IF(!is_same_arithmetic_type::value)> auto fmt_duration_cast(std::chrono::duration from) -> To { // Mixed integer <-> float cast is not supported by safe_duration_cast. return std::chrono::duration_cast(from); } template auto to_time_t( std::chrono::time_point time_point) -> std::time_t { // Cannot use std::chrono::system_clock::to_time_t since this would first // require a cast to std::chrono::system_clock::time_point, which could // overflow. return fmt_duration_cast>( time_point.time_since_epoch()) .count(); } } // namespace detail FMT_BEGIN_EXPORT /** Converts given time since epoch as ``std::time_t`` value into calendar time, expressed in local time. Unlike ``std::localtime``, this function is thread-safe on most platforms. */ inline auto localtime(std::time_t time) -> std::tm { struct dispatcher { std::time_t time_; std::tm tm_; dispatcher(std::time_t t) : time_(t) {} auto run() -> bool { using namespace fmt::detail; return handle(localtime_r(&time_, &tm_)); } auto handle(std::tm* tm) -> bool { return tm != nullptr; } auto handle(detail::null<>) -> bool { using namespace fmt::detail; return fallback(localtime_s(&tm_, &time_)); } auto fallback(int res) -> bool { return res == 0; } #if !FMT_MSC_VERSION auto fallback(detail::null<>) -> bool { using namespace fmt::detail; std::tm* tm = std::localtime(&time_); if (tm) tm_ = *tm; return tm != nullptr; } #endif }; dispatcher lt(time); // Too big time values may be unsupported. if (!lt.run()) FMT_THROW(format_error("time_t value out of range")); return lt.tm_; } #if FMT_USE_LOCAL_TIME template inline auto localtime(std::chrono::local_time time) -> std::tm { return localtime( detail::to_time_t(std::chrono::current_zone()->to_sys(time))); } #endif /** Converts given time since epoch as ``std::time_t`` value into calendar time, expressed in Coordinated Universal Time (UTC). Unlike ``std::gmtime``, this function is thread-safe on most platforms. */ inline auto gmtime(std::time_t time) -> std::tm { struct dispatcher { std::time_t time_; std::tm tm_; dispatcher(std::time_t t) : time_(t) {} auto run() -> bool { using namespace fmt::detail; return handle(gmtime_r(&time_, &tm_)); } auto handle(std::tm* tm) -> bool { return tm != nullptr; } auto handle(detail::null<>) -> bool { using namespace fmt::detail; return fallback(gmtime_s(&tm_, &time_)); } auto fallback(int res) -> bool { return res == 0; } #if !FMT_MSC_VERSION auto fallback(detail::null<>) -> bool { std::tm* tm = std::gmtime(&time_); if (tm) tm_ = *tm; return tm != nullptr; } #endif }; auto gt = dispatcher(time); // Too big time values may be unsupported. if (!gt.run()) FMT_THROW(format_error("time_t value out of range")); return gt.tm_; } template inline auto gmtime( std::chrono::time_point time_point) -> std::tm { return gmtime(detail::to_time_t(time_point)); } namespace detail { // Writes two-digit numbers a, b and c separated by sep to buf. // The method by Pavel Novikov based on // https://johnnylee-sde.github.io/Fast-unsigned-integer-to-time-string/. inline void write_digit2_separated(char* buf, unsigned a, unsigned b, unsigned c, char sep) { unsigned long long digits = a | (b << 24) | (static_cast(c) << 48); // Convert each value to BCD. // We have x = a * 10 + b and we want to convert it to BCD y = a * 16 + b. // The difference is // y - x = a * 6 // a can be found from x: // a = floor(x / 10) // then // y = x + a * 6 = x + floor(x / 10) * 6 // floor(x / 10) is (x * 205) >> 11 (needs 16 bits). digits += (((digits * 205) >> 11) & 0x000f00000f00000f) * 6; // Put low nibbles to high bytes and high nibbles to low bytes. digits = ((digits & 0x00f00000f00000f0) >> 4) | ((digits & 0x000f00000f00000f) << 8); auto usep = static_cast(sep); // Add ASCII '0' to each digit byte and insert separators. digits |= 0x3030003030003030 | (usep << 16) | (usep << 40); constexpr const size_t len = 8; if (const_check(is_big_endian())) { char tmp[len]; std::memcpy(tmp, &digits, len); std::reverse_copy(tmp, tmp + len, buf); } else { std::memcpy(buf, &digits, len); } } template FMT_CONSTEXPR inline auto get_units() -> const char* { if (std::is_same::value) return "as"; if (std::is_same::value) return "fs"; if (std::is_same::value) return "ps"; if (std::is_same::value) return "ns"; if (std::is_same::value) return "µs"; if (std::is_same::value) return "ms"; if (std::is_same::value) return "cs"; if (std::is_same::value) return "ds"; if (std::is_same>::value) return "s"; if (std::is_same::value) return "das"; if (std::is_same::value) return "hs"; if (std::is_same::value) return "ks"; if (std::is_same::value) return "Ms"; if (std::is_same::value) return "Gs"; if (std::is_same::value) return "Ts"; if (std::is_same::value) return "Ps"; if (std::is_same::value) return "Es"; if (std::is_same>::value) return "min"; if (std::is_same>::value) return "h"; if (std::is_same>::value) return "d"; return nullptr; } enum class numeric_system { standard, // Alternative numeric system, e.g. 十二 instead of 12 in ja_JP locale. alternative }; // Glibc extensions for formatting numeric values. enum class pad_type { unspecified, // Do not pad a numeric result string. none, // Pad a numeric result string with zeros even if the conversion specifier // character uses space-padding by default. zero, // Pad a numeric result string with spaces. space, }; template auto write_padding(OutputIt out, pad_type pad, int width) -> OutputIt { if (pad == pad_type::none) return out; return std::fill_n(out, width, pad == pad_type::space ? ' ' : '0'); } template auto write_padding(OutputIt out, pad_type pad) -> OutputIt { if (pad != pad_type::none) *out++ = pad == pad_type::space ? ' ' : '0'; return out; } // Parses a put_time-like format string and invokes handler actions. template FMT_CONSTEXPR auto parse_chrono_format(const Char* begin, const Char* end, Handler&& handler) -> const Char* { if (begin == end || *begin == '}') return begin; if (*begin != '%') FMT_THROW(format_error("invalid format")); auto ptr = begin; pad_type pad = pad_type::unspecified; while (ptr != end) { auto c = *ptr; if (c == '}') break; if (c != '%') { ++ptr; continue; } if (begin != ptr) handler.on_text(begin, ptr); ++ptr; // consume '%' if (ptr == end) FMT_THROW(format_error("invalid format")); c = *ptr; switch (c) { case '_': pad = pad_type::space; ++ptr; break; case '-': pad = pad_type::none; ++ptr; break; case '0': pad = pad_type::zero; ++ptr; break; } if (ptr == end) FMT_THROW(format_error("invalid format")); c = *ptr++; switch (c) { case '%': handler.on_text(ptr - 1, ptr); break; case 'n': { const Char newline[] = {'\n'}; handler.on_text(newline, newline + 1); break; } case 't': { const Char tab[] = {'\t'}; handler.on_text(tab, tab + 1); break; } // Year: case 'Y': handler.on_year(numeric_system::standard); break; case 'y': handler.on_short_year(numeric_system::standard); break; case 'C': handler.on_century(numeric_system::standard); break; case 'G': handler.on_iso_week_based_year(); break; case 'g': handler.on_iso_week_based_short_year(); break; // Day of the week: case 'a': handler.on_abbr_weekday(); break; case 'A': handler.on_full_weekday(); break; case 'w': handler.on_dec0_weekday(numeric_system::standard); break; case 'u': handler.on_dec1_weekday(numeric_system::standard); break; // Month: case 'b': case 'h': handler.on_abbr_month(); break; case 'B': handler.on_full_month(); break; case 'm': handler.on_dec_month(numeric_system::standard); break; // Day of the year/month: case 'U': handler.on_dec0_week_of_year(numeric_system::standard); break; case 'W': handler.on_dec1_week_of_year(numeric_system::standard); break; case 'V': handler.on_iso_week_of_year(numeric_system::standard); break; case 'j': handler.on_day_of_year(); break; case 'd': handler.on_day_of_month(numeric_system::standard); break; case 'e': handler.on_day_of_month_space(numeric_system::standard); break; // Hour, minute, second: case 'H': handler.on_24_hour(numeric_system::standard, pad); break; case 'I': handler.on_12_hour(numeric_system::standard, pad); break; case 'M': handler.on_minute(numeric_system::standard, pad); break; case 'S': handler.on_second(numeric_system::standard, pad); break; // Other: case 'c': handler.on_datetime(numeric_system::standard); break; case 'x': handler.on_loc_date(numeric_system::standard); break; case 'X': handler.on_loc_time(numeric_system::standard); break; case 'D': handler.on_us_date(); break; case 'F': handler.on_iso_date(); break; case 'r': handler.on_12_hour_time(); break; case 'R': handler.on_24_hour_time(); break; case 'T': handler.on_iso_time(); break; case 'p': handler.on_am_pm(); break; case 'Q': handler.on_duration_value(); break; case 'q': handler.on_duration_unit(); break; case 'z': handler.on_utc_offset(numeric_system::standard); break; case 'Z': handler.on_tz_name(); break; // Alternative representation: case 'E': { if (ptr == end) FMT_THROW(format_error("invalid format")); c = *ptr++; switch (c) { case 'Y': handler.on_year(numeric_system::alternative); break; case 'y': handler.on_offset_year(); break; case 'C': handler.on_century(numeric_system::alternative); break; case 'c': handler.on_datetime(numeric_system::alternative); break; case 'x': handler.on_loc_date(numeric_system::alternative); break; case 'X': handler.on_loc_time(numeric_system::alternative); break; case 'z': handler.on_utc_offset(numeric_system::alternative); break; default: FMT_THROW(format_error("invalid format")); } break; } case 'O': if (ptr == end) FMT_THROW(format_error("invalid format")); c = *ptr++; switch (c) { case 'y': handler.on_short_year(numeric_system::alternative); break; case 'm': handler.on_dec_month(numeric_system::alternative); break; case 'U': handler.on_dec0_week_of_year(numeric_system::alternative); break; case 'W': handler.on_dec1_week_of_year(numeric_system::alternative); break; case 'V': handler.on_iso_week_of_year(numeric_system::alternative); break; case 'd': handler.on_day_of_month(numeric_system::alternative); break; case 'e': handler.on_day_of_month_space(numeric_system::alternative); break; case 'w': handler.on_dec0_weekday(numeric_system::alternative); break; case 'u': handler.on_dec1_weekday(numeric_system::alternative); break; case 'H': handler.on_24_hour(numeric_system::alternative, pad); break; case 'I': handler.on_12_hour(numeric_system::alternative, pad); break; case 'M': handler.on_minute(numeric_system::alternative, pad); break; case 'S': handler.on_second(numeric_system::alternative, pad); break; case 'z': handler.on_utc_offset(numeric_system::alternative); break; default: FMT_THROW(format_error("invalid format")); } break; default: FMT_THROW(format_error("invalid format")); } begin = ptr; } if (begin != ptr) handler.on_text(begin, ptr); return ptr; } template struct null_chrono_spec_handler { FMT_CONSTEXPR void unsupported() { static_cast(this)->unsupported(); } FMT_CONSTEXPR void on_year(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_short_year(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_offset_year() { unsupported(); } FMT_CONSTEXPR void on_century(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_iso_week_based_year() { unsupported(); } FMT_CONSTEXPR void on_iso_week_based_short_year() { unsupported(); } FMT_CONSTEXPR void on_abbr_weekday() { unsupported(); } FMT_CONSTEXPR void on_full_weekday() { unsupported(); } FMT_CONSTEXPR void on_dec0_weekday(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_dec1_weekday(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_abbr_month() { unsupported(); } FMT_CONSTEXPR void on_full_month() { unsupported(); } FMT_CONSTEXPR void on_dec_month(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_iso_week_of_year(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_day_of_year() { unsupported(); } FMT_CONSTEXPR void on_day_of_month(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_day_of_month_space(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_24_hour(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_12_hour(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_minute(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_second(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_datetime(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_loc_date(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_loc_time(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_us_date() { unsupported(); } FMT_CONSTEXPR void on_iso_date() { unsupported(); } FMT_CONSTEXPR void on_12_hour_time() { unsupported(); } FMT_CONSTEXPR void on_24_hour_time() { unsupported(); } FMT_CONSTEXPR void on_iso_time() { unsupported(); } FMT_CONSTEXPR void on_am_pm() { unsupported(); } FMT_CONSTEXPR void on_duration_value() { unsupported(); } FMT_CONSTEXPR void on_duration_unit() { unsupported(); } FMT_CONSTEXPR void on_utc_offset(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_tz_name() { unsupported(); } }; struct tm_format_checker : null_chrono_spec_handler { FMT_NORETURN void unsupported() { FMT_THROW(format_error("no format")); } template FMT_CONSTEXPR void on_text(const Char*, const Char*) {} FMT_CONSTEXPR void on_year(numeric_system) {} FMT_CONSTEXPR void on_short_year(numeric_system) {} FMT_CONSTEXPR void on_offset_year() {} FMT_CONSTEXPR void on_century(numeric_system) {} FMT_CONSTEXPR void on_iso_week_based_year() {} FMT_CONSTEXPR void on_iso_week_based_short_year() {} FMT_CONSTEXPR void on_abbr_weekday() {} FMT_CONSTEXPR void on_full_weekday() {} FMT_CONSTEXPR void on_dec0_weekday(numeric_system) {} FMT_CONSTEXPR void on_dec1_weekday(numeric_system) {} FMT_CONSTEXPR void on_abbr_month() {} FMT_CONSTEXPR void on_full_month() {} FMT_CONSTEXPR void on_dec_month(numeric_system) {} FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system) {} FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system) {} FMT_CONSTEXPR void on_iso_week_of_year(numeric_system) {} FMT_CONSTEXPR void on_day_of_year() {} FMT_CONSTEXPR void on_day_of_month(numeric_system) {} FMT_CONSTEXPR void on_day_of_month_space(numeric_system) {} FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {} FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {} FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {} FMT_CONSTEXPR void on_second(numeric_system, pad_type) {} FMT_CONSTEXPR void on_datetime(numeric_system) {} FMT_CONSTEXPR void on_loc_date(numeric_system) {} FMT_CONSTEXPR void on_loc_time(numeric_system) {} FMT_CONSTEXPR void on_us_date() {} FMT_CONSTEXPR void on_iso_date() {} FMT_CONSTEXPR void on_12_hour_time() {} FMT_CONSTEXPR void on_24_hour_time() {} FMT_CONSTEXPR void on_iso_time() {} FMT_CONSTEXPR void on_am_pm() {} FMT_CONSTEXPR void on_utc_offset(numeric_system) {} FMT_CONSTEXPR void on_tz_name() {} }; inline auto tm_wday_full_name(int wday) -> const char* { static constexpr const char* full_name_list[] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}; return wday >= 0 && wday <= 6 ? full_name_list[wday] : "?"; } inline auto tm_wday_short_name(int wday) -> const char* { static constexpr const char* short_name_list[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; return wday >= 0 && wday <= 6 ? short_name_list[wday] : "???"; } inline auto tm_mon_full_name(int mon) -> const char* { static constexpr const char* full_name_list[] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"}; return mon >= 0 && mon <= 11 ? full_name_list[mon] : "?"; } inline auto tm_mon_short_name(int mon) -> const char* { static constexpr const char* short_name_list[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", }; return mon >= 0 && mon <= 11 ? short_name_list[mon] : "???"; } template struct has_member_data_tm_gmtoff : std::false_type {}; template struct has_member_data_tm_gmtoff> : std::true_type {}; template struct has_member_data_tm_zone : std::false_type {}; template struct has_member_data_tm_zone> : std::true_type {}; #if FMT_USE_TZSET inline void tzset_once() { static bool init = []() -> bool { _tzset(); return true; }(); ignore_unused(init); } #endif // Converts value to Int and checks that it's in the range [0, upper). template ::value)> inline auto to_nonnegative_int(T value, Int upper) -> Int { if (!std::is_unsigned::value && (value < 0 || to_unsigned(value) > to_unsigned(upper))) { FMT_THROW(fmt::format_error("chrono value is out of range")); } return static_cast(value); } template ::value)> inline auto to_nonnegative_int(T value, Int upper) -> Int { if (value < 0 || value > static_cast(upper)) FMT_THROW(format_error("invalid value")); return static_cast(value); } constexpr auto pow10(std::uint32_t n) -> long long { return n == 0 ? 1 : 10 * pow10(n - 1); } // Counts the number of fractional digits in the range [0, 18] according to the // C++20 spec. If more than 18 fractional digits are required then returns 6 for // microseconds precision. template () / 10)> struct count_fractional_digits { static constexpr int value = Num % Den == 0 ? N : count_fractional_digits::value; }; // Base case that doesn't instantiate any more templates // in order to avoid overflow. template struct count_fractional_digits { static constexpr int value = (Num % Den == 0) ? N : 6; }; // Format subseconds which are given as an integer type with an appropriate // number of digits. template void write_fractional_seconds(OutputIt& out, Duration d, int precision = -1) { constexpr auto num_fractional_digits = count_fractional_digits::value; using subsecond_precision = std::chrono::duration< typename std::common_type::type, std::ratio<1, detail::pow10(num_fractional_digits)>>; const auto fractional = d - fmt_duration_cast(d); const auto subseconds = std::chrono::treat_as_floating_point< typename subsecond_precision::rep>::value ? fractional.count() : fmt_duration_cast(fractional).count(); auto n = static_cast>(subseconds); const int num_digits = detail::count_digits(n); int leading_zeroes = (std::max)(0, num_fractional_digits - num_digits); if (precision < 0) { FMT_ASSERT(!std::is_floating_point::value, ""); if (std::ratio_less::value) { *out++ = '.'; out = std::fill_n(out, leading_zeroes, '0'); out = format_decimal(out, n, num_digits).end; } } else { *out++ = '.'; leading_zeroes = (std::min)(leading_zeroes, precision); out = std::fill_n(out, leading_zeroes, '0'); int remaining = precision - leading_zeroes; if (remaining != 0 && remaining < num_digits) { n /= to_unsigned(detail::pow10(to_unsigned(num_digits - remaining))); out = format_decimal(out, n, remaining).end; return; } out = format_decimal(out, n, num_digits).end; remaining -= num_digits; out = std::fill_n(out, remaining, '0'); } } // Format subseconds which are given as a floating point type with an // appropriate number of digits. We cannot pass the Duration here, as we // explicitly need to pass the Rep value in the chrono_formatter. template void write_floating_seconds(memory_buffer& buf, Duration duration, int num_fractional_digits = -1) { using rep = typename Duration::rep; FMT_ASSERT(std::is_floating_point::value, ""); auto val = duration.count(); if (num_fractional_digits < 0) { // For `std::round` with fallback to `round`: // On some toolchains `std::round` is not available (e.g. GCC 6). using namespace std; num_fractional_digits = count_fractional_digits::value; if (num_fractional_digits < 6 && static_cast(round(val)) != val) num_fractional_digits = 6; } fmt::format_to(std::back_inserter(buf), FMT_STRING("{:.{}f}"), std::fmod(val * static_cast(Duration::period::num) / static_cast(Duration::period::den), static_cast(60)), num_fractional_digits); } template class tm_writer { private: static constexpr int days_per_week = 7; const std::locale& loc_; const bool is_classic_; OutputIt out_; const Duration* subsecs_; const std::tm& tm_; auto tm_sec() const noexcept -> int { FMT_ASSERT(tm_.tm_sec >= 0 && tm_.tm_sec <= 61, ""); return tm_.tm_sec; } auto tm_min() const noexcept -> int { FMT_ASSERT(tm_.tm_min >= 0 && tm_.tm_min <= 59, ""); return tm_.tm_min; } auto tm_hour() const noexcept -> int { FMT_ASSERT(tm_.tm_hour >= 0 && tm_.tm_hour <= 23, ""); return tm_.tm_hour; } auto tm_mday() const noexcept -> int { FMT_ASSERT(tm_.tm_mday >= 1 && tm_.tm_mday <= 31, ""); return tm_.tm_mday; } auto tm_mon() const noexcept -> int { FMT_ASSERT(tm_.tm_mon >= 0 && tm_.tm_mon <= 11, ""); return tm_.tm_mon; } auto tm_year() const noexcept -> long long { return 1900ll + tm_.tm_year; } auto tm_wday() const noexcept -> int { FMT_ASSERT(tm_.tm_wday >= 0 && tm_.tm_wday <= 6, ""); return tm_.tm_wday; } auto tm_yday() const noexcept -> int { FMT_ASSERT(tm_.tm_yday >= 0 && tm_.tm_yday <= 365, ""); return tm_.tm_yday; } auto tm_hour12() const noexcept -> int { const auto h = tm_hour(); const auto z = h < 12 ? h : h - 12; return z == 0 ? 12 : z; } // POSIX and the C Standard are unclear or inconsistent about what %C and %y // do if the year is negative or exceeds 9999. Use the convention that %C // concatenated with %y yields the same output as %Y, and that %Y contains at // least 4 characters, with more only if necessary. auto split_year_lower(long long year) const noexcept -> int { auto l = year % 100; if (l < 0) l = -l; // l in [0, 99] return static_cast(l); } // Algorithm: https://en.wikipedia.org/wiki/ISO_week_date. auto iso_year_weeks(long long curr_year) const noexcept -> int { const auto prev_year = curr_year - 1; const auto curr_p = (curr_year + curr_year / 4 - curr_year / 100 + curr_year / 400) % days_per_week; const auto prev_p = (prev_year + prev_year / 4 - prev_year / 100 + prev_year / 400) % days_per_week; return 52 + ((curr_p == 4 || prev_p == 3) ? 1 : 0); } auto iso_week_num(int tm_yday, int tm_wday) const noexcept -> int { return (tm_yday + 11 - (tm_wday == 0 ? days_per_week : tm_wday)) / days_per_week; } auto tm_iso_week_year() const noexcept -> long long { const auto year = tm_year(); const auto w = iso_week_num(tm_yday(), tm_wday()); if (w < 1) return year - 1; if (w > iso_year_weeks(year)) return year + 1; return year; } auto tm_iso_week_of_year() const noexcept -> int { const auto year = tm_year(); const auto w = iso_week_num(tm_yday(), tm_wday()); if (w < 1) return iso_year_weeks(year - 1); if (w > iso_year_weeks(year)) return 1; return w; } void write1(int value) { *out_++ = static_cast('0' + to_unsigned(value) % 10); } void write2(int value) { const char* d = digits2(to_unsigned(value) % 100); *out_++ = *d++; *out_++ = *d; } void write2(int value, pad_type pad) { unsigned int v = to_unsigned(value) % 100; if (v >= 10) { const char* d = digits2(v); *out_++ = *d++; *out_++ = *d; } else { out_ = detail::write_padding(out_, pad); *out_++ = static_cast('0' + v); } } void write_year_extended(long long year) { // At least 4 characters. int width = 4; if (year < 0) { *out_++ = '-'; year = 0 - year; --width; } uint32_or_64_or_128_t n = to_unsigned(year); const int num_digits = count_digits(n); if (width > num_digits) out_ = std::fill_n(out_, width - num_digits, '0'); out_ = format_decimal(out_, n, num_digits).end; } void write_year(long long year) { if (year >= 0 && year < 10000) { write2(static_cast(year / 100)); write2(static_cast(year % 100)); } else { write_year_extended(year); } } void write_utc_offset(long offset, numeric_system ns) { if (offset < 0) { *out_++ = '-'; offset = -offset; } else { *out_++ = '+'; } offset /= 60; write2(static_cast(offset / 60)); if (ns != numeric_system::standard) *out_++ = ':'; write2(static_cast(offset % 60)); } template ::value)> void format_utc_offset_impl(const T& tm, numeric_system ns) { write_utc_offset(tm.tm_gmtoff, ns); } template ::value)> void format_utc_offset_impl(const T& tm, numeric_system ns) { #if defined(_WIN32) && defined(_UCRT) # if FMT_USE_TZSET tzset_once(); # endif long offset = 0; _get_timezone(&offset); if (tm.tm_isdst) { long dstbias = 0; _get_dstbias(&dstbias); offset += dstbias; } write_utc_offset(-offset, ns); #else if (ns == numeric_system::standard) return format_localized('z'); // Extract timezone offset from timezone conversion functions. std::tm gtm = tm; std::time_t gt = std::mktime(>m); std::tm ltm = gmtime(gt); std::time_t lt = std::mktime(<m); long offset = gt - lt; write_utc_offset(offset, ns); #endif } template ::value)> void format_tz_name_impl(const T& tm) { if (is_classic_) out_ = write_tm_str(out_, tm.tm_zone, loc_); else format_localized('Z'); } template ::value)> void format_tz_name_impl(const T&) { format_localized('Z'); } void format_localized(char format, char modifier = 0) { out_ = write(out_, tm_, loc_, format, modifier); } public: tm_writer(const std::locale& loc, OutputIt out, const std::tm& tm, const Duration* subsecs = nullptr) : loc_(loc), is_classic_(loc_ == get_classic_locale()), out_(out), subsecs_(subsecs), tm_(tm) {} auto out() const -> OutputIt { return out_; } FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) { out_ = copy_str(begin, end, out_); } void on_abbr_weekday() { if (is_classic_) out_ = write(out_, tm_wday_short_name(tm_wday())); else format_localized('a'); } void on_full_weekday() { if (is_classic_) out_ = write(out_, tm_wday_full_name(tm_wday())); else format_localized('A'); } void on_dec0_weekday(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) return write1(tm_wday()); format_localized('w', 'O'); } void on_dec1_weekday(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) { auto wday = tm_wday(); write1(wday == 0 ? days_per_week : wday); } else { format_localized('u', 'O'); } } void on_abbr_month() { if (is_classic_) out_ = write(out_, tm_mon_short_name(tm_mon())); else format_localized('b'); } void on_full_month() { if (is_classic_) out_ = write(out_, tm_mon_full_name(tm_mon())); else format_localized('B'); } void on_datetime(numeric_system ns) { if (is_classic_) { on_abbr_weekday(); *out_++ = ' '; on_abbr_month(); *out_++ = ' '; on_day_of_month_space(numeric_system::standard); *out_++ = ' '; on_iso_time(); *out_++ = ' '; on_year(numeric_system::standard); } else { format_localized('c', ns == numeric_system::standard ? '\0' : 'E'); } } void on_loc_date(numeric_system ns) { if (is_classic_) on_us_date(); else format_localized('x', ns == numeric_system::standard ? '\0' : 'E'); } void on_loc_time(numeric_system ns) { if (is_classic_) on_iso_time(); else format_localized('X', ns == numeric_system::standard ? '\0' : 'E'); } void on_us_date() { char buf[8]; write_digit2_separated(buf, to_unsigned(tm_mon() + 1), to_unsigned(tm_mday()), to_unsigned(split_year_lower(tm_year())), '/'); out_ = copy_str(std::begin(buf), std::end(buf), out_); } void on_iso_date() { auto year = tm_year(); char buf[10]; size_t offset = 0; if (year >= 0 && year < 10000) { copy2(buf, digits2(static_cast(year / 100))); } else { offset = 4; write_year_extended(year); year = 0; } write_digit2_separated(buf + 2, static_cast(year % 100), to_unsigned(tm_mon() + 1), to_unsigned(tm_mday()), '-'); out_ = copy_str(std::begin(buf) + offset, std::end(buf), out_); } void on_utc_offset(numeric_system ns) { format_utc_offset_impl(tm_, ns); } void on_tz_name() { format_tz_name_impl(tm_); } void on_year(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) return write_year(tm_year()); format_localized('Y', 'E'); } void on_short_year(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) return write2(split_year_lower(tm_year())); format_localized('y', 'O'); } void on_offset_year() { if (is_classic_) return write2(split_year_lower(tm_year())); format_localized('y', 'E'); } void on_century(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) { auto year = tm_year(); auto upper = year / 100; if (year >= -99 && year < 0) { // Zero upper on negative year. *out_++ = '-'; *out_++ = '0'; } else if (upper >= 0 && upper < 100) { write2(static_cast(upper)); } else { out_ = write(out_, upper); } } else { format_localized('C', 'E'); } } void on_dec_month(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) return write2(tm_mon() + 1); format_localized('m', 'O'); } void on_dec0_week_of_year(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) return write2((tm_yday() + days_per_week - tm_wday()) / days_per_week); format_localized('U', 'O'); } void on_dec1_week_of_year(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) { auto wday = tm_wday(); write2((tm_yday() + days_per_week - (wday == 0 ? (days_per_week - 1) : (wday - 1))) / days_per_week); } else { format_localized('W', 'O'); } } void on_iso_week_of_year(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) return write2(tm_iso_week_of_year()); format_localized('V', 'O'); } void on_iso_week_based_year() { write_year(tm_iso_week_year()); } void on_iso_week_based_short_year() { write2(split_year_lower(tm_iso_week_year())); } void on_day_of_year() { auto yday = tm_yday() + 1; write1(yday / 100); write2(yday % 100); } void on_day_of_month(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) return write2(tm_mday()); format_localized('d', 'O'); } void on_day_of_month_space(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) { auto mday = to_unsigned(tm_mday()) % 100; const char* d2 = digits2(mday); *out_++ = mday < 10 ? ' ' : d2[0]; *out_++ = d2[1]; } else { format_localized('e', 'O'); } } void on_24_hour(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) return write2(tm_hour(), pad); format_localized('H', 'O'); } void on_12_hour(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) return write2(tm_hour12(), pad); format_localized('I', 'O'); } void on_minute(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) return write2(tm_min(), pad); format_localized('M', 'O'); } void on_second(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) { write2(tm_sec(), pad); if (subsecs_) { if (std::is_floating_point::value) { auto buf = memory_buffer(); write_floating_seconds(buf, *subsecs_); if (buf.size() > 1) { // Remove the leading "0", write something like ".123". out_ = std::copy(buf.begin() + 1, buf.end(), out_); } } else { write_fractional_seconds(out_, *subsecs_); } } } else { // Currently no formatting of subseconds when a locale is set. format_localized('S', 'O'); } } void on_12_hour_time() { if (is_classic_) { char buf[8]; write_digit2_separated(buf, to_unsigned(tm_hour12()), to_unsigned(tm_min()), to_unsigned(tm_sec()), ':'); out_ = copy_str(std::begin(buf), std::end(buf), out_); *out_++ = ' '; on_am_pm(); } else { format_localized('r'); } } void on_24_hour_time() { write2(tm_hour()); *out_++ = ':'; write2(tm_min()); } void on_iso_time() { on_24_hour_time(); *out_++ = ':'; on_second(numeric_system::standard, pad_type::unspecified); } void on_am_pm() { if (is_classic_) { *out_++ = tm_hour() < 12 ? 'A' : 'P'; *out_++ = 'M'; } else { format_localized('p'); } } // These apply to chrono durations but not tm. void on_duration_value() {} void on_duration_unit() {} }; struct chrono_format_checker : null_chrono_spec_handler { bool has_precision_integral = false; FMT_NORETURN void unsupported() { FMT_THROW(format_error("no date")); } template FMT_CONSTEXPR void on_text(const Char*, const Char*) {} FMT_CONSTEXPR void on_day_of_year() {} FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {} FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {} FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {} FMT_CONSTEXPR void on_second(numeric_system, pad_type) {} FMT_CONSTEXPR void on_12_hour_time() {} FMT_CONSTEXPR void on_24_hour_time() {} FMT_CONSTEXPR void on_iso_time() {} FMT_CONSTEXPR void on_am_pm() {} FMT_CONSTEXPR void on_duration_value() const { if (has_precision_integral) { FMT_THROW(format_error("precision not allowed for this argument type")); } } FMT_CONSTEXPR void on_duration_unit() {} }; template ::value&& has_isfinite::value)> inline auto isfinite(T) -> bool { return true; } template ::value)> inline auto mod(T x, int y) -> T { return x % static_cast(y); } template ::value)> inline auto mod(T x, int y) -> T { return std::fmod(x, static_cast(y)); } // If T is an integral type, maps T to its unsigned counterpart, otherwise // leaves it unchanged (unlike std::make_unsigned). template ::value> struct make_unsigned_or_unchanged { using type = T; }; template struct make_unsigned_or_unchanged { using type = typename std::make_unsigned::type; }; template ::value)> inline auto get_milliseconds(std::chrono::duration d) -> std::chrono::duration { // this may overflow and/or the result may not fit in the // target type. #if FMT_SAFE_DURATION_CAST using CommonSecondsType = typename std::common_type::type; const auto d_as_common = fmt_duration_cast(d); const auto d_as_whole_seconds = fmt_duration_cast(d_as_common); // this conversion should be nonproblematic const auto diff = d_as_common - d_as_whole_seconds; const auto ms = fmt_duration_cast>(diff); return ms; #else auto s = fmt_duration_cast(d); return fmt_duration_cast(d - s); #endif } template ::value)> auto format_duration_value(OutputIt out, Rep val, int) -> OutputIt { return write(out, val); } template ::value)> auto format_duration_value(OutputIt out, Rep val, int precision) -> OutputIt { auto specs = format_specs(); specs.precision = precision; specs.type = precision >= 0 ? presentation_type::fixed_lower : presentation_type::general_lower; return write(out, val, specs); } template auto copy_unit(string_view unit, OutputIt out, Char) -> OutputIt { return std::copy(unit.begin(), unit.end(), out); } template auto copy_unit(string_view unit, OutputIt out, wchar_t) -> OutputIt { // This works when wchar_t is UTF-32 because units only contain characters // that have the same representation in UTF-16 and UTF-32. utf8_to_utf16 u(unit); return std::copy(u.c_str(), u.c_str() + u.size(), out); } template auto format_duration_unit(OutputIt out) -> OutputIt { if (const char* unit = get_units()) return copy_unit(string_view(unit), out, Char()); *out++ = '['; out = write(out, Period::num); if (const_check(Period::den != 1)) { *out++ = '/'; out = write(out, Period::den); } *out++ = ']'; *out++ = 's'; return out; } class get_locale { private: union { std::locale locale_; }; bool has_locale_ = false; public: get_locale(bool localized, locale_ref loc) : has_locale_(localized) { if (localized) ::new (&locale_) std::locale(loc.template get()); } ~get_locale() { if (has_locale_) locale_.~locale(); } operator const std::locale&() const { return has_locale_ ? locale_ : get_classic_locale(); } }; template struct chrono_formatter { FormatContext& context; OutputIt out; int precision; bool localized = false; // rep is unsigned to avoid overflow. using rep = conditional_t::value && sizeof(Rep) < sizeof(int), unsigned, typename make_unsigned_or_unchanged::type>; rep val; using seconds = std::chrono::duration; seconds s; using milliseconds = std::chrono::duration; bool negative; using char_type = typename FormatContext::char_type; using tm_writer_type = tm_writer; chrono_formatter(FormatContext& ctx, OutputIt o, std::chrono::duration d) : context(ctx), out(o), val(static_cast(d.count())), negative(false) { if (d.count() < 0) { val = 0 - val; negative = true; } // this may overflow and/or the result may not fit in the // target type. // might need checked conversion (rep!=Rep) s = fmt_duration_cast(std::chrono::duration(val)); } // returns true if nan or inf, writes to out. auto handle_nan_inf() -> bool { if (isfinite(val)) { return false; } if (isnan(val)) { write_nan(); return true; } // must be +-inf if (val > 0) { write_pinf(); } else { write_ninf(); } return true; } auto days() const -> Rep { return static_cast(s.count() / 86400); } auto hour() const -> Rep { return static_cast(mod((s.count() / 3600), 24)); } auto hour12() const -> Rep { Rep hour = static_cast(mod((s.count() / 3600), 12)); return hour <= 0 ? 12 : hour; } auto minute() const -> Rep { return static_cast(mod((s.count() / 60), 60)); } auto second() const -> Rep { return static_cast(mod(s.count(), 60)); } auto time() const -> std::tm { auto time = std::tm(); time.tm_hour = to_nonnegative_int(hour(), 24); time.tm_min = to_nonnegative_int(minute(), 60); time.tm_sec = to_nonnegative_int(second(), 60); return time; } void write_sign() { if (negative) { *out++ = '-'; negative = false; } } void write(Rep value, int width, pad_type pad = pad_type::unspecified) { write_sign(); if (isnan(value)) return write_nan(); uint32_or_64_or_128_t n = to_unsigned(to_nonnegative_int(value, max_value())); int num_digits = detail::count_digits(n); if (width > num_digits) { out = detail::write_padding(out, pad, width - num_digits); } out = format_decimal(out, n, num_digits).end; } void write_nan() { std::copy_n("nan", 3, out); } void write_pinf() { std::copy_n("inf", 3, out); } void write_ninf() { std::copy_n("-inf", 4, out); } template void format_tm(const tm& time, Callback cb, Args... args) { if (isnan(val)) return write_nan(); get_locale loc(localized, context.locale()); auto w = tm_writer_type(loc, out, time); (w.*cb)(args...); out = w.out(); } void on_text(const char_type* begin, const char_type* end) { std::copy(begin, end, out); } // These are not implemented because durations don't have date information. void on_abbr_weekday() {} void on_full_weekday() {} void on_dec0_weekday(numeric_system) {} void on_dec1_weekday(numeric_system) {} void on_abbr_month() {} void on_full_month() {} void on_datetime(numeric_system) {} void on_loc_date(numeric_system) {} void on_loc_time(numeric_system) {} void on_us_date() {} void on_iso_date() {} void on_utc_offset(numeric_system) {} void on_tz_name() {} void on_year(numeric_system) {} void on_short_year(numeric_system) {} void on_offset_year() {} void on_century(numeric_system) {} void on_iso_week_based_year() {} void on_iso_week_based_short_year() {} void on_dec_month(numeric_system) {} void on_dec0_week_of_year(numeric_system) {} void on_dec1_week_of_year(numeric_system) {} void on_iso_week_of_year(numeric_system) {} void on_day_of_month(numeric_system) {} void on_day_of_month_space(numeric_system) {} void on_day_of_year() { if (handle_nan_inf()) return; write(days(), 0); } void on_24_hour(numeric_system ns, pad_type pad) { if (handle_nan_inf()) return; if (ns == numeric_system::standard) return write(hour(), 2, pad); auto time = tm(); time.tm_hour = to_nonnegative_int(hour(), 24); format_tm(time, &tm_writer_type::on_24_hour, ns, pad); } void on_12_hour(numeric_system ns, pad_type pad) { if (handle_nan_inf()) return; if (ns == numeric_system::standard) return write(hour12(), 2, pad); auto time = tm(); time.tm_hour = to_nonnegative_int(hour12(), 12); format_tm(time, &tm_writer_type::on_12_hour, ns, pad); } void on_minute(numeric_system ns, pad_type pad) { if (handle_nan_inf()) return; if (ns == numeric_system::standard) return write(minute(), 2, pad); auto time = tm(); time.tm_min = to_nonnegative_int(minute(), 60); format_tm(time, &tm_writer_type::on_minute, ns, pad); } void on_second(numeric_system ns, pad_type pad) { if (handle_nan_inf()) return; if (ns == numeric_system::standard) { if (std::is_floating_point::value) { auto buf = memory_buffer(); write_floating_seconds(buf, std::chrono::duration(val), precision); if (negative) *out++ = '-'; if (buf.size() < 2 || buf[1] == '.') { out = detail::write_padding(out, pad); } out = std::copy(buf.begin(), buf.end(), out); } else { write(second(), 2, pad); write_fractional_seconds( out, std::chrono::duration(val), precision); } return; } auto time = tm(); time.tm_sec = to_nonnegative_int(second(), 60); format_tm(time, &tm_writer_type::on_second, ns, pad); } void on_12_hour_time() { if (handle_nan_inf()) return; format_tm(time(), &tm_writer_type::on_12_hour_time); } void on_24_hour_time() { if (handle_nan_inf()) { *out++ = ':'; handle_nan_inf(); return; } write(hour(), 2); *out++ = ':'; write(minute(), 2); } void on_iso_time() { on_24_hour_time(); *out++ = ':'; if (handle_nan_inf()) return; on_second(numeric_system::standard, pad_type::unspecified); } void on_am_pm() { if (handle_nan_inf()) return; format_tm(time(), &tm_writer_type::on_am_pm); } void on_duration_value() { if (handle_nan_inf()) return; write_sign(); out = format_duration_value(out, val, precision); } void on_duration_unit() { out = format_duration_unit(out); } }; } // namespace detail #if defined(__cpp_lib_chrono) && __cpp_lib_chrono >= 201907 using weekday = std::chrono::weekday; #else // A fallback version of weekday. class weekday { private: unsigned char value; public: weekday() = default; explicit constexpr weekday(unsigned wd) noexcept : value(static_cast(wd != 7 ? wd : 0)) {} constexpr auto c_encoding() const noexcept -> unsigned { return value; } }; class year_month_day {}; #endif // A rudimentary weekday formatter. template struct formatter { private: bool localized = false; public: FMT_CONSTEXPR auto parse(basic_format_parse_context& ctx) -> decltype(ctx.begin()) { auto begin = ctx.begin(), end = ctx.end(); if (begin != end && *begin == 'L') { ++begin; localized = true; } return begin; } template auto format(weekday wd, FormatContext& ctx) const -> decltype(ctx.out()) { auto time = std::tm(); time.tm_wday = static_cast(wd.c_encoding()); detail::get_locale loc(localized, ctx.locale()); auto w = detail::tm_writer(loc, ctx.out(), time); w.on_abbr_weekday(); return w.out(); } }; template struct formatter, Char> { private: format_specs specs_; detail::arg_ref width_ref_; detail::arg_ref precision_ref_; bool localized_ = false; basic_string_view format_str_; public: FMT_CONSTEXPR auto parse(basic_format_parse_context& ctx) -> decltype(ctx.begin()) { auto it = ctx.begin(), end = ctx.end(); if (it == end || *it == '}') return it; it = detail::parse_align(it, end, specs_); if (it == end) return it; it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx); if (it == end) return it; auto checker = detail::chrono_format_checker(); if (*it == '.') { checker.has_precision_integral = !std::is_floating_point::value; it = detail::parse_precision(it, end, specs_.precision, precision_ref_, ctx); } if (it != end && *it == 'L') { localized_ = true; ++it; } end = detail::parse_chrono_format(it, end, checker); format_str_ = {it, detail::to_unsigned(end - it)}; return end; } template auto format(std::chrono::duration d, FormatContext& ctx) const -> decltype(ctx.out()) { auto specs = specs_; auto precision = specs.precision; specs.precision = -1; auto begin = format_str_.begin(), end = format_str_.end(); // As a possible future optimization, we could avoid extra copying if width // is not specified. auto buf = basic_memory_buffer(); auto out = std::back_inserter(buf); detail::handle_dynamic_spec(specs.width, width_ref_, ctx); detail::handle_dynamic_spec(precision, precision_ref_, ctx); if (begin == end || *begin == '}') { out = detail::format_duration_value(out, d.count(), precision); detail::format_duration_unit(out); } else { using chrono_formatter = detail::chrono_formatter; auto f = chrono_formatter(ctx, out, d); f.precision = precision; f.localized = localized_; detail::parse_chrono_format(begin, end, f); } return detail::write( ctx.out(), basic_string_view(buf.data(), buf.size()), specs); } }; template struct formatter, Char> : formatter { FMT_CONSTEXPR formatter() { this->format_str_ = detail::string_literal{}; } template auto format(std::chrono::time_point val, FormatContext& ctx) const -> decltype(ctx.out()) { using period = typename Duration::period; if (detail::const_check( period::num != 1 || period::den != 1 || std::is_floating_point::value)) { const auto epoch = val.time_since_epoch(); auto subsecs = detail::fmt_duration_cast( epoch - detail::fmt_duration_cast(epoch)); if (subsecs.count() < 0) { auto second = detail::fmt_duration_cast(std::chrono::seconds(1)); if (epoch.count() < ((Duration::min)() + second).count()) FMT_THROW(format_error("duration is too small")); subsecs += second; val -= second; } return formatter::do_format(gmtime(val), ctx, &subsecs); } return formatter::format(gmtime(val), ctx); } }; #if FMT_USE_LOCAL_TIME template struct formatter, Char> : formatter { FMT_CONSTEXPR formatter() { this->format_str_ = detail::string_literal{}; } template auto format(std::chrono::local_time val, FormatContext& ctx) const -> decltype(ctx.out()) { using period = typename Duration::period; if (period::num != 1 || period::den != 1 || std::is_floating_point::value) { const auto epoch = val.time_since_epoch(); const auto subsecs = detail::fmt_duration_cast( epoch - detail::fmt_duration_cast(epoch)); return formatter::do_format(localtime(val), ctx, &subsecs); } return formatter::format(localtime(val), ctx); } }; #endif #if FMT_USE_UTC_TIME template struct formatter, Char> : formatter, Char> { template auto format(std::chrono::time_point val, FormatContext& ctx) const -> decltype(ctx.out()) { return formatter< std::chrono::time_point, Char>::format(std::chrono::utc_clock::to_sys(val), ctx); } }; #endif template struct formatter { private: format_specs specs_; detail::arg_ref width_ref_; protected: basic_string_view format_str_; template auto do_format(const std::tm& tm, FormatContext& ctx, const Duration* subsecs) const -> decltype(ctx.out()) { auto specs = specs_; auto buf = basic_memory_buffer(); auto out = std::back_inserter(buf); detail::handle_dynamic_spec(specs.width, width_ref_, ctx); auto loc_ref = ctx.locale(); detail::get_locale loc(static_cast(loc_ref), loc_ref); auto w = detail::tm_writer(loc, out, tm, subsecs); detail::parse_chrono_format(format_str_.begin(), format_str_.end(), w); return detail::write( ctx.out(), basic_string_view(buf.data(), buf.size()), specs); } public: FMT_CONSTEXPR auto parse(basic_format_parse_context& ctx) -> decltype(ctx.begin()) { auto it = ctx.begin(), end = ctx.end(); if (it == end || *it == '}') return it; it = detail::parse_align(it, end, specs_); if (it == end) return it; it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx); if (it == end) return it; end = detail::parse_chrono_format(it, end, detail::tm_format_checker()); // Replace the default format_str only if the new spec is not empty. if (end != it) format_str_ = {it, detail::to_unsigned(end - it)}; return end; } template auto format(const std::tm& tm, FormatContext& ctx) const -> decltype(ctx.out()) { return do_format(tm, ctx, nullptr); } }; FMT_END_EXPORT FMT_END_NAMESPACE #endif // FMT_CHRONO_H_ RcppSpdlog/inst/include/spdlog/fmt/bundled/std.h0000644000176200001440000003755714612604314021407 0ustar liggesusers// Formatting library for C++ - formatters for standard library types // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_STD_H_ #define FMT_STD_H_ #include #include #include #include #include #include #include #include #include #include #include "format.h" #include "ostream.h" #if FMT_HAS_INCLUDE() # include #endif // Checking FMT_CPLUSPLUS for warning suppression in MSVC. #if FMT_CPLUSPLUS >= 201703L # if FMT_HAS_INCLUDE() # include # endif # if FMT_HAS_INCLUDE() # include # endif # if FMT_HAS_INCLUDE() # include # endif #endif #if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE() # include #endif // GCC 4 does not support FMT_HAS_INCLUDE. #if FMT_HAS_INCLUDE() || defined(__GLIBCXX__) # include // Android NDK with gabi++ library on some architectures does not implement // abi::__cxa_demangle(). # ifndef __GABIXX_CXXABI_H__ # define FMT_HAS_ABI_CXA_DEMANGLE # endif #endif // Check if typeid is available. #ifndef FMT_USE_TYPEID // __RTTI is for EDG compilers. In MSVC typeid is available without RTTI. # if defined(__GXX_RTTI) || FMT_HAS_FEATURE(cxx_rtti) || FMT_MSC_VERSION || \ defined(__INTEL_RTTI__) || defined(__RTTI) # define FMT_USE_TYPEID 1 # else # define FMT_USE_TYPEID 0 # endif #endif // For older Xcode versions, __cpp_lib_xxx flags are inaccurately defined. #ifndef FMT_CPP_LIB_FILESYSTEM # ifdef __cpp_lib_filesystem # define FMT_CPP_LIB_FILESYSTEM __cpp_lib_filesystem # else # define FMT_CPP_LIB_FILESYSTEM 0 # endif #endif #ifndef FMT_CPP_LIB_VARIANT # ifdef __cpp_lib_variant # define FMT_CPP_LIB_VARIANT __cpp_lib_variant # else # define FMT_CPP_LIB_VARIANT 0 # endif #endif #if FMT_CPP_LIB_FILESYSTEM FMT_BEGIN_NAMESPACE namespace detail { template auto get_path_string(const std::filesystem::path& p, const std::basic_string& native) { if constexpr (std::is_same_v && std::is_same_v) return to_utf8(native, to_utf8_error_policy::replace); else return p.string(); } template void write_escaped_path(basic_memory_buffer& quoted, const std::filesystem::path& p, const std::basic_string& native) { if constexpr (std::is_same_v && std::is_same_v) { auto buf = basic_memory_buffer(); write_escaped_string(std::back_inserter(buf), native); bool valid = to_utf8::convert(quoted, {buf.data(), buf.size()}); FMT_ASSERT(valid, "invalid utf16"); } else if constexpr (std::is_same_v) { write_escaped_string( std::back_inserter(quoted), native); } else { write_escaped_string(std::back_inserter(quoted), p.string()); } } } // namespace detail FMT_EXPORT template struct formatter { private: format_specs specs_; detail::arg_ref width_ref_; bool debug_ = false; char path_type_ = 0; public: FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; } template FMT_CONSTEXPR auto parse(ParseContext& ctx) { auto it = ctx.begin(), end = ctx.end(); if (it == end) return it; it = detail::parse_align(it, end, specs_); if (it == end) return it; it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx); if (it != end && *it == '?') { debug_ = true; ++it; } if (it != end && (*it == 'g')) path_type_ = *it++; return it; } template auto format(const std::filesystem::path& p, FormatContext& ctx) const { auto specs = specs_; # ifdef _WIN32 auto path_string = !path_type_ ? p.native() : p.generic_wstring(); # else auto path_string = !path_type_ ? p.native() : p.generic_string(); # endif detail::handle_dynamic_spec(specs.width, width_ref_, ctx); if (!debug_) { auto s = detail::get_path_string(p, path_string); return detail::write(ctx.out(), basic_string_view(s), specs); } auto quoted = basic_memory_buffer(); detail::write_escaped_path(quoted, p, path_string); return detail::write(ctx.out(), basic_string_view(quoted.data(), quoted.size()), specs); } }; FMT_END_NAMESPACE #endif // FMT_CPP_LIB_FILESYSTEM FMT_BEGIN_NAMESPACE FMT_EXPORT template struct formatter, Char> : nested_formatter { private: // Functor because C++11 doesn't support generic lambdas. struct writer { const std::bitset& bs; template FMT_CONSTEXPR auto operator()(OutputIt out) -> OutputIt { for (auto pos = N; pos > 0; --pos) { out = detail::write(out, bs[pos - 1] ? Char('1') : Char('0')); } return out; } }; public: template auto format(const std::bitset& bs, FormatContext& ctx) const -> decltype(ctx.out()) { return write_padded(ctx, writer{bs}); } }; FMT_EXPORT template struct formatter : basic_ostream_formatter {}; FMT_END_NAMESPACE #ifdef __cpp_lib_optional FMT_BEGIN_NAMESPACE FMT_EXPORT template struct formatter, Char, std::enable_if_t::value>> { private: formatter underlying_; static constexpr basic_string_view optional = detail::string_literal{}; static constexpr basic_string_view none = detail::string_literal{}; template FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, bool set) -> decltype(u.set_debug_format(set)) { u.set_debug_format(set); } template FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {} public: template FMT_CONSTEXPR auto parse(ParseContext& ctx) { maybe_set_debug_format(underlying_, true); return underlying_.parse(ctx); } template auto format(const std::optional& opt, FormatContext& ctx) const -> decltype(ctx.out()) { if (!opt) return detail::write(ctx.out(), none); auto out = ctx.out(); out = detail::write(out, optional); ctx.advance_to(out); out = underlying_.format(*opt, ctx); return detail::write(out, ')'); } }; FMT_END_NAMESPACE #endif // __cpp_lib_optional #ifdef __cpp_lib_source_location FMT_BEGIN_NAMESPACE FMT_EXPORT template <> struct formatter { template FMT_CONSTEXPR auto parse(ParseContext& ctx) { return ctx.begin(); } template auto format(const std::source_location& loc, FormatContext& ctx) const -> decltype(ctx.out()) { auto out = ctx.out(); out = detail::write(out, loc.file_name()); out = detail::write(out, ':'); out = detail::write(out, loc.line()); out = detail::write(out, ':'); out = detail::write(out, loc.column()); out = detail::write(out, ": "); out = detail::write(out, loc.function_name()); return out; } }; FMT_END_NAMESPACE #endif #if FMT_CPP_LIB_VARIANT FMT_BEGIN_NAMESPACE namespace detail { template using variant_index_sequence = std::make_index_sequence::value>; template struct is_variant_like_ : std::false_type {}; template struct is_variant_like_> : std::true_type {}; // formattable element check. template class is_variant_formattable_ { template static std::conjunction< is_formattable, C>...> check(std::index_sequence); public: static constexpr const bool value = decltype(check(variant_index_sequence{}))::value; }; template auto write_variant_alternative(OutputIt out, const T& v) -> OutputIt { if constexpr (is_string::value) return write_escaped_string(out, detail::to_string_view(v)); else if constexpr (std::is_same_v) return write_escaped_char(out, v); else return write(out, v); } } // namespace detail template struct is_variant_like { static constexpr const bool value = detail::is_variant_like_::value; }; template struct is_variant_formattable { static constexpr const bool value = detail::is_variant_formattable_::value; }; FMT_EXPORT template struct formatter { template FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { return ctx.begin(); } template auto format(const std::monostate&, FormatContext& ctx) const -> decltype(ctx.out()) { return detail::write(ctx.out(), "monostate"); } }; FMT_EXPORT template struct formatter< Variant, Char, std::enable_if_t, is_variant_formattable>>> { template FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { return ctx.begin(); } template auto format(const Variant& value, FormatContext& ctx) const -> decltype(ctx.out()) { auto out = ctx.out(); out = detail::write(out, "variant("); FMT_TRY { std::visit( [&](const auto& v) { out = detail::write_variant_alternative(out, v); }, value); } FMT_CATCH(const std::bad_variant_access&) { detail::write(out, "valueless by exception"); } *out++ = ')'; return out; } }; FMT_END_NAMESPACE #endif // FMT_CPP_LIB_VARIANT FMT_BEGIN_NAMESPACE FMT_EXPORT template struct formatter { template FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { return ctx.begin(); } template FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const -> decltype(ctx.out()) { auto out = ctx.out(); out = detail::write_bytes(out, ec.category().name(), format_specs()); out = detail::write(out, Char(':')); out = detail::write(out, ec.value()); return out; } }; FMT_EXPORT template struct formatter< T, Char, // DEPRECATED! Mixing code unit types. typename std::enable_if::value>::type> { private: bool with_typename_ = false; public: FMT_CONSTEXPR auto parse(basic_format_parse_context& ctx) -> decltype(ctx.begin()) { auto it = ctx.begin(); auto end = ctx.end(); if (it == end || *it == '}') return it; if (*it == 't') { ++it; with_typename_ = FMT_USE_TYPEID != 0; } return it; } template auto format(const std::exception& ex, basic_format_context& ctx) const -> OutputIt { format_specs spec; auto out = ctx.out(); if (!with_typename_) return detail::write_bytes(out, string_view(ex.what()), spec); #if FMT_USE_TYPEID const std::type_info& ti = typeid(ex); # ifdef FMT_HAS_ABI_CXA_DEMANGLE int status = 0; std::size_t size = 0; std::unique_ptr demangled_name_ptr( abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free); string_view demangled_name_view; if (demangled_name_ptr) { demangled_name_view = demangled_name_ptr.get(); // Normalization of stdlib inline namespace names. // libc++ inline namespaces. // std::__1::* -> std::* // std::__1::__fs::* -> std::* // libstdc++ inline namespaces. // std::__cxx11::* -> std::* // std::filesystem::__cxx11::* -> std::filesystem::* if (demangled_name_view.starts_with("std::")) { char* begin = demangled_name_ptr.get(); char* to = begin + 5; // std:: for (char *from = to, *end = begin + demangled_name_view.size(); from < end;) { // This is safe, because demangled_name is NUL-terminated. if (from[0] == '_' && from[1] == '_') { char* next = from + 1; while (next < end && *next != ':') next++; if (next[0] == ':' && next[1] == ':') { from = next + 2; continue; } } *to++ = *from++; } demangled_name_view = {begin, detail::to_unsigned(to - begin)}; } } else { demangled_name_view = string_view(ti.name()); } out = detail::write_bytes(out, demangled_name_view, spec); # elif FMT_MSC_VERSION string_view demangled_name_view(ti.name()); if (demangled_name_view.starts_with("class ")) demangled_name_view.remove_prefix(6); else if (demangled_name_view.starts_with("struct ")) demangled_name_view.remove_prefix(7); out = detail::write_bytes(out, demangled_name_view, spec); # else out = detail::write_bytes(out, string_view(ti.name()), spec); # endif *out++ = ':'; *out++ = ' '; return detail::write_bytes(out, string_view(ex.what()), spec); #endif } }; namespace detail { template struct has_flip : std::false_type {}; template struct has_flip().flip())>> : std::true_type {}; template struct is_bit_reference_like { static constexpr const bool value = std::is_convertible::value && std::is_nothrow_assignable::value && has_flip::value; }; #ifdef _LIBCPP_VERSION // Workaround for libc++ incompatibility with C++ standard. // According to the Standard, `bitset::operator[] const` returns bool. template struct is_bit_reference_like> { static constexpr const bool value = true; }; #endif } // namespace detail // We can't use std::vector::reference and // std::bitset::reference because the compiler can't deduce Allocator and N // in partial specialization. FMT_EXPORT template struct formatter::value>> : formatter { template FMT_CONSTEXPR auto format(const BitRef& v, FormatContext& ctx) const -> decltype(ctx.out()) { return formatter::format(v, ctx); } }; FMT_EXPORT template struct formatter, Char, enable_if_t::value>> : formatter { template auto format(const std::atomic& v, FormatContext& ctx) const -> decltype(ctx.out()) { return formatter::format(v.load(), ctx); } }; #ifdef __cpp_lib_atomic_flag_test FMT_EXPORT template struct formatter : formatter { template auto format(const std::atomic_flag& v, FormatContext& ctx) const -> decltype(ctx.out()) { return formatter::format(v.test(), ctx); } }; #endif // __cpp_lib_atomic_flag_test FMT_END_NAMESPACE #endif // FMT_STD_H_ RcppSpdlog/inst/include/spdlog/fmt/bundled/args.h0000644000176200001440000001644214612604314021537 0ustar liggesusers// Formatting library for C++ - dynamic argument lists // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_ARGS_H_ #define FMT_ARGS_H_ #include // std::reference_wrapper #include // std::unique_ptr #include #include "core.h" FMT_BEGIN_NAMESPACE namespace detail { template struct is_reference_wrapper : std::false_type {}; template struct is_reference_wrapper> : std::true_type {}; template auto unwrap(const T& v) -> const T& { return v; } template auto unwrap(const std::reference_wrapper& v) -> const T& { return static_cast(v); } class dynamic_arg_list { // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for // templates it doesn't complain about inability to deduce single translation // unit for placing vtable. So storage_node_base is made a fake template. template struct node { virtual ~node() = default; std::unique_ptr> next; }; template struct typed_node : node<> { T value; template FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {} template FMT_CONSTEXPR typed_node(const basic_string_view& arg) : value(arg.data(), arg.size()) {} }; std::unique_ptr> head_; public: template auto push(const Arg& arg) -> const T& { auto new_node = std::unique_ptr>(new typed_node(arg)); auto& value = new_node->value; new_node->next = std::move(head_); head_ = std::move(new_node); return value; } }; } // namespace detail /** \rst A dynamic version of `fmt::format_arg_store`. It's equipped with a storage to potentially temporary objects which lifetimes could be shorter than the format arguments object. It can be implicitly converted into `~fmt::basic_format_args` for passing into type-erased formatting functions such as `~fmt::vformat`. \endrst */ template class dynamic_format_arg_store #if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 // Workaround a GCC template argument substitution bug. : public basic_format_args #endif { private: using char_type = typename Context::char_type; template struct need_copy { static constexpr detail::type mapped_type = detail::mapped_type_constant::value; enum { value = !(detail::is_reference_wrapper::value || std::is_same>::value || std::is_same>::value || (mapped_type != detail::type::cstring_type && mapped_type != detail::type::string_type && mapped_type != detail::type::custom_type)) }; }; template using stored_type = conditional_t< std::is_convertible>::value && !detail::is_reference_wrapper::value, std::basic_string, T>; // Storage of basic_format_arg must be contiguous. std::vector> data_; std::vector> named_info_; // Storage of arguments not fitting into basic_format_arg must grow // without relocation because items in data_ refer to it. detail::dynamic_arg_list dynamic_args_; friend class basic_format_args; auto get_types() const -> unsigned long long { return detail::is_unpacked_bit | data_.size() | (named_info_.empty() ? 0ULL : static_cast(detail::has_named_args_bit)); } auto data() const -> const basic_format_arg* { return named_info_.empty() ? data_.data() : data_.data() + 1; } template void emplace_arg(const T& arg) { data_.emplace_back(detail::make_arg(arg)); } template void emplace_arg(const detail::named_arg& arg) { if (named_info_.empty()) { constexpr const detail::named_arg_info* zero_ptr{nullptr}; data_.insert(data_.begin(), {zero_ptr, 0}); } data_.emplace_back(detail::make_arg(detail::unwrap(arg.value))); auto pop_one = [](std::vector>* data) { data->pop_back(); }; std::unique_ptr>, decltype(pop_one)> guard{&data_, pop_one}; named_info_.push_back({arg.name, static_cast(data_.size() - 2u)}); data_[0].value_.named_args = {named_info_.data(), named_info_.size()}; guard.release(); } public: constexpr dynamic_format_arg_store() = default; /** \rst Adds an argument into the dynamic store for later passing to a formatting function. Note that custom types and string types (but not string views) are copied into the store dynamically allocating memory if necessary. **Example**:: fmt::dynamic_format_arg_store store; store.push_back(42); store.push_back("abc"); store.push_back(1.5f); std::string result = fmt::vformat("{} and {} and {}", store); \endrst */ template void push_back(const T& arg) { if (detail::const_check(need_copy::value)) emplace_arg(dynamic_args_.push>(arg)); else emplace_arg(detail::unwrap(arg)); } /** \rst Adds a reference to the argument into the dynamic store for later passing to a formatting function. **Example**:: fmt::dynamic_format_arg_store store; char band[] = "Rolling Stones"; store.push_back(std::cref(band)); band[9] = 'c'; // Changing str affects the output. std::string result = fmt::vformat("{}", store); // result == "Rolling Scones" \endrst */ template void push_back(std::reference_wrapper arg) { static_assert( need_copy::value, "objects of built-in types and string views are always copied"); emplace_arg(arg.get()); } /** Adds named argument into the dynamic store for later passing to a formatting function. ``std::reference_wrapper`` is supported to avoid copying of the argument. The name is always copied into the store. */ template void push_back(const detail::named_arg& arg) { const char_type* arg_name = dynamic_args_.push>(arg.name).c_str(); if (detail::const_check(need_copy::value)) { emplace_arg( fmt::arg(arg_name, dynamic_args_.push>(arg.value))); } else { emplace_arg(fmt::arg(arg_name, arg.value)); } } /** Erase all elements from the store */ void clear() { data_.clear(); named_info_.clear(); dynamic_args_ = detail::dynamic_arg_list(); } /** \rst Reserves space to store at least *new_cap* arguments including *new_cap_named* named arguments. \endrst */ void reserve(size_t new_cap, size_t new_cap_named) { FMT_ASSERT(new_cap >= new_cap_named, "Set of arguments includes set of named arguments"); data_.reserve(new_cap); named_info_.reserve(new_cap_named); } }; FMT_END_NAMESPACE #endif // FMT_ARGS_H_ RcppSpdlog/inst/include/spdlog/fmt/bundled/ostream.h0000644000176200001440000001621114612604314022247 0ustar liggesusers// Formatting library for C++ - std::ostream support // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_OSTREAM_H_ #define FMT_OSTREAM_H_ #include // std::filebuf #ifdef _WIN32 # ifdef __GLIBCXX__ # include # include # endif # include #endif #include "format.h" FMT_BEGIN_NAMESPACE namespace detail { template class formatbuf : public Streambuf { private: using char_type = typename Streambuf::char_type; using streamsize = decltype(std::declval().sputn(nullptr, 0)); using int_type = typename Streambuf::int_type; using traits_type = typename Streambuf::traits_type; buffer& buffer_; public: explicit formatbuf(buffer& buf) : buffer_(buf) {} protected: // The put area is always empty. This makes the implementation simpler and has // the advantage that the streambuf and the buffer are always in sync and // sputc never writes into uninitialized memory. A disadvantage is that each // call to sputc always results in a (virtual) call to overflow. There is no // disadvantage here for sputn since this always results in a call to xsputn. auto overflow(int_type ch) -> int_type override { if (!traits_type::eq_int_type(ch, traits_type::eof())) buffer_.push_back(static_cast(ch)); return ch; } auto xsputn(const char_type* s, streamsize count) -> streamsize override { buffer_.append(s, s + count); return count; } }; // Generate a unique explicit instantion in every translation unit using a tag // type in an anonymous namespace. namespace { struct file_access_tag {}; } // namespace template class file_access { friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; } }; #if FMT_MSC_VERSION template class file_access; auto get_file(std::filebuf&) -> FILE*; #endif inline auto write_ostream_unicode(std::ostream& os, fmt::string_view data) -> bool { FILE* f = nullptr; #if FMT_MSC_VERSION if (auto* buf = dynamic_cast(os.rdbuf())) f = get_file(*buf); else return false; #elif defined(_WIN32) && defined(__GLIBCXX__) auto* rdbuf = os.rdbuf(); if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf*>(rdbuf)) f = sfbuf->file(); else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf*>(rdbuf)) f = fbuf->file(); else return false; #else ignore_unused(os, data, f); #endif #ifdef _WIN32 if (f) { int fd = _fileno(f); if (_isatty(fd)) { os.flush(); return write_console(fd, data); } } #endif return false; } inline auto write_ostream_unicode(std::wostream&, fmt::basic_string_view) -> bool { return false; } // Write the content of buf to os. // It is a separate function rather than a part of vprint to simplify testing. template void write_buffer(std::basic_ostream& os, buffer& buf) { const Char* buf_data = buf.data(); using unsigned_streamsize = std::make_unsigned::type; unsigned_streamsize size = buf.size(); unsigned_streamsize max_size = to_unsigned(max_value()); do { unsigned_streamsize n = size <= max_size ? size : max_size; os.write(buf_data, static_cast(n)); buf_data += n; size -= n; } while (size != 0); } template void format_value(buffer& buf, const T& value) { auto&& format_buf = formatbuf>(buf); auto&& output = std::basic_ostream(&format_buf); #if !defined(FMT_STATIC_THOUSANDS_SEPARATOR) output.imbue(std::locale::classic()); // The default is always unlocalized. #endif output << value; output.exceptions(std::ios_base::failbit | std::ios_base::badbit); } template struct streamed_view { const T& value; }; } // namespace detail // Formats an object of type T that has an overloaded ostream operator<<. template struct basic_ostream_formatter : formatter, Char> { void set_debug_format() = delete; template auto format(const T& value, basic_format_context& ctx) const -> OutputIt { auto buffer = basic_memory_buffer(); detail::format_value(buffer, value); return formatter, Char>::format( {buffer.data(), buffer.size()}, ctx); } }; using ostream_formatter = basic_ostream_formatter; template struct formatter, Char> : basic_ostream_formatter { template auto format(detail::streamed_view view, basic_format_context& ctx) const -> OutputIt { return basic_ostream_formatter::format(view.value, ctx); } }; /** \rst Returns a view that formats `value` via an ostream ``operator<<``. **Example**:: fmt::print("Current thread id: {}\n", fmt::streamed(std::this_thread::get_id())); \endrst */ template constexpr auto streamed(const T& value) -> detail::streamed_view { return {value}; } namespace detail { inline void vprint_directly(std::ostream& os, string_view format_str, format_args args) { auto buffer = memory_buffer(); detail::vformat_to(buffer, format_str, args); detail::write_buffer(os, buffer); } } // namespace detail FMT_EXPORT template void vprint(std::basic_ostream& os, basic_string_view> format_str, basic_format_args>> args) { auto buffer = basic_memory_buffer(); detail::vformat_to(buffer, format_str, args); if (detail::write_ostream_unicode(os, {buffer.data(), buffer.size()})) return; detail::write_buffer(os, buffer); } /** \rst Prints formatted data to the stream *os*. **Example**:: fmt::print(cerr, "Don't {}!", "panic"); \endrst */ FMT_EXPORT template void print(std::ostream& os, format_string fmt, T&&... args) { const auto& vargs = fmt::make_format_args(args...); if (detail::is_utf8()) vprint(os, fmt, vargs); else detail::vprint_directly(os, fmt, vargs); } FMT_EXPORT template void print(std::wostream& os, basic_format_string...> fmt, Args&&... args) { vprint(os, fmt, fmt::make_format_args>(args...)); } FMT_EXPORT template void println(std::ostream& os, format_string fmt, T&&... args) { fmt::print(os, "{}\n", fmt::format(fmt, std::forward(args)...)); } FMT_EXPORT template void println(std::wostream& os, basic_format_string...> fmt, Args&&... args) { print(os, L"{}\n", fmt::format(fmt, std::forward(args)...)); } FMT_END_NAMESPACE #endif // FMT_OSTREAM_H_ RcppSpdlog/inst/include/spdlog/fmt/bundled/ranges.h0000644000176200001440000005757614612604314022077 0ustar liggesusers// Formatting library for C++ - range and tuple support // // Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_RANGES_H_ #define FMT_RANGES_H_ #include #include #include #include "format.h" FMT_BEGIN_NAMESPACE namespace detail { template auto copy(const Range& range, OutputIt out) -> OutputIt { for (auto it = range.begin(), end = range.end(); it != end; ++it) *out++ = *it; return out; } template auto copy(const char* str, OutputIt out) -> OutputIt { while (*str) *out++ = *str++; return out; } template auto copy(char ch, OutputIt out) -> OutputIt { *out++ = ch; return out; } template auto copy(wchar_t ch, OutputIt out) -> OutputIt { *out++ = ch; return out; } // Returns true if T has a std::string-like interface, like std::string_view. template class is_std_string_like { template static auto check(U* p) -> decltype((void)p->find('a'), p->length(), (void)p->data(), int()); template static void check(...); public: static constexpr const bool value = is_string::value || std::is_convertible>::value || !std::is_void(nullptr))>::value; }; template struct is_std_string_like> : std::true_type {}; template class is_map { template static auto check(U*) -> typename U::mapped_type; template static void check(...); public: #ifdef FMT_FORMAT_MAP_AS_LIST // DEPRECATED! static constexpr const bool value = false; #else static constexpr const bool value = !std::is_void(nullptr))>::value; #endif }; template class is_set { template static auto check(U*) -> typename U::key_type; template static void check(...); public: #ifdef FMT_FORMAT_SET_AS_LIST // DEPRECATED! static constexpr const bool value = false; #else static constexpr const bool value = !std::is_void(nullptr))>::value && !is_map::value; #endif }; template struct conditional_helper {}; template struct is_range_ : std::false_type {}; #if !FMT_MSC_VERSION || FMT_MSC_VERSION > 1800 # define FMT_DECLTYPE_RETURN(val) \ ->decltype(val) { return val; } \ static_assert( \ true, "") // This makes it so that a semicolon is required after the // macro, which helps clang-format handle the formatting. // C array overload template auto range_begin(const T (&arr)[N]) -> const T* { return arr; } template auto range_end(const T (&arr)[N]) -> const T* { return arr + N; } template struct has_member_fn_begin_end_t : std::false_type {}; template struct has_member_fn_begin_end_t().begin()), decltype(std::declval().end())>> : std::true_type {}; // Member function overload template auto range_begin(T&& rng) FMT_DECLTYPE_RETURN(static_cast(rng).begin()); template auto range_end(T&& rng) FMT_DECLTYPE_RETURN(static_cast(rng).end()); // ADL overload. Only participates in overload resolution if member functions // are not found. template auto range_begin(T&& rng) -> enable_if_t::value, decltype(begin(static_cast(rng)))> { return begin(static_cast(rng)); } template auto range_end(T&& rng) -> enable_if_t::value, decltype(end(static_cast(rng)))> { return end(static_cast(rng)); } template struct has_const_begin_end : std::false_type {}; template struct has_mutable_begin_end : std::false_type {}; template struct has_const_begin_end< T, void_t< decltype(detail::range_begin(std::declval&>())), decltype(detail::range_end(std::declval&>()))>> : std::true_type {}; template struct has_mutable_begin_end< T, void_t())), decltype(detail::range_end(std::declval())), // the extra int here is because older versions of MSVC don't // SFINAE properly unless there are distinct types int>> : std::true_type {}; template struct is_range_ : std::integral_constant::value || has_mutable_begin_end::value)> {}; # undef FMT_DECLTYPE_RETURN #endif // tuple_size and tuple_element check. template class is_tuple_like_ { template static auto check(U* p) -> decltype(std::tuple_size::value, int()); template static void check(...); public: static constexpr const bool value = !std::is_void(nullptr))>::value; }; // Check for integer_sequence #if defined(__cpp_lib_integer_sequence) || FMT_MSC_VERSION >= 1900 template using integer_sequence = std::integer_sequence; template using index_sequence = std::index_sequence; template using make_index_sequence = std::make_index_sequence; #else template struct integer_sequence { using value_type = T; static FMT_CONSTEXPR auto size() -> size_t { return sizeof...(N); } }; template using index_sequence = integer_sequence; template struct make_integer_sequence : make_integer_sequence {}; template struct make_integer_sequence : integer_sequence {}; template using make_index_sequence = make_integer_sequence; #endif template using tuple_index_sequence = make_index_sequence::value>; template ::value> class is_tuple_formattable_ { public: static constexpr const bool value = false; }; template class is_tuple_formattable_ { template static auto check2(index_sequence, integer_sequence) -> std::true_type; static auto check2(...) -> std::false_type; template static auto check(index_sequence) -> decltype(check2( index_sequence{}, integer_sequence::type, C>::value)...>{})); public: static constexpr const bool value = decltype(check(tuple_index_sequence{}))::value; }; template FMT_CONSTEXPR void for_each(index_sequence, Tuple&& t, F&& f) { using std::get; // Using a free function get(Tuple) now. const int unused[] = {0, ((void)f(get(t)), 0)...}; ignore_unused(unused); } template FMT_CONSTEXPR void for_each(Tuple&& t, F&& f) { for_each(tuple_index_sequence>(), std::forward(t), std::forward(f)); } template void for_each2(index_sequence, Tuple1&& t1, Tuple2&& t2, F&& f) { using std::get; const int unused[] = {0, ((void)f(get(t1), get(t2)), 0)...}; ignore_unused(unused); } template void for_each2(Tuple1&& t1, Tuple2&& t2, F&& f) { for_each2(tuple_index_sequence>(), std::forward(t1), std::forward(t2), std::forward(f)); } namespace tuple { // Workaround a bug in MSVC 2019 (v140). template using result_t = std::tuple, Char>...>; using std::get; template auto get_formatters(index_sequence) -> result_t(std::declval()))...>; } // namespace tuple #if FMT_MSC_VERSION && FMT_MSC_VERSION < 1920 // Older MSVC doesn't get the reference type correctly for arrays. template struct range_reference_type_impl { using type = decltype(*detail::range_begin(std::declval())); }; template struct range_reference_type_impl { using type = T&; }; template using range_reference_type = typename range_reference_type_impl::type; #else template using range_reference_type = decltype(*detail::range_begin(std::declval())); #endif // We don't use the Range's value_type for anything, but we do need the Range's // reference type, with cv-ref stripped. template using uncvref_type = remove_cvref_t>; template FMT_CONSTEXPR auto maybe_set_debug_format(Formatter& f, bool set) -> decltype(f.set_debug_format(set)) { f.set_debug_format(set); } template FMT_CONSTEXPR void maybe_set_debug_format(Formatter&, ...) {} // These are not generic lambdas for compatibility with C++11. template struct parse_empty_specs { template FMT_CONSTEXPR void operator()(Formatter& f) { f.parse(ctx); detail::maybe_set_debug_format(f, true); } ParseContext& ctx; }; template struct format_tuple_element { using char_type = typename FormatContext::char_type; template void operator()(const formatter& f, const T& v) { if (i > 0) ctx.advance_to(detail::copy_str(separator, ctx.out())); ctx.advance_to(f.format(v, ctx)); ++i; } int i; FormatContext& ctx; basic_string_view separator; }; } // namespace detail template struct is_tuple_like { static constexpr const bool value = detail::is_tuple_like_::value && !detail::is_range_::value; }; template struct is_tuple_formattable { static constexpr const bool value = detail::is_tuple_formattable_::value; }; template struct formatter::value && fmt::is_tuple_formattable::value>> { private: decltype(detail::tuple::get_formatters( detail::tuple_index_sequence())) formatters_; basic_string_view separator_ = detail::string_literal{}; basic_string_view opening_bracket_ = detail::string_literal{}; basic_string_view closing_bracket_ = detail::string_literal{}; public: FMT_CONSTEXPR formatter() {} FMT_CONSTEXPR void set_separator(basic_string_view sep) { separator_ = sep; } FMT_CONSTEXPR void set_brackets(basic_string_view open, basic_string_view close) { opening_bracket_ = open; closing_bracket_ = close; } template FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { auto it = ctx.begin(); if (it != ctx.end() && *it != '}') FMT_THROW(format_error("invalid format specifier")); detail::for_each(formatters_, detail::parse_empty_specs{ctx}); return it; } template auto format(const Tuple& value, FormatContext& ctx) const -> decltype(ctx.out()) { ctx.advance_to(detail::copy_str(opening_bracket_, ctx.out())); detail::for_each2( formatters_, value, detail::format_tuple_element{0, ctx, separator_}); return detail::copy_str(closing_bracket_, ctx.out()); } }; template struct is_range { static constexpr const bool value = detail::is_range_::value && !detail::is_std_string_like::value && !std::is_convertible>::value && !std::is_convertible>::value; }; namespace detail { template struct range_mapper { using mapper = arg_mapper; template , Context>::value)> static auto map(T&& value) -> T&& { return static_cast(value); } template , Context>::value)> static auto map(T&& value) -> decltype(mapper().map(static_cast(value))) { return mapper().map(static_cast(value)); } }; template using range_formatter_type = formatter>{}.map( std::declval()))>, Char>; template using maybe_const_range = conditional_t::value, const R, R>; // Workaround a bug in MSVC 2015 and earlier. #if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910 template struct is_formattable_delayed : is_formattable>, Char> {}; #endif } // namespace detail template struct conjunction : std::true_type {}; template struct conjunction

: P {}; template struct conjunction : conditional_t, P1> {}; template struct range_formatter; template struct range_formatter< T, Char, enable_if_t>, is_formattable>::value>> { private: detail::range_formatter_type underlying_; basic_string_view separator_ = detail::string_literal{}; basic_string_view opening_bracket_ = detail::string_literal{}; basic_string_view closing_bracket_ = detail::string_literal{}; public: FMT_CONSTEXPR range_formatter() {} FMT_CONSTEXPR auto underlying() -> detail::range_formatter_type& { return underlying_; } FMT_CONSTEXPR void set_separator(basic_string_view sep) { separator_ = sep; } FMT_CONSTEXPR void set_brackets(basic_string_view open, basic_string_view close) { opening_bracket_ = open; closing_bracket_ = close; } template FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { auto it = ctx.begin(); auto end = ctx.end(); if (it != end && *it == 'n') { set_brackets({}, {}); ++it; } if (it != end && *it != '}') { if (*it != ':') FMT_THROW(format_error("invalid format specifier")); ++it; } else { detail::maybe_set_debug_format(underlying_, true); } ctx.advance_to(it); return underlying_.parse(ctx); } template auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) { detail::range_mapper> mapper; auto out = ctx.out(); out = detail::copy_str(opening_bracket_, out); int i = 0; auto it = detail::range_begin(range); auto end = detail::range_end(range); for (; it != end; ++it) { if (i > 0) out = detail::copy_str(separator_, out); ctx.advance_to(out); auto&& item = *it; out = underlying_.format(mapper.map(item), ctx); ++i; } out = detail::copy_str(closing_bracket_, out); return out; } }; enum class range_format { disabled, map, set, sequence, string, debug_string }; namespace detail { template struct range_format_kind_ : std::integral_constant, T>::value ? range_format::disabled : is_map::value ? range_format::map : is_set::value ? range_format::set : range_format::sequence> {}; template struct range_default_formatter; template using range_format_constant = std::integral_constant; template struct range_default_formatter< K, R, Char, enable_if_t<(K == range_format::sequence || K == range_format::map || K == range_format::set)>> { using range_type = detail::maybe_const_range; range_formatter, Char> underlying_; FMT_CONSTEXPR range_default_formatter() { init(range_format_constant()); } FMT_CONSTEXPR void init(range_format_constant) { underlying_.set_brackets(detail::string_literal{}, detail::string_literal{}); } FMT_CONSTEXPR void init(range_format_constant) { underlying_.set_brackets(detail::string_literal{}, detail::string_literal{}); underlying_.underlying().set_brackets({}, {}); underlying_.underlying().set_separator( detail::string_literal{}); } FMT_CONSTEXPR void init(range_format_constant) {} template FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { return underlying_.parse(ctx); } template auto format(range_type& range, FormatContext& ctx) const -> decltype(ctx.out()) { return underlying_.format(range, ctx); } }; } // namespace detail template struct range_format_kind : conditional_t< is_range::value, detail::range_format_kind_, std::integral_constant> {}; template struct formatter< R, Char, enable_if_t::value != range_format::disabled> // Workaround a bug in MSVC 2015 and earlier. #if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910 , detail::is_formattable_delayed #endif >::value>> : detail::range_default_formatter::value, R, Char> { }; template struct tuple_join_view : detail::view { const std::tuple& tuple; basic_string_view sep; tuple_join_view(const std::tuple& t, basic_string_view s) : tuple(t), sep{s} {} }; // Define FMT_TUPLE_JOIN_SPECIFIERS to enable experimental format specifiers // support in tuple_join. It is disabled by default because of issues with // the dynamic width and precision. #ifndef FMT_TUPLE_JOIN_SPECIFIERS # define FMT_TUPLE_JOIN_SPECIFIERS 0 #endif template struct formatter, Char> { template FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { return do_parse(ctx, std::integral_constant()); } template auto format(const tuple_join_view& value, FormatContext& ctx) const -> typename FormatContext::iterator { return do_format(value, ctx, std::integral_constant()); } private: std::tuple::type, Char>...> formatters_; template FMT_CONSTEXPR auto do_parse(ParseContext& ctx, std::integral_constant) -> decltype(ctx.begin()) { return ctx.begin(); } template FMT_CONSTEXPR auto do_parse(ParseContext& ctx, std::integral_constant) -> decltype(ctx.begin()) { auto end = ctx.begin(); #if FMT_TUPLE_JOIN_SPECIFIERS end = std::get(formatters_).parse(ctx); if (N > 1) { auto end1 = do_parse(ctx, std::integral_constant()); if (end != end1) FMT_THROW(format_error("incompatible format specs for tuple elements")); } #endif return end; } template auto do_format(const tuple_join_view&, FormatContext& ctx, std::integral_constant) const -> typename FormatContext::iterator { return ctx.out(); } template auto do_format(const tuple_join_view& value, FormatContext& ctx, std::integral_constant) const -> typename FormatContext::iterator { auto out = std::get(formatters_) .format(std::get(value.tuple), ctx); if (N > 1) { out = std::copy(value.sep.begin(), value.sep.end(), out); ctx.advance_to(out); return do_format(value, ctx, std::integral_constant()); } return out; } }; namespace detail { // Check if T has an interface like a container adaptor (e.g. std::stack, // std::queue, std::priority_queue). template class is_container_adaptor_like { template static auto check(U* p) -> typename U::container_type; template static void check(...); public: static constexpr const bool value = !std::is_void(nullptr))>::value; }; template struct all { const Container& c; auto begin() const -> typename Container::const_iterator { return c.begin(); } auto end() const -> typename Container::const_iterator { return c.end(); } }; } // namespace detail template struct formatter< T, Char, enable_if_t, bool_constant::value == range_format::disabled>>::value>> : formatter, Char> { using all = detail::all; template auto format(const T& t, FormatContext& ctx) const -> decltype(ctx.out()) { struct getter : T { static auto get(const T& t) -> all { return {t.*(&getter::c)}; // Access c through the derived class. } }; return formatter::format(getter::get(t), ctx); } }; FMT_BEGIN_EXPORT /** \rst Returns an object that formats `tuple` with elements separated by `sep`. **Example**:: std::tuple t = {1, 'a'}; fmt::print("{}", fmt::join(t, ", ")); // Output: "1, a" \endrst */ template FMT_CONSTEXPR auto join(const std::tuple& tuple, string_view sep) -> tuple_join_view { return {tuple, sep}; } template FMT_CONSTEXPR auto join(const std::tuple& tuple, basic_string_view sep) -> tuple_join_view { return {tuple, sep}; } /** \rst Returns an object that formats `initializer_list` with elements separated by `sep`. **Example**:: fmt::print("{}", fmt::join({1, 2, 3}, ", ")); // Output: "1, 2, 3" \endrst */ template auto join(std::initializer_list list, string_view sep) -> join_view { return join(std::begin(list), std::end(list), sep); } FMT_END_EXPORT FMT_END_NAMESPACE #endif // FMT_RANGES_H_ RcppSpdlog/inst/include/spdlog/fmt/bundled/core.h0000644000176200001440000030313314612604314021527 0ustar liggesusers// Formatting library for C++ - the core API for char/UTF-8 // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_CORE_H_ #define FMT_CORE_H_ #include // std::byte #include // std::FILE #include // std::strlen #include #include #include // std::addressof #include #include // The fmt library version in the form major * 10000 + minor * 100 + patch. #define FMT_VERSION 100201 #if defined(__clang__) && !defined(__ibmxl__) # define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) #else # define FMT_CLANG_VERSION 0 #endif #if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && \ !defined(__NVCOMPILER) # define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) #else # define FMT_GCC_VERSION 0 #endif #ifndef FMT_GCC_PRAGMA // Workaround _Pragma bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59884. # if FMT_GCC_VERSION >= 504 # define FMT_GCC_PRAGMA(arg) _Pragma(arg) # else # define FMT_GCC_PRAGMA(arg) # endif #endif #ifdef __ICL # define FMT_ICC_VERSION __ICL #elif defined(__INTEL_COMPILER) # define FMT_ICC_VERSION __INTEL_COMPILER #else # define FMT_ICC_VERSION 0 #endif #ifdef _MSC_VER # define FMT_MSC_VERSION _MSC_VER # define FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__)) #else # define FMT_MSC_VERSION 0 # define FMT_MSC_WARNING(...) #endif #ifdef _MSVC_LANG # define FMT_CPLUSPLUS _MSVC_LANG #else # define FMT_CPLUSPLUS __cplusplus #endif #ifdef __has_feature # define FMT_HAS_FEATURE(x) __has_feature(x) #else # define FMT_HAS_FEATURE(x) 0 #endif #if defined(__has_include) || FMT_ICC_VERSION >= 1600 || FMT_MSC_VERSION > 1900 # define FMT_HAS_INCLUDE(x) __has_include(x) #else # define FMT_HAS_INCLUDE(x) 0 #endif #ifdef __has_cpp_attribute # define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) #else # define FMT_HAS_CPP_ATTRIBUTE(x) 0 #endif #define FMT_HAS_CPP14_ATTRIBUTE(attribute) \ (FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute)) #define FMT_HAS_CPP17_ATTRIBUTE(attribute) \ (FMT_CPLUSPLUS >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute)) // Check if relaxed C++14 constexpr is supported. // GCC doesn't allow throw in constexpr until version 6 (bug 67371). #ifndef FMT_USE_CONSTEXPR # if (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VERSION >= 1912 || \ (FMT_GCC_VERSION >= 600 && FMT_CPLUSPLUS >= 201402L)) && \ !FMT_ICC_VERSION && (!defined(__NVCC__) || FMT_CPLUSPLUS >= 202002L) # define FMT_USE_CONSTEXPR 1 # else # define FMT_USE_CONSTEXPR 0 # endif #endif #if FMT_USE_CONSTEXPR # define FMT_CONSTEXPR constexpr #else # define FMT_CONSTEXPR #endif #if (FMT_CPLUSPLUS >= 202002L || \ (FMT_CPLUSPLUS >= 201709L && FMT_GCC_VERSION >= 1002)) && \ ((!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE >= 10) && \ (!defined(_LIBCPP_VERSION) || _LIBCPP_VERSION >= 10000) && \ (!FMT_MSC_VERSION || FMT_MSC_VERSION >= 1928)) && \ defined(__cpp_lib_is_constant_evaluated) # define FMT_CONSTEXPR20 constexpr #else # define FMT_CONSTEXPR20 #endif // Check if constexpr std::char_traits<>::{compare,length} are supported. #if defined(__GLIBCXX__) # if FMT_CPLUSPLUS >= 201703L && defined(_GLIBCXX_RELEASE) && \ _GLIBCXX_RELEASE >= 7 // GCC 7+ libstdc++ has _GLIBCXX_RELEASE. # define FMT_CONSTEXPR_CHAR_TRAITS constexpr # endif #elif defined(_LIBCPP_VERSION) && FMT_CPLUSPLUS >= 201703L && \ _LIBCPP_VERSION >= 4000 # define FMT_CONSTEXPR_CHAR_TRAITS constexpr #elif FMT_MSC_VERSION >= 1914 && FMT_CPLUSPLUS >= 201703L # define FMT_CONSTEXPR_CHAR_TRAITS constexpr #endif #ifndef FMT_CONSTEXPR_CHAR_TRAITS # define FMT_CONSTEXPR_CHAR_TRAITS #endif // Check if exceptions are disabled. #ifndef FMT_EXCEPTIONS # if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \ (FMT_MSC_VERSION && !_HAS_EXCEPTIONS) # define FMT_EXCEPTIONS 0 # else # define FMT_EXCEPTIONS 1 # endif #endif // Disable [[noreturn]] on MSVC/NVCC because of bogus unreachable code warnings. #if FMT_EXCEPTIONS && FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VERSION && \ !defined(__NVCC__) # define FMT_NORETURN [[noreturn]] #else # define FMT_NORETURN #endif #ifndef FMT_NODISCARD # if FMT_HAS_CPP17_ATTRIBUTE(nodiscard) # define FMT_NODISCARD [[nodiscard]] # else # define FMT_NODISCARD # endif #endif #ifndef FMT_INLINE # if FMT_GCC_VERSION || FMT_CLANG_VERSION # define FMT_INLINE inline __attribute__((always_inline)) # else # define FMT_INLINE inline # endif #endif #ifdef _MSC_VER # define FMT_UNCHECKED_ITERATOR(It) \ using _Unchecked_type = It // Mark iterator as checked. #else # define FMT_UNCHECKED_ITERATOR(It) using unchecked_type = It #endif #ifndef FMT_BEGIN_NAMESPACE # define FMT_BEGIN_NAMESPACE \ namespace fmt { \ inline namespace v10 { # define FMT_END_NAMESPACE \ } \ } #endif #ifndef FMT_EXPORT # define FMT_EXPORT # define FMT_BEGIN_EXPORT # define FMT_END_EXPORT #endif #if FMT_GCC_VERSION || FMT_CLANG_VERSION # define FMT_VISIBILITY(value) __attribute__((visibility(value))) #else # define FMT_VISIBILITY(value) #endif #if !defined(FMT_HEADER_ONLY) && defined(_WIN32) # if defined(FMT_LIB_EXPORT) # define FMT_API __declspec(dllexport) # elif defined(FMT_SHARED) # define FMT_API __declspec(dllimport) # endif #elif defined(FMT_LIB_EXPORT) || defined(FMT_SHARED) # define FMT_API FMT_VISIBILITY("default") #endif #ifndef FMT_API # define FMT_API #endif // libc++ supports string_view in pre-c++17. #if FMT_HAS_INCLUDE() && \ (FMT_CPLUSPLUS >= 201703L || defined(_LIBCPP_VERSION)) # include # define FMT_USE_STRING_VIEW #elif FMT_HAS_INCLUDE("experimental/string_view") && FMT_CPLUSPLUS >= 201402L # include # define FMT_USE_EXPERIMENTAL_STRING_VIEW #endif #ifndef FMT_UNICODE # define FMT_UNICODE !FMT_MSC_VERSION #endif #ifndef FMT_CONSTEVAL # if ((FMT_GCC_VERSION >= 1000 || FMT_CLANG_VERSION >= 1101) && \ (!defined(__apple_build_version__) || \ __apple_build_version__ >= 14000029L) && \ FMT_CPLUSPLUS >= 202002L) || \ (defined(__cpp_consteval) && \ (!FMT_MSC_VERSION || FMT_MSC_VERSION >= 1929)) // consteval is broken in MSVC before VS2019 version 16.10 and Apple clang // before 14. # define FMT_CONSTEVAL consteval # define FMT_HAS_CONSTEVAL # else # define FMT_CONSTEVAL # endif #endif #ifndef FMT_USE_NONTYPE_TEMPLATE_ARGS # if defined(__cpp_nontype_template_args) && \ ((FMT_GCC_VERSION >= 903 && FMT_CPLUSPLUS >= 201709L) || \ __cpp_nontype_template_args >= 201911L) && \ !defined(__NVCOMPILER) && !defined(__LCC__) # define FMT_USE_NONTYPE_TEMPLATE_ARGS 1 # else # define FMT_USE_NONTYPE_TEMPLATE_ARGS 0 # endif #endif // GCC < 5 requires this-> in decltype #ifndef FMT_DECLTYPE_THIS # if FMT_GCC_VERSION && FMT_GCC_VERSION < 500 # define FMT_DECLTYPE_THIS this-> # else # define FMT_DECLTYPE_THIS # endif #endif // Enable minimal optimizations for more compact code in debug mode. FMT_GCC_PRAGMA("GCC push_options") #if !defined(__OPTIMIZE__) && !defined(__NVCOMPILER) && !defined(__LCC__) && \ !defined(__CUDACC__) FMT_GCC_PRAGMA("GCC optimize(\"Og\")") #endif FMT_BEGIN_NAMESPACE // Implementations of enable_if_t and other metafunctions for older systems. template using enable_if_t = typename std::enable_if::type; template using conditional_t = typename std::conditional::type; template using bool_constant = std::integral_constant; template using remove_reference_t = typename std::remove_reference::type; template using remove_const_t = typename std::remove_const::type; template using remove_cvref_t = typename std::remove_cv>::type; template struct type_identity { using type = T; }; template using type_identity_t = typename type_identity::type; template using underlying_t = typename std::underlying_type::type; // Checks whether T is a container with contiguous storage. template struct is_contiguous : std::false_type {}; template struct is_contiguous> : std::true_type {}; struct monostate { constexpr monostate() {} }; // An enable_if helper to be used in template parameters which results in much // shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed // to workaround a bug in MSVC 2019 (see #1140 and #1186). #ifdef FMT_DOC # define FMT_ENABLE_IF(...) #else # define FMT_ENABLE_IF(...) fmt::enable_if_t<(__VA_ARGS__), int> = 0 #endif // This is defined in core.h instead of format.h to avoid injecting in std. // It is a template to avoid undesirable implicit conversions to std::byte. #ifdef __cpp_lib_byte template ::value)> inline auto format_as(T b) -> unsigned char { return static_cast(b); } #endif namespace detail { // Suppresses "unused variable" warnings with the method described in // https://herbsutter.com/2009/10/18/mailbag-shutting-up-compiler-warnings/. // (void)var does not work on many Intel compilers. template FMT_CONSTEXPR void ignore_unused(const T&...) {} constexpr FMT_INLINE auto is_constant_evaluated( bool default_value = false) noexcept -> bool { // Workaround for incompatibility between libstdc++ consteval-based // std::is_constant_evaluated() implementation and clang-14. // https://github.com/fmtlib/fmt/issues/3247 #if FMT_CPLUSPLUS >= 202002L && defined(_GLIBCXX_RELEASE) && \ _GLIBCXX_RELEASE >= 12 && \ (FMT_CLANG_VERSION >= 1400 && FMT_CLANG_VERSION < 1500) ignore_unused(default_value); return __builtin_is_constant_evaluated(); #elif defined(__cpp_lib_is_constant_evaluated) ignore_unused(default_value); return std::is_constant_evaluated(); #else return default_value; #endif } // Suppresses "conditional expression is constant" warnings. template constexpr FMT_INLINE auto const_check(T value) -> T { return value; } FMT_NORETURN FMT_API void assert_fail(const char* file, int line, const char* message); #ifndef FMT_ASSERT # ifdef NDEBUG // FMT_ASSERT is not empty to avoid -Wempty-body. # define FMT_ASSERT(condition, message) \ fmt::detail::ignore_unused((condition), (message)) # else # define FMT_ASSERT(condition, message) \ ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \ ? (void)0 \ : fmt::detail::assert_fail(__FILE__, __LINE__, (message))) # endif #endif #if defined(FMT_USE_STRING_VIEW) template using std_string_view = std::basic_string_view; #elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW) template using std_string_view = std::experimental::basic_string_view; #else template struct std_string_view {}; #endif #ifdef FMT_USE_INT128 // Do nothing. #elif defined(__SIZEOF_INT128__) && !defined(__NVCC__) && \ !(FMT_CLANG_VERSION && FMT_MSC_VERSION) # define FMT_USE_INT128 1 using int128_opt = __int128_t; // An optional native 128-bit integer. using uint128_opt = __uint128_t; template inline auto convert_for_visit(T value) -> T { return value; } #else # define FMT_USE_INT128 0 #endif #if !FMT_USE_INT128 enum class int128_opt {}; enum class uint128_opt {}; // Reduce template instantiations. template auto convert_for_visit(T) -> monostate { return {}; } #endif // Casts a nonnegative integer to unsigned. template FMT_CONSTEXPR auto to_unsigned(Int value) -> typename std::make_unsigned::type { FMT_ASSERT(std::is_unsigned::value || value >= 0, "negative value"); return static_cast::type>(value); } FMT_CONSTEXPR inline auto is_utf8() -> bool { FMT_MSC_WARNING(suppress : 4566) constexpr unsigned char section[] = "\u00A7"; // Avoid buggy sign extensions in MSVC's constant evaluation mode (#2297). using uchar = unsigned char; return FMT_UNICODE || (sizeof(section) == 3 && uchar(section[0]) == 0xC2 && uchar(section[1]) == 0xA7); } } // namespace detail /** An implementation of ``std::basic_string_view`` for pre-C++17. It provides a subset of the API. ``fmt::basic_string_view`` is used for format strings even if ``std::string_view`` is available to prevent issues when a library is compiled with a different ``-std`` option than the client code (which is not recommended). */ FMT_EXPORT template class basic_string_view { private: const Char* data_; size_t size_; public: using value_type = Char; using iterator = const Char*; constexpr basic_string_view() noexcept : data_(nullptr), size_(0) {} /** Constructs a string reference object from a C string and a size. */ constexpr basic_string_view(const Char* s, size_t count) noexcept : data_(s), size_(count) {} /** \rst Constructs a string reference object from a C string computing the size with ``std::char_traits::length``. \endrst */ FMT_CONSTEXPR_CHAR_TRAITS FMT_INLINE basic_string_view(const Char* s) : data_(s), size_(detail::const_check(std::is_same::value && !detail::is_constant_evaluated(true)) ? std::strlen(reinterpret_cast(s)) : std::char_traits::length(s)) {} /** Constructs a string reference from a ``std::basic_string`` object. */ template FMT_CONSTEXPR basic_string_view( const std::basic_string& s) noexcept : data_(s.data()), size_(s.size()) {} template >::value)> FMT_CONSTEXPR basic_string_view(S s) noexcept : data_(s.data()), size_(s.size()) {} /** Returns a pointer to the string data. */ constexpr auto data() const noexcept -> const Char* { return data_; } /** Returns the string size. */ constexpr auto size() const noexcept -> size_t { return size_; } constexpr auto begin() const noexcept -> iterator { return data_; } constexpr auto end() const noexcept -> iterator { return data_ + size_; } constexpr auto operator[](size_t pos) const noexcept -> const Char& { return data_[pos]; } FMT_CONSTEXPR void remove_prefix(size_t n) noexcept { data_ += n; size_ -= n; } FMT_CONSTEXPR_CHAR_TRAITS auto starts_with( basic_string_view sv) const noexcept -> bool { return size_ >= sv.size_ && std::char_traits::compare(data_, sv.data_, sv.size_) == 0; } FMT_CONSTEXPR_CHAR_TRAITS auto starts_with(Char c) const noexcept -> bool { return size_ >= 1 && std::char_traits::eq(*data_, c); } FMT_CONSTEXPR_CHAR_TRAITS auto starts_with(const Char* s) const -> bool { return starts_with(basic_string_view(s)); } // Lexicographically compare this string reference to other. FMT_CONSTEXPR_CHAR_TRAITS auto compare(basic_string_view other) const -> int { size_t str_size = size_ < other.size_ ? size_ : other.size_; int result = std::char_traits::compare(data_, other.data_, str_size); if (result == 0) result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1); return result; } FMT_CONSTEXPR_CHAR_TRAITS friend auto operator==(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) == 0; } friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) != 0; } friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) < 0; } friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) <= 0; } friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) > 0; } friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) >= 0; } }; FMT_EXPORT using string_view = basic_string_view; /** Specifies if ``T`` is a character type. Can be specialized by users. */ FMT_EXPORT template struct is_char : std::false_type {}; template <> struct is_char : std::true_type {}; namespace detail { // A base class for compile-time strings. struct compile_string {}; template struct is_compile_string : std::is_base_of {}; template ::value)> FMT_INLINE auto to_string_view(const Char* s) -> basic_string_view { return s; } template inline auto to_string_view(const std::basic_string& s) -> basic_string_view { return s; } template constexpr auto to_string_view(basic_string_view s) -> basic_string_view { return s; } template >::value)> inline auto to_string_view(std_string_view s) -> basic_string_view { return s; } template ::value)> constexpr auto to_string_view(const S& s) -> basic_string_view { return basic_string_view(s); } void to_string_view(...); // Specifies whether S is a string type convertible to fmt::basic_string_view. // It should be a constexpr function but MSVC 2017 fails to compile it in // enable_if and MSVC 2015 fails to compile it as an alias template. // ADL is intentionally disabled as to_string_view is not an extension point. template struct is_string : std::is_class()))> {}; template struct char_t_impl {}; template struct char_t_impl::value>> { using result = decltype(to_string_view(std::declval())); using type = typename result::value_type; }; enum class type { none_type, // Integer types should go first, int_type, uint_type, long_long_type, ulong_long_type, int128_type, uint128_type, bool_type, char_type, last_integer_type = char_type, // followed by floating-point types. float_type, double_type, long_double_type, last_numeric_type = long_double_type, cstring_type, string_type, pointer_type, custom_type }; // Maps core type T to the corresponding type enum constant. template struct type_constant : std::integral_constant {}; #define FMT_TYPE_CONSTANT(Type, constant) \ template \ struct type_constant \ : std::integral_constant {} FMT_TYPE_CONSTANT(int, int_type); FMT_TYPE_CONSTANT(unsigned, uint_type); FMT_TYPE_CONSTANT(long long, long_long_type); FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type); FMT_TYPE_CONSTANT(int128_opt, int128_type); FMT_TYPE_CONSTANT(uint128_opt, uint128_type); FMT_TYPE_CONSTANT(bool, bool_type); FMT_TYPE_CONSTANT(Char, char_type); FMT_TYPE_CONSTANT(float, float_type); FMT_TYPE_CONSTANT(double, double_type); FMT_TYPE_CONSTANT(long double, long_double_type); FMT_TYPE_CONSTANT(const Char*, cstring_type); FMT_TYPE_CONSTANT(basic_string_view, string_type); FMT_TYPE_CONSTANT(const void*, pointer_type); constexpr auto is_integral_type(type t) -> bool { return t > type::none_type && t <= type::last_integer_type; } constexpr auto is_arithmetic_type(type t) -> bool { return t > type::none_type && t <= type::last_numeric_type; } constexpr auto set(type rhs) -> int { return 1 << static_cast(rhs); } constexpr auto in(type t, int set) -> bool { return ((set >> static_cast(t)) & 1) != 0; } // Bitsets of types. enum { sint_set = set(type::int_type) | set(type::long_long_type) | set(type::int128_type), uint_set = set(type::uint_type) | set(type::ulong_long_type) | set(type::uint128_type), bool_set = set(type::bool_type), char_set = set(type::char_type), float_set = set(type::float_type) | set(type::double_type) | set(type::long_double_type), string_set = set(type::string_type), cstring_set = set(type::cstring_type), pointer_set = set(type::pointer_type) }; // DEPRECATED! FMT_NORETURN FMT_API void throw_format_error(const char* message); struct error_handler { constexpr error_handler() = default; // This function is intentionally not constexpr to give a compile-time error. FMT_NORETURN void on_error(const char* message) { throw_format_error(message); } }; } // namespace detail /** Throws ``format_error`` with a given message. */ using detail::throw_format_error; /** String's character type. */ template using char_t = typename detail::char_t_impl::type; /** \rst Parsing context consisting of a format string range being parsed and an argument counter for automatic indexing. You can use the ``format_parse_context`` type alias for ``char`` instead. \endrst */ FMT_EXPORT template class basic_format_parse_context { private: basic_string_view format_str_; int next_arg_id_; FMT_CONSTEXPR void do_check_arg_id(int id); public: using char_type = Char; using iterator = const Char*; explicit constexpr basic_format_parse_context( basic_string_view format_str, int next_arg_id = 0) : format_str_(format_str), next_arg_id_(next_arg_id) {} /** Returns an iterator to the beginning of the format string range being parsed. */ constexpr auto begin() const noexcept -> iterator { return format_str_.begin(); } /** Returns an iterator past the end of the format string range being parsed. */ constexpr auto end() const noexcept -> iterator { return format_str_.end(); } /** Advances the begin iterator to ``it``. */ FMT_CONSTEXPR void advance_to(iterator it) { format_str_.remove_prefix(detail::to_unsigned(it - begin())); } /** Reports an error if using the manual argument indexing; otherwise returns the next argument index and switches to the automatic indexing. */ FMT_CONSTEXPR auto next_arg_id() -> int { if (next_arg_id_ < 0) { detail::throw_format_error( "cannot switch from manual to automatic argument indexing"); return 0; } int id = next_arg_id_++; do_check_arg_id(id); return id; } /** Reports an error if using the automatic argument indexing; otherwise switches to the manual indexing. */ FMT_CONSTEXPR void check_arg_id(int id) { if (next_arg_id_ > 0) { detail::throw_format_error( "cannot switch from automatic to manual argument indexing"); return; } next_arg_id_ = -1; do_check_arg_id(id); } FMT_CONSTEXPR void check_arg_id(basic_string_view) {} FMT_CONSTEXPR void check_dynamic_spec(int arg_id); }; FMT_EXPORT using format_parse_context = basic_format_parse_context; namespace detail { // A parse context with extra data used only in compile-time checks. template class compile_parse_context : public basic_format_parse_context { private: int num_args_; const type* types_; using base = basic_format_parse_context; public: explicit FMT_CONSTEXPR compile_parse_context( basic_string_view format_str, int num_args, const type* types, int next_arg_id = 0) : base(format_str, next_arg_id), num_args_(num_args), types_(types) {} constexpr auto num_args() const -> int { return num_args_; } constexpr auto arg_type(int id) const -> type { return types_[id]; } FMT_CONSTEXPR auto next_arg_id() -> int { int id = base::next_arg_id(); if (id >= num_args_) throw_format_error("argument not found"); return id; } FMT_CONSTEXPR void check_arg_id(int id) { base::check_arg_id(id); if (id >= num_args_) throw_format_error("argument not found"); } using base::check_arg_id; FMT_CONSTEXPR void check_dynamic_spec(int arg_id) { detail::ignore_unused(arg_id); #if !defined(__LCC__) if (arg_id < num_args_ && types_ && !is_integral_type(types_[arg_id])) throw_format_error("width/precision is not integer"); #endif } }; // Extracts a reference to the container from back_insert_iterator. template inline auto get_container(std::back_insert_iterator it) -> Container& { using base = std::back_insert_iterator; struct accessor : base { accessor(base b) : base(b) {} using base::container; }; return *accessor(it).container; } template FMT_CONSTEXPR auto copy_str(InputIt begin, InputIt end, OutputIt out) -> OutputIt { while (begin != end) *out++ = static_cast(*begin++); return out; } template , U>::value&& is_char::value)> FMT_CONSTEXPR auto copy_str(T* begin, T* end, U* out) -> U* { if (is_constant_evaluated()) return copy_str(begin, end, out); auto size = to_unsigned(end - begin); if (size > 0) memcpy(out, begin, size * sizeof(U)); return out + size; } /** \rst A contiguous memory buffer with an optional growing ability. It is an internal class and shouldn't be used directly, only via `~fmt::basic_memory_buffer`. \endrst */ template class buffer { private: T* ptr_; size_t size_; size_t capacity_; protected: // Don't initialize ptr_ since it is not accessed to save a few cycles. FMT_MSC_WARNING(suppress : 26495) FMT_CONSTEXPR buffer(size_t sz) noexcept : size_(sz), capacity_(sz) {} FMT_CONSTEXPR20 buffer(T* p = nullptr, size_t sz = 0, size_t cap = 0) noexcept : ptr_(p), size_(sz), capacity_(cap) {} FMT_CONSTEXPR20 ~buffer() = default; buffer(buffer&&) = default; /** Sets the buffer data and capacity. */ FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept { ptr_ = buf_data; capacity_ = buf_capacity; } /** Increases the buffer capacity to hold at least *capacity* elements. */ // DEPRECATED! virtual FMT_CONSTEXPR20 void grow(size_t capacity) = 0; public: using value_type = T; using const_reference = const T&; buffer(const buffer&) = delete; void operator=(const buffer&) = delete; FMT_INLINE auto begin() noexcept -> T* { return ptr_; } FMT_INLINE auto end() noexcept -> T* { return ptr_ + size_; } FMT_INLINE auto begin() const noexcept -> const T* { return ptr_; } FMT_INLINE auto end() const noexcept -> const T* { return ptr_ + size_; } /** Returns the size of this buffer. */ constexpr auto size() const noexcept -> size_t { return size_; } /** Returns the capacity of this buffer. */ constexpr auto capacity() const noexcept -> size_t { return capacity_; } /** Returns a pointer to the buffer data (not null-terminated). */ FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; } FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; } /** Clears this buffer. */ void clear() { size_ = 0; } // Tries resizing the buffer to contain *count* elements. If T is a POD type // the new elements may not be initialized. FMT_CONSTEXPR20 void try_resize(size_t count) { try_reserve(count); size_ = count <= capacity_ ? count : capacity_; } // Tries increasing the buffer capacity to *new_capacity*. It can increase the // capacity by a smaller amount than requested but guarantees there is space // for at least one additional element either by increasing the capacity or by // flushing the buffer if it is full. FMT_CONSTEXPR20 void try_reserve(size_t new_capacity) { if (new_capacity > capacity_) grow(new_capacity); } FMT_CONSTEXPR20 void push_back(const T& value) { try_reserve(size_ + 1); ptr_[size_++] = value; } /** Appends data to the end of the buffer. */ template void append(const U* begin, const U* end); template FMT_CONSTEXPR auto operator[](Idx index) -> T& { return ptr_[index]; } template FMT_CONSTEXPR auto operator[](Idx index) const -> const T& { return ptr_[index]; } }; struct buffer_traits { explicit buffer_traits(size_t) {} auto count() const -> size_t { return 0; } auto limit(size_t size) -> size_t { return size; } }; class fixed_buffer_traits { private: size_t count_ = 0; size_t limit_; public: explicit fixed_buffer_traits(size_t limit) : limit_(limit) {} auto count() const -> size_t { return count_; } auto limit(size_t size) -> size_t { size_t n = limit_ > count_ ? limit_ - count_ : 0; count_ += size; return size < n ? size : n; } }; // A buffer that writes to an output iterator when flushed. template class iterator_buffer final : public Traits, public buffer { private: OutputIt out_; enum { buffer_size = 256 }; T data_[buffer_size]; protected: FMT_CONSTEXPR20 void grow(size_t) override { if (this->size() == buffer_size) flush(); } void flush() { auto size = this->size(); this->clear(); out_ = copy_str(data_, data_ + this->limit(size), out_); } public: explicit iterator_buffer(OutputIt out, size_t n = buffer_size) : Traits(n), buffer(data_, 0, buffer_size), out_(out) {} iterator_buffer(iterator_buffer&& other) : Traits(other), buffer(data_, 0, buffer_size), out_(other.out_) {} ~iterator_buffer() { flush(); } auto out() -> OutputIt { flush(); return out_; } auto count() const -> size_t { return Traits::count() + this->size(); } }; template class iterator_buffer final : public fixed_buffer_traits, public buffer { private: T* out_; enum { buffer_size = 256 }; T data_[buffer_size]; protected: FMT_CONSTEXPR20 void grow(size_t) override { if (this->size() == this->capacity()) flush(); } void flush() { size_t n = this->limit(this->size()); if (this->data() == out_) { out_ += n; this->set(data_, buffer_size); } this->clear(); } public: explicit iterator_buffer(T* out, size_t n = buffer_size) : fixed_buffer_traits(n), buffer(out, 0, n), out_(out) {} iterator_buffer(iterator_buffer&& other) : fixed_buffer_traits(other), buffer(std::move(other)), out_(other.out_) { if (this->data() != out_) { this->set(data_, buffer_size); this->clear(); } } ~iterator_buffer() { flush(); } auto out() -> T* { flush(); return out_; } auto count() const -> size_t { return fixed_buffer_traits::count() + this->size(); } }; template class iterator_buffer final : public buffer { protected: FMT_CONSTEXPR20 void grow(size_t) override {} public: explicit iterator_buffer(T* out, size_t = 0) : buffer(out, 0, ~size_t()) {} auto out() -> T* { return &*this->end(); } }; // A buffer that writes to a container with the contiguous storage. template class iterator_buffer, enable_if_t::value, typename Container::value_type>> final : public buffer { private: Container& container_; protected: FMT_CONSTEXPR20 void grow(size_t capacity) override { container_.resize(capacity); this->set(&container_[0], capacity); } public: explicit iterator_buffer(Container& c) : buffer(c.size()), container_(c) {} explicit iterator_buffer(std::back_insert_iterator out, size_t = 0) : iterator_buffer(get_container(out)) {} auto out() -> std::back_insert_iterator { return std::back_inserter(container_); } }; // A buffer that counts the number of code units written discarding the output. template class counting_buffer final : public buffer { private: enum { buffer_size = 256 }; T data_[buffer_size]; size_t count_ = 0; protected: FMT_CONSTEXPR20 void grow(size_t) override { if (this->size() != buffer_size) return; count_ += this->size(); this->clear(); } public: counting_buffer() : buffer(data_, 0, buffer_size) {} auto count() -> size_t { return count_ + this->size(); } }; } // namespace detail template FMT_CONSTEXPR void basic_format_parse_context::do_check_arg_id(int id) { // Argument id is only checked at compile-time during parsing because // formatting has its own validation. if (detail::is_constant_evaluated() && (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) { using context = detail::compile_parse_context; if (id >= static_cast(this)->num_args()) detail::throw_format_error("argument not found"); } } template FMT_CONSTEXPR void basic_format_parse_context::check_dynamic_spec( int arg_id) { if (detail::is_constant_evaluated() && (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) { using context = detail::compile_parse_context; static_cast(this)->check_dynamic_spec(arg_id); } } FMT_EXPORT template class basic_format_arg; FMT_EXPORT template class basic_format_args; FMT_EXPORT template class dynamic_format_arg_store; // A formatter for objects of type T. FMT_EXPORT template struct formatter { // A deleted default constructor indicates a disabled formatter. formatter() = delete; }; // Specifies if T has an enabled formatter specialization. A type can be // formattable even if it doesn't have a formatter e.g. via a conversion. template using has_formatter = std::is_constructible>; // An output iterator that appends to a buffer. // It is used to reduce symbol sizes for the common case. class appender : public std::back_insert_iterator> { using base = std::back_insert_iterator>; public: using std::back_insert_iterator>::back_insert_iterator; appender(base it) noexcept : base(it) {} FMT_UNCHECKED_ITERATOR(appender); auto operator++() noexcept -> appender& { return *this; } auto operator++(int) noexcept -> appender { return *this; } }; namespace detail { template constexpr auto has_const_formatter_impl(T*) -> decltype(typename Context::template formatter_type().format( std::declval(), std::declval()), true) { return true; } template constexpr auto has_const_formatter_impl(...) -> bool { return false; } template constexpr auto has_const_formatter() -> bool { return has_const_formatter_impl(static_cast(nullptr)); } template using buffer_appender = conditional_t::value, appender, std::back_insert_iterator>>; // Maps an output iterator to a buffer. template auto get_buffer(OutputIt out) -> iterator_buffer { return iterator_buffer(out); } template , Buf>::value)> auto get_buffer(std::back_insert_iterator out) -> buffer& { return get_container(out); } template FMT_INLINE auto get_iterator(Buf& buf, OutputIt) -> decltype(buf.out()) { return buf.out(); } template auto get_iterator(buffer&, OutputIt out) -> OutputIt { return out; } struct view {}; template struct named_arg : view { const Char* name; const T& value; named_arg(const Char* n, const T& v) : name(n), value(v) {} }; template struct named_arg_info { const Char* name; int id; }; template struct arg_data { // args_[0].named_args points to named_args_ to avoid bloating format_args. // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning. T args_[1 + (NUM_ARGS != 0 ? NUM_ARGS : +1)]; named_arg_info named_args_[NUM_NAMED_ARGS]; template arg_data(const U&... init) : args_{T(named_args_, NUM_NAMED_ARGS), init...} {} arg_data(const arg_data& other) = delete; auto args() const -> const T* { return args_ + 1; } auto named_args() -> named_arg_info* { return named_args_; } }; template struct arg_data { // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning. T args_[NUM_ARGS != 0 ? NUM_ARGS : +1]; template FMT_CONSTEXPR FMT_INLINE arg_data(const U&... init) : args_{init...} {} FMT_CONSTEXPR FMT_INLINE auto args() const -> const T* { return args_; } FMT_CONSTEXPR FMT_INLINE auto named_args() -> std::nullptr_t { return nullptr; } }; template inline void init_named_args(named_arg_info*, int, int) {} template struct is_named_arg : std::false_type {}; template struct is_statically_named_arg : std::false_type {}; template struct is_named_arg> : std::true_type {}; template ::value)> void init_named_args(named_arg_info* named_args, int arg_count, int named_arg_count, const T&, const Tail&... args) { init_named_args(named_args, arg_count + 1, named_arg_count, args...); } template ::value)> void init_named_args(named_arg_info* named_args, int arg_count, int named_arg_count, const T& arg, const Tail&... args) { named_args[named_arg_count++] = {arg.name, arg_count}; init_named_args(named_args, arg_count + 1, named_arg_count, args...); } template FMT_CONSTEXPR FMT_INLINE void init_named_args(std::nullptr_t, int, int, const Args&...) {} template constexpr auto count() -> size_t { return B ? 1 : 0; } template constexpr auto count() -> size_t { return (B1 ? 1 : 0) + count(); } template constexpr auto count_named_args() -> size_t { return count::value...>(); } template constexpr auto count_statically_named_args() -> size_t { return count::value...>(); } struct unformattable {}; struct unformattable_char : unformattable {}; struct unformattable_pointer : unformattable {}; template struct string_value { const Char* data; size_t size; }; template struct named_arg_value { const named_arg_info* data; size_t size; }; template struct custom_value { using parse_context = typename Context::parse_context_type; void* value; void (*format)(void* arg, parse_context& parse_ctx, Context& ctx); }; // A formatting argument value. template class value { public: using char_type = typename Context::char_type; union { monostate no_value; int int_value; unsigned uint_value; long long long_long_value; unsigned long long ulong_long_value; int128_opt int128_value; uint128_opt uint128_value; bool bool_value; char_type char_value; float float_value; double double_value; long double long_double_value; const void* pointer; string_value string; custom_value custom; named_arg_value named_args; }; constexpr FMT_INLINE value() : no_value() {} constexpr FMT_INLINE value(int val) : int_value(val) {} constexpr FMT_INLINE value(unsigned val) : uint_value(val) {} constexpr FMT_INLINE value(long long val) : long_long_value(val) {} constexpr FMT_INLINE value(unsigned long long val) : ulong_long_value(val) {} FMT_INLINE value(int128_opt val) : int128_value(val) {} FMT_INLINE value(uint128_opt val) : uint128_value(val) {} constexpr FMT_INLINE value(float val) : float_value(val) {} constexpr FMT_INLINE value(double val) : double_value(val) {} FMT_INLINE value(long double val) : long_double_value(val) {} constexpr FMT_INLINE value(bool val) : bool_value(val) {} constexpr FMT_INLINE value(char_type val) : char_value(val) {} FMT_CONSTEXPR FMT_INLINE value(const char_type* val) { string.data = val; if (is_constant_evaluated()) string.size = {}; } FMT_CONSTEXPR FMT_INLINE value(basic_string_view val) { string.data = val.data(); string.size = val.size(); } FMT_INLINE value(const void* val) : pointer(val) {} FMT_INLINE value(const named_arg_info* args, size_t size) : named_args{args, size} {} template FMT_CONSTEXPR20 FMT_INLINE value(T& val) { using value_type = remove_const_t; custom.value = const_cast(std::addressof(val)); // Get the formatter type through the context to allow different contexts // have different extension points, e.g. `formatter` for `format` and // `printf_formatter` for `printf`. custom.format = format_custom_arg< value_type, typename Context::template formatter_type>; } value(unformattable); value(unformattable_char); value(unformattable_pointer); private: // Formats an argument of a custom type, such as a user-defined class. template static void format_custom_arg(void* arg, typename Context::parse_context_type& parse_ctx, Context& ctx) { auto f = Formatter(); parse_ctx.advance_to(f.parse(parse_ctx)); using qualified_type = conditional_t(), const T, T>; // Calling format through a mutable reference is deprecated. ctx.advance_to(f.format(*static_cast(arg), ctx)); } }; // 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. enum { long_short = sizeof(long) == sizeof(int) }; using long_type = conditional_t; using ulong_type = conditional_t; template struct format_as_result { template ::value || std::is_class::value)> static auto map(U*) -> remove_cvref_t()))>; static auto map(...) -> void; using type = decltype(map(static_cast(nullptr))); }; template using format_as_t = typename format_as_result::type; template struct has_format_as : bool_constant, void>::value> {}; // Maps formatting arguments to core types. // arg_mapper reports errors by returning unformattable instead of using // static_assert because it's used in the is_formattable trait. template struct arg_mapper { using char_type = typename Context::char_type; FMT_CONSTEXPR FMT_INLINE auto map(signed char val) -> int { return val; } FMT_CONSTEXPR FMT_INLINE auto map(unsigned char val) -> unsigned { return val; } FMT_CONSTEXPR FMT_INLINE auto map(short val) -> int { return val; } FMT_CONSTEXPR FMT_INLINE auto map(unsigned short val) -> unsigned { return val; } FMT_CONSTEXPR FMT_INLINE auto map(int val) -> int { return val; } FMT_CONSTEXPR FMT_INLINE auto map(unsigned val) -> unsigned { return val; } FMT_CONSTEXPR FMT_INLINE auto map(long val) -> long_type { return val; } FMT_CONSTEXPR FMT_INLINE auto map(unsigned long val) -> ulong_type { return val; } FMT_CONSTEXPR FMT_INLINE auto map(long long val) -> long long { return val; } FMT_CONSTEXPR FMT_INLINE auto map(unsigned long long val) -> unsigned long long { return val; } FMT_CONSTEXPR FMT_INLINE auto map(int128_opt val) -> int128_opt { return val; } FMT_CONSTEXPR FMT_INLINE auto map(uint128_opt val) -> uint128_opt { return val; } FMT_CONSTEXPR FMT_INLINE auto map(bool val) -> bool { return val; } template ::value || std::is_same::value)> FMT_CONSTEXPR FMT_INLINE auto map(T val) -> char_type { return val; } template ::value || #ifdef __cpp_char8_t std::is_same::value || #endif std::is_same::value || std::is_same::value) && !std::is_same::value, int> = 0> FMT_CONSTEXPR FMT_INLINE auto map(T) -> unformattable_char { return {}; } FMT_CONSTEXPR FMT_INLINE auto map(float val) -> float { return val; } FMT_CONSTEXPR FMT_INLINE auto map(double val) -> double { return val; } FMT_CONSTEXPR FMT_INLINE auto map(long double val) -> long double { return val; } FMT_CONSTEXPR FMT_INLINE auto map(char_type* val) -> const char_type* { return val; } FMT_CONSTEXPR FMT_INLINE auto map(const char_type* val) -> const char_type* { return val; } template ::value && !std::is_pointer::value && std::is_same>::value)> FMT_CONSTEXPR FMT_INLINE auto map(const T& val) -> basic_string_view { return to_string_view(val); } template ::value && !std::is_pointer::value && !std::is_same>::value)> FMT_CONSTEXPR FMT_INLINE auto map(const T&) -> unformattable_char { return {}; } FMT_CONSTEXPR FMT_INLINE auto map(void* val) -> const void* { return val; } FMT_CONSTEXPR FMT_INLINE auto map(const void* val) -> const void* { return val; } FMT_CONSTEXPR FMT_INLINE auto map(std::nullptr_t val) -> const void* { return val; } // Use SFINAE instead of a const T* parameter to avoid a conflict with the // array overload. template < typename T, FMT_ENABLE_IF( std::is_pointer::value || std::is_member_pointer::value || std::is_function::type>::value || (std::is_array::value && !std::is_convertible::value))> FMT_CONSTEXPR auto map(const T&) -> unformattable_pointer { return {}; } template ::value)> FMT_CONSTEXPR FMT_INLINE auto map(const T (&values)[N]) -> const T (&)[N] { return values; } // Only map owning types because mapping views can be unsafe. template , FMT_ENABLE_IF(std::is_arithmetic::value)> FMT_CONSTEXPR FMT_INLINE auto map(const T& val) -> decltype(FMT_DECLTYPE_THIS map(U())) { return map(format_as(val)); } template > struct formattable : bool_constant() || (has_formatter::value && !std::is_const::value)> {}; template ::value)> FMT_CONSTEXPR FMT_INLINE auto do_map(T& val) -> T& { return val; } template ::value)> FMT_CONSTEXPR FMT_INLINE auto do_map(T&) -> unformattable { return {}; } template , FMT_ENABLE_IF((std::is_class::value || std::is_enum::value || std::is_union::value) && !is_string::value && !is_char::value && !is_named_arg::value && !std::is_arithmetic>::value)> FMT_CONSTEXPR FMT_INLINE auto map(T& val) -> decltype(FMT_DECLTYPE_THIS do_map(val)) { return do_map(val); } template ::value)> FMT_CONSTEXPR FMT_INLINE auto map(const T& named_arg) -> decltype(FMT_DECLTYPE_THIS map(named_arg.value)) { return map(named_arg.value); } auto map(...) -> unformattable { return {}; } }; // A type constant after applying arg_mapper. template using mapped_type_constant = type_constant().map(std::declval())), typename Context::char_type>; enum { packed_arg_bits = 4 }; // Maximum number of arguments with packed types. enum { max_packed_args = 62 / packed_arg_bits }; enum : unsigned long long { is_unpacked_bit = 1ULL << 63 }; enum : unsigned long long { has_named_args_bit = 1ULL << 62 }; template auto copy_str(InputIt begin, InputIt end, appender out) -> appender { get_container(out).append(begin, end); return out; } template auto copy_str(InputIt begin, InputIt end, std::back_insert_iterator out) -> std::back_insert_iterator { get_container(out).append(begin, end); return out; } template FMT_CONSTEXPR auto copy_str(R&& rng, OutputIt out) -> OutputIt { return detail::copy_str(rng.begin(), rng.end(), out); } #if FMT_GCC_VERSION && FMT_GCC_VERSION < 500 // A workaround for gcc 4.8 to make void_t work in a SFINAE context. template struct void_t_impl { using type = void; }; template using void_t = typename void_t_impl::type; #else template using void_t = void; #endif template struct is_output_iterator : std::false_type {}; template struct is_output_iterator< It, T, void_t::iterator_category, decltype(*std::declval() = std::declval())>> : std::true_type {}; template struct is_back_insert_iterator : std::false_type {}; template struct is_back_insert_iterator> : std::true_type {}; // A type-erased reference to an std::locale to avoid a heavy include. class locale_ref { private: const void* locale_; // A type-erased pointer to std::locale. public: constexpr FMT_INLINE locale_ref() : locale_(nullptr) {} template explicit locale_ref(const Locale& loc); explicit operator bool() const noexcept { return locale_ != nullptr; } template auto get() const -> Locale; }; template constexpr auto encode_types() -> unsigned long long { return 0; } template constexpr auto encode_types() -> unsigned long long { return static_cast(mapped_type_constant::value) | (encode_types() << packed_arg_bits); } #if defined(__cpp_if_constexpr) // This type is intentionally undefined, only used for errors template struct type_is_unformattable_for; #endif template FMT_CONSTEXPR FMT_INLINE auto make_arg(T& val) -> value { using arg_type = remove_cvref_t().map(val))>; constexpr bool formattable_char = !std::is_same::value; static_assert(formattable_char, "Mixing character types is disallowed."); // Formatting of arbitrary pointers is disallowed. If you want to format a // pointer cast it to `void*` or `const void*`. In particular, this forbids // formatting of `[const] volatile char*` printed as bool by iostreams. constexpr bool formattable_pointer = !std::is_same::value; static_assert(formattable_pointer, "Formatting of non-void pointers is disallowed."); constexpr bool formattable = !std::is_same::value; #if defined(__cpp_if_constexpr) if constexpr (!formattable) { type_is_unformattable_for _; } #endif static_assert( formattable, "Cannot format an argument. To make type T formattable provide a " "formatter specialization: https://fmt.dev/latest/api.html#udt"); return {arg_mapper().map(val)}; } template FMT_CONSTEXPR auto make_arg(T& val) -> basic_format_arg { auto arg = basic_format_arg(); arg.type_ = mapped_type_constant::value; arg.value_ = make_arg(val); return arg; } template FMT_CONSTEXPR inline auto make_arg(T& val) -> basic_format_arg { return make_arg(val); } } // namespace detail FMT_BEGIN_EXPORT // A formatting argument. Context is a template parameter for the compiled API // where output can be unbuffered. template class basic_format_arg { private: detail::value value_; detail::type type_; template friend FMT_CONSTEXPR auto detail::make_arg(T& value) -> basic_format_arg; template friend FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis, const basic_format_arg& arg) -> decltype(vis(0)); friend class basic_format_args; friend class dynamic_format_arg_store; using char_type = typename Context::char_type; template friend struct detail::arg_data; basic_format_arg(const detail::named_arg_info* args, size_t size) : value_(args, size) {} public: class handle { public: explicit handle(detail::custom_value custom) : custom_(custom) {} void format(typename Context::parse_context_type& parse_ctx, Context& ctx) const { custom_.format(custom_.value, parse_ctx, ctx); } private: detail::custom_value custom_; }; constexpr basic_format_arg() : type_(detail::type::none_type) {} constexpr explicit operator bool() const noexcept { return type_ != detail::type::none_type; } auto type() const -> detail::type { return type_; } auto is_integral() const -> bool { return detail::is_integral_type(type_); } auto is_arithmetic() const -> bool { return detail::is_arithmetic_type(type_); } FMT_INLINE auto format_custom(const char_type* parse_begin, typename Context::parse_context_type& parse_ctx, Context& ctx) -> bool { if (type_ != detail::type::custom_type) return false; parse_ctx.advance_to(parse_begin); value_.custom.format(value_.custom.value, parse_ctx, ctx); return true; } }; /** \rst Visits an argument dispatching to the appropriate visit method based on the argument type. For example, if the argument type is ``double`` then ``vis(value)`` will be called with the value of type ``double``. \endrst */ // DEPRECATED! template FMT_CONSTEXPR FMT_INLINE auto visit_format_arg( Visitor&& vis, const basic_format_arg& arg) -> decltype(vis(0)) { switch (arg.type_) { case detail::type::none_type: break; case detail::type::int_type: return vis(arg.value_.int_value); case detail::type::uint_type: return vis(arg.value_.uint_value); case detail::type::long_long_type: return vis(arg.value_.long_long_value); case detail::type::ulong_long_type: return vis(arg.value_.ulong_long_value); case detail::type::int128_type: return vis(detail::convert_for_visit(arg.value_.int128_value)); case detail::type::uint128_type: return vis(detail::convert_for_visit(arg.value_.uint128_value)); case detail::type::bool_type: return vis(arg.value_.bool_value); case detail::type::char_type: return vis(arg.value_.char_value); case detail::type::float_type: return vis(arg.value_.float_value); case detail::type::double_type: return vis(arg.value_.double_value); case detail::type::long_double_type: return vis(arg.value_.long_double_value); case detail::type::cstring_type: return vis(arg.value_.string.data); case detail::type::string_type: using sv = basic_string_view; return vis(sv(arg.value_.string.data, arg.value_.string.size)); case detail::type::pointer_type: return vis(arg.value_.pointer); case detail::type::custom_type: return vis(typename basic_format_arg::handle(arg.value_.custom)); } return vis(monostate()); } // Formatting context. template class basic_format_context { private: OutputIt out_; basic_format_args args_; detail::locale_ref loc_; public: using iterator = OutputIt; using format_arg = basic_format_arg; using format_args = basic_format_args; using parse_context_type = basic_format_parse_context; template using formatter_type = formatter; /** The character type for the output. */ using char_type = Char; basic_format_context(basic_format_context&&) = default; basic_format_context(const basic_format_context&) = delete; void operator=(const basic_format_context&) = delete; /** Constructs a ``basic_format_context`` object. References to the arguments are stored in the object so make sure they have appropriate lifetimes. */ constexpr basic_format_context(OutputIt out, format_args ctx_args, detail::locale_ref loc = {}) : out_(out), args_(ctx_args), loc_(loc) {} constexpr auto arg(int id) const -> format_arg { return args_.get(id); } FMT_CONSTEXPR auto arg(basic_string_view name) -> format_arg { return args_.get(name); } FMT_CONSTEXPR auto arg_id(basic_string_view name) -> int { return args_.get_id(name); } auto args() const -> const format_args& { return args_; } // DEPRECATED! FMT_CONSTEXPR auto error_handler() -> detail::error_handler { return {}; } void on_error(const char* message) { error_handler().on_error(message); } // Returns an iterator to the beginning of the output range. FMT_CONSTEXPR auto out() -> iterator { return out_; } // Advances the begin iterator to ``it``. void advance_to(iterator it) { if (!detail::is_back_insert_iterator()) out_ = it; } FMT_CONSTEXPR auto locale() -> detail::locale_ref { return loc_; } }; template using buffer_context = basic_format_context, Char>; using format_context = buffer_context; template using is_formattable = bool_constant>() .map(std::declval()))>::value>; /** \rst An array of references to arguments. It can be implicitly converted into `~fmt::basic_format_args` for passing into type-erased formatting functions such as `~fmt::vformat`. \endrst */ template class format_arg_store #if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 // Workaround a GCC template argument substitution bug. : public basic_format_args #endif { private: static const size_t num_args = sizeof...(Args); static constexpr size_t num_named_args = detail::count_named_args(); static const bool is_packed = num_args <= detail::max_packed_args; using value_type = conditional_t, basic_format_arg>; detail::arg_data data_; friend class basic_format_args; static constexpr unsigned long long desc = (is_packed ? detail::encode_types() : detail::is_unpacked_bit | num_args) | (num_named_args != 0 ? static_cast(detail::has_named_args_bit) : 0); public: template FMT_CONSTEXPR FMT_INLINE format_arg_store(T&... args) : #if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 basic_format_args(*this), #endif data_{detail::make_arg(args)...} { if (detail::const_check(num_named_args != 0)) detail::init_named_args(data_.named_args(), 0, 0, args...); } }; /** \rst Constructs a `~fmt::format_arg_store` object that contains references to arguments and can be implicitly converted to `~fmt::format_args`. `Context` can be omitted in which case it defaults to `~fmt::format_context`. See `~fmt::arg` for lifetime considerations. \endrst */ // Arguments are taken by lvalue references to avoid some lifetime issues. template constexpr auto make_format_args(T&... args) -> format_arg_store...> { return {args...}; } /** \rst Returns a named argument to be used in a formatting function. It should only be used in a call to a formatting function or `dynamic_format_arg_store::push_back`. **Example**:: fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23)); \endrst */ template inline auto arg(const Char* name, const T& arg) -> detail::named_arg { static_assert(!detail::is_named_arg(), "nested named arguments"); return {name, arg}; } FMT_END_EXPORT /** \rst A view of a collection of formatting arguments. To avoid lifetime issues it should only be used as a parameter type in type-erased functions such as ``vformat``:: void vlog(string_view format_str, format_args args); // OK format_args args = make_format_args(); // Error: dangling reference \endrst */ template class basic_format_args { public: using size_type = int; using format_arg = basic_format_arg; private: // A descriptor that contains information about formatting arguments. // If the number of arguments is less or equal to max_packed_args then // argument types are passed in the descriptor. This reduces binary code size // per formatting function call. unsigned long long desc_; union { // If is_packed() returns true then argument values are stored in values_; // otherwise they are stored in args_. This is done to improve cache // locality and reduce compiled code size since storing larger objects // may require more code (at least on x86-64) even if the same amount of // data is actually copied to stack. It saves ~10% on the bloat test. const detail::value* values_; const format_arg* args_; }; constexpr auto is_packed() const -> bool { return (desc_ & detail::is_unpacked_bit) == 0; } auto has_named_args() const -> bool { return (desc_ & detail::has_named_args_bit) != 0; } FMT_CONSTEXPR auto type(int index) const -> detail::type { int shift = index * detail::packed_arg_bits; unsigned int mask = (1 << detail::packed_arg_bits) - 1; return static_cast((desc_ >> shift) & mask); } constexpr FMT_INLINE basic_format_args(unsigned long long desc, const detail::value* values) : desc_(desc), values_(values) {} constexpr basic_format_args(unsigned long long desc, const format_arg* args) : desc_(desc), args_(args) {} public: constexpr basic_format_args() : desc_(0), args_(nullptr) {} /** \rst Constructs a `basic_format_args` object from `~fmt::format_arg_store`. \endrst */ template constexpr FMT_INLINE basic_format_args( const format_arg_store& store) : basic_format_args(format_arg_store::desc, store.data_.args()) {} /** \rst Constructs a `basic_format_args` object from `~fmt::dynamic_format_arg_store`. \endrst */ constexpr FMT_INLINE basic_format_args( const dynamic_format_arg_store& store) : basic_format_args(store.get_types(), store.data()) {} /** \rst Constructs a `basic_format_args` object from a dynamic set of arguments. \endrst */ constexpr basic_format_args(const format_arg* args, int count) : basic_format_args(detail::is_unpacked_bit | detail::to_unsigned(count), args) {} /** Returns the argument with the specified id. */ FMT_CONSTEXPR auto get(int id) const -> format_arg { format_arg arg; if (!is_packed()) { if (id < max_size()) arg = args_[id]; return arg; } if (id >= detail::max_packed_args) return arg; arg.type_ = type(id); if (arg.type_ == detail::type::none_type) return arg; arg.value_ = values_[id]; return arg; } template auto get(basic_string_view name) const -> format_arg { int id = get_id(name); return id >= 0 ? get(id) : format_arg(); } template auto get_id(basic_string_view name) const -> int { if (!has_named_args()) return -1; const auto& named_args = (is_packed() ? values_[-1] : args_[-1].value_).named_args; for (size_t i = 0; i < named_args.size; ++i) { if (named_args.data[i].name == name) return named_args.data[i].id; } return -1; } auto max_size() const -> int { unsigned long long max_packed = detail::max_packed_args; return static_cast(is_packed() ? max_packed : desc_ & ~detail::is_unpacked_bit); } }; /** An alias to ``basic_format_args``. */ // A separate type would result in shorter symbols but break ABI compatibility // between clang and gcc on ARM (#1919). FMT_EXPORT using format_args = basic_format_args; // We cannot use enum classes as bit fields because of a gcc bug, so we put them // in namespaces instead (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414). // Additionally, if an underlying type is specified, older gcc incorrectly warns // that the type is too small. Both bugs are fixed in gcc 9.3. #if FMT_GCC_VERSION && FMT_GCC_VERSION < 903 # define FMT_ENUM_UNDERLYING_TYPE(type) #else # define FMT_ENUM_UNDERLYING_TYPE(type) : type #endif namespace align { enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char){none, left, right, center, numeric}; } using align_t = align::type; namespace sign { enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char){none, minus, plus, space}; } using sign_t = sign::type; namespace detail { // Workaround an array initialization issue in gcc 4.8. template struct fill_t { private: enum { max_size = 4 }; Char data_[max_size] = {Char(' '), Char(0), Char(0), Char(0)}; unsigned char size_ = 1; public: FMT_CONSTEXPR void operator=(basic_string_view s) { auto size = s.size(); FMT_ASSERT(size <= max_size, "invalid fill"); for (size_t i = 0; i < size; ++i) data_[i] = s[i]; size_ = static_cast(size); } constexpr auto size() const -> size_t { return size_; } constexpr auto data() const -> const Char* { return data_; } FMT_CONSTEXPR auto operator[](size_t index) -> Char& { return data_[index]; } FMT_CONSTEXPR auto operator[](size_t index) const -> const Char& { return data_[index]; } }; } // namespace detail enum class presentation_type : unsigned char { none, dec, // 'd' oct, // 'o' hex_lower, // 'x' hex_upper, // 'X' bin_lower, // 'b' bin_upper, // 'B' hexfloat_lower, // 'a' hexfloat_upper, // 'A' exp_lower, // 'e' exp_upper, // 'E' fixed_lower, // 'f' fixed_upper, // 'F' general_lower, // 'g' general_upper, // 'G' chr, // 'c' string, // 's' pointer, // 'p' debug // '?' }; // Format specifiers for built-in and string types. template struct format_specs { int width; int precision; presentation_type type; align_t align : 4; sign_t sign : 3; bool alt : 1; // Alternate form ('#'). bool localized : 1; detail::fill_t fill; constexpr format_specs() : width(0), precision(-1), type(presentation_type::none), align(align::none), sign(sign::none), alt(false), localized(false) {} }; namespace detail { enum class arg_id_kind { none, index, name }; // An argument reference. template struct arg_ref { FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {} FMT_CONSTEXPR explicit arg_ref(int index) : kind(arg_id_kind::index), val(index) {} FMT_CONSTEXPR explicit arg_ref(basic_string_view name) : kind(arg_id_kind::name), val(name) {} FMT_CONSTEXPR auto operator=(int idx) -> arg_ref& { kind = arg_id_kind::index; val.index = idx; return *this; } arg_id_kind kind; union value { FMT_CONSTEXPR value(int idx = 0) : index(idx) {} FMT_CONSTEXPR value(basic_string_view n) : name(n) {} int index; basic_string_view name; } val; }; // Format specifiers with width and precision resolved at formatting rather // than parsing time to allow reusing the same parsed specifiers with // different sets of arguments (precompilation of format strings). template struct dynamic_format_specs : format_specs { arg_ref width_ref; arg_ref precision_ref; }; // Converts a character to ASCII. Returns '\0' on conversion failure. template ::value)> constexpr auto to_ascii(Char c) -> char { return c <= 0xff ? static_cast(c) : '\0'; } template ::value)> constexpr auto to_ascii(Char c) -> char { return c <= 0xff ? static_cast(c) : '\0'; } // Returns the number of code units in a code point or 1 on error. template FMT_CONSTEXPR auto code_point_length(const Char* begin) -> int { if (const_check(sizeof(Char) != 1)) return 1; auto c = static_cast(*begin); return static_cast((0x3a55000000000000ull >> (2 * (c >> 3))) & 0x3) + 1; } // Return the result via the out param to workaround gcc bug 77539. template FMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr& out) -> bool { for (out = first; out != last; ++out) { if (*out == value) return true; } return false; } template <> inline auto find(const char* first, const char* last, char value, const char*& out) -> bool { out = static_cast( std::memchr(first, value, to_unsigned(last - first))); return out != nullptr; } // Parses the range [begin, end) as an unsigned integer. This function assumes // that the range is non-empty and the first character is a digit. template FMT_CONSTEXPR auto parse_nonnegative_int(const Char*& begin, const Char* end, int error_value) noexcept -> int { FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', ""); unsigned value = 0, prev = 0; auto p = begin; do { prev = value; value = value * 10 + unsigned(*p - '0'); ++p; } while (p != end && '0' <= *p && *p <= '9'); auto num_digits = p - begin; begin = p; if (num_digits <= std::numeric_limits::digits10) return static_cast(value); // Check for overflow. const unsigned max = to_unsigned((std::numeric_limits::max)()); return num_digits == std::numeric_limits::digits10 + 1 && prev * 10ull + unsigned(p[-1] - '0') <= max ? static_cast(value) : error_value; } FMT_CONSTEXPR inline auto parse_align(char c) -> align_t { switch (c) { case '<': return align::left; case '>': return align::right; case '^': return align::center; } return align::none; } template constexpr auto is_name_start(Char c) -> bool { return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_'; } template FMT_CONSTEXPR auto do_parse_arg_id(const Char* begin, const Char* end, Handler&& handler) -> const Char* { Char c = *begin; if (c >= '0' && c <= '9') { int index = 0; constexpr int max = (std::numeric_limits::max)(); if (c != '0') index = parse_nonnegative_int(begin, end, max); else ++begin; if (begin == end || (*begin != '}' && *begin != ':')) throw_format_error("invalid format string"); else handler.on_index(index); return begin; } if (!is_name_start(c)) { throw_format_error("invalid format string"); return begin; } auto it = begin; do { ++it; } while (it != end && (is_name_start(*it) || ('0' <= *it && *it <= '9'))); handler.on_name({begin, to_unsigned(it - begin)}); return it; } template FMT_CONSTEXPR FMT_INLINE auto parse_arg_id(const Char* begin, const Char* end, Handler&& handler) -> const Char* { FMT_ASSERT(begin != end, ""); Char c = *begin; if (c != '}' && c != ':') return do_parse_arg_id(begin, end, handler); handler.on_auto(); return begin; } template struct dynamic_spec_id_handler { basic_format_parse_context& ctx; arg_ref& ref; FMT_CONSTEXPR void on_auto() { int id = ctx.next_arg_id(); ref = arg_ref(id); ctx.check_dynamic_spec(id); } FMT_CONSTEXPR void on_index(int id) { ref = arg_ref(id); ctx.check_arg_id(id); ctx.check_dynamic_spec(id); } FMT_CONSTEXPR void on_name(basic_string_view id) { ref = arg_ref(id); ctx.check_arg_id(id); } }; // Parses [integer | "{" [arg_id] "}"]. template FMT_CONSTEXPR auto parse_dynamic_spec(const Char* begin, const Char* end, int& value, arg_ref& ref, basic_format_parse_context& ctx) -> const Char* { FMT_ASSERT(begin != end, ""); if ('0' <= *begin && *begin <= '9') { int val = parse_nonnegative_int(begin, end, -1); if (val != -1) value = val; else throw_format_error("number is too big"); } else if (*begin == '{') { ++begin; auto handler = dynamic_spec_id_handler{ctx, ref}; if (begin != end) begin = parse_arg_id(begin, end, handler); if (begin != end && *begin == '}') return ++begin; throw_format_error("invalid format string"); } return begin; } template FMT_CONSTEXPR auto parse_precision(const Char* begin, const Char* end, int& value, arg_ref& ref, basic_format_parse_context& ctx) -> const Char* { ++begin; if (begin == end || *begin == '}') { throw_format_error("invalid precision"); return begin; } return parse_dynamic_spec(begin, end, value, ref, ctx); } enum class state { start, align, sign, hash, zero, width, precision, locale }; // Parses standard format specifiers. template FMT_CONSTEXPR FMT_INLINE auto parse_format_specs( const Char* begin, const Char* end, dynamic_format_specs& specs, basic_format_parse_context& ctx, type arg_type) -> const Char* { auto c = '\0'; if (end - begin > 1) { auto next = to_ascii(begin[1]); c = parse_align(next) == align::none ? to_ascii(*begin) : '\0'; } else { if (begin == end) return begin; c = to_ascii(*begin); } struct { state current_state = state::start; FMT_CONSTEXPR void operator()(state s, bool valid = true) { if (current_state >= s || !valid) throw_format_error("invalid format specifier"); current_state = s; } } enter_state; using pres = presentation_type; constexpr auto integral_set = sint_set | uint_set | bool_set | char_set; struct { const Char*& begin; dynamic_format_specs& specs; type arg_type; FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* { if (!in(arg_type, set)) { if (arg_type == type::none_type) return begin; throw_format_error("invalid format specifier"); } specs.type = pres_type; return begin + 1; } } parse_presentation_type{begin, specs, arg_type}; for (;;) { switch (c) { case '<': case '>': case '^': enter_state(state::align); specs.align = parse_align(c); ++begin; break; case '+': case '-': case ' ': if (arg_type == type::none_type) return begin; enter_state(state::sign, in(arg_type, sint_set | float_set)); switch (c) { case '+': specs.sign = sign::plus; break; case '-': specs.sign = sign::minus; break; case ' ': specs.sign = sign::space; break; } ++begin; break; case '#': if (arg_type == type::none_type) return begin; enter_state(state::hash, is_arithmetic_type(arg_type)); specs.alt = true; ++begin; break; case '0': enter_state(state::zero); if (!is_arithmetic_type(arg_type)) { if (arg_type == type::none_type) return begin; throw_format_error("format specifier requires numeric argument"); } if (specs.align == align::none) { // Ignore 0 if align is specified for compatibility with std::format. specs.align = align::numeric; specs.fill[0] = Char('0'); } ++begin; break; case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case '{': enter_state(state::width); begin = parse_dynamic_spec(begin, end, specs.width, specs.width_ref, ctx); break; case '.': if (arg_type == type::none_type) return begin; enter_state(state::precision, in(arg_type, float_set | string_set | cstring_set)); begin = parse_precision(begin, end, specs.precision, specs.precision_ref, ctx); break; case 'L': if (arg_type == type::none_type) return begin; enter_state(state::locale, is_arithmetic_type(arg_type)); specs.localized = true; ++begin; break; case 'd': return parse_presentation_type(pres::dec, integral_set); case 'o': return parse_presentation_type(pres::oct, integral_set); case 'x': return parse_presentation_type(pres::hex_lower, integral_set); case 'X': return parse_presentation_type(pres::hex_upper, integral_set); case 'b': return parse_presentation_type(pres::bin_lower, integral_set); case 'B': return parse_presentation_type(pres::bin_upper, integral_set); case 'a': return parse_presentation_type(pres::hexfloat_lower, float_set); case 'A': return parse_presentation_type(pres::hexfloat_upper, float_set); case 'e': return parse_presentation_type(pres::exp_lower, float_set); case 'E': return parse_presentation_type(pres::exp_upper, float_set); case 'f': return parse_presentation_type(pres::fixed_lower, float_set); case 'F': return parse_presentation_type(pres::fixed_upper, float_set); case 'g': return parse_presentation_type(pres::general_lower, float_set); case 'G': return parse_presentation_type(pres::general_upper, float_set); case 'c': if (arg_type == type::bool_type) throw_format_error("invalid format specifier"); return parse_presentation_type(pres::chr, integral_set); case 's': return parse_presentation_type(pres::string, bool_set | string_set | cstring_set); case 'p': return parse_presentation_type(pres::pointer, pointer_set | cstring_set); case '?': return parse_presentation_type(pres::debug, char_set | string_set | cstring_set); case '}': return begin; default: { if (*begin == '}') return begin; // Parse fill and alignment. auto fill_end = begin + code_point_length(begin); if (end - fill_end <= 0) { throw_format_error("invalid format specifier"); return begin; } if (*begin == '{') { throw_format_error("invalid fill character '{'"); return begin; } auto align = parse_align(to_ascii(*fill_end)); enter_state(state::align, align != align::none); specs.fill = {begin, to_unsigned(fill_end - begin)}; specs.align = align; begin = fill_end + 1; } } if (begin == end) return begin; c = to_ascii(*begin); } } template FMT_CONSTEXPR auto parse_replacement_field(const Char* begin, const Char* end, Handler&& handler) -> const Char* { struct id_adapter { Handler& handler; int arg_id; FMT_CONSTEXPR void on_auto() { arg_id = handler.on_arg_id(); } FMT_CONSTEXPR void on_index(int id) { arg_id = handler.on_arg_id(id); } FMT_CONSTEXPR void on_name(basic_string_view id) { arg_id = handler.on_arg_id(id); } }; ++begin; if (begin == end) return handler.on_error("invalid format string"), end; if (*begin == '}') { handler.on_replacement_field(handler.on_arg_id(), begin); } else if (*begin == '{') { handler.on_text(begin, begin + 1); } else { auto adapter = id_adapter{handler, 0}; begin = parse_arg_id(begin, end, adapter); Char c = begin != end ? *begin : Char(); if (c == '}') { handler.on_replacement_field(adapter.arg_id, begin); } else if (c == ':') { begin = handler.on_format_specs(adapter.arg_id, begin + 1, end); if (begin == end || *begin != '}') return handler.on_error("unknown format specifier"), end; } else { return handler.on_error("missing '}' in format string"), end; } } return begin + 1; } template FMT_CONSTEXPR FMT_INLINE void parse_format_string( basic_string_view format_str, Handler&& handler) { auto begin = format_str.data(); auto end = begin + format_str.size(); if (end - begin < 32) { // Use a simple loop instead of memchr for small strings. const Char* p = begin; while (p != end) { auto c = *p++; if (c == '{') { handler.on_text(begin, p - 1); begin = p = parse_replacement_field(p - 1, end, handler); } else if (c == '}') { if (p == end || *p != '}') return handler.on_error("unmatched '}' in format string"); handler.on_text(begin, p); begin = ++p; } } handler.on_text(begin, end); return; } struct writer { FMT_CONSTEXPR void operator()(const Char* from, const Char* to) { if (from == to) return; for (;;) { const Char* p = nullptr; if (!find(from, to, Char('}'), p)) return handler_.on_text(from, to); ++p; if (p == to || *p != '}') return handler_.on_error("unmatched '}' in format string"); handler_.on_text(from, p); from = p + 1; } } Handler& handler_; } write = {handler}; while (begin != end) { // Doing two passes with memchr (one for '{' and another for '}') is up to // 2.5x faster than the naive one-pass implementation on big format strings. const Char* p = begin; if (*begin != '{' && !find(begin + 1, end, Char('{'), p)) return write(begin, end); write(begin, p); begin = parse_replacement_field(p, end, handler); } } template ::value> struct strip_named_arg { using type = T; }; template struct strip_named_arg { using type = remove_cvref_t; }; template FMT_CONSTEXPR auto parse_format_specs(ParseContext& ctx) -> decltype(ctx.begin()) { using char_type = typename ParseContext::char_type; using context = buffer_context; using mapped_type = conditional_t< mapped_type_constant::value != type::custom_type, decltype(arg_mapper().map(std::declval())), typename strip_named_arg::type>; #if defined(__cpp_if_constexpr) if constexpr (std::is_default_constructible< formatter>::value) { return formatter().parse(ctx); } else { type_is_unformattable_for _; return ctx.begin(); } #else return formatter().parse(ctx); #endif } // Checks char specs and returns true iff the presentation type is char-like. template FMT_CONSTEXPR auto check_char_specs(const format_specs& specs) -> bool { if (specs.type != presentation_type::none && specs.type != presentation_type::chr && specs.type != presentation_type::debug) { return false; } if (specs.align == align::numeric || specs.sign != sign::none || specs.alt) throw_format_error("invalid format specifier for char"); return true; } #if FMT_USE_NONTYPE_TEMPLATE_ARGS template constexpr auto get_arg_index_by_name(basic_string_view name) -> int { if constexpr (is_statically_named_arg()) { if (name == T::name) return N; } if constexpr (sizeof...(Args) > 0) return get_arg_index_by_name(name); (void)name; // Workaround an MSVC bug about "unused" parameter. return -1; } #endif template FMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view name) -> int { #if FMT_USE_NONTYPE_TEMPLATE_ARGS if constexpr (sizeof...(Args) > 0) return get_arg_index_by_name<0, Args...>(name); #endif (void)name; return -1; } template class format_string_checker { private: using parse_context_type = compile_parse_context; static constexpr int num_args = sizeof...(Args); // Format specifier parsing function. // In the future basic_format_parse_context will replace compile_parse_context // here and will use is_constant_evaluated and downcasting to access the data // needed for compile-time checks: https://godbolt.org/z/GvWzcTjh1. using parse_func = const Char* (*)(parse_context_type&); type types_[num_args > 0 ? static_cast(num_args) : 1]; parse_context_type context_; parse_func parse_funcs_[num_args > 0 ? static_cast(num_args) : 1]; public: explicit FMT_CONSTEXPR format_string_checker(basic_string_view fmt) : types_{mapped_type_constant>::value...}, context_(fmt, num_args, types_), parse_funcs_{&parse_format_specs...} {} FMT_CONSTEXPR void on_text(const Char*, const Char*) {} FMT_CONSTEXPR auto on_arg_id() -> int { return context_.next_arg_id(); } FMT_CONSTEXPR auto on_arg_id(int id) -> int { return context_.check_arg_id(id), id; } FMT_CONSTEXPR auto on_arg_id(basic_string_view id) -> int { #if FMT_USE_NONTYPE_TEMPLATE_ARGS auto index = get_arg_index_by_name(id); if (index < 0) on_error("named argument is not found"); return index; #else (void)id; on_error("compile-time checks for named arguments require C++20 support"); return 0; #endif } FMT_CONSTEXPR void on_replacement_field(int id, const Char* begin) { on_format_specs(id, begin, begin); // Call parse() on empty specs. } FMT_CONSTEXPR auto on_format_specs(int id, const Char* begin, const Char*) -> const Char* { context_.advance_to(begin); // id >= 0 check is a workaround for gcc 10 bug (#2065). return id >= 0 && id < num_args ? parse_funcs_[id](context_) : begin; } FMT_CONSTEXPR void on_error(const char* message) { throw_format_error(message); } }; // Reports a compile-time error if S is not a valid format string. template ::value)> FMT_INLINE void check_format_string(const S&) { #ifdef FMT_ENFORCE_COMPILE_STRING static_assert(is_compile_string::value, "FMT_ENFORCE_COMPILE_STRING requires all format strings to use " "FMT_STRING."); #endif } template ::value)> void check_format_string(S format_str) { using char_t = typename S::char_type; FMT_CONSTEXPR auto s = basic_string_view(format_str); using checker = format_string_checker...>; FMT_CONSTEXPR bool error = (parse_format_string(s, checker(s)), true); ignore_unused(error); } template struct vformat_args { using type = basic_format_args< basic_format_context>, Char>>; }; template <> struct vformat_args { using type = format_args; }; // Use vformat_args and avoid type_identity to keep symbols short. template void vformat_to(buffer& buf, basic_string_view fmt, typename vformat_args::type args, locale_ref loc = {}); FMT_API void vprint_mojibake(std::FILE*, string_view, format_args); #ifndef _WIN32 inline void vprint_mojibake(std::FILE*, string_view, format_args) {} #endif } // namespace detail FMT_BEGIN_EXPORT // A formatter specialization for natively supported types. template struct formatter::value != detail::type::custom_type>> { private: detail::dynamic_format_specs specs_; public: template FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* { auto type = detail::type_constant::value; auto end = detail::parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, type); if (type == detail::type::char_type) detail::check_char_specs(specs_); return end; } template ::value, FMT_ENABLE_IF(U == detail::type::string_type || U == detail::type::cstring_type || U == detail::type::char_type)> FMT_CONSTEXPR void set_debug_format(bool set = true) { specs_.type = set ? presentation_type::debug : presentation_type::none; } template FMT_CONSTEXPR auto format(const T& val, FormatContext& ctx) const -> decltype(ctx.out()); }; template struct runtime_format_string { basic_string_view str; }; /** A compile-time format string. */ template class basic_format_string { private: basic_string_view str_; public: template >::value)> FMT_CONSTEVAL FMT_INLINE basic_format_string(const S& s) : str_(s) { static_assert( detail::count< (std::is_base_of>::value && std::is_reference::value)...>() == 0, "passing views as lvalues is disallowed"); #ifdef FMT_HAS_CONSTEVAL if constexpr (detail::count_named_args() == detail::count_statically_named_args()) { using checker = detail::format_string_checker...>; detail::parse_format_string(str_, checker(s)); } #else detail::check_format_string(s); #endif } basic_format_string(runtime_format_string fmt) : str_(fmt.str) {} FMT_INLINE operator basic_string_view() const { return str_; } FMT_INLINE auto get() const -> basic_string_view { return str_; } }; #if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 // Workaround broken conversion on older gcc. template using format_string = string_view; inline auto runtime(string_view s) -> string_view { return s; } #else template using format_string = basic_format_string...>; /** \rst Creates a runtime format string. **Example**:: // Check format string at runtime instead of compile-time. fmt::print(fmt::runtime("{:d}"), "I am not a number"); \endrst */ inline auto runtime(string_view s) -> runtime_format_string<> { return {{s}}; } #endif FMT_API auto vformat(string_view fmt, format_args args) -> std::string; /** \rst Formats ``args`` according to specifications in ``fmt`` and returns the result as a string. **Example**:: #include std::string message = fmt::format("The answer is {}.", 42); \endrst */ template FMT_NODISCARD FMT_INLINE auto format(format_string fmt, T&&... args) -> std::string { return vformat(fmt, fmt::make_format_args(args...)); } /** Formats a string and writes the output to ``out``. */ template ::value)> auto vformat_to(OutputIt out, string_view fmt, format_args args) -> OutputIt { auto&& buf = detail::get_buffer(out); detail::vformat_to(buf, fmt, args, {}); return detail::get_iterator(buf, out); } /** \rst Formats ``args`` according to specifications in ``fmt``, writes the result to the output iterator ``out`` and returns the iterator past the end of the output range. `format_to` does not append a terminating null character. **Example**:: auto out = std::vector(); fmt::format_to(std::back_inserter(out), "{}", 42); \endrst */ template ::value)> FMT_INLINE auto format_to(OutputIt out, format_string fmt, T&&... args) -> OutputIt { return vformat_to(out, fmt, fmt::make_format_args(args...)); } template struct format_to_n_result { /** Iterator past the end of the output range. */ OutputIt out; /** Total (not truncated) output size. */ size_t size; }; template ::value)> auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args) -> format_to_n_result { using traits = detail::fixed_buffer_traits; auto buf = detail::iterator_buffer(out, n); detail::vformat_to(buf, fmt, args, {}); return {buf.out(), buf.count()}; } /** \rst 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. `format_to_n` does not append a terminating null character. \endrst */ template ::value)> FMT_INLINE auto format_to_n(OutputIt out, size_t n, format_string fmt, T&&... args) -> format_to_n_result { return vformat_to_n(out, n, fmt, fmt::make_format_args(args...)); } /** Returns the number of chars in the output of ``format(fmt, args...)``. */ template FMT_NODISCARD FMT_INLINE auto formatted_size(format_string fmt, T&&... args) -> size_t { auto buf = detail::counting_buffer<>(); detail::vformat_to(buf, fmt, fmt::make_format_args(args...), {}); return buf.count(); } FMT_API void vprint(string_view fmt, format_args args); FMT_API void vprint(std::FILE* f, string_view fmt, format_args args); /** \rst Formats ``args`` according to specifications in ``fmt`` and writes the output to ``stdout``. **Example**:: fmt::print("Elapsed time: {0:.2f} seconds", 1.23); \endrst */ template FMT_INLINE void print(format_string fmt, T&&... args) { const auto& vargs = fmt::make_format_args(args...); return detail::is_utf8() ? vprint(fmt, vargs) : detail::vprint_mojibake(stdout, fmt, vargs); } /** \rst Formats ``args`` according to specifications in ``fmt`` and writes the output to the file ``f``. **Example**:: fmt::print(stderr, "Don't {}!", "panic"); \endrst */ template FMT_INLINE void print(std::FILE* f, format_string fmt, T&&... args) { const auto& vargs = fmt::make_format_args(args...); return detail::is_utf8() ? vprint(f, fmt, vargs) : detail::vprint_mojibake(f, fmt, vargs); } /** Formats ``args`` according to specifications in ``fmt`` and writes the output to the file ``f`` followed by a newline. */ template FMT_INLINE void println(std::FILE* f, format_string fmt, T&&... args) { return fmt::print(f, "{}\n", fmt::format(fmt, std::forward(args)...)); } /** Formats ``args`` according to specifications in ``fmt`` and writes the output to ``stdout`` followed by a newline. */ template FMT_INLINE void println(format_string fmt, T&&... args) { return fmt::println(stdout, fmt, std::forward(args)...); } FMT_END_EXPORT FMT_GCC_PRAGMA("GCC pop_options") FMT_END_NAMESPACE #ifdef FMT_HEADER_ONLY # include "format.h" #endif #endif // FMT_CORE_H_ RcppSpdlog/inst/include/spdlog/fmt/bundled/os.h0000644000176200001440000003175314612604314021226 0ustar liggesusers// Formatting library for C++ - optional OS-specific functionality // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_OS_H_ #define FMT_OS_H_ #include #include #include #include // std::system_error #include "format.h" #if defined __APPLE__ || defined(__FreeBSD__) # if FMT_HAS_INCLUDE() # include // for LC_NUMERIC_MASK on OS X # endif #endif #ifndef FMT_USE_FCNTL // UWP doesn't provide _pipe. # if FMT_HAS_INCLUDE("winapifamily.h") # include # endif # if (FMT_HAS_INCLUDE() || defined(__APPLE__) || \ defined(__linux__)) && \ (!defined(WINAPI_FAMILY) || \ (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP)) # include // for O_RDONLY # define FMT_USE_FCNTL 1 # else # define FMT_USE_FCNTL 0 # endif #endif #ifndef FMT_POSIX # if defined(_WIN32) && !defined(__MINGW32__) // Fix warnings about deprecated symbols. # define FMT_POSIX(call) _##call # else # define FMT_POSIX(call) call # endif #endif // Calls to system functions are wrapped in FMT_SYSTEM for testability. #ifdef FMT_SYSTEM # define FMT_HAS_SYSTEM # define FMT_POSIX_CALL(call) FMT_SYSTEM(call) #else # define FMT_SYSTEM(call) ::call # ifdef _WIN32 // Fix warnings about deprecated symbols. # define FMT_POSIX_CALL(call) ::_##call # else # define FMT_POSIX_CALL(call) ::call # endif #endif // Retries the expression while it evaluates to error_result and errno // equals to EINTR. #ifndef _WIN32 # define FMT_RETRY_VAL(result, expression, error_result) \ do { \ (result) = (expression); \ } while ((result) == (error_result) && errno == EINTR) #else # define FMT_RETRY_VAL(result, expression, error_result) result = (expression) #endif #define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1) FMT_BEGIN_NAMESPACE FMT_BEGIN_EXPORT /** \rst A reference to a null-terminated string. It can be constructed from a C string or ``std::string``. You can use one of the following type aliases for common character types: +---------------+-----------------------------+ | Type | Definition | +===============+=============================+ | cstring_view | basic_cstring_view | +---------------+-----------------------------+ | wcstring_view | basic_cstring_view | +---------------+-----------------------------+ This class is most useful as a parameter type to allow passing different types of strings to a function, for example:: template std::string format(cstring_view format_str, const Args & ... args); format("{}", 42); format(std::string("{}"), 42); \endrst */ template class basic_cstring_view { private: const Char* data_; public: /** Constructs a string reference object from a C string. */ basic_cstring_view(const Char* s) : data_(s) {} /** \rst Constructs a string reference from an ``std::string`` object. \endrst */ basic_cstring_view(const std::basic_string& s) : data_(s.c_str()) {} /** Returns the pointer to a C string. */ auto c_str() const -> const Char* { return data_; } }; using cstring_view = basic_cstring_view; using wcstring_view = basic_cstring_view; #ifdef _WIN32 FMT_API const std::error_category& system_category() noexcept; namespace detail { FMT_API void format_windows_error(buffer& out, int error_code, const char* message) noexcept; } FMT_API std::system_error vwindows_error(int error_code, string_view format_str, format_args args); /** \rst Constructs a :class:`std::system_error` object with the description of the form .. parsed-literal:: **: ** where ** is the formatted message and ** is the system message corresponding to the error code. *error_code* is a Windows error code as given by ``GetLastError``. If *error_code* is not a valid error code such as -1, the system message will look like "error -1". **Example**:: // This throws a system_error with the description // cannot open file 'madeup': The system cannot find the file specified. // or similar (system message may vary). const char *filename = "madeup"; LPOFSTRUCT of = LPOFSTRUCT(); HFILE file = OpenFile(filename, &of, OF_READ); if (file == HFILE_ERROR) { throw fmt::windows_error(GetLastError(), "cannot open file '{}'", filename); } \endrst */ template std::system_error windows_error(int error_code, string_view message, const Args&... args) { return vwindows_error(error_code, message, fmt::make_format_args(args...)); } // Reports a Windows error without throwing an exception. // Can be used to report errors from destructors. FMT_API void report_windows_error(int error_code, const char* message) noexcept; #else inline auto system_category() noexcept -> const std::error_category& { return std::system_category(); } #endif // _WIN32 // std::system is not available on some platforms such as iOS (#2248). #ifdef __OSX__ template > void say(const S& format_str, Args&&... args) { std::system(format("say \"{}\"", format(format_str, args...)).c_str()); } #endif // A buffered file. class buffered_file { private: FILE* file_; friend class file; explicit buffered_file(FILE* f) : file_(f) {} public: buffered_file(const buffered_file&) = delete; void operator=(const buffered_file&) = delete; // Constructs a buffered_file object which doesn't represent any file. buffered_file() noexcept : file_(nullptr) {} // Destroys the object closing the file it represents if any. FMT_API ~buffered_file() noexcept; public: buffered_file(buffered_file&& other) noexcept : file_(other.file_) { other.file_ = nullptr; } auto operator=(buffered_file&& other) -> buffered_file& { close(); file_ = other.file_; other.file_ = nullptr; return *this; } // Opens a file. FMT_API buffered_file(cstring_view filename, cstring_view mode); // Closes the file. FMT_API void close(); // Returns the pointer to a FILE object representing this file. auto get() const noexcept -> FILE* { return file_; } FMT_API auto descriptor() const -> int; void vprint(string_view format_str, format_args args) { fmt::vprint(file_, format_str, args); } template inline void print(string_view format_str, const Args&... args) { vprint(format_str, fmt::make_format_args(args...)); } }; #if FMT_USE_FCNTL // A file. Closed file is represented by a file object with descriptor -1. // Methods that are not declared with noexcept may throw // fmt::system_error in case of failure. Note that some errors such as // closing the file multiple times will cause a crash on Windows rather // than an exception. You can get standard behavior by overriding the // invalid parameter handler with _set_invalid_parameter_handler. class FMT_API file { private: int fd_; // File descriptor. // Constructs a file object with a given descriptor. explicit file(int fd) : fd_(fd) {} public: // Possible values for the oflag argument to the constructor. enum { RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only. WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only. RDWR = FMT_POSIX(O_RDWR), // Open for reading and writing. CREATE = FMT_POSIX(O_CREAT), // Create if the file doesn't exist. APPEND = FMT_POSIX(O_APPEND), // Open in append mode. TRUNC = FMT_POSIX(O_TRUNC) // Truncate the content of the file. }; // Constructs a file object which doesn't represent any file. file() noexcept : fd_(-1) {} // Opens a file and constructs a file object representing this file. file(cstring_view path, int oflag); public: file(const file&) = delete; void operator=(const file&) = delete; file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; } // Move assignment is not noexcept because close may throw. auto operator=(file&& other) -> file& { close(); fd_ = other.fd_; other.fd_ = -1; return *this; } // Destroys the object closing the file it represents if any. ~file() noexcept; // Returns the file descriptor. auto descriptor() const noexcept -> int { return fd_; } // Closes the file. void close(); // Returns the file size. The size has signed type for consistency with // stat::st_size. auto size() const -> long long; // Attempts to read count bytes from the file into the specified buffer. auto read(void* buffer, size_t count) -> size_t; // Attempts to write count bytes from the specified buffer to the file. auto write(const void* buffer, size_t count) -> size_t; // Duplicates a file descriptor with the dup function and returns // the duplicate as a file object. static auto dup(int fd) -> file; // Makes fd be the copy of this file descriptor, closing fd first if // necessary. void dup2(int fd); // Makes fd be the copy of this file descriptor, closing fd first if // necessary. void dup2(int fd, std::error_code& ec) noexcept; // Creates a pipe setting up read_end and write_end file objects for reading // and writing respectively. // DEPRECATED! Taking files as out parameters is deprecated. static void pipe(file& read_end, file& write_end); // Creates a buffered_file object associated with this file and detaches // this file object from the file. auto fdopen(const char* mode) -> buffered_file; # if defined(_WIN32) && !defined(__MINGW32__) // Opens a file and constructs a file object representing this file by // wcstring_view filename. Windows only. static file open_windows_file(wcstring_view path, int oflag); # endif }; // Returns the memory page size. auto getpagesize() -> long; namespace detail { struct buffer_size { buffer_size() = default; size_t value = 0; auto operator=(size_t val) const -> buffer_size { auto bs = buffer_size(); bs.value = val; return bs; } }; struct ostream_params { int oflag = file::WRONLY | file::CREATE | file::TRUNC; size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768; ostream_params() {} template ostream_params(T... params, int new_oflag) : ostream_params(params...) { oflag = new_oflag; } template ostream_params(T... params, detail::buffer_size bs) : ostream_params(params...) { this->buffer_size = bs.value; } // Intel has a bug that results in failure to deduce a constructor // for empty parameter packs. # if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 2000 ostream_params(int new_oflag) : oflag(new_oflag) {} ostream_params(detail::buffer_size bs) : buffer_size(bs.value) {} # endif }; class file_buffer final : public buffer { file file_; FMT_API void grow(size_t) override; public: FMT_API file_buffer(cstring_view path, const ostream_params& params); FMT_API file_buffer(file_buffer&& other); FMT_API ~file_buffer(); void flush() { if (size() == 0) return; file_.write(data(), size() * sizeof(data()[0])); clear(); } void close() { flush(); file_.close(); } }; } // namespace detail // Added {} below to work around default constructor error known to // occur in Xcode versions 7.2.1 and 8.2.1. constexpr detail::buffer_size buffer_size{}; /** A fast output stream which is not thread-safe. */ class FMT_API ostream { private: FMT_MSC_WARNING(suppress : 4251) detail::file_buffer buffer_; ostream(cstring_view path, const detail::ostream_params& params) : buffer_(path, params) {} public: ostream(ostream&& other) : buffer_(std::move(other.buffer_)) {} ~ostream(); void flush() { buffer_.flush(); } template friend auto output_file(cstring_view path, T... params) -> ostream; void close() { buffer_.close(); } /** Formats ``args`` according to specifications in ``fmt`` and writes the output to the file. */ template void print(format_string fmt, T&&... args) { vformat_to(std::back_inserter(buffer_), fmt, fmt::make_format_args(args...)); } }; /** \rst Opens a file for writing. Supported parameters passed in *params*: * ````: Flags passed to `open `_ (``file::WRONLY | file::CREATE | file::TRUNC`` by default) * ``buffer_size=``: Output buffer size **Example**:: auto out = fmt::output_file("guide.txt"); out.print("Don't {}", "Panic"); \endrst */ template inline auto output_file(cstring_view path, T... params) -> ostream { return {path, detail::ostream_params(params...)}; } #endif // FMT_USE_FCNTL FMT_END_EXPORT FMT_END_NAMESPACE #endif // FMT_OS_H_ RcppSpdlog/inst/include/spdlog/fmt/bundled/format-inl.h0000644000176200001440000021765614612604314022665 0ustar liggesusers// Formatting library for C++ - implementation // // Copyright (c) 2012 - 2016, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_FORMAT_INL_H_ #define FMT_FORMAT_INL_H_ #include #include // errno #include #include #include #ifndef FMT_STATIC_THOUSANDS_SEPARATOR # include #endif #if defined(_WIN32) && !defined(FMT_WINDOWS_NO_WCHAR) # include // _isatty #endif #include "format.h" FMT_BEGIN_NAMESPACE namespace detail { FMT_FUNC void assert_fail(const char* file, int line, const char* message) { // Use unchecked std::fprintf to avoid triggering another assertion when // writing to stderr fails std::fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message); // Chosen instead of std::abort to satisfy Clang in CUDA mode during device // code pass. std::terminate(); } FMT_FUNC void throw_format_error(const char* message) { FMT_THROW(format_error(message)); } FMT_FUNC void format_error_code(detail::buffer& out, int error_code, string_view message) noexcept { // Report error code making sure that the output fits into // inline_buffer_size to avoid dynamic memory allocation and potential // bad_alloc. out.try_resize(0); static const char SEP[] = ": "; static const char ERROR_STR[] = "error "; // Subtract 2 to account for terminating null characters in SEP and ERROR_STR. size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2; auto abs_value = static_cast>(error_code); if (detail::is_negative(error_code)) { abs_value = 0 - abs_value; ++error_code_size; } error_code_size += detail::to_unsigned(detail::count_digits(abs_value)); auto it = buffer_appender(out); if (message.size() <= inline_buffer_size - error_code_size) fmt::format_to(it, FMT_STRING("{}{}"), message, SEP); fmt::format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code); FMT_ASSERT(out.size() <= inline_buffer_size, ""); } FMT_FUNC void report_error(format_func func, int error_code, const char* message) noexcept { memory_buffer full_message; func(full_message, error_code, message); // Don't use fwrite_fully because the latter may throw. if (std::fwrite(full_message.data(), full_message.size(), 1, stderr) > 0) std::fputc('\n', stderr); } // A wrapper around fwrite that throws on error. inline void fwrite_fully(const void* ptr, size_t count, FILE* stream) { size_t written = std::fwrite(ptr, 1, count, stream); if (written < count) FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); } #ifndef FMT_STATIC_THOUSANDS_SEPARATOR template locale_ref::locale_ref(const Locale& loc) : locale_(&loc) { static_assert(std::is_same::value, ""); } template auto locale_ref::get() const -> Locale { static_assert(std::is_same::value, ""); return locale_ ? *static_cast(locale_) : std::locale(); } template FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result { auto& facet = std::use_facet>(loc.get()); auto grouping = facet.grouping(); auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep(); return {std::move(grouping), thousands_sep}; } template FMT_FUNC auto decimal_point_impl(locale_ref loc) -> Char { return std::use_facet>(loc.get()) .decimal_point(); } #else template FMT_FUNC auto thousands_sep_impl(locale_ref) -> thousands_sep_result { return {"\03", FMT_STATIC_THOUSANDS_SEPARATOR}; } template FMT_FUNC Char decimal_point_impl(locale_ref) { return '.'; } #endif FMT_FUNC auto write_loc(appender out, loc_value value, const format_specs<>& specs, locale_ref loc) -> bool { #ifndef FMT_STATIC_THOUSANDS_SEPARATOR auto locale = loc.get(); // We cannot use the num_put facet because it may produce output in // a wrong encoding. using facet = format_facet; if (std::has_facet(locale)) return std::use_facet(locale).put(out, value, specs); return facet(locale).put(out, value, specs); #endif return false; } } // namespace detail template typename Locale::id format_facet::id; #ifndef FMT_STATIC_THOUSANDS_SEPARATOR template format_facet::format_facet(Locale& loc) { auto& numpunct = std::use_facet>(loc); grouping_ = numpunct.grouping(); if (!grouping_.empty()) separator_ = std::string(1, numpunct.thousands_sep()); } template <> FMT_API FMT_FUNC auto format_facet::do_put( appender out, loc_value val, const format_specs<>& specs) const -> bool { return val.visit( detail::loc_writer<>{out, specs, separator_, grouping_, decimal_point_}); } #endif FMT_FUNC auto vsystem_error(int error_code, string_view fmt, format_args args) -> std::system_error { auto ec = std::error_code(error_code, std::generic_category()); return std::system_error(ec, vformat(fmt, args)); } namespace detail { template inline auto operator==(basic_fp x, basic_fp y) -> bool { return x.f == y.f && x.e == y.e; } // Compilers should be able to optimize this into the ror instruction. FMT_CONSTEXPR inline auto rotr(uint32_t n, uint32_t r) noexcept -> uint32_t { r &= 31; return (n >> r) | (n << (32 - r)); } FMT_CONSTEXPR inline auto rotr(uint64_t n, uint32_t r) noexcept -> uint64_t { r &= 63; return (n >> r) | (n << (64 - r)); } // Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox. namespace dragonbox { // Computes upper 64 bits of multiplication of a 32-bit unsigned integer and a // 64-bit unsigned integer. inline auto umul96_upper64(uint32_t x, uint64_t y) noexcept -> uint64_t { return umul128_upper64(static_cast(x) << 32, y); } // Computes lower 128 bits of multiplication of a 64-bit unsigned integer and a // 128-bit unsigned integer. inline auto umul192_lower128(uint64_t x, uint128_fallback y) noexcept -> uint128_fallback { uint64_t high = x * y.high(); uint128_fallback high_low = umul128(x, y.low()); return {high + high_low.high(), high_low.low()}; } // Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a // 64-bit unsigned integer. inline auto umul96_lower64(uint32_t x, uint64_t y) noexcept -> uint64_t { return x * y; } // Various fast log computations. inline auto floor_log10_pow2_minus_log10_4_over_3(int e) noexcept -> int { FMT_ASSERT(e <= 2936 && e >= -2985, "too large exponent"); return (e * 631305 - 261663) >> 21; } FMT_INLINE_VARIABLE constexpr struct { uint32_t divisor; int shift_amount; } div_small_pow10_infos[] = {{10, 16}, {100, 16}}; // Replaces n by floor(n / pow(10, N)) returning true if and only if n is // divisible by pow(10, N). // Precondition: n <= pow(10, N + 1). template auto check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept -> bool { // The numbers below are chosen such that: // 1. floor(n/d) = floor(nm / 2^k) where d=10 or d=100, // 2. nm mod 2^k < m if and only if n is divisible by d, // where m is magic_number, k is shift_amount // and d is divisor. // // Item 1 is a common technique of replacing division by a constant with // multiplication, see e.g. "Division by Invariant Integers Using // Multiplication" by Granlund and Montgomery (1994). magic_number (m) is set // to ceil(2^k/d) for large enough k. // The idea for item 2 originates from Schubfach. constexpr auto info = div_small_pow10_infos[N - 1]; FMT_ASSERT(n <= info.divisor * 10, "n is too large"); constexpr uint32_t magic_number = (1u << info.shift_amount) / info.divisor + 1; n *= magic_number; const uint32_t comparison_mask = (1u << info.shift_amount) - 1; bool result = (n & comparison_mask) < magic_number; n >>= info.shift_amount; return result; } // Computes floor(n / pow(10, N)) for small n and N. // Precondition: n <= pow(10, N + 1). template auto small_division_by_pow10(uint32_t n) noexcept -> uint32_t { constexpr auto info = div_small_pow10_infos[N - 1]; FMT_ASSERT(n <= info.divisor * 10, "n is too large"); constexpr uint32_t magic_number = (1u << info.shift_amount) / info.divisor + 1; return (n * magic_number) >> info.shift_amount; } // Computes floor(n / 10^(kappa + 1)) (float) inline auto divide_by_10_to_kappa_plus_1(uint32_t n) noexcept -> uint32_t { // 1374389535 = ceil(2^37/100) return static_cast((static_cast(n) * 1374389535) >> 37); } // Computes floor(n / 10^(kappa + 1)) (double) inline auto divide_by_10_to_kappa_plus_1(uint64_t n) noexcept -> uint64_t { // 2361183241434822607 = ceil(2^(64+7)/1000) return umul128_upper64(n, 2361183241434822607ull) >> 7; } // Various subroutines using pow10 cache template struct cache_accessor; template <> struct cache_accessor { using carrier_uint = float_info::carrier_uint; using cache_entry_type = uint64_t; static auto get_cached_power(int k) noexcept -> uint64_t { FMT_ASSERT(k >= float_info::min_k && k <= float_info::max_k, "k is out of range"); static constexpr const uint64_t pow10_significands[] = { 0x81ceb32c4b43fcf5, 0xa2425ff75e14fc32, 0xcad2f7f5359a3b3f, 0xfd87b5f28300ca0e, 0x9e74d1b791e07e49, 0xc612062576589ddb, 0xf79687aed3eec552, 0x9abe14cd44753b53, 0xc16d9a0095928a28, 0xf1c90080baf72cb2, 0x971da05074da7bef, 0xbce5086492111aeb, 0xec1e4a7db69561a6, 0x9392ee8e921d5d08, 0xb877aa3236a4b44a, 0xe69594bec44de15c, 0x901d7cf73ab0acda, 0xb424dc35095cd810, 0xe12e13424bb40e14, 0x8cbccc096f5088cc, 0xafebff0bcb24aaff, 0xdbe6fecebdedd5bf, 0x89705f4136b4a598, 0xabcc77118461cefd, 0xd6bf94d5e57a42bd, 0x8637bd05af6c69b6, 0xa7c5ac471b478424, 0xd1b71758e219652c, 0x83126e978d4fdf3c, 0xa3d70a3d70a3d70b, 0xcccccccccccccccd, 0x8000000000000000, 0xa000000000000000, 0xc800000000000000, 0xfa00000000000000, 0x9c40000000000000, 0xc350000000000000, 0xf424000000000000, 0x9896800000000000, 0xbebc200000000000, 0xee6b280000000000, 0x9502f90000000000, 0xba43b74000000000, 0xe8d4a51000000000, 0x9184e72a00000000, 0xb5e620f480000000, 0xe35fa931a0000000, 0x8e1bc9bf04000000, 0xb1a2bc2ec5000000, 0xde0b6b3a76400000, 0x8ac7230489e80000, 0xad78ebc5ac620000, 0xd8d726b7177a8000, 0x878678326eac9000, 0xa968163f0a57b400, 0xd3c21bcecceda100, 0x84595161401484a0, 0xa56fa5b99019a5c8, 0xcecb8f27f4200f3a, 0x813f3978f8940985, 0xa18f07d736b90be6, 0xc9f2c9cd04674edf, 0xfc6f7c4045812297, 0x9dc5ada82b70b59e, 0xc5371912364ce306, 0xf684df56c3e01bc7, 0x9a130b963a6c115d, 0xc097ce7bc90715b4, 0xf0bdc21abb48db21, 0x96769950b50d88f5, 0xbc143fa4e250eb32, 0xeb194f8e1ae525fe, 0x92efd1b8d0cf37bf, 0xb7abc627050305ae, 0xe596b7b0c643c71a, 0x8f7e32ce7bea5c70, 0xb35dbf821ae4f38c, 0xe0352f62a19e306f}; return pow10_significands[k - float_info::min_k]; } struct compute_mul_result { carrier_uint result; bool is_integer; }; struct compute_mul_parity_result { bool parity; bool is_integer; }; static auto compute_mul(carrier_uint u, const cache_entry_type& cache) noexcept -> compute_mul_result { auto r = umul96_upper64(u, cache); return {static_cast(r >> 32), static_cast(r) == 0}; } static auto compute_delta(const cache_entry_type& cache, int beta) noexcept -> uint32_t { return static_cast(cache >> (64 - 1 - beta)); } static auto compute_mul_parity(carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept -> compute_mul_parity_result { FMT_ASSERT(beta >= 1, ""); FMT_ASSERT(beta < 64, ""); auto r = umul96_lower64(two_f, cache); return {((r >> (64 - beta)) & 1) != 0, static_cast(r >> (32 - beta)) == 0}; } static auto compute_left_endpoint_for_shorter_interval_case( const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return static_cast( (cache - (cache >> (num_significand_bits() + 2))) >> (64 - num_significand_bits() - 1 - beta)); } static auto compute_right_endpoint_for_shorter_interval_case( const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return static_cast( (cache + (cache >> (num_significand_bits() + 1))) >> (64 - num_significand_bits() - 1 - beta)); } static auto compute_round_up_for_shorter_interval_case( const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return (static_cast( cache >> (64 - num_significand_bits() - 2 - beta)) + 1) / 2; } }; template <> struct cache_accessor { using carrier_uint = float_info::carrier_uint; using cache_entry_type = uint128_fallback; static auto get_cached_power(int k) noexcept -> uint128_fallback { FMT_ASSERT(k >= float_info::min_k && k <= float_info::max_k, "k is out of range"); static constexpr const uint128_fallback pow10_significands[] = { #if FMT_USE_FULL_CACHE_DRAGONBOX {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b}, {0x9faacf3df73609b1, 0x77b191618c54e9ad}, {0xc795830d75038c1d, 0xd59df5b9ef6a2418}, {0xf97ae3d0d2446f25, 0x4b0573286b44ad1e}, {0x9becce62836ac577, 0x4ee367f9430aec33}, {0xc2e801fb244576d5, 0x229c41f793cda740}, {0xf3a20279ed56d48a, 0x6b43527578c11110}, {0x9845418c345644d6, 0x830a13896b78aaaa}, {0xbe5691ef416bd60c, 0x23cc986bc656d554}, {0xedec366b11c6cb8f, 0x2cbfbe86b7ec8aa9}, {0x94b3a202eb1c3f39, 0x7bf7d71432f3d6aa}, {0xb9e08a83a5e34f07, 0xdaf5ccd93fb0cc54}, {0xe858ad248f5c22c9, 0xd1b3400f8f9cff69}, {0x91376c36d99995be, 0x23100809b9c21fa2}, {0xb58547448ffffb2d, 0xabd40a0c2832a78b}, {0xe2e69915b3fff9f9, 0x16c90c8f323f516d}, {0x8dd01fad907ffc3b, 0xae3da7d97f6792e4}, {0xb1442798f49ffb4a, 0x99cd11cfdf41779d}, {0xdd95317f31c7fa1d, 0x40405643d711d584}, {0x8a7d3eef7f1cfc52, 0x482835ea666b2573}, {0xad1c8eab5ee43b66, 0xda3243650005eed0}, {0xd863b256369d4a40, 0x90bed43e40076a83}, {0x873e4f75e2224e68, 0x5a7744a6e804a292}, {0xa90de3535aaae202, 0x711515d0a205cb37}, {0xd3515c2831559a83, 0x0d5a5b44ca873e04}, {0x8412d9991ed58091, 0xe858790afe9486c3}, {0xa5178fff668ae0b6, 0x626e974dbe39a873}, {0xce5d73ff402d98e3, 0xfb0a3d212dc81290}, {0x80fa687f881c7f8e, 0x7ce66634bc9d0b9a}, {0xa139029f6a239f72, 0x1c1fffc1ebc44e81}, {0xc987434744ac874e, 0xa327ffb266b56221}, {0xfbe9141915d7a922, 0x4bf1ff9f0062baa9}, {0x9d71ac8fada6c9b5, 0x6f773fc3603db4aa}, {0xc4ce17b399107c22, 0xcb550fb4384d21d4}, {0xf6019da07f549b2b, 0x7e2a53a146606a49}, {0x99c102844f94e0fb, 0x2eda7444cbfc426e}, {0xc0314325637a1939, 0xfa911155fefb5309}, {0xf03d93eebc589f88, 0x793555ab7eba27cb}, {0x96267c7535b763b5, 0x4bc1558b2f3458df}, {0xbbb01b9283253ca2, 0x9eb1aaedfb016f17}, {0xea9c227723ee8bcb, 0x465e15a979c1cadd}, {0x92a1958a7675175f, 0x0bfacd89ec191eca}, {0xb749faed14125d36, 0xcef980ec671f667c}, {0xe51c79a85916f484, 0x82b7e12780e7401b}, {0x8f31cc0937ae58d2, 0xd1b2ecb8b0908811}, {0xb2fe3f0b8599ef07, 0x861fa7e6dcb4aa16}, {0xdfbdcece67006ac9, 0x67a791e093e1d49b}, {0x8bd6a141006042bd, 0xe0c8bb2c5c6d24e1}, {0xaecc49914078536d, 0x58fae9f773886e19}, {0xda7f5bf590966848, 0xaf39a475506a899f}, {0x888f99797a5e012d, 0x6d8406c952429604}, {0xaab37fd7d8f58178, 0xc8e5087ba6d33b84}, {0xd5605fcdcf32e1d6, 0xfb1e4a9a90880a65}, {0x855c3be0a17fcd26, 0x5cf2eea09a550680}, {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f}, {0xd0601d8efc57b08b, 0xf13b94daf124da27}, {0x823c12795db6ce57, 0x76c53d08d6b70859}, {0xa2cb1717b52481ed, 0x54768c4b0c64ca6f}, {0xcb7ddcdda26da268, 0xa9942f5dcf7dfd0a}, {0xfe5d54150b090b02, 0xd3f93b35435d7c4d}, {0x9efa548d26e5a6e1, 0xc47bc5014a1a6db0}, {0xc6b8e9b0709f109a, 0x359ab6419ca1091c}, {0xf867241c8cc6d4c0, 0xc30163d203c94b63}, {0x9b407691d7fc44f8, 0x79e0de63425dcf1e}, {0xc21094364dfb5636, 0x985915fc12f542e5}, {0xf294b943e17a2bc4, 0x3e6f5b7b17b2939e}, {0x979cf3ca6cec5b5a, 0xa705992ceecf9c43}, {0xbd8430bd08277231, 0x50c6ff782a838354}, {0xece53cec4a314ebd, 0xa4f8bf5635246429}, {0x940f4613ae5ed136, 0x871b7795e136be9a}, {0xb913179899f68584, 0x28e2557b59846e40}, {0xe757dd7ec07426e5, 0x331aeada2fe589d0}, {0x9096ea6f3848984f, 0x3ff0d2c85def7622}, {0xb4bca50b065abe63, 0x0fed077a756b53aa}, {0xe1ebce4dc7f16dfb, 0xd3e8495912c62895}, {0x8d3360f09cf6e4bd, 0x64712dd7abbbd95d}, {0xb080392cc4349dec, 0xbd8d794d96aacfb4}, {0xdca04777f541c567, 0xecf0d7a0fc5583a1}, {0x89e42caaf9491b60, 0xf41686c49db57245}, {0xac5d37d5b79b6239, 0x311c2875c522ced6}, {0xd77485cb25823ac7, 0x7d633293366b828c}, {0x86a8d39ef77164bc, 0xae5dff9c02033198}, {0xa8530886b54dbdeb, 0xd9f57f830283fdfd}, {0xd267caa862a12d66, 0xd072df63c324fd7c}, {0x8380dea93da4bc60, 0x4247cb9e59f71e6e}, {0xa46116538d0deb78, 0x52d9be85f074e609}, {0xcd795be870516656, 0x67902e276c921f8c}, {0x806bd9714632dff6, 0x00ba1cd8a3db53b7}, {0xa086cfcd97bf97f3, 0x80e8a40eccd228a5}, {0xc8a883c0fdaf7df0, 0x6122cd128006b2ce}, {0xfad2a4b13d1b5d6c, 0x796b805720085f82}, {0x9cc3a6eec6311a63, 0xcbe3303674053bb1}, {0xc3f490aa77bd60fc, 0xbedbfc4411068a9d}, {0xf4f1b4d515acb93b, 0xee92fb5515482d45}, {0x991711052d8bf3c5, 0x751bdd152d4d1c4b}, {0xbf5cd54678eef0b6, 0xd262d45a78a0635e}, {0xef340a98172aace4, 0x86fb897116c87c35}, {0x9580869f0e7aac0e, 0xd45d35e6ae3d4da1}, {0xbae0a846d2195712, 0x8974836059cca10a}, {0xe998d258869facd7, 0x2bd1a438703fc94c}, {0x91ff83775423cc06, 0x7b6306a34627ddd0}, {0xb67f6455292cbf08, 0x1a3bc84c17b1d543}, {0xe41f3d6a7377eeca, 0x20caba5f1d9e4a94}, {0x8e938662882af53e, 0x547eb47b7282ee9d}, {0xb23867fb2a35b28d, 0xe99e619a4f23aa44}, {0xdec681f9f4c31f31, 0x6405fa00e2ec94d5}, {0x8b3c113c38f9f37e, 0xde83bc408dd3dd05}, {0xae0b158b4738705e, 0x9624ab50b148d446}, {0xd98ddaee19068c76, 0x3badd624dd9b0958}, {0x87f8a8d4cfa417c9, 0xe54ca5d70a80e5d7}, {0xa9f6d30a038d1dbc, 0x5e9fcf4ccd211f4d}, {0xd47487cc8470652b, 0x7647c32000696720}, {0x84c8d4dfd2c63f3b, 0x29ecd9f40041e074}, {0xa5fb0a17c777cf09, 0xf468107100525891}, {0xcf79cc9db955c2cc, 0x7182148d4066eeb5}, {0x81ac1fe293d599bf, 0xc6f14cd848405531}, {0xa21727db38cb002f, 0xb8ada00e5a506a7d}, {0xca9cf1d206fdc03b, 0xa6d90811f0e4851d}, {0xfd442e4688bd304a, 0x908f4a166d1da664}, {0x9e4a9cec15763e2e, 0x9a598e4e043287ff}, {0xc5dd44271ad3cdba, 0x40eff1e1853f29fe}, {0xf7549530e188c128, 0xd12bee59e68ef47d}, {0x9a94dd3e8cf578b9, 0x82bb74f8301958cf}, {0xc13a148e3032d6e7, 0xe36a52363c1faf02}, {0xf18899b1bc3f8ca1, 0xdc44e6c3cb279ac2}, {0x96f5600f15a7b7e5, 0x29ab103a5ef8c0ba}, {0xbcb2b812db11a5de, 0x7415d448f6b6f0e8}, {0xebdf661791d60f56, 0x111b495b3464ad22}, {0x936b9fcebb25c995, 0xcab10dd900beec35}, {0xb84687c269ef3bfb, 0x3d5d514f40eea743}, {0xe65829b3046b0afa, 0x0cb4a5a3112a5113}, {0x8ff71a0fe2c2e6dc, 0x47f0e785eaba72ac}, {0xb3f4e093db73a093, 0x59ed216765690f57}, {0xe0f218b8d25088b8, 0x306869c13ec3532d}, {0x8c974f7383725573, 0x1e414218c73a13fc}, {0xafbd2350644eeacf, 0xe5d1929ef90898fb}, {0xdbac6c247d62a583, 0xdf45f746b74abf3a}, {0x894bc396ce5da772, 0x6b8bba8c328eb784}, {0xab9eb47c81f5114f, 0x066ea92f3f326565}, {0xd686619ba27255a2, 0xc80a537b0efefebe}, {0x8613fd0145877585, 0xbd06742ce95f5f37}, {0xa798fc4196e952e7, 0x2c48113823b73705}, {0xd17f3b51fca3a7a0, 0xf75a15862ca504c6}, {0x82ef85133de648c4, 0x9a984d73dbe722fc}, {0xa3ab66580d5fdaf5, 0xc13e60d0d2e0ebbb}, {0xcc963fee10b7d1b3, 0x318df905079926a9}, {0xffbbcfe994e5c61f, 0xfdf17746497f7053}, {0x9fd561f1fd0f9bd3, 0xfeb6ea8bedefa634}, {0xc7caba6e7c5382c8, 0xfe64a52ee96b8fc1}, {0xf9bd690a1b68637b, 0x3dfdce7aa3c673b1}, {0x9c1661a651213e2d, 0x06bea10ca65c084f}, {0xc31bfa0fe5698db8, 0x486e494fcff30a63}, {0xf3e2f893dec3f126, 0x5a89dba3c3efccfb}, {0x986ddb5c6b3a76b7, 0xf89629465a75e01d}, {0xbe89523386091465, 0xf6bbb397f1135824}, {0xee2ba6c0678b597f, 0x746aa07ded582e2d}, {0x94db483840b717ef, 0xa8c2a44eb4571cdd}, {0xba121a4650e4ddeb, 0x92f34d62616ce414}, {0xe896a0d7e51e1566, 0x77b020baf9c81d18}, {0x915e2486ef32cd60, 0x0ace1474dc1d122f}, {0xb5b5ada8aaff80b8, 0x0d819992132456bb}, {0xe3231912d5bf60e6, 0x10e1fff697ed6c6a}, {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2}, {0xb1736b96b6fd83b3, 0xbd308ff8a6b17cb3}, {0xddd0467c64bce4a0, 0xac7cb3f6d05ddbdf}, {0x8aa22c0dbef60ee4, 0x6bcdf07a423aa96c}, {0xad4ab7112eb3929d, 0x86c16c98d2c953c7}, {0xd89d64d57a607744, 0xe871c7bf077ba8b8}, {0x87625f056c7c4a8b, 0x11471cd764ad4973}, {0xa93af6c6c79b5d2d, 0xd598e40d3dd89bd0}, {0xd389b47879823479, 0x4aff1d108d4ec2c4}, {0x843610cb4bf160cb, 0xcedf722a585139bb}, {0xa54394fe1eedb8fe, 0xc2974eb4ee658829}, {0xce947a3da6a9273e, 0x733d226229feea33}, {0x811ccc668829b887, 0x0806357d5a3f5260}, {0xa163ff802a3426a8, 0xca07c2dcb0cf26f8}, {0xc9bcff6034c13052, 0xfc89b393dd02f0b6}, {0xfc2c3f3841f17c67, 0xbbac2078d443ace3}, {0x9d9ba7832936edc0, 0xd54b944b84aa4c0e}, {0xc5029163f384a931, 0x0a9e795e65d4df12}, {0xf64335bcf065d37d, 0x4d4617b5ff4a16d6}, {0x99ea0196163fa42e, 0x504bced1bf8e4e46}, {0xc06481fb9bcf8d39, 0xe45ec2862f71e1d7}, {0xf07da27a82c37088, 0x5d767327bb4e5a4d}, {0x964e858c91ba2655, 0x3a6a07f8d510f870}, {0xbbe226efb628afea, 0x890489f70a55368c}, {0xeadab0aba3b2dbe5, 0x2b45ac74ccea842f}, {0x92c8ae6b464fc96f, 0x3b0b8bc90012929e}, {0xb77ada0617e3bbcb, 0x09ce6ebb40173745}, {0xe55990879ddcaabd, 0xcc420a6a101d0516}, {0x8f57fa54c2a9eab6, 0x9fa946824a12232e}, {0xb32df8e9f3546564, 0x47939822dc96abfa}, {0xdff9772470297ebd, 0x59787e2b93bc56f8}, {0x8bfbea76c619ef36, 0x57eb4edb3c55b65b}, {0xaefae51477a06b03, 0xede622920b6b23f2}, {0xdab99e59958885c4, 0xe95fab368e45ecee}, {0x88b402f7fd75539b, 0x11dbcb0218ebb415}, {0xaae103b5fcd2a881, 0xd652bdc29f26a11a}, {0xd59944a37c0752a2, 0x4be76d3346f04960}, {0x857fcae62d8493a5, 0x6f70a4400c562ddc}, {0xa6dfbd9fb8e5b88e, 0xcb4ccd500f6bb953}, {0xd097ad07a71f26b2, 0x7e2000a41346a7a8}, {0x825ecc24c873782f, 0x8ed400668c0c28c9}, {0xa2f67f2dfa90563b, 0x728900802f0f32fb}, {0xcbb41ef979346bca, 0x4f2b40a03ad2ffba}, {0xfea126b7d78186bc, 0xe2f610c84987bfa9}, {0x9f24b832e6b0f436, 0x0dd9ca7d2df4d7ca}, {0xc6ede63fa05d3143, 0x91503d1c79720dbc}, {0xf8a95fcf88747d94, 0x75a44c6397ce912b}, {0x9b69dbe1b548ce7c, 0xc986afbe3ee11abb}, {0xc24452da229b021b, 0xfbe85badce996169}, {0xf2d56790ab41c2a2, 0xfae27299423fb9c4}, {0x97c560ba6b0919a5, 0xdccd879fc967d41b}, {0xbdb6b8e905cb600f, 0x5400e987bbc1c921}, {0xed246723473e3813, 0x290123e9aab23b69}, {0x9436c0760c86e30b, 0xf9a0b6720aaf6522}, {0xb94470938fa89bce, 0xf808e40e8d5b3e6a}, {0xe7958cb87392c2c2, 0xb60b1d1230b20e05}, {0x90bd77f3483bb9b9, 0xb1c6f22b5e6f48c3}, {0xb4ecd5f01a4aa828, 0x1e38aeb6360b1af4}, {0xe2280b6c20dd5232, 0x25c6da63c38de1b1}, {0x8d590723948a535f, 0x579c487e5a38ad0f}, {0xb0af48ec79ace837, 0x2d835a9df0c6d852}, {0xdcdb1b2798182244, 0xf8e431456cf88e66}, {0x8a08f0f8bf0f156b, 0x1b8e9ecb641b5900}, {0xac8b2d36eed2dac5, 0xe272467e3d222f40}, {0xd7adf884aa879177, 0x5b0ed81dcc6abb10}, {0x86ccbb52ea94baea, 0x98e947129fc2b4ea}, {0xa87fea27a539e9a5, 0x3f2398d747b36225}, {0xd29fe4b18e88640e, 0x8eec7f0d19a03aae}, {0x83a3eeeef9153e89, 0x1953cf68300424ad}, {0xa48ceaaab75a8e2b, 0x5fa8c3423c052dd8}, {0xcdb02555653131b6, 0x3792f412cb06794e}, {0x808e17555f3ebf11, 0xe2bbd88bbee40bd1}, {0xa0b19d2ab70e6ed6, 0x5b6aceaeae9d0ec5}, {0xc8de047564d20a8b, 0xf245825a5a445276}, {0xfb158592be068d2e, 0xeed6e2f0f0d56713}, {0x9ced737bb6c4183d, 0x55464dd69685606c}, {0xc428d05aa4751e4c, 0xaa97e14c3c26b887}, {0xf53304714d9265df, 0xd53dd99f4b3066a9}, {0x993fe2c6d07b7fab, 0xe546a8038efe402a}, {0xbf8fdb78849a5f96, 0xde98520472bdd034}, {0xef73d256a5c0f77c, 0x963e66858f6d4441}, {0x95a8637627989aad, 0xdde7001379a44aa9}, {0xbb127c53b17ec159, 0x5560c018580d5d53}, {0xe9d71b689dde71af, 0xaab8f01e6e10b4a7}, {0x9226712162ab070d, 0xcab3961304ca70e9}, {0xb6b00d69bb55c8d1, 0x3d607b97c5fd0d23}, {0xe45c10c42a2b3b05, 0x8cb89a7db77c506b}, {0x8eb98a7a9a5b04e3, 0x77f3608e92adb243}, {0xb267ed1940f1c61c, 0x55f038b237591ed4}, {0xdf01e85f912e37a3, 0x6b6c46dec52f6689}, {0x8b61313bbabce2c6, 0x2323ac4b3b3da016}, {0xae397d8aa96c1b77, 0xabec975e0a0d081b}, {0xd9c7dced53c72255, 0x96e7bd358c904a22}, {0x881cea14545c7575, 0x7e50d64177da2e55}, {0xaa242499697392d2, 0xdde50bd1d5d0b9ea}, {0xd4ad2dbfc3d07787, 0x955e4ec64b44e865}, {0x84ec3c97da624ab4, 0xbd5af13bef0b113f}, {0xa6274bbdd0fadd61, 0xecb1ad8aeacdd58f}, {0xcfb11ead453994ba, 0x67de18eda5814af3}, {0x81ceb32c4b43fcf4, 0x80eacf948770ced8}, {0xa2425ff75e14fc31, 0xa1258379a94d028e}, {0xcad2f7f5359a3b3e, 0x096ee45813a04331}, {0xfd87b5f28300ca0d, 0x8bca9d6e188853fd}, {0x9e74d1b791e07e48, 0x775ea264cf55347e}, {0xc612062576589dda, 0x95364afe032a819e}, {0xf79687aed3eec551, 0x3a83ddbd83f52205}, {0x9abe14cd44753b52, 0xc4926a9672793543}, {0xc16d9a0095928a27, 0x75b7053c0f178294}, {0xf1c90080baf72cb1, 0x5324c68b12dd6339}, {0x971da05074da7bee, 0xd3f6fc16ebca5e04}, {0xbce5086492111aea, 0x88f4bb1ca6bcf585}, {0xec1e4a7db69561a5, 0x2b31e9e3d06c32e6}, {0x9392ee8e921d5d07, 0x3aff322e62439fd0}, {0xb877aa3236a4b449, 0x09befeb9fad487c3}, {0xe69594bec44de15b, 0x4c2ebe687989a9b4}, {0x901d7cf73ab0acd9, 0x0f9d37014bf60a11}, {0xb424dc35095cd80f, 0x538484c19ef38c95}, {0xe12e13424bb40e13, 0x2865a5f206b06fba}, {0x8cbccc096f5088cb, 0xf93f87b7442e45d4}, {0xafebff0bcb24aafe, 0xf78f69a51539d749}, {0xdbe6fecebdedd5be, 0xb573440e5a884d1c}, {0x89705f4136b4a597, 0x31680a88f8953031}, {0xabcc77118461cefc, 0xfdc20d2b36ba7c3e}, {0xd6bf94d5e57a42bc, 0x3d32907604691b4d}, {0x8637bd05af6c69b5, 0xa63f9a49c2c1b110}, {0xa7c5ac471b478423, 0x0fcf80dc33721d54}, {0xd1b71758e219652b, 0xd3c36113404ea4a9}, {0x83126e978d4fdf3b, 0x645a1cac083126ea}, {0xa3d70a3d70a3d70a, 0x3d70a3d70a3d70a4}, {0xcccccccccccccccc, 0xcccccccccccccccd}, {0x8000000000000000, 0x0000000000000000}, {0xa000000000000000, 0x0000000000000000}, {0xc800000000000000, 0x0000000000000000}, {0xfa00000000000000, 0x0000000000000000}, {0x9c40000000000000, 0x0000000000000000}, {0xc350000000000000, 0x0000000000000000}, {0xf424000000000000, 0x0000000000000000}, {0x9896800000000000, 0x0000000000000000}, {0xbebc200000000000, 0x0000000000000000}, {0xee6b280000000000, 0x0000000000000000}, {0x9502f90000000000, 0x0000000000000000}, {0xba43b74000000000, 0x0000000000000000}, {0xe8d4a51000000000, 0x0000000000000000}, {0x9184e72a00000000, 0x0000000000000000}, {0xb5e620f480000000, 0x0000000000000000}, {0xe35fa931a0000000, 0x0000000000000000}, {0x8e1bc9bf04000000, 0x0000000000000000}, {0xb1a2bc2ec5000000, 0x0000000000000000}, {0xde0b6b3a76400000, 0x0000000000000000}, {0x8ac7230489e80000, 0x0000000000000000}, {0xad78ebc5ac620000, 0x0000000000000000}, {0xd8d726b7177a8000, 0x0000000000000000}, {0x878678326eac9000, 0x0000000000000000}, {0xa968163f0a57b400, 0x0000000000000000}, {0xd3c21bcecceda100, 0x0000000000000000}, {0x84595161401484a0, 0x0000000000000000}, {0xa56fa5b99019a5c8, 0x0000000000000000}, {0xcecb8f27f4200f3a, 0x0000000000000000}, {0x813f3978f8940984, 0x4000000000000000}, {0xa18f07d736b90be5, 0x5000000000000000}, {0xc9f2c9cd04674ede, 0xa400000000000000}, {0xfc6f7c4045812296, 0x4d00000000000000}, {0x9dc5ada82b70b59d, 0xf020000000000000}, {0xc5371912364ce305, 0x6c28000000000000}, {0xf684df56c3e01bc6, 0xc732000000000000}, {0x9a130b963a6c115c, 0x3c7f400000000000}, {0xc097ce7bc90715b3, 0x4b9f100000000000}, {0xf0bdc21abb48db20, 0x1e86d40000000000}, {0x96769950b50d88f4, 0x1314448000000000}, {0xbc143fa4e250eb31, 0x17d955a000000000}, {0xeb194f8e1ae525fd, 0x5dcfab0800000000}, {0x92efd1b8d0cf37be, 0x5aa1cae500000000}, {0xb7abc627050305ad, 0xf14a3d9e40000000}, {0xe596b7b0c643c719, 0x6d9ccd05d0000000}, {0x8f7e32ce7bea5c6f, 0xe4820023a2000000}, {0xb35dbf821ae4f38b, 0xdda2802c8a800000}, {0xe0352f62a19e306e, 0xd50b2037ad200000}, {0x8c213d9da502de45, 0x4526f422cc340000}, {0xaf298d050e4395d6, 0x9670b12b7f410000}, {0xdaf3f04651d47b4c, 0x3c0cdd765f114000}, {0x88d8762bf324cd0f, 0xa5880a69fb6ac800}, {0xab0e93b6efee0053, 0x8eea0d047a457a00}, {0xd5d238a4abe98068, 0x72a4904598d6d880}, {0x85a36366eb71f041, 0x47a6da2b7f864750}, {0xa70c3c40a64e6c51, 0x999090b65f67d924}, {0xd0cf4b50cfe20765, 0xfff4b4e3f741cf6d}, {0x82818f1281ed449f, 0xbff8f10e7a8921a5}, {0xa321f2d7226895c7, 0xaff72d52192b6a0e}, {0xcbea6f8ceb02bb39, 0x9bf4f8a69f764491}, {0xfee50b7025c36a08, 0x02f236d04753d5b5}, {0x9f4f2726179a2245, 0x01d762422c946591}, {0xc722f0ef9d80aad6, 0x424d3ad2b7b97ef6}, {0xf8ebad2b84e0d58b, 0xd2e0898765a7deb3}, {0x9b934c3b330c8577, 0x63cc55f49f88eb30}, {0xc2781f49ffcfa6d5, 0x3cbf6b71c76b25fc}, {0xf316271c7fc3908a, 0x8bef464e3945ef7b}, {0x97edd871cfda3a56, 0x97758bf0e3cbb5ad}, {0xbde94e8e43d0c8ec, 0x3d52eeed1cbea318}, {0xed63a231d4c4fb27, 0x4ca7aaa863ee4bde}, {0x945e455f24fb1cf8, 0x8fe8caa93e74ef6b}, {0xb975d6b6ee39e436, 0xb3e2fd538e122b45}, {0xe7d34c64a9c85d44, 0x60dbbca87196b617}, {0x90e40fbeea1d3a4a, 0xbc8955e946fe31ce}, {0xb51d13aea4a488dd, 0x6babab6398bdbe42}, {0xe264589a4dcdab14, 0xc696963c7eed2dd2}, {0x8d7eb76070a08aec, 0xfc1e1de5cf543ca3}, {0xb0de65388cc8ada8, 0x3b25a55f43294bcc}, {0xdd15fe86affad912, 0x49ef0eb713f39ebf}, {0x8a2dbf142dfcc7ab, 0x6e3569326c784338}, {0xacb92ed9397bf996, 0x49c2c37f07965405}, {0xd7e77a8f87daf7fb, 0xdc33745ec97be907}, {0x86f0ac99b4e8dafd, 0x69a028bb3ded71a4}, {0xa8acd7c0222311bc, 0xc40832ea0d68ce0d}, {0xd2d80db02aabd62b, 0xf50a3fa490c30191}, {0x83c7088e1aab65db, 0x792667c6da79e0fb}, {0xa4b8cab1a1563f52, 0x577001b891185939}, {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87}, {0x80b05e5ac60b6178, 0x544f8158315b05b5}, {0xa0dc75f1778e39d6, 0x696361ae3db1c722}, {0xc913936dd571c84c, 0x03bc3a19cd1e38ea}, {0xfb5878494ace3a5f, 0x04ab48a04065c724}, {0x9d174b2dcec0e47b, 0x62eb0d64283f9c77}, {0xc45d1df942711d9a, 0x3ba5d0bd324f8395}, {0xf5746577930d6500, 0xca8f44ec7ee3647a}, {0x9968bf6abbe85f20, 0x7e998b13cf4e1ecc}, {0xbfc2ef456ae276e8, 0x9e3fedd8c321a67f}, {0xefb3ab16c59b14a2, 0xc5cfe94ef3ea101f}, {0x95d04aee3b80ece5, 0xbba1f1d158724a13}, {0xbb445da9ca61281f, 0x2a8a6e45ae8edc98}, {0xea1575143cf97226, 0xf52d09d71a3293be}, {0x924d692ca61be758, 0x593c2626705f9c57}, {0xb6e0c377cfa2e12e, 0x6f8b2fb00c77836d}, {0xe498f455c38b997a, 0x0b6dfb9c0f956448}, {0x8edf98b59a373fec, 0x4724bd4189bd5ead}, {0xb2977ee300c50fe7, 0x58edec91ec2cb658}, {0xdf3d5e9bc0f653e1, 0x2f2967b66737e3ee}, {0x8b865b215899f46c, 0xbd79e0d20082ee75}, {0xae67f1e9aec07187, 0xecd8590680a3aa12}, {0xda01ee641a708de9, 0xe80e6f4820cc9496}, {0x884134fe908658b2, 0x3109058d147fdcde}, {0xaa51823e34a7eede, 0xbd4b46f0599fd416}, {0xd4e5e2cdc1d1ea96, 0x6c9e18ac7007c91b}, {0x850fadc09923329e, 0x03e2cf6bc604ddb1}, {0xa6539930bf6bff45, 0x84db8346b786151d}, {0xcfe87f7cef46ff16, 0xe612641865679a64}, {0x81f14fae158c5f6e, 0x4fcb7e8f3f60c07f}, {0xa26da3999aef7749, 0xe3be5e330f38f09e}, {0xcb090c8001ab551c, 0x5cadf5bfd3072cc6}, {0xfdcb4fa002162a63, 0x73d9732fc7c8f7f7}, {0x9e9f11c4014dda7e, 0x2867e7fddcdd9afb}, {0xc646d63501a1511d, 0xb281e1fd541501b9}, {0xf7d88bc24209a565, 0x1f225a7ca91a4227}, {0x9ae757596946075f, 0x3375788de9b06959}, {0xc1a12d2fc3978937, 0x0052d6b1641c83af}, {0xf209787bb47d6b84, 0xc0678c5dbd23a49b}, {0x9745eb4d50ce6332, 0xf840b7ba963646e1}, {0xbd176620a501fbff, 0xb650e5a93bc3d899}, {0xec5d3fa8ce427aff, 0xa3e51f138ab4cebf}, {0x93ba47c980e98cdf, 0xc66f336c36b10138}, {0xb8a8d9bbe123f017, 0xb80b0047445d4185}, {0xe6d3102ad96cec1d, 0xa60dc059157491e6}, {0x9043ea1ac7e41392, 0x87c89837ad68db30}, {0xb454e4a179dd1877, 0x29babe4598c311fc}, {0xe16a1dc9d8545e94, 0xf4296dd6fef3d67b}, {0x8ce2529e2734bb1d, 0x1899e4a65f58660d}, {0xb01ae745b101e9e4, 0x5ec05dcff72e7f90}, {0xdc21a1171d42645d, 0x76707543f4fa1f74}, {0x899504ae72497eba, 0x6a06494a791c53a9}, {0xabfa45da0edbde69, 0x0487db9d17636893}, {0xd6f8d7509292d603, 0x45a9d2845d3c42b7}, {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3}, {0xa7f26836f282b732, 0x8e6cac7768d7141f}, {0xd1ef0244af2364ff, 0x3207d795430cd927}, {0x8335616aed761f1f, 0x7f44e6bd49e807b9}, {0xa402b9c5a8d3a6e7, 0x5f16206c9c6209a7}, {0xcd036837130890a1, 0x36dba887c37a8c10}, {0x802221226be55a64, 0xc2494954da2c978a}, {0xa02aa96b06deb0fd, 0xf2db9baa10b7bd6d}, {0xc83553c5c8965d3d, 0x6f92829494e5acc8}, {0xfa42a8b73abbf48c, 0xcb772339ba1f17fa}, {0x9c69a97284b578d7, 0xff2a760414536efc}, {0xc38413cf25e2d70d, 0xfef5138519684abb}, {0xf46518c2ef5b8cd1, 0x7eb258665fc25d6a}, {0x98bf2f79d5993802, 0xef2f773ffbd97a62}, {0xbeeefb584aff8603, 0xaafb550ffacfd8fb}, {0xeeaaba2e5dbf6784, 0x95ba2a53f983cf39}, {0x952ab45cfa97a0b2, 0xdd945a747bf26184}, {0xba756174393d88df, 0x94f971119aeef9e5}, {0xe912b9d1478ceb17, 0x7a37cd5601aab85e}, {0x91abb422ccb812ee, 0xac62e055c10ab33b}, {0xb616a12b7fe617aa, 0x577b986b314d600a}, {0xe39c49765fdf9d94, 0xed5a7e85fda0b80c}, {0x8e41ade9fbebc27d, 0x14588f13be847308}, {0xb1d219647ae6b31c, 0x596eb2d8ae258fc9}, {0xde469fbd99a05fe3, 0x6fca5f8ed9aef3bc}, {0x8aec23d680043bee, 0x25de7bb9480d5855}, {0xada72ccc20054ae9, 0xaf561aa79a10ae6b}, {0xd910f7ff28069da4, 0x1b2ba1518094da05}, {0x87aa9aff79042286, 0x90fb44d2f05d0843}, {0xa99541bf57452b28, 0x353a1607ac744a54}, {0xd3fa922f2d1675f2, 0x42889b8997915ce9}, {0x847c9b5d7c2e09b7, 0x69956135febada12}, {0xa59bc234db398c25, 0x43fab9837e699096}, {0xcf02b2c21207ef2e, 0x94f967e45e03f4bc}, {0x8161afb94b44f57d, 0x1d1be0eebac278f6}, {0xa1ba1ba79e1632dc, 0x6462d92a69731733}, {0xca28a291859bbf93, 0x7d7b8f7503cfdcff}, {0xfcb2cb35e702af78, 0x5cda735244c3d43f}, {0x9defbf01b061adab, 0x3a0888136afa64a8}, {0xc56baec21c7a1916, 0x088aaa1845b8fdd1}, {0xf6c69a72a3989f5b, 0x8aad549e57273d46}, {0x9a3c2087a63f6399, 0x36ac54e2f678864c}, {0xc0cb28a98fcf3c7f, 0x84576a1bb416a7de}, {0xf0fdf2d3f3c30b9f, 0x656d44a2a11c51d6}, {0x969eb7c47859e743, 0x9f644ae5a4b1b326}, {0xbc4665b596706114, 0x873d5d9f0dde1fef}, {0xeb57ff22fc0c7959, 0xa90cb506d155a7eb}, {0x9316ff75dd87cbd8, 0x09a7f12442d588f3}, {0xb7dcbf5354e9bece, 0x0c11ed6d538aeb30}, {0xe5d3ef282a242e81, 0x8f1668c8a86da5fb}, {0x8fa475791a569d10, 0xf96e017d694487bd}, {0xb38d92d760ec4455, 0x37c981dcc395a9ad}, {0xe070f78d3927556a, 0x85bbe253f47b1418}, {0x8c469ab843b89562, 0x93956d7478ccec8f}, {0xaf58416654a6babb, 0x387ac8d1970027b3}, {0xdb2e51bfe9d0696a, 0x06997b05fcc0319f}, {0x88fcf317f22241e2, 0x441fece3bdf81f04}, {0xab3c2fddeeaad25a, 0xd527e81cad7626c4}, {0xd60b3bd56a5586f1, 0x8a71e223d8d3b075}, {0x85c7056562757456, 0xf6872d5667844e4a}, {0xa738c6bebb12d16c, 0xb428f8ac016561dc}, {0xd106f86e69d785c7, 0xe13336d701beba53}, {0x82a45b450226b39c, 0xecc0024661173474}, {0xa34d721642b06084, 0x27f002d7f95d0191}, {0xcc20ce9bd35c78a5, 0x31ec038df7b441f5}, {0xff290242c83396ce, 0x7e67047175a15272}, {0x9f79a169bd203e41, 0x0f0062c6e984d387}, {0xc75809c42c684dd1, 0x52c07b78a3e60869}, {0xf92e0c3537826145, 0xa7709a56ccdf8a83}, {0x9bbcc7a142b17ccb, 0x88a66076400bb692}, {0xc2abf989935ddbfe, 0x6acff893d00ea436}, {0xf356f7ebf83552fe, 0x0583f6b8c4124d44}, {0x98165af37b2153de, 0xc3727a337a8b704b}, {0xbe1bf1b059e9a8d6, 0x744f18c0592e4c5d}, {0xeda2ee1c7064130c, 0x1162def06f79df74}, {0x9485d4d1c63e8be7, 0x8addcb5645ac2ba9}, {0xb9a74a0637ce2ee1, 0x6d953e2bd7173693}, {0xe8111c87c5c1ba99, 0xc8fa8db6ccdd0438}, {0x910ab1d4db9914a0, 0x1d9c9892400a22a3}, {0xb54d5e4a127f59c8, 0x2503beb6d00cab4c}, {0xe2a0b5dc971f303a, 0x2e44ae64840fd61e}, {0x8da471a9de737e24, 0x5ceaecfed289e5d3}, {0xb10d8e1456105dad, 0x7425a83e872c5f48}, {0xdd50f1996b947518, 0xd12f124e28f7771a}, {0x8a5296ffe33cc92f, 0x82bd6b70d99aaa70}, {0xace73cbfdc0bfb7b, 0x636cc64d1001550c}, {0xd8210befd30efa5a, 0x3c47f7e05401aa4f}, {0x8714a775e3e95c78, 0x65acfaec34810a72}, {0xa8d9d1535ce3b396, 0x7f1839a741a14d0e}, {0xd31045a8341ca07c, 0x1ede48111209a051}, {0x83ea2b892091e44d, 0x934aed0aab460433}, {0xa4e4b66b68b65d60, 0xf81da84d56178540}, {0xce1de40642e3f4b9, 0x36251260ab9d668f}, {0x80d2ae83e9ce78f3, 0xc1d72b7c6b42601a}, {0xa1075a24e4421730, 0xb24cf65b8612f820}, {0xc94930ae1d529cfc, 0xdee033f26797b628}, {0xfb9b7cd9a4a7443c, 0x169840ef017da3b2}, {0x9d412e0806e88aa5, 0x8e1f289560ee864f}, {0xc491798a08a2ad4e, 0xf1a6f2bab92a27e3}, {0xf5b5d7ec8acb58a2, 0xae10af696774b1dc}, {0x9991a6f3d6bf1765, 0xacca6da1e0a8ef2a}, {0xbff610b0cc6edd3f, 0x17fd090a58d32af4}, {0xeff394dcff8a948e, 0xddfc4b4cef07f5b1}, {0x95f83d0a1fb69cd9, 0x4abdaf101564f98f}, {0xbb764c4ca7a4440f, 0x9d6d1ad41abe37f2}, {0xea53df5fd18d5513, 0x84c86189216dc5ee}, {0x92746b9be2f8552c, 0x32fd3cf5b4e49bb5}, {0xb7118682dbb66a77, 0x3fbc8c33221dc2a2}, {0xe4d5e82392a40515, 0x0fabaf3feaa5334b}, {0x8f05b1163ba6832d, 0x29cb4d87f2a7400f}, {0xb2c71d5bca9023f8, 0x743e20e9ef511013}, {0xdf78e4b2bd342cf6, 0x914da9246b255417}, {0x8bab8eefb6409c1a, 0x1ad089b6c2f7548f}, {0xae9672aba3d0c320, 0xa184ac2473b529b2}, {0xda3c0f568cc4f3e8, 0xc9e5d72d90a2741f}, {0x8865899617fb1871, 0x7e2fa67c7a658893}, {0xaa7eebfb9df9de8d, 0xddbb901b98feeab8}, {0xd51ea6fa85785631, 0x552a74227f3ea566}, {0x8533285c936b35de, 0xd53a88958f872760}, {0xa67ff273b8460356, 0x8a892abaf368f138}, {0xd01fef10a657842c, 0x2d2b7569b0432d86}, {0x8213f56a67f6b29b, 0x9c3b29620e29fc74}, {0xa298f2c501f45f42, 0x8349f3ba91b47b90}, {0xcb3f2f7642717713, 0x241c70a936219a74}, {0xfe0efb53d30dd4d7, 0xed238cd383aa0111}, {0x9ec95d1463e8a506, 0xf4363804324a40ab}, {0xc67bb4597ce2ce48, 0xb143c6053edcd0d6}, {0xf81aa16fdc1b81da, 0xdd94b7868e94050b}, {0x9b10a4e5e9913128, 0xca7cf2b4191c8327}, {0xc1d4ce1f63f57d72, 0xfd1c2f611f63a3f1}, {0xf24a01a73cf2dccf, 0xbc633b39673c8ced}, {0x976e41088617ca01, 0xd5be0503e085d814}, {0xbd49d14aa79dbc82, 0x4b2d8644d8a74e19}, {0xec9c459d51852ba2, 0xddf8e7d60ed1219f}, {0x93e1ab8252f33b45, 0xcabb90e5c942b504}, {0xb8da1662e7b00a17, 0x3d6a751f3b936244}, {0xe7109bfba19c0c9d, 0x0cc512670a783ad5}, {0x906a617d450187e2, 0x27fb2b80668b24c6}, {0xb484f9dc9641e9da, 0xb1f9f660802dedf7}, {0xe1a63853bbd26451, 0x5e7873f8a0396974}, {0x8d07e33455637eb2, 0xdb0b487b6423e1e9}, {0xb049dc016abc5e5f, 0x91ce1a9a3d2cda63}, {0xdc5c5301c56b75f7, 0x7641a140cc7810fc}, {0x89b9b3e11b6329ba, 0xa9e904c87fcb0a9e}, {0xac2820d9623bf429, 0x546345fa9fbdcd45}, {0xd732290fbacaf133, 0xa97c177947ad4096}, {0x867f59a9d4bed6c0, 0x49ed8eabcccc485e}, {0xa81f301449ee8c70, 0x5c68f256bfff5a75}, {0xd226fc195c6a2f8c, 0x73832eec6fff3112}, {0x83585d8fd9c25db7, 0xc831fd53c5ff7eac}, {0xa42e74f3d032f525, 0xba3e7ca8b77f5e56}, {0xcd3a1230c43fb26f, 0x28ce1bd2e55f35ec}, {0x80444b5e7aa7cf85, 0x7980d163cf5b81b4}, {0xa0555e361951c366, 0xd7e105bcc3326220}, {0xc86ab5c39fa63440, 0x8dd9472bf3fefaa8}, {0xfa856334878fc150, 0xb14f98f6f0feb952}, {0x9c935e00d4b9d8d2, 0x6ed1bf9a569f33d4}, {0xc3b8358109e84f07, 0x0a862f80ec4700c9}, {0xf4a642e14c6262c8, 0xcd27bb612758c0fb}, {0x98e7e9cccfbd7dbd, 0x8038d51cb897789d}, {0xbf21e44003acdd2c, 0xe0470a63e6bd56c4}, {0xeeea5d5004981478, 0x1858ccfce06cac75}, {0x95527a5202df0ccb, 0x0f37801e0c43ebc9}, {0xbaa718e68396cffd, 0xd30560258f54e6bb}, {0xe950df20247c83fd, 0x47c6b82ef32a206a}, {0x91d28b7416cdd27e, 0x4cdc331d57fa5442}, {0xb6472e511c81471d, 0xe0133fe4adf8e953}, {0xe3d8f9e563a198e5, 0x58180fddd97723a7}, {0x8e679c2f5e44ff8f, 0x570f09eaa7ea7649}, {0xb201833b35d63f73, 0x2cd2cc6551e513db}, {0xde81e40a034bcf4f, 0xf8077f7ea65e58d2}, {0x8b112e86420f6191, 0xfb04afaf27faf783}, {0xadd57a27d29339f6, 0x79c5db9af1f9b564}, {0xd94ad8b1c7380874, 0x18375281ae7822bd}, {0x87cec76f1c830548, 0x8f2293910d0b15b6}, {0xa9c2794ae3a3c69a, 0xb2eb3875504ddb23}, {0xd433179d9c8cb841, 0x5fa60692a46151ec}, {0x849feec281d7f328, 0xdbc7c41ba6bcd334}, {0xa5c7ea73224deff3, 0x12b9b522906c0801}, {0xcf39e50feae16bef, 0xd768226b34870a01}, {0x81842f29f2cce375, 0xe6a1158300d46641}, {0xa1e53af46f801c53, 0x60495ae3c1097fd1}, {0xca5e89b18b602368, 0x385bb19cb14bdfc5}, {0xfcf62c1dee382c42, 0x46729e03dd9ed7b6}, {0x9e19db92b4e31ba9, 0x6c07a2c26a8346d2}, {0xc5a05277621be293, 0xc7098b7305241886}, {0xf70867153aa2db38, 0xb8cbee4fc66d1ea8}, {0x9a65406d44a5c903, 0x737f74f1dc043329}, {0xc0fe908895cf3b44, 0x505f522e53053ff3}, {0xf13e34aabb430a15, 0x647726b9e7c68ff0}, {0x96c6e0eab509e64d, 0x5eca783430dc19f6}, {0xbc789925624c5fe0, 0xb67d16413d132073}, {0xeb96bf6ebadf77d8, 0xe41c5bd18c57e890}, {0x933e37a534cbaae7, 0x8e91b962f7b6f15a}, {0xb80dc58e81fe95a1, 0x723627bbb5a4adb1}, {0xe61136f2227e3b09, 0xcec3b1aaa30dd91d}, {0x8fcac257558ee4e6, 0x213a4f0aa5e8a7b2}, {0xb3bd72ed2af29e1f, 0xa988e2cd4f62d19e}, {0xe0accfa875af45a7, 0x93eb1b80a33b8606}, {0x8c6c01c9498d8b88, 0xbc72f130660533c4}, {0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5}, {0xdb68c2ca82ed2a05, 0xa67398db9f6820e2}, #else {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b}, {0xce5d73ff402d98e3, 0xfb0a3d212dc81290}, {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f}, {0x86a8d39ef77164bc, 0xae5dff9c02033198}, {0xd98ddaee19068c76, 0x3badd624dd9b0958}, {0xafbd2350644eeacf, 0xe5d1929ef90898fb}, {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2}, {0xe55990879ddcaabd, 0xcc420a6a101d0516}, {0xb94470938fa89bce, 0xf808e40e8d5b3e6a}, {0x95a8637627989aad, 0xdde7001379a44aa9}, {0xf1c90080baf72cb1, 0x5324c68b12dd6339}, {0xc350000000000000, 0x0000000000000000}, {0x9dc5ada82b70b59d, 0xf020000000000000}, {0xfee50b7025c36a08, 0x02f236d04753d5b5}, {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87}, {0xa6539930bf6bff45, 0x84db8346b786151d}, {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3}, {0xd910f7ff28069da4, 0x1b2ba1518094da05}, {0xaf58416654a6babb, 0x387ac8d1970027b3}, {0x8da471a9de737e24, 0x5ceaecfed289e5d3}, {0xe4d5e82392a40515, 0x0fabaf3feaa5334b}, {0xb8da1662e7b00a17, 0x3d6a751f3b936244}, {0x95527a5202df0ccb, 0x0f37801e0c43ebc9}, {0xf13e34aabb430a15, 0x647726b9e7c68ff0} #endif }; #if FMT_USE_FULL_CACHE_DRAGONBOX return pow10_significands[k - float_info::min_k]; #else static constexpr const uint64_t powers_of_5_64[] = { 0x0000000000000001, 0x0000000000000005, 0x0000000000000019, 0x000000000000007d, 0x0000000000000271, 0x0000000000000c35, 0x0000000000003d09, 0x000000000001312d, 0x000000000005f5e1, 0x00000000001dcd65, 0x00000000009502f9, 0x0000000002e90edd, 0x000000000e8d4a51, 0x0000000048c27395, 0x000000016bcc41e9, 0x000000071afd498d, 0x0000002386f26fc1, 0x000000b1a2bc2ec5, 0x000003782dace9d9, 0x00001158e460913d, 0x000056bc75e2d631, 0x0001b1ae4d6e2ef5, 0x000878678326eac9, 0x002a5a058fc295ed, 0x00d3c21bcecceda1, 0x0422ca8b0a00a425, 0x14adf4b7320334b9}; static const int compression_ratio = 27; // Compute base index. int cache_index = (k - float_info::min_k) / compression_ratio; int kb = cache_index * compression_ratio + float_info::min_k; int offset = k - kb; // Get base cache. uint128_fallback base_cache = pow10_significands[cache_index]; if (offset == 0) return base_cache; // Compute the required amount of bit-shift. int alpha = floor_log2_pow10(kb + offset) - floor_log2_pow10(kb) - offset; FMT_ASSERT(alpha > 0 && alpha < 64, "shifting error detected"); // Try to recover the real cache. uint64_t pow5 = powers_of_5_64[offset]; uint128_fallback recovered_cache = umul128(base_cache.high(), pow5); uint128_fallback middle_low = umul128(base_cache.low(), pow5); recovered_cache += middle_low.high(); uint64_t high_to_middle = recovered_cache.high() << (64 - alpha); uint64_t middle_to_low = recovered_cache.low() << (64 - alpha); recovered_cache = uint128_fallback{(recovered_cache.low() >> alpha) | high_to_middle, ((middle_low.low() >> alpha) | middle_to_low)}; FMT_ASSERT(recovered_cache.low() + 1 != 0, ""); return {recovered_cache.high(), recovered_cache.low() + 1}; #endif } struct compute_mul_result { carrier_uint result; bool is_integer; }; struct compute_mul_parity_result { bool parity; bool is_integer; }; static auto compute_mul(carrier_uint u, const cache_entry_type& cache) noexcept -> compute_mul_result { auto r = umul192_upper128(u, cache); return {r.high(), r.low() == 0}; } static auto compute_delta(cache_entry_type const& cache, int beta) noexcept -> uint32_t { return static_cast(cache.high() >> (64 - 1 - beta)); } static auto compute_mul_parity(carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept -> compute_mul_parity_result { FMT_ASSERT(beta >= 1, ""); FMT_ASSERT(beta < 64, ""); auto r = umul192_lower128(two_f, cache); return {((r.high() >> (64 - beta)) & 1) != 0, ((r.high() << beta) | (r.low() >> (64 - beta))) == 0}; } static auto compute_left_endpoint_for_shorter_interval_case( const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return (cache.high() - (cache.high() >> (num_significand_bits() + 2))) >> (64 - num_significand_bits() - 1 - beta); } static auto compute_right_endpoint_for_shorter_interval_case( const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return (cache.high() + (cache.high() >> (num_significand_bits() + 1))) >> (64 - num_significand_bits() - 1 - beta); } static auto compute_round_up_for_shorter_interval_case( const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return ((cache.high() >> (64 - num_significand_bits() - 2 - beta)) + 1) / 2; } }; FMT_FUNC auto get_cached_power(int k) noexcept -> uint128_fallback { return cache_accessor::get_cached_power(k); } // Various integer checks template auto is_left_endpoint_integer_shorter_interval(int exponent) noexcept -> bool { const int case_shorter_interval_left_endpoint_lower_threshold = 2; const int case_shorter_interval_left_endpoint_upper_threshold = 3; return exponent >= case_shorter_interval_left_endpoint_lower_threshold && exponent <= case_shorter_interval_left_endpoint_upper_threshold; } // Remove trailing zeros from n and return the number of zeros removed (float) FMT_INLINE int remove_trailing_zeros(uint32_t& n, int s = 0) noexcept { FMT_ASSERT(n != 0, ""); // Modular inverse of 5 (mod 2^32): (mod_inv_5 * 5) mod 2^32 = 1. constexpr uint32_t mod_inv_5 = 0xcccccccd; constexpr uint32_t mod_inv_25 = 0xc28f5c29; // = mod_inv_5 * mod_inv_5 while (true) { auto q = rotr(n * mod_inv_25, 2); if (q > max_value() / 100) break; n = q; s += 2; } auto q = rotr(n * mod_inv_5, 1); if (q <= max_value() / 10) { n = q; s |= 1; } return s; } // Removes trailing zeros and returns the number of zeros removed (double) FMT_INLINE int remove_trailing_zeros(uint64_t& n) noexcept { FMT_ASSERT(n != 0, ""); // This magic number is ceil(2^90 / 10^8). constexpr uint64_t magic_number = 12379400392853802749ull; auto nm = umul128(n, magic_number); // Is n is divisible by 10^8? if ((nm.high() & ((1ull << (90 - 64)) - 1)) == 0 && nm.low() < magic_number) { // If yes, work with the quotient... auto n32 = static_cast(nm.high() >> (90 - 64)); // ... and use the 32 bit variant of the function int s = remove_trailing_zeros(n32, 8); n = n32; return s; } // If n is not divisible by 10^8, work with n itself. constexpr uint64_t mod_inv_5 = 0xcccccccccccccccd; constexpr uint64_t mod_inv_25 = 0x8f5c28f5c28f5c29; // mod_inv_5 * mod_inv_5 int s = 0; while (true) { auto q = rotr(n * mod_inv_25, 2); if (q > max_value() / 100) break; n = q; s += 2; } auto q = rotr(n * mod_inv_5, 1); if (q <= max_value() / 10) { n = q; s |= 1; } return s; } // The main algorithm for shorter interval case template FMT_INLINE decimal_fp shorter_interval_case(int exponent) noexcept { decimal_fp ret_value; // Compute k and beta const int minus_k = floor_log10_pow2_minus_log10_4_over_3(exponent); const int beta = exponent + floor_log2_pow10(-minus_k); // Compute xi and zi using cache_entry_type = typename cache_accessor::cache_entry_type; const cache_entry_type cache = cache_accessor::get_cached_power(-minus_k); auto xi = cache_accessor::compute_left_endpoint_for_shorter_interval_case( cache, beta); auto zi = cache_accessor::compute_right_endpoint_for_shorter_interval_case( cache, beta); // If the left endpoint is not an integer, increase it if (!is_left_endpoint_integer_shorter_interval(exponent)) ++xi; // Try bigger divisor ret_value.significand = zi / 10; // If succeed, remove trailing zeros if necessary and return if (ret_value.significand * 10 >= xi) { ret_value.exponent = minus_k + 1; ret_value.exponent += remove_trailing_zeros(ret_value.significand); return ret_value; } // Otherwise, compute the round-up of y ret_value.significand = cache_accessor::compute_round_up_for_shorter_interval_case(cache, beta); ret_value.exponent = minus_k; // When tie occurs, choose one of them according to the rule if (exponent >= float_info::shorter_interval_tie_lower_threshold && exponent <= float_info::shorter_interval_tie_upper_threshold) { ret_value.significand = ret_value.significand % 2 == 0 ? ret_value.significand : ret_value.significand - 1; } else if (ret_value.significand < xi) { ++ret_value.significand; } return ret_value; } template auto to_decimal(T x) noexcept -> decimal_fp { // Step 1: integer promotion & Schubfach multiplier calculation. using carrier_uint = typename float_info::carrier_uint; using cache_entry_type = typename cache_accessor::cache_entry_type; auto br = bit_cast(x); // Extract significand bits and exponent bits. const carrier_uint significand_mask = (static_cast(1) << num_significand_bits()) - 1; carrier_uint significand = (br & significand_mask); int exponent = static_cast((br & exponent_mask()) >> num_significand_bits()); if (exponent != 0) { // Check if normal. exponent -= exponent_bias() + num_significand_bits(); // Shorter interval case; proceed like Schubfach. // In fact, when exponent == 1 and significand == 0, the interval is // regular. However, it can be shown that the end-results are anyway same. if (significand == 0) return shorter_interval_case(exponent); significand |= (static_cast(1) << num_significand_bits()); } else { // Subnormal case; the interval is always regular. if (significand == 0) return {0, 0}; exponent = std::numeric_limits::min_exponent - num_significand_bits() - 1; } const bool include_left_endpoint = (significand % 2 == 0); const bool include_right_endpoint = include_left_endpoint; // Compute k and beta. const int minus_k = floor_log10_pow2(exponent) - float_info::kappa; const cache_entry_type cache = cache_accessor::get_cached_power(-minus_k); const int beta = exponent + floor_log2_pow10(-minus_k); // Compute zi and deltai. // 10^kappa <= deltai < 10^(kappa + 1) const uint32_t deltai = cache_accessor::compute_delta(cache, beta); const carrier_uint two_fc = significand << 1; // For the case of binary32, the result of integer check is not correct for // 29711844 * 2^-82 // = 6.1442653300000000008655037797566933477355632930994033813476... * 10^-18 // and 29711844 * 2^-81 // = 1.2288530660000000001731007559513386695471126586198806762695... * 10^-17, // and they are the unique counterexamples. However, since 29711844 is even, // this does not cause any problem for the endpoints calculations; it can only // cause a problem when we need to perform integer check for the center. // Fortunately, with these inputs, that branch is never executed, so we are // fine. const typename cache_accessor::compute_mul_result z_mul = cache_accessor::compute_mul((two_fc | 1) << beta, cache); // Step 2: Try larger divisor; remove trailing zeros if necessary. // Using an upper bound on zi, we might be able to optimize the division // better than the compiler; we are computing zi / big_divisor here. decimal_fp ret_value; ret_value.significand = divide_by_10_to_kappa_plus_1(z_mul.result); uint32_t r = static_cast(z_mul.result - float_info::big_divisor * ret_value.significand); if (r < deltai) { // Exclude the right endpoint if necessary. if (r == 0 && (z_mul.is_integer & !include_right_endpoint)) { --ret_value.significand; r = float_info::big_divisor; goto small_divisor_case_label; } } else if (r > deltai) { goto small_divisor_case_label; } else { // r == deltai; compare fractional parts. const typename cache_accessor::compute_mul_parity_result x_mul = cache_accessor::compute_mul_parity(two_fc - 1, cache, beta); if (!(x_mul.parity | (x_mul.is_integer & include_left_endpoint))) goto small_divisor_case_label; } ret_value.exponent = minus_k + float_info::kappa + 1; // We may need to remove trailing zeros. ret_value.exponent += remove_trailing_zeros(ret_value.significand); return ret_value; // Step 3: Find the significand with the smaller divisor. small_divisor_case_label: ret_value.significand *= 10; ret_value.exponent = minus_k + float_info::kappa; uint32_t dist = r - (deltai / 2) + (float_info::small_divisor / 2); const bool approx_y_parity = ((dist ^ (float_info::small_divisor / 2)) & 1) != 0; // Is dist divisible by 10^kappa? const bool divisible_by_small_divisor = check_divisibility_and_divide_by_pow10::kappa>(dist); // Add dist / 10^kappa to the significand. ret_value.significand += dist; if (!divisible_by_small_divisor) return ret_value; // Check z^(f) >= epsilon^(f). // We have either yi == zi - epsiloni or yi == (zi - epsiloni) - 1, // where yi == zi - epsiloni if and only if z^(f) >= epsilon^(f). // Since there are only 2 possibilities, we only need to care about the // parity. Also, zi and r should have the same parity since the divisor // is an even number. const auto y_mul = cache_accessor::compute_mul_parity(two_fc, cache, beta); // If z^(f) >= epsilon^(f), we might have a tie when z^(f) == epsilon^(f), // or equivalently, when y is an integer. if (y_mul.parity != approx_y_parity) --ret_value.significand; else if (y_mul.is_integer & (ret_value.significand % 2 != 0)) --ret_value.significand; return ret_value; } } // namespace dragonbox } // namespace detail template <> struct formatter { FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> format_parse_context::iterator { return ctx.begin(); } auto format(const detail::bigint& n, format_context& ctx) const -> format_context::iterator { auto out = ctx.out(); bool first = true; for (auto i = n.bigits_.size(); i > 0; --i) { auto value = n.bigits_[i - 1u]; if (first) { out = fmt::format_to(out, FMT_STRING("{:x}"), value); first = false; continue; } out = fmt::format_to(out, FMT_STRING("{:08x}"), value); } if (n.exp_ > 0) out = fmt::format_to(out, FMT_STRING("p{}"), n.exp_ * detail::bigint::bigit_bits); return out; } }; FMT_FUNC detail::utf8_to_utf16::utf8_to_utf16(string_view s) { for_each_codepoint(s, [this](uint32_t cp, string_view) { if (cp == invalid_code_point) FMT_THROW(std::runtime_error("invalid utf8")); if (cp <= 0xFFFF) { buffer_.push_back(static_cast(cp)); } else { cp -= 0x10000; buffer_.push_back(static_cast(0xD800 + (cp >> 10))); buffer_.push_back(static_cast(0xDC00 + (cp & 0x3FF))); } return true; }); buffer_.push_back(0); } FMT_FUNC void format_system_error(detail::buffer& out, int error_code, const char* message) noexcept { FMT_TRY { auto ec = std::error_code(error_code, std::generic_category()); write(std::back_inserter(out), std::system_error(ec, message).what()); return; } FMT_CATCH(...) {} format_error_code(out, error_code, message); } FMT_FUNC void report_system_error(int error_code, const char* message) noexcept { report_error(format_system_error, error_code, message); } FMT_FUNC auto vformat(string_view fmt, format_args args) -> std::string { // Don't optimize the "{}" case to keep the binary size small and because it // can be better optimized in fmt::format anyway. auto buffer = memory_buffer(); detail::vformat_to(buffer, fmt, args); return to_string(buffer); } namespace detail { #if !defined(_WIN32) || defined(FMT_WINDOWS_NO_WCHAR) FMT_FUNC auto write_console(int, string_view) -> bool { return false; } FMT_FUNC auto write_console(std::FILE*, string_view) -> bool { return false; } #else using dword = conditional_t; extern "C" __declspec(dllimport) int __stdcall WriteConsoleW( // void*, const void*, dword, dword*, void*); FMT_FUNC bool write_console(int fd, string_view text) { auto u16 = utf8_to_utf16(text); return WriteConsoleW(reinterpret_cast(_get_osfhandle(fd)), u16.c_str(), static_cast(u16.size()), nullptr, nullptr) != 0; } FMT_FUNC auto write_console(std::FILE* f, string_view text) -> bool { return write_console(_fileno(f), text); } #endif #ifdef _WIN32 // Print assuming legacy (non-Unicode) encoding. FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args) { auto buffer = memory_buffer(); detail::vformat_to(buffer, fmt, args); fwrite_fully(buffer.data(), buffer.size(), f); } #endif FMT_FUNC void print(std::FILE* f, string_view text) { #ifdef _WIN32 int fd = _fileno(f); if (_isatty(fd)) { std::fflush(f); if (write_console(fd, text)) return; } #endif fwrite_fully(text.data(), text.size(), f); } } // namespace detail FMT_FUNC void vprint(std::FILE* f, string_view fmt, format_args args) { auto buffer = memory_buffer(); detail::vformat_to(buffer, fmt, args); detail::print(f, {buffer.data(), buffer.size()}); } FMT_FUNC void vprint(string_view fmt, format_args args) { vprint(stdout, fmt, args); } namespace detail { struct singleton { unsigned char upper; unsigned char lower_count; }; inline auto is_printable(uint16_t x, const singleton* singletons, size_t singletons_size, const unsigned char* singleton_lowers, const unsigned char* normal, size_t normal_size) -> bool { auto upper = x >> 8; auto lower_start = 0; for (size_t i = 0; i < singletons_size; ++i) { auto s = singletons[i]; auto lower_end = lower_start + s.lower_count; if (upper < s.upper) break; if (upper == s.upper) { for (auto j = lower_start; j < lower_end; ++j) { if (singleton_lowers[j] == (x & 0xff)) return false; } } lower_start = lower_end; } auto xsigned = static_cast(x); auto current = true; for (size_t i = 0; i < normal_size; ++i) { auto v = static_cast(normal[i]); auto len = (v & 0x80) != 0 ? (v & 0x7f) << 8 | normal[++i] : v; xsigned -= len; if (xsigned < 0) break; current = !current; } return current; } // This code is generated by support/printable.py. FMT_FUNC auto is_printable(uint32_t cp) -> bool { static constexpr singleton singletons0[] = { {0x00, 1}, {0x03, 5}, {0x05, 6}, {0x06, 3}, {0x07, 6}, {0x08, 8}, {0x09, 17}, {0x0a, 28}, {0x0b, 25}, {0x0c, 20}, {0x0d, 16}, {0x0e, 13}, {0x0f, 4}, {0x10, 3}, {0x12, 18}, {0x13, 9}, {0x16, 1}, {0x17, 5}, {0x18, 2}, {0x19, 3}, {0x1a, 7}, {0x1c, 2}, {0x1d, 1}, {0x1f, 22}, {0x20, 3}, {0x2b, 3}, {0x2c, 2}, {0x2d, 11}, {0x2e, 1}, {0x30, 3}, {0x31, 2}, {0x32, 1}, {0xa7, 2}, {0xa9, 2}, {0xaa, 4}, {0xab, 8}, {0xfa, 2}, {0xfb, 5}, {0xfd, 4}, {0xfe, 3}, {0xff, 9}, }; static constexpr unsigned char singletons0_lower[] = { 0xad, 0x78, 0x79, 0x8b, 0x8d, 0xa2, 0x30, 0x57, 0x58, 0x8b, 0x8c, 0x90, 0x1c, 0x1d, 0xdd, 0x0e, 0x0f, 0x4b, 0x4c, 0xfb, 0xfc, 0x2e, 0x2f, 0x3f, 0x5c, 0x5d, 0x5f, 0xb5, 0xe2, 0x84, 0x8d, 0x8e, 0x91, 0x92, 0xa9, 0xb1, 0xba, 0xbb, 0xc5, 0xc6, 0xc9, 0xca, 0xde, 0xe4, 0xe5, 0xff, 0x00, 0x04, 0x11, 0x12, 0x29, 0x31, 0x34, 0x37, 0x3a, 0x3b, 0x3d, 0x49, 0x4a, 0x5d, 0x84, 0x8e, 0x92, 0xa9, 0xb1, 0xb4, 0xba, 0xbb, 0xc6, 0xca, 0xce, 0xcf, 0xe4, 0xe5, 0x00, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a, 0x3b, 0x45, 0x46, 0x49, 0x4a, 0x5e, 0x64, 0x65, 0x84, 0x91, 0x9b, 0x9d, 0xc9, 0xce, 0xcf, 0x0d, 0x11, 0x29, 0x45, 0x49, 0x57, 0x64, 0x65, 0x8d, 0x91, 0xa9, 0xb4, 0xba, 0xbb, 0xc5, 0xc9, 0xdf, 0xe4, 0xe5, 0xf0, 0x0d, 0x11, 0x45, 0x49, 0x64, 0x65, 0x80, 0x84, 0xb2, 0xbc, 0xbe, 0xbf, 0xd5, 0xd7, 0xf0, 0xf1, 0x83, 0x85, 0x8b, 0xa4, 0xa6, 0xbe, 0xbf, 0xc5, 0xc7, 0xce, 0xcf, 0xda, 0xdb, 0x48, 0x98, 0xbd, 0xcd, 0xc6, 0xce, 0xcf, 0x49, 0x4e, 0x4f, 0x57, 0x59, 0x5e, 0x5f, 0x89, 0x8e, 0x8f, 0xb1, 0xb6, 0xb7, 0xbf, 0xc1, 0xc6, 0xc7, 0xd7, 0x11, 0x16, 0x17, 0x5b, 0x5c, 0xf6, 0xf7, 0xfe, 0xff, 0x80, 0x0d, 0x6d, 0x71, 0xde, 0xdf, 0x0e, 0x0f, 0x1f, 0x6e, 0x6f, 0x1c, 0x1d, 0x5f, 0x7d, 0x7e, 0xae, 0xaf, 0xbb, 0xbc, 0xfa, 0x16, 0x17, 0x1e, 0x1f, 0x46, 0x47, 0x4e, 0x4f, 0x58, 0x5a, 0x5c, 0x5e, 0x7e, 0x7f, 0xb5, 0xc5, 0xd4, 0xd5, 0xdc, 0xf0, 0xf1, 0xf5, 0x72, 0x73, 0x8f, 0x74, 0x75, 0x96, 0x2f, 0x5f, 0x26, 0x2e, 0x2f, 0xa7, 0xaf, 0xb7, 0xbf, 0xc7, 0xcf, 0xd7, 0xdf, 0x9a, 0x40, 0x97, 0x98, 0x30, 0x8f, 0x1f, 0xc0, 0xc1, 0xce, 0xff, 0x4e, 0x4f, 0x5a, 0x5b, 0x07, 0x08, 0x0f, 0x10, 0x27, 0x2f, 0xee, 0xef, 0x6e, 0x6f, 0x37, 0x3d, 0x3f, 0x42, 0x45, 0x90, 0x91, 0xfe, 0xff, 0x53, 0x67, 0x75, 0xc8, 0xc9, 0xd0, 0xd1, 0xd8, 0xd9, 0xe7, 0xfe, 0xff, }; static constexpr singleton singletons1[] = { {0x00, 6}, {0x01, 1}, {0x03, 1}, {0x04, 2}, {0x08, 8}, {0x09, 2}, {0x0a, 5}, {0x0b, 2}, {0x0e, 4}, {0x10, 1}, {0x11, 2}, {0x12, 5}, {0x13, 17}, {0x14, 1}, {0x15, 2}, {0x17, 2}, {0x19, 13}, {0x1c, 5}, {0x1d, 8}, {0x24, 1}, {0x6a, 3}, {0x6b, 2}, {0xbc, 2}, {0xd1, 2}, {0xd4, 12}, {0xd5, 9}, {0xd6, 2}, {0xd7, 2}, {0xda, 1}, {0xe0, 5}, {0xe1, 2}, {0xe8, 2}, {0xee, 32}, {0xf0, 4}, {0xf8, 2}, {0xf9, 2}, {0xfa, 2}, {0xfb, 1}, }; static constexpr unsigned char singletons1_lower[] = { 0x0c, 0x27, 0x3b, 0x3e, 0x4e, 0x4f, 0x8f, 0x9e, 0x9e, 0x9f, 0x06, 0x07, 0x09, 0x36, 0x3d, 0x3e, 0x56, 0xf3, 0xd0, 0xd1, 0x04, 0x14, 0x18, 0x36, 0x37, 0x56, 0x57, 0x7f, 0xaa, 0xae, 0xaf, 0xbd, 0x35, 0xe0, 0x12, 0x87, 0x89, 0x8e, 0x9e, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a, 0x45, 0x46, 0x49, 0x4a, 0x4e, 0x4f, 0x64, 0x65, 0x5c, 0xb6, 0xb7, 0x1b, 0x1c, 0x07, 0x08, 0x0a, 0x0b, 0x14, 0x17, 0x36, 0x39, 0x3a, 0xa8, 0xa9, 0xd8, 0xd9, 0x09, 0x37, 0x90, 0x91, 0xa8, 0x07, 0x0a, 0x3b, 0x3e, 0x66, 0x69, 0x8f, 0x92, 0x6f, 0x5f, 0xee, 0xef, 0x5a, 0x62, 0x9a, 0x9b, 0x27, 0x28, 0x55, 0x9d, 0xa0, 0xa1, 0xa3, 0xa4, 0xa7, 0xa8, 0xad, 0xba, 0xbc, 0xc4, 0x06, 0x0b, 0x0c, 0x15, 0x1d, 0x3a, 0x3f, 0x45, 0x51, 0xa6, 0xa7, 0xcc, 0xcd, 0xa0, 0x07, 0x19, 0x1a, 0x22, 0x25, 0x3e, 0x3f, 0xc5, 0xc6, 0x04, 0x20, 0x23, 0x25, 0x26, 0x28, 0x33, 0x38, 0x3a, 0x48, 0x4a, 0x4c, 0x50, 0x53, 0x55, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x63, 0x65, 0x66, 0x6b, 0x73, 0x78, 0x7d, 0x7f, 0x8a, 0xa4, 0xaa, 0xaf, 0xb0, 0xc0, 0xd0, 0xae, 0xaf, 0x79, 0xcc, 0x6e, 0x6f, 0x93, }; static constexpr unsigned char normal0[] = { 0x00, 0x20, 0x5f, 0x22, 0x82, 0xdf, 0x04, 0x82, 0x44, 0x08, 0x1b, 0x04, 0x06, 0x11, 0x81, 0xac, 0x0e, 0x80, 0xab, 0x35, 0x28, 0x0b, 0x80, 0xe0, 0x03, 0x19, 0x08, 0x01, 0x04, 0x2f, 0x04, 0x34, 0x04, 0x07, 0x03, 0x01, 0x07, 0x06, 0x07, 0x11, 0x0a, 0x50, 0x0f, 0x12, 0x07, 0x55, 0x07, 0x03, 0x04, 0x1c, 0x0a, 0x09, 0x03, 0x08, 0x03, 0x07, 0x03, 0x02, 0x03, 0x03, 0x03, 0x0c, 0x04, 0x05, 0x03, 0x0b, 0x06, 0x01, 0x0e, 0x15, 0x05, 0x3a, 0x03, 0x11, 0x07, 0x06, 0x05, 0x10, 0x07, 0x57, 0x07, 0x02, 0x07, 0x15, 0x0d, 0x50, 0x04, 0x43, 0x03, 0x2d, 0x03, 0x01, 0x04, 0x11, 0x06, 0x0f, 0x0c, 0x3a, 0x04, 0x1d, 0x25, 0x5f, 0x20, 0x6d, 0x04, 0x6a, 0x25, 0x80, 0xc8, 0x05, 0x82, 0xb0, 0x03, 0x1a, 0x06, 0x82, 0xfd, 0x03, 0x59, 0x07, 0x15, 0x0b, 0x17, 0x09, 0x14, 0x0c, 0x14, 0x0c, 0x6a, 0x06, 0x0a, 0x06, 0x1a, 0x06, 0x59, 0x07, 0x2b, 0x05, 0x46, 0x0a, 0x2c, 0x04, 0x0c, 0x04, 0x01, 0x03, 0x31, 0x0b, 0x2c, 0x04, 0x1a, 0x06, 0x0b, 0x03, 0x80, 0xac, 0x06, 0x0a, 0x06, 0x21, 0x3f, 0x4c, 0x04, 0x2d, 0x03, 0x74, 0x08, 0x3c, 0x03, 0x0f, 0x03, 0x3c, 0x07, 0x38, 0x08, 0x2b, 0x05, 0x82, 0xff, 0x11, 0x18, 0x08, 0x2f, 0x11, 0x2d, 0x03, 0x20, 0x10, 0x21, 0x0f, 0x80, 0x8c, 0x04, 0x82, 0x97, 0x19, 0x0b, 0x15, 0x88, 0x94, 0x05, 0x2f, 0x05, 0x3b, 0x07, 0x02, 0x0e, 0x18, 0x09, 0x80, 0xb3, 0x2d, 0x74, 0x0c, 0x80, 0xd6, 0x1a, 0x0c, 0x05, 0x80, 0xff, 0x05, 0x80, 0xdf, 0x0c, 0xee, 0x0d, 0x03, 0x84, 0x8d, 0x03, 0x37, 0x09, 0x81, 0x5c, 0x14, 0x80, 0xb8, 0x08, 0x80, 0xcb, 0x2a, 0x38, 0x03, 0x0a, 0x06, 0x38, 0x08, 0x46, 0x08, 0x0c, 0x06, 0x74, 0x0b, 0x1e, 0x03, 0x5a, 0x04, 0x59, 0x09, 0x80, 0x83, 0x18, 0x1c, 0x0a, 0x16, 0x09, 0x4c, 0x04, 0x80, 0x8a, 0x06, 0xab, 0xa4, 0x0c, 0x17, 0x04, 0x31, 0xa1, 0x04, 0x81, 0xda, 0x26, 0x07, 0x0c, 0x05, 0x05, 0x80, 0xa5, 0x11, 0x81, 0x6d, 0x10, 0x78, 0x28, 0x2a, 0x06, 0x4c, 0x04, 0x80, 0x8d, 0x04, 0x80, 0xbe, 0x03, 0x1b, 0x03, 0x0f, 0x0d, }; static constexpr unsigned char normal1[] = { 0x5e, 0x22, 0x7b, 0x05, 0x03, 0x04, 0x2d, 0x03, 0x66, 0x03, 0x01, 0x2f, 0x2e, 0x80, 0x82, 0x1d, 0x03, 0x31, 0x0f, 0x1c, 0x04, 0x24, 0x09, 0x1e, 0x05, 0x2b, 0x05, 0x44, 0x04, 0x0e, 0x2a, 0x80, 0xaa, 0x06, 0x24, 0x04, 0x24, 0x04, 0x28, 0x08, 0x34, 0x0b, 0x01, 0x80, 0x90, 0x81, 0x37, 0x09, 0x16, 0x0a, 0x08, 0x80, 0x98, 0x39, 0x03, 0x63, 0x08, 0x09, 0x30, 0x16, 0x05, 0x21, 0x03, 0x1b, 0x05, 0x01, 0x40, 0x38, 0x04, 0x4b, 0x05, 0x2f, 0x04, 0x0a, 0x07, 0x09, 0x07, 0x40, 0x20, 0x27, 0x04, 0x0c, 0x09, 0x36, 0x03, 0x3a, 0x05, 0x1a, 0x07, 0x04, 0x0c, 0x07, 0x50, 0x49, 0x37, 0x33, 0x0d, 0x33, 0x07, 0x2e, 0x08, 0x0a, 0x81, 0x26, 0x52, 0x4e, 0x28, 0x08, 0x2a, 0x56, 0x1c, 0x14, 0x17, 0x09, 0x4e, 0x04, 0x1e, 0x0f, 0x43, 0x0e, 0x19, 0x07, 0x0a, 0x06, 0x48, 0x08, 0x27, 0x09, 0x75, 0x0b, 0x3f, 0x41, 0x2a, 0x06, 0x3b, 0x05, 0x0a, 0x06, 0x51, 0x06, 0x01, 0x05, 0x10, 0x03, 0x05, 0x80, 0x8b, 0x62, 0x1e, 0x48, 0x08, 0x0a, 0x80, 0xa6, 0x5e, 0x22, 0x45, 0x0b, 0x0a, 0x06, 0x0d, 0x13, 0x39, 0x07, 0x0a, 0x36, 0x2c, 0x04, 0x10, 0x80, 0xc0, 0x3c, 0x64, 0x53, 0x0c, 0x48, 0x09, 0x0a, 0x46, 0x45, 0x1b, 0x48, 0x08, 0x53, 0x1d, 0x39, 0x81, 0x07, 0x46, 0x0a, 0x1d, 0x03, 0x47, 0x49, 0x37, 0x03, 0x0e, 0x08, 0x0a, 0x06, 0x39, 0x07, 0x0a, 0x81, 0x36, 0x19, 0x80, 0xb7, 0x01, 0x0f, 0x32, 0x0d, 0x83, 0x9b, 0x66, 0x75, 0x0b, 0x80, 0xc4, 0x8a, 0xbc, 0x84, 0x2f, 0x8f, 0xd1, 0x82, 0x47, 0xa1, 0xb9, 0x82, 0x39, 0x07, 0x2a, 0x04, 0x02, 0x60, 0x26, 0x0a, 0x46, 0x0a, 0x28, 0x05, 0x13, 0x82, 0xb0, 0x5b, 0x65, 0x4b, 0x04, 0x39, 0x07, 0x11, 0x40, 0x05, 0x0b, 0x02, 0x0e, 0x97, 0xf8, 0x08, 0x84, 0xd6, 0x2a, 0x09, 0xa2, 0xf7, 0x81, 0x1f, 0x31, 0x03, 0x11, 0x04, 0x08, 0x81, 0x8c, 0x89, 0x04, 0x6b, 0x05, 0x0d, 0x03, 0x09, 0x07, 0x10, 0x93, 0x60, 0x80, 0xf6, 0x0a, 0x73, 0x08, 0x6e, 0x17, 0x46, 0x80, 0x9a, 0x14, 0x0c, 0x57, 0x09, 0x19, 0x80, 0x87, 0x81, 0x47, 0x03, 0x85, 0x42, 0x0f, 0x15, 0x85, 0x50, 0x2b, 0x80, 0xd5, 0x2d, 0x03, 0x1a, 0x04, 0x02, 0x81, 0x70, 0x3a, 0x05, 0x01, 0x85, 0x00, 0x80, 0xd7, 0x29, 0x4c, 0x04, 0x0a, 0x04, 0x02, 0x83, 0x11, 0x44, 0x4c, 0x3d, 0x80, 0xc2, 0x3c, 0x06, 0x01, 0x04, 0x55, 0x05, 0x1b, 0x34, 0x02, 0x81, 0x0e, 0x2c, 0x04, 0x64, 0x0c, 0x56, 0x0a, 0x80, 0xae, 0x38, 0x1d, 0x0d, 0x2c, 0x04, 0x09, 0x07, 0x02, 0x0e, 0x06, 0x80, 0x9a, 0x83, 0xd8, 0x08, 0x0d, 0x03, 0x0d, 0x03, 0x74, 0x0c, 0x59, 0x07, 0x0c, 0x14, 0x0c, 0x04, 0x38, 0x08, 0x0a, 0x06, 0x28, 0x08, 0x22, 0x4e, 0x81, 0x54, 0x0c, 0x15, 0x03, 0x03, 0x05, 0x07, 0x09, 0x19, 0x07, 0x07, 0x09, 0x03, 0x0d, 0x07, 0x29, 0x80, 0xcb, 0x25, 0x0a, 0x84, 0x06, }; auto lower = static_cast(cp); if (cp < 0x10000) { return is_printable(lower, singletons0, sizeof(singletons0) / sizeof(*singletons0), singletons0_lower, normal0, sizeof(normal0)); } if (cp < 0x20000) { return is_printable(lower, singletons1, sizeof(singletons1) / sizeof(*singletons1), singletons1_lower, normal1, sizeof(normal1)); } if (0x2a6de <= cp && cp < 0x2a700) return false; if (0x2b735 <= cp && cp < 0x2b740) return false; if (0x2b81e <= cp && cp < 0x2b820) return false; if (0x2cea2 <= cp && cp < 0x2ceb0) return false; if (0x2ebe1 <= cp && cp < 0x2f800) return false; if (0x2fa1e <= cp && cp < 0x30000) return false; if (0x3134b <= cp && cp < 0xe0100) return false; if (0xe01f0 <= cp && cp < 0x110000) return false; return cp < 0x110000; } } // namespace detail FMT_END_NAMESPACE #endif // FMT_FORMAT_INL_H_ RcppSpdlog/inst/include/spdlog/fmt/bundled/format.h0000644000176200001440000050135414612604314022074 0ustar liggesusers/* Formatting library for C++ Copyright (c) 2012 - present, Victor Zverovich Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. --- Optional exception to the license --- As an exception, if, as a result of your compiling your source code, portions of this Software are embedded into a machine-executable object form of such source code, you may redistribute such embedded portions in such object form without including the above copyright and permission notices. */ #ifndef FMT_FORMAT_H_ #define FMT_FORMAT_H_ #include // std::signbit #include // uint32_t #include // std::memcpy #include // std::initializer_list #include // std::numeric_limits #include // std::uninitialized_copy #include // std::runtime_error #include // std::system_error #ifdef __cpp_lib_bit_cast # include // std::bit_cast #endif #include "core.h" #if defined __cpp_inline_variables && __cpp_inline_variables >= 201606L # define FMT_INLINE_VARIABLE inline #else # define FMT_INLINE_VARIABLE #endif #if FMT_HAS_CPP17_ATTRIBUTE(fallthrough) # define FMT_FALLTHROUGH [[fallthrough]] #elif defined(__clang__) # define FMT_FALLTHROUGH [[clang::fallthrough]] #elif FMT_GCC_VERSION >= 700 && \ (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 520) # define FMT_FALLTHROUGH [[gnu::fallthrough]] #else # define FMT_FALLTHROUGH #endif #ifndef FMT_DEPRECATED # if FMT_HAS_CPP14_ATTRIBUTE(deprecated) || FMT_MSC_VERSION >= 1900 # define FMT_DEPRECATED [[deprecated]] # else # if (defined(__GNUC__) && !defined(__LCC__)) || defined(__clang__) # define FMT_DEPRECATED __attribute__((deprecated)) # elif FMT_MSC_VERSION # define FMT_DEPRECATED __declspec(deprecated) # else # define FMT_DEPRECATED /* deprecated */ # endif # endif #endif #ifndef FMT_NO_UNIQUE_ADDRESS # if FMT_CPLUSPLUS >= 202002L # if FMT_HAS_CPP_ATTRIBUTE(no_unique_address) # define FMT_NO_UNIQUE_ADDRESS [[no_unique_address]] // VS2019 v16.10 and later except clang-cl (https://reviews.llvm.org/D110485) # elif (FMT_MSC_VERSION >= 1929) && !FMT_CLANG_VERSION # define FMT_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]] # endif # endif #endif #ifndef FMT_NO_UNIQUE_ADDRESS # define FMT_NO_UNIQUE_ADDRESS #endif // Visibility when compiled as a shared library/object. #if defined(FMT_LIB_EXPORT) || defined(FMT_SHARED) # define FMT_SO_VISIBILITY(value) FMT_VISIBILITY(value) #else # define FMT_SO_VISIBILITY(value) #endif #ifdef __has_builtin # define FMT_HAS_BUILTIN(x) __has_builtin(x) #else # define FMT_HAS_BUILTIN(x) 0 #endif #if FMT_GCC_VERSION || FMT_CLANG_VERSION # define FMT_NOINLINE __attribute__((noinline)) #else # define FMT_NOINLINE #endif #ifndef FMT_THROW # if FMT_EXCEPTIONS # if FMT_MSC_VERSION || defined(__NVCC__) FMT_BEGIN_NAMESPACE namespace detail { template inline void do_throw(const Exception& x) { // Silence unreachable code warnings in MSVC and NVCC because these // are nearly impossible to fix in a generic code. volatile bool b = true; if (b) throw x; } } // namespace detail FMT_END_NAMESPACE # define FMT_THROW(x) detail::do_throw(x) # else # define FMT_THROW(x) throw x # endif # else # define FMT_THROW(x) \ ::fmt::detail::assert_fail(__FILE__, __LINE__, (x).what()) # endif #endif #if FMT_EXCEPTIONS # define FMT_TRY try # define FMT_CATCH(x) catch (x) #else # define FMT_TRY if (true) # define FMT_CATCH(x) if (false) #endif #ifndef FMT_MAYBE_UNUSED # if FMT_HAS_CPP17_ATTRIBUTE(maybe_unused) # define FMT_MAYBE_UNUSED [[maybe_unused]] # else # define FMT_MAYBE_UNUSED # endif #endif #ifndef FMT_USE_USER_DEFINED_LITERALS // EDG based compilers (Intel, NVIDIA, Elbrus, etc), GCC and MSVC support UDLs. // // GCC before 4.9 requires a space in `operator"" _a` which is invalid in later // compiler versions. # if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 409 || \ FMT_MSC_VERSION >= 1900) && \ (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= /* UDL feature */ 480) # define FMT_USE_USER_DEFINED_LITERALS 1 # else # define FMT_USE_USER_DEFINED_LITERALS 0 # endif #endif // Defining FMT_REDUCE_INT_INSTANTIATIONS to 1, will reduce the number of // integer formatter template instantiations to just one by only using the // largest integer type. This results in a reduction in binary size but will // cause a decrease in integer formatting performance. #if !defined(FMT_REDUCE_INT_INSTANTIATIONS) # define FMT_REDUCE_INT_INSTANTIATIONS 0 #endif // __builtin_clz is broken in clang with Microsoft CodeGen: // https://github.com/fmtlib/fmt/issues/519. #if !FMT_MSC_VERSION # if FMT_HAS_BUILTIN(__builtin_clz) || FMT_GCC_VERSION || FMT_ICC_VERSION # define FMT_BUILTIN_CLZ(n) __builtin_clz(n) # endif # if FMT_HAS_BUILTIN(__builtin_clzll) || FMT_GCC_VERSION || FMT_ICC_VERSION # define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n) # endif #endif // __builtin_ctz is broken in Intel Compiler Classic on Windows: // https://github.com/fmtlib/fmt/issues/2510. #ifndef __ICL # if FMT_HAS_BUILTIN(__builtin_ctz) || FMT_GCC_VERSION || FMT_ICC_VERSION || \ defined(__NVCOMPILER) # define FMT_BUILTIN_CTZ(n) __builtin_ctz(n) # endif # if FMT_HAS_BUILTIN(__builtin_ctzll) || FMT_GCC_VERSION || \ FMT_ICC_VERSION || defined(__NVCOMPILER) # define FMT_BUILTIN_CTZLL(n) __builtin_ctzll(n) # endif #endif #if FMT_MSC_VERSION # include // _BitScanReverse[64], _BitScanForward[64], _umul128 #endif // Some compilers masquerade as both MSVC and GCC-likes or otherwise support // __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the // MSVC intrinsics if the clz and clzll builtins are not available. #if FMT_MSC_VERSION && !defined(FMT_BUILTIN_CLZLL) && \ !defined(FMT_BUILTIN_CTZLL) FMT_BEGIN_NAMESPACE namespace detail { // Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning. # if !defined(__clang__) # pragma intrinsic(_BitScanForward) # pragma intrinsic(_BitScanReverse) # if defined(_WIN64) # pragma intrinsic(_BitScanForward64) # pragma intrinsic(_BitScanReverse64) # endif # endif inline auto clz(uint32_t x) -> int { unsigned long r = 0; _BitScanReverse(&r, x); FMT_ASSERT(x != 0, ""); // Static analysis complains about using uninitialized data // "r", but the only way that can happen is if "x" is 0, // which the callers guarantee to not happen. FMT_MSC_WARNING(suppress : 6102) return 31 ^ static_cast(r); } # define FMT_BUILTIN_CLZ(n) detail::clz(n) inline auto clzll(uint64_t x) -> int { unsigned long r = 0; # ifdef _WIN64 _BitScanReverse64(&r, x); # else // Scan the high 32 bits. if (_BitScanReverse(&r, static_cast(x >> 32))) return 63 ^ static_cast(r + 32); // Scan the low 32 bits. _BitScanReverse(&r, static_cast(x)); # endif FMT_ASSERT(x != 0, ""); FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. return 63 ^ static_cast(r); } # define FMT_BUILTIN_CLZLL(n) detail::clzll(n) inline auto ctz(uint32_t x) -> int { unsigned long r = 0; _BitScanForward(&r, x); FMT_ASSERT(x != 0, ""); FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. return static_cast(r); } # define FMT_BUILTIN_CTZ(n) detail::ctz(n) inline auto ctzll(uint64_t x) -> int { unsigned long r = 0; FMT_ASSERT(x != 0, ""); FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. # ifdef _WIN64 _BitScanForward64(&r, x); # else // Scan the low 32 bits. if (_BitScanForward(&r, static_cast(x))) return static_cast(r); // Scan the high 32 bits. _BitScanForward(&r, static_cast(x >> 32)); r += 32; # endif return static_cast(r); } # define FMT_BUILTIN_CTZLL(n) detail::ctzll(n) } // namespace detail FMT_END_NAMESPACE #endif FMT_BEGIN_NAMESPACE namespace detail { FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) { ignore_unused(condition); #ifdef FMT_FUZZ if (condition) throw std::runtime_error("fuzzing limit reached"); #endif } template struct string_literal { static constexpr CharT value[sizeof...(C)] = {C...}; constexpr operator basic_string_view() const { return {value, sizeof...(C)}; } }; #if FMT_CPLUSPLUS < 201703L template constexpr CharT string_literal::value[sizeof...(C)]; #endif // Implementation of std::bit_cast for pre-C++20. template FMT_CONSTEXPR20 auto bit_cast(const From& from) -> To { #ifdef __cpp_lib_bit_cast if (is_constant_evaluated()) return std::bit_cast(from); #endif auto to = To(); // The cast suppresses a bogus -Wclass-memaccess on GCC. std::memcpy(static_cast(&to), &from, sizeof(to)); return to; } inline auto is_big_endian() -> bool { #ifdef _WIN32 return false; #elif defined(__BIG_ENDIAN__) return true; #elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) return __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__; #else struct bytes { char data[sizeof(int)]; }; return bit_cast(1).data[0] == 0; #endif } class uint128_fallback { private: uint64_t lo_, hi_; public: constexpr uint128_fallback(uint64_t hi, uint64_t lo) : lo_(lo), hi_(hi) {} constexpr uint128_fallback(uint64_t value = 0) : lo_(value), hi_(0) {} constexpr auto high() const noexcept -> uint64_t { return hi_; } constexpr auto low() const noexcept -> uint64_t { return lo_; } template ::value)> constexpr explicit operator T() const { return static_cast(lo_); } friend constexpr auto operator==(const uint128_fallback& lhs, const uint128_fallback& rhs) -> bool { return lhs.hi_ == rhs.hi_ && lhs.lo_ == rhs.lo_; } friend constexpr auto operator!=(const uint128_fallback& lhs, const uint128_fallback& rhs) -> bool { return !(lhs == rhs); } friend constexpr auto operator>(const uint128_fallback& lhs, const uint128_fallback& rhs) -> bool { return lhs.hi_ != rhs.hi_ ? lhs.hi_ > rhs.hi_ : lhs.lo_ > rhs.lo_; } friend constexpr auto operator|(const uint128_fallback& lhs, const uint128_fallback& rhs) -> uint128_fallback { return {lhs.hi_ | rhs.hi_, lhs.lo_ | rhs.lo_}; } friend constexpr auto operator&(const uint128_fallback& lhs, const uint128_fallback& rhs) -> uint128_fallback { return {lhs.hi_ & rhs.hi_, lhs.lo_ & rhs.lo_}; } friend constexpr auto operator~(const uint128_fallback& n) -> uint128_fallback { return {~n.hi_, ~n.lo_}; } friend auto operator+(const uint128_fallback& lhs, const uint128_fallback& rhs) -> uint128_fallback { auto result = uint128_fallback(lhs); result += rhs; return result; } friend auto operator*(const uint128_fallback& lhs, uint32_t rhs) -> uint128_fallback { FMT_ASSERT(lhs.hi_ == 0, ""); uint64_t hi = (lhs.lo_ >> 32) * rhs; uint64_t lo = (lhs.lo_ & ~uint32_t()) * rhs; uint64_t new_lo = (hi << 32) + lo; return {(hi >> 32) + (new_lo < lo ? 1 : 0), new_lo}; } friend auto operator-(const uint128_fallback& lhs, uint64_t rhs) -> uint128_fallback { return {lhs.hi_ - (lhs.lo_ < rhs ? 1 : 0), lhs.lo_ - rhs}; } FMT_CONSTEXPR auto operator>>(int shift) const -> uint128_fallback { if (shift == 64) return {0, hi_}; if (shift > 64) return uint128_fallback(0, hi_) >> (shift - 64); return {hi_ >> shift, (hi_ << (64 - shift)) | (lo_ >> shift)}; } FMT_CONSTEXPR auto operator<<(int shift) const -> uint128_fallback { if (shift == 64) return {lo_, 0}; if (shift > 64) return uint128_fallback(lo_, 0) << (shift - 64); return {hi_ << shift | (lo_ >> (64 - shift)), (lo_ << shift)}; } FMT_CONSTEXPR auto operator>>=(int shift) -> uint128_fallback& { return *this = *this >> shift; } FMT_CONSTEXPR void operator+=(uint128_fallback n) { uint64_t new_lo = lo_ + n.lo_; uint64_t new_hi = hi_ + n.hi_ + (new_lo < lo_ ? 1 : 0); FMT_ASSERT(new_hi >= hi_, ""); lo_ = new_lo; hi_ = new_hi; } FMT_CONSTEXPR void operator&=(uint128_fallback n) { lo_ &= n.lo_; hi_ &= n.hi_; } FMT_CONSTEXPR20 auto operator+=(uint64_t n) noexcept -> uint128_fallback& { if (is_constant_evaluated()) { lo_ += n; hi_ += (lo_ < n ? 1 : 0); return *this; } #if FMT_HAS_BUILTIN(__builtin_addcll) && !defined(__ibmxl__) unsigned long long carry; lo_ = __builtin_addcll(lo_, n, 0, &carry); hi_ += carry; #elif FMT_HAS_BUILTIN(__builtin_ia32_addcarryx_u64) && !defined(__ibmxl__) unsigned long long result; auto carry = __builtin_ia32_addcarryx_u64(0, lo_, n, &result); lo_ = result; hi_ += carry; #elif defined(_MSC_VER) && defined(_M_X64) auto carry = _addcarry_u64(0, lo_, n, &lo_); _addcarry_u64(carry, hi_, 0, &hi_); #else lo_ += n; hi_ += (lo_ < n ? 1 : 0); #endif return *this; } }; using uint128_t = conditional_t; #ifdef UINTPTR_MAX using uintptr_t = ::uintptr_t; #else using uintptr_t = uint128_t; #endif // Returns the largest possible value for type T. Same as // std::numeric_limits::max() but shorter and not affected by the max macro. template constexpr auto max_value() -> T { return (std::numeric_limits::max)(); } template constexpr auto num_bits() -> int { return std::numeric_limits::digits; } // std::numeric_limits::digits may return 0 for 128-bit ints. template <> constexpr auto num_bits() -> int { return 128; } template <> constexpr auto num_bits() -> int { return 128; } // A heterogeneous bit_cast used for converting 96-bit long double to uint128_t // and 128-bit pointers to uint128_fallback. template sizeof(From))> inline auto bit_cast(const From& from) -> To { constexpr auto size = static_cast(sizeof(From) / sizeof(unsigned)); struct data_t { unsigned value[static_cast(size)]; } data = bit_cast(from); auto result = To(); if (const_check(is_big_endian())) { for (int i = 0; i < size; ++i) result = (result << num_bits()) | data.value[i]; } else { for (int i = size - 1; i >= 0; --i) result = (result << num_bits()) | data.value[i]; } return result; } template FMT_CONSTEXPR20 inline auto countl_zero_fallback(UInt n) -> int { int lz = 0; constexpr UInt msb_mask = static_cast(1) << (num_bits() - 1); for (; (n & msb_mask) == 0; n <<= 1) lz++; return lz; } FMT_CONSTEXPR20 inline auto countl_zero(uint32_t n) -> int { #ifdef FMT_BUILTIN_CLZ if (!is_constant_evaluated()) return FMT_BUILTIN_CLZ(n); #endif return countl_zero_fallback(n); } FMT_CONSTEXPR20 inline auto countl_zero(uint64_t n) -> int { #ifdef FMT_BUILTIN_CLZLL if (!is_constant_evaluated()) return FMT_BUILTIN_CLZLL(n); #endif return countl_zero_fallback(n); } FMT_INLINE void assume(bool condition) { (void)condition; #if FMT_HAS_BUILTIN(__builtin_assume) && !FMT_ICC_VERSION __builtin_assume(condition); #elif FMT_GCC_VERSION if (!condition) __builtin_unreachable(); #endif } // An approximation of iterator_t for pre-C++20 systems. template using iterator_t = decltype(std::begin(std::declval())); template using sentinel_t = decltype(std::end(std::declval())); // A workaround for std::string not having mutable data() until C++17. template inline auto get_data(std::basic_string& s) -> Char* { return &s[0]; } template inline auto get_data(Container& c) -> typename Container::value_type* { return c.data(); } // Attempts to reserve space for n extra characters in the output range. // Returns a pointer to the reserved range or a reference to it. template ::value)> #if FMT_CLANG_VERSION >= 307 && !FMT_ICC_VERSION __attribute__((no_sanitize("undefined"))) #endif inline auto reserve(std::back_insert_iterator it, size_t n) -> typename Container::value_type* { Container& c = get_container(it); size_t size = c.size(); c.resize(size + n); return get_data(c) + size; } template inline auto reserve(buffer_appender it, size_t n) -> buffer_appender { buffer& buf = get_container(it); buf.try_reserve(buf.size() + n); return it; } template constexpr auto reserve(Iterator& it, size_t) -> Iterator& { return it; } template using reserve_iterator = remove_reference_t(), 0))>; template constexpr auto to_pointer(OutputIt, size_t) -> T* { return nullptr; } template auto to_pointer(buffer_appender it, size_t n) -> T* { buffer& buf = get_container(it); auto size = buf.size(); if (buf.capacity() < size + n) return nullptr; buf.try_resize(size + n); return buf.data() + size; } template ::value)> inline auto base_iterator(std::back_insert_iterator it, typename Container::value_type*) -> std::back_insert_iterator { return it; } template constexpr auto base_iterator(Iterator, Iterator it) -> Iterator { return it; } // is spectacularly slow to compile in C++20 so use a simple fill_n // instead (#1998). template FMT_CONSTEXPR auto fill_n(OutputIt out, Size count, const T& value) -> OutputIt { for (Size i = 0; i < count; ++i) *out++ = value; return out; } template FMT_CONSTEXPR20 auto fill_n(T* out, Size count, char value) -> T* { if (is_constant_evaluated()) { return fill_n(out, count, value); } std::memset(out, value, to_unsigned(count)); return out + count; } #ifdef __cpp_char8_t using char8_type = char8_t; #else enum char8_type : unsigned char {}; #endif template FMT_CONSTEXPR FMT_NOINLINE auto copy_str_noinline(InputIt begin, InputIt end, OutputIt out) -> OutputIt { return copy_str(begin, end, out); } // A public domain branchless UTF-8 decoder by Christopher Wellons: // https://github.com/skeeto/branchless-utf8 /* Decode the next character, c, from s, reporting errors in e. * * Since this is a branchless decoder, four bytes will be read from the * buffer regardless of the actual length of the next character. This * means the buffer _must_ have at least three bytes of zero padding * following the end of the data stream. * * Errors are reported in e, which will be non-zero if the parsed * character was somehow invalid: invalid byte sequence, non-canonical * encoding, or a surrogate half. * * The function returns a pointer to the next character. When an error * occurs, this pointer will be a guess that depends on the particular * error, but it will always advance at least one byte. */ FMT_CONSTEXPR inline auto utf8_decode(const char* s, uint32_t* c, int* e) -> const char* { constexpr const int masks[] = {0x00, 0x7f, 0x1f, 0x0f, 0x07}; constexpr const uint32_t mins[] = {4194304, 0, 128, 2048, 65536}; constexpr const int shiftc[] = {0, 18, 12, 6, 0}; constexpr const int shifte[] = {0, 6, 4, 2, 0}; int len = "\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\0\0\0\0\0\0\0\2\2\2\2\3\3\4" [static_cast(*s) >> 3]; // Compute the pointer to the next character early so that the next // iteration can start working on the next character. Neither Clang // nor GCC figure out this reordering on their own. const char* next = s + len + !len; using uchar = unsigned char; // Assume a four-byte character and load four bytes. Unused bits are // shifted out. *c = uint32_t(uchar(s[0]) & masks[len]) << 18; *c |= uint32_t(uchar(s[1]) & 0x3f) << 12; *c |= uint32_t(uchar(s[2]) & 0x3f) << 6; *c |= uint32_t(uchar(s[3]) & 0x3f) << 0; *c >>= shiftc[len]; // Accumulate the various error conditions. *e = (*c < mins[len]) << 6; // non-canonical encoding *e |= ((*c >> 11) == 0x1b) << 7; // surrogate half? *e |= (*c > 0x10FFFF) << 8; // out of range? *e |= (uchar(s[1]) & 0xc0) >> 2; *e |= (uchar(s[2]) & 0xc0) >> 4; *e |= uchar(s[3]) >> 6; *e ^= 0x2a; // top two bits of each tail byte correct? *e >>= shifte[len]; return next; } constexpr FMT_INLINE_VARIABLE uint32_t invalid_code_point = ~uint32_t(); // Invokes f(cp, sv) for every code point cp in s with sv being the string view // corresponding to the code point. cp is invalid_code_point on error. template FMT_CONSTEXPR void for_each_codepoint(string_view s, F f) { auto decode = [f](const char* buf_ptr, const char* ptr) { auto cp = uint32_t(); auto error = 0; auto end = utf8_decode(buf_ptr, &cp, &error); bool result = f(error ? invalid_code_point : cp, string_view(ptr, error ? 1 : to_unsigned(end - buf_ptr))); return result ? (error ? buf_ptr + 1 : end) : nullptr; }; auto p = s.data(); const size_t block_size = 4; // utf8_decode always reads blocks of 4 chars. if (s.size() >= block_size) { for (auto end = p + s.size() - block_size + 1; p < end;) { p = decode(p, p); if (!p) return; } } if (auto num_chars_left = s.data() + s.size() - p) { char buf[2 * block_size - 1] = {}; copy_str(p, p + num_chars_left, buf); const char* buf_ptr = buf; do { auto end = decode(buf_ptr, p); if (!end) return; p += end - buf_ptr; buf_ptr = end; } while (buf_ptr - buf < num_chars_left); } } template inline auto compute_width(basic_string_view s) -> size_t { return s.size(); } // Computes approximate display width of a UTF-8 string. FMT_CONSTEXPR inline auto compute_width(string_view s) -> size_t { size_t num_code_points = 0; // It is not a lambda for compatibility with C++14. struct count_code_points { size_t* count; FMT_CONSTEXPR auto operator()(uint32_t cp, string_view) const -> bool { *count += detail::to_unsigned( 1 + (cp >= 0x1100 && (cp <= 0x115f || // Hangul Jamo init. consonants cp == 0x2329 || // LEFT-POINTING ANGLE BRACKET cp == 0x232a || // RIGHT-POINTING ANGLE BRACKET // CJK ... Yi except IDEOGRAPHIC HALF FILL SPACE: (cp >= 0x2e80 && cp <= 0xa4cf && cp != 0x303f) || (cp >= 0xac00 && cp <= 0xd7a3) || // Hangul Syllables (cp >= 0xf900 && cp <= 0xfaff) || // CJK Compatibility Ideographs (cp >= 0xfe10 && cp <= 0xfe19) || // Vertical Forms (cp >= 0xfe30 && cp <= 0xfe6f) || // CJK Compatibility Forms (cp >= 0xff00 && cp <= 0xff60) || // Fullwidth Forms (cp >= 0xffe0 && cp <= 0xffe6) || // Fullwidth Forms (cp >= 0x20000 && cp <= 0x2fffd) || // CJK (cp >= 0x30000 && cp <= 0x3fffd) || // Miscellaneous Symbols and Pictographs + Emoticons: (cp >= 0x1f300 && cp <= 0x1f64f) || // Supplemental Symbols and Pictographs: (cp >= 0x1f900 && cp <= 0x1f9ff)))); return true; } }; // We could avoid branches by using utf8_decode directly. for_each_codepoint(s, count_code_points{&num_code_points}); return num_code_points; } inline auto compute_width(basic_string_view s) -> size_t { return compute_width( string_view(reinterpret_cast(s.data()), s.size())); } template inline auto code_point_index(basic_string_view s, size_t n) -> size_t { size_t size = s.size(); return n < size ? n : size; } // Calculates the index of the nth code point in a UTF-8 string. inline auto code_point_index(string_view s, size_t n) -> size_t { size_t result = s.size(); const char* begin = s.begin(); for_each_codepoint(s, [begin, &n, &result](uint32_t, string_view sv) { if (n != 0) { --n; return true; } result = to_unsigned(sv.begin() - begin); return false; }); return result; } inline auto code_point_index(basic_string_view s, size_t n) -> size_t { return code_point_index( string_view(reinterpret_cast(s.data()), s.size()), n); } template struct is_integral : std::is_integral {}; template <> struct is_integral : std::true_type {}; template <> struct is_integral : std::true_type {}; template using is_signed = std::integral_constant::is_signed || std::is_same::value>; template using is_integer = bool_constant::value && !std::is_same::value && !std::is_same::value && !std::is_same::value>; #ifndef FMT_USE_FLOAT # define FMT_USE_FLOAT 1 #endif #ifndef FMT_USE_DOUBLE # define FMT_USE_DOUBLE 1 #endif #ifndef FMT_USE_LONG_DOUBLE # define FMT_USE_LONG_DOUBLE 1 #endif #ifndef FMT_USE_FLOAT128 # ifdef __clang__ // Clang emulates GCC, so it has to appear early. # if FMT_HAS_INCLUDE() # define FMT_USE_FLOAT128 1 # endif # elif defined(__GNUC__) // GNU C++: # if defined(_GLIBCXX_USE_FLOAT128) && !defined(__STRICT_ANSI__) # define FMT_USE_FLOAT128 1 # endif # endif # ifndef FMT_USE_FLOAT128 # define FMT_USE_FLOAT128 0 # endif #endif #if FMT_USE_FLOAT128 using float128 = __float128; #else using float128 = void; #endif template using is_float128 = std::is_same; template using is_floating_point = bool_constant::value || is_float128::value>; template ::value> struct is_fast_float : bool_constant::is_iec559 && sizeof(T) <= sizeof(double)> {}; template struct is_fast_float : std::false_type {}; template using is_double_double = bool_constant::digits == 106>; #ifndef FMT_USE_FULL_CACHE_DRAGONBOX # define FMT_USE_FULL_CACHE_DRAGONBOX 0 #endif template template void buffer::append(const U* begin, const U* end) { while (begin != end) { auto count = to_unsigned(end - begin); try_reserve(size_ + count); auto free_cap = capacity_ - size_; if (free_cap < count) count = free_cap; std::uninitialized_copy_n(begin, count, ptr_ + size_); size_ += count; begin += count; } } template struct is_locale : std::false_type {}; template struct is_locale> : std::true_type {}; } // namespace detail FMT_BEGIN_EXPORT // The number of characters to store in the basic_memory_buffer object itself // to avoid dynamic memory allocation. enum { inline_buffer_size = 500 }; /** \rst A dynamically growing memory buffer for trivially copyable/constructible types with the first ``SIZE`` elements stored in the object itself. You can use the ``memory_buffer`` type alias for ``char`` instead. **Example**:: auto out = fmt::memory_buffer(); fmt::format_to(std::back_inserter(out), "The answer is {}.", 42); This will append the following output to the ``out`` object: .. code-block:: none The answer is 42. The output can be converted to an ``std::string`` with ``to_string(out)``. \endrst */ template > class basic_memory_buffer final : public detail::buffer { private: T store_[SIZE]; // Don't inherit from Allocator to avoid generating type_info for it. FMT_NO_UNIQUE_ADDRESS Allocator alloc_; // Deallocate memory allocated by the buffer. FMT_CONSTEXPR20 void deallocate() { T* data = this->data(); if (data != store_) alloc_.deallocate(data, this->capacity()); } protected: FMT_CONSTEXPR20 void grow(size_t size) override { detail::abort_fuzzing_if(size > 5000); const size_t max_size = std::allocator_traits::max_size(alloc_); size_t old_capacity = this->capacity(); size_t new_capacity = old_capacity + old_capacity / 2; if (size > new_capacity) new_capacity = size; else if (new_capacity > max_size) new_capacity = size > max_size ? size : max_size; T* old_data = this->data(); T* new_data = std::allocator_traits::allocate(alloc_, new_capacity); // Suppress a bogus -Wstringop-overflow in gcc 13.1 (#3481). detail::assume(this->size() <= new_capacity); // The following code doesn't throw, so the raw pointer above doesn't leak. std::uninitialized_copy_n(old_data, this->size(), new_data); this->set(new_data, new_capacity); // deallocate must not throw according to the standard, but even if it does, // the buffer already uses the new storage and will deallocate it in // destructor. if (old_data != store_) alloc_.deallocate(old_data, old_capacity); } public: using value_type = T; using const_reference = const T&; FMT_CONSTEXPR20 explicit basic_memory_buffer( const Allocator& alloc = Allocator()) : alloc_(alloc) { this->set(store_, SIZE); if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T()); } FMT_CONSTEXPR20 ~basic_memory_buffer() { deallocate(); } private: // Move data from other to this buffer. FMT_CONSTEXPR20 void move(basic_memory_buffer& other) { alloc_ = std::move(other.alloc_); T* data = other.data(); size_t size = other.size(), capacity = other.capacity(); if (data == other.store_) { this->set(store_, capacity); detail::copy_str(other.store_, other.store_ + size, store_); } else { this->set(data, capacity); // Set pointer to the inline array so that delete is not called // when deallocating. other.set(other.store_, 0); other.clear(); } this->resize(size); } public: /** \rst Constructs a :class:`fmt::basic_memory_buffer` object moving the content of the other object to it. \endrst */ FMT_CONSTEXPR20 basic_memory_buffer(basic_memory_buffer&& other) noexcept { move(other); } /** \rst Moves the content of the other ``basic_memory_buffer`` object to this one. \endrst */ auto operator=(basic_memory_buffer&& other) noexcept -> basic_memory_buffer& { FMT_ASSERT(this != &other, ""); deallocate(); move(other); return *this; } // Returns a copy of the allocator associated with this buffer. auto get_allocator() const -> Allocator { return alloc_; } /** Resizes the buffer to contain *count* elements. If T is a POD type new elements may not be initialized. */ FMT_CONSTEXPR20 void resize(size_t count) { this->try_resize(count); } /** Increases the buffer capacity to *new_capacity*. */ void reserve(size_t new_capacity) { this->try_reserve(new_capacity); } using detail::buffer::append; template void append(const ContiguousRange& range) { append(range.data(), range.data() + range.size()); } }; using memory_buffer = basic_memory_buffer; template struct is_contiguous> : std::true_type { }; FMT_END_EXPORT namespace detail { FMT_API auto write_console(int fd, string_view text) -> bool; FMT_API auto write_console(std::FILE* f, string_view text) -> bool; FMT_API void print(std::FILE*, string_view); } // namespace detail FMT_BEGIN_EXPORT // Suppress a misleading warning in older versions of clang. #if FMT_CLANG_VERSION # pragma clang diagnostic ignored "-Wweak-vtables" #endif /** An error reported from a formatting function. */ class FMT_SO_VISIBILITY("default") format_error : public std::runtime_error { public: using std::runtime_error::runtime_error; }; namespace detail_exported { #if FMT_USE_NONTYPE_TEMPLATE_ARGS template struct fixed_string { constexpr fixed_string(const Char (&str)[N]) { detail::copy_str(static_cast(str), str + N, data); } Char data[N] = {}; }; #endif // Converts a compile-time string to basic_string_view. template constexpr auto compile_string_to_view(const Char (&s)[N]) -> basic_string_view { // Remove trailing NUL character if needed. Won't be present if this is used // with a raw character array (i.e. not defined as a string). return {s, N - (std::char_traits::to_int_type(s[N - 1]) == 0 ? 1 : 0)}; } template constexpr auto compile_string_to_view(detail::std_string_view s) -> basic_string_view { return {s.data(), s.size()}; } } // namespace detail_exported class loc_value { private: basic_format_arg value_; public: template ::value)> loc_value(T value) : value_(detail::make_arg(value)) {} template ::value)> loc_value(T) {} template auto visit(Visitor&& vis) -> decltype(vis(0)) { return visit_format_arg(vis, value_); } }; // A locale facet that formats values in UTF-8. // It is parameterized on the locale to avoid the heavy include. template class format_facet : public Locale::facet { private: std::string separator_; std::string grouping_; std::string decimal_point_; protected: virtual auto do_put(appender out, loc_value val, const format_specs<>& specs) const -> bool; public: static FMT_API typename Locale::id id; explicit format_facet(Locale& loc); explicit format_facet(string_view sep = "", std::initializer_list g = {3}, std::string decimal_point = ".") : separator_(sep.data(), sep.size()), grouping_(g.begin(), g.end()), decimal_point_(decimal_point) {} auto put(appender out, loc_value val, const format_specs<>& specs) const -> bool { return do_put(out, val, specs); } }; namespace detail { // Returns true if value is negative, false otherwise. // Same as `value < 0` but doesn't produce warnings if T is an unsigned type. template ::value)> constexpr auto is_negative(T value) -> bool { return value < 0; } template ::value)> constexpr auto is_negative(T) -> bool { return false; } template FMT_CONSTEXPR auto is_supported_floating_point(T) -> bool { if (std::is_same()) return FMT_USE_FLOAT; if (std::is_same()) return FMT_USE_DOUBLE; if (std::is_same()) return FMT_USE_LONG_DOUBLE; return true; } // Smallest of uint32_t, uint64_t, uint128_t that is large enough to // represent all values of an integral type T. template using uint32_or_64_or_128_t = conditional_t() <= 32 && !FMT_REDUCE_INT_INSTANTIATIONS, uint32_t, conditional_t() <= 64, uint64_t, uint128_t>>; template using uint64_or_128_t = conditional_t() <= 64, uint64_t, uint128_t>; #define FMT_POWERS_OF_10(factor) \ factor * 10, (factor) * 100, (factor) * 1000, (factor) * 10000, \ (factor) * 100000, (factor) * 1000000, (factor) * 10000000, \ (factor) * 100000000, (factor) * 1000000000 // Converts value in the range [0, 100) to a string. constexpr auto digits2(size_t value) -> const char* { // GCC generates slightly better code when value is pointer-size. return &"0001020304050607080910111213141516171819" "2021222324252627282930313233343536373839" "4041424344454647484950515253545556575859" "6061626364656667686970717273747576777879" "8081828384858687888990919293949596979899"[value * 2]; } // Sign is a template parameter to workaround a bug in gcc 4.8. template constexpr auto sign(Sign s) -> Char { #if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 604 static_assert(std::is_same::value, ""); #endif return static_cast("\0-+ "[s]); } template FMT_CONSTEXPR auto count_digits_fallback(T n) -> int { int 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; } } #if FMT_USE_INT128 FMT_CONSTEXPR inline auto count_digits(uint128_opt n) -> int { return count_digits_fallback(n); } #endif #ifdef FMT_BUILTIN_CLZLL // It is a separate function rather than a part of count_digits to workaround // the lack of static constexpr in constexpr functions. inline auto do_count_digits(uint64_t n) -> int { // This has comparable performance to the version by Kendall Willets // (https://github.com/fmtlib/format-benchmark/blob/master/digits10) // but uses smaller tables. // Maps bsr(n) to ceil(log10(pow(2, bsr(n) + 1) - 1)). static constexpr uint8_t bsr2log10[] = { 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15, 15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19, 20}; auto t = bsr2log10[FMT_BUILTIN_CLZLL(n | 1) ^ 63]; static constexpr const uint64_t zero_or_powers_of_10[] = { 0, 0, FMT_POWERS_OF_10(1U), FMT_POWERS_OF_10(1000000000ULL), 10000000000000000000ULL}; return t - (n < zero_or_powers_of_10[t]); } #endif // Returns the number of decimal digits in n. Leading zeros are not counted // except for n == 0 in which case count_digits returns 1. FMT_CONSTEXPR20 inline auto count_digits(uint64_t n) -> int { #ifdef FMT_BUILTIN_CLZLL if (!is_constant_evaluated()) { return do_count_digits(n); } #endif return count_digits_fallback(n); } // Counts the number of digits in n. BITS = log2(radix). template FMT_CONSTEXPR auto count_digits(UInt n) -> int { #ifdef FMT_BUILTIN_CLZ if (!is_constant_evaluated() && num_bits() == 32) return (FMT_BUILTIN_CLZ(static_cast(n) | 1) ^ 31) / BITS + 1; #endif // Lambda avoids unreachable code warnings from NVHPC. return [](UInt m) { int num_digits = 0; do { ++num_digits; } while ((m >>= BITS) != 0); return num_digits; }(n); } #ifdef FMT_BUILTIN_CLZ // It is a separate function rather than a part of count_digits to workaround // the lack of static constexpr in constexpr functions. FMT_INLINE auto do_count_digits(uint32_t n) -> int { // An optimization by Kendall Willets from https://bit.ly/3uOIQrB. // This increments the upper 32 bits (log10(T) - 1) when >= T is added. # define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T) static constexpr uint64_t table[] = { FMT_INC(0), FMT_INC(0), FMT_INC(0), // 8 FMT_INC(10), FMT_INC(10), FMT_INC(10), // 64 FMT_INC(100), FMT_INC(100), FMT_INC(100), // 512 FMT_INC(1000), FMT_INC(1000), FMT_INC(1000), // 4096 FMT_INC(10000), FMT_INC(10000), FMT_INC(10000), // 32k FMT_INC(100000), FMT_INC(100000), FMT_INC(100000), // 256k FMT_INC(1000000), FMT_INC(1000000), FMT_INC(1000000), // 2048k FMT_INC(10000000), FMT_INC(10000000), FMT_INC(10000000), // 16M FMT_INC(100000000), FMT_INC(100000000), FMT_INC(100000000), // 128M FMT_INC(1000000000), FMT_INC(1000000000), FMT_INC(1000000000), // 1024M FMT_INC(1000000000), FMT_INC(1000000000) // 4B }; auto inc = table[FMT_BUILTIN_CLZ(n | 1) ^ 31]; return static_cast((n + inc) >> 32); } #endif // Optional version of count_digits for better performance on 32-bit platforms. FMT_CONSTEXPR20 inline auto count_digits(uint32_t n) -> int { #ifdef FMT_BUILTIN_CLZ if (!is_constant_evaluated()) { return do_count_digits(n); } #endif return count_digits_fallback(n); } template constexpr auto digits10() noexcept -> int { return std::numeric_limits::digits10; } template <> constexpr auto digits10() noexcept -> int { return 38; } template <> constexpr auto digits10() noexcept -> int { return 38; } template struct thousands_sep_result { std::string grouping; Char thousands_sep; }; template FMT_API auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result; template inline auto thousands_sep(locale_ref loc) -> thousands_sep_result { auto result = thousands_sep_impl(loc); return {result.grouping, Char(result.thousands_sep)}; } template <> inline auto thousands_sep(locale_ref loc) -> thousands_sep_result { return thousands_sep_impl(loc); } template FMT_API auto decimal_point_impl(locale_ref loc) -> Char; template inline auto decimal_point(locale_ref loc) -> Char { return Char(decimal_point_impl(loc)); } template <> inline auto decimal_point(locale_ref loc) -> wchar_t { return decimal_point_impl(loc); } // Compares two characters for equality. template auto equal2(const Char* lhs, const char* rhs) -> bool { return lhs[0] == Char(rhs[0]) && lhs[1] == Char(rhs[1]); } inline auto equal2(const char* lhs, const char* rhs) -> bool { return memcmp(lhs, rhs, 2) == 0; } // Copies two characters from src to dst. template FMT_CONSTEXPR20 FMT_INLINE void copy2(Char* dst, const char* src) { if (!is_constant_evaluated() && sizeof(Char) == sizeof(char)) { memcpy(dst, src, 2); return; } *dst++ = static_cast(*src++); *dst = static_cast(*src); } template struct format_decimal_result { Iterator begin; Iterator end; }; // Formats a decimal unsigned integer value writing into out pointing to a // buffer of specified size. The caller must ensure that the buffer is large // enough. template FMT_CONSTEXPR20 auto format_decimal(Char* out, UInt value, int size) -> format_decimal_result { FMT_ASSERT(size >= count_digits(value), "invalid digit count"); out += size; Char* end = out; while (value >= 100) { // Integer division is slow so do it for a group of two 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. out -= 2; copy2(out, digits2(static_cast(value % 100))); value /= 100; } if (value < 10) { *--out = static_cast('0' + value); return {out, end}; } out -= 2; copy2(out, digits2(static_cast(value))); return {out, end}; } template >::value)> FMT_CONSTEXPR inline auto format_decimal(Iterator out, UInt value, int size) -> format_decimal_result { // Buffer is large enough to hold all digits (digits10 + 1). Char buffer[digits10() + 1] = {}; auto end = format_decimal(buffer, value, size).end; return {out, detail::copy_str_noinline(buffer, end, out)}; } template FMT_CONSTEXPR auto format_uint(Char* buffer, UInt value, int num_digits, bool upper = false) -> Char* { buffer += num_digits; Char* end = buffer; do { const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef"; unsigned digit = static_cast(value & ((1 << BASE_BITS) - 1)); *--buffer = static_cast(BASE_BITS < 4 ? static_cast('0' + digit) : digits[digit]); } while ((value >>= BASE_BITS) != 0); return end; } template FMT_CONSTEXPR inline auto format_uint(It out, UInt value, int num_digits, bool upper = false) -> It { if (auto ptr = to_pointer(out, to_unsigned(num_digits))) { format_uint(ptr, value, num_digits, upper); return out; } // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1). char buffer[num_bits() / BASE_BITS + 1] = {}; format_uint(buffer, value, num_digits, upper); return detail::copy_str_noinline(buffer, buffer + num_digits, out); } // A converter from UTF-8 to UTF-16. class utf8_to_utf16 { private: basic_memory_buffer buffer_; public: FMT_API explicit utf8_to_utf16(string_view s); operator basic_string_view() const { return {&buffer_[0], size()}; } auto size() const -> size_t { return buffer_.size() - 1; } auto c_str() const -> const wchar_t* { return &buffer_[0]; } auto str() const -> std::wstring { return {&buffer_[0], size()}; } }; enum class to_utf8_error_policy { abort, replace }; // A converter from UTF-16/UTF-32 (host endian) to UTF-8. template class to_utf8 { private: Buffer buffer_; public: to_utf8() {} explicit to_utf8(basic_string_view s, to_utf8_error_policy policy = to_utf8_error_policy::abort) { static_assert(sizeof(WChar) == 2 || sizeof(WChar) == 4, "Expect utf16 or utf32"); if (!convert(s, policy)) FMT_THROW(std::runtime_error(sizeof(WChar) == 2 ? "invalid utf16" : "invalid utf32")); } operator string_view() const { return string_view(&buffer_[0], size()); } auto size() const -> size_t { return buffer_.size() - 1; } auto c_str() const -> const char* { return &buffer_[0]; } auto str() const -> std::string { return std::string(&buffer_[0], size()); } // Performs conversion returning a bool instead of throwing exception on // conversion error. This method may still throw in case of memory allocation // error. auto convert(basic_string_view s, to_utf8_error_policy policy = to_utf8_error_policy::abort) -> bool { if (!convert(buffer_, s, policy)) return false; buffer_.push_back(0); return true; } static auto convert(Buffer& buf, basic_string_view s, to_utf8_error_policy policy = to_utf8_error_policy::abort) -> bool { for (auto p = s.begin(); p != s.end(); ++p) { uint32_t c = static_cast(*p); if (sizeof(WChar) == 2 && c >= 0xd800 && c <= 0xdfff) { // Handle a surrogate pair. ++p; if (p == s.end() || (c & 0xfc00) != 0xd800 || (*p & 0xfc00) != 0xdc00) { if (policy == to_utf8_error_policy::abort) return false; buf.append(string_view("\xEF\xBF\xBD")); --p; } else { c = (c << 10) + static_cast(*p) - 0x35fdc00; } } else if (c < 0x80) { buf.push_back(static_cast(c)); } else if (c < 0x800) { buf.push_back(static_cast(0xc0 | (c >> 6))); buf.push_back(static_cast(0x80 | (c & 0x3f))); } else if ((c >= 0x800 && c <= 0xd7ff) || (c >= 0xe000 && c <= 0xffff)) { buf.push_back(static_cast(0xe0 | (c >> 12))); buf.push_back(static_cast(0x80 | ((c & 0xfff) >> 6))); buf.push_back(static_cast(0x80 | (c & 0x3f))); } else if (c >= 0x10000 && c <= 0x10ffff) { buf.push_back(static_cast(0xf0 | (c >> 18))); buf.push_back(static_cast(0x80 | ((c & 0x3ffff) >> 12))); buf.push_back(static_cast(0x80 | ((c & 0xfff) >> 6))); buf.push_back(static_cast(0x80 | (c & 0x3f))); } else { return false; } } return true; } }; // Computes 128-bit result of multiplication of two 64-bit unsigned integers. inline auto umul128(uint64_t x, uint64_t y) noexcept -> uint128_fallback { #if FMT_USE_INT128 auto p = static_cast(x) * static_cast(y); return {static_cast(p >> 64), static_cast(p)}; #elif defined(_MSC_VER) && defined(_M_X64) auto hi = uint64_t(); auto lo = _umul128(x, y, &hi); return {hi, lo}; #else const uint64_t mask = static_cast(max_value()); uint64_t a = x >> 32; uint64_t b = x & mask; uint64_t c = y >> 32; uint64_t d = y & mask; uint64_t ac = a * c; uint64_t bc = b * c; uint64_t ad = a * d; uint64_t bd = b * d; uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask); return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32), (intermediate << 32) + (bd & mask)}; #endif } namespace dragonbox { // Computes floor(log10(pow(2, e))) for e in [-2620, 2620] using the method from // https://fmt.dev/papers/Dragonbox.pdf#page=28, section 6.1. inline auto floor_log10_pow2(int e) noexcept -> int { FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent"); static_assert((-1 >> 1) == -1, "right shift is not arithmetic"); return (e * 315653) >> 20; } inline auto floor_log2_pow10(int e) noexcept -> int { FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent"); return (e * 1741647) >> 19; } // Computes upper 64 bits of multiplication of two 64-bit unsigned integers. inline auto umul128_upper64(uint64_t x, uint64_t y) noexcept -> uint64_t { #if FMT_USE_INT128 auto p = static_cast(x) * static_cast(y); return static_cast(p >> 64); #elif defined(_MSC_VER) && defined(_M_X64) return __umulh(x, y); #else return umul128(x, y).high(); #endif } // Computes upper 128 bits of multiplication of a 64-bit unsigned integer and a // 128-bit unsigned integer. inline auto umul192_upper128(uint64_t x, uint128_fallback y) noexcept -> uint128_fallback { uint128_fallback r = umul128(x, y.high()); r += umul128_upper64(x, y.low()); return r; } FMT_API auto get_cached_power(int k) noexcept -> uint128_fallback; // Type-specific information that Dragonbox uses. template struct float_info; template <> struct float_info { using carrier_uint = uint32_t; static const int exponent_bits = 8; static const int kappa = 1; static const int big_divisor = 100; static const int small_divisor = 10; static const int min_k = -31; static const int max_k = 46; static const int shorter_interval_tie_lower_threshold = -35; static const int shorter_interval_tie_upper_threshold = -35; }; template <> struct float_info { using carrier_uint = uint64_t; static const int exponent_bits = 11; static const int kappa = 2; static const int big_divisor = 1000; static const int small_divisor = 100; static const int min_k = -292; static const int max_k = 341; static const int shorter_interval_tie_lower_threshold = -77; static const int shorter_interval_tie_upper_threshold = -77; }; // An 80- or 128-bit floating point number. template struct float_info::digits == 64 || std::numeric_limits::digits == 113 || is_float128::value>> { using carrier_uint = detail::uint128_t; static const int exponent_bits = 15; }; // A double-double floating point number. template struct float_info::value>> { using carrier_uint = detail::uint128_t; }; template struct decimal_fp { using significand_type = typename float_info::carrier_uint; significand_type significand; int exponent; }; template FMT_API auto to_decimal(T x) noexcept -> decimal_fp; } // namespace dragonbox // Returns true iff Float has the implicit bit which is not stored. template constexpr auto has_implicit_bit() -> bool { // An 80-bit FP number has a 64-bit significand an no implicit bit. return std::numeric_limits::digits != 64; } // Returns the number of significand bits stored in Float. The implicit bit is // not counted since it is not stored. template constexpr auto num_significand_bits() -> int { // std::numeric_limits may not support __float128. return is_float128() ? 112 : (std::numeric_limits::digits - (has_implicit_bit() ? 1 : 0)); } template constexpr auto exponent_mask() -> typename dragonbox::float_info::carrier_uint { using float_uint = typename dragonbox::float_info::carrier_uint; return ((float_uint(1) << dragonbox::float_info::exponent_bits) - 1) << num_significand_bits(); } template constexpr auto exponent_bias() -> int { // std::numeric_limits may not support __float128. return is_float128() ? 16383 : std::numeric_limits::max_exponent - 1; } // Writes the exponent exp in the form "[+-]d{2,3}" to buffer. template FMT_CONSTEXPR auto write_exponent(int exp, It it) -> It { FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range"); if (exp < 0) { *it++ = static_cast('-'); exp = -exp; } else { *it++ = static_cast('+'); } if (exp >= 100) { const char* top = digits2(to_unsigned(exp / 100)); if (exp >= 1000) *it++ = static_cast(top[0]); *it++ = static_cast(top[1]); exp %= 100; } const char* d = digits2(to_unsigned(exp)); *it++ = static_cast(d[0]); *it++ = static_cast(d[1]); return it; } // A floating-point number f * pow(2, e) where F is an unsigned type. template struct basic_fp { F f; int e; static constexpr const int num_significand_bits = static_cast(sizeof(F) * num_bits()); constexpr basic_fp() : f(0), e(0) {} constexpr basic_fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {} // Constructs fp from an IEEE754 floating-point number. template FMT_CONSTEXPR basic_fp(Float n) { assign(n); } // Assigns n to this and return true iff predecessor is closer than successor. template ::value)> FMT_CONSTEXPR auto assign(Float n) -> bool { static_assert(std::numeric_limits::digits <= 113, "unsupported FP"); // Assume Float is in the format [sign][exponent][significand]. using carrier_uint = typename dragonbox::float_info::carrier_uint; const auto num_float_significand_bits = detail::num_significand_bits(); const auto implicit_bit = carrier_uint(1) << num_float_significand_bits; const auto significand_mask = implicit_bit - 1; auto u = bit_cast(n); f = static_cast(u & significand_mask); auto biased_e = static_cast((u & exponent_mask()) >> num_float_significand_bits); // The predecessor is closer if n is a normalized power of 2 (f == 0) // other than the smallest normalized number (biased_e > 1). auto is_predecessor_closer = f == 0 && biased_e > 1; if (biased_e == 0) biased_e = 1; // Subnormals use biased exponent 1 (min exponent). else if (has_implicit_bit()) f += static_cast(implicit_bit); e = biased_e - exponent_bias() - num_float_significand_bits; if (!has_implicit_bit()) ++e; return is_predecessor_closer; } template ::value)> FMT_CONSTEXPR auto assign(Float n) -> bool { static_assert(std::numeric_limits::is_iec559, "unsupported FP"); return assign(static_cast(n)); } }; using fp = basic_fp; // Normalizes the value converted from double and multiplied by (1 << SHIFT). template FMT_CONSTEXPR auto normalize(basic_fp value) -> basic_fp { // Handle subnormals. const auto implicit_bit = F(1) << num_significand_bits(); const auto shifted_implicit_bit = implicit_bit << SHIFT; while ((value.f & shifted_implicit_bit) == 0) { value.f <<= 1; --value.e; } // Subtract 1 to account for hidden bit. const auto offset = basic_fp::num_significand_bits - num_significand_bits() - SHIFT - 1; value.f <<= offset; value.e -= offset; return value; } // Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking. FMT_CONSTEXPR inline auto multiply(uint64_t lhs, uint64_t rhs) -> uint64_t { #if FMT_USE_INT128 auto product = static_cast<__uint128_t>(lhs) * rhs; auto f = static_cast(product >> 64); return (static_cast(product) & (1ULL << 63)) != 0 ? f + 1 : f; #else // Multiply 32-bit parts of significands. uint64_t mask = (1ULL << 32) - 1; uint64_t a = lhs >> 32, b = lhs & mask; uint64_t c = rhs >> 32, d = rhs & mask; uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d; // Compute mid 64-bit of result and round. uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31); return ac + (ad >> 32) + (bc >> 32) + (mid >> 32); #endif } FMT_CONSTEXPR inline auto operator*(fp x, fp y) -> fp { return {multiply(x.f, y.f), x.e + y.e + 64}; } template () == num_bits()> using convert_float_result = conditional_t::value || doublish, double, T>; template constexpr auto convert_float(T value) -> convert_float_result { return static_cast>(value); } template FMT_NOINLINE FMT_CONSTEXPR auto fill(OutputIt it, size_t n, const fill_t& fill) -> OutputIt { auto fill_size = fill.size(); if (fill_size == 1) return detail::fill_n(it, n, fill[0]); auto data = fill.data(); for (size_t i = 0; i < n; ++i) it = copy_str(data, data + fill_size, it); return it; } // Writes the output of f, padded according to format specifications in specs. // size: output size in code units. // width: output display width in (terminal) column positions. template FMT_CONSTEXPR auto write_padded(OutputIt out, const format_specs& specs, size_t size, size_t width, F&& f) -> OutputIt { static_assert(align == align::left || align == align::right, ""); unsigned spec_width = to_unsigned(specs.width); size_t padding = spec_width > width ? spec_width - width : 0; // Shifts are encoded as string literals because static constexpr is not // supported in constexpr functions. auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01"; size_t left_padding = padding >> shifts[specs.align]; size_t right_padding = padding - left_padding; auto it = reserve(out, size + padding * specs.fill.size()); if (left_padding != 0) it = fill(it, left_padding, specs.fill); it = f(it); if (right_padding != 0) it = fill(it, right_padding, specs.fill); return base_iterator(out, it); } template constexpr auto write_padded(OutputIt out, const format_specs& specs, size_t size, F&& f) -> OutputIt { return write_padded(out, specs, size, size, f); } template FMT_CONSTEXPR auto write_bytes(OutputIt out, string_view bytes, const format_specs& specs) -> OutputIt { return write_padded( out, specs, bytes.size(), [bytes](reserve_iterator it) { const char* data = bytes.data(); return copy_str(data, data + bytes.size(), it); }); } template auto write_ptr(OutputIt out, UIntPtr value, const format_specs* specs) -> OutputIt { int num_digits = count_digits<4>(value); auto size = to_unsigned(num_digits) + size_t(2); auto write = [=](reserve_iterator it) { *it++ = static_cast('0'); *it++ = static_cast('x'); return format_uint<4, Char>(it, value, num_digits); }; return specs ? write_padded(out, *specs, size, write) : base_iterator(out, write(reserve(out, size))); } // Returns true iff the code point cp is printable. FMT_API auto is_printable(uint32_t cp) -> bool; inline auto needs_escape(uint32_t cp) -> bool { return cp < 0x20 || cp == 0x7f || cp == '"' || cp == '\\' || !is_printable(cp); } template struct find_escape_result { const Char* begin; const Char* end; uint32_t cp; }; template using make_unsigned_char = typename conditional_t::value, std::make_unsigned, type_identity>::type; template auto find_escape(const Char* begin, const Char* end) -> find_escape_result { for (; begin != end; ++begin) { uint32_t cp = static_cast>(*begin); if (const_check(sizeof(Char) == 1) && cp >= 0x80) continue; if (needs_escape(cp)) return {begin, begin + 1, cp}; } return {begin, nullptr, 0}; } inline auto find_escape(const char* begin, const char* end) -> find_escape_result { if (!is_utf8()) return find_escape(begin, end); auto result = find_escape_result{end, nullptr, 0}; for_each_codepoint(string_view(begin, to_unsigned(end - begin)), [&](uint32_t cp, string_view sv) { if (needs_escape(cp)) { result = {sv.begin(), sv.end(), cp}; return false; } return true; }); return result; } #define FMT_STRING_IMPL(s, base, explicit) \ [] { \ /* Use the hidden visibility as a workaround for a GCC bug (#1973). */ \ /* Use a macro-like name to avoid shadowing warnings. */ \ struct FMT_VISIBILITY("hidden") FMT_COMPILE_STRING : base { \ using char_type FMT_MAYBE_UNUSED = fmt::remove_cvref_t; \ FMT_MAYBE_UNUSED FMT_CONSTEXPR explicit \ operator fmt::basic_string_view() const { \ return fmt::detail_exported::compile_string_to_view(s); \ } \ }; \ return FMT_COMPILE_STRING(); \ }() /** \rst Constructs a compile-time format string from a string literal *s*. **Example**:: // A compile-time error because 'd' is an invalid specifier for strings. std::string s = fmt::format(FMT_STRING("{:d}"), "foo"); \endrst */ #define FMT_STRING(s) FMT_STRING_IMPL(s, fmt::detail::compile_string, ) template auto write_codepoint(OutputIt out, char prefix, uint32_t cp) -> OutputIt { *out++ = static_cast('\\'); *out++ = static_cast(prefix); Char buf[width]; fill_n(buf, width, static_cast('0')); format_uint<4>(buf, cp, width); return copy_str(buf, buf + width, out); } template auto write_escaped_cp(OutputIt out, const find_escape_result& escape) -> OutputIt { auto c = static_cast(escape.cp); switch (escape.cp) { case '\n': *out++ = static_cast('\\'); c = static_cast('n'); break; case '\r': *out++ = static_cast('\\'); c = static_cast('r'); break; case '\t': *out++ = static_cast('\\'); c = static_cast('t'); break; case '"': FMT_FALLTHROUGH; case '\'': FMT_FALLTHROUGH; case '\\': *out++ = static_cast('\\'); break; default: if (escape.cp < 0x100) { return write_codepoint<2, Char>(out, 'x', escape.cp); } if (escape.cp < 0x10000) { return write_codepoint<4, Char>(out, 'u', escape.cp); } if (escape.cp < 0x110000) { return write_codepoint<8, Char>(out, 'U', escape.cp); } for (Char escape_char : basic_string_view( escape.begin, to_unsigned(escape.end - escape.begin))) { out = write_codepoint<2, Char>(out, 'x', static_cast(escape_char) & 0xFF); } return out; } *out++ = c; return out; } template auto write_escaped_string(OutputIt out, basic_string_view str) -> OutputIt { *out++ = static_cast('"'); auto begin = str.begin(), end = str.end(); do { auto escape = find_escape(begin, end); out = copy_str(begin, escape.begin, out); begin = escape.end; if (!begin) break; out = write_escaped_cp(out, escape); } while (begin != end); *out++ = static_cast('"'); return out; } template auto write_escaped_char(OutputIt out, Char v) -> OutputIt { Char v_array[1] = {v}; *out++ = static_cast('\''); if ((needs_escape(static_cast(v)) && v != static_cast('"')) || v == static_cast('\'')) { out = write_escaped_cp(out, find_escape_result{v_array, v_array + 1, static_cast(v)}); } else { *out++ = v; } *out++ = static_cast('\''); return out; } template FMT_CONSTEXPR auto write_char(OutputIt out, Char value, const format_specs& specs) -> OutputIt { bool is_debug = specs.type == presentation_type::debug; return write_padded(out, specs, 1, [=](reserve_iterator it) { if (is_debug) return write_escaped_char(it, value); *it++ = value; return it; }); } template FMT_CONSTEXPR auto write(OutputIt out, Char value, const format_specs& specs, locale_ref loc = {}) -> OutputIt { // char is formatted as unsigned char for consistency across platforms. using unsigned_type = conditional_t::value, unsigned char, unsigned>; return check_char_specs(specs) ? write_char(out, value, specs) : write(out, static_cast(value), specs, loc); } // Data for write_int that doesn't depend on output iterator type. It is used to // avoid template code bloat. template struct write_int_data { size_t size; size_t padding; FMT_CONSTEXPR write_int_data(int num_digits, unsigned prefix, const format_specs& specs) : size((prefix >> 24) + to_unsigned(num_digits)), padding(0) { if (specs.align == align::numeric) { auto width = to_unsigned(specs.width); if (width > size) { padding = width - size; size = width; } } else if (specs.precision > num_digits) { size = (prefix >> 24) + to_unsigned(specs.precision); padding = to_unsigned(specs.precision - num_digits); } } }; // Writes an integer in the format // // where are written by write_digits(it). // prefix contains chars in three lower bytes and the size in the fourth byte. template FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, int num_digits, unsigned prefix, const format_specs& specs, W write_digits) -> OutputIt { // Slightly faster check for specs.width == 0 && specs.precision == -1. if ((specs.width | (specs.precision + 1)) == 0) { auto it = reserve(out, to_unsigned(num_digits) + (prefix >> 24)); if (prefix != 0) { for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) *it++ = static_cast(p & 0xff); } return base_iterator(out, write_digits(it)); } auto data = write_int_data(num_digits, prefix, specs); return write_padded( out, specs, data.size, [=](reserve_iterator it) { for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) *it++ = static_cast(p & 0xff); it = detail::fill_n(it, data.padding, static_cast('0')); return write_digits(it); }); } template class digit_grouping { private: std::string grouping_; std::basic_string thousands_sep_; struct next_state { std::string::const_iterator group; int pos; }; auto initial_state() const -> next_state { return {grouping_.begin(), 0}; } // Returns the next digit group separator position. auto next(next_state& state) const -> int { if (thousands_sep_.empty()) return max_value(); if (state.group == grouping_.end()) return state.pos += grouping_.back(); if (*state.group <= 0 || *state.group == max_value()) return max_value(); state.pos += *state.group++; return state.pos; } public: explicit digit_grouping(locale_ref loc, bool localized = true) { if (!localized) return; auto sep = thousands_sep(loc); grouping_ = sep.grouping; if (sep.thousands_sep) thousands_sep_.assign(1, sep.thousands_sep); } digit_grouping(std::string grouping, std::basic_string sep) : grouping_(std::move(grouping)), thousands_sep_(std::move(sep)) {} auto has_separator() const -> bool { return !thousands_sep_.empty(); } auto count_separators(int num_digits) const -> int { int count = 0; auto state = initial_state(); while (num_digits > next(state)) ++count; return count; } // Applies grouping to digits and write the output to out. template auto apply(Out out, basic_string_view digits) const -> Out { auto num_digits = static_cast(digits.size()); auto separators = basic_memory_buffer(); separators.push_back(0); auto state = initial_state(); while (int i = next(state)) { if (i >= num_digits) break; separators.push_back(i); } for (int i = 0, sep_index = static_cast(separators.size() - 1); i < num_digits; ++i) { if (num_digits - i == separators[sep_index]) { out = copy_str(thousands_sep_.data(), thousands_sep_.data() + thousands_sep_.size(), out); --sep_index; } *out++ = static_cast(digits[to_unsigned(i)]); } return out; } }; FMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) { prefix |= prefix != 0 ? value << 8 : value; prefix += (1u + (value > 0xff ? 1 : 0)) << 24; } // Writes a decimal integer with digit grouping. template auto write_int(OutputIt out, UInt value, unsigned prefix, const format_specs& specs, const digit_grouping& grouping) -> OutputIt { static_assert(std::is_same, UInt>::value, ""); int num_digits = 0; auto buffer = memory_buffer(); switch (specs.type) { case presentation_type::none: case presentation_type::dec: { num_digits = count_digits(value); format_decimal(appender(buffer), value, num_digits); break; } case presentation_type::hex_lower: case presentation_type::hex_upper: { bool upper = specs.type == presentation_type::hex_upper; if (specs.alt) prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0'); num_digits = count_digits<4>(value); format_uint<4, char>(appender(buffer), value, num_digits, upper); break; } case presentation_type::bin_lower: case presentation_type::bin_upper: { bool upper = specs.type == presentation_type::bin_upper; if (specs.alt) prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0'); num_digits = count_digits<1>(value); format_uint<1, char>(appender(buffer), value, num_digits); break; } case presentation_type::oct: { num_digits = count_digits<3>(value); // Octal prefix '0' is counted as a digit, so only add it if precision // is not greater than the number of digits. if (specs.alt && specs.precision <= num_digits && value != 0) prefix_append(prefix, '0'); format_uint<3, char>(appender(buffer), value, num_digits); break; } case presentation_type::chr: return write_char(out, static_cast(value), specs); default: throw_format_error("invalid format specifier"); } unsigned size = (prefix != 0 ? prefix >> 24 : 0) + to_unsigned(num_digits) + to_unsigned(grouping.count_separators(num_digits)); return write_padded( out, specs, size, size, [&](reserve_iterator it) { for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) *it++ = static_cast(p & 0xff); return grouping.apply(it, string_view(buffer.data(), buffer.size())); }); } // Writes a localized value. FMT_API auto write_loc(appender out, loc_value value, const format_specs<>& specs, locale_ref loc) -> bool; template inline auto write_loc(OutputIt, loc_value, const format_specs&, locale_ref) -> bool { return false; } template struct write_int_arg { UInt abs_value; unsigned prefix; }; template FMT_CONSTEXPR auto make_write_int_arg(T value, sign_t sign) -> write_int_arg> { auto prefix = 0u; auto abs_value = static_cast>(value); if (is_negative(value)) { prefix = 0x01000000 | '-'; abs_value = 0 - abs_value; } else { constexpr const unsigned prefixes[4] = {0, 0, 0x1000000u | '+', 0x1000000u | ' '}; prefix = prefixes[sign]; } return {abs_value, prefix}; } template struct loc_writer { buffer_appender out; const format_specs& specs; std::basic_string sep; std::string grouping; std::basic_string decimal_point; template ::value)> auto operator()(T value) -> bool { auto arg = make_write_int_arg(value, specs.sign); write_int(out, static_cast>(arg.abs_value), arg.prefix, specs, digit_grouping(grouping, sep)); return true; } template ::value)> auto operator()(T) -> bool { return false; } }; template FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, write_int_arg arg, const format_specs& specs, locale_ref) -> OutputIt { static_assert(std::is_same>::value, ""); auto abs_value = arg.abs_value; auto prefix = arg.prefix; switch (specs.type) { case presentation_type::none: case presentation_type::dec: { auto num_digits = count_digits(abs_value); return write_int( out, num_digits, prefix, specs, [=](reserve_iterator it) { return format_decimal(it, abs_value, num_digits).end; }); } case presentation_type::hex_lower: case presentation_type::hex_upper: { bool upper = specs.type == presentation_type::hex_upper; if (specs.alt) prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0'); int num_digits = count_digits<4>(abs_value); return write_int( out, num_digits, prefix, specs, [=](reserve_iterator it) { return format_uint<4, Char>(it, abs_value, num_digits, upper); }); } case presentation_type::bin_lower: case presentation_type::bin_upper: { bool upper = specs.type == presentation_type::bin_upper; if (specs.alt) prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0'); int num_digits = count_digits<1>(abs_value); return write_int(out, num_digits, prefix, specs, [=](reserve_iterator it) { return format_uint<1, Char>(it, abs_value, num_digits); }); } case presentation_type::oct: { int num_digits = count_digits<3>(abs_value); // Octal prefix '0' is counted as a digit, so only add it if precision // is not greater than the number of digits. if (specs.alt && specs.precision <= num_digits && abs_value != 0) prefix_append(prefix, '0'); return write_int(out, num_digits, prefix, specs, [=](reserve_iterator it) { return format_uint<3, Char>(it, abs_value, num_digits); }); } case presentation_type::chr: return write_char(out, static_cast(abs_value), specs); default: throw_format_error("invalid format specifier"); } return out; } template FMT_CONSTEXPR FMT_NOINLINE auto write_int_noinline( OutputIt out, write_int_arg arg, const format_specs& specs, locale_ref loc) -> OutputIt { return write_int(out, arg, specs, loc); } template ::value && !std::is_same::value && std::is_same>::value)> FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value, const format_specs& specs, locale_ref loc) -> OutputIt { if (specs.localized && write_loc(out, value, specs, loc)) return out; return write_int_noinline(out, make_write_int_arg(value, specs.sign), specs, loc); } // An inlined version of write used in format string compilation. template ::value && !std::is_same::value && !std::is_same>::value)> FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value, const format_specs& specs, locale_ref loc) -> OutputIt { if (specs.localized && write_loc(out, value, specs, loc)) return out; return write_int(out, make_write_int_arg(value, specs.sign), specs, loc); } // An output iterator that counts the number of objects written to it and // discards them. class counting_iterator { private: size_t count_; public: using iterator_category = std::output_iterator_tag; using difference_type = std::ptrdiff_t; using pointer = void; using reference = void; FMT_UNCHECKED_ITERATOR(counting_iterator); struct value_type { template FMT_CONSTEXPR void operator=(const T&) {} }; FMT_CONSTEXPR counting_iterator() : count_(0) {} FMT_CONSTEXPR auto count() const -> size_t { return count_; } FMT_CONSTEXPR auto operator++() -> counting_iterator& { ++count_; return *this; } FMT_CONSTEXPR auto operator++(int) -> counting_iterator { auto it = *this; ++*this; return it; } FMT_CONSTEXPR friend auto operator+(counting_iterator it, difference_type n) -> counting_iterator { it.count_ += static_cast(n); return it; } FMT_CONSTEXPR auto operator*() const -> value_type { return {}; } }; template FMT_CONSTEXPR auto write(OutputIt out, basic_string_view s, const format_specs& specs) -> OutputIt { auto data = s.data(); auto size = s.size(); if (specs.precision >= 0 && to_unsigned(specs.precision) < size) size = code_point_index(s, to_unsigned(specs.precision)); bool is_debug = specs.type == presentation_type::debug; size_t width = 0; if (specs.width != 0) { if (is_debug) width = write_escaped_string(counting_iterator{}, s).count(); else width = compute_width(basic_string_view(data, size)); } return write_padded(out, specs, size, width, [=](reserve_iterator it) { if (is_debug) return write_escaped_string(it, s); return copy_str(data, data + size, it); }); } template FMT_CONSTEXPR auto write(OutputIt out, basic_string_view> s, const format_specs& specs, locale_ref) -> OutputIt { return write(out, s, specs); } template FMT_CONSTEXPR auto write(OutputIt out, const Char* s, const format_specs& specs, locale_ref) -> OutputIt { if (specs.type == presentation_type::pointer) return write_ptr(out, bit_cast(s), &specs); if (!s) throw_format_error("string pointer is null"); return write(out, basic_string_view(s), specs, {}); } template ::value && !std::is_same::value && !std::is_same::value)> FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt { auto abs_value = static_cast>(value); bool negative = is_negative(value); // Don't do -abs_value since it trips unsigned-integer-overflow sanitizer. if (negative) abs_value = ~abs_value + 1; int num_digits = count_digits(abs_value); auto size = (negative ? 1 : 0) + static_cast(num_digits); auto it = reserve(out, size); if (auto ptr = to_pointer(it, size)) { if (negative) *ptr++ = static_cast('-'); format_decimal(ptr, abs_value, num_digits); return out; } if (negative) *it++ = static_cast('-'); it = format_decimal(it, abs_value, num_digits).end; return base_iterator(out, it); } // DEPRECATED! template FMT_CONSTEXPR auto parse_align(const Char* begin, const Char* end, format_specs& specs) -> const Char* { FMT_ASSERT(begin != end, ""); auto align = align::none; auto p = begin + code_point_length(begin); if (end - p <= 0) p = begin; for (;;) { switch (to_ascii(*p)) { case '<': align = align::left; break; case '>': align = align::right; break; case '^': align = align::center; break; } if (align != align::none) { if (p != begin) { auto c = *begin; if (c == '}') return begin; if (c == '{') { throw_format_error("invalid fill character '{'"); return begin; } specs.fill = {begin, to_unsigned(p - begin)}; begin = p + 1; } else { ++begin; } break; } else if (p == begin) { break; } p = begin; } specs.align = align; return begin; } // A floating-point presentation format. enum class float_format : unsigned char { general, // General: exponent notation or fixed point based on magnitude. exp, // Exponent notation with the default precision of 6, e.g. 1.2e-3. fixed, // Fixed point with the default precision of 6, e.g. 0.0012. hex }; struct float_specs { int precision; float_format format : 8; sign_t sign : 8; bool upper : 1; bool locale : 1; bool binary32 : 1; bool showpoint : 1; }; template FMT_CONSTEXPR auto parse_float_type_spec(const format_specs& specs) -> float_specs { auto result = float_specs(); result.showpoint = specs.alt; result.locale = specs.localized; switch (specs.type) { case presentation_type::none: result.format = float_format::general; break; case presentation_type::general_upper: result.upper = true; FMT_FALLTHROUGH; case presentation_type::general_lower: result.format = float_format::general; break; case presentation_type::exp_upper: result.upper = true; FMT_FALLTHROUGH; case presentation_type::exp_lower: result.format = float_format::exp; result.showpoint |= specs.precision != 0; break; case presentation_type::fixed_upper: result.upper = true; FMT_FALLTHROUGH; case presentation_type::fixed_lower: result.format = float_format::fixed; result.showpoint |= specs.precision != 0; break; case presentation_type::hexfloat_upper: result.upper = true; FMT_FALLTHROUGH; case presentation_type::hexfloat_lower: result.format = float_format::hex; break; default: throw_format_error("invalid format specifier"); break; } return result; } template FMT_CONSTEXPR20 auto write_nonfinite(OutputIt out, bool isnan, format_specs specs, const float_specs& fspecs) -> OutputIt { auto str = isnan ? (fspecs.upper ? "NAN" : "nan") : (fspecs.upper ? "INF" : "inf"); constexpr size_t str_size = 3; auto sign = fspecs.sign; auto size = str_size + (sign ? 1 : 0); // Replace '0'-padding with space for non-finite values. const bool is_zero_fill = specs.fill.size() == 1 && *specs.fill.data() == static_cast('0'); if (is_zero_fill) specs.fill[0] = static_cast(' '); return write_padded(out, specs, size, [=](reserve_iterator it) { if (sign) *it++ = detail::sign(sign); return copy_str(str, str + str_size, it); }); } // A decimal floating-point number significand * pow(10, exp). struct big_decimal_fp { const char* significand; int significand_size; int exponent; }; constexpr auto get_significand_size(const big_decimal_fp& f) -> int { return f.significand_size; } template inline auto get_significand_size(const dragonbox::decimal_fp& f) -> int { return count_digits(f.significand); } template constexpr auto write_significand(OutputIt out, const char* significand, int significand_size) -> OutputIt { return copy_str(significand, significand + significand_size, out); } template inline auto write_significand(OutputIt out, UInt significand, int significand_size) -> OutputIt { return format_decimal(out, significand, significand_size).end; } template FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand, int significand_size, int exponent, const Grouping& grouping) -> OutputIt { if (!grouping.has_separator()) { out = write_significand(out, significand, significand_size); return detail::fill_n(out, exponent, static_cast('0')); } auto buffer = memory_buffer(); write_significand(appender(buffer), significand, significand_size); detail::fill_n(appender(buffer), exponent, '0'); return grouping.apply(out, string_view(buffer.data(), buffer.size())); } template ::value)> inline auto write_significand(Char* out, UInt significand, int significand_size, int integral_size, Char decimal_point) -> Char* { if (!decimal_point) return format_decimal(out, significand, significand_size).end; out += significand_size + 1; Char* end = out; int floating_size = significand_size - integral_size; for (int i = floating_size / 2; i > 0; --i) { out -= 2; copy2(out, digits2(static_cast(significand % 100))); significand /= 100; } if (floating_size % 2 != 0) { *--out = static_cast('0' + significand % 10); significand /= 10; } *--out = decimal_point; format_decimal(out - integral_size, significand, integral_size); return end; } template >::value)> inline auto write_significand(OutputIt out, UInt significand, int significand_size, int integral_size, Char decimal_point) -> OutputIt { // Buffer is large enough to hold digits (digits10 + 1) and a decimal point. Char buffer[digits10() + 2]; auto end = write_significand(buffer, significand, significand_size, integral_size, decimal_point); return detail::copy_str_noinline(buffer, end, out); } template FMT_CONSTEXPR auto write_significand(OutputIt out, const char* significand, int significand_size, int integral_size, Char decimal_point) -> OutputIt { out = detail::copy_str_noinline(significand, significand + integral_size, out); if (!decimal_point) return out; *out++ = decimal_point; return detail::copy_str_noinline(significand + integral_size, significand + significand_size, out); } template FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand, int significand_size, int integral_size, Char decimal_point, const Grouping& grouping) -> OutputIt { if (!grouping.has_separator()) { return write_significand(out, significand, significand_size, integral_size, decimal_point); } auto buffer = basic_memory_buffer(); write_significand(buffer_appender(buffer), significand, significand_size, integral_size, decimal_point); grouping.apply( out, basic_string_view(buffer.data(), to_unsigned(integral_size))); return detail::copy_str_noinline(buffer.data() + integral_size, buffer.end(), out); } template > FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f, const format_specs& specs, float_specs fspecs, locale_ref loc) -> OutputIt { auto significand = f.significand; int significand_size = get_significand_size(f); const Char zero = static_cast('0'); auto sign = fspecs.sign; size_t size = to_unsigned(significand_size) + (sign ? 1 : 0); using iterator = reserve_iterator; Char decimal_point = fspecs.locale ? detail::decimal_point(loc) : static_cast('.'); int output_exp = f.exponent + significand_size - 1; auto use_exp_format = [=]() { if (fspecs.format == float_format::exp) return true; if (fspecs.format != float_format::general) return false; // Use the fixed notation if the exponent is in [exp_lower, exp_upper), // e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation. const int exp_lower = -4, exp_upper = 16; return output_exp < exp_lower || output_exp >= (fspecs.precision > 0 ? fspecs.precision : exp_upper); }; if (use_exp_format()) { int num_zeros = 0; if (fspecs.showpoint) { num_zeros = fspecs.precision - significand_size; if (num_zeros < 0) num_zeros = 0; size += to_unsigned(num_zeros); } else if (significand_size == 1) { decimal_point = Char(); } auto abs_output_exp = output_exp >= 0 ? output_exp : -output_exp; int exp_digits = 2; if (abs_output_exp >= 100) exp_digits = abs_output_exp >= 1000 ? 4 : 3; size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits); char exp_char = fspecs.upper ? 'E' : 'e'; auto write = [=](iterator it) { if (sign) *it++ = detail::sign(sign); // Insert a decimal point after the first digit and add an exponent. it = write_significand(it, significand, significand_size, 1, decimal_point); if (num_zeros > 0) it = detail::fill_n(it, num_zeros, zero); *it++ = static_cast(exp_char); return write_exponent(output_exp, it); }; return specs.width > 0 ? write_padded(out, specs, size, write) : base_iterator(out, write(reserve(out, size))); } int exp = f.exponent + significand_size; if (f.exponent >= 0) { // 1234e5 -> 123400000[.0+] size += to_unsigned(f.exponent); int num_zeros = fspecs.precision - exp; abort_fuzzing_if(num_zeros > 5000); if (fspecs.showpoint) { ++size; if (num_zeros <= 0 && fspecs.format != float_format::fixed) num_zeros = 0; if (num_zeros > 0) size += to_unsigned(num_zeros); } auto grouping = Grouping(loc, fspecs.locale); size += to_unsigned(grouping.count_separators(exp)); return write_padded(out, specs, size, [&](iterator it) { if (sign) *it++ = detail::sign(sign); it = write_significand(it, significand, significand_size, f.exponent, grouping); if (!fspecs.showpoint) return it; *it++ = decimal_point; return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it; }); } else if (exp > 0) { // 1234e-2 -> 12.34[0+] int num_zeros = fspecs.showpoint ? fspecs.precision - significand_size : 0; size += 1 + to_unsigned(num_zeros > 0 ? num_zeros : 0); auto grouping = Grouping(loc, fspecs.locale); size += to_unsigned(grouping.count_separators(exp)); return write_padded(out, specs, size, [&](iterator it) { if (sign) *it++ = detail::sign(sign); it = write_significand(it, significand, significand_size, exp, decimal_point, grouping); return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it; }); } // 1234e-6 -> 0.001234 int num_zeros = -exp; if (significand_size == 0 && fspecs.precision >= 0 && fspecs.precision < num_zeros) { num_zeros = fspecs.precision; } bool pointy = num_zeros != 0 || significand_size != 0 || fspecs.showpoint; size += 1 + (pointy ? 1 : 0) + to_unsigned(num_zeros); return write_padded(out, specs, size, [&](iterator it) { if (sign) *it++ = detail::sign(sign); *it++ = zero; if (!pointy) return it; *it++ = decimal_point; it = detail::fill_n(it, num_zeros, zero); return write_significand(it, significand, significand_size); }); } template class fallback_digit_grouping { public: constexpr fallback_digit_grouping(locale_ref, bool) {} constexpr auto has_separator() const -> bool { return false; } constexpr auto count_separators(int) const -> int { return 0; } template constexpr auto apply(Out out, basic_string_view) const -> Out { return out; } }; template FMT_CONSTEXPR20 auto write_float(OutputIt out, const DecimalFP& f, const format_specs& specs, float_specs fspecs, locale_ref loc) -> OutputIt { if (is_constant_evaluated()) { return do_write_float>(out, f, specs, fspecs, loc); } else { return do_write_float(out, f, specs, fspecs, loc); } } template constexpr auto isnan(T value) -> bool { return !(value >= value); // std::isnan doesn't support __float128. } template struct has_isfinite : std::false_type {}; template struct has_isfinite> : std::true_type {}; template ::value&& has_isfinite::value)> FMT_CONSTEXPR20 auto isfinite(T value) -> bool { constexpr T inf = T(std::numeric_limits::infinity()); if (is_constant_evaluated()) return !detail::isnan(value) && value < inf && value > -inf; return std::isfinite(value); } template ::value)> FMT_CONSTEXPR auto isfinite(T value) -> bool { T inf = T(std::numeric_limits::infinity()); // std::isfinite doesn't support __float128. return !detail::isnan(value) && value < inf && value > -inf; } template ::value)> FMT_INLINE FMT_CONSTEXPR bool signbit(T value) { if (is_constant_evaluated()) { #ifdef __cpp_if_constexpr if constexpr (std::numeric_limits::is_iec559) { auto bits = detail::bit_cast(static_cast(value)); return (bits >> (num_bits() - 1)) != 0; } #endif } return std::signbit(static_cast(value)); } inline FMT_CONSTEXPR20 void adjust_precision(int& precision, int exp10) { // Adjust fixed precision by exponent because it is relative to decimal // point. if (exp10 > 0 && precision > max_value() - exp10) FMT_THROW(format_error("number is too big")); precision += exp10; } class bigint { private: // A bigint is stored as an array of bigits (big digits), with bigit at index // 0 being the least significant one. using bigit = uint32_t; using double_bigit = uint64_t; enum { bigits_capacity = 32 }; basic_memory_buffer bigits_; int exp_; FMT_CONSTEXPR20 auto operator[](int index) const -> bigit { return bigits_[to_unsigned(index)]; } FMT_CONSTEXPR20 auto operator[](int index) -> bigit& { return bigits_[to_unsigned(index)]; } static constexpr const int bigit_bits = num_bits(); friend struct formatter; FMT_CONSTEXPR20 void subtract_bigits(int index, bigit other, bigit& borrow) { auto result = static_cast((*this)[index]) - other - borrow; (*this)[index] = static_cast(result); borrow = static_cast(result >> (bigit_bits * 2 - 1)); } FMT_CONSTEXPR20 void remove_leading_zeros() { int num_bigits = static_cast(bigits_.size()) - 1; while (num_bigits > 0 && (*this)[num_bigits] == 0) --num_bigits; bigits_.resize(to_unsigned(num_bigits + 1)); } // Computes *this -= other assuming aligned bigints and *this >= other. FMT_CONSTEXPR20 void subtract_aligned(const bigint& other) { FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints"); FMT_ASSERT(compare(*this, other) >= 0, ""); bigit borrow = 0; int i = other.exp_ - exp_; for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j) subtract_bigits(i, other.bigits_[j], borrow); while (borrow > 0) subtract_bigits(i, 0, borrow); remove_leading_zeros(); } FMT_CONSTEXPR20 void multiply(uint32_t value) { const double_bigit wide_value = value; bigit carry = 0; for (size_t i = 0, n = bigits_.size(); i < n; ++i) { double_bigit result = bigits_[i] * wide_value + carry; bigits_[i] = static_cast(result); carry = static_cast(result >> bigit_bits); } if (carry != 0) bigits_.push_back(carry); } template ::value || std::is_same::value)> FMT_CONSTEXPR20 void multiply(UInt value) { using half_uint = conditional_t::value, uint64_t, uint32_t>; const int shift = num_bits() - bigit_bits; const UInt lower = static_cast(value); const UInt upper = value >> num_bits(); UInt carry = 0; for (size_t i = 0, n = bigits_.size(); i < n; ++i) { UInt result = lower * bigits_[i] + static_cast(carry); carry = (upper * bigits_[i] << shift) + (result >> bigit_bits) + (carry >> bigit_bits); bigits_[i] = static_cast(result); } while (carry != 0) { bigits_.push_back(static_cast(carry)); carry >>= bigit_bits; } } template ::value || std::is_same::value)> FMT_CONSTEXPR20 void assign(UInt n) { size_t num_bigits = 0; do { bigits_[num_bigits++] = static_cast(n); n >>= bigit_bits; } while (n != 0); bigits_.resize(num_bigits); exp_ = 0; } public: FMT_CONSTEXPR20 bigint() : exp_(0) {} explicit bigint(uint64_t n) { assign(n); } bigint(const bigint&) = delete; void operator=(const bigint&) = delete; FMT_CONSTEXPR20 void assign(const bigint& other) { auto size = other.bigits_.size(); bigits_.resize(size); auto data = other.bigits_.data(); copy_str(data, data + size, bigits_.data()); exp_ = other.exp_; } template FMT_CONSTEXPR20 void operator=(Int n) { FMT_ASSERT(n > 0, ""); assign(uint64_or_128_t(n)); } FMT_CONSTEXPR20 auto num_bigits() const -> int { return static_cast(bigits_.size()) + exp_; } FMT_NOINLINE FMT_CONSTEXPR20 auto operator<<=(int shift) -> bigint& { FMT_ASSERT(shift >= 0, ""); exp_ += shift / bigit_bits; shift %= bigit_bits; if (shift == 0) return *this; bigit carry = 0; for (size_t i = 0, n = bigits_.size(); i < n; ++i) { bigit c = bigits_[i] >> (bigit_bits - shift); bigits_[i] = (bigits_[i] << shift) + carry; carry = c; } if (carry != 0) bigits_.push_back(carry); return *this; } template FMT_CONSTEXPR20 auto operator*=(Int value) -> bigint& { FMT_ASSERT(value > 0, ""); multiply(uint32_or_64_or_128_t(value)); return *this; } friend FMT_CONSTEXPR20 auto compare(const bigint& lhs, const bigint& rhs) -> int { int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits(); if (num_lhs_bigits != num_rhs_bigits) return num_lhs_bigits > num_rhs_bigits ? 1 : -1; int i = static_cast(lhs.bigits_.size()) - 1; int j = static_cast(rhs.bigits_.size()) - 1; int end = i - j; if (end < 0) end = 0; for (; i >= end; --i, --j) { bigit lhs_bigit = lhs[i], rhs_bigit = rhs[j]; if (lhs_bigit != rhs_bigit) return lhs_bigit > rhs_bigit ? 1 : -1; } if (i != j) return i > j ? 1 : -1; return 0; } // Returns compare(lhs1 + lhs2, rhs). friend FMT_CONSTEXPR20 auto add_compare(const bigint& lhs1, const bigint& lhs2, const bigint& rhs) -> int { auto minimum = [](int a, int b) { return a < b ? a : b; }; auto maximum = [](int a, int b) { return a > b ? a : b; }; int max_lhs_bigits = maximum(lhs1.num_bigits(), lhs2.num_bigits()); int num_rhs_bigits = rhs.num_bigits(); if (max_lhs_bigits + 1 < num_rhs_bigits) return -1; if (max_lhs_bigits > num_rhs_bigits) return 1; auto get_bigit = [](const bigint& n, int i) -> bigit { return i >= n.exp_ && i < n.num_bigits() ? n[i - n.exp_] : 0; }; double_bigit borrow = 0; int min_exp = minimum(minimum(lhs1.exp_, lhs2.exp_), rhs.exp_); for (int i = num_rhs_bigits - 1; i >= min_exp; --i) { double_bigit sum = static_cast(get_bigit(lhs1, i)) + get_bigit(lhs2, i); bigit rhs_bigit = get_bigit(rhs, i); if (sum > rhs_bigit + borrow) return 1; borrow = rhs_bigit + borrow - sum; if (borrow > 1) return -1; borrow <<= bigit_bits; } return borrow != 0 ? -1 : 0; } // Assigns pow(10, exp) to this bigint. FMT_CONSTEXPR20 void assign_pow10(int exp) { FMT_ASSERT(exp >= 0, ""); if (exp == 0) return *this = 1; // Find the top bit. int bitmask = 1; while (exp >= bitmask) bitmask <<= 1; bitmask >>= 1; // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by // repeated squaring and multiplication. *this = 5; bitmask >>= 1; while (bitmask != 0) { square(); if ((exp & bitmask) != 0) *this *= 5; bitmask >>= 1; } *this <<= exp; // Multiply by pow(2, exp) by shifting. } FMT_CONSTEXPR20 void square() { int num_bigits = static_cast(bigits_.size()); int num_result_bigits = 2 * num_bigits; basic_memory_buffer n(std::move(bigits_)); bigits_.resize(to_unsigned(num_result_bigits)); auto sum = uint128_t(); for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) { // Compute bigit at position bigit_index of the result by adding // cross-product terms n[i] * n[j] such that i + j == bigit_index. for (int i = 0, j = bigit_index; j >= 0; ++i, --j) { // Most terms are multiplied twice which can be optimized in the future. sum += static_cast(n[i]) * n[j]; } (*this)[bigit_index] = static_cast(sum); sum >>= num_bits(); // Compute the carry. } // Do the same for the top half. for (int bigit_index = num_bigits; bigit_index < num_result_bigits; ++bigit_index) { for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;) sum += static_cast(n[i++]) * n[j--]; (*this)[bigit_index] = static_cast(sum); sum >>= num_bits(); } remove_leading_zeros(); exp_ *= 2; } // If this bigint has a bigger exponent than other, adds trailing zero to make // exponents equal. This simplifies some operations such as subtraction. FMT_CONSTEXPR20 void align(const bigint& other) { int exp_difference = exp_ - other.exp_; if (exp_difference <= 0) return; int num_bigits = static_cast(bigits_.size()); bigits_.resize(to_unsigned(num_bigits + exp_difference)); for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j) bigits_[j] = bigits_[i]; std::uninitialized_fill_n(bigits_.data(), exp_difference, 0u); exp_ -= exp_difference; } // Divides this bignum by divisor, assigning the remainder to this and // returning the quotient. FMT_CONSTEXPR20 auto divmod_assign(const bigint& divisor) -> int { FMT_ASSERT(this != &divisor, ""); if (compare(*this, divisor) < 0) return 0; FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, ""); align(divisor); int quotient = 0; do { subtract_aligned(divisor); ++quotient; } while (compare(*this, divisor) >= 0); return quotient; } }; // format_dragon flags. enum dragon { predecessor_closer = 1, fixup = 2, // Run fixup to correct exp10 which can be off by one. fixed = 4, }; // Formats a floating-point number using a variation of the Fixed-Precision // Positive Floating-Point Printout ((FPP)^2) algorithm by Steele & White: // https://fmt.dev/papers/p372-steele.pdf. FMT_CONSTEXPR20 inline void format_dragon(basic_fp value, unsigned flags, int num_digits, buffer& buf, int& exp10) { bigint numerator; // 2 * R in (FPP)^2. bigint denominator; // 2 * S in (FPP)^2. // lower and upper are differences between value and corresponding boundaries. bigint lower; // (M^- in (FPP)^2). bigint upper_store; // upper's value if different from lower. bigint* upper = nullptr; // (M^+ in (FPP)^2). // Shift numerator and denominator by an extra bit or two (if lower boundary // is closer) to make lower and upper integers. This eliminates multiplication // by 2 during later computations. bool is_predecessor_closer = (flags & dragon::predecessor_closer) != 0; int shift = is_predecessor_closer ? 2 : 1; if (value.e >= 0) { numerator = value.f; numerator <<= value.e + shift; lower = 1; lower <<= value.e; if (is_predecessor_closer) { upper_store = 1; upper_store <<= value.e + 1; upper = &upper_store; } denominator.assign_pow10(exp10); denominator <<= shift; } else if (exp10 < 0) { numerator.assign_pow10(-exp10); lower.assign(numerator); if (is_predecessor_closer) { upper_store.assign(numerator); upper_store <<= 1; upper = &upper_store; } numerator *= value.f; numerator <<= shift; denominator = 1; denominator <<= shift - value.e; } else { numerator = value.f; numerator <<= shift; denominator.assign_pow10(exp10); denominator <<= shift - value.e; lower = 1; if (is_predecessor_closer) { upper_store = 1ULL << 1; upper = &upper_store; } } int even = static_cast((value.f & 1) == 0); if (!upper) upper = &lower; bool shortest = num_digits < 0; if ((flags & dragon::fixup) != 0) { if (add_compare(numerator, *upper, denominator) + even <= 0) { --exp10; numerator *= 10; if (num_digits < 0) { lower *= 10; if (upper != &lower) *upper *= 10; } } if ((flags & dragon::fixed) != 0) adjust_precision(num_digits, exp10 + 1); } // Invariant: value == (numerator / denominator) * pow(10, exp10). if (shortest) { // Generate the shortest representation. num_digits = 0; char* data = buf.data(); for (;;) { int digit = numerator.divmod_assign(denominator); bool low = compare(numerator, lower) - even < 0; // numerator <[=] lower. // numerator + upper >[=] pow10: bool high = add_compare(numerator, *upper, denominator) + even > 0; data[num_digits++] = static_cast('0' + digit); if (low || high) { if (!low) { ++data[num_digits - 1]; } else if (high) { int result = add_compare(numerator, numerator, denominator); // Round half to even. if (result > 0 || (result == 0 && (digit % 2) != 0)) ++data[num_digits - 1]; } buf.try_resize(to_unsigned(num_digits)); exp10 -= num_digits - 1; return; } numerator *= 10; lower *= 10; if (upper != &lower) *upper *= 10; } } // Generate the given number of digits. exp10 -= num_digits - 1; if (num_digits <= 0) { denominator *= 10; auto digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0'; buf.push_back(digit); return; } buf.try_resize(to_unsigned(num_digits)); for (int i = 0; i < num_digits - 1; ++i) { int digit = numerator.divmod_assign(denominator); buf[i] = static_cast('0' + digit); numerator *= 10; } int digit = numerator.divmod_assign(denominator); auto result = add_compare(numerator, numerator, denominator); if (result > 0 || (result == 0 && (digit % 2) != 0)) { if (digit == 9) { const auto overflow = '0' + 10; buf[num_digits - 1] = overflow; // Propagate the carry. for (int i = num_digits - 1; i > 0 && buf[i] == overflow; --i) { buf[i] = '0'; ++buf[i - 1]; } if (buf[0] == overflow) { buf[0] = '1'; if ((flags & dragon::fixed) != 0) buf.push_back('0'); else ++exp10; } return; } ++digit; } buf[num_digits - 1] = static_cast('0' + digit); } // Formats a floating-point number using the hexfloat format. template ::value)> FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision, float_specs specs, buffer& buf) { // float is passed as double to reduce the number of instantiations and to // simplify implementation. static_assert(!std::is_same::value, ""); using info = dragonbox::float_info; // Assume Float is in the format [sign][exponent][significand]. using carrier_uint = typename info::carrier_uint; constexpr auto num_float_significand_bits = detail::num_significand_bits(); basic_fp f(value); f.e += num_float_significand_bits; if (!has_implicit_bit()) --f.e; constexpr auto num_fraction_bits = num_float_significand_bits + (has_implicit_bit() ? 1 : 0); constexpr auto num_xdigits = (num_fraction_bits + 3) / 4; constexpr auto leading_shift = ((num_xdigits - 1) * 4); const auto leading_mask = carrier_uint(0xF) << leading_shift; const auto leading_xdigit = static_cast((f.f & leading_mask) >> leading_shift); if (leading_xdigit > 1) f.e -= (32 - countl_zero(leading_xdigit) - 1); int print_xdigits = num_xdigits - 1; if (precision >= 0 && print_xdigits > precision) { const int shift = ((print_xdigits - precision - 1) * 4); const auto mask = carrier_uint(0xF) << shift; const auto v = static_cast((f.f & mask) >> shift); if (v >= 8) { const auto inc = carrier_uint(1) << (shift + 4); f.f += inc; f.f &= ~(inc - 1); } // Check long double overflow if (!has_implicit_bit()) { const auto implicit_bit = carrier_uint(1) << num_float_significand_bits; if ((f.f & implicit_bit) == implicit_bit) { f.f >>= 4; f.e += 4; } } print_xdigits = precision; } char xdigits[num_bits() / 4]; detail::fill_n(xdigits, sizeof(xdigits), '0'); format_uint<4>(xdigits, f.f, num_xdigits, specs.upper); // Remove zero tail while (print_xdigits > 0 && xdigits[print_xdigits] == '0') --print_xdigits; buf.push_back('0'); buf.push_back(specs.upper ? 'X' : 'x'); buf.push_back(xdigits[0]); if (specs.showpoint || print_xdigits > 0 || print_xdigits < precision) buf.push_back('.'); buf.append(xdigits + 1, xdigits + 1 + print_xdigits); for (; print_xdigits < precision; ++print_xdigits) buf.push_back('0'); buf.push_back(specs.upper ? 'P' : 'p'); uint32_t abs_e; if (f.e < 0) { buf.push_back('-'); abs_e = static_cast(-f.e); } else { buf.push_back('+'); abs_e = static_cast(f.e); } format_decimal(appender(buf), abs_e, detail::count_digits(abs_e)); } template ::value)> FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision, float_specs specs, buffer& buf) { format_hexfloat(static_cast(value), precision, specs, buf); } constexpr auto fractional_part_rounding_thresholds(int index) -> uint32_t { // For checking rounding thresholds. // The kth entry is chosen to be the smallest integer such that the // upper 32-bits of 10^(k+1) times it is strictly bigger than 5 * 10^k. // It is equal to ceil(2^31 + 2^32/10^(k + 1)). // These are stored in a string literal because we cannot have static arrays // in constexpr functions and non-static ones are poorly optimized. return U"\x9999999a\x828f5c29\x80418938\x80068db9\x8000a7c6\x800010c7" U"\x800001ae\x8000002b"[index]; } template FMT_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs, buffer& buf) -> int { // float is passed as double to reduce the number of instantiations. static_assert(!std::is_same::value, ""); FMT_ASSERT(value >= 0, "value is negative"); auto converted_value = convert_float(value); const bool fixed = specs.format == float_format::fixed; if (value <= 0) { // <= instead of == to silence a warning. if (precision <= 0 || !fixed) { buf.push_back('0'); return 0; } buf.try_resize(to_unsigned(precision)); fill_n(buf.data(), precision, '0'); return -precision; } int exp = 0; bool use_dragon = true; unsigned dragon_flags = 0; if (!is_fast_float() || is_constant_evaluated()) { const auto inv_log2_10 = 0.3010299956639812; // 1 / log2(10) using info = dragonbox::float_info; const auto f = basic_fp(converted_value); // Compute exp, an approximate power of 10, such that // 10^(exp - 1) <= value < 10^exp or 10^exp <= value < 10^(exp + 1). // This is based on log10(value) == log2(value) / log2(10) and approximation // of log2(value) by e + num_fraction_bits idea from double-conversion. auto e = (f.e + count_digits<1>(f.f) - 1) * inv_log2_10 - 1e-10; exp = static_cast(e); if (e > exp) ++exp; // Compute ceil. dragon_flags = dragon::fixup; } else if (precision < 0) { // Use Dragonbox for the shortest format. if (specs.binary32) { auto dec = dragonbox::to_decimal(static_cast(value)); write(buffer_appender(buf), dec.significand); return dec.exponent; } auto dec = dragonbox::to_decimal(static_cast(value)); write(buffer_appender(buf), dec.significand); return dec.exponent; } else { // Extract significand bits and exponent bits. using info = dragonbox::float_info; auto br = bit_cast(static_cast(value)); const uint64_t significand_mask = (static_cast(1) << num_significand_bits()) - 1; uint64_t significand = (br & significand_mask); int exponent = static_cast((br & exponent_mask()) >> num_significand_bits()); if (exponent != 0) { // Check if normal. exponent -= exponent_bias() + num_significand_bits(); significand |= (static_cast(1) << num_significand_bits()); significand <<= 1; } else { // Normalize subnormal inputs. FMT_ASSERT(significand != 0, "zeros should not appear here"); int shift = countl_zero(significand); FMT_ASSERT(shift >= num_bits() - num_significand_bits(), ""); shift -= (num_bits() - num_significand_bits() - 2); exponent = (std::numeric_limits::min_exponent - num_significand_bits()) - shift; significand <<= shift; } // Compute the first several nonzero decimal significand digits. // We call the number we get the first segment. const int k = info::kappa - dragonbox::floor_log10_pow2(exponent); exp = -k; const int beta = exponent + dragonbox::floor_log2_pow10(k); uint64_t first_segment; bool has_more_segments; int digits_in_the_first_segment; { const auto r = dragonbox::umul192_upper128( significand << beta, dragonbox::get_cached_power(k)); first_segment = r.high(); has_more_segments = r.low() != 0; // The first segment can have 18 ~ 19 digits. if (first_segment >= 1000000000000000000ULL) { digits_in_the_first_segment = 19; } else { // When it is of 18-digits, we align it to 19-digits by adding a bogus // zero at the end. digits_in_the_first_segment = 18; first_segment *= 10; } } // Compute the actual number of decimal digits to print. if (fixed) adjust_precision(precision, exp + digits_in_the_first_segment); // Use Dragon4 only when there might be not enough digits in the first // segment. if (digits_in_the_first_segment > precision) { use_dragon = false; if (precision <= 0) { exp += digits_in_the_first_segment; if (precision < 0) { // Nothing to do, since all we have are just leading zeros. buf.try_resize(0); } else { // We may need to round-up. buf.try_resize(1); if ((first_segment | static_cast(has_more_segments)) > 5000000000000000000ULL) { buf[0] = '1'; } else { buf[0] = '0'; } } } // precision <= 0 else { exp += digits_in_the_first_segment - precision; // When precision > 0, we divide the first segment into three // subsegments, each with 9, 9, and 0 ~ 1 digits so that each fits // in 32-bits which usually allows faster calculation than in // 64-bits. Since some compiler (e.g. MSVC) doesn't know how to optimize // division-by-constant for large 64-bit divisors, we do it here // manually. The magic number 7922816251426433760 below is equal to // ceil(2^(64+32) / 10^10). const uint32_t first_subsegment = static_cast( dragonbox::umul128_upper64(first_segment, 7922816251426433760ULL) >> 32); const uint64_t second_third_subsegments = first_segment - first_subsegment * 10000000000ULL; uint64_t prod; uint32_t digits; bool should_round_up; int number_of_digits_to_print = precision > 9 ? 9 : precision; // Print a 9-digits subsegment, either the first or the second. auto print_subsegment = [&](uint32_t subsegment, char* buffer) { int number_of_digits_printed = 0; // If we want to print an odd number of digits from the subsegment, if ((number_of_digits_to_print & 1) != 0) { // Convert to 64-bit fixed-point fractional form with 1-digit // integer part. The magic number 720575941 is a good enough // approximation of 2^(32 + 24) / 10^8; see // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case // for details. prod = ((subsegment * static_cast(720575941)) >> 24) + 1; digits = static_cast(prod >> 32); *buffer = static_cast('0' + digits); number_of_digits_printed++; } // If we want to print an even number of digits from the // first_subsegment, else { // Convert to 64-bit fixed-point fractional form with 2-digits // integer part. The magic number 450359963 is a good enough // approximation of 2^(32 + 20) / 10^7; see // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case // for details. prod = ((subsegment * static_cast(450359963)) >> 20) + 1; digits = static_cast(prod >> 32); copy2(buffer, digits2(digits)); number_of_digits_printed += 2; } // Print all digit pairs. while (number_of_digits_printed < number_of_digits_to_print) { prod = static_cast(prod) * static_cast(100); digits = static_cast(prod >> 32); copy2(buffer + number_of_digits_printed, digits2(digits)); number_of_digits_printed += 2; } }; // Print first subsegment. print_subsegment(first_subsegment, buf.data()); // Perform rounding if the first subsegment is the last subsegment to // print. if (precision <= 9) { // Rounding inside the subsegment. // We round-up if: // - either the fractional part is strictly larger than 1/2, or // - the fractional part is exactly 1/2 and the last digit is odd. // We rely on the following observations: // - If fractional_part >= threshold, then the fractional part is // strictly larger than 1/2. // - If the MSB of fractional_part is set, then the fractional part // must be at least 1/2. // - When the MSB of fractional_part is set, either // second_third_subsegments being nonzero or has_more_segments // being true means there are further digits not printed, so the // fractional part is strictly larger than 1/2. if (precision < 9) { uint32_t fractional_part = static_cast(prod); should_round_up = fractional_part >= fractional_part_rounding_thresholds( 8 - number_of_digits_to_print) || ((fractional_part >> 31) & ((digits & 1) | (second_third_subsegments != 0) | has_more_segments)) != 0; } // Rounding at the subsegment boundary. // In this case, the fractional part is at least 1/2 if and only if // second_third_subsegments >= 5000000000ULL, and is strictly larger // than 1/2 if we further have either second_third_subsegments > // 5000000000ULL or has_more_segments == true. else { should_round_up = second_third_subsegments > 5000000000ULL || (second_third_subsegments == 5000000000ULL && ((digits & 1) != 0 || has_more_segments)); } } // Otherwise, print the second subsegment. else { // Compilers are not aware of how to leverage the maximum value of // second_third_subsegments to find out a better magic number which // allows us to eliminate an additional shift. 1844674407370955162 = // ceil(2^64/10) < ceil(2^64*(10^9/(10^10 - 1))). const uint32_t second_subsegment = static_cast(dragonbox::umul128_upper64( second_third_subsegments, 1844674407370955162ULL)); const uint32_t third_subsegment = static_cast(second_third_subsegments) - second_subsegment * 10; number_of_digits_to_print = precision - 9; print_subsegment(second_subsegment, buf.data() + 9); // Rounding inside the subsegment. if (precision < 18) { // The condition third_subsegment != 0 implies that the segment was // of 19 digits, so in this case the third segment should be // consisting of a genuine digit from the input. uint32_t fractional_part = static_cast(prod); should_round_up = fractional_part >= fractional_part_rounding_thresholds( 8 - number_of_digits_to_print) || ((fractional_part >> 31) & ((digits & 1) | (third_subsegment != 0) | has_more_segments)) != 0; } // Rounding at the subsegment boundary. else { // In this case, the segment must be of 19 digits, thus // the third subsegment should be consisting of a genuine digit from // the input. should_round_up = third_subsegment > 5 || (third_subsegment == 5 && ((digits & 1) != 0 || has_more_segments)); } } // Round-up if necessary. if (should_round_up) { ++buf[precision - 1]; for (int i = precision - 1; i > 0 && buf[i] > '9'; --i) { buf[i] = '0'; ++buf[i - 1]; } if (buf[0] > '9') { buf[0] = '1'; if (fixed) buf[precision++] = '0'; else ++exp; } } buf.try_resize(to_unsigned(precision)); } } // if (digits_in_the_first_segment > precision) else { // Adjust the exponent for its use in Dragon4. exp += digits_in_the_first_segment - 1; } } if (use_dragon) { auto f = basic_fp(); bool is_predecessor_closer = specs.binary32 ? f.assign(static_cast(value)) : f.assign(converted_value); if (is_predecessor_closer) dragon_flags |= dragon::predecessor_closer; if (fixed) dragon_flags |= dragon::fixed; // Limit precision to the maximum possible number of significant digits in // an IEEE754 double because we don't need to generate zeros. const int max_double_digits = 767; if (precision > max_double_digits) precision = max_double_digits; format_dragon(f, dragon_flags, precision, buf, exp); } if (!fixed && !specs.showpoint) { // Remove trailing zeros. auto num_digits = buf.size(); while (num_digits > 0 && buf[num_digits - 1] == '0') { --num_digits; ++exp; } buf.try_resize(num_digits); } return exp; } template FMT_CONSTEXPR20 auto write_float(OutputIt out, T value, format_specs specs, locale_ref loc) -> OutputIt { float_specs fspecs = parse_float_type_spec(specs); fspecs.sign = specs.sign; if (detail::signbit(value)) { // value < 0 is false for NaN so use signbit. fspecs.sign = sign::minus; value = -value; } else if (fspecs.sign == sign::minus) { fspecs.sign = sign::none; } if (!detail::isfinite(value)) return write_nonfinite(out, detail::isnan(value), specs, fspecs); if (specs.align == align::numeric && fspecs.sign) { auto it = reserve(out, 1); *it++ = detail::sign(fspecs.sign); out = base_iterator(out, it); fspecs.sign = sign::none; if (specs.width != 0) --specs.width; } memory_buffer buffer; if (fspecs.format == float_format::hex) { if (fspecs.sign) buffer.push_back(detail::sign(fspecs.sign)); format_hexfloat(convert_float(value), specs.precision, fspecs, buffer); return write_bytes(out, {buffer.data(), buffer.size()}, specs); } int precision = specs.precision >= 0 || specs.type == presentation_type::none ? specs.precision : 6; if (fspecs.format == float_format::exp) { if (precision == max_value()) throw_format_error("number is too big"); else ++precision; } else if (fspecs.format != float_format::fixed && precision == 0) { precision = 1; } if (const_check(std::is_same())) fspecs.binary32 = true; int exp = format_float(convert_float(value), precision, fspecs, buffer); fspecs.precision = precision; auto f = big_decimal_fp{buffer.data(), static_cast(buffer.size()), exp}; return write_float(out, f, specs, fspecs, loc); } template ::value)> FMT_CONSTEXPR20 auto write(OutputIt out, T value, format_specs specs, locale_ref loc = {}) -> OutputIt { if (const_check(!is_supported_floating_point(value))) return out; return specs.localized && write_loc(out, value, specs, loc) ? out : write_float(out, value, specs, loc); } template ::value)> FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt { if (is_constant_evaluated()) return write(out, value, format_specs()); if (const_check(!is_supported_floating_point(value))) return out; auto fspecs = float_specs(); if (detail::signbit(value)) { fspecs.sign = sign::minus; value = -value; } constexpr auto specs = format_specs(); using floaty = conditional_t::value, double, T>; using floaty_uint = typename dragonbox::float_info::carrier_uint; floaty_uint mask = exponent_mask(); if ((bit_cast(value) & mask) == mask) return write_nonfinite(out, std::isnan(value), specs, fspecs); auto dec = dragonbox::to_decimal(static_cast(value)); return write_float(out, dec, specs, fspecs, {}); } template ::value && !is_fast_float::value)> inline auto write(OutputIt out, T value) -> OutputIt { return write(out, value, format_specs()); } template auto write(OutputIt out, monostate, format_specs = {}, locale_ref = {}) -> OutputIt { FMT_ASSERT(false, ""); return out; } template FMT_CONSTEXPR auto write(OutputIt out, basic_string_view value) -> OutputIt { auto it = reserve(out, value.size()); it = copy_str_noinline(value.begin(), value.end(), it); return base_iterator(out, it); } template ::value)> constexpr auto write(OutputIt out, const T& value) -> OutputIt { return write(out, to_string_view(value)); } // FMT_ENABLE_IF() condition separated to workaround an MSVC bug. template < typename Char, typename OutputIt, typename T, bool check = std::is_enum::value && !std::is_same::value && mapped_type_constant>::value != type::custom_type, FMT_ENABLE_IF(check)> FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt { return write(out, static_cast>(value)); } template ::value)> FMT_CONSTEXPR auto write(OutputIt out, T value, const format_specs& specs = {}, locale_ref = {}) -> OutputIt { return specs.type != presentation_type::none && specs.type != presentation_type::string ? write(out, value ? 1 : 0, specs, {}) : write_bytes(out, value ? "true" : "false", specs); } template FMT_CONSTEXPR auto write(OutputIt out, Char value) -> OutputIt { auto it = reserve(out, 1); *it++ = value; return base_iterator(out, it); } template FMT_CONSTEXPR_CHAR_TRAITS auto write(OutputIt out, const Char* value) -> OutputIt { if (value) return write(out, basic_string_view(value)); throw_format_error("string pointer is null"); return out; } template ::value)> auto write(OutputIt out, const T* value, const format_specs& specs = {}, locale_ref = {}) -> OutputIt { return write_ptr(out, bit_cast(value), &specs); } // A write overload that handles implicit conversions. template > FMT_CONSTEXPR auto write(OutputIt out, const T& value) -> enable_if_t< std::is_class::value && !is_string::value && !is_floating_point::value && !std::is_same::value && !std::is_same().map( value))>>::value, OutputIt> { return write(out, arg_mapper().map(value)); } template > FMT_CONSTEXPR auto write(OutputIt out, const T& value) -> enable_if_t::value == type::custom_type, OutputIt> { auto formatter = typename Context::template formatter_type(); auto parse_ctx = typename Context::parse_context_type({}); formatter.parse(parse_ctx); auto ctx = Context(out, {}, {}); return formatter.format(value, ctx); } // An argument visitor that formats the argument and writes it via the output // iterator. It's a class and not a generic lambda for compatibility with C++11. template struct default_arg_formatter { using iterator = buffer_appender; using context = buffer_context; iterator out; basic_format_args args; locale_ref loc; template auto operator()(T value) -> iterator { return write(out, value); } auto operator()(typename basic_format_arg::handle h) -> iterator { basic_format_parse_context parse_ctx({}); context format_ctx(out, args, loc); h.format(parse_ctx, format_ctx); return format_ctx.out(); } }; template struct arg_formatter { using iterator = buffer_appender; using context = buffer_context; iterator out; const format_specs& specs; locale_ref locale; template FMT_CONSTEXPR FMT_INLINE auto operator()(T value) -> iterator { return detail::write(out, value, specs, locale); } auto operator()(typename basic_format_arg::handle) -> iterator { // User-defined types are handled separately because they require access // to the parse context. return out; } }; struct width_checker { template ::value)> FMT_CONSTEXPR auto operator()(T value) -> unsigned long long { if (is_negative(value)) throw_format_error("negative width"); return static_cast(value); } template ::value)> FMT_CONSTEXPR auto operator()(T) -> unsigned long long { throw_format_error("width is not integer"); return 0; } }; struct precision_checker { template ::value)> FMT_CONSTEXPR auto operator()(T value) -> unsigned long long { if (is_negative(value)) throw_format_error("negative precision"); return static_cast(value); } template ::value)> FMT_CONSTEXPR auto operator()(T) -> unsigned long long { throw_format_error("precision is not integer"); return 0; } }; template FMT_CONSTEXPR auto get_dynamic_spec(FormatArg arg) -> int { unsigned long long value = visit_format_arg(Handler(), arg); if (value > to_unsigned(max_value())) throw_format_error("number is too big"); return static_cast(value); } template FMT_CONSTEXPR auto get_arg(Context& ctx, ID id) -> decltype(ctx.arg(id)) { auto arg = ctx.arg(id); if (!arg) ctx.on_error("argument not found"); return arg; } template FMT_CONSTEXPR void handle_dynamic_spec(int& value, arg_ref ref, Context& ctx) { switch (ref.kind) { case arg_id_kind::none: break; case arg_id_kind::index: value = detail::get_dynamic_spec(get_arg(ctx, ref.val.index)); break; case arg_id_kind::name: value = detail::get_dynamic_spec(get_arg(ctx, ref.val.name)); break; } } #if FMT_USE_USER_DEFINED_LITERALS # if FMT_USE_NONTYPE_TEMPLATE_ARGS template Str> struct statically_named_arg : view { static constexpr auto name = Str.data; const T& value; statically_named_arg(const T& v) : value(v) {} }; template Str> struct is_named_arg> : std::true_type {}; template Str> struct is_statically_named_arg> : std::true_type {}; template Str> struct udl_arg { template auto operator=(T&& value) const { return statically_named_arg(std::forward(value)); } }; # else template struct udl_arg { const Char* str; template auto operator=(T&& value) const -> named_arg { return {str, std::forward(value)}; } }; # endif #endif // FMT_USE_USER_DEFINED_LITERALS template auto vformat(const Locale& loc, basic_string_view fmt, basic_format_args>> args) -> std::basic_string { auto buf = basic_memory_buffer(); detail::vformat_to(buf, fmt, args, detail::locale_ref(loc)); return {buf.data(), buf.size()}; } using format_func = void (*)(detail::buffer&, int, const char*); FMT_API void format_error_code(buffer& out, int error_code, string_view message) noexcept; FMT_API void report_error(format_func func, int error_code, const char* message) noexcept; } // namespace detail FMT_API auto vsystem_error(int error_code, string_view format_str, format_args args) -> std::system_error; /** \rst Constructs :class:`std::system_error` with a message formatted with ``fmt::format(fmt, args...)``. *error_code* is a system error code as given by ``errno``. **Example**:: // This throws std::system_error with the description // cannot open file 'madeup': No such file or directory // or similar (system message may vary). const char* filename = "madeup"; std::FILE* file = std::fopen(filename, "r"); if (!file) throw fmt::system_error(errno, "cannot open file '{}'", filename); \endrst */ template auto system_error(int error_code, format_string fmt, T&&... args) -> std::system_error { return vsystem_error(error_code, fmt, fmt::make_format_args(args...)); } /** \rst 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*. The format is the same as the one used by ``std::system_error(ec, message)`` where ``ec`` is ``std::error_code(error_code, std::generic_category()})``. It is implementation-defined but normally looks like: .. parsed-literal:: **: ** where ** is the passed message and ** is the system message corresponding to the error code. *error_code* is a system error code as given by ``errno``. \endrst */ FMT_API void format_system_error(detail::buffer& out, int error_code, const char* message) noexcept; // Reports a system error without throwing an exception. // Can be used to report errors from destructors. FMT_API void report_system_error(int error_code, const char* message) noexcept; /** Fast integer formatter. */ class format_int { private: // Buffer should be large enough to hold all digits (digits10 + 1), // a sign and a null character. enum { buffer_size = std::numeric_limits::digits10 + 3 }; mutable char buffer_[buffer_size]; char* str_; template auto format_unsigned(UInt value) -> char* { auto n = static_cast>(value); return detail::format_decimal(buffer_, n, buffer_size - 1).begin; } template auto format_signed(Int value) -> char* { auto abs_value = static_cast>(value); bool negative = value < 0; if (negative) abs_value = 0 - abs_value; auto begin = format_unsigned(abs_value); if (negative) *--begin = '-'; return begin; } public: explicit format_int(int value) : str_(format_signed(value)) {} explicit format_int(long value) : str_(format_signed(value)) {} explicit format_int(long long value) : str_(format_signed(value)) {} explicit format_int(unsigned value) : str_(format_unsigned(value)) {} explicit format_int(unsigned long value) : str_(format_unsigned(value)) {} explicit format_int(unsigned long long value) : str_(format_unsigned(value)) {} /** Returns the number of characters written to the output buffer. */ auto size() const -> size_t { return detail::to_unsigned(buffer_ - str_ + buffer_size - 1); } /** Returns a pointer to the output buffer content. No terminating null character is appended. */ auto data() const -> const char* { return str_; } /** Returns a pointer to the output buffer content with terminating null character appended. */ auto c_str() const -> const char* { buffer_[buffer_size - 1] = '\0'; return str_; } /** \rst Returns the content of the output buffer as an ``std::string``. \endrst */ auto str() const -> std::string { return std::string(str_, size()); } }; template struct formatter::value>> : formatter, Char> { template auto format(const T& value, FormatContext& ctx) const -> decltype(ctx.out()) { using base = formatter, Char>; return base::format(format_as(value), ctx); } }; #define FMT_FORMAT_AS(Type, Base) \ template \ struct formatter : formatter {} FMT_FORMAT_AS(signed char, int); FMT_FORMAT_AS(unsigned char, unsigned); FMT_FORMAT_AS(short, int); FMT_FORMAT_AS(unsigned short, unsigned); FMT_FORMAT_AS(long, detail::long_type); FMT_FORMAT_AS(unsigned long, detail::ulong_type); FMT_FORMAT_AS(Char*, const Char*); FMT_FORMAT_AS(std::basic_string, basic_string_view); FMT_FORMAT_AS(std::nullptr_t, const void*); FMT_FORMAT_AS(detail::std_string_view, basic_string_view); FMT_FORMAT_AS(void*, const void*); template struct formatter : formatter, Char> {}; /** \rst Converts ``p`` to ``const void*`` for pointer formatting. **Example**:: auto s = fmt::format("{}", fmt::ptr(p)); \endrst */ template auto ptr(T p) -> const void* { static_assert(std::is_pointer::value, ""); return detail::bit_cast(p); } template auto ptr(const std::unique_ptr& p) -> const void* { return p.get(); } template auto ptr(const std::shared_ptr& p) -> const void* { return p.get(); } /** \rst Converts ``e`` to the underlying type. **Example**:: enum class color { red, green, blue }; auto s = fmt::format("{}", fmt::underlying(color::red)); \endrst */ template constexpr auto underlying(Enum e) noexcept -> underlying_t { return static_cast>(e); } namespace enums { template ::value)> constexpr auto format_as(Enum e) noexcept -> underlying_t { return static_cast>(e); } } // namespace enums class bytes { private: string_view data_; friend struct formatter; public: explicit bytes(string_view data) : data_(data) {} }; template <> struct formatter { private: detail::dynamic_format_specs<> specs_; public: template FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const char* { return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, detail::type::string_type); } template auto format(bytes b, FormatContext& ctx) -> decltype(ctx.out()) { detail::handle_dynamic_spec(specs_.width, specs_.width_ref, ctx); detail::handle_dynamic_spec( specs_.precision, specs_.precision_ref, ctx); return detail::write_bytes(ctx.out(), b.data_, specs_); } }; // group_digits_view is not derived from view because it copies the argument. template struct group_digits_view { T value; }; /** \rst Returns a view that formats an integer value using ',' as a locale-independent thousands separator. **Example**:: fmt::print("{}", fmt::group_digits(12345)); // Output: "12,345" \endrst */ template auto group_digits(T value) -> group_digits_view { return {value}; } template struct formatter> : formatter { private: detail::dynamic_format_specs<> specs_; public: template FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const char* { return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, detail::type::int_type); } template auto format(group_digits_view t, FormatContext& ctx) -> decltype(ctx.out()) { detail::handle_dynamic_spec(specs_.width, specs_.width_ref, ctx); detail::handle_dynamic_spec( specs_.precision, specs_.precision_ref, ctx); return detail::write_int( ctx.out(), static_cast>(t.value), 0, specs_, detail::digit_grouping("\3", ",")); } }; template struct nested_view { const formatter* fmt; const T* value; }; template struct formatter> { FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> const char* { return ctx.begin(); } auto format(nested_view view, format_context& ctx) const -> decltype(ctx.out()) { return view.fmt->format(*view.value, ctx); } }; template struct nested_formatter { private: int width_; detail::fill_t fill_; align_t align_ : 4; formatter formatter_; public: constexpr nested_formatter() : width_(0), align_(align_t::none) {} FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> const char* { auto specs = detail::dynamic_format_specs(); auto it = parse_format_specs(ctx.begin(), ctx.end(), specs, ctx, detail::type::none_type); width_ = specs.width; fill_ = specs.fill; align_ = specs.align; ctx.advance_to(it); return formatter_.parse(ctx); } template auto write_padded(format_context& ctx, F write) const -> decltype(ctx.out()) { if (width_ == 0) return write(ctx.out()); auto buf = memory_buffer(); write(std::back_inserter(buf)); auto specs = format_specs<>(); specs.width = width_; specs.fill = fill_; specs.align = align_; return detail::write(ctx.out(), string_view(buf.data(), buf.size()), specs); } auto nested(const T& value) const -> nested_view { return nested_view{&formatter_, &value}; } }; // DEPRECATED! join_view will be moved to ranges.h. template struct join_view : detail::view { It begin; Sentinel end; basic_string_view sep; join_view(It b, Sentinel e, basic_string_view s) : begin(b), end(e), sep(s) {} }; template struct formatter, Char> { private: using value_type = #ifdef __cpp_lib_ranges std::iter_value_t; #else typename std::iterator_traits::value_type; #endif formatter, Char> value_formatter_; public: template FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* { return value_formatter_.parse(ctx); } template auto format(const join_view& value, FormatContext& ctx) const -> decltype(ctx.out()) { auto it = value.begin; auto out = ctx.out(); if (it != value.end) { out = value_formatter_.format(*it, ctx); ++it; while (it != value.end) { out = detail::copy_str(value.sep.begin(), value.sep.end(), out); ctx.advance_to(out); out = value_formatter_.format(*it, ctx); ++it; } } return out; } }; /** Returns a view that formats the iterator range `[begin, end)` with elements separated by `sep`. */ template auto join(It begin, Sentinel end, string_view sep) -> join_view { return {begin, end, sep}; } /** \rst Returns a view that formats `range` with elements separated by `sep`. **Example**:: std::vector v = {1, 2, 3}; fmt::print("{}", fmt::join(v, ", ")); // Output: "1, 2, 3" ``fmt::join`` applies passed format specifiers to the range elements:: fmt::print("{:02}", fmt::join(v, ", ")); // Output: "01, 02, 03" \endrst */ template auto join(Range&& range, string_view sep) -> join_view, detail::sentinel_t> { return join(std::begin(range), std::end(range), sep); } /** \rst Converts *value* to ``std::string`` using the default format for type *T*. **Example**:: #include std::string answer = fmt::to_string(42); \endrst */ template ::value && !detail::has_format_as::value)> inline auto to_string(const T& value) -> std::string { auto buffer = memory_buffer(); detail::write(appender(buffer), value); return {buffer.data(), buffer.size()}; } template ::value)> FMT_NODISCARD inline auto to_string(T value) -> std::string { // The buffer should be large enough to store the number including the sign // or "false" for bool. constexpr int max_size = detail::digits10() + 2; char buffer[max_size > 5 ? static_cast(max_size) : 5]; char* begin = buffer; return std::string(begin, detail::write(begin, value)); } template FMT_NODISCARD auto to_string(const basic_memory_buffer& buf) -> std::basic_string { auto size = buf.size(); detail::assume(size < std::basic_string().max_size()); return std::basic_string(buf.data(), size); } template ::value && detail::has_format_as::value)> inline auto to_string(const T& value) -> std::string { return to_string(format_as(value)); } FMT_END_EXPORT namespace detail { template void vformat_to(buffer& buf, basic_string_view fmt, typename vformat_args::type args, locale_ref loc) { auto out = buffer_appender(buf); if (fmt.size() == 2 && equal2(fmt.data(), "{}")) { auto arg = args.get(0); if (!arg) throw_format_error("argument not found"); visit_format_arg(default_arg_formatter{out, args, loc}, arg); return; } struct format_handler : error_handler { basic_format_parse_context parse_context; buffer_context context; format_handler(buffer_appender p_out, basic_string_view str, basic_format_args> p_args, locale_ref p_loc) : parse_context(str), context(p_out, p_args, p_loc) {} void on_text(const Char* begin, const Char* end) { auto text = basic_string_view(begin, to_unsigned(end - begin)); context.advance_to(write(context.out(), text)); } FMT_CONSTEXPR auto on_arg_id() -> int { return parse_context.next_arg_id(); } FMT_CONSTEXPR auto on_arg_id(int id) -> int { return parse_context.check_arg_id(id), id; } FMT_CONSTEXPR auto on_arg_id(basic_string_view id) -> int { int arg_id = context.arg_id(id); if (arg_id < 0) throw_format_error("argument not found"); return arg_id; } FMT_INLINE void on_replacement_field(int id, const Char*) { auto arg = get_arg(context, id); context.advance_to(visit_format_arg( default_arg_formatter{context.out(), context.args(), context.locale()}, arg)); } auto on_format_specs(int id, const Char* begin, const Char* end) -> const Char* { auto arg = get_arg(context, id); // Not using a visitor for custom types gives better codegen. if (arg.format_custom(begin, parse_context, context)) return parse_context.begin(); auto specs = detail::dynamic_format_specs(); begin = parse_format_specs(begin, end, specs, parse_context, arg.type()); detail::handle_dynamic_spec( specs.width, specs.width_ref, context); detail::handle_dynamic_spec( specs.precision, specs.precision_ref, context); if (begin == end || *begin != '}') throw_format_error("missing '}' in format string"); auto f = arg_formatter{context.out(), specs, context.locale()}; context.advance_to(visit_format_arg(f, arg)); return begin; } }; detail::parse_format_string(fmt, format_handler(out, fmt, args, loc)); } FMT_BEGIN_EXPORT #ifndef FMT_HEADER_ONLY extern template FMT_API void vformat_to(buffer&, string_view, typename vformat_args<>::type, locale_ref); extern template FMT_API auto thousands_sep_impl(locale_ref) -> thousands_sep_result; extern template FMT_API auto thousands_sep_impl(locale_ref) -> thousands_sep_result; extern template FMT_API auto decimal_point_impl(locale_ref) -> char; extern template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t; #endif // FMT_HEADER_ONLY } // namespace detail #if FMT_USE_USER_DEFINED_LITERALS inline namespace literals { /** \rst User-defined literal equivalent of :func:`fmt::arg`. **Example**:: using namespace fmt::literals; fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23); \endrst */ # if FMT_USE_NONTYPE_TEMPLATE_ARGS template constexpr auto operator""_a() { using char_t = remove_cvref_t; return detail::udl_arg(); } # else constexpr auto operator""_a(const char* s, size_t) -> detail::udl_arg { return {s}; } # endif } // namespace literals #endif // FMT_USE_USER_DEFINED_LITERALS template ::value)> inline auto vformat(const Locale& loc, string_view fmt, format_args args) -> std::string { return detail::vformat(loc, fmt, args); } template ::value)> inline auto format(const Locale& loc, format_string fmt, T&&... args) -> std::string { return fmt::vformat(loc, string_view(fmt), fmt::make_format_args(args...)); } template ::value&& detail::is_locale::value)> auto vformat_to(OutputIt out, const Locale& loc, string_view fmt, format_args args) -> OutputIt { using detail::get_buffer; auto&& buf = get_buffer(out); detail::vformat_to(buf, fmt, args, detail::locale_ref(loc)); return detail::get_iterator(buf, out); } template ::value&& detail::is_locale::value)> FMT_INLINE auto format_to(OutputIt out, const Locale& loc, format_string fmt, T&&... args) -> OutputIt { return vformat_to(out, loc, fmt, fmt::make_format_args(args...)); } template ::value)> FMT_NODISCARD FMT_INLINE auto formatted_size(const Locale& loc, format_string fmt, T&&... args) -> size_t { auto buf = detail::counting_buffer<>(); detail::vformat_to(buf, fmt, fmt::make_format_args(args...), detail::locale_ref(loc)); return buf.count(); } FMT_END_EXPORT template template FMT_CONSTEXPR FMT_INLINE auto formatter::value != detail::type::custom_type>>::format(const T& val, FormatContext& ctx) const -> decltype(ctx.out()) { if (specs_.width_ref.kind == detail::arg_id_kind::none && specs_.precision_ref.kind == detail::arg_id_kind::none) { return detail::write(ctx.out(), val, specs_, ctx.locale()); } auto specs = specs_; detail::handle_dynamic_spec(specs.width, specs.width_ref, ctx); detail::handle_dynamic_spec( specs.precision, specs.precision_ref, ctx); return detail::write(ctx.out(), val, specs, ctx.locale()); } FMT_END_NAMESPACE #ifdef FMT_HEADER_ONLY # define FMT_FUNC inline # include "format-inl.h" #else # define FMT_FUNC #endif #endif // FMT_FORMAT_H_ RcppSpdlog/inst/include/spdlog/fmt/bundled/xchar.h0000644000176200001440000002335214612604314021706 0ustar liggesusers// Formatting library for C++ - optional wchar_t and exotic character support // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_XCHAR_H_ #define FMT_XCHAR_H_ #include #include "format.h" #ifndef FMT_STATIC_THOUSANDS_SEPARATOR # include #endif FMT_BEGIN_NAMESPACE namespace detail { template using is_exotic_char = bool_constant::value>; inline auto write_loc(std::back_insert_iterator> out, loc_value value, const format_specs& specs, locale_ref loc) -> bool { #ifndef FMT_STATIC_THOUSANDS_SEPARATOR auto& numpunct = std::use_facet>(loc.get()); auto separator = std::wstring(); auto grouping = numpunct.grouping(); if (!grouping.empty()) separator = std::wstring(1, numpunct.thousands_sep()); return value.visit(loc_writer{out, specs, separator, grouping, {}}); #endif return false; } } // namespace detail FMT_BEGIN_EXPORT using wstring_view = basic_string_view; using wformat_parse_context = basic_format_parse_context; using wformat_context = buffer_context; using wformat_args = basic_format_args; using wmemory_buffer = basic_memory_buffer; #if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 // Workaround broken conversion on older gcc. template using wformat_string = wstring_view; inline auto runtime(wstring_view s) -> wstring_view { return s; } #else template using wformat_string = basic_format_string...>; inline auto runtime(wstring_view s) -> runtime_format_string { return {{s}}; } #endif template <> struct is_char : std::true_type {}; template <> struct is_char : std::true_type {}; template <> struct is_char : std::true_type {}; template <> struct is_char : std::true_type {}; template constexpr auto make_wformat_args(const T&... args) -> format_arg_store { return {args...}; } inline namespace literals { #if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_ARGS constexpr auto operator""_a(const wchar_t* s, size_t) -> detail::udl_arg { return {s}; } #endif } // namespace literals template auto join(It begin, Sentinel end, wstring_view sep) -> join_view { return {begin, end, sep}; } template auto join(Range&& range, wstring_view sep) -> join_view, detail::sentinel_t, wchar_t> { return join(std::begin(range), std::end(range), sep); } template auto join(std::initializer_list list, wstring_view sep) -> join_view { return join(std::begin(list), std::end(list), sep); } template ::value)> auto vformat(basic_string_view format_str, basic_format_args>> args) -> std::basic_string { auto buf = basic_memory_buffer(); detail::vformat_to(buf, format_str, args); return to_string(buf); } template auto format(wformat_string fmt, T&&... args) -> std::wstring { return vformat(fmt::wstring_view(fmt), fmt::make_wformat_args(args...)); } // Pass char_t as a default template parameter instead of using // std::basic_string> to reduce the symbol size. template , FMT_ENABLE_IF(!std::is_same::value && !std::is_same::value)> auto format(const S& format_str, T&&... args) -> std::basic_string { return vformat(detail::to_string_view(format_str), fmt::make_format_args>(args...)); } template , FMT_ENABLE_IF(detail::is_locale::value&& detail::is_exotic_char::value)> inline auto vformat( const Locale& loc, const S& format_str, basic_format_args>> args) -> std::basic_string { return detail::vformat(loc, detail::to_string_view(format_str), args); } template , FMT_ENABLE_IF(detail::is_locale::value&& detail::is_exotic_char::value)> inline auto format(const Locale& loc, const S& format_str, T&&... args) -> std::basic_string { return detail::vformat(loc, detail::to_string_view(format_str), fmt::make_format_args>(args...)); } template , FMT_ENABLE_IF(detail::is_output_iterator::value&& detail::is_exotic_char::value)> auto vformat_to(OutputIt out, const S& format_str, basic_format_args>> args) -> OutputIt { auto&& buf = detail::get_buffer(out); detail::vformat_to(buf, detail::to_string_view(format_str), args); return detail::get_iterator(buf, out); } template , FMT_ENABLE_IF(detail::is_output_iterator::value&& detail::is_exotic_char::value)> inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt { return vformat_to(out, detail::to_string_view(fmt), fmt::make_format_args>(args...)); } template , FMT_ENABLE_IF(detail::is_output_iterator::value&& detail::is_locale::value&& detail::is_exotic_char::value)> inline auto vformat_to( OutputIt out, const Locale& loc, const S& format_str, basic_format_args>> args) -> OutputIt { auto&& buf = detail::get_buffer(out); vformat_to(buf, detail::to_string_view(format_str), args, detail::locale_ref(loc)); return detail::get_iterator(buf, out); } template , bool enable = detail::is_output_iterator::value && detail::is_locale::value && detail::is_exotic_char::value> inline auto format_to(OutputIt out, const Locale& loc, const S& format_str, T&&... args) -> typename std::enable_if::type { return vformat_to(out, loc, detail::to_string_view(format_str), fmt::make_format_args>(args...)); } template ::value&& detail::is_exotic_char::value)> inline auto vformat_to_n( OutputIt out, size_t n, basic_string_view format_str, basic_format_args>> args) -> format_to_n_result { using traits = detail::fixed_buffer_traits; auto buf = detail::iterator_buffer(out, n); detail::vformat_to(buf, format_str, args); return {buf.out(), buf.count()}; } template , FMT_ENABLE_IF(detail::is_output_iterator::value&& detail::is_exotic_char::value)> inline auto format_to_n(OutputIt out, size_t n, const S& fmt, T&&... args) -> format_to_n_result { return vformat_to_n(out, n, detail::to_string_view(fmt), fmt::make_format_args>(args...)); } template , FMT_ENABLE_IF(detail::is_exotic_char::value)> inline auto formatted_size(const S& fmt, T&&... args) -> size_t { auto buf = detail::counting_buffer(); detail::vformat_to(buf, detail::to_string_view(fmt), fmt::make_format_args>(args...)); return buf.count(); } inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) { auto buf = wmemory_buffer(); detail::vformat_to(buf, fmt, args); buf.push_back(L'\0'); if (std::fputws(buf.data(), f) == -1) FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); } inline void vprint(wstring_view fmt, wformat_args args) { vprint(stdout, fmt, args); } template void print(std::FILE* f, wformat_string fmt, T&&... args) { return vprint(f, wstring_view(fmt), fmt::make_wformat_args(args...)); } template void print(wformat_string fmt, T&&... args) { return vprint(wstring_view(fmt), fmt::make_wformat_args(args...)); } template void println(std::FILE* f, wformat_string fmt, T&&... args) { return print(f, L"{}\n", fmt::format(fmt, std::forward(args)...)); } template void println(wformat_string fmt, T&&... args) { return print(L"{}\n", fmt::format(fmt, std::forward(args)...)); } /** Converts *value* to ``std::wstring`` using the default format for type *T*. */ template inline auto to_wstring(const T& value) -> std::wstring { return format(FMT_STRING(L"{}"), value); } FMT_END_EXPORT FMT_END_NAMESPACE #endif // FMT_XCHAR_H_ RcppSpdlog/inst/include/spdlog/fmt/compile.h0000644000176200001440000000105714550234366020621 0ustar liggesusers// // Copyright(c) 2016 Gabi Melman. // Distributed under the MIT License (http://opensource.org/licenses/MIT) // #pragma once // // include bundled or external copy of fmtlib's compile-time support // #include #if !defined(SPDLOG_USE_STD_FORMAT) #if !defined(SPDLOG_FMT_EXTERNAL) #ifdef SPDLOG_HEADER_ONLY #ifndef FMT_HEADER_ONLY #define FMT_HEADER_ONLY #endif #endif #include #else #include #endif #endif RcppSpdlog/inst/include/spdlog/fmt/chrono.h0000644000176200001440000000104714550234366020460 0ustar liggesusers// // Copyright(c) 2016 Gabi Melman. // Distributed under the MIT License (http://opensource.org/licenses/MIT) // #pragma once // // include bundled or external copy of fmtlib's chrono support // #include #if !defined(SPDLOG_USE_STD_FORMAT) #if !defined(SPDLOG_FMT_EXTERNAL) #ifdef SPDLOG_HEADER_ONLY #ifndef FMT_HEADER_ONLY #define FMT_HEADER_ONLY #endif #endif #include #else #include #endif #endif RcppSpdlog/inst/include/spdlog/fmt/std.h0000644000176200001440000000120114550234366017752 0ustar liggesusers// // Copyright(c) 2016 Gabi Melman. // Distributed under the MIT License (http://opensource.org/licenses/MIT) // #pragma once // // include bundled or external copy of fmtlib's std support (for formatting e.g. // std::filesystem::path, std::thread::id, std::monostate, std::variant, ...) // #include #if !defined(SPDLOG_USE_STD_FORMAT) #if !defined(SPDLOG_FMT_EXTERNAL) #ifdef SPDLOG_HEADER_ONLY #ifndef FMT_HEADER_ONLY #define FMT_HEADER_ONLY #endif #endif #include #else #include #endif #endif RcppSpdlog/inst/include/spdlog/fmt/ranges.h0000644000176200001440000000104714550234366020447 0ustar liggesusers// // Copyright(c) 2016 Gabi Melman. // Distributed under the MIT License (http://opensource.org/licenses/MIT) // #pragma once // // include bundled or external copy of fmtlib's ranges support // #include #if !defined(SPDLOG_USE_STD_FORMAT) #if !defined(SPDLOG_FMT_EXTERNAL) #ifdef SPDLOG_HEADER_ONLY #ifndef FMT_HEADER_ONLY #define FMT_HEADER_ONLY #endif #endif #include #else #include #endif #endif RcppSpdlog/inst/include/spdlog/fmt/fmt.h0000644000176200001440000000147514612604314017754 0ustar liggesusers// // Copyright(c) 2016-2018 Gabi Melman. // Distributed under the MIT License (http://opensource.org/licenses/MIT) // #pragma once // // Include a bundled header-only copy of fmtlib or an external one. // By default spdlog include its own copy. // #include #if defined(SPDLOG_USE_STD_FORMAT) // SPDLOG_USE_STD_FORMAT is defined - use std::format #include #elif !defined(SPDLOG_FMT_EXTERNAL) #if !defined(SPDLOG_COMPILED_LIB) && !defined(FMT_HEADER_ONLY) #define FMT_HEADER_ONLY #endif #ifndef FMT_USE_WINDOWS_H #define FMT_USE_WINDOWS_H 0 #endif #include #include #else // SPDLOG_FMT_EXTERNAL is defined - use external fmtlib #include #include #endif RcppSpdlog/inst/include/spdlog/fmt/bin_to_hex.h0000644000176200001440000001632414550234366021312 0ustar liggesusers// // Copyright(c) 2015 Gabi Melman. // Distributed under the MIT License (http://opensource.org/licenses/MIT) // #pragma once #include #include #if defined(__has_include) #if __has_include() #include #endif #endif #if __cpp_lib_span >= 202002L #include #endif // // Support for logging binary data as hex // format flags, any combination of the following: // {:X} - print in uppercase. // {:s} - don't separate each byte with space. // {:p} - don't print the position on each line start. // {:n} - don't split the output to lines. // {:a} - show ASCII if :n is not set // // Examples: // // std::vector v(200, 0x0b); // logger->info("Some buffer {}", spdlog::to_hex(v)); // char buf[128]; // logger->info("Some buffer {:X}", spdlog::to_hex(std::begin(buf), std::end(buf))); // logger->info("Some buffer {:X}", spdlog::to_hex(std::begin(buf), std::end(buf), 16)); namespace spdlog { namespace details { template class dump_info { public: dump_info(It range_begin, It range_end, size_t size_per_line) : begin_(range_begin), end_(range_end), size_per_line_(size_per_line) {} // do not use begin() and end() to avoid collision with fmt/ranges It get_begin() const { return begin_; } It get_end() const { return end_; } size_t size_per_line() const { return size_per_line_; } private: It begin_, end_; size_t size_per_line_; }; } // namespace details // create a dump_info that wraps the given container template inline details::dump_info to_hex(const Container &container, size_t size_per_line = 32) { static_assert(sizeof(typename Container::value_type) == 1, "sizeof(Container::value_type) != 1"); using Iter = typename Container::const_iterator; return details::dump_info(std::begin(container), std::end(container), size_per_line); } #if __cpp_lib_span >= 202002L template inline details::dump_info::iterator> to_hex( const std::span &container, size_t size_per_line = 32) { using Container = std::span; static_assert(sizeof(typename Container::value_type) == 1, "sizeof(Container::value_type) != 1"); using Iter = typename Container::iterator; return details::dump_info(std::begin(container), std::end(container), size_per_line); } #endif // create dump_info from ranges template inline details::dump_info to_hex(const It range_begin, const It range_end, size_t size_per_line = 32) { return details::dump_info(range_begin, range_end, size_per_line); } } // namespace spdlog namespace #ifdef SPDLOG_USE_STD_FORMAT std #else fmt #endif { template struct formatter, char> { const char delimiter = ' '; bool put_newlines = true; bool put_delimiters = true; bool use_uppercase = false; bool put_positions = true; // position on start of each line bool show_ascii = false; // parse the format string flags template SPDLOG_CONSTEXPR_FUNC auto parse(ParseContext &ctx) -> decltype(ctx.begin()) { auto it = ctx.begin(); while (it != ctx.end() && *it != '}') { switch (*it) { case 'X': use_uppercase = true; break; case 's': put_delimiters = false; break; case 'p': put_positions = false; break; case 'n': put_newlines = false; show_ascii = false; break; case 'a': if (put_newlines) { show_ascii = true; } break; } ++it; } return it; } // format the given bytes range as hex template auto format(const spdlog::details::dump_info &the_range, FormatContext &ctx) const -> decltype(ctx.out()) { SPDLOG_CONSTEXPR const char *hex_upper = "0123456789ABCDEF"; SPDLOG_CONSTEXPR const char *hex_lower = "0123456789abcdef"; const char *hex_chars = use_uppercase ? hex_upper : hex_lower; #if !defined(SPDLOG_USE_STD_FORMAT) && FMT_VERSION < 60000 auto inserter = ctx.begin(); #else auto inserter = ctx.out(); #endif int size_per_line = static_cast(the_range.size_per_line()); auto start_of_line = the_range.get_begin(); for (auto i = the_range.get_begin(); i != the_range.get_end(); i++) { auto ch = static_cast(*i); if (put_newlines && (i == the_range.get_begin() || i - start_of_line >= size_per_line)) { if (show_ascii && i != the_range.get_begin()) { *inserter++ = delimiter; *inserter++ = delimiter; for (auto j = start_of_line; j < i; j++) { auto pc = static_cast(*j); *inserter++ = std::isprint(pc) ? static_cast(*j) : '.'; } } put_newline(inserter, static_cast(i - the_range.get_begin())); // put first byte without delimiter in front of it *inserter++ = hex_chars[(ch >> 4) & 0x0f]; *inserter++ = hex_chars[ch & 0x0f]; start_of_line = i; continue; } if (put_delimiters && i != the_range.get_begin()) { *inserter++ = delimiter; } *inserter++ = hex_chars[(ch >> 4) & 0x0f]; *inserter++ = hex_chars[ch & 0x0f]; } if (show_ascii) // add ascii to last line { if (the_range.get_end() - the_range.get_begin() > size_per_line) { auto blank_num = size_per_line - (the_range.get_end() - start_of_line); while (blank_num-- > 0) { *inserter++ = delimiter; *inserter++ = delimiter; if (put_delimiters) { *inserter++ = delimiter; } } } *inserter++ = delimiter; *inserter++ = delimiter; for (auto j = start_of_line; j != the_range.get_end(); j++) { auto pc = static_cast(*j); *inserter++ = std::isprint(pc) ? static_cast(*j) : '.'; } } return inserter; } // put newline(and position header) template void put_newline(It inserter, std::size_t pos) const { #ifdef _WIN32 *inserter++ = '\r'; #endif *inserter++ = '\n'; if (put_positions) { spdlog::fmt_lib::format_to(inserter, SPDLOG_FMT_STRING("{:04X}: "), pos); } } }; } // namespace std RcppSpdlog/inst/include/spdlog/fmt/xchar.h0000644000176200001440000000104414550234366020272 0ustar liggesusers// // Copyright(c) 2016 Gabi Melman. // Distributed under the MIT License (http://opensource.org/licenses/MIT) // #pragma once // // include bundled or external copy of fmtlib's xchar support // #include #if !defined(SPDLOG_USE_STD_FORMAT) #if !defined(SPDLOG_FMT_EXTERNAL) #ifdef SPDLOG_HEADER_ONLY #ifndef FMT_HEADER_ONLY #define FMT_HEADER_ONLY #endif #endif #include #else #include #endif #endif RcppSpdlog/inst/include/spdlog/spdlog-inl.h0000644000176200001440000000651114612604314020444 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifndef SPDLOG_HEADER_ONLY #include #endif #include #include namespace spdlog { SPDLOG_INLINE void initialize_logger(std::shared_ptr logger) { details::registry::instance().initialize_logger(std::move(logger)); } SPDLOG_INLINE std::shared_ptr get(const std::string &name) { return details::registry::instance().get(name); } #if __cplusplus >= 201703L // C++17 SPDLOG_INLINE std::shared_ptr get(std::string_view name) { return details::registry::instance().get(name); } SPDLOG_INLINE std::shared_ptr get(const char *name) { return details::registry::instance().get(name); } #endif SPDLOG_INLINE void set_formatter(std::unique_ptr formatter) { details::registry::instance().set_formatter(std::move(formatter)); } SPDLOG_INLINE void set_pattern(std::string pattern, pattern_time_type time_type) { set_formatter( std::unique_ptr(new pattern_formatter(std::move(pattern), time_type))); } SPDLOG_INLINE void enable_backtrace(size_t n_messages) { details::registry::instance().enable_backtrace(n_messages); } SPDLOG_INLINE void disable_backtrace() { details::registry::instance().disable_backtrace(); } SPDLOG_INLINE void dump_backtrace() { default_logger_raw()->dump_backtrace(); } SPDLOG_INLINE level::level_enum get_level() { return default_logger_raw()->level(); } SPDLOG_INLINE bool should_log(level::level_enum log_level) { return default_logger_raw()->should_log(log_level); } SPDLOG_INLINE void set_level(level::level_enum log_level) { details::registry::instance().set_level(log_level); } SPDLOG_INLINE void flush_on(level::level_enum log_level) { details::registry::instance().flush_on(log_level); } SPDLOG_INLINE void set_error_handler(void (*handler)(const std::string &msg)) { details::registry::instance().set_error_handler(handler); } SPDLOG_INLINE void register_logger(std::shared_ptr logger) { details::registry::instance().register_logger(std::move(logger)); } SPDLOG_INLINE void apply_all(const std::function)> &fun) { details::registry::instance().apply_all(fun); } SPDLOG_INLINE void drop(const std::string &name) { details::registry::instance().drop(name); } SPDLOG_INLINE void drop_all() { details::registry::instance().drop_all(); } SPDLOG_INLINE void shutdown() { details::registry::instance().shutdown(); } SPDLOG_INLINE void set_automatic_registration(bool automatic_registration) { details::registry::instance().set_automatic_registration(automatic_registration); } SPDLOG_INLINE std::shared_ptr default_logger() { return details::registry::instance().default_logger(); } SPDLOG_INLINE spdlog::logger *default_logger_raw() { return details::registry::instance().get_default_raw(); } SPDLOG_INLINE void set_default_logger(std::shared_ptr default_logger) { details::registry::instance().set_default_logger(std::move(default_logger)); } SPDLOG_INLINE void apply_logger_env_levels(std::shared_ptr logger) { details::registry::instance().apply_logger_env_levels(std::move(logger)); } } // namespace spdlog RcppSpdlog/inst/include/spdlog/common-inl.h0000644000176200001440000000400214550234366020444 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifndef SPDLOG_HEADER_ONLY #include #endif #include #include namespace spdlog { namespace level { #if __cplusplus >= 201703L constexpr #endif static string_view_t level_string_views[] SPDLOG_LEVEL_NAMES; static const char *short_level_names[] SPDLOG_SHORT_LEVEL_NAMES; SPDLOG_INLINE const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT { return level_string_views[l]; } SPDLOG_INLINE const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT { return short_level_names[l]; } SPDLOG_INLINE spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT { auto it = std::find(std::begin(level_string_views), std::end(level_string_views), name); if (it != std::end(level_string_views)) return static_cast(std::distance(std::begin(level_string_views), it)); // check also for "warn" and "err" before giving up.. if (name == "warn") { return level::warn; } if (name == "err") { return level::err; } return level::off; } } // namespace level SPDLOG_INLINE spdlog_ex::spdlog_ex(std::string msg) : msg_(std::move(msg)) {} SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno) { #ifdef SPDLOG_USE_STD_FORMAT msg_ = std::system_error(std::error_code(last_errno, std::generic_category()), msg).what(); #else memory_buf_t outbuf; fmt::format_system_error(outbuf, last_errno, msg.c_str()); msg_ = fmt::to_string(outbuf); #endif } SPDLOG_INLINE const char *spdlog_ex::what() const SPDLOG_NOEXCEPT { return msg_.c_str(); } SPDLOG_INLINE void throw_spdlog_ex(const std::string &msg, int last_errno) { SPDLOG_THROW(spdlog_ex(msg, last_errno)); } SPDLOG_INLINE void throw_spdlog_ex(std::string msg) { SPDLOG_THROW(spdlog_ex(std::move(msg))); } } // namespace spdlog RcppSpdlog/inst/include/spdlog/logger-inl.h0000644000176200001440000001510514550234366020441 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifndef SPDLOG_HEADER_ONLY #include #endif #include #include #include #include namespace spdlog { // public methods SPDLOG_INLINE logger::logger(const logger &other) : name_(other.name_), sinks_(other.sinks_), level_(other.level_.load(std::memory_order_relaxed)), flush_level_(other.flush_level_.load(std::memory_order_relaxed)), custom_err_handler_(other.custom_err_handler_), tracer_(other.tracer_) {} SPDLOG_INLINE logger::logger(logger &&other) SPDLOG_NOEXCEPT : name_(std::move(other.name_)), sinks_(std::move(other.sinks_)), level_(other.level_.load(std::memory_order_relaxed)), flush_level_(other.flush_level_.load(std::memory_order_relaxed)), custom_err_handler_(std::move(other.custom_err_handler_)), tracer_(std::move(other.tracer_)) {} SPDLOG_INLINE logger &logger::operator=(logger other) SPDLOG_NOEXCEPT { this->swap(other); return *this; } SPDLOG_INLINE void logger::swap(spdlog::logger &other) SPDLOG_NOEXCEPT { name_.swap(other.name_); sinks_.swap(other.sinks_); // swap level_ auto other_level = other.level_.load(); auto my_level = level_.exchange(other_level); other.level_.store(my_level); // swap flush level_ other_level = other.flush_level_.load(); my_level = flush_level_.exchange(other_level); other.flush_level_.store(my_level); custom_err_handler_.swap(other.custom_err_handler_); std::swap(tracer_, other.tracer_); } SPDLOG_INLINE void swap(logger &a, logger &b) { a.swap(b); } SPDLOG_INLINE void logger::set_level(level::level_enum log_level) { level_.store(log_level); } SPDLOG_INLINE level::level_enum logger::level() const { return static_cast(level_.load(std::memory_order_relaxed)); } SPDLOG_INLINE const std::string &logger::name() const { return name_; } // set formatting for the sinks in this logger. // each sink will get a separate instance of the formatter object. SPDLOG_INLINE void logger::set_formatter(std::unique_ptr f) { for (auto it = sinks_.begin(); it != sinks_.end(); ++it) { if (std::next(it) == sinks_.end()) { // last element - we can be move it. (*it)->set_formatter(std::move(f)); break; // to prevent clang-tidy warning } else { (*it)->set_formatter(f->clone()); } } } SPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type time_type) { auto new_formatter = details::make_unique(std::move(pattern), time_type); set_formatter(std::move(new_formatter)); } // create new backtrace sink and move to it all our child sinks SPDLOG_INLINE void logger::enable_backtrace(size_t n_messages) { tracer_.enable(n_messages); } // restore orig sinks and level and delete the backtrace sink SPDLOG_INLINE void logger::disable_backtrace() { tracer_.disable(); } SPDLOG_INLINE void logger::dump_backtrace() { dump_backtrace_(); } // flush functions SPDLOG_INLINE void logger::flush() { flush_(); } SPDLOG_INLINE void logger::flush_on(level::level_enum log_level) { flush_level_.store(log_level); } SPDLOG_INLINE level::level_enum logger::flush_level() const { return static_cast(flush_level_.load(std::memory_order_relaxed)); } // sinks SPDLOG_INLINE const std::vector &logger::sinks() const { return sinks_; } SPDLOG_INLINE std::vector &logger::sinks() { return sinks_; } // error handler SPDLOG_INLINE void logger::set_error_handler(err_handler handler) { custom_err_handler_ = std::move(handler); } // create new logger with same sinks and configuration. SPDLOG_INLINE std::shared_ptr logger::clone(std::string logger_name) { auto cloned = std::make_shared(*this); cloned->name_ = std::move(logger_name); return cloned; } // protected methods SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg &log_msg, bool log_enabled, bool traceback_enabled) { if (log_enabled) { sink_it_(log_msg); } if (traceback_enabled) { tracer_.push_back(log_msg); } } SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg) { for (auto &sink : sinks_) { if (sink->should_log(msg.level)) { SPDLOG_TRY { sink->log(msg); } SPDLOG_LOGGER_CATCH(msg.source) } } if (should_flush_(msg)) { flush_(); } } SPDLOG_INLINE void logger::flush_() { for (auto &sink : sinks_) { SPDLOG_TRY { sink->flush(); } SPDLOG_LOGGER_CATCH(source_loc()) } } SPDLOG_INLINE void logger::dump_backtrace_() { using details::log_msg; if (tracer_.enabled() && !tracer_.empty()) { sink_it_( log_msg{name(), level::info, "****************** Backtrace Start ******************"}); tracer_.foreach_pop([this](const log_msg &msg) { this->sink_it_(msg); }); sink_it_( log_msg{name(), level::info, "****************** Backtrace End ********************"}); } } SPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg) { auto flush_level = flush_level_.load(std::memory_order_relaxed); return (msg.level >= flush_level) && (msg.level != level::off); } SPDLOG_INLINE void logger::err_handler_(const std::string &msg) { if (custom_err_handler_) { custom_err_handler_(msg); } else { using std::chrono::system_clock; static std::mutex mutex; static std::chrono::system_clock::time_point last_report_time; static size_t err_counter = 0; std::lock_guard lk{mutex}; auto now = system_clock::now(); err_counter++; if (now - last_report_time < std::chrono::seconds(1)) { return; } last_report_time = now; auto tm_time = details::os::localtime(system_clock::to_time_t(now)); char date_buf[64]; std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time); #if defined(USING_R) && defined(R_R_H) // if in R environment REprintf("[*** LOG ERROR #%04zu ***] [%s] [%s] %s\n", err_counter, date_buf, name().c_str(), msg.c_str()); #else std::fprintf(stderr, "[*** LOG ERROR #%04zu ***] [%s] [%s] %s\n", err_counter, date_buf, name().c_str(), msg.c_str()); #endif } } } // namespace spdlog RcppSpdlog/inst/include/spdlog/version.h0000644000176200001440000000064114612604314020057 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #define SPDLOG_VER_MAJOR 1 #define SPDLOG_VER_MINOR 14 #define SPDLOG_VER_PATCH 0 #define SPDLOG_TO_VERSION(major, minor, patch) (major * 10000 + minor * 100 + patch) #define SPDLOG_VERSION SPDLOG_TO_VERSION(SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR, SPDLOG_VER_PATCH) RcppSpdlog/inst/include/spdlog/pattern_formatter-inl.h0000644000176200001440000013257414612604314022725 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifndef SPDLOG_HEADER_ONLY #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace spdlog { namespace details { /////////////////////////////////////////////////////////////////////// // name & level pattern appender /////////////////////////////////////////////////////////////////////// class scoped_padder { public: scoped_padder(size_t wrapped_size, const padding_info &padinfo, memory_buf_t &dest) : padinfo_(padinfo), dest_(dest) { remaining_pad_ = static_cast(padinfo.width_) - static_cast(wrapped_size); if (remaining_pad_ <= 0) { return; } if (padinfo_.side_ == padding_info::pad_side::left) { pad_it(remaining_pad_); remaining_pad_ = 0; } else if (padinfo_.side_ == padding_info::pad_side::center) { auto half_pad = remaining_pad_ / 2; auto reminder = remaining_pad_ & 1; pad_it(half_pad); remaining_pad_ = half_pad + reminder; // for the right side } } template static unsigned int count_digits(T n) { return fmt_helper::count_digits(n); } ~scoped_padder() { if (remaining_pad_ >= 0) { pad_it(remaining_pad_); } else if (padinfo_.truncate_) { long new_size = static_cast(dest_.size()) + remaining_pad_; dest_.resize(static_cast(new_size)); } } private: void pad_it(long count) { fmt_helper::append_string_view(string_view_t(spaces_.data(), static_cast(count)), dest_); } const padding_info &padinfo_; memory_buf_t &dest_; long remaining_pad_; string_view_t spaces_{" ", 64}; }; struct null_scoped_padder { null_scoped_padder(size_t /*wrapped_size*/, const padding_info & /*padinfo*/, memory_buf_t & /*dest*/) {} template static unsigned int count_digits(T /* number */) { return 0; } }; template class name_formatter final : public flag_formatter { public: explicit name_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { ScopedPadder p(msg.logger_name.size(), padinfo_, dest); fmt_helper::append_string_view(msg.logger_name, dest); } }; // log level appender template class level_formatter final : public flag_formatter { public: explicit level_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { const string_view_t &level_name = level::to_string_view(msg.level); ScopedPadder p(level_name.size(), padinfo_, dest); fmt_helper::append_string_view(level_name, dest); } }; // short log level appender template class short_level_formatter final : public flag_formatter { public: explicit short_level_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { string_view_t level_name{level::to_short_c_str(msg.level)}; ScopedPadder p(level_name.size(), padinfo_, dest); fmt_helper::append_string_view(level_name, dest); } }; /////////////////////////////////////////////////////////////////////// // Date time pattern appenders /////////////////////////////////////////////////////////////////////// static const char *ampm(const tm &t) { return t.tm_hour >= 12 ? "PM" : "AM"; } static int to12h(const tm &t) { return t.tm_hour > 12 ? t.tm_hour - 12 : t.tm_hour; } // Abbreviated weekday name static std::array days{{"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}}; template class a_formatter final : public flag_formatter { public: explicit a_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { string_view_t field_value{days[static_cast(tm_time.tm_wday)]}; ScopedPadder p(field_value.size(), padinfo_, dest); fmt_helper::append_string_view(field_value, dest); } }; // Full weekday name static std::array full_days{ {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}}; template class A_formatter : public flag_formatter { public: explicit A_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { string_view_t field_value{full_days[static_cast(tm_time.tm_wday)]}; ScopedPadder p(field_value.size(), padinfo_, dest); fmt_helper::append_string_view(field_value, dest); } }; // Abbreviated month static const std::array months{ {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sept", "Oct", "Nov", "Dec"}}; template class b_formatter final : public flag_formatter { public: explicit b_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { string_view_t field_value{months[static_cast(tm_time.tm_mon)]}; ScopedPadder p(field_value.size(), padinfo_, dest); fmt_helper::append_string_view(field_value, dest); } }; // Full month name static const std::array full_months{{"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"}}; template class B_formatter final : public flag_formatter { public: explicit B_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { string_view_t field_value{full_months[static_cast(tm_time.tm_mon)]}; ScopedPadder p(field_value.size(), padinfo_, dest); fmt_helper::append_string_view(field_value, dest); } }; // Date and time representation (Thu Aug 23 15:35:46 2014) template class c_formatter final : public flag_formatter { public: explicit c_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 24; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::append_string_view(days[static_cast(tm_time.tm_wday)], dest); dest.push_back(' '); fmt_helper::append_string_view(months[static_cast(tm_time.tm_mon)], dest); dest.push_back(' '); fmt_helper::append_int(tm_time.tm_mday, dest); dest.push_back(' '); // time fmt_helper::pad2(tm_time.tm_hour, dest); dest.push_back(':'); fmt_helper::pad2(tm_time.tm_min, dest); dest.push_back(':'); fmt_helper::pad2(tm_time.tm_sec, dest); dest.push_back(' '); fmt_helper::append_int(tm_time.tm_year + 1900, dest); } }; // year - 2 digit template class C_formatter final : public flag_formatter { public: explicit C_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 2; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::pad2(tm_time.tm_year % 100, dest); } }; // Short MM/DD/YY date, equivalent to %m/%d/%y 08/23/01 template class D_formatter final : public flag_formatter { public: explicit D_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 10; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::pad2(tm_time.tm_mon + 1, dest); dest.push_back('/'); fmt_helper::pad2(tm_time.tm_mday, dest); dest.push_back('/'); fmt_helper::pad2(tm_time.tm_year % 100, dest); } }; // year - 4 digit template class Y_formatter final : public flag_formatter { public: explicit Y_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 4; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::append_int(tm_time.tm_year + 1900, dest); } }; // month 1-12 template class m_formatter final : public flag_formatter { public: explicit m_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 2; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::pad2(tm_time.tm_mon + 1, dest); } }; // day of month 1-31 template class d_formatter final : public flag_formatter { public: explicit d_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 2; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::pad2(tm_time.tm_mday, dest); } }; // hours in 24 format 0-23 template class H_formatter final : public flag_formatter { public: explicit H_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 2; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::pad2(tm_time.tm_hour, dest); } }; // hours in 12 format 1-12 template class I_formatter final : public flag_formatter { public: explicit I_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 2; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::pad2(to12h(tm_time), dest); } }; // minutes 0-59 template class M_formatter final : public flag_formatter { public: explicit M_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 2; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::pad2(tm_time.tm_min, dest); } }; // seconds 0-59 template class S_formatter final : public flag_formatter { public: explicit S_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 2; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::pad2(tm_time.tm_sec, dest); } }; // milliseconds template class e_formatter final : public flag_formatter { public: explicit e_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { auto millis = fmt_helper::time_fraction(msg.time); const size_t field_size = 3; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::pad3(static_cast(millis.count()), dest); } }; // microseconds template class f_formatter final : public flag_formatter { public: explicit f_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { auto micros = fmt_helper::time_fraction(msg.time); const size_t field_size = 6; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::pad6(static_cast(micros.count()), dest); } }; // nanoseconds template class F_formatter final : public flag_formatter { public: explicit F_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { auto ns = fmt_helper::time_fraction(msg.time); const size_t field_size = 9; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::pad9(static_cast(ns.count()), dest); } }; // seconds since epoch template class E_formatter final : public flag_formatter { public: explicit E_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { const size_t field_size = 10; ScopedPadder p(field_size, padinfo_, dest); auto duration = msg.time.time_since_epoch(); auto seconds = std::chrono::duration_cast(duration).count(); fmt_helper::append_int(seconds, dest); } }; // AM/PM template class p_formatter final : public flag_formatter { public: explicit p_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 2; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::append_string_view(ampm(tm_time), dest); } }; // 12 hour clock 02:55:02 pm template class r_formatter final : public flag_formatter { public: explicit r_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 11; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::pad2(to12h(tm_time), dest); dest.push_back(':'); fmt_helper::pad2(tm_time.tm_min, dest); dest.push_back(':'); fmt_helper::pad2(tm_time.tm_sec, dest); dest.push_back(' '); fmt_helper::append_string_view(ampm(tm_time), dest); } }; // 24-hour HH:MM time, equivalent to %H:%M template class R_formatter final : public flag_formatter { public: explicit R_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 5; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::pad2(tm_time.tm_hour, dest); dest.push_back(':'); fmt_helper::pad2(tm_time.tm_min, dest); } }; // ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S template class T_formatter final : public flag_formatter { public: explicit T_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 8; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::pad2(tm_time.tm_hour, dest); dest.push_back(':'); fmt_helper::pad2(tm_time.tm_min, dest); dest.push_back(':'); fmt_helper::pad2(tm_time.tm_sec, dest); } }; // ISO 8601 offset from UTC in timezone (+-HH:MM) template class z_formatter final : public flag_formatter { public: explicit z_formatter(padding_info padinfo) : flag_formatter(padinfo) {} z_formatter() = default; z_formatter(const z_formatter &) = delete; z_formatter &operator=(const z_formatter &) = delete; void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 6; ScopedPadder p(field_size, padinfo_, dest); auto total_minutes = get_cached_offset(msg, tm_time); bool is_negative = total_minutes < 0; if (is_negative) { total_minutes = -total_minutes; dest.push_back('-'); } else { dest.push_back('+'); } fmt_helper::pad2(total_minutes / 60, dest); // hours dest.push_back(':'); fmt_helper::pad2(total_minutes % 60, dest); // minutes } private: log_clock::time_point last_update_{std::chrono::seconds(0)}; int offset_minutes_{0}; int get_cached_offset(const log_msg &msg, const std::tm &tm_time) { // refresh every 10 seconds if (msg.time - last_update_ >= std::chrono::seconds(10)) { offset_minutes_ = os::utc_minutes_offset(tm_time); last_update_ = msg.time; } return offset_minutes_; } }; // Thread id template class t_formatter final : public flag_formatter { public: explicit t_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { const auto field_size = ScopedPadder::count_digits(msg.thread_id); ScopedPadder p(field_size, padinfo_, dest); fmt_helper::append_int(msg.thread_id, dest); } }; // Current pid template class pid_formatter final : public flag_formatter { public: explicit pid_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override { const auto pid = static_cast(details::os::pid()); auto field_size = ScopedPadder::count_digits(pid); ScopedPadder p(field_size, padinfo_, dest); fmt_helper::append_int(pid, dest); } }; template class v_formatter final : public flag_formatter { public: explicit v_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { ScopedPadder p(msg.payload.size(), padinfo_, dest); fmt_helper::append_string_view(msg.payload, dest); } }; class ch_formatter final : public flag_formatter { public: explicit ch_formatter(char ch) : ch_(ch) {} void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override { dest.push_back(ch_); } private: char ch_; }; // aggregate user chars to display as is class aggregate_formatter final : public flag_formatter { public: aggregate_formatter() = default; void add_ch(char ch) { str_ += ch; } void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override { fmt_helper::append_string_view(str_, dest); } private: std::string str_; }; // mark the color range. expect it to be in the form of "%^colored text%$" class color_start_formatter final : public flag_formatter { public: explicit color_start_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { msg.color_range_start = dest.size(); } }; class color_stop_formatter final : public flag_formatter { public: explicit color_stop_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { msg.color_range_end = dest.size(); } }; // print source location template class source_location_formatter final : public flag_formatter { public: explicit source_location_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { if (msg.source.empty()) { ScopedPadder p(0, padinfo_, dest); return; } size_t text_size; if (padinfo_.enabled()) { // calc text size for padding based on "filename:line" text_size = std::char_traits::length(msg.source.filename) + ScopedPadder::count_digits(msg.source.line) + 1; } else { text_size = 0; } ScopedPadder p(text_size, padinfo_, dest); fmt_helper::append_string_view(msg.source.filename, dest); dest.push_back(':'); fmt_helper::append_int(msg.source.line, dest); } }; // print source filename template class source_filename_formatter final : public flag_formatter { public: explicit source_filename_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { if (msg.source.empty()) { ScopedPadder p(0, padinfo_, dest); return; } size_t text_size = padinfo_.enabled() ? std::char_traits::length(msg.source.filename) : 0; ScopedPadder p(text_size, padinfo_, dest); fmt_helper::append_string_view(msg.source.filename, dest); } }; template class short_filename_formatter final : public flag_formatter { public: explicit short_filename_formatter(padding_info padinfo) : flag_formatter(padinfo) {} #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4127) // consider using 'if constexpr' instead #endif // _MSC_VER static const char *basename(const char *filename) { // if the size is 2 (1 character + null terminator) we can use the more efficient strrchr // the branch will be elided by optimizations if (sizeof(os::folder_seps) == 2) { const char *rv = std::strrchr(filename, os::folder_seps[0]); return rv != nullptr ? rv + 1 : filename; } else { const std::reverse_iterator begin(filename + std::strlen(filename)); const std::reverse_iterator end(filename); const auto it = std::find_first_of(begin, end, std::begin(os::folder_seps), std::end(os::folder_seps) - 1); return it != end ? it.base() : filename; } } #ifdef _MSC_VER #pragma warning(pop) #endif // _MSC_VER void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { if (msg.source.empty()) { ScopedPadder p(0, padinfo_, dest); return; } auto filename = basename(msg.source.filename); size_t text_size = padinfo_.enabled() ? std::char_traits::length(filename) : 0; ScopedPadder p(text_size, padinfo_, dest); fmt_helper::append_string_view(filename, dest); } }; template class source_linenum_formatter final : public flag_formatter { public: explicit source_linenum_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { if (msg.source.empty()) { ScopedPadder p(0, padinfo_, dest); return; } auto field_size = ScopedPadder::count_digits(msg.source.line); ScopedPadder p(field_size, padinfo_, dest); fmt_helper::append_int(msg.source.line, dest); } }; // print source funcname template class source_funcname_formatter final : public flag_formatter { public: explicit source_funcname_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { if (msg.source.empty()) { ScopedPadder p(0, padinfo_, dest); return; } size_t text_size = padinfo_.enabled() ? std::char_traits::length(msg.source.funcname) : 0; ScopedPadder p(text_size, padinfo_, dest); fmt_helper::append_string_view(msg.source.funcname, dest); } }; // print elapsed time since last message template class elapsed_formatter final : public flag_formatter { public: using DurationUnits = Units; explicit elapsed_formatter(padding_info padinfo) : flag_formatter(padinfo), last_message_time_(log_clock::now()) {} void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { auto delta = (std::max)(msg.time - last_message_time_, log_clock::duration::zero()); auto delta_units = std::chrono::duration_cast(delta); last_message_time_ = msg.time; auto delta_count = static_cast(delta_units.count()); auto n_digits = static_cast(ScopedPadder::count_digits(delta_count)); ScopedPadder p(n_digits, padinfo_, dest); fmt_helper::append_int(delta_count, dest); } private: log_clock::time_point last_message_time_; }; // Class for formatting Mapped Diagnostic Context (MDC) in log messages. // Example: [logger-name] [info] [mdc_key_1:mdc_value_1 mdc_key_2:mdc_value_2] some message template class mdc_formatter : public flag_formatter { public: explicit mdc_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override { auto &mdc_map = mdc::get_context(); if (mdc_map.empty()) { ScopedPadder p(0, padinfo_, dest); return; } else { format_mdc(mdc_map, dest); } } void format_mdc(const mdc::mdc_map_t &mdc_map, memory_buf_t &dest){ auto last_element = --mdc_map.end(); for (auto it = mdc_map.begin(); it != mdc_map.end(); ++it) { auto &pair = *it; const auto &key = pair.first; const auto &value = pair.second; size_t content_size = key.size() + value.size() + 1; // 1 for ':' if (it != last_element) { content_size++; // 1 for ' ' } ScopedPadder p(content_size, padinfo_, dest); fmt_helper::append_string_view(key, dest); fmt_helper::append_string_view(":", dest); fmt_helper::append_string_view(value, dest); if (it != last_element) { fmt_helper::append_string_view(" ", dest); } } } }; // Full info formatter // pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] [%s:%#] %v class full_formatter final : public flag_formatter { public: explicit full_formatter(padding_info padinfo) : flag_formatter(padinfo) {} void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) override { using std::chrono::duration_cast; using std::chrono::milliseconds; using std::chrono::seconds; // cache the date/time part for the next second. auto duration = msg.time.time_since_epoch(); auto secs = duration_cast(duration); if (cache_timestamp_ != secs || cached_datetime_.size() == 0) { cached_datetime_.clear(); cached_datetime_.push_back('['); fmt_helper::append_int(tm_time.tm_year + 1900, cached_datetime_); cached_datetime_.push_back('-'); fmt_helper::pad2(tm_time.tm_mon + 1, cached_datetime_); cached_datetime_.push_back('-'); fmt_helper::pad2(tm_time.tm_mday, cached_datetime_); cached_datetime_.push_back(' '); fmt_helper::pad2(tm_time.tm_hour, cached_datetime_); cached_datetime_.push_back(':'); fmt_helper::pad2(tm_time.tm_min, cached_datetime_); cached_datetime_.push_back(':'); fmt_helper::pad2(tm_time.tm_sec, cached_datetime_); cached_datetime_.push_back('.'); cache_timestamp_ = secs; } dest.append(cached_datetime_.begin(), cached_datetime_.end()); auto millis = fmt_helper::time_fraction(msg.time); fmt_helper::pad3(static_cast(millis.count()), dest); dest.push_back(']'); dest.push_back(' '); // append logger name if exists if (msg.logger_name.size() > 0) { dest.push_back('['); fmt_helper::append_string_view(msg.logger_name, dest); dest.push_back(']'); dest.push_back(' '); } dest.push_back('['); // wrap the level name with color msg.color_range_start = dest.size(); // fmt_helper::append_string_view(level::to_c_str(msg.level), dest); fmt_helper::append_string_view(level::to_string_view(msg.level), dest); msg.color_range_end = dest.size(); dest.push_back(']'); dest.push_back(' '); // add source location if present if (!msg.source.empty()) { dest.push_back('['); const char *filename = details::short_filename_formatter::basename( msg.source.filename); fmt_helper::append_string_view(filename, dest); dest.push_back(':'); fmt_helper::append_int(msg.source.line, dest); dest.push_back(']'); dest.push_back(' '); } // add mdc if present auto &mdc_map = mdc::get_context(); if (!mdc_map.empty()) { dest.push_back('['); mdc_formatter_.format_mdc(mdc_map, dest); dest.push_back(']'); dest.push_back(' '); } // fmt_helper::append_string_view(msg.msg(), dest); fmt_helper::append_string_view(msg.payload, dest); } private: std::chrono::seconds cache_timestamp_{0}; memory_buf_t cached_datetime_; mdc_formatter mdc_formatter_{padding_info{}}; }; } // namespace details SPDLOG_INLINE pattern_formatter::pattern_formatter(std::string pattern, pattern_time_type time_type, std::string eol, custom_flags custom_user_flags) : pattern_(std::move(pattern)), eol_(std::move(eol)), pattern_time_type_(time_type), need_localtime_(false), last_log_secs_(0), custom_handlers_(std::move(custom_user_flags)) { std::memset(&cached_tm_, 0, sizeof(cached_tm_)); compile_pattern_(pattern_); } // use by default full formatter for if pattern is not given SPDLOG_INLINE pattern_formatter::pattern_formatter(pattern_time_type time_type, std::string eol) : pattern_("%+"), eol_(std::move(eol)), pattern_time_type_(time_type), need_localtime_(true), last_log_secs_(0) { std::memset(&cached_tm_, 0, sizeof(cached_tm_)); formatters_.push_back(details::make_unique(details::padding_info{})); } SPDLOG_INLINE std::unique_ptr pattern_formatter::clone() const { custom_flags cloned_custom_formatters; for (auto &it : custom_handlers_) { cloned_custom_formatters[it.first] = it.second->clone(); } auto cloned = details::make_unique(pattern_, pattern_time_type_, eol_, std::move(cloned_custom_formatters)); cloned->need_localtime(need_localtime_); #if defined(__GNUC__) && __GNUC__ < 5 return std::move(cloned); #else return cloned; #endif } SPDLOG_INLINE void pattern_formatter::format(const details::log_msg &msg, memory_buf_t &dest) { if (need_localtime_) { const auto secs = std::chrono::duration_cast(msg.time.time_since_epoch()); if (secs != last_log_secs_) { cached_tm_ = get_time_(msg); last_log_secs_ = secs; } } for (auto &f : formatters_) { f->format(msg, cached_tm_, dest); } // write eol details::fmt_helper::append_string_view(eol_, dest); } SPDLOG_INLINE void pattern_formatter::set_pattern(std::string pattern) { pattern_ = std::move(pattern); need_localtime_ = false; compile_pattern_(pattern_); } SPDLOG_INLINE void pattern_formatter::need_localtime(bool need) { need_localtime_ = need; } SPDLOG_INLINE std::tm pattern_formatter::get_time_(const details::log_msg &msg) { if (pattern_time_type_ == pattern_time_type::local) { return details::os::localtime(log_clock::to_time_t(msg.time)); } return details::os::gmtime(log_clock::to_time_t(msg.time)); } template SPDLOG_INLINE void pattern_formatter::handle_flag_(char flag, details::padding_info padding) { // process custom flags auto it = custom_handlers_.find(flag); if (it != custom_handlers_.end()) { auto custom_handler = it->second->clone(); custom_handler->set_padding_info(padding); formatters_.push_back(std::move(custom_handler)); return; } // process built-in flags switch (flag) { case ('+'): // default formatter formatters_.push_back(details::make_unique(padding)); need_localtime_ = true; break; case 'n': // logger name formatters_.push_back(details::make_unique>(padding)); break; case 'l': // level formatters_.push_back(details::make_unique>(padding)); break; case 'L': // short level formatters_.push_back( details::make_unique>(padding)); break; case ('t'): // thread id formatters_.push_back(details::make_unique>(padding)); break; case ('v'): // the message text formatters_.push_back(details::make_unique>(padding)); break; case ('a'): // weekday formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; case ('A'): // short weekday formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; case ('b'): case ('h'): // month formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; case ('B'): // short month formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; case ('c'): // datetime formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; case ('C'): // year 2 digits formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; case ('Y'): // year 4 digits formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; case ('D'): case ('x'): // datetime MM/DD/YY formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; case ('m'): // month 1-12 formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; case ('d'): // day of month 1-31 formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; case ('H'): // hours 24 formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; case ('I'): // hours 12 formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; case ('M'): // minutes formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; case ('S'): // seconds formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; case ('e'): // milliseconds formatters_.push_back(details::make_unique>(padding)); break; case ('f'): // microseconds formatters_.push_back(details::make_unique>(padding)); break; case ('F'): // nanoseconds formatters_.push_back(details::make_unique>(padding)); break; case ('E'): // seconds since epoch formatters_.push_back(details::make_unique>(padding)); break; case ('p'): // am/pm formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; case ('r'): // 12 hour clock 02:55:02 pm formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; case ('R'): // 24-hour HH:MM time formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; case ('T'): case ('X'): // ISO 8601 time format (HH:MM:SS) formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; case ('z'): // timezone formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; case ('P'): // pid formatters_.push_back(details::make_unique>(padding)); break; case ('^'): // color range start formatters_.push_back(details::make_unique(padding)); break; case ('$'): // color range end formatters_.push_back(details::make_unique(padding)); break; case ('@'): // source location (filename:filenumber) formatters_.push_back( details::make_unique>(padding)); break; case ('s'): // short source filename - without directory name formatters_.push_back( details::make_unique>(padding)); break; case ('g'): // full source filename formatters_.push_back( details::make_unique>(padding)); break; case ('#'): // source line number formatters_.push_back( details::make_unique>(padding)); break; case ('!'): // source funcname formatters_.push_back( details::make_unique>(padding)); break; case ('%'): // % char formatters_.push_back(details::make_unique('%')); break; case ('u'): // elapsed time since last log message in nanos formatters_.push_back( details::make_unique>( padding)); break; case ('i'): // elapsed time since last log message in micros formatters_.push_back( details::make_unique>( padding)); break; case ('o'): // elapsed time since last log message in millis formatters_.push_back( details::make_unique>( padding)); break; case ('O'): // elapsed time since last log message in seconds formatters_.push_back( details::make_unique>( padding)); break; case ('&'): formatters_.push_back(details::make_unique>(padding)); break; default: // Unknown flag appears as is auto unknown_flag = details::make_unique(); if (!padding.truncate_) { unknown_flag->add_ch('%'); unknown_flag->add_ch(flag); formatters_.push_back((std::move(unknown_flag))); } // fix issue #1617 (prev char was '!' and should have been treated as funcname flag // instead of truncating flag) spdlog::set_pattern("[%10!] %v") => "[ main] some // message" spdlog::set_pattern("[%3!!] %v") => "[mai] some message" else { padding.truncate_ = false; formatters_.push_back( details::make_unique>(padding)); unknown_flag->add_ch(flag); formatters_.push_back((std::move(unknown_flag))); } break; } } // Extract given pad spec (e.g. %8X, %=8X, %-8!X, %8!X, %=8!X, %-8!X, %+8!X) // Advance the given it pass the end of the padding spec found (if any) // Return padding. SPDLOG_INLINE details::padding_info pattern_formatter::handle_padspec_( std::string::const_iterator &it, std::string::const_iterator end) { using details::padding_info; using details::scoped_padder; const size_t max_width = 64; if (it == end) { return padding_info{}; } padding_info::pad_side side; switch (*it) { case '-': side = padding_info::pad_side::right; ++it; break; case '=': side = padding_info::pad_side::center; ++it; break; default: side = details::padding_info::pad_side::left; break; } if (it == end || !std::isdigit(static_cast(*it))) { return padding_info{}; // no padding if no digit found here } auto width = static_cast(*it) - '0'; for (++it; it != end && std::isdigit(static_cast(*it)); ++it) { auto digit = static_cast(*it) - '0'; width = width * 10 + digit; } // search for the optional truncate marker '!' bool truncate; if (it != end && *it == '!') { truncate = true; ++it; } else { truncate = false; } return details::padding_info{std::min(width, max_width), side, truncate}; } SPDLOG_INLINE void pattern_formatter::compile_pattern_(const std::string &pattern) { auto end = pattern.end(); std::unique_ptr user_chars; formatters_.clear(); for (auto it = pattern.begin(); it != end; ++it) { if (*it == '%') { if (user_chars) // append user chars found so far { formatters_.push_back(std::move(user_chars)); } auto padding = handle_padspec_(++it, end); if (it != end) { if (padding.enabled()) { handle_flag_(*it, padding); } else { handle_flag_(*it, padding); } } else { break; } } else // chars not following the % sign should be displayed as is { if (!user_chars) { user_chars = details::make_unique(); } user_chars->add_ch(*it); } } if (user_chars) // append raw chars found so far { formatters_.push_back(std::move(user_chars)); } } } // namespace spdlog RcppSpdlog/inst/include/spdlog/logger.h0000644000176200001440000003214414550234366017663 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once // Thread safe logger (except for set_error_handler()) // Has name, log level, vector of std::shared sink pointers and formatter // Upon each log write the logger: // 1. Checks if its log level is enough to log the message and if yes: // 2. Call the underlying sinks to do the job. // 3. Each sink use its own private copy of a formatter to format the message // and send to its destination. // // The use of private formatter per sink provides the opportunity to cache some // formatted data, and support for different format per sink. #include #include #include #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifndef _WIN32 #error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows #endif #include #endif #include #ifndef SPDLOG_NO_EXCEPTIONS #define SPDLOG_LOGGER_CATCH(location) \ catch (const std::exception &ex) { \ if (location.filename) { \ err_handler_(fmt_lib::format(SPDLOG_FMT_STRING("{} [{}({})]"), ex.what(), \ location.filename, location.line)); \ } else { \ err_handler_(ex.what()); \ } \ } \ catch (...) { \ err_handler_("Rethrowing unknown exception in logger"); \ throw; \ } #else #define SPDLOG_LOGGER_CATCH(location) #endif namespace spdlog { class SPDLOG_API logger { public: // Empty logger explicit logger(std::string name) : name_(std::move(name)), sinks_() {} // Logger with range on sinks template logger(std::string name, It begin, It end) : name_(std::move(name)), sinks_(begin, end) {} // Logger with single sink logger(std::string name, sink_ptr single_sink) : logger(std::move(name), {std::move(single_sink)}) {} // Logger with sinks init list logger(std::string name, sinks_init_list sinks) : logger(std::move(name), sinks.begin(), sinks.end()) {} virtual ~logger() = default; logger(const logger &other); logger(logger &&other) SPDLOG_NOEXCEPT; logger &operator=(logger other) SPDLOG_NOEXCEPT; void swap(spdlog::logger &other) SPDLOG_NOEXCEPT; template void log(source_loc loc, level::level_enum lvl, format_string_t fmt, Args &&...args) { log_(loc, lvl, details::to_string_view(fmt), std::forward(args)...); } template void log(level::level_enum lvl, format_string_t fmt, Args &&...args) { log(source_loc{}, lvl, fmt, std::forward(args)...); } template void log(level::level_enum lvl, const T &msg) { log(source_loc{}, lvl, msg); } // T cannot be statically converted to format string (including string_view/wstring_view) template ::value, int>::type = 0> void log(source_loc loc, level::level_enum lvl, const T &msg) { log(loc, lvl, "{}", msg); } void log(log_clock::time_point log_time, source_loc loc, level::level_enum lvl, string_view_t msg) { bool log_enabled = should_log(lvl); bool traceback_enabled = tracer_.enabled(); if (!log_enabled && !traceback_enabled) { return; } details::log_msg log_msg(log_time, loc, name_, lvl, msg); log_it_(log_msg, log_enabled, traceback_enabled); } void log(source_loc loc, level::level_enum lvl, string_view_t msg) { bool log_enabled = should_log(lvl); bool traceback_enabled = tracer_.enabled(); if (!log_enabled && !traceback_enabled) { return; } details::log_msg log_msg(loc, name_, lvl, msg); log_it_(log_msg, log_enabled, traceback_enabled); } void log(level::level_enum lvl, string_view_t msg) { log(source_loc{}, lvl, msg); } template void trace(format_string_t fmt, Args &&...args) { log(level::trace, fmt, std::forward(args)...); } template void debug(format_string_t fmt, Args &&...args) { log(level::debug, fmt, std::forward(args)...); } template void info(format_string_t fmt, Args &&...args) { log(level::info, fmt, std::forward(args)...); } template void warn(format_string_t fmt, Args &&...args) { log(level::warn, fmt, std::forward(args)...); } template void error(format_string_t fmt, Args &&...args) { log(level::err, fmt, std::forward(args)...); } template void critical(format_string_t fmt, Args &&...args) { log(level::critical, fmt, std::forward(args)...); } #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT template void log(source_loc loc, level::level_enum lvl, wformat_string_t fmt, Args &&...args) { log_(loc, lvl, details::to_string_view(fmt), std::forward(args)...); } template void log(level::level_enum lvl, wformat_string_t fmt, Args &&...args) { log(source_loc{}, lvl, fmt, std::forward(args)...); } void log(log_clock::time_point log_time, source_loc loc, level::level_enum lvl, wstring_view_t msg) { bool log_enabled = should_log(lvl); bool traceback_enabled = tracer_.enabled(); if (!log_enabled && !traceback_enabled) { return; } memory_buf_t buf; details::os::wstr_to_utf8buf(wstring_view_t(msg.data(), msg.size()), buf); details::log_msg log_msg(log_time, loc, name_, lvl, string_view_t(buf.data(), buf.size())); log_it_(log_msg, log_enabled, traceback_enabled); } void log(source_loc loc, level::level_enum lvl, wstring_view_t msg) { bool log_enabled = should_log(lvl); bool traceback_enabled = tracer_.enabled(); if (!log_enabled && !traceback_enabled) { return; } memory_buf_t buf; details::os::wstr_to_utf8buf(wstring_view_t(msg.data(), msg.size()), buf); details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())); log_it_(log_msg, log_enabled, traceback_enabled); } void log(level::level_enum lvl, wstring_view_t msg) { log(source_loc{}, lvl, msg); } template void trace(wformat_string_t fmt, Args &&...args) { log(level::trace, fmt, std::forward(args)...); } template void debug(wformat_string_t fmt, Args &&...args) { log(level::debug, fmt, std::forward(args)...); } template void info(wformat_string_t fmt, Args &&...args) { log(level::info, fmt, std::forward(args)...); } template void warn(wformat_string_t fmt, Args &&...args) { log(level::warn, fmt, std::forward(args)...); } template void error(wformat_string_t fmt, Args &&...args) { log(level::err, fmt, std::forward(args)...); } template void critical(wformat_string_t fmt, Args &&...args) { log(level::critical, fmt, std::forward(args)...); } #endif template void trace(const T &msg) { log(level::trace, msg); } template void debug(const T &msg) { log(level::debug, msg); } template void info(const T &msg) { log(level::info, msg); } template void warn(const T &msg) { log(level::warn, msg); } template void error(const T &msg) { log(level::err, msg); } template void critical(const T &msg) { log(level::critical, msg); } // return true logging is enabled for the given level. bool should_log(level::level_enum msg_level) const { return msg_level >= level_.load(std::memory_order_relaxed); } // return true if backtrace logging is enabled. bool should_backtrace() const { return tracer_.enabled(); } void set_level(level::level_enum log_level); level::level_enum level() const; const std::string &name() const; // set formatting for the sinks in this logger. // each sink will get a separate instance of the formatter object. void set_formatter(std::unique_ptr f); // set formatting for the sinks in this logger. // equivalent to // set_formatter(make_unique(pattern, time_type)) // Note: each sink will get a new instance of a formatter object, replacing the old one. void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local); // backtrace support. // efficiently store all debug/trace messages in a circular buffer until needed for debugging. void enable_backtrace(size_t n_messages); void disable_backtrace(); void dump_backtrace(); // flush functions void flush(); void flush_on(level::level_enum log_level); level::level_enum flush_level() const; // sinks const std::vector &sinks() const; std::vector &sinks(); // error handler void set_error_handler(err_handler); // create new logger with same sinks and configuration. virtual std::shared_ptr clone(std::string logger_name); protected: std::string name_; std::vector sinks_; spdlog::level_t level_{level::info}; spdlog::level_t flush_level_{level::off}; err_handler custom_err_handler_{nullptr}; details::backtracer tracer_; // common implementation for after templated public api has been resolved template void log_(source_loc loc, level::level_enum lvl, string_view_t fmt, Args &&...args) { bool log_enabled = should_log(lvl); bool traceback_enabled = tracer_.enabled(); if (!log_enabled && !traceback_enabled) { return; } SPDLOG_TRY { memory_buf_t buf; #ifdef SPDLOG_USE_STD_FORMAT fmt_lib::vformat_to(std::back_inserter(buf), fmt, fmt_lib::make_format_args(args...)); #else fmt::vformat_to(fmt::appender(buf), fmt, fmt::make_format_args(args...)); #endif details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())); log_it_(log_msg, log_enabled, traceback_enabled); } SPDLOG_LOGGER_CATCH(loc) } #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT template void log_(source_loc loc, level::level_enum lvl, wstring_view_t fmt, Args &&...args) { bool log_enabled = should_log(lvl); bool traceback_enabled = tracer_.enabled(); if (!log_enabled && !traceback_enabled) { return; } SPDLOG_TRY { // format to wmemory_buffer and convert to utf8 wmemory_buf_t wbuf; fmt_lib::vformat_to(std::back_inserter(wbuf), fmt, fmt_lib::make_format_args(args...)); memory_buf_t buf; details::os::wstr_to_utf8buf(wstring_view_t(wbuf.data(), wbuf.size()), buf); details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())); log_it_(log_msg, log_enabled, traceback_enabled); } SPDLOG_LOGGER_CATCH(loc) } #endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT // log the given message (if the given log level is high enough), // and save backtrace (if backtrace is enabled). void log_it_(const details::log_msg &log_msg, bool log_enabled, bool traceback_enabled); virtual void sink_it_(const details::log_msg &msg); virtual void flush_(); void dump_backtrace_(); bool should_flush_(const details::log_msg &msg); // handle errors during logging. // default handler prints the error to stderr at max rate of 1 message/sec. void err_handler_(const std::string &msg); }; void swap(logger &a, logger &b); } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY #include "logger-inl.h" #endif RcppSpdlog/inst/include/spdlog/async_logger.h0000644000176200001440000000500014550234366021047 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once // Fast asynchronous logger. // Uses pre allocated queue. // Creates a single back thread to pop messages from the queue and log them. // // Upon each log write the logger: // 1. Checks if its log level is enough to log the message // 2. Push a new copy of the message to a queue (or block the caller until // space is available in the queue) // Upon destruction, logs all remaining messages in the queue before // destructing.. #include namespace spdlog { // Async overflow policy - block by default. enum class async_overflow_policy { block, // Block until message can be enqueued overrun_oldest, // Discard oldest message in the queue if full when trying to // add new item. discard_new // Discard new message if the queue is full when trying to add new item. }; namespace details { class thread_pool; } class SPDLOG_API async_logger final : public std::enable_shared_from_this, public logger { friend class details::thread_pool; public: template async_logger(std::string logger_name, It begin, It end, std::weak_ptr tp, async_overflow_policy overflow_policy = async_overflow_policy::block) : logger(std::move(logger_name), begin, end), thread_pool_(std::move(tp)), overflow_policy_(overflow_policy) {} async_logger(std::string logger_name, sinks_init_list sinks_list, std::weak_ptr tp, async_overflow_policy overflow_policy = async_overflow_policy::block); async_logger(std::string logger_name, sink_ptr single_sink, std::weak_ptr tp, async_overflow_policy overflow_policy = async_overflow_policy::block); std::shared_ptr clone(std::string new_name) override; protected: void sink_it_(const details::log_msg &msg) override; void flush_() override; void backend_sink_it_(const details::log_msg &incoming_log_msg); void backend_flush_(); private: std::weak_ptr thread_pool_; async_overflow_policy overflow_policy_; }; } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY #include "async_logger-inl.h" #endif RcppSpdlog/inst/include/spdlog/cfg/0000755000176200001440000000000014550234366016766 5ustar liggesusersRcppSpdlog/inst/include/spdlog/cfg/helpers-inl.h0000644000176200001440000000614214550234366021364 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifndef SPDLOG_HEADER_ONLY #include #endif #include #include #include #include #include #include #include namespace spdlog { namespace cfg { namespace helpers { // inplace convert to lowercase inline std::string &to_lower_(std::string &str) { std::transform(str.begin(), str.end(), str.begin(), [](char ch) { return static_cast((ch >= 'A' && ch <= 'Z') ? ch + ('a' - 'A') : ch); }); return str; } // inplace trim spaces inline std::string &trim_(std::string &str) { const char *spaces = " \n\r\t"; str.erase(str.find_last_not_of(spaces) + 1); str.erase(0, str.find_first_not_of(spaces)); return str; } // return (name,value) trimmed pair from given "name=value" string. // return empty string on missing parts // "key=val" => ("key", "val") // " key = val " => ("key", "val") // "key=" => ("key", "") // "val" => ("", "val") inline std::pair extract_kv_(char sep, const std::string &str) { auto n = str.find(sep); std::string k, v; if (n == std::string::npos) { v = str; } else { k = str.substr(0, n); v = str.substr(n + 1); } return std::make_pair(trim_(k), trim_(v)); } // return vector of key/value pairs from sequence of "K1=V1,K2=V2,.." // "a=AAA,b=BBB,c=CCC,.." => {("a","AAA"),("b","BBB"),("c", "CCC"),...} inline std::unordered_map extract_key_vals_(const std::string &str) { std::string token; std::istringstream token_stream(str); std::unordered_map rv{}; while (std::getline(token_stream, token, ',')) { if (token.empty()) { continue; } auto kv = extract_kv_('=', token); rv[kv.first] = kv.second; } return rv; } SPDLOG_INLINE void load_levels(const std::string &input) { if (input.empty() || input.size() > 512) { return; } auto key_vals = extract_key_vals_(input); std::unordered_map levels; level::level_enum global_level = level::info; bool global_level_found = false; for (auto &name_level : key_vals) { auto &logger_name = name_level.first; auto level_name = to_lower_(name_level.second); auto level = level::from_str(level_name); // ignore unrecognized level names if (level == level::off && level_name != "off") { continue; } if (logger_name.empty()) // no logger name indicate global level { global_level_found = true; global_level = level; } else { levels[logger_name] = level; } } details::registry::instance().set_levels(std::move(levels), global_level_found ? &global_level : nullptr); } } // namespace helpers } // namespace cfg } // namespace spdlog RcppSpdlog/inst/include/spdlog/cfg/env.h0000644000176200001440000000173214550234366017732 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include #include // // Init levels and patterns from env variables SPDLOG_LEVEL // Inspired from Rust's "env_logger" crate (https://crates.io/crates/env_logger). // Note - fallback to "info" level on unrecognized levels // // Examples: // // set global level to debug: // export SPDLOG_LEVEL=debug // // turn off all logging except for logger1: // export SPDLOG_LEVEL="*=off,logger1=debug" // // turn off all logging except for logger1 and logger2: // export SPDLOG_LEVEL="off,logger1=debug,logger2=info" namespace spdlog { namespace cfg { inline void load_env_levels() { auto env_val = details::os::getenv("SPDLOG_LEVEL"); if (!env_val.empty()) { helpers::load_levels(env_val); } } } // namespace cfg } // namespace spdlog RcppSpdlog/inst/include/spdlog/cfg/helpers.h0000644000176200001440000000131614550234366020602 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include namespace spdlog { namespace cfg { namespace helpers { // // Init levels from given string // // Examples: // // set global level to debug: "debug" // turn off all logging except for logger1: "off,logger1=debug" // turn off all logging except for logger1 and logger2: "off,logger1=debug,logger2=info" // SPDLOG_API void load_levels(const std::string &txt); } // namespace helpers } // namespace cfg } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY #include "helpers-inl.h" #endif // SPDLOG_HEADER_ONLY RcppSpdlog/inst/include/spdlog/cfg/argv.h0000644000176200001440000000230314550234366020074 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include // // Init log levels using each argv entry that starts with "SPDLOG_LEVEL=" // // set all loggers to debug level: // example.exe "SPDLOG_LEVEL=debug" // set logger1 to trace level // example.exe "SPDLOG_LEVEL=logger1=trace" // turn off all logging except for logger1 and logger2: // example.exe "SPDLOG_LEVEL=off,logger1=debug,logger2=info" namespace spdlog { namespace cfg { // search for SPDLOG_LEVEL= in the args and use it to init the levels inline void load_argv_levels(int argc, const char **argv) { const std::string spdlog_level_prefix = "SPDLOG_LEVEL="; for (int i = 1; i < argc; i++) { std::string arg = argv[i]; if (arg.find(spdlog_level_prefix) == 0) { auto levels_string = arg.substr(spdlog_level_prefix.size()); helpers::load_levels(levels_string); } } } inline void load_argv_levels(int argc, char **argv) { load_argv_levels(argc, const_cast(argv)); } } // namespace cfg } // namespace spdlog RcppSpdlog/inst/include/spdlog/sinks/0000755000176200001440000000000014612604314017347 5ustar liggesusersRcppSpdlog/inst/include/spdlog/sinks/ansicolor_sink.h0000644000176200001440000000756714550234366022563 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include #include #include #include #include #include namespace spdlog { namespace sinks { /** * This sink prefixes the output with an ANSI escape sequence color code * depending on the severity * of the message. * If no color terminal detected, omit the escape codes. */ template class ansicolor_sink : public sink { public: using mutex_t = typename ConsoleMutex::mutex_t; ansicolor_sink(FILE *target_file, color_mode mode); ~ansicolor_sink() override = default; ansicolor_sink(const ansicolor_sink &other) = delete; ansicolor_sink(ansicolor_sink &&other) = delete; ansicolor_sink &operator=(const ansicolor_sink &other) = delete; ansicolor_sink &operator=(ansicolor_sink &&other) = delete; void set_color(level::level_enum color_level, string_view_t color); void set_color_mode(color_mode mode); bool should_color(); void log(const details::log_msg &msg) override; void flush() override; void set_pattern(const std::string &pattern) final; void set_formatter(std::unique_ptr sink_formatter) override; // Formatting codes const string_view_t reset = "\033[m"; const string_view_t bold = "\033[1m"; const string_view_t dark = "\033[2m"; const string_view_t underline = "\033[4m"; const string_view_t blink = "\033[5m"; const string_view_t reverse = "\033[7m"; const string_view_t concealed = "\033[8m"; const string_view_t clear_line = "\033[K"; // Foreground colors const string_view_t black = "\033[30m"; const string_view_t red = "\033[31m"; const string_view_t green = "\033[32m"; const string_view_t yellow = "\033[33m"; const string_view_t blue = "\033[34m"; const string_view_t magenta = "\033[35m"; const string_view_t cyan = "\033[36m"; const string_view_t white = "\033[37m"; /// Background colors const string_view_t on_black = "\033[40m"; const string_view_t on_red = "\033[41m"; const string_view_t on_green = "\033[42m"; const string_view_t on_yellow = "\033[43m"; const string_view_t on_blue = "\033[44m"; const string_view_t on_magenta = "\033[45m"; const string_view_t on_cyan = "\033[46m"; const string_view_t on_white = "\033[47m"; /// Bold colors const string_view_t yellow_bold = "\033[33m\033[1m"; const string_view_t red_bold = "\033[31m\033[1m"; const string_view_t bold_on_red = "\033[1m\033[41m"; private: FILE *target_file_; mutex_t &mutex_; bool should_do_colors_; std::unique_ptr formatter_; std::array colors_; void print_ccode_(const string_view_t &color_code); void print_range_(const memory_buf_t &formatted, size_t start, size_t end); static std::string to_string_(const string_view_t &sv); }; template class ansicolor_stdout_sink : public ansicolor_sink { public: explicit ansicolor_stdout_sink(color_mode mode = color_mode::automatic); }; template class ansicolor_stderr_sink : public ansicolor_sink { public: explicit ansicolor_stderr_sink(color_mode mode = color_mode::automatic); }; using ansicolor_stdout_sink_mt = ansicolor_stdout_sink; using ansicolor_stdout_sink_st = ansicolor_stdout_sink; using ansicolor_stderr_sink_mt = ansicolor_stderr_sink; using ansicolor_stderr_sink_st = ansicolor_stderr_sink; } // namespace sinks } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY #include "ansicolor_sink-inl.h" #endif RcppSpdlog/inst/include/spdlog/sinks/base_sink.h0000644000176200001440000000304014550234366021462 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once // // base sink templated over a mutex (either dummy or real) // concrete implementation should override the sink_it_() and flush_() methods. // locking is taken care of in this class - no locking needed by the // implementers.. // #include #include #include namespace spdlog { namespace sinks { template class SPDLOG_API base_sink : public sink { public: base_sink(); explicit base_sink(std::unique_ptr formatter); ~base_sink() override = default; base_sink(const base_sink &) = delete; base_sink(base_sink &&) = delete; base_sink &operator=(const base_sink &) = delete; base_sink &operator=(base_sink &&) = delete; void log(const details::log_msg &msg) final; void flush() final; void set_pattern(const std::string &pattern) final; void set_formatter(std::unique_ptr sink_formatter) final; protected: // sink formatter std::unique_ptr formatter_; Mutex mutex_; virtual void sink_it_(const details::log_msg &msg) = 0; virtual void flush_() = 0; virtual void set_pattern_(const std::string &pattern); virtual void set_formatter_(std::unique_ptr sink_formatter); }; } // namespace sinks } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY #include "base_sink-inl.h" #endif RcppSpdlog/inst/include/spdlog/sinks/rotating_file_sink.h0000644000176200001440000000623514550234366023407 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include #include #include #include #include #include namespace spdlog { namespace sinks { // // Rotating file sink based on size // template class rotating_file_sink final : public base_sink { public: rotating_file_sink(filename_t base_filename, std::size_t max_size, std::size_t max_files, bool rotate_on_open = false, const file_event_handlers &event_handlers = {}); static filename_t calc_filename(const filename_t &filename, std::size_t index); filename_t filename(); protected: void sink_it_(const details::log_msg &msg) override; void flush_() override; private: // Rotate files: // log.txt -> log.1.txt // log.1.txt -> log.2.txt // log.2.txt -> log.3.txt // log.3.txt -> delete void rotate_(); // delete the target if exists, and rename the src file to target // return true on success, false otherwise. bool rename_file_(const filename_t &src_filename, const filename_t &target_filename); filename_t base_filename_; std::size_t max_size_; std::size_t max_files_; std::size_t current_size_; details::file_helper file_helper_; }; using rotating_file_sink_mt = rotating_file_sink; using rotating_file_sink_st = rotating_file_sink; } // namespace sinks // // factory functions // template inline std::shared_ptr rotating_logger_mt(const std::string &logger_name, const filename_t &filename, size_t max_file_size, size_t max_files, bool rotate_on_open = false, const file_event_handlers &event_handlers = {}) { return Factory::template create( logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers); } template inline std::shared_ptr rotating_logger_st(const std::string &logger_name, const filename_t &filename, size_t max_file_size, size_t max_files, bool rotate_on_open = false, const file_event_handlers &event_handlers = {}) { return Factory::template create( logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers); } } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY #include "rotating_file_sink-inl.h" #endif RcppSpdlog/inst/include/spdlog/sinks/basic_file_sink-inl.h0000644000176200001440000000230014550234366023406 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifndef SPDLOG_HEADER_ONLY #include #endif #include #include namespace spdlog { namespace sinks { template SPDLOG_INLINE basic_file_sink::basic_file_sink(const filename_t &filename, bool truncate, const file_event_handlers &event_handlers) : file_helper_{event_handlers} { file_helper_.open(filename, truncate); } template SPDLOG_INLINE const filename_t &basic_file_sink::filename() const { return file_helper_.filename(); } template SPDLOG_INLINE void basic_file_sink::sink_it_(const details::log_msg &msg) { memory_buf_t formatted; base_sink::formatter_->format(msg, formatted); file_helper_.write(formatted); } template SPDLOG_INLINE void basic_file_sink::flush_() { file_helper_.flush(); } } // namespace sinks } // namespace spdlog RcppSpdlog/inst/include/spdlog/sinks/kafka_sink.h0000644000176200001440000001053514550234366021634 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once // // Custom sink for kafka // Building and using requires librdkafka library. // For building librdkafka library check the url below // https://github.com/confluentinc/librdkafka // #include "spdlog/async.h" #include "spdlog/details/log_msg.h" #include "spdlog/details/null_mutex.h" #include "spdlog/details/synchronous_factory.h" #include "spdlog/sinks/base_sink.h" #include #include // kafka header #include namespace spdlog { namespace sinks { struct kafka_sink_config { std::string server_addr; std::string produce_topic; int32_t flush_timeout_ms = 1000; kafka_sink_config(std::string addr, std::string topic, int flush_timeout_ms = 1000) : server_addr{std::move(addr)}, produce_topic{std::move(topic)}, flush_timeout_ms(flush_timeout_ms) {} }; template class kafka_sink : public base_sink { public: kafka_sink(kafka_sink_config config) : config_{std::move(config)} { try { std::string errstr; conf_.reset(RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL)); RdKafka::Conf::ConfResult confRes = conf_->set("bootstrap.servers", config_.server_addr, errstr); if (confRes != RdKafka::Conf::CONF_OK) { throw_spdlog_ex( fmt_lib::format("conf set bootstrap.servers failed err:{}", errstr)); } tconf_.reset(RdKafka::Conf::create(RdKafka::Conf::CONF_TOPIC)); if (tconf_ == nullptr) { throw_spdlog_ex(fmt_lib::format("create topic config failed")); } producer_.reset(RdKafka::Producer::create(conf_.get(), errstr)); if (producer_ == nullptr) { throw_spdlog_ex(fmt_lib::format("create producer failed err:{}", errstr)); } topic_.reset(RdKafka::Topic::create(producer_.get(), config_.produce_topic, tconf_.get(), errstr)); if (topic_ == nullptr) { throw_spdlog_ex(fmt_lib::format("create topic failed err:{}", errstr)); } } catch (const std::exception &e) { throw_spdlog_ex(fmt_lib::format("error create kafka instance: {}", e.what())); } } ~kafka_sink() { producer_->flush(config_.flush_timeout_ms); } protected: void sink_it_(const details::log_msg &msg) override { producer_->produce(topic_.get(), 0, RdKafka::Producer::RK_MSG_COPY, (void *)msg.payload.data(), msg.payload.size(), NULL, NULL); } void flush_() override { producer_->flush(config_.flush_timeout_ms); } private: kafka_sink_config config_; std::unique_ptr producer_ = nullptr; std::unique_ptr conf_ = nullptr; std::unique_ptr tconf_ = nullptr; std::unique_ptr topic_ = nullptr; }; using kafka_sink_mt = kafka_sink; using kafka_sink_st = kafka_sink; } // namespace sinks template inline std::shared_ptr kafka_logger_mt(const std::string &logger_name, spdlog::sinks::kafka_sink_config config) { return Factory::template create(logger_name, config); } template inline std::shared_ptr kafka_logger_st(const std::string &logger_name, spdlog::sinks::kafka_sink_config config) { return Factory::template create(logger_name, config); } template inline std::shared_ptr kafka_logger_async_mt( std::string logger_name, spdlog::sinks::kafka_sink_config config) { return Factory::template create(logger_name, config); } template inline std::shared_ptr kafka_logger_async_st( std::string logger_name, spdlog::sinks::kafka_sink_config config) { return Factory::template create(logger_name, config); } } // namespace spdlog RcppSpdlog/inst/include/spdlog/sinks/qt_sinks.h0000644000176200001440000003017414612604314021360 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman, mguludag and spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once // // Custom sink for QPlainTextEdit or QTextEdit and its children (QTextBrowser... // etc) Building and using requires Qt library. // // Warning: the qt_sink won't be notified if the target widget is destroyed. // If the widget's lifetime can be shorter than the logger's one, you should provide some permanent // QObject, and then use a standard signal/slot. // #include "spdlog/common.h" #include "spdlog/details/log_msg.h" #include "spdlog/details/synchronous_factory.h" #include "spdlog/sinks/base_sink.h" #include #include #include // // qt_sink class // namespace spdlog { namespace sinks { template class qt_sink : public base_sink { public: qt_sink(QObject *qt_object, std::string meta_method) : qt_object_(qt_object), meta_method_(std::move(meta_method)) { if (!qt_object_) { throw_spdlog_ex("qt_sink: qt_object is null"); } } ~qt_sink() { flush_(); } protected: void sink_it_(const details::log_msg &msg) override { memory_buf_t formatted; base_sink::formatter_->format(msg, formatted); const string_view_t str = string_view_t(formatted.data(), formatted.size()); QMetaObject::invokeMethod( qt_object_, meta_method_.c_str(), Qt::AutoConnection, Q_ARG(QString, QString::fromUtf8(str.data(), static_cast(str.size())).trimmed())); } void flush_() override {} private: QObject *qt_object_ = nullptr; std::string meta_method_; }; // Qt color sink to QTextEdit. // Color location is determined by the sink log pattern like in the rest of spdlog sinks. // Colors can be modified if needed using sink->set_color(level, qtTextCharFormat). // max_lines is the maximum number of lines that the sink will hold before removing the oldest // lines. By default, only ascii (latin1) is supported by this sink. Set is_utf8 to true if utf8 // support is needed. template class qt_color_sink : public base_sink { public: qt_color_sink(QTextEdit *qt_text_edit, int max_lines, bool dark_colors = false, bool is_utf8 = false) : qt_text_edit_(qt_text_edit), max_lines_(max_lines), is_utf8_(is_utf8) { if (!qt_text_edit_) { throw_spdlog_ex("qt_color_text_sink: text_edit is null"); } default_color_ = qt_text_edit_->currentCharFormat(); // set colors QTextCharFormat format; // trace format.setForeground(dark_colors ? Qt::darkGray : Qt::gray); colors_.at(level::trace) = format; // debug format.setForeground(dark_colors ? Qt::darkCyan : Qt::cyan); colors_.at(level::debug) = format; // info format.setForeground(dark_colors ? Qt::darkGreen : Qt::green); colors_.at(level::info) = format; // warn format.setForeground(dark_colors ? Qt::darkYellow : Qt::yellow); colors_.at(level::warn) = format; // err format.setForeground(Qt::red); colors_.at(level::err) = format; // critical format.setForeground(Qt::white); format.setBackground(Qt::red); colors_.at(level::critical) = format; } ~qt_color_sink() { flush_(); } void set_default_color(QTextCharFormat format) { // std::lock_guard lock(base_sink::mutex_); default_color_ = format; } void set_level_color(level::level_enum color_level, QTextCharFormat format) { // std::lock_guard lock(base_sink::mutex_); colors_.at(static_cast(color_level)) = format; } QTextCharFormat &get_level_color(level::level_enum color_level) { std::lock_guard lock(base_sink::mutex_); return colors_.at(static_cast(color_level)); } QTextCharFormat &get_default_color() { std::lock_guard lock(base_sink::mutex_); return default_color_; } protected: struct invoke_params { invoke_params(int max_lines, QTextEdit *q_text_edit, QString payload, QTextCharFormat default_color, QTextCharFormat level_color, int color_range_start, int color_range_end) : max_lines(max_lines), q_text_edit(q_text_edit), payload(std::move(payload)), default_color(default_color), level_color(level_color), color_range_start(color_range_start), color_range_end(color_range_end) {} int max_lines; QTextEdit *q_text_edit; QString payload; QTextCharFormat default_color; QTextCharFormat level_color; int color_range_start; int color_range_end; }; void sink_it_(const details::log_msg &msg) override { memory_buf_t formatted; base_sink::formatter_->format(msg, formatted); const string_view_t str = string_view_t(formatted.data(), formatted.size()); // apply the color to the color range in the formatted message. QString payload; int color_range_start = static_cast(msg.color_range_start); int color_range_end = static_cast(msg.color_range_end); if (is_utf8_) { payload = QString::fromUtf8(str.data(), static_cast(str.size())); // convert color ranges from byte index to character index. if (msg.color_range_start < msg.color_range_end) { color_range_start = QString::fromUtf8(str.data(), msg.color_range_start).size(); color_range_end = QString::fromUtf8(str.data(), msg.color_range_end).size(); } } else { payload = QString::fromLatin1(str.data(), static_cast(str.size())); } invoke_params params{max_lines_, // max lines qt_text_edit_, // text edit to append to std::move(payload), // text to append default_color_, // default color colors_.at(msg.level), // color to apply color_range_start, // color range start color_range_end}; // color range end QMetaObject::invokeMethod( qt_text_edit_, [params]() { invoke_method_(params); }, Qt::AutoConnection); } void flush_() override {} // Add colored text to the text edit widget. This method is invoked in the GUI thread. // It is a static method to ensure that it is handled correctly even if the sink is destroyed // prematurely before it is invoked. static void invoke_method_(invoke_params params) { auto *document = params.q_text_edit->document(); QTextCursor cursor(document); // remove first blocks if number of blocks exceeds max_lines while (document->blockCount() > params.max_lines) { cursor.select(QTextCursor::BlockUnderCursor); cursor.removeSelectedText(); cursor.deleteChar(); // delete the newline after the block } cursor.movePosition(QTextCursor::End); cursor.setCharFormat(params.default_color); // if color range not specified or not not valid, just append the text with default color if (params.color_range_end <= params.color_range_start) { cursor.insertText(params.payload); return; } // insert the text before the color range cursor.insertText(params.payload.left(params.color_range_start)); // insert the colorized text cursor.setCharFormat(params.level_color); cursor.insertText(params.payload.mid(params.color_range_start, params.color_range_end - params.color_range_start)); // insert the text after the color range with default format cursor.setCharFormat(params.default_color); cursor.insertText(params.payload.mid(params.color_range_end)); } QTextEdit *qt_text_edit_; int max_lines_; bool is_utf8_; QTextCharFormat default_color_; std::array colors_; }; #include "spdlog/details/null_mutex.h" #include using qt_sink_mt = qt_sink; using qt_sink_st = qt_sink; using qt_color_sink_mt = qt_color_sink; using qt_color_sink_st = qt_color_sink; } // namespace sinks // // Factory functions // // log to QTextEdit template inline std::shared_ptr qt_logger_mt(const std::string &logger_name, QTextEdit *qt_object, const std::string &meta_method = "append") { return Factory::template create(logger_name, qt_object, meta_method); } template inline std::shared_ptr qt_logger_st(const std::string &logger_name, QTextEdit *qt_object, const std::string &meta_method = "append") { return Factory::template create(logger_name, qt_object, meta_method); } // log to QPlainTextEdit template inline std::shared_ptr qt_logger_mt(const std::string &logger_name, QPlainTextEdit *qt_object, const std::string &meta_method = "appendPlainText") { return Factory::template create(logger_name, qt_object, meta_method); } template inline std::shared_ptr qt_logger_st(const std::string &logger_name, QPlainTextEdit *qt_object, const std::string &meta_method = "appendPlainText") { return Factory::template create(logger_name, qt_object, meta_method); } // log to QObject template inline std::shared_ptr qt_logger_mt(const std::string &logger_name, QObject *qt_object, const std::string &meta_method) { return Factory::template create(logger_name, qt_object, meta_method); } template inline std::shared_ptr qt_logger_st(const std::string &logger_name, QObject *qt_object, const std::string &meta_method) { return Factory::template create(logger_name, qt_object, meta_method); } // log to QTextEdit with colorized output template inline std::shared_ptr qt_color_logger_mt(const std::string &logger_name, QTextEdit *qt_text_edit, int max_lines, bool is_utf8 = false) { return Factory::template create(logger_name, qt_text_edit, max_lines, false, is_utf8); } template inline std::shared_ptr qt_color_logger_st(const std::string &logger_name, QTextEdit *qt_text_edit, int max_lines, bool is_utf8 = false) { return Factory::template create(logger_name, qt_text_edit, max_lines, false, is_utf8); } } // namespace spdlog RcppSpdlog/inst/include/spdlog/sinks/wincolor_sink-inl.h0000644000176200001440000001477314550234366023203 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifndef SPDLOG_HEADER_ONLY #include #endif #include #include #include #include namespace spdlog { namespace sinks { template SPDLOG_INLINE wincolor_sink::wincolor_sink(void *out_handle, color_mode mode) : out_handle_(out_handle), mutex_(ConsoleMutex::mutex()), formatter_(details::make_unique()) { set_color_mode_impl(mode); // set level colors colors_[level::trace] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; // white colors_[level::debug] = FOREGROUND_GREEN | FOREGROUND_BLUE; // cyan colors_[level::info] = FOREGROUND_GREEN; // green colors_[level::warn] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY; // intense yellow colors_[level::err] = FOREGROUND_RED | FOREGROUND_INTENSITY; // intense red colors_[level::critical] = BACKGROUND_RED | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY; // intense white on red background colors_[level::off] = 0; } template SPDLOG_INLINE wincolor_sink::~wincolor_sink() { this->flush(); } // change the color for the given level template void SPDLOG_INLINE wincolor_sink::set_color(level::level_enum level, std::uint16_t color) { std::lock_guard lock(mutex_); colors_[static_cast(level)] = color; } template void SPDLOG_INLINE wincolor_sink::log(const details::log_msg &msg) { if (out_handle_ == nullptr || out_handle_ == INVALID_HANDLE_VALUE) { return; } std::lock_guard lock(mutex_); msg.color_range_start = 0; msg.color_range_end = 0; memory_buf_t formatted; formatter_->format(msg, formatted); if (should_do_colors_ && msg.color_range_end > msg.color_range_start) { // before color range print_range_(formatted, 0, msg.color_range_start); // in color range auto orig_attribs = static_cast(set_foreground_color_(colors_[static_cast(msg.level)])); print_range_(formatted, msg.color_range_start, msg.color_range_end); // reset to orig colors ::SetConsoleTextAttribute(static_cast(out_handle_), orig_attribs); print_range_(formatted, msg.color_range_end, formatted.size()); } else // print without colors if color range is invalid (or color is disabled) { write_to_file_(formatted); } } template void SPDLOG_INLINE wincolor_sink::flush() { // windows console always flushed? } template void SPDLOG_INLINE wincolor_sink::set_pattern(const std::string &pattern) { std::lock_guard lock(mutex_); formatter_ = std::unique_ptr(new pattern_formatter(pattern)); } template void SPDLOG_INLINE wincolor_sink::set_formatter(std::unique_ptr sink_formatter) { std::lock_guard lock(mutex_); formatter_ = std::move(sink_formatter); } template void SPDLOG_INLINE wincolor_sink::set_color_mode(color_mode mode) { std::lock_guard lock(mutex_); set_color_mode_impl(mode); } template void SPDLOG_INLINE wincolor_sink::set_color_mode_impl(color_mode mode) { if (mode == color_mode::automatic) { // should do colors only if out_handle_ points to actual console. DWORD console_mode; bool in_console = ::GetConsoleMode(static_cast(out_handle_), &console_mode) != 0; should_do_colors_ = in_console; } else { should_do_colors_ = mode == color_mode::always ? true : false; } } // set foreground color and return the orig console attributes (for resetting later) template std::uint16_t SPDLOG_INLINE wincolor_sink::set_foreground_color_(std::uint16_t attribs) { CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info; if (!::GetConsoleScreenBufferInfo(static_cast(out_handle_), &orig_buffer_info)) { // just return white if failed getting console info return FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; } // change only the foreground bits (lowest 4 bits) auto new_attribs = static_cast(attribs) | (orig_buffer_info.wAttributes & 0xfff0); auto ignored = ::SetConsoleTextAttribute(static_cast(out_handle_), static_cast(new_attribs)); (void)(ignored); return static_cast(orig_buffer_info.wAttributes); // return orig attribs } // print a range of formatted message to console template void SPDLOG_INLINE wincolor_sink::print_range_(const memory_buf_t &formatted, size_t start, size_t end) { if (end > start) { auto size = static_cast(end - start); auto ignored = ::WriteConsoleA(static_cast(out_handle_), formatted.data() + start, size, nullptr, nullptr); (void)(ignored); } } template void SPDLOG_INLINE wincolor_sink::write_to_file_(const memory_buf_t &formatted) { auto size = static_cast(formatted.size()); DWORD bytes_written = 0; auto ignored = ::WriteFile(static_cast(out_handle_), formatted.data(), size, &bytes_written, nullptr); (void)(ignored); } // wincolor_stdout_sink template SPDLOG_INLINE wincolor_stdout_sink::wincolor_stdout_sink(color_mode mode) : wincolor_sink(::GetStdHandle(STD_OUTPUT_HANDLE), mode) {} // wincolor_stderr_sink template SPDLOG_INLINE wincolor_stderr_sink::wincolor_stderr_sink(color_mode mode) : wincolor_sink(::GetStdHandle(STD_ERROR_HANDLE), mode) {} } // namespace sinks } // namespace spdlog RcppSpdlog/inst/include/spdlog/sinks/stdout_sinks.h0000644000176200001440000000457514550234366022273 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include #include #include #ifdef _WIN32 #include #endif namespace spdlog { namespace sinks { template class stdout_sink_base : public sink { public: using mutex_t = typename ConsoleMutex::mutex_t; explicit stdout_sink_base(FILE *file); ~stdout_sink_base() override = default; stdout_sink_base(const stdout_sink_base &other) = delete; stdout_sink_base(stdout_sink_base &&other) = delete; stdout_sink_base &operator=(const stdout_sink_base &other) = delete; stdout_sink_base &operator=(stdout_sink_base &&other) = delete; void log(const details::log_msg &msg) override; void flush() override; void set_pattern(const std::string &pattern) override; void set_formatter(std::unique_ptr sink_formatter) override; protected: mutex_t &mutex_; FILE *file_; std::unique_ptr formatter_; #ifdef _WIN32 HANDLE handle_; #endif // WIN32 }; template class stdout_sink : public stdout_sink_base { public: stdout_sink(); }; template class stderr_sink : public stdout_sink_base { public: stderr_sink(); }; using stdout_sink_mt = stdout_sink; using stdout_sink_st = stdout_sink; using stderr_sink_mt = stderr_sink; using stderr_sink_st = stderr_sink; } // namespace sinks // factory methods template std::shared_ptr stdout_logger_mt(const std::string &logger_name); template std::shared_ptr stdout_logger_st(const std::string &logger_name); template std::shared_ptr stderr_logger_mt(const std::string &logger_name); template std::shared_ptr stderr_logger_st(const std::string &logger_name); } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY #include "stdout_sinks-inl.h" #endif RcppSpdlog/inst/include/spdlog/sinks/daily_file_sink.h0000644000176200001440000002235414550234366022662 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace spdlog { namespace sinks { /* * Generator of daily log file names in format basename.YYYY-MM-DD.ext */ struct daily_filename_calculator { // Create filename for the form basename.YYYY-MM-DD static filename_t calc_filename(const filename_t &filename, const tm &now_tm) { filename_t basename, ext; std::tie(basename, ext) = details::file_helper::split_by_extension(filename); return fmt_lib::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}")), basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday, ext); } }; /* * Generator of daily log file names with strftime format. * Usages: * auto sink = * std::make_shared("myapp-%Y-%m-%d:%H:%M:%S.log", hour, * minute);" auto logger = spdlog::daily_logger_format_mt("loggername, "myapp-%Y-%m-%d:%X.log", * hour, minute)" * */ struct daily_filename_format_calculator { static filename_t calc_filename(const filename_t &file_path, const tm &now_tm) { #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) std::wstringstream stream; #else std::stringstream stream; #endif stream << std::put_time(&now_tm, file_path.c_str()); return stream.str(); } }; /* * Rotating file sink based on date. * If truncate != false , the created file will be truncated. * If max_files > 0, retain only the last max_files and delete previous. */ template class daily_file_sink final : public base_sink { public: // create daily file sink which rotates on given time daily_file_sink(filename_t base_filename, int rotation_hour, int rotation_minute, bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {}) : base_filename_(std::move(base_filename)), rotation_h_(rotation_hour), rotation_m_(rotation_minute), file_helper_{event_handlers}, truncate_(truncate), max_files_(max_files), filenames_q_() { if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || rotation_minute > 59) { throw_spdlog_ex("daily_file_sink: Invalid rotation time in ctor"); } auto now = log_clock::now(); auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now)); file_helper_.open(filename, truncate_); rotation_tp_ = next_rotation_tp_(); if (max_files_ > 0) { init_filenames_q_(); } } filename_t filename() { std::lock_guard lock(base_sink::mutex_); return file_helper_.filename(); } protected: void sink_it_(const details::log_msg &msg) override { auto time = msg.time; bool should_rotate = time >= rotation_tp_; if (should_rotate) { auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(time)); file_helper_.open(filename, truncate_); rotation_tp_ = next_rotation_tp_(); } memory_buf_t formatted; base_sink::formatter_->format(msg, formatted); file_helper_.write(formatted); // Do the cleaning only at the end because it might throw on failure. if (should_rotate && max_files_ > 0) { delete_old_(); } } void flush_() override { file_helper_.flush(); } private: void init_filenames_q_() { using details::os::path_exists; filenames_q_ = details::circular_q(static_cast(max_files_)); std::vector filenames; auto now = log_clock::now(); while (filenames.size() < max_files_) { auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now)); if (!path_exists(filename)) { break; } filenames.emplace_back(filename); now -= std::chrono::hours(24); } for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) { filenames_q_.push_back(std::move(*iter)); } } tm now_tm(log_clock::time_point tp) { time_t tnow = log_clock::to_time_t(tp); return spdlog::details::os::localtime(tnow); } log_clock::time_point next_rotation_tp_() { auto now = log_clock::now(); tm date = now_tm(now); date.tm_hour = rotation_h_; date.tm_min = rotation_m_; date.tm_sec = 0; auto rotation_time = log_clock::from_time_t(std::mktime(&date)); if (rotation_time > now) { return rotation_time; } return {rotation_time + std::chrono::hours(24)}; } // Delete the file N rotations ago. // Throw spdlog_ex on failure to delete the old file. void delete_old_() { using details::os::filename_to_str; using details::os::remove_if_exists; filename_t current_file = file_helper_.filename(); if (filenames_q_.full()) { auto old_filename = std::move(filenames_q_.front()); filenames_q_.pop_front(); bool ok = remove_if_exists(old_filename) == 0; if (!ok) { filenames_q_.push_back(std::move(current_file)); throw_spdlog_ex("Failed removing daily file " + filename_to_str(old_filename), errno); } } filenames_q_.push_back(std::move(current_file)); } filename_t base_filename_; int rotation_h_; int rotation_m_; log_clock::time_point rotation_tp_; details::file_helper file_helper_; bool truncate_; uint16_t max_files_; details::circular_q filenames_q_; }; using daily_file_sink_mt = daily_file_sink; using daily_file_sink_st = daily_file_sink; using daily_file_format_sink_mt = daily_file_sink; using daily_file_format_sink_st = daily_file_sink; } // namespace sinks // // factory functions // template inline std::shared_ptr daily_logger_mt(const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {}) { return Factory::template create(logger_name, filename, hour, minute, truncate, max_files, event_handlers); } template inline std::shared_ptr daily_logger_format_mt( const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {}) { return Factory::template create( logger_name, filename, hour, minute, truncate, max_files, event_handlers); } template inline std::shared_ptr daily_logger_st(const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {}) { return Factory::template create(logger_name, filename, hour, minute, truncate, max_files, event_handlers); } template inline std::shared_ptr daily_logger_format_st( const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {}) { return Factory::template create( logger_name, filename, hour, minute, truncate, max_files, event_handlers); } } // namespace spdlog RcppSpdlog/inst/include/spdlog/sinks/callback_sink.h0000644000176200001440000000325114550234366022310 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include #include #include #include namespace spdlog { // callbacks type typedef std::function custom_log_callback; namespace sinks { /* * Trivial callback sink, gets a callback function and calls it on each log */ template class callback_sink final : public base_sink { public: explicit callback_sink(const custom_log_callback &callback) : callback_{callback} {} protected: void sink_it_(const details::log_msg &msg) override { callback_(msg); } void flush_() override{}; private: custom_log_callback callback_; }; using callback_sink_mt = callback_sink; using callback_sink_st = callback_sink; } // namespace sinks // // factory functions // template inline std::shared_ptr callback_logger_mt(const std::string &logger_name, const custom_log_callback &callback) { return Factory::template create(logger_name, callback); } template inline std::shared_ptr callback_logger_st(const std::string &logger_name, const custom_log_callback &callback) { return Factory::template create(logger_name, callback); } } // namespace spdlog RcppSpdlog/inst/include/spdlog/sinks/rotating_file_sink-inl.h0000644000176200001440000001146514550234366024170 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifndef SPDLOG_HEADER_ONLY #include #endif #include #include #include #include #include #include #include #include #include #include namespace spdlog { namespace sinks { template SPDLOG_INLINE rotating_file_sink::rotating_file_sink( filename_t base_filename, std::size_t max_size, std::size_t max_files, bool rotate_on_open, const file_event_handlers &event_handlers) : base_filename_(std::move(base_filename)), max_size_(max_size), max_files_(max_files), file_helper_{event_handlers} { if (max_size == 0) { throw_spdlog_ex("rotating sink constructor: max_size arg cannot be zero"); } if (max_files > 200000) { throw_spdlog_ex("rotating sink constructor: max_files arg cannot exceed 200000"); } file_helper_.open(calc_filename(base_filename_, 0)); current_size_ = file_helper_.size(); // expensive. called only once if (rotate_on_open && current_size_ > 0) { rotate_(); current_size_ = 0; } } // calc filename according to index and file extension if exists. // e.g. calc_filename("logs/mylog.txt, 3) => "logs/mylog.3.txt". template SPDLOG_INLINE filename_t rotating_file_sink::calc_filename(const filename_t &filename, std::size_t index) { if (index == 0u) { return filename; } filename_t basename, ext; std::tie(basename, ext) = details::file_helper::split_by_extension(filename); return fmt_lib::format(SPDLOG_FILENAME_T("{}.{}{}"), basename, index, ext); } template SPDLOG_INLINE filename_t rotating_file_sink::filename() { std::lock_guard lock(base_sink::mutex_); return file_helper_.filename(); } template SPDLOG_INLINE void rotating_file_sink::sink_it_(const details::log_msg &msg) { memory_buf_t formatted; base_sink::formatter_->format(msg, formatted); auto new_size = current_size_ + formatted.size(); // rotate if the new estimated file size exceeds max size. // rotate only if the real size > 0 to better deal with full disk (see issue #2261). // we only check the real size when new_size > max_size_ because it is relatively expensive. if (new_size > max_size_) { file_helper_.flush(); if (file_helper_.size() > 0) { rotate_(); new_size = formatted.size(); } } file_helper_.write(formatted); current_size_ = new_size; } template SPDLOG_INLINE void rotating_file_sink::flush_() { file_helper_.flush(); } // Rotate files: // log.txt -> log.1.txt // log.1.txt -> log.2.txt // log.2.txt -> log.3.txt // log.3.txt -> delete template SPDLOG_INLINE void rotating_file_sink::rotate_() { using details::os::filename_to_str; using details::os::path_exists; file_helper_.close(); for (auto i = max_files_; i > 0; --i) { filename_t src = calc_filename(base_filename_, i - 1); if (!path_exists(src)) { continue; } filename_t target = calc_filename(base_filename_, i); if (!rename_file_(src, target)) { // if failed try again after a small delay. // this is a workaround to a windows issue, where very high rotation // rates can cause the rename to fail with permission denied (because of antivirus?). details::os::sleep_for_millis(100); if (!rename_file_(src, target)) { file_helper_.reopen( true); // truncate the log file anyway to prevent it to grow beyond its limit! current_size_ = 0; throw_spdlog_ex("rotating_file_sink: failed renaming " + filename_to_str(src) + " to " + filename_to_str(target), errno); } } } file_helper_.reopen(true); } // delete the target if exists, and rename the src file to target // return true on success, false otherwise. template SPDLOG_INLINE bool rotating_file_sink::rename_file_(const filename_t &src_filename, const filename_t &target_filename) { // try to delete the target file in case it already exists. (void)details::os::remove(target_filename); return details::os::rename(src_filename, target_filename) == 0; } } // namespace sinks } // namespace spdlog RcppSpdlog/inst/include/spdlog/sinks/hourly_file_sink.h0000644000176200001440000001572114550234366023102 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include namespace spdlog { namespace sinks { /* * Generator of Hourly log file names in format basename.YYYY-MM-DD-HH.ext */ struct hourly_filename_calculator { // Create filename for the form basename.YYYY-MM-DD-H static filename_t calc_filename(const filename_t &filename, const tm &now_tm) { filename_t basename, ext; std::tie(basename, ext) = details::file_helper::split_by_extension(filename); return fmt_lib::format(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}_{:02d}{}"), basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday, now_tm.tm_hour, ext); } }; /* * Rotating file sink based on time. * If truncate != false , the created file will be truncated. * If max_files > 0, retain only the last max_files and delete previous. */ template class hourly_file_sink final : public base_sink { public: // create hourly file sink which rotates on given time hourly_file_sink(filename_t base_filename, bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {}) : base_filename_(std::move(base_filename)), file_helper_{event_handlers}, truncate_(truncate), max_files_(max_files), filenames_q_() { auto now = log_clock::now(); auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now)); file_helper_.open(filename, truncate_); remove_init_file_ = file_helper_.size() == 0; rotation_tp_ = next_rotation_tp_(); if (max_files_ > 0) { init_filenames_q_(); } } filename_t filename() { std::lock_guard lock(base_sink::mutex_); return file_helper_.filename(); } protected: void sink_it_(const details::log_msg &msg) override { auto time = msg.time; bool should_rotate = time >= rotation_tp_; if (should_rotate) { if (remove_init_file_) { file_helper_.close(); details::os::remove(file_helper_.filename()); } auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(time)); file_helper_.open(filename, truncate_); rotation_tp_ = next_rotation_tp_(); } remove_init_file_ = false; memory_buf_t formatted; base_sink::formatter_->format(msg, formatted); file_helper_.write(formatted); // Do the cleaning only at the end because it might throw on failure. if (should_rotate && max_files_ > 0) { delete_old_(); } } void flush_() override { file_helper_.flush(); } private: void init_filenames_q_() { using details::os::path_exists; filenames_q_ = details::circular_q(static_cast(max_files_)); std::vector filenames; auto now = log_clock::now(); while (filenames.size() < max_files_) { auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now)); if (!path_exists(filename)) { break; } filenames.emplace_back(filename); now -= std::chrono::hours(1); } for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) { filenames_q_.push_back(std::move(*iter)); } } tm now_tm(log_clock::time_point tp) { time_t tnow = log_clock::to_time_t(tp); return spdlog::details::os::localtime(tnow); } log_clock::time_point next_rotation_tp_() { auto now = log_clock::now(); tm date = now_tm(now); date.tm_min = 0; date.tm_sec = 0; auto rotation_time = log_clock::from_time_t(std::mktime(&date)); if (rotation_time > now) { return rotation_time; } return {rotation_time + std::chrono::hours(1)}; } // Delete the file N rotations ago. // Throw spdlog_ex on failure to delete the old file. void delete_old_() { using details::os::filename_to_str; using details::os::remove_if_exists; filename_t current_file = file_helper_.filename(); if (filenames_q_.full()) { auto old_filename = std::move(filenames_q_.front()); filenames_q_.pop_front(); bool ok = remove_if_exists(old_filename) == 0; if (!ok) { filenames_q_.push_back(std::move(current_file)); SPDLOG_THROW(spdlog_ex( "Failed removing hourly file " + filename_to_str(old_filename), errno)); } } filenames_q_.push_back(std::move(current_file)); } filename_t base_filename_; log_clock::time_point rotation_tp_; details::file_helper file_helper_; bool truncate_; uint16_t max_files_; details::circular_q filenames_q_; bool remove_init_file_; }; using hourly_file_sink_mt = hourly_file_sink; using hourly_file_sink_st = hourly_file_sink; } // namespace sinks // // factory functions // template inline std::shared_ptr hourly_logger_mt(const std::string &logger_name, const filename_t &filename, bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {}) { return Factory::template create(logger_name, filename, truncate, max_files, event_handlers); } template inline std::shared_ptr hourly_logger_st(const std::string &logger_name, const filename_t &filename, bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {}) { return Factory::template create(logger_name, filename, truncate, max_files, event_handlers); } } // namespace spdlog RcppSpdlog/inst/include/spdlog/sinks/null_sink.h0000644000176200001440000000232214550234366021524 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include #include #include namespace spdlog { namespace sinks { template class null_sink : public base_sink { protected: void sink_it_(const details::log_msg &) override {} void flush_() override {} }; using null_sink_mt = null_sink; using null_sink_st = null_sink; } // namespace sinks template inline std::shared_ptr null_logger_mt(const std::string &logger_name) { auto null_logger = Factory::template create(logger_name); null_logger->set_level(level::off); return null_logger; } template inline std::shared_ptr null_logger_st(const std::string &logger_name) { auto null_logger = Factory::template create(logger_name); null_logger->set_level(level::off); return null_logger; } } // namespace spdlog RcppSpdlog/inst/include/spdlog/sinks/base_sink-inl.h0000644000176200001440000000342014550234366022244 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifndef SPDLOG_HEADER_ONLY #include #endif #include #include #include #include template SPDLOG_INLINE spdlog::sinks::base_sink::base_sink() : formatter_{details::make_unique()} {} template SPDLOG_INLINE spdlog::sinks::base_sink::base_sink( std::unique_ptr formatter) : formatter_{std::move(formatter)} {} template void SPDLOG_INLINE spdlog::sinks::base_sink::log(const details::log_msg &msg) { std::lock_guard lock(mutex_); sink_it_(msg); } template void SPDLOG_INLINE spdlog::sinks::base_sink::flush() { std::lock_guard lock(mutex_); flush_(); } template void SPDLOG_INLINE spdlog::sinks::base_sink::set_pattern(const std::string &pattern) { std::lock_guard lock(mutex_); set_pattern_(pattern); } template void SPDLOG_INLINE spdlog::sinks::base_sink::set_formatter(std::unique_ptr sink_formatter) { std::lock_guard lock(mutex_); set_formatter_(std::move(sink_formatter)); } template void SPDLOG_INLINE spdlog::sinks::base_sink::set_pattern_(const std::string &pattern) { set_formatter_(details::make_unique(pattern)); } template void SPDLOG_INLINE spdlog::sinks::base_sink::set_formatter_(std::unique_ptr sink_formatter) { formatter_ = std::move(sink_formatter); } RcppSpdlog/inst/include/spdlog/sinks/dup_filter_sink.h0000644000176200001440000000625314550234366022716 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include "dist_sink.h" #include #include #include #include #include #include // Duplicate message removal sink. // Skip the message if previous one is identical and less than "max_skip_duration" have passed // // Example: // // #include // // int main() { // auto dup_filter = std::make_shared(std::chrono::seconds(5), // level::info); dup_filter->add_sink(std::make_shared()); // spdlog::logger l("logger", dup_filter); // l.info("Hello"); // l.info("Hello"); // l.info("Hello"); // l.info("Different Hello"); // } // // Will produce: // [2019-06-25 17:50:56.511] [logger] [info] Hello // [2019-06-25 17:50:56.512] [logger] [info] Skipped 3 duplicate messages.. // [2019-06-25 17:50:56.512] [logger] [info] Different Hello namespace spdlog { namespace sinks { template class dup_filter_sink : public dist_sink { public: template explicit dup_filter_sink(std::chrono::duration max_skip_duration, level::level_enum notification_level = level::info) : max_skip_duration_{max_skip_duration}, log_level_{notification_level} {} protected: std::chrono::microseconds max_skip_duration_; log_clock::time_point last_msg_time_; std::string last_msg_payload_; size_t skip_counter_ = 0; level::level_enum log_level_; void sink_it_(const details::log_msg &msg) override { bool filtered = filter_(msg); if (!filtered) { skip_counter_ += 1; return; } // log the "skipped.." message if (skip_counter_ > 0) { char buf[64]; auto msg_size = ::snprintf(buf, sizeof(buf), "Skipped %u duplicate messages..", static_cast(skip_counter_)); if (msg_size > 0 && static_cast(msg_size) < sizeof(buf)) { details::log_msg skipped_msg{msg.source, msg.logger_name, log_level_, string_view_t{buf, static_cast(msg_size)}}; dist_sink::sink_it_(skipped_msg); } } // log current message dist_sink::sink_it_(msg); last_msg_time_ = msg.time; skip_counter_ = 0; last_msg_payload_.assign(msg.payload.data(), msg.payload.data() + msg.payload.size()); } // return whether the log msg should be displayed (true) or skipped (false) bool filter_(const details::log_msg &msg) { auto filter_duration = msg.time - last_msg_time_; return (filter_duration > max_skip_duration_) || (msg.payload != last_msg_payload_); } }; using dup_filter_sink_mt = dup_filter_sink; using dup_filter_sink_st = dup_filter_sink; } // namespace sinks } // namespace spdlog RcppSpdlog/inst/include/spdlog/sinks/dist_sink.h0000644000176200001440000000450514550234366021522 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include "base_sink.h" #include #include #include #include #include #include #include // Distribution sink (mux). Stores a vector of sinks which get called when log // is called namespace spdlog { namespace sinks { template class dist_sink : public base_sink { public: dist_sink() = default; explicit dist_sink(std::vector> sinks) : sinks_(sinks) {} dist_sink(const dist_sink &) = delete; dist_sink &operator=(const dist_sink &) = delete; void add_sink(std::shared_ptr sub_sink) { std::lock_guard lock(base_sink::mutex_); sinks_.push_back(sub_sink); } void remove_sink(std::shared_ptr sub_sink) { std::lock_guard lock(base_sink::mutex_); sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sub_sink), sinks_.end()); } void set_sinks(std::vector> sinks) { std::lock_guard lock(base_sink::mutex_); sinks_ = std::move(sinks); } std::vector> &sinks() { return sinks_; } protected: void sink_it_(const details::log_msg &msg) override { for (auto &sub_sink : sinks_) { if (sub_sink->should_log(msg.level)) { sub_sink->log(msg); } } } void flush_() override { for (auto &sub_sink : sinks_) { sub_sink->flush(); } } void set_pattern_(const std::string &pattern) override { set_formatter_(details::make_unique(pattern)); } void set_formatter_(std::unique_ptr sink_formatter) override { base_sink::formatter_ = std::move(sink_formatter); for (auto &sub_sink : sinks_) { sub_sink->set_formatter(base_sink::formatter_->clone()); } } std::vector> sinks_; }; using dist_sink_mt = dist_sink; using dist_sink_st = dist_sink; } // namespace sinks } // namespace spdlog RcppSpdlog/inst/include/spdlog/sinks/ringbuffer_sink.h0000644000176200001440000000404114550234366022703 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include "spdlog/details/circular_q.h" #include "spdlog/details/log_msg_buffer.h" #include "spdlog/details/null_mutex.h" #include "spdlog/sinks/base_sink.h" #include #include #include namespace spdlog { namespace sinks { /* * Ring buffer sink */ template class ringbuffer_sink final : public base_sink { public: explicit ringbuffer_sink(size_t n_items) : q_{n_items} {} std::vector last_raw(size_t lim = 0) { std::lock_guard lock(base_sink::mutex_); auto items_available = q_.size(); auto n_items = lim > 0 ? (std::min)(lim, items_available) : items_available; std::vector ret; ret.reserve(n_items); for (size_t i = (items_available - n_items); i < items_available; i++) { ret.push_back(q_.at(i)); } return ret; } std::vector last_formatted(size_t lim = 0) { std::lock_guard lock(base_sink::mutex_); auto items_available = q_.size(); auto n_items = lim > 0 ? (std::min)(lim, items_available) : items_available; std::vector ret; ret.reserve(n_items); for (size_t i = (items_available - n_items); i < items_available; i++) { memory_buf_t formatted; base_sink::formatter_->format(q_.at(i), formatted); ret.push_back(SPDLOG_BUF_TO_STRING(formatted)); } return ret; } protected: void sink_it_(const details::log_msg &msg) override { q_.push_back(details::log_msg_buffer{msg}); } void flush_() override {} private: details::circular_q q_; }; using ringbuffer_sink_mt = ringbuffer_sink; using ringbuffer_sink_st = ringbuffer_sink; } // namespace sinks } // namespace spdlog RcppSpdlog/inst/include/spdlog/sinks/stdout_color_sinks-inl.h0000644000176200001440000000263314550234366024242 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifndef SPDLOG_HEADER_ONLY #include #endif #include #include namespace spdlog { template SPDLOG_INLINE std::shared_ptr stdout_color_mt(const std::string &logger_name, color_mode mode) { return Factory::template create(logger_name, mode); } template SPDLOG_INLINE std::shared_ptr stdout_color_st(const std::string &logger_name, color_mode mode) { return Factory::template create(logger_name, mode); } template SPDLOG_INLINE std::shared_ptr stderr_color_mt(const std::string &logger_name, color_mode mode) { return Factory::template create(logger_name, mode); } template SPDLOG_INLINE std::shared_ptr stderr_color_st(const std::string &logger_name, color_mode mode) { return Factory::template create(logger_name, mode); } } // namespace spdlog RcppSpdlog/inst/include/spdlog/sinks/mongo_sink.h0000644000176200001440000000764314550234366021704 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once // // Custom sink for mongodb // Building and using requires mongocxx library. // For building mongocxx library check the url below // http://mongocxx.org/mongocxx-v3/installation/ // #include "spdlog/common.h" #include "spdlog/details/log_msg.h" #include "spdlog/sinks/base_sink.h" #include #include #include #include #include #include #include namespace spdlog { namespace sinks { template class mongo_sink : public base_sink { public: mongo_sink(const std::string &db_name, const std::string &collection_name, const std::string &uri = "mongodb://localhost:27017") try : mongo_sink(std::make_shared(), db_name, collection_name, uri) { } catch (const std::exception &e) { throw_spdlog_ex(fmt_lib::format("Error opening database: {}", e.what())); } mongo_sink(std::shared_ptr instance, const std::string &db_name, const std::string &collection_name, const std::string &uri = "mongodb://localhost:27017") : instance_(std::move(instance)), db_name_(db_name), coll_name_(collection_name) { try { client_ = spdlog::details::make_unique(mongocxx::uri{uri}); } catch (const std::exception &e) { throw_spdlog_ex(fmt_lib::format("Error opening database: {}", e.what())); } } ~mongo_sink() { flush_(); } protected: void sink_it_(const details::log_msg &msg) override { using bsoncxx::builder::stream::document; using bsoncxx::builder::stream::finalize; if (client_ != nullptr) { auto doc = document{} << "timestamp" << bsoncxx::types::b_date(msg.time) << "level" << level::to_string_view(msg.level).data() << "level_num" << msg.level << "message" << std::string(msg.payload.begin(), msg.payload.end()) << "logger_name" << std::string(msg.logger_name.begin(), msg.logger_name.end()) << "thread_id" << static_cast(msg.thread_id) << finalize; client_->database(db_name_).collection(coll_name_).insert_one(doc.view()); } } void flush_() override {} private: std::shared_ptr instance_; std::string db_name_; std::string coll_name_; std::unique_ptr client_ = nullptr; }; #include "spdlog/details/null_mutex.h" #include using mongo_sink_mt = mongo_sink; using mongo_sink_st = mongo_sink; } // namespace sinks template inline std::shared_ptr mongo_logger_mt( const std::string &logger_name, const std::string &db_name, const std::string &collection_name, const std::string &uri = "mongodb://localhost:27017") { return Factory::template create(logger_name, db_name, collection_name, uri); } template inline std::shared_ptr mongo_logger_st( const std::string &logger_name, const std::string &db_name, const std::string &collection_name, const std::string &uri = "mongodb://localhost:27017") { return Factory::template create(logger_name, db_name, collection_name, uri); } } // namespace spdlog RcppSpdlog/inst/include/spdlog/sinks/wincolor_sink.h0000644000176200001440000000523414550234366022413 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include #include #include #include #include #include #include #include namespace spdlog { namespace sinks { /* * Windows color console sink. Uses WriteConsoleA to write to the console with * colors */ template class wincolor_sink : public sink { public: wincolor_sink(void *out_handle, color_mode mode); ~wincolor_sink() override; wincolor_sink(const wincolor_sink &other) = delete; wincolor_sink &operator=(const wincolor_sink &other) = delete; // change the color for the given level void set_color(level::level_enum level, std::uint16_t color); void log(const details::log_msg &msg) final override; void flush() final override; void set_pattern(const std::string &pattern) override final; void set_formatter(std::unique_ptr sink_formatter) override final; void set_color_mode(color_mode mode); protected: using mutex_t = typename ConsoleMutex::mutex_t; void *out_handle_; mutex_t &mutex_; bool should_do_colors_; std::unique_ptr formatter_; std::array colors_; // set foreground color and return the orig console attributes (for resetting later) std::uint16_t set_foreground_color_(std::uint16_t attribs); // print a range of formatted message to console void print_range_(const memory_buf_t &formatted, size_t start, size_t end); // in case we are redirected to file (not in console mode) void write_to_file_(const memory_buf_t &formatted); void set_color_mode_impl(color_mode mode); }; template class wincolor_stdout_sink : public wincolor_sink { public: explicit wincolor_stdout_sink(color_mode mode = color_mode::automatic); }; template class wincolor_stderr_sink : public wincolor_sink { public: explicit wincolor_stderr_sink(color_mode mode = color_mode::automatic); }; using wincolor_stdout_sink_mt = wincolor_stdout_sink; using wincolor_stdout_sink_st = wincolor_stdout_sink; using wincolor_stderr_sink_mt = wincolor_stderr_sink; using wincolor_stderr_sink_st = wincolor_stderr_sink; } // namespace sinks } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY #include "wincolor_sink-inl.h" #endif RcppSpdlog/inst/include/spdlog/sinks/sink.h0000644000176200001440000000157514550234366020503 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include namespace spdlog { namespace sinks { class SPDLOG_API sink { public: virtual ~sink() = default; virtual void log(const details::log_msg &msg) = 0; virtual void flush() = 0; virtual void set_pattern(const std::string &pattern) = 0; virtual void set_formatter(std::unique_ptr sink_formatter) = 0; void set_level(level::level_enum log_level); level::level_enum level() const; bool should_log(level::level_enum msg_level) const; protected: // sink log level - default is all level_t level_{level::trace}; }; } // namespace sinks } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY #include "sink-inl.h" #endif RcppSpdlog/inst/include/spdlog/sinks/msvc_sink.h0000644000176200001440000000400114550234366021516 0ustar liggesusers// Copyright(c) 2016 Alexander Dalshov & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #if defined(_WIN32) #include #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) #include #endif #include #include #include // Avoid including windows.h (https://stackoverflow.com/a/30741042) #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) extern "C" __declspec(dllimport) void __stdcall OutputDebugStringW(const wchar_t *lpOutputString); #else extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA(const char *lpOutputString); #endif extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); namespace spdlog { namespace sinks { /* * MSVC sink (logging using OutputDebugStringA) */ template class msvc_sink : public base_sink { public: msvc_sink() = default; msvc_sink(bool check_debugger_present) : check_debugger_present_{check_debugger_present} {}; protected: void sink_it_(const details::log_msg &msg) override { if (check_debugger_present_ && !IsDebuggerPresent()) { return; } memory_buf_t formatted; base_sink::formatter_->format(msg, formatted); formatted.push_back('\0'); // add a null terminator for OutputDebugString #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) wmemory_buf_t wformatted; details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), wformatted); OutputDebugStringW(wformatted.data()); #else OutputDebugStringA(formatted.data()); #endif } void flush_() override {} bool check_debugger_present_ = true; }; using msvc_sink_mt = msvc_sink; using msvc_sink_st = msvc_sink; using windebug_sink_mt = msvc_sink_mt; using windebug_sink_st = msvc_sink_st; } // namespace sinks } // namespace spdlog #endif RcppSpdlog/inst/include/spdlog/sinks/win_eventlog_sink.h0000644000176200001440000002127014550234366023255 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) // Writing to Windows Event Log requires the registry entries below to be present, with the // following modifications: // 1. should be replaced with your log name (e.g. your application name) // 2. should be replaced with the specific source name and the key should be // duplicated for // each source used in the application // // Since typically modifications of this kind require elevation, it's better to do it as a part of // setup procedure. The snippet below uses mscoree.dll as the message file as it exists on most of // the Windows systems anyway and happens to contain the needed resource. // // You can also specify a custom message file if needed. // Please refer to Event Log functions descriptions in MSDN for more details on custom message // files. /*--------------------------------------------------------------------------------------- Windows Registry Editor Version 5.00 [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\EventLog\] [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\EventLog\\] "TypesSupported"=dword:00000007 "EventMessageFile"=hex(2):25,00,73,00,79,00,73,00,74,00,65,00,6d,00,72,00,6f,\ 00,6f,00,74,00,25,00,5c,00,53,00,79,00,73,00,74,00,65,00,6d,00,33,00,32,00,\ 5c,00,6d,00,73,00,63,00,6f,00,72,00,65,00,65,00,2e,00,64,00,6c,00,6c,00,00,\ 00 -----------------------------------------------------------------------------------------*/ #pragma once #include #include #include #include #include #include #include namespace spdlog { namespace sinks { namespace win_eventlog { namespace internal { struct local_alloc_t { HLOCAL hlocal_; SPDLOG_CONSTEXPR local_alloc_t() SPDLOG_NOEXCEPT : hlocal_(nullptr) {} local_alloc_t(local_alloc_t const &) = delete; local_alloc_t &operator=(local_alloc_t const &) = delete; ~local_alloc_t() SPDLOG_NOEXCEPT { if (hlocal_) { LocalFree(hlocal_); } } }; /** Windows error */ struct win32_error : public spdlog_ex { /** Formats an error report line: "user-message: error-code (system message)" */ static std::string format(std::string const &user_message, DWORD error_code = GetLastError()) { std::string system_message; local_alloc_t format_message_result{}; auto format_message_succeeded = ::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&format_message_result.hlocal_, 0, nullptr); if (format_message_succeeded && format_message_result.hlocal_) { system_message = fmt_lib::format(" ({})", (LPSTR)format_message_result.hlocal_); } return fmt_lib::format("{}: {}{}", user_message, error_code, system_message); } explicit win32_error(std::string const &func_name, DWORD error = GetLastError()) : spdlog_ex(format(func_name, error)) {} }; /** Wrapper for security identifiers (SID) on Windows */ struct sid_t { std::vector buffer_; public: sid_t() {} /** creates a wrapped SID copy */ static sid_t duplicate_sid(PSID psid) { if (!::IsValidSid(psid)) { throw_spdlog_ex("sid_t::sid_t(): invalid SID received"); } auto const sid_length{::GetLengthSid(psid)}; sid_t result; result.buffer_.resize(sid_length); if (!::CopySid(sid_length, (PSID)result.as_sid(), psid)) { SPDLOG_THROW(win32_error("CopySid")); } return result; } /** Retrieves pointer to the internal buffer contents as SID* */ SID *as_sid() const { return buffer_.empty() ? nullptr : (SID *)buffer_.data(); } /** Get SID for the current user */ static sid_t get_current_user_sid() { /* create and init RAII holder for process token */ struct process_token_t { HANDLE token_handle_ = INVALID_HANDLE_VALUE; explicit process_token_t(HANDLE process) { if (!::OpenProcessToken(process, TOKEN_QUERY, &token_handle_)) { SPDLOG_THROW(win32_error("OpenProcessToken")); } } ~process_token_t() { ::CloseHandle(token_handle_); } } current_process_token( ::GetCurrentProcess()); // GetCurrentProcess returns pseudohandle, no leak here! // Get the required size, this is expected to fail with ERROR_INSUFFICIENT_BUFFER and return // the token size DWORD tusize = 0; if (::GetTokenInformation(current_process_token.token_handle_, TokenUser, NULL, 0, &tusize)) { SPDLOG_THROW(win32_error("GetTokenInformation should fail")); } // get user token std::vector buffer(static_cast(tusize)); if (!::GetTokenInformation(current_process_token.token_handle_, TokenUser, (LPVOID)buffer.data(), tusize, &tusize)) { SPDLOG_THROW(win32_error("GetTokenInformation")); } // create a wrapper of the SID data as stored in the user token return sid_t::duplicate_sid(((TOKEN_USER *)buffer.data())->User.Sid); } }; struct eventlog { static WORD get_event_type(details::log_msg const &msg) { switch (msg.level) { case level::trace: case level::debug: return EVENTLOG_SUCCESS; case level::info: return EVENTLOG_INFORMATION_TYPE; case level::warn: return EVENTLOG_WARNING_TYPE; case level::err: case level::critical: case level::off: return EVENTLOG_ERROR_TYPE; default: return EVENTLOG_INFORMATION_TYPE; } } static WORD get_event_category(details::log_msg const &msg) { return (WORD)msg.level; } }; } // namespace internal /* * Windows Event Log sink */ template class win_eventlog_sink : public base_sink { private: HANDLE hEventLog_{NULL}; internal::sid_t current_user_sid_; std::string source_; DWORD event_id_; HANDLE event_log_handle() { if (!hEventLog_) { hEventLog_ = ::RegisterEventSourceA(nullptr, source_.c_str()); if (!hEventLog_ || hEventLog_ == (HANDLE)ERROR_ACCESS_DENIED) { SPDLOG_THROW(internal::win32_error("RegisterEventSource")); } } return hEventLog_; } protected: void sink_it_(const details::log_msg &msg) override { using namespace internal; bool succeeded; memory_buf_t formatted; base_sink::formatter_->format(msg, formatted); formatted.push_back('\0'); #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT wmemory_buf_t buf; details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), buf); LPCWSTR lp_wstr = buf.data(); succeeded = static_cast(::ReportEventW( event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg), event_id_, current_user_sid_.as_sid(), 1, 0, &lp_wstr, nullptr)); #else LPCSTR lp_str = formatted.data(); succeeded = static_cast(::ReportEventA( event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg), event_id_, current_user_sid_.as_sid(), 1, 0, &lp_str, nullptr)); #endif if (!succeeded) { SPDLOG_THROW(win32_error("ReportEvent")); } } void flush_() override {} public: win_eventlog_sink(std::string const &source, DWORD event_id = 1000 /* according to mscoree.dll */) : source_(source), event_id_(event_id) { try { current_user_sid_ = internal::sid_t::get_current_user_sid(); } catch (...) { // get_current_user_sid() is unlikely to fail and if it does, we can still proceed // without current_user_sid but in the event log the record will have no user name } } ~win_eventlog_sink() { if (hEventLog_) DeregisterEventSource(hEventLog_); } }; } // namespace win_eventlog using win_eventlog_sink_mt = win_eventlog::win_eventlog_sink; using win_eventlog_sink_st = win_eventlog::win_eventlog_sink; } // namespace sinks } // namespace spdlog RcppSpdlog/inst/include/spdlog/sinks/basic_file_sink.h0000644000176200001440000000436714550234366022645 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include #include #include #include #include namespace spdlog { namespace sinks { /* * Trivial file sink with single file as target */ template class basic_file_sink final : public base_sink { public: explicit basic_file_sink(const filename_t &filename, bool truncate = false, const file_event_handlers &event_handlers = {}); const filename_t &filename() const; protected: void sink_it_(const details::log_msg &msg) override; void flush_() override; private: details::file_helper file_helper_; }; using basic_file_sink_mt = basic_file_sink; using basic_file_sink_st = basic_file_sink; } // namespace sinks // // factory functions // template inline std::shared_ptr basic_logger_mt(const std::string &logger_name, const filename_t &filename, bool truncate = false, const file_event_handlers &event_handlers = {}) { return Factory::template create(logger_name, filename, truncate, event_handlers); } template inline std::shared_ptr basic_logger_st(const std::string &logger_name, const filename_t &filename, bool truncate = false, const file_event_handlers &event_handlers = {}) { return Factory::template create(logger_name, filename, truncate, event_handlers); } } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY #include "basic_file_sink-inl.h" #endif RcppSpdlog/inst/include/spdlog/sinks/stdout_sinks-inl.h0000644000176200001440000001037314550234366023044 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifndef SPDLOG_HEADER_ONLY #include #endif #include #include #include #ifdef _WIN32 // under windows using fwrite to non-binary stream results in \r\r\n (see issue #1675) // so instead we use ::FileWrite #include #ifndef _USING_V110_SDK71_ // fileapi.h doesn't exist in winxp #include // WriteFile (..) #endif #include // _get_osfhandle(..) #include // _fileno(..) #endif // WIN32 namespace spdlog { namespace sinks { template SPDLOG_INLINE stdout_sink_base::stdout_sink_base(FILE *file) : mutex_(ConsoleMutex::mutex()), file_(file), formatter_(details::make_unique()) { #ifdef _WIN32 // get windows handle from the FILE* object handle_ = reinterpret_cast(::_get_osfhandle(::_fileno(file_))); // don't throw to support cases where no console is attached, // and let the log method to do nothing if (handle_ == INVALID_HANDLE_VALUE). // throw only if non stdout/stderr target is requested (probably regular file and not console). if (handle_ == INVALID_HANDLE_VALUE && file != stdout && file != stderr) { throw_spdlog_ex("spdlog::stdout_sink_base: _get_osfhandle() failed", errno); } #endif // WIN32 } template SPDLOG_INLINE void stdout_sink_base::log(const details::log_msg &msg) { #ifdef _WIN32 if (handle_ == INVALID_HANDLE_VALUE) { return; } std::lock_guard lock(mutex_); memory_buf_t formatted; formatter_->format(msg, formatted); auto size = static_cast(formatted.size()); DWORD bytes_written = 0; bool ok = ::WriteFile(handle_, formatted.data(), size, &bytes_written, nullptr) != 0; if (!ok) { throw_spdlog_ex("stdout_sink_base: WriteFile() failed. GetLastError(): " + std::to_string(::GetLastError())); } #else std::lock_guard lock(mutex_); memory_buf_t formatted; formatter_->format(msg, formatted); ::fwrite(formatted.data(), sizeof(char), formatted.size(), file_); #endif // WIN32 ::fflush(file_); // flush every line to terminal } template SPDLOG_INLINE void stdout_sink_base::flush() { std::lock_guard lock(mutex_); fflush(file_); } template SPDLOG_INLINE void stdout_sink_base::set_pattern(const std::string &pattern) { std::lock_guard lock(mutex_); formatter_ = std::unique_ptr(new pattern_formatter(pattern)); } template SPDLOG_INLINE void stdout_sink_base::set_formatter( std::unique_ptr sink_formatter) { std::lock_guard lock(mutex_); formatter_ = std::move(sink_formatter); } // stdout sink template SPDLOG_INLINE stdout_sink::stdout_sink() : stdout_sink_base(stdout) {} // stderr sink template SPDLOG_INLINE stderr_sink::stderr_sink() : stdout_sink_base(stderr) {} } // namespace sinks // factory methods template SPDLOG_INLINE std::shared_ptr stdout_logger_mt(const std::string &logger_name) { return Factory::template create(logger_name); } template SPDLOG_INLINE std::shared_ptr stdout_logger_st(const std::string &logger_name) { return Factory::template create(logger_name); } template SPDLOG_INLINE std::shared_ptr stderr_logger_mt(const std::string &logger_name) { return Factory::template create(logger_name); } template SPDLOG_INLINE std::shared_ptr stderr_logger_st(const std::string &logger_name) { return Factory::template create(logger_name); } } // namespace spdlog RcppSpdlog/inst/include/spdlog/sinks/tcp_sink.h0000644000176200001440000000411714550234366021344 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include #include #ifdef _WIN32 #include #else #include #endif #include #include #include #include #pragma once // Simple tcp client sink // Connects to remote address and send the formatted log. // Will attempt to reconnect if connection drops. // If more complicated behaviour is needed (i.e get responses), you can inherit it and override the // sink_it_ method. namespace spdlog { namespace sinks { struct tcp_sink_config { std::string server_host; int server_port; bool lazy_connect = false; // if true connect on first log call instead of on construction tcp_sink_config(std::string host, int port) : server_host{std::move(host)}, server_port{port} {} }; template class tcp_sink : public spdlog::sinks::base_sink { public: // connect to tcp host/port or throw if failed // host can be hostname or ip address explicit tcp_sink(tcp_sink_config sink_config) : config_{std::move(sink_config)} { if (!config_.lazy_connect) { this->client_.connect(config_.server_host, config_.server_port); } } ~tcp_sink() override = default; protected: void sink_it_(const spdlog::details::log_msg &msg) override { spdlog::memory_buf_t formatted; spdlog::sinks::base_sink::formatter_->format(msg, formatted); if (!client_.is_connected()) { client_.connect(config_.server_host, config_.server_port); } client_.send(formatted.data(), formatted.size()); } void flush_() override {} tcp_sink_config config_; details::tcp_client client_; }; using tcp_sink_mt = tcp_sink; using tcp_sink_st = tcp_sink; } // namespace sinks } // namespace spdlog RcppSpdlog/inst/include/spdlog/sinks/sink-inl.h0000644000176200001440000000132514550234366021254 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifndef SPDLOG_HEADER_ONLY #include #endif #include SPDLOG_INLINE bool spdlog::sinks::sink::should_log(spdlog::level::level_enum msg_level) const { return msg_level >= level_.load(std::memory_order_relaxed); } SPDLOG_INLINE void spdlog::sinks::sink::set_level(level::level_enum log_level) { level_.store(log_level, std::memory_order_relaxed); } SPDLOG_INLINE spdlog::level::level_enum spdlog::sinks::sink::level() const { return static_cast(level_.load(std::memory_order_relaxed)); } RcppSpdlog/inst/include/spdlog/sinks/ansicolor_sink-inl.h0000644000176200001440000001141314550234366023324 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifndef SPDLOG_HEADER_ONLY #include #endif #include #include namespace spdlog { namespace sinks { template SPDLOG_INLINE ansicolor_sink::ansicolor_sink(FILE *target_file, color_mode mode) : target_file_(target_file), mutex_(ConsoleMutex::mutex()), formatter_(details::make_unique()) { set_color_mode(mode); colors_.at(level::trace) = to_string_(white); colors_.at(level::debug) = to_string_(cyan); colors_.at(level::info) = to_string_(green); colors_.at(level::warn) = to_string_(yellow_bold); colors_.at(level::err) = to_string_(red_bold); colors_.at(level::critical) = to_string_(bold_on_red); colors_.at(level::off) = to_string_(reset); } template SPDLOG_INLINE void ansicolor_sink::set_color(level::level_enum color_level, string_view_t color) { std::lock_guard lock(mutex_); colors_.at(static_cast(color_level)) = to_string_(color); } template SPDLOG_INLINE void ansicolor_sink::log(const details::log_msg &msg) { // Wrap the originally formatted message in color codes. // If color is not supported in the terminal, log as is instead. std::lock_guard lock(mutex_); msg.color_range_start = 0; msg.color_range_end = 0; memory_buf_t formatted; formatter_->format(msg, formatted); if (should_do_colors_ && msg.color_range_end > msg.color_range_start) { // before color range print_range_(formatted, 0, msg.color_range_start); // in color range print_ccode_(colors_.at(static_cast(msg.level))); print_range_(formatted, msg.color_range_start, msg.color_range_end); print_ccode_(reset); // after color range print_range_(formatted, msg.color_range_end, formatted.size()); } else // no color { print_range_(formatted, 0, formatted.size()); } fflush(target_file_); } template SPDLOG_INLINE void ansicolor_sink::flush() { std::lock_guard lock(mutex_); fflush(target_file_); } template SPDLOG_INLINE void ansicolor_sink::set_pattern(const std::string &pattern) { std::lock_guard lock(mutex_); formatter_ = std::unique_ptr(new pattern_formatter(pattern)); } template SPDLOG_INLINE void ansicolor_sink::set_formatter( std::unique_ptr sink_formatter) { std::lock_guard lock(mutex_); formatter_ = std::move(sink_formatter); } template SPDLOG_INLINE bool ansicolor_sink::should_color() { return should_do_colors_; } template SPDLOG_INLINE void ansicolor_sink::set_color_mode(color_mode mode) { switch (mode) { case color_mode::always: should_do_colors_ = true; return; case color_mode::automatic: should_do_colors_ = details::os::in_terminal(target_file_) && details::os::is_color_terminal(); return; case color_mode::never: should_do_colors_ = false; return; default: should_do_colors_ = false; } } template SPDLOG_INLINE void ansicolor_sink::print_ccode_(const string_view_t &color_code) { fwrite(color_code.data(), sizeof(char), color_code.size(), target_file_); } template SPDLOG_INLINE void ansicolor_sink::print_range_(const memory_buf_t &formatted, size_t start, size_t end) { fwrite(formatted.data() + start, sizeof(char), end - start, target_file_); } template SPDLOG_INLINE std::string ansicolor_sink::to_string_(const string_view_t &sv) { return std::string(sv.data(), sv.size()); } // ansicolor_stdout_sink template SPDLOG_INLINE ansicolor_stdout_sink::ansicolor_stdout_sink(color_mode mode) : ansicolor_sink(stdout, mode) {} // ansicolor_stderr_sink template SPDLOG_INLINE ansicolor_stderr_sink::ansicolor_stderr_sink(color_mode mode) : ansicolor_sink(stderr, mode) {} } // namespace sinks } // namespace spdlog RcppSpdlog/inst/include/spdlog/sinks/ostream_sink.h0000644000176200001440000000230614550234366022226 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include #include #include namespace spdlog { namespace sinks { template class ostream_sink final : public base_sink { public: explicit ostream_sink(std::ostream &os, bool force_flush = false) : ostream_(os), force_flush_(force_flush) {} ostream_sink(const ostream_sink &) = delete; ostream_sink &operator=(const ostream_sink &) = delete; protected: void sink_it_(const details::log_msg &msg) override { memory_buf_t formatted; base_sink::formatter_->format(msg, formatted); ostream_.write(formatted.data(), static_cast(formatted.size())); if (force_flush_) { ostream_.flush(); } } void flush_() override { ostream_.flush(); } std::ostream &ostream_; bool force_flush_; }; using ostream_sink_mt = ostream_sink; using ostream_sink_st = ostream_sink; } // namespace sinks } // namespace spdlog RcppSpdlog/inst/include/spdlog/sinks/stdout_color_sinks.h0000644000176200001440000000340014550234366023453 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifdef _WIN32 #include #else #include #endif #include namespace spdlog { namespace sinks { #ifdef _WIN32 using stdout_color_sink_mt = wincolor_stdout_sink_mt; using stdout_color_sink_st = wincolor_stdout_sink_st; using stderr_color_sink_mt = wincolor_stderr_sink_mt; using stderr_color_sink_st = wincolor_stderr_sink_st; #else using stdout_color_sink_mt = ansicolor_stdout_sink_mt; using stdout_color_sink_st = ansicolor_stdout_sink_st; using stderr_color_sink_mt = ansicolor_stderr_sink_mt; using stderr_color_sink_st = ansicolor_stderr_sink_st; #endif } // namespace sinks template std::shared_ptr stdout_color_mt(const std::string &logger_name, color_mode mode = color_mode::automatic); template std::shared_ptr stdout_color_st(const std::string &logger_name, color_mode mode = color_mode::automatic); template std::shared_ptr stderr_color_mt(const std::string &logger_name, color_mode mode = color_mode::automatic); template std::shared_ptr stderr_color_st(const std::string &logger_name, color_mode mode = color_mode::automatic); } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY #include "stdout_color_sinks-inl.h" #endif RcppSpdlog/inst/include/spdlog/sinks/syslog_sink.h0000644000176200001440000001021714550234366022074 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include #include #include #include #include namespace spdlog { namespace sinks { /** * Sink that write to syslog using the `syscall()` library call. */ template class syslog_sink : public base_sink { public: syslog_sink(std::string ident, int syslog_option, int syslog_facility, bool enable_formatting) : enable_formatting_{enable_formatting}, syslog_levels_{{/* spdlog::level::trace */ LOG_DEBUG, /* spdlog::level::debug */ LOG_DEBUG, /* spdlog::level::info */ LOG_INFO, /* spdlog::level::warn */ LOG_WARNING, /* spdlog::level::err */ LOG_ERR, /* spdlog::level::critical */ LOG_CRIT, /* spdlog::level::off */ LOG_INFO}}, ident_{std::move(ident)} { // set ident to be program name if empty ::openlog(ident_.empty() ? nullptr : ident_.c_str(), syslog_option, syslog_facility); } ~syslog_sink() override { ::closelog(); } syslog_sink(const syslog_sink &) = delete; syslog_sink &operator=(const syslog_sink &) = delete; protected: void sink_it_(const details::log_msg &msg) override { string_view_t payload; memory_buf_t formatted; if (enable_formatting_) { base_sink::formatter_->format(msg, formatted); payload = string_view_t(formatted.data(), formatted.size()); } else { payload = msg.payload; } size_t length = payload.size(); // limit to max int if (length > static_cast(std::numeric_limits::max())) { length = static_cast(std::numeric_limits::max()); } ::syslog(syslog_prio_from_level(msg), "%.*s", static_cast(length), payload.data()); } void flush_() override {} bool enable_formatting_ = false; // // Simply maps spdlog's log level to syslog priority level. // int syslog_prio_from_level(const details::log_msg &msg) const { return syslog_levels_.at(static_cast(msg.level)); } private: using levels_array = std::array; levels_array syslog_levels_; // must store the ident because the man says openlog might use the pointer as // is and not a string copy const std::string ident_; }; using syslog_sink_mt = syslog_sink; using syslog_sink_st = syslog_sink; } // namespace sinks // Create and register a syslog logger template inline std::shared_ptr syslog_logger_mt(const std::string &logger_name, const std::string &syslog_ident = "", int syslog_option = 0, int syslog_facility = LOG_USER, bool enable_formatting = false) { return Factory::template create(logger_name, syslog_ident, syslog_option, syslog_facility, enable_formatting); } template inline std::shared_ptr syslog_logger_st(const std::string &logger_name, const std::string &syslog_ident = "", int syslog_option = 0, int syslog_facility = LOG_USER, bool enable_formatting = false) { return Factory::template create(logger_name, syslog_ident, syslog_option, syslog_facility, enable_formatting); } } // namespace spdlog RcppSpdlog/inst/include/spdlog/sinks/udp_sink.h0000644000176200001440000000350214550234366021343 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include #include #ifdef _WIN32 #include #else #include #endif #include #include #include #include // Simple udp client sink // Sends formatted log via udp namespace spdlog { namespace sinks { struct udp_sink_config { std::string server_host; uint16_t server_port; udp_sink_config(std::string host, uint16_t port) : server_host{std::move(host)}, server_port{port} {} }; template class udp_sink : public spdlog::sinks::base_sink { public: // host can be hostname or ip address explicit udp_sink(udp_sink_config sink_config) : client_{sink_config.server_host, sink_config.server_port} {} ~udp_sink() override = default; protected: void sink_it_(const spdlog::details::log_msg &msg) override { spdlog::memory_buf_t formatted; spdlog::sinks::base_sink::formatter_->format(msg, formatted); client_.send(formatted.data(), formatted.size()); } void flush_() override {} details::udp_client client_; }; using udp_sink_mt = udp_sink; using udp_sink_st = udp_sink; } // namespace sinks // // factory functions // template inline std::shared_ptr udp_logger_mt(const std::string &logger_name, sinks::udp_sink_config skin_config) { return Factory::template create(logger_name, skin_config); } } // namespace spdlog RcppSpdlog/inst/include/spdlog/sinks/android_sink.h0000644000176200001440000001125114550234366022173 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #ifdef __ANDROID__ #include #include #include #include #include #include #include #include #include #include #include #if !defined(SPDLOG_ANDROID_RETRIES) #define SPDLOG_ANDROID_RETRIES 2 #endif namespace spdlog { namespace sinks { /* * Android sink * (logging using __android_log_write or __android_log_buf_write depending on the specified * BufferID) */ template class android_sink final : public base_sink { public: explicit android_sink(std::string tag = "spdlog", bool use_raw_msg = false) : tag_(std::move(tag)), use_raw_msg_(use_raw_msg) {} protected: void sink_it_(const details::log_msg &msg) override { const android_LogPriority priority = convert_to_android_(msg.level); memory_buf_t formatted; if (use_raw_msg_) { details::fmt_helper::append_string_view(msg.payload, formatted); } else { base_sink::formatter_->format(msg, formatted); } formatted.push_back('\0'); const char *msg_output = formatted.data(); // See system/core/liblog/logger_write.c for explanation of return value int ret = android_log(priority, tag_.c_str(), msg_output); if (ret == -EPERM) { return; // !__android_log_is_loggable } int retry_count = 0; while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES)) { details::os::sleep_for_millis(5); ret = android_log(priority, tag_.c_str(), msg_output); retry_count++; } if (ret < 0) { throw_spdlog_ex("logging to Android failed", ret); } } void flush_() override {} private: // There might be liblog versions used, that do not support __android_log_buf_write. So we only // compile and link against // __android_log_buf_write, if user explicitly provides a non-default log buffer. Otherwise, // when using the default log buffer, always log via __android_log_write. template typename std::enable_if(log_id::LOG_ID_MAIN), int>::type android_log( int prio, const char *tag, const char *text) { return __android_log_write(prio, tag, text); } template typename std::enable_if(log_id::LOG_ID_MAIN), int>::type android_log( int prio, const char *tag, const char *text) { return __android_log_buf_write(ID, prio, tag, text); } static android_LogPriority convert_to_android_(spdlog::level::level_enum level) { switch (level) { case spdlog::level::trace: return ANDROID_LOG_VERBOSE; case spdlog::level::debug: return ANDROID_LOG_DEBUG; case spdlog::level::info: return ANDROID_LOG_INFO; case spdlog::level::warn: return ANDROID_LOG_WARN; case spdlog::level::err: return ANDROID_LOG_ERROR; case spdlog::level::critical: return ANDROID_LOG_FATAL; default: return ANDROID_LOG_DEFAULT; } } std::string tag_; bool use_raw_msg_; }; using android_sink_mt = android_sink; using android_sink_st = android_sink; template using android_sink_buf_mt = android_sink; template using android_sink_buf_st = android_sink; } // namespace sinks // Create and register android syslog logger template inline std::shared_ptr android_logger_mt(const std::string &logger_name, const std::string &tag = "spdlog") { return Factory::template create(logger_name, tag); } template inline std::shared_ptr android_logger_st(const std::string &logger_name, const std::string &tag = "spdlog") { return Factory::template create(logger_name, tag); } } // namespace spdlog #endif // __ANDROID__ RcppSpdlog/inst/include/spdlog/sinks/systemd_sink.h0000644000176200001440000001141014550234366022240 0ustar liggesusers// Copyright(c) 2019 ZVYAGIN.Alexander@gmail.com // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include #include #include #include #ifndef SD_JOURNAL_SUPPRESS_LOCATION #define SD_JOURNAL_SUPPRESS_LOCATION #endif #include namespace spdlog { namespace sinks { /** * Sink that write to systemd journal using the `sd_journal_send()` library call. */ template class systemd_sink : public base_sink { public: systemd_sink(std::string ident = "", bool enable_formatting = false) : ident_{std::move(ident)}, enable_formatting_{enable_formatting}, syslog_levels_{{/* spdlog::level::trace */ LOG_DEBUG, /* spdlog::level::debug */ LOG_DEBUG, /* spdlog::level::info */ LOG_INFO, /* spdlog::level::warn */ LOG_WARNING, /* spdlog::level::err */ LOG_ERR, /* spdlog::level::critical */ LOG_CRIT, /* spdlog::level::off */ LOG_INFO}} {} ~systemd_sink() override {} systemd_sink(const systemd_sink &) = delete; systemd_sink &operator=(const systemd_sink &) = delete; protected: const std::string ident_; bool enable_formatting_ = false; using levels_array = std::array; levels_array syslog_levels_; void sink_it_(const details::log_msg &msg) override { int err; string_view_t payload; memory_buf_t formatted; if (enable_formatting_) { base_sink::formatter_->format(msg, formatted); payload = string_view_t(formatted.data(), formatted.size()); } else { payload = msg.payload; } size_t length = payload.size(); // limit to max int if (length > static_cast(std::numeric_limits::max())) { length = static_cast(std::numeric_limits::max()); } const string_view_t syslog_identifier = ident_.empty() ? msg.logger_name : ident_; // Do not send source location if not available if (msg.source.empty()) { // Note: function call inside '()' to avoid macro expansion err = (sd_journal_send)("MESSAGE=%.*s", static_cast(length), payload.data(), "PRIORITY=%d", syslog_level(msg.level), #ifndef SPDLOG_NO_THREAD_ID "TID=%zu", msg.thread_id, #endif "SYSLOG_IDENTIFIER=%.*s", static_cast(syslog_identifier.size()), syslog_identifier.data(), nullptr); } else { err = (sd_journal_send)("MESSAGE=%.*s", static_cast(length), payload.data(), "PRIORITY=%d", syslog_level(msg.level), #ifndef SPDLOG_NO_THREAD_ID "TID=%zu", msg.thread_id, #endif "SYSLOG_IDENTIFIER=%.*s", static_cast(syslog_identifier.size()), syslog_identifier.data(), "CODE_FILE=%s", msg.source.filename, "CODE_LINE=%d", msg.source.line, "CODE_FUNC=%s", msg.source.funcname, nullptr); } if (err) { throw_spdlog_ex("Failed writing to systemd", errno); } } int syslog_level(level::level_enum l) { return syslog_levels_.at(static_cast(l)); } void flush_() override {} }; using systemd_sink_mt = systemd_sink; using systemd_sink_st = systemd_sink; } // namespace sinks // Create and register a syslog logger template inline std::shared_ptr systemd_logger_mt(const std::string &logger_name, const std::string &ident = "", bool enable_formatting = false) { return Factory::template create(logger_name, ident, enable_formatting); } template inline std::shared_ptr systemd_logger_st(const std::string &logger_name, const std::string &ident = "", bool enable_formatting = false) { return Factory::template create(logger_name, ident, enable_formatting); } } // namespace spdlog RcppSpdlog/inst/include/spdlog/fwd.h0000644000176200001440000000046114550234366017161 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once namespace spdlog { class logger; class formatter; namespace sinks { class sink; } namespace level { enum level_enum : int; } } // namespace spdlog RcppSpdlog/inst/include/spdlog/spdlog.h0000644000176200001440000002735014612604314017670 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) // spdlog main header file. // see example.cpp for usage example #ifndef SPDLOG_H #define SPDLOG_H #pragma once #include #include #include #include #include #include #include #include #include #if __cplusplus >= 201703L // C++17 #include #endif namespace spdlog { using default_factory = synchronous_factory; // Create and register a logger with a templated sink type // The logger's level, formatter and flush level will be set according the // global settings. // // Example: // spdlog::create("logger_name", "dailylog_filename", 11, 59); template inline std::shared_ptr create(std::string logger_name, SinkArgs &&...sink_args) { return default_factory::create(std::move(logger_name), std::forward(sink_args)...); } // Initialize and register a logger, // formatter and flush level will be set according the global settings. // // Useful for initializing manually created loggers with the global settings. // // Example: // auto mylogger = std::make_shared("mylogger", ...); // spdlog::initialize_logger(mylogger); SPDLOG_API void initialize_logger(std::shared_ptr logger); // Return an existing logger or nullptr if a logger with such name doesn't // exist. // example: spdlog::get("my_logger")->info("hello {}", "world"); SPDLOG_API std::shared_ptr get(const std::string &name); #if __cplusplus >= 201703L // C++17 SPDLOG_API std::shared_ptr get(std::string_view name); SPDLOG_API std::shared_ptr get(const char *name); #endif // Set global formatter. Each sink in each logger will get a clone of this object SPDLOG_API void set_formatter(std::unique_ptr formatter); // Set global format string. // example: spdlog::set_pattern("%Y-%m-%d %H:%M:%S.%e %l : %v"); SPDLOG_API void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local); // enable global backtrace support SPDLOG_API void enable_backtrace(size_t n_messages); // disable global backtrace support SPDLOG_API void disable_backtrace(); // call dump backtrace on default logger SPDLOG_API void dump_backtrace(); // Get global logging level SPDLOG_API level::level_enum get_level(); // Set global logging level SPDLOG_API void set_level(level::level_enum log_level); // Determine whether the default logger should log messages with a certain level SPDLOG_API bool should_log(level::level_enum lvl); // Set global flush level SPDLOG_API void flush_on(level::level_enum log_level); // Start/Restart a periodic flusher thread // Warning: Use only if all your loggers are thread safe! template inline void flush_every(std::chrono::duration interval) { details::registry::instance().flush_every(interval); } // Set global error handler SPDLOG_API void set_error_handler(void (*handler)(const std::string &msg)); // Register the given logger with the given name SPDLOG_API void register_logger(std::shared_ptr logger); // Apply a user defined function on all registered loggers // Example: // spdlog::apply_all([&](std::shared_ptr l) {l->flush();}); SPDLOG_API void apply_all(const std::function)> &fun); // Drop the reference to the given logger SPDLOG_API void drop(const std::string &name); // Drop all references from the registry SPDLOG_API void drop_all(); // stop any running threads started by spdlog and clean registry loggers SPDLOG_API void shutdown(); // Automatic registration of loggers when using spdlog::create() or spdlog::create_async SPDLOG_API void set_automatic_registration(bool automatic_registration); // API for using default logger (stdout_color_mt), // e.g: spdlog::info("Message {}", 1); // // The default logger object can be accessed using the spdlog::default_logger(): // For example, to add another sink to it: // spdlog::default_logger()->sinks().push_back(some_sink); // // The default logger can replaced using spdlog::set_default_logger(new_logger). // For example, to replace it with a file logger. // // IMPORTANT: // The default API is thread safe (for _mt loggers), but: // set_default_logger() *should not* be used concurrently with the default API. // e.g do not call set_default_logger() from one thread while calling spdlog::info() from another. SPDLOG_API std::shared_ptr default_logger(); SPDLOG_API spdlog::logger *default_logger_raw(); SPDLOG_API void set_default_logger(std::shared_ptr default_logger); // Initialize logger level based on environment configs. // // Useful for applying SPDLOG_LEVEL to manually created loggers. // // Example: // auto mylogger = std::make_shared("mylogger", ...); // spdlog::apply_logger_env_levels(mylogger); SPDLOG_API void apply_logger_env_levels(std::shared_ptr logger); template inline void log(source_loc source, level::level_enum lvl, format_string_t fmt, Args &&...args) { default_logger_raw()->log(source, lvl, fmt, std::forward(args)...); } template inline void log(level::level_enum lvl, format_string_t fmt, Args &&...args) { default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward(args)...); } template inline void trace(format_string_t fmt, Args &&...args) { default_logger_raw()->trace(fmt, std::forward(args)...); } template inline void debug(format_string_t fmt, Args &&...args) { default_logger_raw()->debug(fmt, std::forward(args)...); } template inline void info(format_string_t fmt, Args &&...args) { default_logger_raw()->info(fmt, std::forward(args)...); } template inline void warn(format_string_t fmt, Args &&...args) { default_logger_raw()->warn(fmt, std::forward(args)...); } template inline void error(format_string_t fmt, Args &&...args) { default_logger_raw()->error(fmt, std::forward(args)...); } template inline void critical(format_string_t fmt, Args &&...args) { default_logger_raw()->critical(fmt, std::forward(args)...); } template inline void log(source_loc source, level::level_enum lvl, const T &msg) { default_logger_raw()->log(source, lvl, msg); } template inline void log(level::level_enum lvl, const T &msg) { default_logger_raw()->log(lvl, msg); } #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT template inline void log(source_loc source, level::level_enum lvl, wformat_string_t fmt, Args &&...args) { default_logger_raw()->log(source, lvl, fmt, std::forward(args)...); } template inline void log(level::level_enum lvl, wformat_string_t fmt, Args &&...args) { default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward(args)...); } template inline void trace(wformat_string_t fmt, Args &&...args) { default_logger_raw()->trace(fmt, std::forward(args)...); } template inline void debug(wformat_string_t fmt, Args &&...args) { default_logger_raw()->debug(fmt, std::forward(args)...); } template inline void info(wformat_string_t fmt, Args &&...args) { default_logger_raw()->info(fmt, std::forward(args)...); } template inline void warn(wformat_string_t fmt, Args &&...args) { default_logger_raw()->warn(fmt, std::forward(args)...); } template inline void error(wformat_string_t fmt, Args &&...args) { default_logger_raw()->error(fmt, std::forward(args)...); } template inline void critical(wformat_string_t fmt, Args &&...args) { default_logger_raw()->critical(fmt, std::forward(args)...); } #endif template inline void trace(const T &msg) { default_logger_raw()->trace(msg); } template inline void debug(const T &msg) { default_logger_raw()->debug(msg); } template inline void info(const T &msg) { default_logger_raw()->info(msg); } template inline void warn(const T &msg) { default_logger_raw()->warn(msg); } template inline void error(const T &msg) { default_logger_raw()->error(msg); } template inline void critical(const T &msg) { default_logger_raw()->critical(msg); } } // namespace spdlog // // enable/disable log calls at compile time according to global level. // // define SPDLOG_ACTIVE_LEVEL to one of those (before including spdlog.h): // SPDLOG_LEVEL_TRACE, // SPDLOG_LEVEL_DEBUG, // SPDLOG_LEVEL_INFO, // SPDLOG_LEVEL_WARN, // SPDLOG_LEVEL_ERROR, // SPDLOG_LEVEL_CRITICAL, // SPDLOG_LEVEL_OFF // #ifndef SPDLOG_NO_SOURCE_LOC #define SPDLOG_LOGGER_CALL(logger, level, ...) \ (logger)->log(spdlog::source_loc{__FILE__, __LINE__, SPDLOG_FUNCTION}, level, __VA_ARGS__) #else #define SPDLOG_LOGGER_CALL(logger, level, ...) \ (logger)->log(spdlog::source_loc{}, level, __VA_ARGS__) #endif #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_TRACE #define SPDLOG_LOGGER_TRACE(logger, ...) \ SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__) #define SPDLOG_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), __VA_ARGS__) #else #define SPDLOG_LOGGER_TRACE(logger, ...) (void)0 #define SPDLOG_TRACE(...) (void)0 #endif #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_DEBUG #define SPDLOG_LOGGER_DEBUG(logger, ...) \ SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__) #define SPDLOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), __VA_ARGS__) #else #define SPDLOG_LOGGER_DEBUG(logger, ...) (void)0 #define SPDLOG_DEBUG(...) (void)0 #endif #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_INFO #define SPDLOG_LOGGER_INFO(logger, ...) \ SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__) #define SPDLOG_INFO(...) SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), __VA_ARGS__) #else #define SPDLOG_LOGGER_INFO(logger, ...) (void)0 #define SPDLOG_INFO(...) (void)0 #endif #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_WARN #define SPDLOG_LOGGER_WARN(logger, ...) \ SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__) #define SPDLOG_WARN(...) SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), __VA_ARGS__) #else #define SPDLOG_LOGGER_WARN(logger, ...) (void)0 #define SPDLOG_WARN(...) (void)0 #endif #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_ERROR #define SPDLOG_LOGGER_ERROR(logger, ...) \ SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__) #define SPDLOG_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), __VA_ARGS__) #else #define SPDLOG_LOGGER_ERROR(logger, ...) (void)0 #define SPDLOG_ERROR(...) (void)0 #endif #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_CRITICAL #define SPDLOG_LOGGER_CRITICAL(logger, ...) \ SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__) #define SPDLOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), __VA_ARGS__) #else #define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0 #define SPDLOG_CRITICAL(...) (void)0 #endif #ifdef SPDLOG_HEADER_ONLY #include "spdlog-inl.h" #endif #endif // SPDLOG_H RcppSpdlog/inst/include/spdlog/common.h0000644000176200001440000003161214612604314017664 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once #include #include #include #include #include #include #include #include #include #include #include #ifdef SPDLOG_USE_STD_FORMAT #include #if __cpp_lib_format >= 202207L #include #else #include #endif #endif #ifdef SPDLOG_COMPILED_LIB #undef SPDLOG_HEADER_ONLY #if defined(SPDLOG_SHARED_LIB) #if defined(_WIN32) #ifdef spdlog_EXPORTS #define SPDLOG_API __declspec(dllexport) #else // !spdlog_EXPORTS #define SPDLOG_API __declspec(dllimport) #endif #else // !defined(_WIN32) #define SPDLOG_API __attribute__((visibility("default"))) #endif #else // !defined(SPDLOG_SHARED_LIB) #define SPDLOG_API #endif #define SPDLOG_INLINE #else // !defined(SPDLOG_COMPILED_LIB) #define SPDLOG_API #define SPDLOG_HEADER_ONLY #define SPDLOG_INLINE inline #endif // #ifdef SPDLOG_COMPILED_LIB #include #if !defined(SPDLOG_USE_STD_FORMAT) && \ FMT_VERSION >= 80000 // backward compatibility with fmt versions older than 8 #define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string) #define SPDLOG_FMT_STRING(format_string) FMT_STRING(format_string) #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) #include #endif #else #define SPDLOG_FMT_RUNTIME(format_string) format_string #define SPDLOG_FMT_STRING(format_string) format_string #endif // visual studio up to 2013 does not support noexcept nor constexpr #if defined(_MSC_VER) && (_MSC_VER < 1900) #define SPDLOG_NOEXCEPT _NOEXCEPT #define SPDLOG_CONSTEXPR #else #define SPDLOG_NOEXCEPT noexcept #define SPDLOG_CONSTEXPR constexpr #endif // If building with std::format, can just use constexpr, otherwise if building with fmt // SPDLOG_CONSTEXPR_FUNC needs to be set the same as FMT_CONSTEXPR to avoid situations where // a constexpr function in spdlog could end up calling a non-constexpr function in fmt // depending on the compiler // If fmt determines it can't use constexpr, we should inline the function instead #ifdef SPDLOG_USE_STD_FORMAT #define SPDLOG_CONSTEXPR_FUNC constexpr #else // Being built with fmt #if FMT_USE_CONSTEXPR #define SPDLOG_CONSTEXPR_FUNC FMT_CONSTEXPR #else #define SPDLOG_CONSTEXPR_FUNC inline #endif #endif #if defined(__GNUC__) || defined(__clang__) #define SPDLOG_DEPRECATED __attribute__((deprecated)) #elif defined(_MSC_VER) #define SPDLOG_DEPRECATED __declspec(deprecated) #else #define SPDLOG_DEPRECATED #endif // disable thread local on msvc 2013 #ifndef SPDLOG_NO_TLS #if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt) #define SPDLOG_NO_TLS 1 #endif #endif #ifndef SPDLOG_FUNCTION #define SPDLOG_FUNCTION static_cast(__FUNCTION__) #endif #ifdef SPDLOG_NO_EXCEPTIONS #define SPDLOG_TRY #define SPDLOG_THROW(ex) \ do { \ printf("spdlog fatal error: %s\n", ex.what()); \ std::abort(); \ } while (0) #define SPDLOG_CATCH_STD #else #define SPDLOG_TRY try #define SPDLOG_THROW(ex) throw(ex) #define SPDLOG_CATCH_STD \ catch (const std::exception &) { \ } #endif namespace spdlog { class formatter; namespace sinks { class sink; } #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) using filename_t = std::wstring; // allow macro expansion to occur in SPDLOG_FILENAME_T #define SPDLOG_FILENAME_T_INNER(s) L##s #define SPDLOG_FILENAME_T(s) SPDLOG_FILENAME_T_INNER(s) #else using filename_t = std::string; #define SPDLOG_FILENAME_T(s) s #endif using log_clock = std::chrono::system_clock; using sink_ptr = std::shared_ptr; using sinks_init_list = std::initializer_list; using err_handler = std::function; #ifdef SPDLOG_USE_STD_FORMAT namespace fmt_lib = std; using string_view_t = std::string_view; using memory_buf_t = std::string; template #if __cpp_lib_format >= 202207L using format_string_t = std::format_string; #else using format_string_t = std::string_view; #endif template struct is_convertible_to_basic_format_string : std::integral_constant>::value> {}; #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) using wstring_view_t = std::wstring_view; using wmemory_buf_t = std::wstring; template #if __cpp_lib_format >= 202207L using wformat_string_t = std::wformat_string; #else using wformat_string_t = std::wstring_view; #endif #endif #define SPDLOG_BUF_TO_STRING(x) x #else // use fmt lib instead of std::format namespace fmt_lib = fmt; using string_view_t = fmt::basic_string_view; using memory_buf_t = fmt::basic_memory_buffer; template using format_string_t = fmt::format_string; template using remove_cvref_t = typename std::remove_cv::type>::type; template #if FMT_VERSION >= 90101 using fmt_runtime_string = fmt::runtime_format_string; #else using fmt_runtime_string = fmt::basic_runtime; #endif // clang doesn't like SFINAE disabled constructor in std::is_convertible<> so have to repeat the // condition from basic_format_string here, in addition, fmt::basic_runtime is only // convertible to basic_format_string but not basic_string_view template struct is_convertible_to_basic_format_string : std::integral_constant>::value || std::is_same, fmt_runtime_string>::value> { }; #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) using wstring_view_t = fmt::basic_string_view; using wmemory_buf_t = fmt::basic_memory_buffer; template using wformat_string_t = fmt::wformat_string; #endif #define SPDLOG_BUF_TO_STRING(x) fmt::to_string(x) #endif #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifndef _WIN32 #error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows #endif // _WIN32 #endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT template struct is_convertible_to_any_format_string : std::integral_constant::value || is_convertible_to_basic_format_string::value> {}; #if defined(SPDLOG_NO_ATOMIC_LEVELS) using level_t = details::null_atomic_int; #else using level_t = std::atomic; #endif #define SPDLOG_LEVEL_TRACE 0 #define SPDLOG_LEVEL_DEBUG 1 #define SPDLOG_LEVEL_INFO 2 #define SPDLOG_LEVEL_WARN 3 #define SPDLOG_LEVEL_ERROR 4 #define SPDLOG_LEVEL_CRITICAL 5 #define SPDLOG_LEVEL_OFF 6 #if !defined(SPDLOG_ACTIVE_LEVEL) #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO #endif // Log level enum namespace level { enum level_enum : int { trace = SPDLOG_LEVEL_TRACE, debug = SPDLOG_LEVEL_DEBUG, info = SPDLOG_LEVEL_INFO, warn = SPDLOG_LEVEL_WARN, err = SPDLOG_LEVEL_ERROR, critical = SPDLOG_LEVEL_CRITICAL, off = SPDLOG_LEVEL_OFF, n_levels }; #define SPDLOG_LEVEL_NAME_TRACE spdlog::string_view_t("trace", 5) #define SPDLOG_LEVEL_NAME_DEBUG spdlog::string_view_t("debug", 5) #define SPDLOG_LEVEL_NAME_INFO spdlog::string_view_t("info", 4) #define SPDLOG_LEVEL_NAME_WARNING spdlog::string_view_t("warning", 7) #define SPDLOG_LEVEL_NAME_ERROR spdlog::string_view_t("error", 5) #define SPDLOG_LEVEL_NAME_CRITICAL spdlog::string_view_t("critical", 8) #define SPDLOG_LEVEL_NAME_OFF spdlog::string_view_t("off", 3) #if !defined(SPDLOG_LEVEL_NAMES) #define SPDLOG_LEVEL_NAMES \ { \ SPDLOG_LEVEL_NAME_TRACE, SPDLOG_LEVEL_NAME_DEBUG, SPDLOG_LEVEL_NAME_INFO, \ SPDLOG_LEVEL_NAME_WARNING, SPDLOG_LEVEL_NAME_ERROR, SPDLOG_LEVEL_NAME_CRITICAL, \ SPDLOG_LEVEL_NAME_OFF \ } #endif #if !defined(SPDLOG_SHORT_LEVEL_NAMES) #define SPDLOG_SHORT_LEVEL_NAMES \ { "T", "D", "I", "W", "E", "C", "O" } #endif SPDLOG_API const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT; SPDLOG_API const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT; SPDLOG_API spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT; } // namespace level // // Color mode used by sinks with color support. // enum class color_mode { always, automatic, never }; // // Pattern time - specific time getting to use for pattern_formatter. // local time by default // enum class pattern_time_type { local, // log localtime utc // log utc }; // // Log exception // class SPDLOG_API spdlog_ex : public std::exception { public: explicit spdlog_ex(std::string msg); spdlog_ex(const std::string &msg, int last_errno); const char *what() const SPDLOG_NOEXCEPT override; private: std::string msg_; }; [[noreturn]] SPDLOG_API void throw_spdlog_ex(const std::string &msg, int last_errno); [[noreturn]] SPDLOG_API void throw_spdlog_ex(std::string msg); struct source_loc { SPDLOG_CONSTEXPR source_loc() = default; SPDLOG_CONSTEXPR source_loc(const char *filename_in, int line_in, const char *funcname_in) : filename{filename_in}, line{line_in}, funcname{funcname_in} {} SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT { return line <= 0; } const char *filename{nullptr}; int line{0}; const char *funcname{nullptr}; }; struct file_event_handlers { file_event_handlers() : before_open(nullptr), after_open(nullptr), before_close(nullptr), after_close(nullptr) {} std::function before_open; std::function after_open; std::function before_close; std::function after_close; }; namespace details { // to_string_view SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(const memory_buf_t &buf) SPDLOG_NOEXCEPT { return spdlog::string_view_t{buf.data(), buf.size()}; } SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(spdlog::string_view_t str) SPDLOG_NOEXCEPT { return str; } #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(const wmemory_buf_t &buf) SPDLOG_NOEXCEPT { return spdlog::wstring_view_t{buf.data(), buf.size()}; } SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(spdlog::wstring_view_t str) SPDLOG_NOEXCEPT { return str; } #endif #ifndef SPDLOG_USE_STD_FORMAT template inline fmt::basic_string_view to_string_view(fmt::basic_format_string fmt) { return fmt; } #elif __cpp_lib_format >= 202207L template SPDLOG_CONSTEXPR_FUNC std::basic_string_view to_string_view( std::basic_format_string fmt) SPDLOG_NOEXCEPT { return fmt.get(); } #endif // make_unique support for pre c++14 #if __cplusplus >= 201402L // C++14 and beyond using std::enable_if_t; using std::make_unique; #else template using enable_if_t = typename std::enable_if::type; template std::unique_ptr make_unique(Args &&...args) { static_assert(!std::is_array::value, "arrays not supported"); return std::unique_ptr(new T(std::forward(args)...)); } #endif // to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324) template ::value, int> = 0> constexpr T conditional_static_cast(U value) { return static_cast(value); } template ::value, int> = 0> constexpr T conditional_static_cast(U value) { return value; } } // namespace details } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY #include "common-inl.h" #endif RcppSpdlog/inst/include/spdlog/async.h0000644000176200001440000000766514550234366017533 0ustar liggesusers// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once // // Async logging using global thread pool // All loggers created here share same global thread pool. // Each log message is pushed to a queue along with a shared pointer to the // logger. // If a logger deleted while having pending messages in the queue, it's actual // destruction will defer // until all its messages are processed by the thread pool. // This is because each message in the queue holds a shared_ptr to the // originating logger. #include #include #include #include #include #include namespace spdlog { namespace details { static const size_t default_async_q_size = 8192; } // async logger factory - creates async loggers backed with thread pool. // if a global thread pool doesn't already exist, create it with default queue // size of 8192 items and single thread. template struct async_factory_impl { template static std::shared_ptr create(std::string logger_name, SinkArgs &&...args) { auto ®istry_inst = details::registry::instance(); // create global thread pool if not already exists.. auto &mutex = registry_inst.tp_mutex(); std::lock_guard tp_lock(mutex); auto tp = registry_inst.get_tp(); if (tp == nullptr) { tp = std::make_shared(details::default_async_q_size, 1U); registry_inst.set_tp(tp); } auto sink = std::make_shared(std::forward(args)...); auto new_logger = std::make_shared(std::move(logger_name), std::move(sink), std::move(tp), OverflowPolicy); registry_inst.initialize_logger(new_logger); return new_logger; } }; using async_factory = async_factory_impl; using async_factory_nonblock = async_factory_impl; template inline std::shared_ptr create_async(std::string logger_name, SinkArgs &&...sink_args) { return async_factory::create(std::move(logger_name), std::forward(sink_args)...); } template inline std::shared_ptr create_async_nb(std::string logger_name, SinkArgs &&...sink_args) { return async_factory_nonblock::create(std::move(logger_name), std::forward(sink_args)...); } // set global thread pool. inline void init_thread_pool(size_t q_size, size_t thread_count, std::function on_thread_start, std::function on_thread_stop) { auto tp = std::make_shared(q_size, thread_count, on_thread_start, on_thread_stop); details::registry::instance().set_tp(std::move(tp)); } inline void init_thread_pool(size_t q_size, size_t thread_count, std::function on_thread_start) { init_thread_pool(q_size, thread_count, on_thread_start, [] {}); } inline void init_thread_pool(size_t q_size, size_t thread_count) { init_thread_pool( q_size, thread_count, [] {}, [] {}); } // get the global thread pool. inline std::shared_ptr thread_pool() { return details::registry::instance().get_tp(); } } // namespace spdlog RcppSpdlog/inst/include/spdlog_stopwatch.h0000644000176200001440000000252514361640417020476 0ustar liggesusers// taken from spdlog but removing ftm header to not have spillover // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once //#include #include // Stopwatch support for spdlog (using std::chrono::steady_clock). // Displays elapsed seconds since construction as double. // // Usage: // // spdlog::stopwatch sw; // ... // spdlog::debug("Elapsed: {} seconds", sw); => "Elapsed 0.005116733 seconds" // spdlog::info("Elapsed: {:.6} seconds", sw); => "Elapsed 0.005163 seconds" // // // If other units are needed (e.g. millis instead of double), include "fmt/chrono.h" and use "duration_cast<..>(sw.elapsed())": // // #include //.. // using std::chrono::duration_cast; // using std::chrono::milliseconds; // spdlog::info("Elapsed {}", duration_cast(sw.elapsed())); => "Elapsed 5ms" namespace spdlog { class stopwatch { using clock = std::chrono::steady_clock; std::chrono::time_point start_tp_; public: stopwatch() : start_tp_{clock::now()} {} std::chrono::duration elapsed() const { return std::chrono::duration(clock::now() - start_tp_); } void reset() { start_tp_ = clock::now(); } }; } // namespace spdlog RcppSpdlog/inst/include/RcppSpdlog_RcppExports.h0000644000176200001440000004013114442072323021526 0ustar liggesusers// Generated by using Rcpp::compileAttributes() -> do not edit by hand // Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 #ifndef RCPP_RcppSpdlog_RCPPEXPORTS_H_GEN_ #define RCPP_RcppSpdlog_RCPPEXPORTS_H_GEN_ #include "RcppSpdlog_types.h" #include namespace RcppSpdlog { using namespace Rcpp; namespace { void validateSignature(const char* sig) { Rcpp::Function require = Rcpp::Environment::base_env()["require"]; require("RcppSpdlog", Rcpp::Named("quietly") = true); typedef int(*Ptr_validate)(const char*); static Ptr_validate p_validate = (Ptr_validate) R_GetCCallable("RcppSpdlog", "_RcppSpdlog_RcppExport_validate"); if (!p_validate(sig)) { throw Rcpp::function_not_exported( "C++ function with signature '" + std::string(sig) + "' not found in RcppSpdlog"); } } } inline std::string formatter(const std::string s, std::vector v) { typedef SEXP(*Ptr_formatter)(SEXP,SEXP); static Ptr_formatter p_formatter = NULL; if (p_formatter == NULL) { validateSignature("std::string(*formatter)(const std::string,std::vector)"); p_formatter = (Ptr_formatter)R_GetCCallable("RcppSpdlog", "_RcppSpdlog_formatter"); } RObject rcpp_result_gen; { RNGScope RCPP_rngScope_gen; rcpp_result_gen = p_formatter(Shield(Rcpp::wrap(s)), Shield(Rcpp::wrap(v))); } if (rcpp_result_gen.inherits("interrupted-error")) throw Rcpp::internal::InterruptedException(); if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen)) throw Rcpp::LongjumpException(rcpp_result_gen); if (rcpp_result_gen.inherits("try-error")) throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str()); return Rcpp::as(rcpp_result_gen); } inline void log_setup(const std::string& name = "default", const std::string& level = "warn") { typedef SEXP(*Ptr_log_setup)(SEXP,SEXP); static Ptr_log_setup p_log_setup = NULL; if (p_log_setup == NULL) { validateSignature("void(*log_setup)(const std::string&,const std::string&)"); p_log_setup = (Ptr_log_setup)R_GetCCallable("RcppSpdlog", "_RcppSpdlog_log_setup"); } RObject rcpp_result_gen; { RNGScope RCPP_rngScope_gen; rcpp_result_gen = p_log_setup(Shield(Rcpp::wrap(name)), Shield(Rcpp::wrap(level))); } if (rcpp_result_gen.inherits("interrupted-error")) throw Rcpp::internal::InterruptedException(); if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen)) throw Rcpp::LongjumpException(rcpp_result_gen); if (rcpp_result_gen.inherits("try-error")) throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str()); } inline void log_init(const std::string& level = "warn") { typedef SEXP(*Ptr_log_init)(SEXP); static Ptr_log_init p_log_init = NULL; if (p_log_init == NULL) { validateSignature("void(*log_init)(const std::string&)"); p_log_init = (Ptr_log_init)R_GetCCallable("RcppSpdlog", "_RcppSpdlog_log_init"); } RObject rcpp_result_gen; { RNGScope RCPP_rngScope_gen; rcpp_result_gen = p_log_init(Shield(Rcpp::wrap(level))); } if (rcpp_result_gen.inherits("interrupted-error")) throw Rcpp::internal::InterruptedException(); if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen)) throw Rcpp::LongjumpException(rcpp_result_gen); if (rcpp_result_gen.inherits("try-error")) throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str()); } inline void log_filesetup(const std::string& filename, const std::string& name = "default", const std::string& level = "warn") { typedef SEXP(*Ptr_log_filesetup)(SEXP,SEXP,SEXP); static Ptr_log_filesetup p_log_filesetup = NULL; if (p_log_filesetup == NULL) { validateSignature("void(*log_filesetup)(const std::string&,const std::string&,const std::string&)"); p_log_filesetup = (Ptr_log_filesetup)R_GetCCallable("RcppSpdlog", "_RcppSpdlog_log_filesetup"); } RObject rcpp_result_gen; { RNGScope RCPP_rngScope_gen; rcpp_result_gen = p_log_filesetup(Shield(Rcpp::wrap(filename)), Shield(Rcpp::wrap(name)), Shield(Rcpp::wrap(level))); } if (rcpp_result_gen.inherits("interrupted-error")) throw Rcpp::internal::InterruptedException(); if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen)) throw Rcpp::LongjumpException(rcpp_result_gen); if (rcpp_result_gen.inherits("try-error")) throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str()); } inline void log_drop(const std::string& name) { typedef SEXP(*Ptr_log_drop)(SEXP); static Ptr_log_drop p_log_drop = NULL; if (p_log_drop == NULL) { validateSignature("void(*log_drop)(const std::string&)"); p_log_drop = (Ptr_log_drop)R_GetCCallable("RcppSpdlog", "_RcppSpdlog_log_drop"); } RObject rcpp_result_gen; { RNGScope RCPP_rngScope_gen; rcpp_result_gen = p_log_drop(Shield(Rcpp::wrap(name))); } if (rcpp_result_gen.inherits("interrupted-error")) throw Rcpp::internal::InterruptedException(); if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen)) throw Rcpp::LongjumpException(rcpp_result_gen); if (rcpp_result_gen.inherits("try-error")) throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str()); } inline void log_set_pattern(const std::string& s) { typedef SEXP(*Ptr_log_set_pattern)(SEXP); static Ptr_log_set_pattern p_log_set_pattern = NULL; if (p_log_set_pattern == NULL) { validateSignature("void(*log_set_pattern)(const std::string&)"); p_log_set_pattern = (Ptr_log_set_pattern)R_GetCCallable("RcppSpdlog", "_RcppSpdlog_log_set_pattern"); } RObject rcpp_result_gen; { RNGScope RCPP_rngScope_gen; rcpp_result_gen = p_log_set_pattern(Shield(Rcpp::wrap(s))); } if (rcpp_result_gen.inherits("interrupted-error")) throw Rcpp::internal::InterruptedException(); if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen)) throw Rcpp::LongjumpException(rcpp_result_gen); if (rcpp_result_gen.inherits("try-error")) throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str()); } inline void log_set_level(const std::string& s) { typedef SEXP(*Ptr_log_set_level)(SEXP); static Ptr_log_set_level p_log_set_level = NULL; if (p_log_set_level == NULL) { validateSignature("void(*log_set_level)(const std::string&)"); p_log_set_level = (Ptr_log_set_level)R_GetCCallable("RcppSpdlog", "_RcppSpdlog_log_set_level"); } RObject rcpp_result_gen; { RNGScope RCPP_rngScope_gen; rcpp_result_gen = p_log_set_level(Shield(Rcpp::wrap(s))); } if (rcpp_result_gen.inherits("interrupted-error")) throw Rcpp::internal::InterruptedException(); if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen)) throw Rcpp::LongjumpException(rcpp_result_gen); if (rcpp_result_gen.inherits("try-error")) throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str()); } inline void log_trace(const std::string& s) { typedef SEXP(*Ptr_log_trace)(SEXP); static Ptr_log_trace p_log_trace = NULL; if (p_log_trace == NULL) { validateSignature("void(*log_trace)(const std::string&)"); p_log_trace = (Ptr_log_trace)R_GetCCallable("RcppSpdlog", "_RcppSpdlog_log_trace"); } RObject rcpp_result_gen; { RNGScope RCPP_rngScope_gen; rcpp_result_gen = p_log_trace(Shield(Rcpp::wrap(s))); } if (rcpp_result_gen.inherits("interrupted-error")) throw Rcpp::internal::InterruptedException(); if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen)) throw Rcpp::LongjumpException(rcpp_result_gen); if (rcpp_result_gen.inherits("try-error")) throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str()); } inline void log_debug(const std::string& s) { typedef SEXP(*Ptr_log_debug)(SEXP); static Ptr_log_debug p_log_debug = NULL; if (p_log_debug == NULL) { validateSignature("void(*log_debug)(const std::string&)"); p_log_debug = (Ptr_log_debug)R_GetCCallable("RcppSpdlog", "_RcppSpdlog_log_debug"); } RObject rcpp_result_gen; { RNGScope RCPP_rngScope_gen; rcpp_result_gen = p_log_debug(Shield(Rcpp::wrap(s))); } if (rcpp_result_gen.inherits("interrupted-error")) throw Rcpp::internal::InterruptedException(); if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen)) throw Rcpp::LongjumpException(rcpp_result_gen); if (rcpp_result_gen.inherits("try-error")) throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str()); } inline void log_info(const std::string& s) { typedef SEXP(*Ptr_log_info)(SEXP); static Ptr_log_info p_log_info = NULL; if (p_log_info == NULL) { validateSignature("void(*log_info)(const std::string&)"); p_log_info = (Ptr_log_info)R_GetCCallable("RcppSpdlog", "_RcppSpdlog_log_info"); } RObject rcpp_result_gen; { RNGScope RCPP_rngScope_gen; rcpp_result_gen = p_log_info(Shield(Rcpp::wrap(s))); } if (rcpp_result_gen.inherits("interrupted-error")) throw Rcpp::internal::InterruptedException(); if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen)) throw Rcpp::LongjumpException(rcpp_result_gen); if (rcpp_result_gen.inherits("try-error")) throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str()); } inline void log_warn(const std::string& s) { typedef SEXP(*Ptr_log_warn)(SEXP); static Ptr_log_warn p_log_warn = NULL; if (p_log_warn == NULL) { validateSignature("void(*log_warn)(const std::string&)"); p_log_warn = (Ptr_log_warn)R_GetCCallable("RcppSpdlog", "_RcppSpdlog_log_warn"); } RObject rcpp_result_gen; { RNGScope RCPP_rngScope_gen; rcpp_result_gen = p_log_warn(Shield(Rcpp::wrap(s))); } if (rcpp_result_gen.inherits("interrupted-error")) throw Rcpp::internal::InterruptedException(); if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen)) throw Rcpp::LongjumpException(rcpp_result_gen); if (rcpp_result_gen.inherits("try-error")) throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str()); } inline void log_error(const std::string& s) { typedef SEXP(*Ptr_log_error)(SEXP); static Ptr_log_error p_log_error = NULL; if (p_log_error == NULL) { validateSignature("void(*log_error)(const std::string&)"); p_log_error = (Ptr_log_error)R_GetCCallable("RcppSpdlog", "_RcppSpdlog_log_error"); } RObject rcpp_result_gen; { RNGScope RCPP_rngScope_gen; rcpp_result_gen = p_log_error(Shield(Rcpp::wrap(s))); } if (rcpp_result_gen.inherits("interrupted-error")) throw Rcpp::internal::InterruptedException(); if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen)) throw Rcpp::LongjumpException(rcpp_result_gen); if (rcpp_result_gen.inherits("try-error")) throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str()); } inline void log_critical(const std::string& s) { typedef SEXP(*Ptr_log_critical)(SEXP); static Ptr_log_critical p_log_critical = NULL; if (p_log_critical == NULL) { validateSignature("void(*log_critical)(const std::string&)"); p_log_critical = (Ptr_log_critical)R_GetCCallable("RcppSpdlog", "_RcppSpdlog_log_critical"); } RObject rcpp_result_gen; { RNGScope RCPP_rngScope_gen; rcpp_result_gen = p_log_critical(Shield(Rcpp::wrap(s))); } if (rcpp_result_gen.inherits("interrupted-error")) throw Rcpp::internal::InterruptedException(); if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen)) throw Rcpp::LongjumpException(rcpp_result_gen); if (rcpp_result_gen.inherits("try-error")) throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str()); } inline Rcpp::XPtr get_stopwatch() { typedef SEXP(*Ptr_get_stopwatch)(); static Ptr_get_stopwatch p_get_stopwatch = NULL; if (p_get_stopwatch == NULL) { validateSignature("Rcpp::XPtr(*get_stopwatch)()"); p_get_stopwatch = (Ptr_get_stopwatch)R_GetCCallable("RcppSpdlog", "_RcppSpdlog_get_stopwatch"); } RObject rcpp_result_gen; { RNGScope RCPP_rngScope_gen; rcpp_result_gen = p_get_stopwatch(); } if (rcpp_result_gen.inherits("interrupted-error")) throw Rcpp::internal::InterruptedException(); if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen)) throw Rcpp::LongjumpException(rcpp_result_gen); if (rcpp_result_gen.inherits("try-error")) throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str()); return Rcpp::as >(rcpp_result_gen); } inline double elapsed_stopwatch(Rcpp::XPtr sw) { typedef SEXP(*Ptr_elapsed_stopwatch)(SEXP); static Ptr_elapsed_stopwatch p_elapsed_stopwatch = NULL; if (p_elapsed_stopwatch == NULL) { validateSignature("double(*elapsed_stopwatch)(Rcpp::XPtr)"); p_elapsed_stopwatch = (Ptr_elapsed_stopwatch)R_GetCCallable("RcppSpdlog", "_RcppSpdlog_elapsed_stopwatch"); } RObject rcpp_result_gen; { RNGScope RCPP_rngScope_gen; rcpp_result_gen = p_elapsed_stopwatch(Shield(Rcpp::wrap(sw))); } if (rcpp_result_gen.inherits("interrupted-error")) throw Rcpp::internal::InterruptedException(); if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen)) throw Rcpp::LongjumpException(rcpp_result_gen); if (rcpp_result_gen.inherits("try-error")) throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str()); return Rcpp::as(rcpp_result_gen); } inline std::string format_stopwatch(Rcpp::XPtr sw) { typedef SEXP(*Ptr_format_stopwatch)(SEXP); static Ptr_format_stopwatch p_format_stopwatch = NULL; if (p_format_stopwatch == NULL) { validateSignature("std::string(*format_stopwatch)(Rcpp::XPtr)"); p_format_stopwatch = (Ptr_format_stopwatch)R_GetCCallable("RcppSpdlog", "_RcppSpdlog_format_stopwatch"); } RObject rcpp_result_gen; { RNGScope RCPP_rngScope_gen; rcpp_result_gen = p_format_stopwatch(Shield(Rcpp::wrap(sw))); } if (rcpp_result_gen.inherits("interrupted-error")) throw Rcpp::internal::InterruptedException(); if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen)) throw Rcpp::LongjumpException(rcpp_result_gen); if (rcpp_result_gen.inherits("try-error")) throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str()); return Rcpp::as(rcpp_result_gen); } } #endif // RCPP_RcppSpdlog_RCPPEXPORTS_H_GEN_ RcppSpdlog/inst/include/RcppSpdlog0000644000176200001440000000137614350715655016751 0ustar liggesusers// Emacs make this -*- mode: C++; -*- // RcppSpdlog -- wrapping spdlog for use with R // define R_R_H and USING_R so that REprintf is used, then declare ut // (including R.h leads to a side-effect with MinGW so minimal is better) #define R_R_H #define USING_R extern "C" { void REprintf(const char *, ...); void R_FlushConsole(void); } // this define is important to not include another logger pulling in stdout #define SPDLOG_DISABLE_DEFAULT_LOGGER 1 // include main header for spdlog -- others headers needed for extra features #include "spdlog/spdlog.h" // pulls in stopwatch and template #include "RcppSpdlog_types.h" // a custom R sink using Rcpp::Rcout (and Rcpp.h is included too) #include "rcpp_sink.h" RcppSpdlog/inst/include/rcpp_sink.h0000644000176200001440000000315214350715745017104 0ustar liggesusers #ifndef _RcppSpdlog_Rcpp_Sink_h_ #define _RcppSpdlog_Rcpp_Sink_h_ // this define is important to no include another logger pulling in stdout #define SPDLOG_DISABLE_DEFAULT_LOGGER 1 #include "spdlog/spdlog.h" #include "spdlog/sinks/base_sink.h" #include "spdlog/sinks/basic_file_sink.h" #include #include // for Rcpp::Rcout namespace spdlog { namespace sinks { template class r_sink : public base_sink { protected: void sink_it_(const spdlog::details::log_msg& msg) override { // log_msg is a struct containing the log entry info like level, timestamp, thread id etc. // msg.raw contains pre formatted log // If needed (very likely but not mandatory), the sink formats the message before // sending it to its final destination: spdlog::memory_buf_t formatted; spdlog::sinks::base_sink::formatter_->format(msg, formatted); Rcpp::Rcout << fmt::to_string(formatted); } void flush_() override { Rcpp::Rcout << std::flush; } }; using r_sink_mt = r_sink; using r_sink_st = r_sink; } // namespace sinks // factory functions template inline std::shared_ptr r_sink_mt(const std::string &logger_name) { return Factory::template create(logger_name); } template inline std::shared_ptr r_sink_st(const std::string &logger_name) { return Factory::template create(logger_name); } } // namespace spdlog #endif RcppSpdlog/inst/include/RcppSpdlog.h0000644000176200001440000000040614345741570017167 0ustar liggesusers// Generated by using Rcpp::compileAttributes() -> do not edit by hand // Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 #ifndef RCPP_RcppSpdlog_H_GEN_ #define RCPP_RcppSpdlog_H_GEN_ #include "RcppSpdlog_RcppExports.h" #endif // RCPP_RcppSpdlog_H_GEN_ RcppSpdlog/inst/include/RcppSpdlog_types.h0000644000176200001440000000040114361641610020376 0ustar liggesusers #pragma once #include #if defined(RCPPSPDLOG_STOPWATCH_NO_FMT) #include // spdlog::stopwatch without fmt header #else #include // also support standard spdlog stopwatch feature #endif RcppSpdlog/inst/include/spdl.h0000644000176200001440000000612714442073414016053 0ustar liggesusers #pragma once // includes the auto-generated exports for the exported (via a C interface) underlying C++ functions #include // expose fmt::format via the courses in spdlog #include // for convenience define cuter ones in another (shorter) namespace namespace spdl { inline void setup(const std::string& name = "default", const std::string& level = "warn") { RcppSpdlog::log_setup(name, level); } inline void init(const std::string& level = "warn") { RcppSpdlog::log_setup("r", level); } inline void log(const std::string& level = "warn") { RcppSpdlog::log_setup("r", level); } inline void filesetup(const std::string& filename = "default", const std::string& name = "default", const std::string& level = "warn") { RcppSpdlog::log_filesetup(name, level); } inline void drop(const std::string& name) { RcppSpdlog::log_drop(name); } inline void set_pattern(const std::string& s) { RcppSpdlog::log_set_pattern(s); } inline void set_level(const std::string& s) { RcppSpdlog::log_set_level(s); } inline void trace(const std::string& s) { RcppSpdlog::log_trace(s); } inline void debug(const std::string& s) { RcppSpdlog::log_debug(s); } inline void info(const std::string& s) { RcppSpdlog::log_info(s); } inline void warn(const std::string& s) { RcppSpdlog::log_warn(s); } inline void error(const std::string& s) { RcppSpdlog::log_error(s); } inline void critical(const std::string& s) { RcppSpdlog::log_critical(s); } // it is highly unlikely we find a package imposing C++98 as R itself now defaults to C++14 // and many packages have opted into C++11 (or newer) but the check does not hurt #if __cplusplus >= 201103L template inline void trace(const char* fmt, Args&&... args ) { RcppSpdlog::log_trace(fmt::format(fmt, std::forward(args)... ).c_str()); } template inline void debug(const char* fmt, Args&&... args ) { RcppSpdlog::log_debug(fmt::format(fmt, std::forward(args)... ).c_str()); } template inline void info(const char* fmt, Args&&... args ) { RcppSpdlog::log_info(fmt::format(fmt, std::forward(args)... ).c_str()); } template inline void warn(const char* fmt, Args&&... args ) { RcppSpdlog::log_warn(fmt::format(fmt, std::forward(args)... ).c_str()); } template inline void error(const char* fmt, Args&&... args ) { RcppSpdlog::log_error(fmt::format(fmt, std::forward(args)... ).c_str()); } template inline void critical(const char* fmt, Args&&... args ) { RcppSpdlog::log_critical(fmt::format(fmt, std::forward(args)... ).c_str()); } #endif // if C++11 inline Rcpp::XPtr stopwatch() { return RcppSpdlog::get_stopwatch(); } inline double elapsed(Rcpp::XPtr w) { return RcppSpdlog::elapsed_stopwatch(w); } inline std::string format(Rcpp::XPtr w) { return RcppSpdlog::format_stopwatch(w); } } RcppSpdlog/inst/AUTHORS0000644000176200001440000000571213723456567014403 0ustar liggesusersDirk Eddelbuettel wrote the R package 'RcppSpdlog' providing R integration for 'spdlog'. It includes the (header-only) C++ sources for 'spdlog' which in turn includes parts of 'fmt'. See below for details. -- spdlog -------------------------------------------------------- Gabi Melman is the principal author of 'spdlog'. As the upstream source state, there are also many contributors. The list of (100+) contributors (going back to 2014) can obtained from GitHub via https://github.com/gabime/spdlog/graphs/contributors Files: inst/include/spdlog/* Copyright: (c) 2014-2020 Gabi Melman Copyright: (c) 2015-present, Gabi Melman & spdlog contributors License: MIT Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: . The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. . THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -- fmt ----------------------------------------------------------- Victor Zverovic is the principal author of 'fmt'. As the upstream source state, there are also many contributors. The list of (100+) contributors (going back to 2012) can obtained from GitHub via https://github.com/fmtlib/fmt/graphs/contributors Files: inst/include/spdlog/fmt/bundled/* Copyright: (c) 2012 - present, Victor Zverovic Upstream-Name: fmt Source: https://github.com/gabime/spdlog/tree/v1.x/include/spdlog/fmt/bundled -- other files --------------------------------------------------- File: inst/include/spdlog/fmt/bundled/chrono.h Copyright: (c) 2019 Paul Dreik Source: https://github.com/pauldreik/safe_duration_cast File: inst/include/spdlog/fmt/bundled/ranges.h Copyright (c) 2012 - present, Victor Zverovich Copyright (c) 2018 - present, Remotion (Igor Schulz) Source: https://github.com/gabime/spdlog/tree/v1.x/include/spdlog/fmt/bundled/ranges.h File: inst/include/spdlog/sinks/msvc_sink.h Copyright(c) 2016 Alexander Dalshov. Source: https://github.com/gabime/spdlog/tree/v1.x/include/spdlog/sinks/msvc_sink.h File: inst/include/spdlog/sinks/systemd_sink.h Copyright(c) 2019 ZVYAGIN.Alexander@gmail.com Source: https://github.com/gabime/spdlog/tree/v1.x/include/spdlog/sinks/systemd_sink.h RcppSpdlog/inst/NEWS.Rd0000644000176200001440000001060414612606404014353 0ustar liggesusers\name{NEWS} \title{News for Package \pkg{RcppSpdlog}} \newcommand{\ghpr}{\href{https://github.com/eddelbuettel/rcppspdlog/pull/#1}{##1}} \newcommand{\ghit}{\href{https://github.com/eddelbuettel/rcppspdlog/issues/#1}{##1}} \section{Changes in RcppSpdlog version 0.0.17 (2024-04-25)}{ \itemize{ \item Minor continuous integration update \item Upgraded to upstream releases spdlog 1.14.0 } } \section{Changes in RcppSpdlog version 0.0.16 (2024-01-12)}{ \itemize{ \item Upgraded to upstream releases spdlog 1.13.0 } } \section{Changes in RcppSpdlog version 0.0.15 (2023-11-29)}{ \itemize{ \item Correct default package help page slighly \item \code{RcppExports.cpp} has been regenerated under an updated \pkg{Rcpp} to address a format string warning under R-devel } } \section{Changes in RcppSpdlog version 0.0.14 (2023-07-09)}{ \itemize{ \item Added new badge to README.md \item Upgraded to upstream releases spdlog 1.12.0 } } \section{Changes in RcppSpdlog version 0.0.13 (2023-06-17)}{ \itemize{ \item Minor tweak to \code{stopwatch} setup avoids pulling in \pkg{fmt} \item No longer set a C++ compilation standard as the default choices by R are sufficient for the package \item Add convenience wrapper \code{log_init} omitting first argument to \code{log_setup} while preserving the interface from the latter \item Add convenience \code{setup} wrappers \code{init} and \code{log} to API header file \code{spdl.h} } } \section{Changes in RcppSpdlog version 0.0.12 (2023-01-07)}{ \itemize{ \item Addeed support for 'stopwatch' object allowing for simple timing (from both C++ and R) via the logging framework. \item The \sQuote{spdlog} logging pattern is documented via a reference. } } \section{Changes in RcppSpdlog version 0.0.11 (2022-12-13)}{ \itemize{ \item Export the formatter at C level \item Mention package \pkg{spdl} in README.md \item Support simple file-based logger } } \section{Changes in RcppSpdlog version 0.0.10 (2022-11-17)}{ \itemize{ \item Support variadic templates with fmt::format \item Add R formatting helper which converts arguments to character taking advantage of variadic template logger: fmt logging from R \item Expand vignette } } \section{Changes in RcppSpdlog version 0.0.9 (2022-11-04)}{ \itemize{ \item Add both an R and an C++ interface to \code{spdlog} \item Update GitHub Actions to checkout@v3 \item Add a shorter aliased namespace for C++ \item Upgraded to upstream releases spdlog 1.11.0 } } \section{Changes in RcppSpdlog version 0.0.8 (2022-04-04)}{ \itemize{ \item Upgraded to upstream releases spdlog 1.10.0 } } \section{Changes in RcppSpdlog version 0.0.7 (2021-12-05)}{ \itemize{ \item Upgraded to upstream bug fix releases spdlog 1.9.1 and 1.9.2 \item Travis artifacts and badges have been pruned \item Vignette now uses \pkg{simplermarkdown} } } \section{Changes in RcppSpdlog version 0.0.6 (2021-07-21)}{ \itemize{ \item Upgraded to upstream release spdlog 1.9.0 } } \section{Changes in RcppSpdlog version 0.0.5 (2020-12-11)}{ \itemize{ \item Upgraded to upstream release spdlog 1.8.5 (and 1.8.4 and 1.8.3) \item Small enhancements to DESCRIPTION files } } \section{Changes in RcppSpdlog version 0.0.4 (2020-12-11)}{ \itemize{ \item Upgraded to upstream release spdlog 1.8.2 \item Added GitHub Actions CI using \code{run.sh} from \href{https://eddelbuettel.github.io/r-ci/}{r-ci} } } \section{Changes in RcppSpdlog version 0.0.3 (2020-10-23)}{ \itemize{ \item New function \code{setLogLevel} with R accessor in \code{exampleRsink} example \item Updated \code{exampleRsink} to use default logger instance \item Upgraded to upstream release 1.8.1 which contains finalised upstream use to switch to REprintf() if R compilation detected \item Added new vignette with extensive usage examples, added compile-time logging switch example \item A package documentation website was added } } \section{Changes in RcppSpdlog version 0.0.2 (2020-09-17)}{ \itemize{ \item Upgraded to upstream release 1.8.0 \item Switched Travis CI to using BSPM, also test on macOS \item Added 'stopwatch' use to main R sink example } } \section{Changes in RcppSpdlog version 0.0.1 (2020-09-08)}{ \itemize{ \item Initial release with added R/Rcpp logging sink example } } RcppSpdlog/cleanup0000755000176200001440000000030014612606454013705 0ustar liggesusers#!/bin/sh rm -fr src/*.o src/*.so src/symbols.rds RcppSpdlog.Rcheck/ #rm -rf vignettes/auto/ vignettes/*.log vignettes/*.aux vignettes/*.out vignettes/*.tex find . -name \*~ -exec rm {} \;