[med-svn] [spdlog] 01/03: Imported Upstream version 1.7
Michael Crusoe
misterc-guest at moszumanska.debian.org
Sat May 14 18:06:53 UTC 2016
This is an automated email from the git hooks/post-receive script.
misterc-guest pushed a commit to branch master
in repository spdlog.
commit f484e8daacb83c126fa355571b580c751de8869f
Author: Michael R. Crusoe <crusoe at ucdavis.edu>
Date: Sat May 14 10:59:49 2016 -0700
Imported Upstream version 1.7
---
.travis.yml | 2 +-
CMakeLists.txt | 62 +
LICENSE | 45 +-
README.md | 10 +-
bench/Makefile | 16 +-
bench/boost-bench-mt.cpp | 5 +
bench/boost-bench.cpp | 4 +
bench/easylogging-bench-mt.cpp | 5 +
bench/easylogging-bench.cpp | 6 +
bench/g2log-async.cpp | 5 +
bench/glog-bench-mt.cpp | 5 +
bench/glog-bench.cpp | 4 +
bench/run_all.sh | 13 +-
bench/spdlog-async.cpp | 8 +-
bench/spdlog-bench-mt.cpp | 9 +-
bench/spdlog-bench.cpp | 4 +
bench/zf_log-bench-mt.cpp | 56 +
bench/zf_log-bench.cpp | 27 +
cmake/Config.cmake.in | 24 +
example/CMakeLists.txt | 49 +
example/bench.cpp | 33 +-
example/example.cpp | 42 +-
example/example.sln | 22 +
example/example.vcxproj | 90 +
example/utils.h | 27 +-
include/spdlog/async_logger.h | 40 +-
include/spdlog/common.h | 30 +-
include/spdlog/details/async_log_helper.h | 152 +-
include/spdlog/details/async_logger_impl.h | 52 +-
include/spdlog/details/file_helper.h | 62 +-
include/spdlog/details/format.cc | 1577 +++----
include/spdlog/details/format.h | 5149 ++++++++++++++---------
include/spdlog/details/line_logger.h | 221 -
include/spdlog/details/line_logger_fwd.h | 78 +
include/spdlog/details/line_logger_impl.h | 185 +
include/spdlog/details/log_msg.h | 35 +-
include/spdlog/details/logger_impl.h | 43 +-
include/spdlog/details/mpmc_bounded_q.h | 28 +-
include/spdlog/details/null_mutex.h | 27 +-
include/spdlog/details/os.h | 90 +-
include/spdlog/details/pattern_formatter_impl.h | 52 +-
include/spdlog/details/registry.h | 79 +-
include/spdlog/details/spdlog_impl.h | 45 +-
include/spdlog/formatter.h | 37 +-
include/spdlog/logger.h | 50 +-
include/spdlog/sinks/android_sink.h | 92 +
include/spdlog/sinks/base_sink.h | 39 +-
include/spdlog/sinks/dist_sink.h | 72 +
include/spdlog/sinks/file_sinks.h | 43 +-
include/spdlog/sinks/msvc_sink.h | 50 +
include/spdlog/sinks/null_sink.h | 34 +-
include/spdlog/sinks/ostream_sink.h | 34 +-
include/spdlog/sinks/sink.h | 30 +-
include/spdlog/sinks/stdout_sinks.h | 33 +-
include/spdlog/sinks/syslog_sink.h | 39 +-
include/spdlog/spdlog.h | 47 +-
include/spdlog/tweakme.h | 33 +-
tests/Makefile | 2 +-
tests/file_helper.cpp | 77 +
tests/file_log.cpp | 53 +-
tests/includes.h | 3 +
tests/tests.vcxproj | 17 +-
tests/tests.vcxproj.filters | 9 +
tests/utils.cpp | 45 +
tests/utils.h | 15 +
65 files changed, 5370 insertions(+), 4002 deletions(-)
diff --git a/.travis.yml b/.travis.yml
index 3557a2f..6364b6a 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -84,7 +84,7 @@ install:
- sed -i 's/march=native/msse4.2/' example/Makefile
- if [ ! -d build ]; then mkdir build; fi
- - export CXX_FLAGS=""
+ - export CXX_FLAGS="-I${CHECKOUT_PATH}/include"
- export CXX_LINKER_FLAGS=""
- if [ -z "$BUILD_TYPE" ]; then export BUILD_TYPE=Release; fi
- if [ "$ASAN" == "On"]; then export CXX_FLAGS="${CXX_FLAGS} -fsanitize=address,undefined,integer -fno-omit-frame-pointer -fno-sanitize=unsigned-integer-overflow"; fi
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..15553b1
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,62 @@
+#
+# Copyright(c) 2015 Ruslan Baratov.
+# Distributed under the MIT License (http://opensource.org/licenses/MIT)
+#
+
+cmake_minimum_required(VERSION 3.0)
+project(spdlog VERSION 1.0.0)
+
+add_library(spdlog INTERFACE)
+
+option(SPDLOG_BUILD_EXAMPLES "Build examples" OFF)
+
+target_include_directories(
+ spdlog
+ INTERFACE
+ "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
+ "$<INSTALL_INTERFACE:include>"
+)
+
+if(SPDLOG_BUILD_EXAMPLES)
+ enable_testing()
+ add_subdirectory(example)
+endif()
+
+### Install ###
+# * https://github.com/forexample/package-example
+set(generated_dir "${CMAKE_CURRENT_BINARY_DIR}/generated")
+
+set(config_install_dir "lib/cmake/${PROJECT_NAME}")
+set(include_install_dir "include")
+
+set(version_config "${generated_dir}/${PROJECT_NAME}ConfigVersion.cmake")
+set(project_config "${generated_dir}/${PROJECT_NAME}Config.cmake")
+set(targets_export_name "${PROJECT_NAME}Targets")
+set(namespace "${PROJECT_NAME}::")
+
+include(CMakePackageConfigHelpers)
+write_basic_package_version_file(
+ "${version_config}" COMPATIBILITY SameMajorVersion
+)
+
+# Note: use 'targets_export_name'
+configure_file("cmake/Config.cmake.in" "${project_config}" @ONLY)
+
+install(
+ TARGETS spdlog
+ EXPORT "${targets_export_name}"
+ INCLUDES DESTINATION "${include_install_dir}"
+)
+
+install(DIRECTORY "include/spdlog" DESTINATION "${include_install_dir}")
+
+install(
+ FILES "${project_config}" "${version_config}"
+ DESTINATION "${config_install_dir}"
+)
+
+install(
+ EXPORT "${targets_export_name}"
+ NAMESPACE "${namespace}"
+ DESTINATION "${config_install_dir}"
+)
diff --git a/LICENSE b/LICENSE
index 00c32d1..a199709 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,23 +1,22 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
+The MIT License (MIT)
+
+Copyright (c) 2015 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.
+
diff --git a/README.md b/README.md
index 3d161cf..bc55968 100644
--- a/README.md
+++ b/README.md
@@ -3,11 +3,11 @@
Very fast, header only, C++ logging library. [](https://travis-ci.org/gabime/spdlog)
## Install
-Just copy the files to your build tree and use a C++11 compiler
+Just copy the source [folder](https://github.com/gabime/spdlog/tree/master/include/spdlog) to your build tree and use a C++11 compiler
## Platforms
* Linux (gcc 4.8.1+, clang 3.5+)
- * Windows (visual studio 2013+, mingw with g++ 4.9.1+)
+ * Windows (visual studio 2013+, cygwin/mingw with g++ 4.9.1+)
* Mac OSX (clang 3.5+)
##Features
@@ -36,11 +36,11 @@ Below are some [benchmarks](bench) comparing popular log libraries under Ubuntu
#### Synchronous mode
Time needed to log 1,000,000 lines in synchronous mode (in seconds, the best of 3 runs):
-|threads|boost log|glog |easylogging |spdlog|
+|threads|boost log 1.54|glog |easylogging |spdlog|
|-------|:-------:|:-----:|----------:|------:|
|1| 4.169s |1.066s |0.975s |0.302s|
-|10| 16.029 |3.032s |2.857s |0.968s|
-|100| 15.008 |1.139s |4.512s |0.497s|
+|10| 6.180s |3.032s |2.857s |0.968s|
+|100| 5.981s |1.139s |4.512s |0.497s|
#### Asynchronous mode
diff --git a/bench/Makefile b/bench/Makefile
index c0edbd6..6331f21 100644
--- a/bench/Makefile
+++ b/bench/Makefile
@@ -1,9 +1,9 @@
CXX ?= g++
-CXXFLAGS = -march=native -Wall -Wextra -pedantic -std=c++11 -pthread -Wl,--no-as-needed -I../include
-CXX_RELEASE_FLAGS = -O3 -flto
+CXXFLAGS = -march=native -Wall -Wextra -pedantic -std=c++11 -pthread -Wl,--no-as-needed -I../include
+CXX_RELEASE_FLAGS = -O3 -flto -DNDEBUG
-binaries=spdlog-bench spdlog-bench-mt spdlog-async boost-bench boost-bench-mt glog-bench glog-bench-mt g2log-async easylogging-bench easylogging-bench-mt
+binaries=spdlog-bench spdlog-bench-mt spdlog-async zf_log-bench zf_log-bench-mt boost-bench boost-bench-mt glog-bench glog-bench-mt g2log-async easylogging-bench easylogging-bench-mt
all: $(binaries)
@@ -15,9 +15,17 @@ spdlog-bench-mt: spdlog-bench-mt.cpp
spdlog-async: spdlog-async.cpp
$(CXX) spdlog-async.cpp -o spdlog-async $(CXXFLAGS) $(CXX_RELEASE_FLAGS)
+
+
+ZF_LOG_FLAGS = -I../../zf_log.git/zf_log/
+zf_log-bench: zf_log-bench.cpp
+ $(CXX) zf_log-bench.cpp -o zf_log-bench $(CXXFLAGS) $(CXX_RELEASE_FLAGS) $(ZF_LOG_FLAGS)
+
+zf_log-bench-mt: zf_log-bench-mt.cpp
+ $(CXX) zf_log-bench-mt.cpp -o zf_log-bench-mt $(CXXFLAGS) $(CXX_RELEASE_FLAGS) $(ZF_LOG_FLAGS)
-BOOST_FLAGS = -DBOOST_LOG_DYN_LINK -I/home/gabi/devel/boost_1_56_0/ -L/home/gabi/devel/boost_1_56_0/stage/lib -lboost_log -lboost_log_setup -lboost_filesystem -lboost_system -lboost_thread -lboost_regex -lboost_date_time -lboost_chrono
+BOOST_FLAGS = -DBOOST_LOG_DYN_LINK -I/usr/include -lboost_log -lboost_log_setup -lboost_filesystem -lboost_system -lboost_thread -lboost_regex -lboost_date_time -lboost_chrono
boost-bench: boost-bench.cpp
$(CXX) boost-bench.cpp -o boost-bench $(CXXFLAGS) $(BOOST_FLAGS) $(CXX_RELEASE_FLAGS)
diff --git a/bench/boost-bench-mt.cpp b/bench/boost-bench-mt.cpp
index 24967fe..d845fce 100644
--- a/bench/boost-bench-mt.cpp
+++ b/bench/boost-bench-mt.cpp
@@ -1,3 +1,8 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
#include <thread>
#include <vector>
#include <atomic>
diff --git a/bench/boost-bench.cpp b/bench/boost-bench.cpp
index 3bc4fc2..7668544 100644
--- a/bench/boost-bench.cpp
+++ b/bench/boost-bench.cpp
@@ -1,3 +1,7 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#include <boost/log/core.hpp>
#include <boost/log/trivial.hpp>
diff --git a/bench/easylogging-bench-mt.cpp b/bench/easylogging-bench-mt.cpp
index 99d5caa..98d1ae3 100644
--- a/bench/easylogging-bench-mt.cpp
+++ b/bench/easylogging-bench-mt.cpp
@@ -1,3 +1,8 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
#include <thread>
#include <vector>
#include <atomic>
diff --git a/bench/easylogging-bench.cpp b/bench/easylogging-bench.cpp
index b289c81..a952cbd 100644
--- a/bench/easylogging-bench.cpp
+++ b/bench/easylogging-bench.cpp
@@ -1,3 +1,9 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+
#include "easylogging++.h"
_INITIALIZE_EASYLOGGINGPP
diff --git a/bench/g2log-async.cpp b/bench/g2log-async.cpp
index 1d6bc5f..9f9eb71 100644
--- a/bench/g2log-async.cpp
+++ b/bench/g2log-async.cpp
@@ -1,3 +1,8 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
#include <thread>
#include <vector>
#include <atomic>
diff --git a/bench/glog-bench-mt.cpp b/bench/glog-bench-mt.cpp
index 5418c08..db193ae 100644
--- a/bench/glog-bench-mt.cpp
+++ b/bench/glog-bench-mt.cpp
@@ -1,3 +1,8 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
#include <thread>
#include <vector>
#include <atomic>
diff --git a/bench/glog-bench.cpp b/bench/glog-bench.cpp
index 837fce5..cf7e70a 100644
--- a/bench/glog-bench.cpp
+++ b/bench/glog-bench.cpp
@@ -1,3 +1,7 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#include "glog/logging.h"
diff --git a/bench/run_all.sh b/bench/run_all.sh
index 94cc193..92fcd9e 100755
--- a/bench/run_all.sh
+++ b/bench/run_all.sh
@@ -24,13 +24,13 @@ bench_async ()
rm -f logs/*
sleep 3
done;
-}
+}
echo "----------------------------------------------------------"
echo "Single threaded benchmarks.. (1 thread, 1,000,000 lines)"
echo "----------------------------------------------------------"
-for exe in boost-bench glog-bench easylogging-bench spdlog-bench;
+for exe in boost-bench glog-bench easylogging-bench zf_log-bench spdlog-bench;
do
bench_exe $exe 1
done;
@@ -38,7 +38,7 @@ done;
echo "----------------------------------------------------------"
echo "Multi threaded benchmarks.. (10 threads, 1,000,000 lines)"
echo "----------------------------------------------------------"
-for exe in boost-bench-mt glog-bench-mt easylogging-bench-mt spdlog-bench-mt;
+for exe in boost-bench-mt glog-bench-mt easylogging-bench-mt zf_log-bench-mt spdlog-bench-mt;
do
bench_exe $exe 10
done;
@@ -46,11 +46,10 @@ done;
echo "----------------------------------------------------------"
echo "Multi threaded benchmarks.. (100 threads, 1,000,000 lines)"
echo "----------------------------------------------------------"
-for exe in boost-bench-mt glog-bench-mt easylogging-bench-mt spdlog-bench-mt;
+for exe in boost-bench-mt glog-bench-mt easylogging-bench-mt zf_log-bench-mt spdlog-bench-mt;
do
bench_exe $exe 100
done;
-
echo "---------------------------------------------------------------"
echo "Async, single threaded benchmark.. (1 thread, 1,000,000 lines)"
@@ -68,7 +67,6 @@ do
bench_async $exe 10
done;
-
echo "---------------------------------------------------------------"
echo "Async, multi threaded benchmark.. (100 threads, 1,000,000 lines)"
echo "---------------------------------------------------------------"
@@ -76,6 +74,3 @@ for exe in spdlog-async g2log-async
do
bench_async $exe 100
done;
-
-
-
diff --git a/bench/spdlog-async.cpp b/bench/spdlog-async.cpp
index 7307f39..0e2c118 100644
--- a/bench/spdlog-async.cpp
+++ b/bench/spdlog-async.cpp
@@ -1,10 +1,14 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#include <thread>
#include <vector>
#include <atomic>
#include <iostream>
#include <chrono>
-
+#include <cstdlib>
#include "spdlog/spdlog.h"
using namespace std;
@@ -18,7 +22,7 @@ int main(int argc, char* argv[])
int thread_count = 10;
if(argc > 1)
- thread_count = atoi(argv[1]);
+ thread_count = ::atoi(argv[1]);
int howmany = 1000000;
spd::set_async_mode(1048576);
diff --git a/bench/spdlog-bench-mt.cpp b/bench/spdlog-bench-mt.cpp
index d69a01e..0492306 100644
--- a/bench/spdlog-bench-mt.cpp
+++ b/bench/spdlog-bench-mt.cpp
@@ -1,7 +1,12 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
#include <thread>
#include <vector>
#include <atomic>
-
+#include <cstdlib>
#include "spdlog/spdlog.h"
@@ -12,7 +17,7 @@ int main(int argc, char* argv[])
int thread_count = 10;
if(argc > 1)
- thread_count = atoi(argv[1]);
+ thread_count = std::atoi(argv[1]);
int howmany = 1000000;
diff --git a/bench/spdlog-bench.cpp b/bench/spdlog-bench.cpp
index e0b41f3..700a82b 100644
--- a/bench/spdlog-bench.cpp
+++ b/bench/spdlog-bench.cpp
@@ -1,3 +1,7 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#include "spdlog/spdlog.h"
diff --git a/bench/zf_log-bench-mt.cpp b/bench/zf_log-bench-mt.cpp
new file mode 100644
index 0000000..3463d7e
--- /dev/null
+++ b/bench/zf_log-bench-mt.cpp
@@ -0,0 +1,56 @@
+#include <thread>
+#include <vector>
+#include <atomic>
+#include <cstdlib>
+#include <unistd.h>
+#include <fcntl.h>
+#include <zf_log.c>
+
+const char g_path[] = "logs/zf_log.txt";
+int g_fd;
+
+static void output_callback(zf_log_message *msg)
+{
+ *msg->p = '\n';
+ write(g_fd, msg->buf, msg->p - msg->buf + 1);
+}
+
+using namespace std;
+
+int main(int argc, char* argv[])
+{
+ g_fd = open(g_path, O_APPEND|O_CREAT|O_WRONLY);
+ if (0 > g_fd)
+ {
+ ZF_LOGE_AUX(ZF_LOG_STDERR, "Failed to open log file: %s", g_path);
+ return -1;
+ }
+ zf_log_set_output_callback(ZF_LOG_PUT_STD, output_callback);
+
+ int thread_count = 10;
+ if(argc > 1)
+ thread_count = std::atoi(argv[1]);
+ int howmany = 1000000;
+ std::atomic<int > msg_counter {0};
+ vector<thread> threads;
+
+ for (int t = 0; t < thread_count; ++t)
+ {
+ threads.push_back(std::thread([&]()
+ {
+ while (true)
+ {
+ int counter = ++msg_counter;
+ if (counter > howmany) break;
+ ZF_LOGI("zf_log message #%i: This is some text for your pleasure", counter);
+ }
+ }));
+ }
+
+ for (auto &t:threads)
+ {
+ t.join();
+ };
+ close(g_fd);
+ return 0;
+}
diff --git a/bench/zf_log-bench.cpp b/bench/zf_log-bench.cpp
new file mode 100644
index 0000000..dfa2892
--- /dev/null
+++ b/bench/zf_log-bench.cpp
@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <zf_log.c>
+
+const char g_path[] = "logs/zf_log.txt";
+static FILE *g_f;
+
+static void output_callback(zf_log_message *msg)
+{
+ *msg->p = '\n';
+ fwrite(msg->buf, msg->p - msg->buf + 1, 1, g_f);
+}
+
+int main(int, char* [])
+{
+ g_f = fopen(g_path, "wb");
+ if (!g_f) {
+ ZF_LOGE_AUX(ZF_LOG_STDERR, "Failed to open log file: %s", g_path);
+ return -1;
+ }
+ zf_log_set_output_callback(ZF_LOG_PUT_STD, output_callback);
+
+ const int howmany = 1000000;
+ for(int i = 0 ; i < howmany; ++i)
+ ZF_LOGI("zf_log message #%i: This is some text for your pleasure", i);
+ fclose(g_f);
+ return 0;
+}
diff --git a/cmake/Config.cmake.in b/cmake/Config.cmake.in
new file mode 100644
index 0000000..b59e23e
--- /dev/null
+++ b/cmake/Config.cmake.in
@@ -0,0 +1,24 @@
+# *************************************************************************/
+# * Copyright (c) 2015 Ruslan Baratov. */
+# * */
+# * 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. */
+# *************************************************************************/
+
+include("${CMAKE_CURRENT_LIST_DIR}/@targets_export_name at .cmake")
diff --git a/example/CMakeLists.txt b/example/CMakeLists.txt
new file mode 100644
index 0000000..6ef158e
--- /dev/null
+++ b/example/CMakeLists.txt
@@ -0,0 +1,49 @@
+# *************************************************************************/
+# * Copyright (c) 2015 Ruslan Baratov. */
+# * */
+# * 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. */
+# *************************************************************************/
+
+cmake_minimum_required(VERSION 3.0)
+project(SpdlogExamples)
+
+if(TARGET spdlog)
+ # Part of the main project
+ add_library(spdlog::spdlog ALIAS spdlog)
+else()
+ # Stand-alone build
+ find_package(spdlog CONFIG REQUIRED)
+endif()
+
+if (CMAKE_COMPILER_IS_GNUCXX)
+ set ( CMAKE_CXX_FLAGS "--std=c++11 -pthread")
+ set ( CMAKE_EXE_LIKKER_FLAGS "-pthread")
+endif ()
+
+add_executable(example example.cpp)
+target_link_libraries(example spdlog::spdlog)
+
+add_executable(benchmark bench.cpp)
+target_link_libraries(benchmark spdlog::spdlog)
+
+enable_testing()
+file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/logs")
+add_test(NAME RunExample COMMAND example)
+add_test(NAME RunBenchmark COMMAND benchmark)
diff --git a/example/bench.cpp b/example/bench.cpp
index ba76e2a..d45705b 100644
--- a/example/bench.cpp
+++ b/example/bench.cpp
@@ -1,35 +1,17 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
//
// bench.cpp : spdlog benchmarks
//
+#include <atomic>
+#include <cstdlib> // EXIT_FAILURE
#include <iostream>
#include <memory>
#include <string>
#include <thread>
-#include <atomic>
#include "spdlog/spdlog.h"
#include "spdlog/async_logger.h"
#include "spdlog/sinks/file_sinks.h"
@@ -108,8 +90,9 @@ int main(int argc, char* argv[])
{
std::cerr << "Error: " << ex.what() << std::endl;
perror("Last error");
+ return EXIT_FAILURE;
}
- return 0;
+ return EXIT_SUCCESS;
}
diff --git a/example/example.cpp b/example/example.cpp
index 6159770..ac45bdd 100644
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -1,30 +1,11 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
-
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
//
// spdlog usage example
//
+#include <cstdlib> // EXIT_FAILURE
#include <iostream>
#include "spdlog/spdlog.h"
@@ -92,8 +73,9 @@ int main(int, char*[])
size_t q_size = 1048576; //queue size must be power of 2
spdlog::set_async_mode(q_size);
auto async_file = spd::daily_logger_st("async_file_logger", "logs/async_log.txt");
- async_file->info() << "This is async log.." << "Should be very fast!";
- spdlog::drop_all(); //Close all loggers
+ for (int i = 0; i < 100; ++i)
+ async_file->info("Async message #{}", i);
+
//
// syslog example. linux only..
//
@@ -102,11 +84,19 @@ int main(int, char*[])
auto syslog_logger = spd::syslog_logger("syslog", ident, LOG_PID);
syslog_logger->warn("This is warning that will end up in syslog. This is Linux only!");
#endif
+
+ //
+ //Release and close all loggers
+ //
+ spdlog::drop_all();
}
+
catch (const spd::spdlog_ex& ex)
{
std::cout << "Log failed: " << ex.what() << std::endl;
+ return EXIT_FAILURE;
}
+ return EXIT_SUCCESS;
}
diff --git a/example/example.sln b/example/example.sln
new file mode 100644
index 0000000..20a6a1f
--- /dev/null
+++ b/example/example.sln
@@ -0,0 +1,22 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2013
+VisualStudioVersion = 12.0.40629.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "example", "example.vcxproj", "{9E5AB93A-0CCE-4BAC-9FCB-0FC9CB5EB8D2}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Win32 = Debug|Win32
+ Release|Win32 = Release|Win32
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {9E5AB93A-0CCE-4BAC-9FCB-0FC9CB5EB8D2}.Debug|Win32.ActiveCfg = Debug|Win32
+ {9E5AB93A-0CCE-4BAC-9FCB-0FC9CB5EB8D2}.Debug|Win32.Build.0 = Debug|Win32
+ {9E5AB93A-0CCE-4BAC-9FCB-0FC9CB5EB8D2}.Release|Win32.ActiveCfg = Release|Win32
+ {9E5AB93A-0CCE-4BAC-9FCB-0FC9CB5EB8D2}.Release|Win32.Build.0 = Release|Win32
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal
diff --git a/example/example.vcxproj b/example/example.vcxproj
new file mode 100644
index 0000000..a8218f4
--- /dev/null
+++ b/example/example.vcxproj
@@ -0,0 +1,90 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ItemGroup Label="ProjectConfigurations">
+ <ProjectConfiguration Include="Debug|Win32">
+ <Configuration>Debug</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Release|Win32">
+ <Configuration>Release</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ </ItemGroup>
+ <ItemGroup>
+ <ClCompile Include="example.cpp" />
+ </ItemGroup>
+ <PropertyGroup Label="Globals">
+ <ProjectGuid>{9E5AB93A-0CCE-4BAC-9FCB-0FC9CB5EB8D2}</ProjectGuid>
+ <Keyword>Win32Proj</Keyword>
+ <RootNamespace>.</RootNamespace>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+ <ConfigurationType>Application</ConfigurationType>
+ <UseDebugLibraries>true</UseDebugLibraries>
+ <PlatformToolset>v140</PlatformToolset>
+ <CharacterSet>Unicode</CharacterSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+ <ConfigurationType>Application</ConfigurationType>
+ <UseDebugLibraries>false</UseDebugLibraries>
+ <PlatformToolset>v140</PlatformToolset>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>Unicode</CharacterSet>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+ <ImportGroup Label="ExtensionSettings">
+ </ImportGroup>
+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <PropertyGroup Label="UserMacros" />
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <LinkIncremental>true</LinkIncremental>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <LinkIncremental>false</LinkIncremental>
+ </PropertyGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <ClCompile>
+ <PrecompiledHeader>
+ </PrecompiledHeader>
+ <WarningLevel>Level3</WarningLevel>
+ <Optimization>Disabled</Optimization>
+ <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <AdditionalIncludeDirectories>..\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile />
+ <PrecompiledHeaderOutputFile />
+ </ClCompile>
+ <Link>
+ <SubSystem>Console</SubSystem>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ </Link>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <ClCompile>
+ <WarningLevel>Level3</WarningLevel>
+ <PrecompiledHeader>
+ </PrecompiledHeader>
+ <Optimization>MaxSpeed</Optimization>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <AdditionalIncludeDirectories>..\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile />
+ <PrecompiledHeaderOutputFile />
+ </ClCompile>
+ <Link>
+ <SubSystem>Console</SubSystem>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <OptimizeReferences>true</OptimizeReferences>
+ </Link>
+ </ItemDefinitionGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+ <ImportGroup Label="ExtensionTargets">
+ </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/example/utils.h b/example/utils.h
index 95dd925..b260f72 100644
--- a/example/utils.h
+++ b/example/utils.h
@@ -1,26 +1,7 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#pragma once
diff --git a/include/spdlog/async_logger.h b/include/spdlog/async_logger.h
index 517ce92..be21501 100644
--- a/include/spdlog/async_logger.h
+++ b/include/spdlog/async_logger.h
@@ -1,26 +1,7 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#pragma once
@@ -34,12 +15,13 @@
// 3. will throw spdlog_ex upon log exceptions
// Upong destruction, logs all remaining messages in the queue before destructing..
+#include <spdlog/common.h>
+#include <spdlog/logger.h>
+
#include <chrono>
#include <functional>
-#include "common.h"
-#include "logger.h"
-#include "spdlog.h"
-
+#include <string>
+#include <memory>
namespace spdlog
{
@@ -76,6 +58,7 @@ public:
const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero());
+ void flush() override;
protected:
void _log_msg(details::log_msg& msg) override;
void _set_formatter(spdlog::formatter_ptr msg_formatter) override;
@@ -87,4 +70,5 @@ private:
}
-#include "./details/async_logger_impl.h"
+#include <spdlog/details/async_logger_impl.h>
+
diff --git a/include/spdlog/common.h b/include/spdlog/common.h
index 01b2212..269c881 100644
--- a/include/spdlog/common.h
+++ b/include/spdlog/common.h
@@ -1,26 +1,7 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#pragma once
@@ -28,6 +9,7 @@
#include <initializer_list>
#include <chrono>
#include <memory>
+#include <exception>
//visual studio does not support noexcept yet
#ifndef _MSC_VER
@@ -113,4 +95,4 @@ private:
};
-} //spdlog
\ No newline at end of file
+} //spdlog
diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h
index 59c1b2d..8555ef0 100644
--- a/include/spdlog/details/async_log_helper.h
+++ b/include/spdlog/details/async_log_helper.h
@@ -1,26 +1,7 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
// async log helper :
// Process logs asynchronously using a back thread.
@@ -33,18 +14,21 @@
#pragma once
+#include <spdlog/common.h>
+#include <spdlog/sinks/sink.h>
+#include <spdlog/details/mpmc_bounded_q.h>
+#include <spdlog/details/log_msg.h>
+#include <spdlog/details/os.h>
+#include <spdlog/formatter.h>
+
#include <chrono>
-#include <thread>
-#include <atomic>
+#include <exception>
#include <functional>
-
-#include "../common.h"
-#include "../sinks/sink.h"
-#include "./mpmc_bounded_q.h"
-#include "./log_msg.h"
-#include "./format.h"
-#include "os.h"
-
+#include <memory>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
namespace spdlog
{
@@ -55,6 +39,12 @@ class async_log_helper
{
// Async msg to move to/from the queue
// Movable only. should never be copied
+ enum class async_msg_type
+ {
+ log,
+ flush,
+ terminate
+ };
struct async_msg
{
std::string logger_name;
@@ -62,17 +52,23 @@ class async_log_helper
log_clock::time_point time;
size_t thread_id;
std::string txt;
+ async_msg_type msg_type;
async_msg() = default;
~async_msg() = default;
+
async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
logger_name(std::move(other.logger_name)),
level(std::move(other.level)),
time(std::move(other.time)),
- txt(std::move(other.txt))
+ txt(std::move(other.txt)),
+ msg_type(std::move(other.msg_type))
{}
+ async_msg(async_msg_type m_type) :msg_type(m_type)
+ {};
+
async_msg& operator=(async_msg&& other) SPDLOG_NOEXCEPT
{
logger_name = std::move(other.logger_name);
@@ -80,8 +76,10 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
time = std::move(other.time);
thread_id = other.thread_id;
txt = std::move(other.txt);
+ msg_type = other.msg_type;
return *this;
}
+
// never copy or assign. should only be moved..
async_msg(const async_msg&) = delete;
async_msg& operator=(async_msg& other) = delete;
@@ -92,10 +90,12 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
level(m.level),
time(m.time),
thread_id(m.thread_id),
- txt(m.raw.data(), m.raw.size())
+ txt(m.raw.data(), m.raw.size()),
+ msg_type(async_msg_type::log)
{}
+
// copy into log_msg
void fill_log_msg(log_msg &msg)
{
@@ -130,6 +130,8 @@ public:
void set_formatter(formatter_ptr);
+ void flush();
+
private:
formatter_ptr _formatter;
@@ -138,6 +140,11 @@ private:
// queue of messages to log
q_type _q;
+ bool _flush_requested;
+
+ bool _terminate_requested;
+
+
// last exception thrown from the worker thread
std::shared_ptr<spdlog_ex> _last_workerthread_ex;
@@ -153,14 +160,16 @@ private:
// worker thread
std::thread _worker_thread;
+ void push_msg(async_msg&& new_msg);
// throw last worker thread exception or if worker thread is not active
+
void throw_if_bad_worker();
// worker thread main loop
void worker_loop();
- // pop next message from the queue and process it
- // return true if a message was available (queue was not empty), will set the last_pop to the pop time
+ // pop next message from the queue and process it. will set the last_pop to the pop time
+ // return false if termination of the queue is required
bool process_next_msg(log_clock::time_point& last_pop, log_clock::time_point& last_flush);
void handle_flush_interval(log_clock::time_point& now, log_clock::time_point& last_flush);
@@ -168,8 +177,6 @@ private:
// sleep,yield or return immediatly using the time passed since last message as a hint
static void sleep_or_yield(const spdlog::log_clock::time_point& now, const log_clock::time_point& last_op_time);
-
-
};
}
}
@@ -177,10 +184,18 @@ private:
///////////////////////////////////////////////////////////////////////////////
// async_sink class implementation
///////////////////////////////////////////////////////////////////////////////
-inline spdlog::details::async_log_helper::async_log_helper(formatter_ptr formatter, const std::vector<sink_ptr>& sinks, size_t queue_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms):
+inline spdlog::details::async_log_helper::async_log_helper(
+ formatter_ptr formatter,
+ const std::vector<sink_ptr>& sinks,
+ size_t queue_size,
+ const async_overflow_policy overflow_policy,
+ const std::function<void()>& worker_warmup_cb,
+ const std::chrono::milliseconds& flush_interval_ms):
_formatter(formatter),
_sinks(sinks),
_q(queue_size),
+ _flush_requested(false),
+ _terminate_requested(false),
_overflow_policy(overflow_policy),
_worker_warmup_cb(worker_warmup_cb),
_flush_interval_ms(flush_interval_ms),
@@ -191,13 +206,12 @@ inline spdlog::details::async_log_helper::async_log_helper(formatter_ptr formatt
// and wait for it to finish gracefully
inline spdlog::details::async_log_helper::~async_log_helper()
{
-
try
{
- log(log_msg(level::off));
+ push_msg(async_msg(async_msg_type::terminate));
_worker_thread.join();
}
- catch (...) //Dont crash if thread not joinable
+ catch (...) // don't crash in destructor
{}
}
@@ -205,8 +219,15 @@ inline spdlog::details::async_log_helper::~async_log_helper()
//Try to push and block until succeeded
inline void spdlog::details::async_log_helper::log(const details::log_msg& msg)
{
+ push_msg(async_msg(msg));
+
+
+}
+
+//Try to push and block until succeeded
+inline void spdlog::details::async_log_helper::push_msg(details::async_log_helper::async_msg&& new_msg)
+{
throw_if_bad_worker();
- async_msg new_msg(msg);
if (!_q.enqueue(std::move(new_msg)) && _overflow_policy != async_overflow_policy::discard_log_msg)
{
auto last_op_time = details::os::now();
@@ -221,6 +242,11 @@ inline void spdlog::details::async_log_helper::log(const details::log_msg& msg)
}
+inline void spdlog::details::async_log_helper::flush()
+{
+ push_msg(async_msg(async_msg_type::flush));
+}
+
inline void spdlog::details::async_log_helper::worker_loop()
{
try
@@ -251,31 +277,47 @@ inline bool spdlog::details::async_log_helper::process_next_msg(log_clock::time_
if (_q.dequeue(incoming_async_msg))
{
last_pop = details::os::now();
-
- if(incoming_async_msg.level == level::off)
- return false;
-
- incoming_async_msg.fill_log_msg(incoming_log_msg);
- _formatter->format(incoming_log_msg);
- for (auto &s : _sinks)
- s->log(incoming_log_msg);
+ switch (incoming_async_msg.msg_type)
+ {
+ case async_msg_type::flush:
+ _flush_requested = true;
+ break;
+
+ case async_msg_type::terminate:
+ _flush_requested = true;
+ _terminate_requested = true;
+ break;
+
+ default:
+ incoming_async_msg.fill_log_msg(incoming_log_msg);
+ _formatter->format(incoming_log_msg);
+ for (auto &s : _sinks)
+ s->log(incoming_log_msg);
+ }
+ return true;
}
- else //empty queue
+
+ // Handle empty queue..
+ // This is the only place where the queue can terminate or flush to avoid losing messages already in the queue
+ else
{
auto now = details::os::now();
handle_flush_interval(now, last_flush);
sleep_or_yield(now, last_pop);
+ return !_terminate_requested;
+
}
- return true;
}
inline void spdlog::details::async_log_helper::handle_flush_interval(log_clock::time_point& now, log_clock::time_point& last_flush)
{
- if (_flush_interval_ms != std::chrono::milliseconds::zero() && now - last_flush >= _flush_interval_ms)
+ auto should_flush = _flush_requested || (_flush_interval_ms != std::chrono::milliseconds::zero() && now - last_flush >= _flush_interval_ms);
+ if (should_flush)
{
for (auto &s : _sinks)
s->flush();
now = last_flush = details::os::now();
+ _flush_requested = false;
}
}
inline void spdlog::details::async_log_helper::set_formatter(formatter_ptr msg_formatter)
diff --git a/include/spdlog/details/async_logger_impl.h b/include/spdlog/details/async_logger_impl.h
index f60407e..140d45f 100644
--- a/include/spdlog/details/async_logger_impl.h
+++ b/include/spdlog/details/async_logger_impl.h
@@ -1,37 +1,20 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#pragma once
-
-#include "./async_log_helper.h"
-
-//
// Async Logger implementation
-// Use single async_sink (queue) to perform the logging in a worker thread
-//
+// Use an async_sink (queue per logger) to perform the logging in a worker thread
+#include <spdlog/details/async_log_helper.h>
+#include <spdlog/async_logger.h>
+
+#include <string>
+#include <functional>
+#include <chrono>
+#include <memory>
template<class It>
inline spdlog::async_logger::async_logger(const std::string& logger_name,
@@ -60,8 +43,17 @@ inline spdlog::async_logger::async_logger(const std::string& logger_name,
const async_overflow_policy overflow_policy,
const std::function<void()>& worker_warmup_cb,
const std::chrono::milliseconds& flush_interval_ms) :
- async_logger(logger_name, { single_sink }, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms) {}
+ async_logger(logger_name,
+{
+ single_sink
+}, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms) {}
+
+inline void spdlog::async_logger::flush()
+{
+
+ _async_log_helper->flush();
+}
inline void spdlog::async_logger::_set_formatter(spdlog::formatter_ptr msg_formatter)
{
diff --git a/include/spdlog/details/file_helper.h b/include/spdlog/details/file_helper.h
index 4ba556a..e563d00 100644
--- a/include/spdlog/details/file_helper.h
+++ b/include/spdlog/details/file_helper.h
@@ -1,26 +1,7 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#pragma once
@@ -29,13 +10,13 @@
// Can be set to auto flush on every line
// Throw spdlog_ex exception on errors
+#include <spdlog/details/os.h>
+#include <spdlog/details/log_msg.h>
+
+#include <chrono>
+#include <cstdio>
#include <string>
#include <thread>
-#include <chrono>
-#include "os.h"
-
-
-
namespace spdlog
{
@@ -87,7 +68,8 @@ public:
}
- void flush() {
+ void flush()
+ {
std::fflush(_fd);
}
@@ -103,9 +85,9 @@ public:
void write(const log_msg& msg)
{
- size_t size = msg.formatted.size();
+ size_t msg_size = msg.formatted.size();
auto data = msg.formatted.data();
- if (std::fwrite(data, 1, size, _fd) != size)
+ if (std::fwrite(data, 1, msg_size, _fd) != msg_size)
throw spdlog_ex("Failed writing to file " + _filename);
if (_force_flush)
@@ -122,16 +104,16 @@ public:
if (fseek(_fd, 0, SEEK_END) != 0)
throw spdlog_ex("fseek failed on file " + _filename);
- auto size = ftell(_fd);
+ auto file_size = ftell(_fd);
if(fseek(_fd, pos, SEEK_SET) !=0)
throw spdlog_ex("fseek failed on file " + _filename);
- if (size == -1)
+ if (file_size == -1)
throw spdlog_ex("ftell failed on file " + _filename);
- return size;
+ return file_size;
}
@@ -143,16 +125,8 @@ public:
static bool file_exists(const std::string& name)
{
- FILE* file;
- if (!os::fopen_s(&file, name.c_str(), "r"))
- {
- fclose(file);
- return true;
- }
- else
- {
- return false;
- }
+
+ return os::file_exists(name);
}
diff --git a/include/spdlog/details/format.cc b/include/spdlog/details/format.cc
index 873d827..c77e1ef 100644
--- a/include/spdlog/details/format.cc
+++ b/include/spdlog/details/format.cc
@@ -1,29 +1,29 @@
/*
- Formatting library for C++
-
- Copyright (c) 2012 - 2015, Victor Zverovich
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice, this
- list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright notice,
- this list of conditions and the following disclaimer in the documentation
- and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+Formatting library for C++
+
+Copyright (c) 2012 - 2015, Victor Zverovich
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
#include "format.h"
@@ -34,6 +34,7 @@
#include <climits>
#include <cmath>
#include <cstdarg>
+#include <cstddef> // for std::ptrdiff_t
#if defined(_WIN32) && defined(__MINGW32__)
# include <cstring>
@@ -51,17 +52,6 @@
using fmt::internal::Arg;
-// Check if exceptions are disabled.
-#if __GNUC__ && !__EXCEPTIONS
-# define FMT_EXCEPTIONS 0
-#endif
-#if _MSC_VER && !_HAS_EXCEPTIONS
-# define FMT_EXCEPTIONS 0
-#endif
-#ifndef FMT_EXCEPTIONS
-# define FMT_EXCEPTIONS 1
-#endif
-
#if FMT_EXCEPTIONS
# define FMT_TRY try
# define FMT_CATCH(x) catch (x)
@@ -70,21 +60,13 @@ using fmt::internal::Arg;
# define FMT_CATCH(x) if (false)
#endif
-#ifndef FMT_THROW
-# if FMT_EXCEPTIONS
-# define FMT_THROW(x) throw x
-# else
-# define FMT_THROW(x) assert(false)
-# endif
-#endif
-
#ifdef FMT_HEADER_ONLY
# define FMT_FUNC inline
#else
# define FMT_FUNC
#endif
-#if _MSC_VER
+#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4127) // conditional expression is constant
# pragma warning(disable: 4702) // unreachable code
@@ -96,10 +78,10 @@ using fmt::internal::Arg;
// Dummy implementations of strerror_r and strerror_s called if corresponding
// system functions are not available.
static inline fmt::internal::Null<> strerror_r(int, char *, ...) {
- return fmt::internal::Null<>();
+ return fmt::internal::Null<>();
}
static inline fmt::internal::Null<> strerror_s(char *, std::size_t, ...) {
- return fmt::internal::Null<>();
+ return fmt::internal::Null<>();
}
namespace fmt {
@@ -109,11 +91,11 @@ namespace {
# define FMT_SNPRINTF snprintf
#else // _MSC_VER
inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) {
- va_list args;
- va_start(args, format);
- int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
- va_end(args);
- return result;
+ va_list args;
+ va_start(args, format);
+ int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
+ va_end(args);
+ return result;
}
# define FMT_SNPRINTF fmt_snprintf
#endif // _MSC_VER
@@ -128,25 +110,30 @@ inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) {
// signed and unsigned integers.
template <bool IsSigned>
struct IntChecker {
- template <typename T>
- static bool fits_in_int(T value) {
- unsigned max = INT_MAX;
- return value <= max;
- }
- static bool fits_in_int(bool) { return true; }
+ template <typename T>
+ static bool fits_in_int(T value) {
+ unsigned max = INT_MAX;
+ return value <= max;
+ }
+ static bool fits_in_int(bool) {
+ return true;
+ }
};
template <>
struct IntChecker<true> {
- template <typename T>
- static bool fits_in_int(T value) {
- return value >= INT_MIN && value <= INT_MAX;
- }
+ template <typename T>
+ static bool fits_in_int(T value) {
+ return value >= INT_MIN && value <= INT_MAX;
+ }
+ static bool fits_in_int(int) {
+ return true;
+ }
};
const char RESET_COLOR[] = "\x1b[0m";
-typedef void (*FormatFunc)(fmt::Writer &, int, fmt::StringRef);
+typedef void(*FormatFunc)(fmt::Writer &, int, fmt::StringRef);
// Portable thread-safe version of strerror.
// Sets buffer to point to a string describing the error code.
@@ -158,410 +145,322 @@ typedef void (*FormatFunc)(fmt::Writer &, int, fmt::StringRef);
// other - failure
// Buffer should be at least of size 1.
int safe_strerror(
- int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT {
- FMT_ASSERT(buffer != 0 && buffer_size != 0, "invalid buffer");
-
- class StrError {
- private:
- int error_code_;
- char *&buffer_;
- std::size_t buffer_size_;
-
- // A noop assignment operator to avoid bogus warnings.
- void operator=(const StrError &) {}
-
- // Handle the result of XSI-compliant version of strerror_r.
- int handle(int result) {
- // glibc versions before 2.13 return result in errno.
- return result == -1 ? errno : result;
- }
+ int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT{
+ FMT_ASSERT(buffer != 0 && buffer_size != 0, "invalid buffer");
+
+ class StrError {
+ private:
+ int error_code_;
+ char *&buffer_;
+ std::size_t buffer_size_;
+
+ // A noop assignment operator to avoid bogus warnings.
+ void operator=(const StrError &) {}
+
+ // Handle the result of XSI-compliant version of strerror_r.
+ int handle(int result) {
+ // glibc versions before 2.13 return result in errno.
+ return result == -1 ? errno : result;
+ }
- // Handle the result of GNU-specific version of strerror_r.
- int handle(char *message) {
- // If the buffer is full then the message is probably truncated.
- if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
- return ERANGE;
- buffer_ = message;
- return 0;
- }
+ // Handle the result of GNU-specific version of strerror_r.
+ int handle(char *message) {
+ // If the buffer is full then the message is probably truncated.
+ if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
+ return ERANGE;
+ buffer_ = message;
+ return 0;
+ }
- // Handle the case when strerror_r is not available.
- int handle(fmt::internal::Null<>) {
- return fallback(strerror_s(buffer_, buffer_size_, error_code_));
- }
+ // Handle the case when strerror_r is not available.
+ int handle(fmt::internal::Null<>) {
+ return fallback(strerror_s(buffer_, buffer_size_, error_code_));
+ }
- // Fallback to strerror_s when strerror_r is not available.
- int fallback(int result) {
- // If the buffer is full then the message is probably truncated.
- return result == 0 && strlen(buffer_) == buffer_size_ - 1 ?
+ // Fallback to strerror_s when strerror_r is not available.
+ int fallback(int result) {
+ // If the buffer is full then the message is probably truncated.
+ return result == 0 && strlen(buffer_) == buffer_size_ - 1 ?
ERANGE : result;
- }
+ }
- // Fallback to strerror if strerror_r and strerror_s are not available.
- int fallback(fmt::internal::Null<>) {
- errno = 0;
- buffer_ = strerror(error_code_);
- return errno;
- }
+ // Fallback to strerror if strerror_r and strerror_s are not available.
+ int fallback(fmt::internal::Null<>) {
+ errno = 0;
+ buffer_ = strerror(error_code_);
+ return errno;
+ }
- public:
- StrError(int err_code, char *&buf, std::size_t buf_size)
- : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
+ public:
+ StrError(int err_code, char *&buf, std::size_t buf_size)
+ : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
- int run() {
- strerror_r(0, 0, ""); // Suppress a warning about unused strerror_r.
- return handle(strerror_r(error_code_, buffer_, buffer_size_));
- }
- };
- return StrError(error_code, buffer, buffer_size).run();
+ int run() {
+ strerror_r(0, 0, ""); // Suppress a warning about unused strerror_r.
+ return handle(strerror_r(error_code_, buffer_, buffer_size_));
+ }
+ };
+ return StrError(error_code, buffer, buffer_size).run();
}
void format_error_code(fmt::Writer &out, int error_code,
- fmt::StringRef message) FMT_NOEXCEPT {
- // Report error code making sure that the output fits into
- // INLINE_BUFFER_SIZE to avoid dynamic memory allocation and potential
- // bad_alloc.
- out.clear();
- static const char SEP[] = ": ";
- static const char ERROR_STR[] = "error ";
- fmt::internal::IntTraits<int>::MainType ec_value = error_code;
- // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
- std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
- error_code_size += fmt::internal::count_digits(ec_value);
- if (message.size() <= fmt::internal::INLINE_BUFFER_SIZE - error_code_size)
- out << message << SEP;
- out << ERROR_STR << error_code;
- assert(out.size() <= fmt::internal::INLINE_BUFFER_SIZE);
+ fmt::StringRef message) FMT_NOEXCEPT{
+ // Report error code making sure that the output fits into
+ // INLINE_BUFFER_SIZE to avoid dynamic memory allocation and potential
+ // bad_alloc.
+ out.clear();
+ static const char SEP[] = ": ";
+ static const char ERROR_STR[] = "error ";
+ fmt::internal::IntTraits<int>::MainType ec_value = error_code;
+ // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
+ std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
+ error_code_size += fmt::internal::count_digits(ec_value);
+ if (message.size() <= fmt::internal::INLINE_BUFFER_SIZE - error_code_size)
+ out << message << SEP;
+ out << ERROR_STR << error_code;
+ assert(out.size() <= fmt::internal::INLINE_BUFFER_SIZE);
}
void report_error(FormatFunc func,
- int error_code, fmt::StringRef message) FMT_NOEXCEPT {
- fmt::MemoryWriter full_message;
- func(full_message, error_code, message);
- // Use Writer::data instead of Writer::c_str to avoid potential memory
- // allocation.
- std::fwrite(full_message.data(), full_message.size(), 1, stderr);
- std::fputc('\n', stderr);
+ int error_code, fmt::StringRef message) FMT_NOEXCEPT{
+ fmt::MemoryWriter full_message;
+ func(full_message, error_code, message);
+ // Use Writer::data instead of Writer::c_str to avoid potential memory
+ // allocation.
+ std::fwrite(full_message.data(), full_message.size(), 1, stderr);
+ std::fputc('\n', stderr);
}
// IsZeroInt::visit(arg) returns true iff arg is a zero integer.
class IsZeroInt : public fmt::internal::ArgVisitor<IsZeroInt, bool> {
- public:
- template <typename T>
- bool visit_any_int(T value) { return value == 0; }
-};
-
-// Parses an unsigned integer advancing s to the end of the parsed input.
-// This function assumes that the first character of s is a digit.
-template <typename Char>
-int parse_nonnegative_int(const Char *&s) {
- assert('0' <= *s && *s <= '9');
- unsigned value = 0;
- do {
- unsigned new_value = value * 10 + (*s++ - '0');
- // Check if value wrapped around.
- if (new_value < value) {
- value = UINT_MAX;
- break;
+public:
+ template <typename T>
+ bool visit_any_int(T value) {
+ return value == 0;
}
- value = new_value;
- } while ('0' <= *s && *s <= '9');
- if (value > INT_MAX)
- FMT_THROW(fmt::FormatError("number is too big"));
- return value;
-}
-
-template <typename Char>
-inline bool is_name_start(Char c) {
- return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
-}
-
-inline void require_numeric_argument(const Arg &arg, char spec) {
- if (arg.type > Arg::LAST_NUMERIC_TYPE) {
- std::string message =
- fmt::format("format specifier '{}' requires numeric argument", spec);
- FMT_THROW(fmt::FormatError(message));
- }
-}
-
-template <typename Char>
-void check_sign(const Char *&s, const Arg &arg) {
- char sign = static_cast<char>(*s);
- require_numeric_argument(arg, sign);
- if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG) {
- FMT_THROW(fmt::FormatError(fmt::format(
- "format specifier '{}' requires signed argument", sign)));
- }
- ++s;
-}
+};
// Checks if an argument is a valid printf width specifier and sets
// left alignment if it is negative.
class WidthHandler : public fmt::internal::ArgVisitor<WidthHandler, unsigned> {
- private:
- fmt::FormatSpec &spec_;
+private:
+ fmt::FormatSpec &spec_;
- FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler);
+ FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler);
- public:
- explicit WidthHandler(fmt::FormatSpec &spec) : spec_(spec) {}
+public:
+ explicit WidthHandler(fmt::FormatSpec &spec) : spec_(spec) {}
- void report_unhandled_arg() {
- FMT_THROW(fmt::FormatError("width is not integer"));
- }
+ void report_unhandled_arg() {
+ FMT_THROW(fmt::FormatError("width is not integer"));
+ }
- template <typename T>
- unsigned visit_any_int(T value) {
- typedef typename fmt::internal::IntTraits<T>::MainType UnsignedType;
- UnsignedType width = value;
- if (fmt::internal::is_negative(value)) {
- spec_.align_ = fmt::ALIGN_LEFT;
- width = 0 - width;
+ template <typename T>
+ unsigned visit_any_int(T value) {
+ typedef typename fmt::internal::IntTraits<T>::MainType UnsignedType;
+ UnsignedType width = value;
+ if (fmt::internal::is_negative(value)) {
+ spec_.align_ = fmt::ALIGN_LEFT;
+ width = 0 - width;
+ }
+ if (width > INT_MAX)
+ FMT_THROW(fmt::FormatError("number is too big"));
+ return static_cast<unsigned>(width);
}
- if (width > INT_MAX)
- FMT_THROW(fmt::FormatError("number is too big"));
- return static_cast<unsigned>(width);
- }
};
class PrecisionHandler :
public fmt::internal::ArgVisitor<PrecisionHandler, int> {
- public:
- void report_unhandled_arg() {
- FMT_THROW(fmt::FormatError("precision is not integer"));
- }
-
- template <typename T>
- int visit_any_int(T value) {
- if (!IntChecker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
- FMT_THROW(fmt::FormatError("number is too big"));
- return static_cast<int>(value);
- }
+public:
+ void report_unhandled_arg() {
+ FMT_THROW(fmt::FormatError("precision is not integer"));
+ }
+
+ template <typename T>
+ int visit_any_int(T value) {
+ if (!IntChecker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
+ FMT_THROW(fmt::FormatError("number is too big"));
+ return static_cast<int>(value);
+ }
};
// Converts an integer argument to an integral type T for printf.
template <typename T>
class ArgConverter : public fmt::internal::ArgVisitor<ArgConverter<T>, void> {
- private:
- fmt::internal::Arg &arg_;
- wchar_t type_;
-
- FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter);
-
- public:
- ArgConverter(fmt::internal::Arg &arg, wchar_t type)
- : arg_(arg), type_(type) {}
-
- template <typename U>
- void visit_any_int(U value) {
- bool is_signed = type_ == 'd' || type_ == 'i';
- using fmt::internal::Arg;
- if (sizeof(T) <= sizeof(int)) {
- // Extra casts are used to silence warnings.
- if (is_signed) {
- arg_.type = Arg::INT;
- arg_.int_value = static_cast<int>(static_cast<T>(value));
- } else {
- arg_.type = Arg::UINT;
- arg_.uint_value = static_cast<unsigned>(
- static_cast<typename fmt::internal::MakeUnsigned<T>::Type>(value));
- }
- } else {
- if (is_signed) {
- arg_.type = Arg::LONG_LONG;
- arg_.long_long_value =
- static_cast<typename fmt::internal::MakeUnsigned<U>::Type>(value);
- } else {
- arg_.type = Arg::ULONG_LONG;
- arg_.ulong_long_value =
- static_cast<typename fmt::internal::MakeUnsigned<U>::Type>(value);
- }
+private:
+ fmt::internal::Arg &arg_;
+ wchar_t type_;
+
+ FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter);
+
+public:
+ ArgConverter(fmt::internal::Arg &arg, wchar_t type)
+ : arg_(arg), type_(type) {}
+
+ void visit_bool(bool value) {
+ if (type_ != 's')
+ visit_any_int(value);
+ }
+
+ template <typename U>
+ void visit_any_int(U value) {
+ bool is_signed = type_ == 'd' || type_ == 'i';
+ using fmt::internal::Arg;
+ if (sizeof(T) <= sizeof(int)) {
+ // Extra casts are used to silence warnings.
+ if (is_signed) {
+ arg_.type = Arg::INT;
+ arg_.int_value = static_cast<int>(static_cast<T>(value));
+ }
+ else {
+ arg_.type = Arg::UINT;
+ arg_.uint_value = static_cast<unsigned>(
+ static_cast<typename fmt::internal::MakeUnsigned<T>::Type>(value));
+ }
+ }
+ else {
+ if (is_signed) {
+ arg_.type = Arg::LONG_LONG;
+ arg_.long_long_value =
+ static_cast<typename fmt::internal::MakeUnsigned<U>::Type>(value);
+ }
+ else {
+ arg_.type = Arg::ULONG_LONG;
+ arg_.ulong_long_value =
+ static_cast<typename fmt::internal::MakeUnsigned<U>::Type>(value);
+ }
+ }
}
- }
};
// Converts an integer argument to char for printf.
class CharConverter : public fmt::internal::ArgVisitor<CharConverter, void> {
- private:
- fmt::internal::Arg &arg_;
+private:
+ fmt::internal::Arg &arg_;
- FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter);
+ FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter);
- public:
- explicit CharConverter(fmt::internal::Arg &arg) : arg_(arg) {}
+public:
+ explicit CharConverter(fmt::internal::Arg &arg) : arg_(arg) {}
- template <typename T>
- void visit_any_int(T value) {
- arg_.type = Arg::CHAR;
- arg_.int_value = static_cast<char>(value);
- }
+ template <typename T>
+ void visit_any_int(T value) {
+ arg_.type = Arg::CHAR;
+ arg_.int_value = static_cast<char>(value);
+ }
};
} // namespace
namespace internal {
-template <typename Impl, typename Char>
-class BasicArgFormatter : public ArgVisitor<Impl, void> {
- private:
- BasicWriter<Char> &writer_;
- FormatSpec &spec_;
-
- FMT_DISALLOW_COPY_AND_ASSIGN(BasicArgFormatter);
-
- protected:
- BasicWriter<Char> &writer() { return writer_; }
- const FormatSpec &spec() const { return spec_; }
-
- public:
- BasicArgFormatter(BasicWriter<Char> &w, FormatSpec &s)
- : writer_(w), spec_(s) {}
-
- template <typename T>
- void visit_any_int(T value) { writer_.write_int(value, spec_); }
-
- template <typename T>
- void visit_any_double(T value) { writer_.write_double(value, spec_); }
-
- void visit_bool(bool value) {
- if (spec_.type_) {
- writer_.write_int(value, spec_);
- return;
- }
- const char *str_value = value ? "true" : "false";
- Arg::StringValue<char> str = { str_value, strlen(str_value) };
- writer_.write_str(str, spec_);
- }
-
- void visit_char(int value) {
- if (spec_.type_ && spec_.type_ != 'c') {
- spec_.flags_ |= CHAR_FLAG;
- writer_.write_int(value, spec_);
- return;
+template <typename Char>
+class PrintfArgFormatter :
+ public ArgFormatterBase<PrintfArgFormatter<Char>, Char> {
+
+ void write_null_pointer() {
+ this->spec().type_ = 0;
+ this->write("(nil)");
+ }
+
+ typedef ArgFormatterBase<PrintfArgFormatter<Char>, Char> Base;
+
+public:
+ PrintfArgFormatter(BasicWriter<Char> &w, FormatSpec &s)
+ : ArgFormatterBase<PrintfArgFormatter<Char>, Char>(w, s) {}
+
+ void visit_bool(bool value) {
+ FormatSpec &fmt_spec = this->spec();
+ if (fmt_spec.type_ != 's')
+ return this->visit_any_int(value);
+ fmt_spec.type_ = 0;
+ this->write(value);
+ }
+
+ void visit_char(int value) {
+ const FormatSpec &fmt_spec = this->spec();
+ BasicWriter<Char> &w = this->writer();
+ if (fmt_spec.type_ && fmt_spec.type_ != 'c')
+ w.write_int(value, fmt_spec);
+ typedef typename BasicWriter<Char>::CharPtr CharPtr;
+ CharPtr out = CharPtr();
+ if (fmt_spec.width_ > 1) {
+ Char fill = ' ';
+ out = w.grow_buffer(fmt_spec.width_);
+ if (fmt_spec.align_ != ALIGN_LEFT) {
+ std::fill_n(out, fmt_spec.width_ - 1, fill);
+ out += fmt_spec.width_ - 1;
+ }
+ else {
+ std::fill_n(out + 1, fmt_spec.width_ - 1, fill);
+ }
+ }
+ else {
+ out = w.grow_buffer(1);
+ }
+ *out = static_cast<Char>(value);
}
- if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0)
- FMT_THROW(FormatError("invalid format specifier for char"));
- typedef typename BasicWriter<Char>::CharPtr CharPtr;
- Char fill = internal::CharTraits<Char>::cast(spec_.fill());
- CharPtr out = CharPtr();
- if (spec_.width_ > 1) {
- out = writer_.grow_buffer(spec_.width_);
- if (spec_.align_ == ALIGN_RIGHT) {
- std::fill_n(out, spec_.width_ - 1, fill);
- out += spec_.width_ - 1;
- } else if (spec_.align_ == ALIGN_CENTER) {
- out = writer_.fill_padding(out, spec_.width_, 1, fill);
- } else {
- std::fill_n(out + 1, spec_.width_ - 1, fill);
- }
- } else {
- out = writer_.grow_buffer(1);
+
+ void visit_cstring(const char *value) {
+ if (value)
+ Base::visit_cstring(value);
+ else if (this->spec().type_ == 'p')
+ write_null_pointer();
+ else
+ this->write("(null)");
}
- *out = internal::CharTraits<Char>::cast(value);
- }
-
- void visit_string(Arg::StringValue<char> value) {
- writer_.write_str(value, spec_);
- }
-
- using ArgVisitor<Impl, void>::visit_wstring;
-
- void visit_wstring(Arg::StringValue<Char> value) {
- writer_.write_str(value, spec_);
- }
-
- void visit_pointer(const void *value) {
- if (spec_.type_ && spec_.type_ != 'p')
- report_unknown_type(spec_.type_, "pointer");
- spec_.flags_ = HASH_FLAG;
- spec_.type_ = 'x';
- writer_.write_int(reinterpret_cast<uintptr_t>(value), spec_);
- }
-};
-// An argument formatter.
-template <typename Char>
-class ArgFormatter : public BasicArgFormatter<ArgFormatter<Char>, Char> {
- private:
- BasicFormatter<Char> &formatter_;
- const Char *format_;
-
- public:
- ArgFormatter(BasicFormatter<Char> &f, FormatSpec &s, const Char *fmt)
- : BasicArgFormatter<ArgFormatter<Char>, Char>(f.writer(), s),
- formatter_(f), format_(fmt) {}
-
- void visit_custom(Arg::CustomValue c) {
- c.format(&formatter_, c.value, &format_);
- }
-};
+ void visit_pointer(const void *value) {
+ if (value)
+ return Base::visit_pointer(value);
+ this->spec().type_ = 0;
+ write_null_pointer();
+ }
-template <typename Char>
-class PrintfArgFormatter :
- public BasicArgFormatter<PrintfArgFormatter<Char>, Char> {
- public:
- PrintfArgFormatter(BasicWriter<Char> &w, FormatSpec &s)
- : BasicArgFormatter<PrintfArgFormatter<Char>, Char>(w, s) {}
-
- void visit_char(int value) {
- const FormatSpec &fmt_spec = this->spec();
- BasicWriter<Char> &w = this->writer();
- if (fmt_spec.type_ && fmt_spec.type_ != 'c')
- w.write_int(value, fmt_spec);
- typedef typename BasicWriter<Char>::CharPtr CharPtr;
- CharPtr out = CharPtr();
- if (fmt_spec.width_ > 1) {
- Char fill = ' ';
- out = w.grow_buffer(fmt_spec.width_);
- if (fmt_spec.align_ != ALIGN_LEFT) {
- std::fill_n(out, fmt_spec.width_ - 1, fill);
- out += fmt_spec.width_ - 1;
- } else {
- std::fill_n(out + 1, fmt_spec.width_ - 1, fill);
- }
- } else {
- out = w.grow_buffer(1);
+ void visit_custom(Arg::CustomValue c) {
+ BasicFormatter<Char> formatter(ArgList(), this->writer());
+ const Char format_str[] = { '}', 0 };
+ const Char *format = format_str;
+ c.format(&formatter, c.value, &format);
}
- *out = static_cast<Char>(value);
- }
};
} // namespace internal
} // namespace fmt
FMT_FUNC void fmt::SystemError::init(
int err_code, CStringRef format_str, ArgList args) {
- error_code_ = err_code;
- MemoryWriter w;
- internal::format_system_error(w, err_code, format(format_str, args));
- std::runtime_error &base = *this;
- base = std::runtime_error(w.str());
+ error_code_ = err_code;
+ MemoryWriter w;
+ internal::format_system_error(w, err_code, format(format_str, args));
+ std::runtime_error &base = *this;
+ base = std::runtime_error(w.str());
}
template <typename T>
int fmt::internal::CharTraits<char>::format_float(
char *buffer, std::size_t size, const char *format,
unsigned width, int precision, T value) {
- if (width == 0) {
+ if (width == 0) {
+ return precision < 0 ?
+ FMT_SNPRINTF(buffer, size, format, value) :
+ FMT_SNPRINTF(buffer, size, format, precision, value);
+ }
return precision < 0 ?
- FMT_SNPRINTF(buffer, size, format, value) :
- FMT_SNPRINTF(buffer, size, format, precision, value);
- }
- return precision < 0 ?
- FMT_SNPRINTF(buffer, size, format, width, value) :
- FMT_SNPRINTF(buffer, size, format, width, precision, value);
+ FMT_SNPRINTF(buffer, size, format, width, value) :
+ FMT_SNPRINTF(buffer, size, format, width, precision, value);
}
template <typename T>
int fmt::internal::CharTraits<wchar_t>::format_float(
wchar_t *buffer, std::size_t size, const wchar_t *format,
unsigned width, int precision, T value) {
- if (width == 0) {
+ if (width == 0) {
+ return precision < 0 ?
+ FMT_SWPRINTF(buffer, size, format, value) :
+ FMT_SWPRINTF(buffer, size, format, precision, value);
+ }
return precision < 0 ?
- FMT_SWPRINTF(buffer, size, format, value) :
- FMT_SWPRINTF(buffer, size, format, precision, value);
- }
- return precision < 0 ?
- FMT_SWPRINTF(buffer, size, format, width, value) :
- FMT_SWPRINTF(buffer, size, format, width, precision, value);
+ FMT_SWPRINTF(buffer, size, format, width, value) :
+ FMT_SWPRINTF(buffer, size, format, width, precision, value);
}
template <typename T>
@@ -585,685 +484,424 @@ const char fmt::internal::BasicData<T>::DIGITS[] =
template <typename T>
const uint32_t fmt::internal::BasicData<T>::POWERS_OF_10_32[] = {
- 0, FMT_POWERS_OF_10(1)
+ 0, FMT_POWERS_OF_10(1)
};
template <typename T>
const uint64_t fmt::internal::BasicData<T>::POWERS_OF_10_64[] = {
- 0,
- FMT_POWERS_OF_10(1),
- FMT_POWERS_OF_10(fmt::ULongLong(1000000000)),
- // Multiply several constants instead of using a single long long constant
- // to avoid warnings about C++98 not supporting long long.
- fmt::ULongLong(1000000000) * fmt::ULongLong(1000000000) * 10
+ 0,
+ FMT_POWERS_OF_10(1),
+ FMT_POWERS_OF_10(fmt::ULongLong(1000000000)),
+ // Multiply several constants instead of using a single long long constant
+ // to avoid warnings about C++98 not supporting long long.
+ fmt::ULongLong(1000000000) * fmt::ULongLong(1000000000) * 10
};
FMT_FUNC void fmt::internal::report_unknown_type(char code, const char *type) {
- (void)type;
- if (std::isprint(static_cast<unsigned char>(code))) {
+ (void)type;
+ if (std::isprint(static_cast<unsigned char>(code))) {
+ FMT_THROW(fmt::FormatError(
+ fmt::format("unknown format code '{}' for {}", code, type)));
+ }
FMT_THROW(fmt::FormatError(
- fmt::format("unknown format code '{}' for {}", code, type)));
- }
- FMT_THROW(fmt::FormatError(
- fmt::format("unknown format code '\\x{:02x}' for {}",
- static_cast<unsigned>(code), type)));
+ fmt::format("unknown format code '\\x{:02x}' for {}",
+ static_cast<unsigned>(code), type)));
}
#if FMT_USE_WINDOWS_H
FMT_FUNC fmt::internal::UTF8ToUTF16::UTF8ToUTF16(fmt::StringRef s) {
- static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
- if (s.size() > INT_MAX)
- FMT_THROW(WindowsError(ERROR_INVALID_PARAMETER, ERROR_MSG));
- int s_size = static_cast<int>(s.size());
- int length = MultiByteToWideChar(
- CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, 0, 0);
- if (length == 0)
- FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
- buffer_.resize(length + 1);
- length = MultiByteToWideChar(
- CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length);
- if (length == 0)
- FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
- buffer_[length] = 0;
+ static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
+ if (s.size() > INT_MAX)
+ FMT_THROW(WindowsError(ERROR_INVALID_PARAMETER, ERROR_MSG));
+ int s_size = static_cast<int>(s.size());
+ int length = MultiByteToWideChar(
+ CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, 0, 0);
+ if (length == 0)
+ FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
+ buffer_.resize(length + 1);
+ length = MultiByteToWideChar(
+ CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length);
+ if (length == 0)
+ FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
+ buffer_[length] = 0;
}
FMT_FUNC fmt::internal::UTF16ToUTF8::UTF16ToUTF8(fmt::WStringRef s) {
- if (int error_code = convert(s)) {
- FMT_THROW(WindowsError(error_code,
- "cannot convert string from UTF-16 to UTF-8"));
- }
+ if (int error_code = convert(s)) {
+ FMT_THROW(WindowsError(error_code,
+ "cannot convert string from UTF-16 to UTF-8"));
+ }
}
FMT_FUNC int fmt::internal::UTF16ToUTF8::convert(fmt::WStringRef s) {
- if (s.size() > INT_MAX)
- return ERROR_INVALID_PARAMETER;
- int s_size = static_cast<int>(s.size());
- int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, 0, 0, 0, 0);
- if (length == 0)
- return GetLastError();
- buffer_.resize(length + 1);
- length = WideCharToMultiByte(
- CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, 0, 0);
- if (length == 0)
- return GetLastError();
- buffer_[length] = 0;
- return 0;
+ if (s.size() > INT_MAX)
+ return ERROR_INVALID_PARAMETER;
+ int s_size = static_cast<int>(s.size());
+ int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, 0, 0, 0, 0);
+ if (length == 0)
+ return GetLastError();
+ buffer_.resize(length + 1);
+ length = WideCharToMultiByte(
+ CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, 0, 0);
+ if (length == 0)
+ return GetLastError();
+ buffer_[length] = 0;
+ return 0;
}
FMT_FUNC void fmt::WindowsError::init(
int err_code, CStringRef format_str, ArgList args) {
- error_code_ = err_code;
- MemoryWriter w;
- internal::format_windows_error(w, err_code, format(format_str, args));
- std::runtime_error &base = *this;
- base = std::runtime_error(w.str());
+ error_code_ = err_code;
+ MemoryWriter w;
+ internal::format_windows_error(w, err_code, format(format_str, args));
+ std::runtime_error &base = *this;
+ base = std::runtime_error(w.str());
}
FMT_FUNC void fmt::internal::format_windows_error(
fmt::Writer &out, int error_code,
- fmt::StringRef message) FMT_NOEXCEPT {
- class String {
- private:
- LPWSTR str_;
-
- public:
- String() : str_() {}
- ~String() { LocalFree(str_); }
- LPWSTR *ptr() { return &str_; }
- LPCWSTR c_str() const { return str_; }
- };
- FMT_TRY {
- String system_message;
- if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+ fmt::StringRef message) FMT_NOEXCEPT{
+ class String {
+ private:
+ LPWSTR str_;
+
+ public:
+ String() : str_() {}
+ ~String() {
+ LocalFree(str_);
+ }
+ LPWSTR *ptr() {
+ return &str_;
+ }
+ LPCWSTR c_str() const { return str_; }
+ };
+ FMT_TRY{
+ String system_message;
+ if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0,
error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
reinterpret_cast<LPWSTR>(system_message.ptr()), 0, 0)) {
- UTF16ToUTF8 utf8_message;
- if (utf8_message.convert(system_message.c_str()) == ERROR_SUCCESS) {
- out << message << ": " << utf8_message;
- return;
- }
- }
- } FMT_CATCH(...) {}
- format_error_code(out, error_code, message);
+ UTF16ToUTF8 utf8_message;
+ if (utf8_message.convert(system_message.c_str()) == ERROR_SUCCESS) {
+ out << message << ": " << utf8_message;
+ return;
+ }
+ }
+ } FMT_CATCH(...) {}
+ fmt::format_error_code(out, error_code, message); // 'fmt::' is for bcc32.
}
#endif // FMT_USE_WINDOWS_H
FMT_FUNC void fmt::internal::format_system_error(
fmt::Writer &out, int error_code,
- fmt::StringRef message) FMT_NOEXCEPT {
- FMT_TRY {
- MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer;
- buffer.resize(INLINE_BUFFER_SIZE);
- for (;;) {
- char *system_message = &buffer[0];
- int result = safe_strerror(error_code, system_message, buffer.size());
- if (result == 0) {
- out << message << ": " << system_message;
- return;
- }
- if (result != ERANGE)
- break; // Can't get error message, report error code instead.
- buffer.resize(buffer.size() * 2);
- }
- } FMT_CATCH(...) {}
- format_error_code(out, error_code, message);
+ fmt::StringRef message) FMT_NOEXCEPT{
+ FMT_TRY{
+ MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer;
+ buffer.resize(INLINE_BUFFER_SIZE);
+ for (;;) {
+ char *system_message = &buffer[0];
+ int result = safe_strerror(error_code, system_message, buffer.size());
+ if (result == 0) {
+ out << message << ": " << system_message;
+ return;
+ }
+ if (result != ERANGE)
+ break; // Can't get error message, report error code instead.
+ buffer.resize(buffer.size() * 2);
+ }
+ } FMT_CATCH(...) {}
+ fmt::format_error_code(out, error_code, message); // 'fmt::' is for bcc32.
}
template <typename Char>
void fmt::internal::ArgMap<Char>::init(const ArgList &args) {
- if (!map_.empty())
- return;
- typedef internal::NamedArg<Char> NamedArg;
- const NamedArg *named_arg = 0;
- bool use_values =
- args.type(ArgList::MAX_PACKED_ARGS - 1) == internal::Arg::NONE;
- if (use_values) {
- for (unsigned i = 0;/*nothing*/; ++i) {
- internal::Arg::Type arg_type = args.type(i);
- switch (arg_type) {
- case internal::Arg::NONE:
+ if (!map_.empty())
+ return;
+ typedef internal::NamedArg<Char> NamedArg;
+ const NamedArg *named_arg = 0;
+ bool use_values =
+ args.type(ArgList::MAX_PACKED_ARGS - 1) == internal::Arg::NONE;
+ if (use_values) {
+ for (unsigned i = 0;/*nothing*/; ++i) {
+ internal::Arg::Type arg_type = args.type(i);
+ switch (arg_type) {
+ case internal::Arg::NONE:
+ return;
+ case internal::Arg::NAMED_ARG:
+ named_arg = static_cast<const NamedArg*>(args.values_[i].pointer);
+ map_.insert(Pair(named_arg->name, *named_arg));
+ break;
+ default:
+ /*nothing*/
+ ;
+ }
+ }
return;
- case internal::Arg::NAMED_ARG:
- named_arg = static_cast<const NamedArg*>(args.values_[i].pointer);
- map_.insert(Pair(named_arg->name, *named_arg));
- break;
- default:
- /*nothing*/;
- }
}
- return;
- }
- for (unsigned i = 0; i != ArgList::MAX_PACKED_ARGS; ++i) {
- internal::Arg::Type arg_type = args.type(i);
- if (arg_type == internal::Arg::NAMED_ARG) {
- named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);
- map_.insert(Pair(named_arg->name, *named_arg));
+ for (unsigned i = 0; i != ArgList::MAX_PACKED_ARGS; ++i) {
+ internal::Arg::Type arg_type = args.type(i);
+ if (arg_type == internal::Arg::NAMED_ARG) {
+ named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);
+ map_.insert(Pair(named_arg->name, *named_arg));
+ }
}
- }
- for (unsigned i = ArgList::MAX_PACKED_ARGS;/*nothing*/; ++i) {
- switch (args.args_[i].type) {
- case internal::Arg::NONE:
- return;
- case internal::Arg::NAMED_ARG:
- named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);
- map_.insert(Pair(named_arg->name, *named_arg));
- break;
- default:
- /*nothing*/;
+ for (unsigned i = ArgList::MAX_PACKED_ARGS;/*nothing*/; ++i) {
+ switch (args.args_[i].type) {
+ case internal::Arg::NONE:
+ return;
+ case internal::Arg::NAMED_ARG:
+ named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);
+ map_.insert(Pair(named_arg->name, *named_arg));
+ break;
+ default:
+ /*nothing*/
+ ;
+ }
}
- }
}
template <typename Char>
void fmt::internal::FixedBuffer<Char>::grow(std::size_t) {
- FMT_THROW(std::runtime_error("buffer overflow"));
-}
-
-template <typename Char>
-template <typename StrChar>
-void fmt::BasicWriter<Char>::write_str(
- const Arg::StringValue<StrChar> &s, const FormatSpec &spec) {
- // Check if StrChar is convertible to Char.
- internal::CharTraits<Char>::convert(StrChar());
- if (spec.type_ && spec.type_ != 's')
- internal::report_unknown_type(spec.type_, "string");
- const StrChar *str_value = s.value;
- std::size_t str_size = s.size;
- if (str_size == 0) {
- if (!str_value)
- FMT_THROW(FormatError("string pointer is null"));
- if (*str_value)
- str_size = std::char_traits<StrChar>::length(str_value);
- }
- std::size_t precision = spec.precision_;
- if (spec.precision_ >= 0 && precision < str_size)
- str_size = spec.precision_;
- write_str(str_value, str_size, spec);
-}
-
-template <typename Char>
-inline Arg fmt::BasicFormatter<Char>::get_arg(
- BasicStringRef<Char> arg_name, const char *&error) {
- if (check_no_auto_index(error)) {
- map_.init(args());
- const Arg *arg = map_.find(arg_name);
- if (arg)
- return *arg;
- error = "argument not found";
- }
- return Arg();
-}
-
-template <typename Char>
-inline Arg fmt::BasicFormatter<Char>::parse_arg_index(const Char *&s) {
- const char *error = 0;
- Arg arg = *s < '0' || *s > '9' ?
- next_arg(error) : get_arg(parse_nonnegative_int(s), error);
- if (error) {
- FMT_THROW(FormatError(
- *s != '}' && *s != ':' ? "invalid format string" : error));
- }
- return arg;
-}
-
-template <typename Char>
-inline Arg fmt::BasicFormatter<Char>::parse_arg_name(const Char *&s) {
- assert(is_name_start(*s));
- const Char *start = s;
- Char c;
- do {
- c = *++s;
- } while (is_name_start(c) || ('0' <= c && c <= '9'));
- const char *error = 0;
- Arg arg = get_arg(fmt::BasicStringRef<Char>(start, s - start), error);
- if (error)
- FMT_THROW(fmt::FormatError(error));
- return arg;
+ FMT_THROW(std::runtime_error("buffer overflow"));
}
FMT_FUNC Arg fmt::internal::FormatterBase::do_get_arg(
unsigned arg_index, const char *&error) {
- Arg arg = args_[arg_index];
- switch (arg.type) {
- case Arg::NONE:
- error = "argument index out of range";
- break;
- case Arg::NAMED_ARG:
- arg = *static_cast<const internal::Arg*>(arg.pointer);
- default:
- /*nothing*/;
- }
- return arg;
-}
-
-inline Arg fmt::internal::FormatterBase::next_arg(const char *&error) {
- if (next_arg_index_ >= 0)
- return do_get_arg(next_arg_index_++, error);
- error = "cannot switch from manual to automatic argument indexing";
- return Arg();
-}
-
-inline bool fmt::internal::FormatterBase::check_no_auto_index(
- const char *&error) {
- if (next_arg_index_ > 0) {
- error = "cannot switch from automatic to manual argument indexing";
- return false;
- }
- next_arg_index_ = -1;
- return true;
-}
-
-inline Arg fmt::internal::FormatterBase::get_arg(
- unsigned arg_index, const char *&error) {
- return check_no_auto_index(error) ? do_get_arg(arg_index, error) : Arg();
+ Arg arg = args_[arg_index];
+ switch (arg.type) {
+ case Arg::NONE:
+ error = "argument index out of range";
+ break;
+ case Arg::NAMED_ARG:
+ arg = *static_cast<const internal::Arg*>(arg.pointer);
+ default:
+ /*nothing*/
+ ;
+ }
+ return arg;
}
template <typename Char>
void fmt::internal::PrintfFormatter<Char>::parse_flags(
FormatSpec &spec, const Char *&s) {
- for (;;) {
- switch (*s++) {
- case '-':
- spec.align_ = ALIGN_LEFT;
- break;
- case '+':
- spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
- break;
- case '0':
- spec.fill_ = '0';
- break;
- case ' ':
- spec.flags_ |= SIGN_FLAG;
- break;
- case '#':
- spec.flags_ |= HASH_FLAG;
- break;
- default:
- --s;
- return;
+ for (;;) {
+ switch (*s++) {
+ case '-':
+ spec.align_ = ALIGN_LEFT;
+ break;
+ case '+':
+ spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
+ break;
+ case '0':
+ spec.fill_ = '0';
+ break;
+ case ' ':
+ spec.flags_ |= SIGN_FLAG;
+ break;
+ case '#':
+ spec.flags_ |= HASH_FLAG;
+ break;
+ default:
+ --s;
+ return;
+ }
}
- }
}
template <typename Char>
Arg fmt::internal::PrintfFormatter<Char>::get_arg(
const Char *s, unsigned arg_index) {
- (void)s;
- const char *error = 0;
- Arg arg = arg_index == UINT_MAX ?
- next_arg(error) : FormatterBase::get_arg(arg_index - 1, error);
- if (error)
- FMT_THROW(FormatError(!*s ? "invalid format string" : error));
- return arg;
+ (void)s;
+ const char *error = 0;
+ Arg arg = arg_index == UINT_MAX ?
+ next_arg(error) : FormatterBase::get_arg(arg_index - 1, error);
+ if (error)
+ FMT_THROW(FormatError(!*s ? "invalid format string" : error));
+ return arg;
}
template <typename Char>
unsigned fmt::internal::PrintfFormatter<Char>::parse_header(
- const Char *&s, FormatSpec &spec) {
- unsigned arg_index = UINT_MAX;
- Char c = *s;
- if (c >= '0' && c <= '9') {
- // Parse an argument index (if followed by '$') or a width possibly
- // preceded with '0' flag(s).
- unsigned value = parse_nonnegative_int(s);
- if (*s == '$') { // value is an argument index
- ++s;
- arg_index = value;
- } else {
- if (c == '0')
- spec.fill_ = '0';
- if (value != 0) {
- // Nonzero value means that we parsed width and don't need to
- // parse it or flags again, so return now.
- spec.width_ = value;
- return arg_index;
- }
+ const Char *&s, FormatSpec &spec) {
+ unsigned arg_index = UINT_MAX;
+ Char c = *s;
+ if (c >= '0' && c <= '9') {
+ // Parse an argument index (if followed by '$') or a width possibly
+ // preceded with '0' flag(s).
+ unsigned value = parse_nonnegative_int(s);
+ if (*s == '$') { // value is an argument index
+ ++s;
+ arg_index = value;
+ }
+ else {
+ if (c == '0')
+ spec.fill_ = '0';
+ if (value != 0) {
+ // Nonzero value means that we parsed width and don't need to
+ // parse it or flags again, so return now.
+ spec.width_ = value;
+ return arg_index;
+ }
+ }
}
- }
- parse_flags(spec, s);
- // Parse width.
- if (*s >= '0' && *s <= '9') {
- spec.width_ = parse_nonnegative_int(s);
- } else if (*s == '*') {
- ++s;
- spec.width_ = WidthHandler(spec).visit(get_arg(s));
- }
- return arg_index;
-}
-
-template <typename Char>
-void fmt::internal::PrintfFormatter<Char>::format(
- BasicWriter<Char> &writer, BasicCStringRef<Char> format_str) {
- const Char *start = format_str.c_str();
- const Char *s = start;
- while (*s) {
- Char c = *s++;
- if (c != '%') continue;
- if (*s == c) {
- write(writer, start, s);
- start = ++s;
- continue;
+ parse_flags(spec, s);
+ // Parse width.
+ if (*s >= '0' && *s <= '9') {
+ spec.width_ = parse_nonnegative_int(s);
}
- write(writer, start, s - 1);
-
- FormatSpec spec;
- spec.align_ = ALIGN_RIGHT;
-
- // Parse argument index, flags and width.
- unsigned arg_index = parse_header(s, spec);
-
- // Parse precision.
- if (*s == '.') {
- ++s;
- if ('0' <= *s && *s <= '9') {
- spec.precision_ = parse_nonnegative_int(s);
- } else if (*s == '*') {
+ else if (*s == '*') {
++s;
- spec.precision_ = PrecisionHandler().visit(get_arg(s));
- }
- }
-
- Arg arg = get_arg(s, arg_index);
- if (spec.flag(HASH_FLAG) && IsZeroInt().visit(arg))
- spec.flags_ &= ~HASH_FLAG;
- if (spec.fill_ == '0') {
- if (arg.type <= Arg::LAST_NUMERIC_TYPE)
- spec.align_ = ALIGN_NUMERIC;
- else
- spec.fill_ = ' '; // Ignore '0' flag for non-numeric types.
+ spec.width_ = WidthHandler(spec).visit(get_arg(s));
}
-
- // Parse length and convert the argument to the required type.
- switch (*s++) {
- case 'h':
- if (*s == 'h')
- ArgConverter<signed char>(arg, *++s).visit(arg);
- else
- ArgConverter<short>(arg, *s).visit(arg);
- break;
- case 'l':
- if (*s == 'l')
- ArgConverter<fmt::LongLong>(arg, *++s).visit(arg);
- else
- ArgConverter<long>(arg, *s).visit(arg);
- break;
- case 'j':
- ArgConverter<intmax_t>(arg, *s).visit(arg);
- break;
- case 'z':
- ArgConverter<size_t>(arg, *s).visit(arg);
- break;
- case 't':
- ArgConverter<ptrdiff_t>(arg, *s).visit(arg);
- break;
- case 'L':
- // printf produces garbage when 'L' is omitted for long double, no
- // need to do the same.
- break;
- default:
- --s;
- ArgConverter<int>(arg, *s).visit(arg);
- }
-
- // Parse type.
- if (!*s)
- FMT_THROW(FormatError("invalid format string"));
- spec.type_ = static_cast<char>(*s++);
- if (arg.type <= Arg::LAST_INTEGER_TYPE) {
- // Normalize type.
- switch (spec.type_) {
- case 'i': case 'u':
- spec.type_ = 'd';
- break;
- case 'c':
- // TODO: handle wchar_t
- CharConverter(arg).visit(arg);
- break;
- }
- }
-
- start = s;
-
- // Format argument.
- internal::PrintfArgFormatter<Char>(writer, spec).visit(arg);
- }
- write(writer, start, s);
+ return arg_index;
}
template <typename Char>
-const Char *fmt::BasicFormatter<Char>::format(
- const Char *&format_str, const Arg &arg) {
- const Char *s = format_str;
- FormatSpec spec;
- if (*s == ':') {
- if (arg.type == Arg::CUSTOM) {
- arg.custom.format(this, arg.custom.value, &s);
- return s;
- }
- ++s;
- // Parse fill and alignment.
- if (Char c = *s) {
- const Char *p = s + 1;
- spec.align_ = ALIGN_DEFAULT;
- do {
- switch (*p) {
- case '<':
- spec.align_ = ALIGN_LEFT;
- break;
- case '>':
- spec.align_ = ALIGN_RIGHT;
- break;
- case '=':
- spec.align_ = ALIGN_NUMERIC;
- break;
- case '^':
- spec.align_ = ALIGN_CENTER;
- break;
+void fmt::internal::PrintfFormatter<Char>::format(
+ BasicWriter<Char> &writer, BasicCStringRef<Char> format_str) {
+ const Char *start = format_str.c_str();
+ const Char *s = start;
+ while (*s) {
+ Char c = *s++;
+ if (c != '%') continue;
+ if (*s == c) {
+ write(writer, start, s);
+ start = ++s;
+ continue;
}
- if (spec.align_ != ALIGN_DEFAULT) {
- if (p != s) {
- if (c == '}') break;
- if (c == '{')
- FMT_THROW(FormatError("invalid fill character '{'"));
- s += 2;
- spec.fill_ = c;
- } else ++s;
- if (spec.align_ == ALIGN_NUMERIC)
- require_numeric_argument(arg, '=');
- break;
+ write(writer, start, s - 1);
+
+ FormatSpec spec;
+ spec.align_ = ALIGN_RIGHT;
+
+ // Parse argument index, flags and width.
+ unsigned arg_index = parse_header(s, spec);
+
+ // Parse precision.
+ if (*s == '.') {
+ ++s;
+ if ('0' <= *s && *s <= '9') {
+ spec.precision_ = parse_nonnegative_int(s);
+ }
+ else if (*s == '*') {
+ ++s;
+ spec.precision_ = PrecisionHandler().visit(get_arg(s));
+ }
}
- } while (--p >= s);
- }
- // Parse sign.
- switch (*s) {
- case '+':
- check_sign(s, arg);
- spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
- break;
- case '-':
- check_sign(s, arg);
- spec.flags_ |= MINUS_FLAG;
- break;
- case ' ':
- check_sign(s, arg);
- spec.flags_ |= SIGN_FLAG;
- break;
- }
-
- if (*s == '#') {
- require_numeric_argument(arg, '#');
- spec.flags_ |= HASH_FLAG;
- ++s;
- }
-
- // Parse zero flag.
- if (*s == '0') {
- require_numeric_argument(arg, '0');
- spec.align_ = ALIGN_NUMERIC;
- spec.fill_ = '0';
- ++s;
- }
-
- // Parse width.
- if ('0' <= *s && *s <= '9') {
- spec.width_ = parse_nonnegative_int(s);
- } else if (*s == '{') {
- ++s;
- Arg width_arg = is_name_start(*s) ?
- parse_arg_name(s) : parse_arg_index(s);
- if (*s++ != '}')
- FMT_THROW(FormatError("invalid format string"));
- ULongLong value = 0;
- switch (width_arg.type) {
- case Arg::INT:
- if (width_arg.int_value < 0)
- FMT_THROW(FormatError("negative width"));
- value = width_arg.int_value;
- break;
- case Arg::UINT:
- value = width_arg.uint_value;
- break;
- case Arg::LONG_LONG:
- if (width_arg.long_long_value < 0)
- FMT_THROW(FormatError("negative width"));
- value = width_arg.long_long_value;
- break;
- case Arg::ULONG_LONG:
- value = width_arg.ulong_long_value;
- break;
- default:
- FMT_THROW(FormatError("width is not integer"));
- }
- if (value > INT_MAX)
- FMT_THROW(FormatError("number is too big"));
- spec.width_ = static_cast<int>(value);
- }
+ Arg arg = get_arg(s, arg_index);
+ if (spec.flag(HASH_FLAG) && IsZeroInt().visit(arg))
+ spec.flags_ &= ~HASH_FLAG;
+ if (spec.fill_ == '0') {
+ if (arg.type <= Arg::LAST_NUMERIC_TYPE)
+ spec.align_ = ALIGN_NUMERIC;
+ else
+ spec.fill_ = ' '; // Ignore '0' flag for non-numeric types.
+ }
- // Parse precision.
- if (*s == '.') {
- ++s;
- spec.precision_ = 0;
- if ('0' <= *s && *s <= '9') {
- spec.precision_ = parse_nonnegative_int(s);
- } else if (*s == '{') {
- ++s;
- Arg precision_arg =
- is_name_start(*s) ? parse_arg_name(s) : parse_arg_index(s);
- if (*s++ != '}')
- FMT_THROW(FormatError("invalid format string"));
- ULongLong value = 0;
- switch (precision_arg.type) {
- case Arg::INT:
- if (precision_arg.int_value < 0)
- FMT_THROW(FormatError("negative precision"));
- value = precision_arg.int_value;
+ // Parse length and convert the argument to the required type.
+ switch (*s++) {
+ case 'h':
+ if (*s == 'h')
+ ArgConverter<signed char>(arg, *++s).visit(arg);
+ else
+ ArgConverter<short>(arg, *s).visit(arg);
+ break;
+ case 'l':
+ if (*s == 'l')
+ ArgConverter<fmt::LongLong>(arg, *++s).visit(arg);
+ else
+ ArgConverter<long>(arg, *s).visit(arg);
+ break;
+ case 'j':
+ ArgConverter<intmax_t>(arg, *s).visit(arg);
break;
- case Arg::UINT:
- value = precision_arg.uint_value;
+ case 'z':
+ ArgConverter<std::size_t>(arg, *s).visit(arg);
break;
- case Arg::LONG_LONG:
- if (precision_arg.long_long_value < 0)
- FMT_THROW(FormatError("negative precision"));
- value = precision_arg.long_long_value;
+ case 't':
+ ArgConverter<std::ptrdiff_t>(arg, *s).visit(arg);
break;
- case Arg::ULONG_LONG:
- value = precision_arg.ulong_long_value;
+ case 'L':
+ // printf produces garbage when 'L' is omitted for long double, no
+ // need to do the same.
break;
- default:
- FMT_THROW(FormatError("precision is not integer"));
+ default:
+ --s;
+ ArgConverter<int>(arg, *s).visit(arg);
}
- if (value > INT_MAX)
- FMT_THROW(FormatError("number is too big"));
- spec.precision_ = static_cast<int>(value);
- } else {
- FMT_THROW(FormatError("missing precision specifier"));
- }
- if (arg.type <= Arg::LAST_INTEGER_TYPE || arg.type == Arg::POINTER) {
- FMT_THROW(FormatError(
- fmt::format("precision not allowed in {} format specifier",
- arg.type == Arg::POINTER ? "pointer" : "integer")));
- }
- }
-
- // Parse type.
- if (*s != '}' && *s)
- spec.type_ = static_cast<char>(*s++);
- }
- if (*s++ != '}')
- FMT_THROW(FormatError("missing '}' in format string"));
+ // Parse type.
+ if (!*s)
+ FMT_THROW(FormatError("invalid format string"));
+ spec.type_ = static_cast<char>(*s++);
+ if (arg.type <= Arg::LAST_INTEGER_TYPE) {
+ // Normalize type.
+ switch (spec.type_) {
+ case 'i':
+ case 'u':
+ spec.type_ = 'd';
+ break;
+ case 'c':
+ // TODO: handle wchar_t
+ CharConverter(arg).visit(arg);
+ break;
+ }
+ }
- // Format argument.
- internal::ArgFormatter<Char>(*this, spec, s - 1).visit(arg);
- return s;
-}
+ start = s;
-template <typename Char>
-void fmt::BasicFormatter<Char>::format(BasicCStringRef<Char> format_str) {
- const Char *s = format_str.c_str();
- const Char *start = s;
- while (*s) {
- Char c = *s++;
- if (c != '{' && c != '}') continue;
- if (*s == c) {
- write(writer_, start, s);
- start = ++s;
- continue;
+ // Format argument.
+ internal::PrintfArgFormatter<Char>(writer, spec).visit(arg);
}
- if (c == '}')
- FMT_THROW(FormatError("unmatched '}' in format string"));
- write(writer_, start, s - 1);
- Arg arg = is_name_start(*s) ? parse_arg_name(s) : parse_arg_index(s);
- start = s = format(s, arg);
- }
- write(writer_, start, s);
+ write(writer, start, s);
}
FMT_FUNC void fmt::report_system_error(
- int error_code, fmt::StringRef message) FMT_NOEXCEPT {
- report_error(internal::format_system_error, error_code, message);
+ int error_code, fmt::StringRef message) FMT_NOEXCEPT{
+ // 'fmt::' is for bcc32.
+ fmt::report_error(internal::format_system_error, error_code, message);
}
#if FMT_USE_WINDOWS_H
FMT_FUNC void fmt::report_windows_error(
- int error_code, fmt::StringRef message) FMT_NOEXCEPT {
- report_error(internal::format_windows_error, error_code, message);
+ int error_code, fmt::StringRef message) FMT_NOEXCEPT{
+ // 'fmt::' is for bcc32.
+ fmt::report_error(internal::format_windows_error, error_code, message);
}
#endif
FMT_FUNC void fmt::print(std::FILE *f, CStringRef format_str, ArgList args) {
- MemoryWriter w;
- w.write(format_str, args);
- std::fwrite(w.data(), 1, w.size(), f);
+ MemoryWriter w;
+ w.write(format_str, args);
+ std::fwrite(w.data(), 1, w.size(), f);
}
FMT_FUNC void fmt::print(CStringRef format_str, ArgList args) {
- print(stdout, format_str, args);
+ print(stdout, format_str, args);
}
FMT_FUNC void fmt::print(std::ostream &os, CStringRef format_str, ArgList args) {
- MemoryWriter w;
- w.write(format_str, args);
- os.write(w.data(), w.size());
+ MemoryWriter w;
+ w.write(format_str, args);
+ os.write(w.data(), w.size());
}
FMT_FUNC void fmt::print_colored(Color c, CStringRef format, ArgList args) {
- char escape[] = "\x1b[30m";
- escape[3] = '0' + static_cast<char>(c);
- std::fputs(escape, stdout);
- print(format, args);
- std::fputs(RESET_COLOR, stdout);
+ char escape[] = "\x1b[30m";
+ escape[3] = static_cast<char>('0' + c);
+ std::fputs(escape, stdout);
+ print(format, args);
+ std::fputs(RESET_COLOR, stdout);
}
FMT_FUNC int fmt::fprintf(std::FILE *f, CStringRef format, ArgList args) {
- MemoryWriter w;
- printf(w, format, args);
- std::size_t size = w.size();
- return std::fwrite(w.data(), 1, size, f) < size ? -1 : static_cast<int>(size);
+ MemoryWriter w;
+ printf(w, format, args);
+ std::size_t size = w.size();
+ return std::fwrite(w.data(), 1, size, f) < size ? -1 : static_cast<int>(size);
}
#ifndef FMT_HEADER_ONLY
@@ -1274,13 +912,10 @@ template struct fmt::internal::BasicData<void>;
template void fmt::internal::FixedBuffer<char>::grow(std::size_t);
-template const char *fmt::BasicFormatter<char>::format(
- const char *&format_str, const fmt::internal::Arg &arg);
-
-template void fmt::BasicFormatter<char>::format(CStringRef format);
+template void fmt::internal::ArgMap<char>::init(const fmt::ArgList &args);
template void fmt::internal::PrintfFormatter<char>::format(
- BasicWriter<char> &writer, CStringRef format);
+ BasicWriter<char> &writer, CStringRef format);
template int fmt::internal::CharTraits<char>::format_float(
char *buffer, std::size_t size, const char *format,
@@ -1294,11 +929,7 @@ template int fmt::internal::CharTraits<char>::format_float(
template void fmt::internal::FixedBuffer<wchar_t>::grow(std::size_t);
-template const wchar_t *fmt::BasicFormatter<wchar_t>::format(
- const wchar_t *&format_str, const fmt::internal::Arg &arg);
-
-template void fmt::BasicFormatter<wchar_t>::format(
- BasicCStringRef<wchar_t> format);
+template void fmt::internal::ArgMap<wchar_t>::init(const fmt::ArgList &args);
template void fmt::internal::PrintfFormatter<wchar_t>::format(
BasicWriter<wchar_t> &writer, WCStringRef format);
@@ -1313,6 +944,6 @@ template int fmt::internal::CharTraits<wchar_t>::format_float(
#endif // FMT_HEADER_ONLY
-#if _MSC_VER
+#ifdef _MSC_VER
# pragma warning(pop)
#endif
\ No newline at end of file
diff --git a/include/spdlog/details/format.h b/include/spdlog/details/format.h
index 8e55b29..2e98d67 100644
--- a/include/spdlog/details/format.h
+++ b/include/spdlog/details/format.h
@@ -1,61 +1,101 @@
/*
- Formatting library for C++
-
- Copyright (c) 2012 - 2015, Victor Zverovich
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice, this
- list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright notice,
- this list of conditions and the following disclaimer in the documentation
- and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+Formatting library for C++
+
+Copyright (c) 2012 - 2015, Victor Zverovich
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
#ifndef FMT_FORMAT_H_
#define FMT_FORMAT_H_
+
+//Added to spdlog version for header only usage
#define FMT_HEADER_ONLY
+//Added to spdlog version in order to avoid including windows.h
+#if !defined (FMT_USE_WINDOWS_H)
+#define FMT_USE_WINDOWS_H 0
+#endif
+
+#if defined _MSC_VER && _MSC_VER <= 1500
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+typedef long long intmax_t;
+#else
#include <stdint.h>
+#endif
#include <cassert>
#include <cmath>
-#include <cstddef> // for std::ptrdiff_t
#include <cstdio>
-#include <algorithm>
+#include <cstring>
#include <limits>
+#include <memory>
#include <stdexcept>
#include <string>
-#include <sstream>
#include <map>
-#if _SECURE_SCL
+#ifndef FMT_USE_IOSTREAMS
+# define FMT_USE_IOSTREAMS 1
+#endif
+
+#if FMT_USE_IOSTREAMS
+# include <ostream>
+#endif
+
+#ifdef _SECURE_SCL
+# define FMT_SECURE_SCL _SECURE_SCL
+#else
+# define FMT_SECURE_SCL 0
+#endif
+
+#if FMT_SECURE_SCL
# include <iterator>
#endif
+#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
+# ifdef FMT_EXPORT
+# define FMT_API __declspec(dllexport)
+# elif defined(FMT_SHARED)
+# define FMT_API __declspec(dllimport)
+# endif
+#endif
+#ifndef FMT_API
+# define FMT_API
+#endif
+
#ifdef _MSC_VER
# include <intrin.h> // _BitScanReverse, _BitScanReverse64
-namespace fmt {
-namespace internal {
+namespace fmt
+{
+namespace internal
+{
# pragma intrinsic(_BitScanReverse)
-inline uint32_t clz(uint32_t x) {
- unsigned long r = 0;
- _BitScanReverse(&r, x);
- return 31 - r;
+inline uint32_t clz(uint32_t x)
+{
+ unsigned long r = 0;
+ _BitScanReverse(&r, x);
+ return 31 - r;
}
# define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n)
@@ -63,19 +103,20 @@ inline uint32_t clz(uint32_t x) {
# pragma intrinsic(_BitScanReverse64)
# endif
-inline uint32_t clzll(uint64_t x) {
- unsigned long r = 0;
+inline uint32_t clzll(uint64_t x)
+{
+ unsigned long r = 0;
# ifdef _WIN64
- _BitScanReverse64(&r, x);
+ _BitScanReverse64(&r, x);
# else
- // Scan the high 32 bits.
- if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
- return 63 - (r + 32);
+ // Scan the high 32 bits.
+ if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
+ return 63 - (r + 32);
- // Scan the low 32 bits.
- _BitScanReverse(&r, static_cast<uint32_t>(x));
+ // Scan the low 32 bits.
+ _BitScanReverse(&r, static_cast<uint32_t>(x));
# endif
- return 63 - r;
+ return 63 - r;
}
# define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n)
}
@@ -93,6 +134,9 @@ inline uint32_t clzll(uint64_t x) {
// Disable the warning about declaration shadowing because it affects too
// many valid cases.
# pragma GCC diagnostic ignored "-Wshadow"
+// Disable the warning about implicit conversions that may change the sign of
+// an integer; silencing it otherwise would require many explicit casts.
+# pragma GCC diagnostic ignored "-Wsign-conversion"
# endif
# if __cplusplus >= 201103L || defined __GXX_EXPERIMENTAL_CXX0X__
# define FMT_HAS_GXX_CXX11 1
@@ -101,7 +145,7 @@ inline uint32_t clzll(uint64_t x) {
# define FMT_GCC_EXTENSION
#endif
-#ifdef __clang__
+#if defined(__clang__) && !defined(__INTEL_COMPILER)
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wdocumentation"
#endif
@@ -154,17 +198,45 @@ inline uint32_t clzll(uint64_t x) {
#endif
// Define FMT_USE_NOEXCEPT to make C++ Format use noexcept (C++11 feature).
+#ifndef FMT_USE_NOEXCEPT
+# define FMT_USE_NOEXCEPT 0
+#endif
+
#ifndef FMT_NOEXCEPT
# if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
- (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11)
+ (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \
+ _MSC_VER >= 1900
# define FMT_NOEXCEPT noexcept
# else
# define FMT_NOEXCEPT throw()
# endif
#endif
+// Check if exceptions are disabled.
+#if defined(__GNUC__) && !defined(__EXCEPTIONS)
+# define FMT_EXCEPTIONS 0
+#endif
+#if defined(_MSC_VER) && !_HAS_EXCEPTIONS
+# define FMT_EXCEPTIONS 0
+#endif
+#ifndef FMT_EXCEPTIONS
+# define FMT_EXCEPTIONS 1
+#endif
+
+#ifndef FMT_THROW
+# if FMT_EXCEPTIONS
+# define FMT_THROW(x) throw x
+# else
+# define FMT_THROW(x) assert(false)
+# endif
+#endif
+
// A macro to disallow the copy constructor and operator= functions
// This should be used in the private: declarations for a class
+#ifndef FMT_USE_DELETED_FUNCTIONS
+# define FMT_USE_DELETED_FUNCTIONS 0
+#endif
+
#if FMT_USE_DELETED_FUNCTIONS || FMT_HAS_FEATURE(cxx_deleted_functions) || \
(FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1800
# define FMT_DELETED_OR_UNDEFINED = delete
@@ -178,11 +250,128 @@ inline uint32_t clzll(uint64_t x) {
TypeName& operator=(const TypeName&)
#endif
+#ifndef FMT_USE_USER_DEFINED_LITERALS
+// All compilers which support UDLs also support variadic templates. This
+// makes the fmt::literals implementation easier. However, an explicit check
+// for variadic templates is added here just in case.
+# define FMT_USE_USER_DEFINED_LITERALS \
+ FMT_USE_VARIADIC_TEMPLATES && FMT_USE_RVALUE_REFERENCES && \
+ (FMT_HAS_FEATURE(cxx_user_literals) || \
+ (FMT_GCC_VERSION >= 407 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1900)
+#endif
+
#ifndef FMT_ASSERT
# define FMT_ASSERT(condition, message) assert((condition) && message)
#endif
-namespace fmt {
+namespace fmt
+{
+namespace internal
+{
+struct DummyInt
+{
+ int data[2];
+ operator int() const
+ {
+ return 0;
+ }
+};
+typedef std::numeric_limits<fmt::internal::DummyInt> FPUtil;
+
+// Dummy implementations of system functions such as signbit and ecvt called
+// if the latter are not available.
+inline DummyInt signbit(...)
+{
+ return DummyInt();
+}
+inline DummyInt _ecvt_s(...)
+{
+ return DummyInt();
+}
+inline DummyInt isinf(...)
+{
+ return DummyInt();
+}
+inline DummyInt _finite(...)
+{
+ return DummyInt();
+}
+inline DummyInt isnan(...)
+{
+ return DummyInt();
+}
+inline DummyInt _isnan(...)
+{
+ return DummyInt();
+}
+
+// A helper function to suppress bogus "conditional expression is constant"
+// warnings.
+template <typename T>
+inline T check(T value)
+{
+ return value;
+}
+}
+} // namespace fmt
+
+namespace std
+{
+// Standard permits specialization of std::numeric_limits. This specialization
+// is used to resolve ambiguity between isinf and std::isinf in glibc:
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=48891
+// and the same for isnan and signbit.
+template <>
+class numeric_limits<fmt::internal::DummyInt> :
+ public std::numeric_limits<int>
+{
+public:
+ // Portable version of isinf.
+ template <typename T>
+ static bool isinfinity(T x)
+ {
+ using namespace fmt::internal;
+ // The resolution "priority" is:
+ // isinf macro > std::isinf > ::isinf > fmt::internal::isinf
+ if (check(sizeof(isinf(x)) == sizeof(bool) ||
+ sizeof(isinf(x)) == sizeof(int)))
+ {
+ return isinf(x) != 0;
+ }
+ return !_finite(static_cast<double>(x));
+ }
+
+ // Portable version of isnan.
+ template <typename T>
+ static bool isnotanumber(T x)
+ {
+ using namespace fmt::internal;
+ if (check(sizeof(isnan(x)) == sizeof(bool) ||
+ sizeof(isnan(x)) == sizeof(int)))
+ {
+ return isnan(x) != 0;
+ }
+ return _isnan(static_cast<double>(x)) != 0;
+ }
+
+ // Portable version of signbit.
+ static bool isnegative(double x)
+ {
+ using namespace fmt::internal;
+ if (check(sizeof(signbit(x)) == sizeof(int)))
+ return signbit(x) != 0;
+ if (x < 0) return true;
+ if (!isnotanumber(x)) return false;
+ int dec = 0, sign = 0;
+ char buffer[2]; // The buffer size must be >= 2 or _ecvt_s will fail.
+ _ecvt_s(buffer, sizeof(buffer), x, 0, &dec, &sign);
+ return sign != 0;
+ }
+};
+} // namespace std
+
+namespace fmt
+{
// Fix the warning about long long on older versions of GCC
// that don't support the diagnostic pragma.
@@ -206,442 +395,519 @@ template <typename Char, typename T>
void format(BasicFormatter<Char> &f, const Char *&format_str, const T &value);
/**
- \rst
- A string reference. It can be constructed from a C string or ``std::string``.
-
- You can use one of the following typedefs for common character types:
-
- +------------+-------------------------+
- | Type | Definition |
- +============+=========================+
- | StringRef | BasicStringRef<char> |
- +------------+-------------------------+
- | WStringRef | BasicStringRef<wchar_t> |
- +------------+-------------------------+
-
- This class is most useful as a parameter type to allow passing
- different types of strings to a function, for example::
+\rst
+A string reference. It can be constructed from a C string or ``std::string``.
- template <typename... Args>
- std::string format(StringRef format_str, const Args & ... args);
+You can use one of the following typedefs for common character types:
+
++------------+-------------------------+
+| Type | Definition |
++============+=========================+
+| StringRef | BasicStringRef<char> |
++------------+-------------------------+
+| WStringRef | BasicStringRef<wchar_t> |
++------------+-------------------------+
+
+This class is most useful as a parameter type to allow passing
+different types of strings to a function, for example::
+
+template <typename... Args>
+std::string format(StringRef format_str, const Args & ... args);
- format("{}", 42);
- format(std::string("{}"), 42);
- \endrst
- */
+format("{}", 42);
+format(std::string("{}"), 42);
+\endrst
+*/
template <typename Char>
-class BasicStringRef {
- private:
- const Char *data_;
- std::size_t size_;
+class BasicStringRef
+{
+private:
+ const Char *data_;
+ std::size_t size_;
- public:
- /** Constructs a string reference object from a C string and a size. */
- BasicStringRef(const Char *s, std::size_t size) : data_(s), size_(size) {}
+public:
+ /** Constructs a string reference object from a C string and a size. */
+ BasicStringRef(const Char *s, std::size_t size) : data_(s), size_(size) {}
- /**
+ /**
\rst
Constructs a string reference object from a C string computing
the size with ``std::char_traits<Char>::length``.
\endrst
- */
- BasicStringRef(const Char *s)
- : data_(s), size_(std::char_traits<Char>::length(s)) {}
+ */
+ BasicStringRef(const Char *s)
+ : data_(s), size_(std::char_traits<Char>::length(s)) {}
- /**
+ /**
\rst
Constructs a string reference from an ``std::string`` object.
\endrst
- */
- BasicStringRef(const std::basic_string<Char> &s)
- : data_(s.c_str()), size_(s.size()) {}
+ */
+ BasicStringRef(const std::basic_string<Char> &s)
+ : data_(s.c_str()), size_(s.size()) {}
- /**
+ /**
\rst
Converts a string reference to an ``std::string`` object.
\endrst
- */
- std::basic_string<Char> to_string() const {
- return std::basic_string<Char>(data_, size_);
- }
+ */
+ std::basic_string<Char> to_string() const
+ {
+ return std::basic_string<Char>(data_, size_);
+ }
- /** Returns the pointer to a C string. */
- const Char *data() const { return data_; }
+ /** Returns the pointer to a C string. */
+ const Char *data() const
+ {
+ return data_;
+ }
- /** Returns the string size. */
- std::size_t size() const { return size_; }
+ /** Returns the string size. */
+ std::size_t size() const
+ {
+ return size_;
+ }
- friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) {
- return lhs.data_ == rhs.data_;
- }
- friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) {
- return lhs.data_ != rhs.data_;
- }
- friend bool operator<(BasicStringRef lhs, BasicStringRef rhs) {
- return std::lexicographical_compare(
- lhs.data_, lhs.data_ + lhs.size_, rhs.data_, rhs.data_ + rhs.size_);
- }
+ // Lexicographically compare this string reference to other.
+ int compare(BasicStringRef other) const
+ {
+ std::size_t size = size_ < other.size_ ? size_ : other.size_;
+ int result = std::char_traits<Char>::compare(data_, other.data_, size);
+ if (result == 0)
+ result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
+ return result;
+ }
+
+ friend bool operator==(BasicStringRef lhs, BasicStringRef rhs)
+ {
+ return lhs.compare(rhs) == 0;
+ }
+ friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs)
+ {
+ return lhs.compare(rhs) != 0;
+ }
+ friend bool operator<(BasicStringRef lhs, BasicStringRef rhs)
+ {
+ return lhs.compare(rhs) < 0;
+ }
+ friend bool operator<=(BasicStringRef lhs, BasicStringRef rhs)
+ {
+ return lhs.compare(rhs) <= 0;
+ }
+ friend bool operator>(BasicStringRef lhs, BasicStringRef rhs)
+ {
+ return lhs.compare(rhs) > 0;
+ }
+ friend bool operator>=(BasicStringRef lhs, BasicStringRef rhs)
+ {
+ return lhs.compare(rhs) >= 0;
+ }
};
typedef BasicStringRef<char> StringRef;
typedef BasicStringRef<wchar_t> WStringRef;
-
/**
- \rst
- A reference to a null terminated string. It can be constructed from a C
- string or ``std::string``.
+\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 typedefs for common character types:
+You can use one of the following typedefs for common character types:
- +-------------+--------------------------+
- | Type | Definition |
- +=============+==========================+
- | CStringRef | BasicCStringRef<char> |
- +-------------+--------------------------+
- | WCStringRef | BasicCStringRef<wchar_t> |
- +-------------+--------------------------+
++-------------+--------------------------+
+| Type | Definition |
++=============+==========================+
+| CStringRef | BasicCStringRef<char> |
++-------------+--------------------------+
+| WCStringRef | BasicCStringRef<wchar_t> |
++-------------+--------------------------+
- This class is most useful as a parameter type to allow passing
- different types of strings to a function, for example::
+This class is most useful as a parameter type to allow passing
+different types of strings to a function, for example::
- template <typename... Args>
- std::string format(CStringRef format_str, const Args & ... args);
+template <typename... Args>
+std::string format(CStringRef format_str, const Args & ... args);
- format("{}", 42);
- format(std::string("{}"), 42);
- \endrst
- */
+format("{}", 42);
+format(std::string("{}"), 42);
+\endrst
+*/
template <typename Char>
-class BasicCStringRef {
- private:
- const Char *data_;
+class BasicCStringRef
+{
+private:
+ const Char *data_;
- public:
- /** Constructs a string reference object from a C string. */
- BasicCStringRef(const Char *s) : data_(s) {}
+public:
+ /** Constructs a string reference object from a C string. */
+ BasicCStringRef(const Char *s) : data_(s) {}
- /**
+ /**
\rst
Constructs a string reference from an ``std::string`` object.
\endrst
- */
- BasicCStringRef(const std::basic_string<Char> &s) : data_(s.c_str()) {}
+ */
+ BasicCStringRef(const std::basic_string<Char> &s) : data_(s.c_str()) {}
- /** Returns the pointer to a C string. */
- const Char *c_str() const { return data_; }
+ /** Returns the pointer to a C string. */
+ const Char *c_str() const
+ {
+ return data_;
+ }
};
typedef BasicCStringRef<char> CStringRef;
typedef BasicCStringRef<wchar_t> WCStringRef;
/**
- A formatting error such as invalid format string.
+A formatting error such as invalid format string.
*/
-class FormatError : public std::runtime_error {
- public:
- explicit FormatError(CStringRef message)
- : std::runtime_error(message.c_str()) {}
+class FormatError : public std::runtime_error
+{
+public:
+ explicit FormatError(CStringRef message)
+ : std::runtime_error(message.c_str()) {}
};
-namespace internal {
+namespace internal
+{
// The number of characters to store in the MemoryBuffer object itself
// to avoid dynamic memory allocation.
enum { INLINE_BUFFER_SIZE = 500 };
-#if _SECURE_SCL
+#if FMT_SECURE_SCL
// Use checked iterator to avoid warnings on MSVC.
template <typename T>
-inline stdext::checked_array_iterator<T*> make_ptr(T *ptr, std::size_t size) {
- return stdext::checked_array_iterator<T*>(ptr, size);
+inline stdext::checked_array_iterator<T*> make_ptr(T *ptr, std::size_t size)
+{
+ return stdext::checked_array_iterator<T*>(ptr, size);
}
#else
template <typename T>
-inline T *make_ptr(T *ptr, std::size_t) { return ptr; }
+inline T *make_ptr(T *ptr, std::size_t)
+{
+ return ptr;
+}
#endif
} // namespace internal
/**
- \rst
- A buffer supporting a subset of ``std::vector``'s operations.
- \endrst
- */
+\rst
+A buffer supporting a subset of ``std::vector``'s operations.
+\endrst
+*/
template <typename T>
-class Buffer {
- private:
- FMT_DISALLOW_COPY_AND_ASSIGN(Buffer);
+class Buffer
+{
+private:
+ FMT_DISALLOW_COPY_AND_ASSIGN(Buffer);
- protected:
- T *ptr_;
- std::size_t size_;
- std::size_t capacity_;
+protected:
+ T *ptr_;
+ std::size_t size_;
+ std::size_t capacity_;
- Buffer(T *ptr = 0, std::size_t capacity = 0)
- : ptr_(ptr), size_(0), capacity_(capacity) {}
+ Buffer(T *ptr = 0, std::size_t capacity = 0)
+ : ptr_(ptr), size_(0), capacity_(capacity) {}
- /**
+ /**
\rst
Increases the buffer capacity to hold at least *size* elements updating
``ptr_`` and ``capacity_``.
\endrst
- */
- virtual void grow(std::size_t size) = 0;
+ */
+ virtual void grow(std::size_t size) = 0;
- public:
- virtual ~Buffer() {}
+public:
+ virtual ~Buffer() {}
- /** Returns the size of this buffer. */
- std::size_t size() const { return size_; }
+ /** Returns the size of this buffer. */
+ std::size_t size() const
+ {
+ return size_;
+ }
- /** Returns the capacity of this buffer. */
- std::size_t capacity() const { return capacity_; }
+ /** Returns the capacity of this buffer. */
+ std::size_t capacity() const
+ {
+ return capacity_;
+ }
- /**
+ /**
Resizes the buffer. If T is a POD type new elements may not be initialized.
- */
- void resize(std::size_t new_size) {
- if (new_size > capacity_)
- grow(new_size);
- size_ = new_size;
- }
+ */
+ void resize(std::size_t new_size)
+ {
+ if (new_size > capacity_)
+ grow(new_size);
+ size_ = new_size;
+ }
- /**
+ /**
\rst
Reserves space to store at least *capacity* elements.
\endrst
- */
- void reserve(std::size_t capacity) {
- if (capacity > capacity_)
- grow(capacity);
- }
+ */
+ void reserve(std::size_t capacity)
+ {
+ if (capacity > capacity_)
+ grow(capacity);
+ }
- void clear() FMT_NOEXCEPT { size_ = 0; }
+ void clear() FMT_NOEXCEPT { size_ = 0; }
- void push_back(const T &value) {
- if (size_ == capacity_)
- grow(size_ + 1);
- ptr_[size_++] = value;
- }
+ void push_back(const T &value)
+ {
+ if (size_ == capacity_)
+ grow(size_ + 1);
+ ptr_[size_++] = value;
+ }
- /** Appends data to the end of the buffer. */
- template <typename U>
- void append(const U *begin, const U *end);
+ /** Appends data to the end of the buffer. */
+ template <typename U>
+ void append(const U *begin, const U *end);
- T &operator[](std::size_t index) { return ptr_[index]; }
- const T &operator[](std::size_t index) const { return ptr_[index]; }
+ T &operator[](std::size_t index)
+ {
+ return ptr_[index];
+ }
+ const T &operator[](std::size_t index) const
+ {
+ return ptr_[index];
+ }
};
template <typename T>
template <typename U>
-void Buffer<T>::append(const U *begin, const U *end) {
- std::ptrdiff_t num_elements = end - begin;
- if (size_ + num_elements > capacity_)
- grow(size_ + num_elements);
- std::copy(begin, end, internal::make_ptr(ptr_, capacity_) + size_);
- size_ += num_elements;
+void Buffer<T>::append(const U *begin, const U *end)
+{
+ assert(begin <= end);
+ std::size_t new_size = size_ + (end - begin);
+ if (new_size > capacity_)
+ grow(new_size);
+ std::uninitialized_copy(begin, end,
+ internal::make_ptr(ptr_, capacity_) + size_);
+ size_ = new_size;
}
-namespace internal {
+namespace internal
+{
// A memory buffer for POD types with the first SIZE elements stored in
// the object itself.
template <typename T, std::size_t SIZE, typename Allocator = std::allocator<T> >
-class MemoryBuffer : private Allocator, public Buffer<T> {
- private:
- T data_[SIZE];
-
- // Free memory allocated by the buffer.
- void free() {
- if (this->ptr_ != data_) this->deallocate(this->ptr_, this->capacity_);
- }
+class MemoryBuffer : private Allocator, public Buffer<T>
+{
+private:
+ T data_[SIZE];
+
+ // Deallocate memory allocated by the buffer.
+ void deallocate()
+ {
+ if (this->ptr_ != data_) Allocator::deallocate(this->ptr_, this->capacity_);
+ }
- protected:
- void grow(std::size_t size);
+protected:
+ void grow(std::size_t size);
- public:
- explicit MemoryBuffer(const Allocator &alloc = Allocator())
- : Allocator(alloc), Buffer<T>(data_, SIZE) {}
- ~MemoryBuffer() { free(); }
+public:
+ explicit MemoryBuffer(const Allocator &alloc = Allocator())
+ : Allocator(alloc), Buffer<T>(data_, SIZE) {}
+ ~MemoryBuffer()
+ {
+ deallocate();
+ }
#if FMT_USE_RVALUE_REFERENCES
- private:
- // Move data from other to this buffer.
- void move(MemoryBuffer &other) {
- Allocator &this_alloc = *this, &other_alloc = other;
- this_alloc = std::move(other_alloc);
- this->size_ = other.size_;
- this->capacity_ = other.capacity_;
- if (other.ptr_ == other.data_) {
- this->ptr_ = data_;
- std::copy(other.data_,
- other.data_ + this->size_, make_ptr(data_, this->capacity_));
- } else {
- this->ptr_ = other.ptr_;
- // Set pointer to the inline array so that delete is not called
- // when freeing.
- other.ptr_ = other.data_;
+private:
+ // Move data from other to this buffer.
+ void move(MemoryBuffer &other)
+ {
+ Allocator &this_alloc = *this, &other_alloc = other;
+ this_alloc = std::move(other_alloc);
+ this->size_ = other.size_;
+ this->capacity_ = other.capacity_;
+ if (other.ptr_ == other.data_)
+ {
+ this->ptr_ = data_;
+ std::uninitialized_copy(other.data_, other.data_ + this->size_,
+ make_ptr(data_, this->capacity_));
+ }
+ else
+ {
+ this->ptr_ = other.ptr_;
+ // Set pointer to the inline array so that delete is not called
+ // when deallocating.
+ other.ptr_ = other.data_;
+ }
}
- }
- public:
- MemoryBuffer(MemoryBuffer &&other) {
- move(other);
- }
+public:
+ MemoryBuffer(MemoryBuffer &&other)
+ {
+ move(other);
+ }
- MemoryBuffer &operator=(MemoryBuffer &&other) {
- assert(this != &other);
- free();
- move(other);
- return *this;
- }
+ MemoryBuffer &operator=(MemoryBuffer &&other)
+ {
+ assert(this != &other);
+ deallocate();
+ move(other);
+ return *this;
+ }
#endif
- // Returns a copy of the allocator associated with this buffer.
- Allocator get_allocator() const { return *this; }
+ // Returns a copy of the allocator associated with this buffer.
+ Allocator get_allocator() const
+ {
+ return *this;
+ }
};
template <typename T, std::size_t SIZE, typename Allocator>
-void MemoryBuffer<T, SIZE, Allocator>::grow(std::size_t size) {
- std::size_t new_capacity =
- (std::max)(size, this->capacity_ + this->capacity_ / 2);
- T *new_ptr = this->allocate(new_capacity);
- // The following code doesn't throw, so the raw pointer above doesn't leak.
- std::copy(this->ptr_,
- this->ptr_ + this->size_, make_ptr(new_ptr, new_capacity));
- std::size_t old_capacity = this->capacity_;
- T *old_ptr = this->ptr_;
- this->capacity_ = new_capacity;
- this->ptr_ = new_ptr;
- // deallocate may throw (at least in principle), but it doesn't matter since
- // the buffer already uses the new storage and will deallocate it in case
- // of exception.
- if (old_ptr != data_)
- this->deallocate(old_ptr, old_capacity);
+void MemoryBuffer<T, SIZE, Allocator>::grow(std::size_t size)
+{
+ std::size_t new_capacity = this->capacity_ + this->capacity_ / 2;
+ if (size > new_capacity)
+ new_capacity = size;
+ T *new_ptr = this->allocate(new_capacity);
+ // The following code doesn't throw, so the raw pointer above doesn't leak.
+ std::uninitialized_copy(this->ptr_, this->ptr_ + this->size_,
+ make_ptr(new_ptr, new_capacity));
+ std::size_t old_capacity = this->capacity_;
+ T *old_ptr = this->ptr_;
+ this->capacity_ = new_capacity;
+ this->ptr_ = new_ptr;
+ // deallocate may throw (at least in principle), but it doesn't matter since
+ // the buffer already uses the new storage and will deallocate it in case
+ // of exception.
+ if (old_ptr != data_)
+ Allocator::deallocate(old_ptr, old_capacity);
}
// A fixed-size buffer.
template <typename Char>
-class FixedBuffer : public fmt::Buffer<Char> {
- public:
- FixedBuffer(Char *array, std::size_t size) : fmt::Buffer<Char>(array, size) {}
+class FixedBuffer : public fmt::Buffer<Char>
+{
+public:
+ FixedBuffer(Char *array, std::size_t size) : fmt::Buffer<Char>(array, size) {}
- protected:
- void grow(std::size_t size);
+protected:
+ FMT_API void grow(std::size_t size);
};
-#ifndef _MSC_VER
-// Portable version of signbit.
-inline int getsign(double x) {
- // When compiled in C++11 mode signbit is no longer a macro but a function
- // defined in namespace std and the macro is undefined.
-# ifdef signbit
- return signbit(x);
-# else
- return std::signbit(x);
-# endif
-}
-
-// Portable version of isinf.
-# ifdef isinf
-inline int isinfinity(double x) { return isinf(x); }
-inline int isinfinity(long double x) { return isinf(x); }
-# else
-inline int isinfinity(double x) { return std::isinf(x); }
-inline int isinfinity(long double x) { return std::isinf(x); }
-# endif
-#else
-inline int getsign(double value) {
- if (value < 0) return 1;
- if (value == value) return 0;
- int dec = 0, sign = 0;
- char buffer[2]; // The buffer size must be >= 2 or _ecvt_s will fail.
- _ecvt_s(buffer, sizeof(buffer), value, 0, &dec, &sign);
- return sign;
-}
-inline int isinfinity(double x) { return !_finite(x); }
-inline int isinfinity(long double x) {
- return !_finite(static_cast<double>(x));
-}
-#endif
-
template <typename Char>
-class BasicCharTraits {
- public:
-#if _SECURE_SCL
- typedef stdext::checked_array_iterator<Char*> CharPtr;
+class BasicCharTraits
+{
+public:
+#if FMT_SECURE_SCL
+ typedef stdext::checked_array_iterator<Char*> CharPtr;
#else
- typedef Char *CharPtr;
+ typedef Char *CharPtr;
#endif
- static Char cast(wchar_t value) { return static_cast<Char>(value); }
+ static Char cast(int value)
+ {
+ return static_cast<Char>(value);
+ }
};
template <typename Char>
class CharTraits;
template <>
-class CharTraits<char> : public BasicCharTraits<char> {
- private:
- // Conversion from wchar_t to char is not allowed.
- static char convert(wchar_t);
-
- public:
- static char convert(char value) { return value; }
+class CharTraits<char> : public BasicCharTraits<char>
+{
+private:
+ // Conversion from wchar_t to char is not allowed.
+ static char convert(wchar_t);
+
+public:
+ static char convert(char value)
+ {
+ return value;
+ }
- // Formats a floating-point number.
- template <typename T>
- static int format_float(char *buffer, std::size_t size,
- const char *format, unsigned width, int precision, T value);
+ // Formats a floating-point number.
+ template <typename T>
+ FMT_API static int format_float(char *buffer, std::size_t size,
+ const char *format, unsigned width, int precision, T value);
};
template <>
-class CharTraits<wchar_t> : public BasicCharTraits<wchar_t> {
- public:
- static wchar_t convert(char value) { return value; }
- static wchar_t convert(wchar_t value) { return value; }
+class CharTraits<wchar_t> : public BasicCharTraits<wchar_t>
+{
+public:
+ static wchar_t convert(char value)
+ {
+ return value;
+ }
+ static wchar_t convert(wchar_t value)
+ {
+ return value;
+ }
- template <typename T>
- static int format_float(wchar_t *buffer, std::size_t size,
- const wchar_t *format, unsigned width, int precision, T value);
+ template <typename T>
+ FMT_API static int format_float(wchar_t *buffer, std::size_t size,
+ const wchar_t *format, unsigned width, int precision, T value);
};
// Checks if a number is negative - used to avoid warnings.
template <bool IsSigned>
-struct SignChecker {
- template <typename T>
- static bool is_negative(T value) { return value < 0; }
+struct SignChecker
+{
+ template <typename T>
+ static bool is_negative(T value)
+ {
+ return value < 0;
+ }
};
template <>
-struct SignChecker<false> {
- template <typename T>
- static bool is_negative(T) { return false; }
+struct SignChecker<false>
+{
+ template <typename T>
+ static bool is_negative(T)
+ {
+ return false;
+ }
};
// Returns true if value is negative, false otherwise.
// Same as (value < 0) but doesn't produce warnings if T is an unsigned type.
template <typename T>
-inline bool is_negative(T value) {
- return SignChecker<std::numeric_limits<T>::is_signed>::is_negative(value);
+inline bool is_negative(T value)
+{
+ return SignChecker<std::numeric_limits<T>::is_signed>::is_negative(value);
}
// Selects uint32_t if FitsIn32Bits is true, uint64_t otherwise.
template <bool FitsIn32Bits>
-struct TypeSelector { typedef uint32_t Type; };
+struct TypeSelector
+{
+ typedef uint32_t Type;
+};
template <>
-struct TypeSelector<false> { typedef uint64_t Type; };
+struct TypeSelector<false>
+{
+ typedef uint64_t Type;
+};
template <typename T>
-struct IntTraits {
- // Smallest of uint32_t and uint64_t that is large enough to represent
- // all values of T.
- typedef typename
+struct IntTraits
+{
+ // Smallest of uint32_t and uint64_t that is large enough to represent
+ // all values of T.
+ typedef typename
TypeSelector<std::numeric_limits<T>::digits <= 32>::Type MainType;
};
// MakeUnsigned<T>::Type gives an unsigned type corresponding to integer type T.
template <typename T>
-struct MakeUnsigned { typedef T Type; };
+struct MakeUnsigned
+{
+ typedef T Type;
+};
#define FMT_SPECIALIZE_MAKE_UNSIGNED(T, U) \
template <> \
@@ -654,15 +920,16 @@ FMT_SPECIALIZE_MAKE_UNSIGNED(int, unsigned);
FMT_SPECIALIZE_MAKE_UNSIGNED(long, unsigned long);
FMT_SPECIALIZE_MAKE_UNSIGNED(LongLong, ULongLong);
-void report_unknown_type(char code, const char *type);
+FMT_API void report_unknown_type(char code, const char *type);
// Static data is placed in this class template to allow header-only
// configuration.
template <typename T = void>
-struct BasicData {
- static const uint32_t POWERS_OF_10_32[];
- static const uint64_t POWERS_OF_10_64[];
- static const char DIGITS[];
+struct FMT_API BasicData
+{
+ static const uint32_t POWERS_OF_10_32[];
+ static const uint64_t POWERS_OF_10_64[];
+ static const char DIGITS[];
};
typedef BasicData<> Data;
@@ -678,58 +945,65 @@ typedef BasicData<> Data;
#ifdef FMT_BUILTIN_CLZLL
// Returns the number of decimal digits in n. Leading zeros are not counted
// except for n == 0 in which case count_digits returns 1.
-inline unsigned count_digits(uint64_t n) {
- // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
- // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.
- unsigned t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
- return t - (n < Data::POWERS_OF_10_64[t]) + 1;
+inline unsigned count_digits(uint64_t n)
+{
+ // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
+ // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.
+ unsigned t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
+ return t - (n < Data::POWERS_OF_10_64[t]) + 1;
}
#else
// Fallback version of count_digits used when __builtin_clz is not available.
-inline unsigned count_digits(uint64_t n) {
- unsigned 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;
- }
+inline unsigned count_digits(uint64_t n)
+{
+ unsigned 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;
+ }
}
#endif
#ifdef FMT_BUILTIN_CLZ
// Optional version of count_digits for better performance on 32-bit platforms.
-inline unsigned count_digits(uint32_t n) {
- uint32_t t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
- return t - (n < Data::POWERS_OF_10_32[t]) + 1;
+inline unsigned count_digits(uint32_t n)
+{
+ uint32_t t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
+ return t - (n < Data::POWERS_OF_10_32[t]) + 1;
}
#endif
// Formats a decimal unsigned integer value writing into buffer.
template <typename UInt, typename Char>
-inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) {
- buffer += num_digits;
- 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.
- unsigned index = (value % 100) * 2;
- value /= 100;
+inline void format_decimal(Char *buffer, UInt value, unsigned num_digits)
+{
+ buffer += num_digits;
+ 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.
+ unsigned index = static_cast<unsigned>((value % 100) * 2);
+ value /= 100;
+ *--buffer = Data::DIGITS[index + 1];
+ *--buffer = Data::DIGITS[index];
+ }
+ if (value < 10)
+ {
+ *--buffer = static_cast<char>('0' + value);
+ return;
+ }
+ unsigned index = static_cast<unsigned>(value * 2);
*--buffer = Data::DIGITS[index + 1];
*--buffer = Data::DIGITS[index];
- }
- if (value < 10) {
- *--buffer = static_cast<char>('0' + value);
- return;
- }
- unsigned index = static_cast<unsigned>(value * 2);
- *--buffer = Data::DIGITS[index + 1];
- *--buffer = Data::DIGITS[index];
}
#ifndef _WIN32
@@ -743,90 +1017,122 @@ inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) {
#if FMT_USE_WINDOWS_H
// A converter from UTF-8 to UTF-16.
// It is only provided for Windows since other systems support UTF-8 natively.
-class UTF8ToUTF16 {
- private:
- MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer_;
-
- public:
- explicit UTF8ToUTF16(StringRef s);
- operator WStringRef() const { return WStringRef(&buffer_[0], size()); }
- size_t size() const { return buffer_.size() - 1; }
- const wchar_t *c_str() const { return &buffer_[0]; }
- std::wstring str() const { return std::wstring(&buffer_[0], size()); }
+class UTF8ToUTF16
+{
+private:
+ MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer_;
+
+public:
+ FMT_API explicit UTF8ToUTF16(StringRef s);
+ operator WStringRef() const
+ {
+ return WStringRef(&buffer_[0], size());
+ }
+ size_t size() const
+ {
+ return buffer_.size() - 1;
+ }
+ const wchar_t *c_str() const
+ {
+ return &buffer_[0];
+ }
+ std::wstring str() const
+ {
+ return std::wstring(&buffer_[0], size());
+ }
};
// A converter from UTF-16 to UTF-8.
// It is only provided for Windows since other systems support UTF-8 natively.
-class UTF16ToUTF8 {
- private:
- MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer_;
-
- public:
- UTF16ToUTF8() {}
- explicit UTF16ToUTF8(WStringRef s);
- operator StringRef() const { return StringRef(&buffer_[0], size()); }
- size_t size() const { return buffer_.size() - 1; }
- const char *c_str() const { return &buffer_[0]; }
- std::string str() const { return std::string(&buffer_[0], size()); }
-
- // Performs conversion returning a system error code instead of
- // throwing exception on conversion error. This method may still throw
- // in case of memory allocation error.
- int convert(WStringRef s);
-};
-
-void format_windows_error(fmt::Writer &out, int error_code,
- fmt::StringRef message) FMT_NOEXCEPT;
+class UTF16ToUTF8
+{
+private:
+ MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer_;
+
+public:
+ UTF16ToUTF8() {}
+ FMT_API explicit UTF16ToUTF8(WStringRef s);
+ operator StringRef() const
+ {
+ return StringRef(&buffer_[0], size());
+ }
+ size_t size() const
+ {
+ return buffer_.size() - 1;
+ }
+ const char *c_str() const
+ {
+ return &buffer_[0];
+ }
+ std::string str() const
+ {
+ return std::string(&buffer_[0], size());
+ }
+
+ // Performs conversion returning a system error code instead of
+ // throwing exception on conversion error. This method may still throw
+ // in case of memory allocation error.
+ FMT_API int convert(WStringRef s);
+};
+
+FMT_API void format_windows_error(fmt::Writer &out, int error_code,
+ fmt::StringRef message) FMT_NOEXCEPT;
#endif
-void format_system_error(fmt::Writer &out, int error_code,
- fmt::StringRef message) FMT_NOEXCEPT;
+FMT_API void format_system_error(fmt::Writer &out, int error_code,
+ fmt::StringRef message) FMT_NOEXCEPT;
// A formatting argument value.
-struct Value {
- template <typename Char>
- struct StringValue {
- const Char *value;
- std::size_t size;
- };
-
- typedef void (*FormatFunc)(
- void *formatter, const void *arg, void *format_str_ptr);
-
- struct CustomValue {
- const void *value;
- FormatFunc format;
- };
-
- union {
- int int_value;
- unsigned uint_value;
- LongLong long_long_value;
- ULongLong ulong_long_value;
- double double_value;
- long double long_double_value;
- const void *pointer;
- StringValue<char> string;
- StringValue<signed char> sstring;
- StringValue<unsigned char> ustring;
- StringValue<wchar_t> wstring;
- CustomValue custom;
- };
-
- enum Type {
- NONE, NAMED_ARG,
- // Integer types should go first,
- INT, UINT, LONG_LONG, ULONG_LONG, BOOL, CHAR, LAST_INTEGER_TYPE = CHAR,
- // followed by floating-point types.
- DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE,
- CSTRING, STRING, WSTRING, POINTER, CUSTOM
- };
+struct Value
+{
+ template <typename Char>
+ struct StringValue
+ {
+ const Char *value;
+ std::size_t size;
+ };
+
+ typedef void(*FormatFunc)(
+ void *formatter, const void *arg, void *format_str_ptr);
+
+ struct CustomValue
+ {
+ const void *value;
+ FormatFunc format;
+ };
+
+ union
+ {
+ int int_value;
+ unsigned uint_value;
+ LongLong long_long_value;
+ ULongLong ulong_long_value;
+ double double_value;
+ long double long_double_value;
+ const void *pointer;
+ StringValue<char> string;
+ StringValue<signed char> sstring;
+ StringValue<unsigned char> ustring;
+ StringValue<wchar_t> wstring;
+ CustomValue custom;
+ };
+
+ enum Type
+ {
+ NONE, NAMED_ARG,
+ // Integer types should go first,
+ INT, UINT, LONG_LONG, ULONG_LONG, BOOL, CHAR, LAST_INTEGER_TYPE = CHAR,
+ // followed by floating-point types.
+ DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE,
+ CSTRING, STRING, WSTRING, POINTER, CUSTOM
+ };
};
// A formatting argument. It is a POD type to allow storage in
// internal::MemoryBuffer.
-struct Arg : Value {
- Type type;
+struct Arg : Value
+{
+ Type type;
};
template <typename Char>
@@ -838,105 +1144,175 @@ struct Null {};
// A helper class template to enable or disable overloads taking wide
// characters and strings in MakeValue.
template <typename T, typename Char>
-struct WCharHelper {
- typedef Null<T> Supported;
- typedef T Unsupported;
+struct WCharHelper
+{
+ typedef Null<T> Supported;
+ typedef T Unsupported;
};
template <typename T>
-struct WCharHelper<T, wchar_t> {
- typedef T Supported;
- typedef Null<T> Unsupported;
+struct WCharHelper<T, wchar_t>
+{
+ typedef T Supported;
+ typedef Null<T> Unsupported;
};
+typedef char Yes[1];
+typedef char No[2];
+
+// These are non-members to workaround an overload resolution bug in bcc32.
+Yes &convert(fmt::ULongLong);
+Yes &convert(std::ostream &);
+No &convert(...);
+
template <typename T>
-class IsConvertibleToInt {
- private:
- typedef char yes[1];
- typedef char no[2];
+T &get();
+
+struct DummyStream : std::ostream
+{
+ DummyStream(); // Suppress a bogus warning in MSVC.
+ // Hide all operator<< overloads from std::ostream.
+ void operator<<(Null<>);
+};
+
+No &operator<<(std::ostream &, int);
+
+template<typename T, bool ENABLE_CONVERSION>
+struct ConvertToIntImpl
+{
+ enum { value = false };
+};
+
+template<typename T>
+struct ConvertToIntImpl<T, true>
+{
+ // Convert to int only if T doesn't have an overloaded operator<<.
+ enum
+ {
+ value = sizeof(convert(get<DummyStream>() << get<T>())) == sizeof(No)
+ };
+};
- static const T &get();
+template<typename T, bool ENABLE_CONVERSION>
+struct ConvertToIntImpl2
+{
+ enum { value = false };
+};
+
+template<typename T>
+struct ConvertToIntImpl2<T, true>
+{
+ enum
+ {
+ // Don't convert numeric types.
+ value = ConvertToIntImpl<T, !std::numeric_limits<T>::is_specialized>::value
+ };
+};
- static yes &convert(fmt::ULongLong);
- static no &convert(...);
-
- public:
- enum { value = (sizeof(convert(get())) == sizeof(yes)) };
+template<typename T>
+struct ConvertToInt
+{
+ enum { enable_conversion = sizeof(convert(get<T>())) == sizeof(Yes) };
+ enum { value = ConvertToIntImpl2<T, enable_conversion>::value };
};
-#define FMT_CONVERTIBLE_TO_INT(Type) \
+#define FMT_DISABLE_CONVERSION_TO_INT(Type) \
template <> \
- class IsConvertibleToInt<Type> { \
- public: \
- enum { value = 1 }; \
- }
+ struct ConvertToInt<Type> { enum { value = 0 }; }
// Silence warnings about convering float to int.
-FMT_CONVERTIBLE_TO_INT(float);
-FMT_CONVERTIBLE_TO_INT(double);
-FMT_CONVERTIBLE_TO_INT(long double);
+FMT_DISABLE_CONVERSION_TO_INT(float);
+FMT_DISABLE_CONVERSION_TO_INT(double);
+FMT_DISABLE_CONVERSION_TO_INT(long double);
template<bool B, class T = void>
struct EnableIf {};
template<class T>
-struct EnableIf<true, T> { typedef T type; };
+struct EnableIf<true, T>
+{
+ typedef T type;
+};
template<bool B, class T, class F>
-struct Conditional { typedef T type; };
+struct Conditional
+{
+ typedef T type;
+};
template<class T, class F>
-struct Conditional<false, T, F> { typedef F type; };
+struct Conditional<false, T, F>
+{
+ typedef F type;
+};
-// A helper function to suppress bogus "conditional expression is constant"
-// warnings.
-inline bool check(bool value) { return value; }
+// For bcc32 which doesn't understand ! in template arguments.
+template<bool>
+struct Not
+{
+ enum { value = 0 };
+};
+
+template<>
+struct Not<false>
+{
+ enum { value = 1 };
+};
// Makes an Arg object from any type.
-template <typename Char>
-class MakeValue : public Arg {
- private:
- // The following two methods are private to disallow formatting of
- // arbitrary pointers. If you want to output a pointer cast it to
- // "void *" or "const void *". In particular, this forbids formatting
- // of "[const] volatile char *" which is printed as bool by iostreams.
- // Do not implement!
- template <typename T>
- MakeValue(const T *value);
- template <typename T>
- MakeValue(T *value);
-
- // The following methods are private to disallow formatting of wide
- // characters and strings into narrow strings as in
- // fmt::format("{}", L"test");
- // To fix this, use a wide format string: fmt::format(L"{}", L"test").
- MakeValue(typename WCharHelper<wchar_t, Char>::Unsupported);
- MakeValue(typename WCharHelper<wchar_t *, Char>::Unsupported);
- MakeValue(typename WCharHelper<const wchar_t *, Char>::Unsupported);
- MakeValue(typename WCharHelper<const std::wstring &, Char>::Unsupported);
- MakeValue(typename WCharHelper<WStringRef, Char>::Unsupported);
-
- void set_string(StringRef str) {
- string.value = str.data();
- string.size = str.size();
- }
+template <typename Formatter>
+class MakeValue : public Arg
+{
+public:
+ typedef typename Formatter::Char Char;
+
+private:
+ // The following two methods are private to disallow formatting of
+ // arbitrary pointers. If you want to output a pointer cast it to
+ // "void *" or "const void *". In particular, this forbids formatting
+ // of "[const] volatile char *" which is printed as bool by iostreams.
+ // Do not implement!
+ template <typename T>
+ MakeValue(const T *value);
+ template <typename T>
+ MakeValue(T *value);
+
+ // The following methods are private to disallow formatting of wide
+ // characters and strings into narrow strings as in
+ // fmt::format("{}", L"test");
+ // To fix this, use a wide format string: fmt::format(L"{}", L"test").
+#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
+ MakeValue(typename WCharHelper<wchar_t, Char>::Unsupported);
+#endif
+ MakeValue(typename WCharHelper<wchar_t *, Char>::Unsupported);
+ MakeValue(typename WCharHelper<const wchar_t *, Char>::Unsupported);
+ MakeValue(typename WCharHelper<const std::wstring &, Char>::Unsupported);
+ MakeValue(typename WCharHelper<WStringRef, Char>::Unsupported);
+
+ void set_string(StringRef str)
+ {
+ string.value = str.data();
+ string.size = str.size();
+ }
- void set_string(WStringRef str) {
- wstring.value = str.data();
- wstring.size = str.size();
- }
+ void set_string(WStringRef str)
+ {
+ wstring.value = str.data();
+ wstring.size = str.size();
+ }
- // Formats an argument of a custom type, such as a user-defined class.
- template <typename T>
- static void format_custom_arg(
- void *formatter, const void *arg, void *format_str_ptr) {
- format(*static_cast<BasicFormatter<Char>*>(formatter),
- *static_cast<const Char**>(format_str_ptr),
- *static_cast<const T*>(arg));
- }
+ // Formats an argument of a custom type, such as a user-defined class.
+ template <typename T>
+ static void format_custom_arg(
+ void *formatter, const void *arg, void *format_str_ptr)
+ {
+ format(*static_cast<Formatter*>(formatter),
+ *static_cast<const Char**>(format_str_ptr),
+ *static_cast<const T*>(arg));
+ }
- public:
- MakeValue() {}
+public:
+ MakeValue() {}
#define FMT_MAKE_VALUE_(Type, field, TYPE, rhs) \
MakeValue(Type value) { field = rhs; } \
@@ -945,111 +1321,135 @@ class MakeValue : public Arg {
#define FMT_MAKE_VALUE(Type, field, TYPE) \
FMT_MAKE_VALUE_(Type, field, TYPE, value)
- FMT_MAKE_VALUE(bool, int_value, BOOL)
- FMT_MAKE_VALUE(short, int_value, INT)
- FMT_MAKE_VALUE(unsigned short, uint_value, UINT)
- FMT_MAKE_VALUE(int, int_value, INT)
- FMT_MAKE_VALUE(unsigned, uint_value, UINT)
-
- MakeValue(long value) {
- // 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.
- if (check(sizeof(long) == sizeof(int)))
- int_value = static_cast<int>(value);
- else
- long_long_value = value;
- }
- static uint64_t type(long) {
- return sizeof(long) == sizeof(int) ? Arg::INT : Arg::LONG_LONG;
- }
+ FMT_MAKE_VALUE(bool, int_value, BOOL)
+ FMT_MAKE_VALUE(short, int_value, INT)
+ FMT_MAKE_VALUE(unsigned short, uint_value, UINT)
+ FMT_MAKE_VALUE(int, int_value, INT)
+ FMT_MAKE_VALUE(unsigned, uint_value, UINT)
+
+ MakeValue(long value)
+ {
+ // 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.
+ if (check(sizeof(long) == sizeof(int)))
+ int_value = static_cast<int>(value);
+ else
+ long_long_value = value;
+ }
+ static uint64_t type(long)
+ {
+ return sizeof(long) == sizeof(int) ? Arg::INT : Arg::LONG_LONG;
+ }
- MakeValue(unsigned long value) {
- if (check(sizeof(unsigned long) == sizeof(unsigned)))
- uint_value = static_cast<unsigned>(value);
- else
- ulong_long_value = value;
- }
- static uint64_t type(unsigned long) {
- return sizeof(unsigned long) == sizeof(unsigned) ?
- Arg::UINT : Arg::ULONG_LONG;
- }
+ MakeValue(unsigned long value)
+ {
+ if (check(sizeof(unsigned long) == sizeof(unsigned)))
+ uint_value = static_cast<unsigned>(value);
+ else
+ ulong_long_value = value;
+ }
+ static uint64_t type(unsigned long)
+ {
+ return sizeof(unsigned long) == sizeof(unsigned) ?
+ Arg::UINT : Arg::ULONG_LONG;
+ }
- FMT_MAKE_VALUE(LongLong, long_long_value, LONG_LONG)
- FMT_MAKE_VALUE(ULongLong, ulong_long_value, ULONG_LONG)
- FMT_MAKE_VALUE(float, double_value, DOUBLE)
- FMT_MAKE_VALUE(double, double_value, DOUBLE)
- FMT_MAKE_VALUE(long double, long_double_value, LONG_DOUBLE)
- FMT_MAKE_VALUE(signed char, int_value, CHAR)
- FMT_MAKE_VALUE(unsigned char, int_value, CHAR)
- FMT_MAKE_VALUE(char, int_value, CHAR)
-
- MakeValue(typename WCharHelper<wchar_t, Char>::Supported value) {
- int_value = value;
- }
- static uint64_t type(wchar_t) { return Arg::CHAR; }
+ FMT_MAKE_VALUE(LongLong, long_long_value, LONG_LONG)
+ FMT_MAKE_VALUE(ULongLong, ulong_long_value, ULONG_LONG)
+ FMT_MAKE_VALUE(float, double_value, DOUBLE)
+ FMT_MAKE_VALUE(double, double_value, DOUBLE)
+ FMT_MAKE_VALUE(long double, long_double_value, LONG_DOUBLE)
+ FMT_MAKE_VALUE(signed char, int_value, INT)
+ FMT_MAKE_VALUE(unsigned char, uint_value, UINT)
+ FMT_MAKE_VALUE(char, int_value, CHAR)
+
+#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
+ MakeValue(typename WCharHelper<wchar_t, Char>::Supported value)
+ {
+ int_value = value;
+ }
+ static uint64_t type(wchar_t)
+ {
+ return Arg::CHAR;
+ }
+#endif
#define FMT_MAKE_STR_VALUE(Type, TYPE) \
MakeValue(Type value) { set_string(value); } \
static uint64_t type(Type) { return Arg::TYPE; }
- FMT_MAKE_VALUE(char *, string.value, CSTRING)
- FMT_MAKE_VALUE(const char *, string.value, CSTRING)
- FMT_MAKE_VALUE(const signed char *, sstring.value, CSTRING)
- FMT_MAKE_VALUE(const unsigned char *, ustring.value, CSTRING)
- FMT_MAKE_STR_VALUE(const std::string &, STRING)
- FMT_MAKE_STR_VALUE(StringRef, STRING)
- FMT_MAKE_VALUE_(CStringRef, string.value, CSTRING, value.c_str())
+ FMT_MAKE_VALUE(char *, string.value, CSTRING)
+ FMT_MAKE_VALUE(const char *, string.value, CSTRING)
+ FMT_MAKE_VALUE(const signed char *, sstring.value, CSTRING)
+ FMT_MAKE_VALUE(const unsigned char *, ustring.value, CSTRING)
+ FMT_MAKE_STR_VALUE(const std::string &, STRING)
+ FMT_MAKE_STR_VALUE(StringRef, STRING)
+ FMT_MAKE_VALUE_(CStringRef, string.value, CSTRING, value.c_str())
#define FMT_MAKE_WSTR_VALUE(Type, TYPE) \
MakeValue(typename WCharHelper<Type, Char>::Supported value) { \
set_string(value); \
- } \
+ } \
static uint64_t type(Type) { return Arg::TYPE; }
- FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING)
- FMT_MAKE_WSTR_VALUE(const wchar_t *, WSTRING)
- FMT_MAKE_WSTR_VALUE(const std::wstring &, WSTRING)
- FMT_MAKE_WSTR_VALUE(WStringRef, WSTRING)
-
- FMT_MAKE_VALUE(void *, pointer, POINTER)
- FMT_MAKE_VALUE(const void *, pointer, POINTER)
-
- template <typename T>
- MakeValue(const T &value,
- typename EnableIf<!IsConvertibleToInt<T>::value, int>::type = 0) {
- custom.value = &value;
- custom.format = &format_custom_arg<T>;
- }
+ FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING)
+ FMT_MAKE_WSTR_VALUE(const wchar_t *, WSTRING)
+ FMT_MAKE_WSTR_VALUE(const std::wstring &, WSTRING)
+ FMT_MAKE_WSTR_VALUE(WStringRef, WSTRING)
+
+ FMT_MAKE_VALUE(void *, pointer, POINTER)
+ FMT_MAKE_VALUE(const void *, pointer, POINTER)
+
+ template <typename T>
+ MakeValue(const T &value,
+ typename EnableIf<Not<
+ ConvertToInt<T>::value>::value, int>::type = 0)
+ {
+ custom.value = &value;
+ custom.format = &format_custom_arg<T>;
+ }
- template <typename T>
- MakeValue(const T &value,
- typename EnableIf<IsConvertibleToInt<T>::value, int>::type = 0) {
- int_value = value;
- }
+ template <typename T>
+ MakeValue(const T &value,
+ typename EnableIf<ConvertToInt<T>::value, int>::type = 0)
+ {
+ int_value = value;
+ }
- template <typename T>
- static uint64_t type(const T &) {
- return IsConvertibleToInt<T>::value ? Arg::INT : Arg::CUSTOM;
- }
+ template <typename T>
+ static uint64_t type(const T &)
+ {
+ return ConvertToInt<T>::value ? Arg::INT : Arg::CUSTOM;
+ }
- // Additional template param `Char_` is needed here because make_type always
- // uses MakeValue<char>.
- template <typename Char_>
- MakeValue(const NamedArg<Char_> &value) { pointer = &value; }
+ // Additional template param `Char_` is needed here because make_type always
+ // uses char.
+ template <typename Char_>
+ MakeValue(const NamedArg<Char_> &value)
+ {
+ pointer = &value;
+ }
- template <typename Char_>
- static uint64_t type(const NamedArg<Char_> &) { return Arg::NAMED_ARG; }
+ template <typename Char_>
+ static uint64_t type(const NamedArg<Char_> &)
+ {
+ return Arg::NAMED_ARG;
+ }
};
template <typename Char>
-struct NamedArg : Arg {
- BasicStringRef<Char> name;
+struct NamedArg : Arg
+{
+ BasicStringRef<Char> name;
- template <typename T>
- NamedArg(BasicStringRef<Char> argname, const T &value)
- : name(argname), Arg(MakeValue<Char>(value)) {
- type = static_cast<internal::Arg::Type>(MakeValue<Char>::type(value));
- }
+ typedef internal::MakeValue< BasicFormatter<Char> > MakeValue;
+
+ template <typename T>
+ NamedArg(BasicStringRef<Char> argname, const T &value)
+ : Arg(MakeValue(value)), name(argname)
+ {
+ type = static_cast<Arg::Type>(MakeValue::type(value));
+ }
};
#define FMT_DISPATCH(call) static_cast<Impl*>(this)->call
@@ -1075,108 +1475,125 @@ struct NamedArg : Arg {
// ArgVisitor uses the curiously recurring template pattern:
// http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern
template <typename Impl, typename Result>
-class ArgVisitor {
- public:
- void report_unhandled_arg() {}
-
- Result visit_unhandled_arg() {
- FMT_DISPATCH(report_unhandled_arg());
- return Result();
- }
+class ArgVisitor
+{
+public:
+ void report_unhandled_arg() {}
+
+ Result visit_unhandled_arg()
+ {
+ FMT_DISPATCH(report_unhandled_arg());
+ return Result();
+ }
- Result visit_int(int value) {
- return FMT_DISPATCH(visit_any_int(value));
- }
- Result visit_long_long(LongLong value) {
- return FMT_DISPATCH(visit_any_int(value));
- }
- Result visit_uint(unsigned value) {
- return FMT_DISPATCH(visit_any_int(value));
- }
- Result visit_ulong_long(ULongLong value) {
- return FMT_DISPATCH(visit_any_int(value));
- }
- Result visit_bool(bool value) {
- return FMT_DISPATCH(visit_any_int(value));
- }
- Result visit_char(int value) {
- return FMT_DISPATCH(visit_any_int(value));
- }
- template <typename T>
- Result visit_any_int(T) {
- return FMT_DISPATCH(visit_unhandled_arg());
- }
+ Result visit_int(int value)
+ {
+ return FMT_DISPATCH(visit_any_int(value));
+ }
+ Result visit_long_long(LongLong value)
+ {
+ return FMT_DISPATCH(visit_any_int(value));
+ }
+ Result visit_uint(unsigned value)
+ {
+ return FMT_DISPATCH(visit_any_int(value));
+ }
+ Result visit_ulong_long(ULongLong value)
+ {
+ return FMT_DISPATCH(visit_any_int(value));
+ }
+ Result visit_bool(bool value)
+ {
+ return FMT_DISPATCH(visit_any_int(value));
+ }
+ Result visit_char(int value)
+ {
+ return FMT_DISPATCH(visit_any_int(value));
+ }
+ template <typename T>
+ Result visit_any_int(T)
+ {
+ return FMT_DISPATCH(visit_unhandled_arg());
+ }
- Result visit_double(double value) {
- return FMT_DISPATCH(visit_any_double(value));
- }
- Result visit_long_double(long double value) {
- return FMT_DISPATCH(visit_any_double(value));
- }
- template <typename T>
- Result visit_any_double(T) {
- return FMT_DISPATCH(visit_unhandled_arg());
- }
+ Result visit_double(double value)
+ {
+ return FMT_DISPATCH(visit_any_double(value));
+ }
+ Result visit_long_double(long double value)
+ {
+ return FMT_DISPATCH(visit_any_double(value));
+ }
+ template <typename T>
+ Result visit_any_double(T)
+ {
+ return FMT_DISPATCH(visit_unhandled_arg());
+ }
- Result visit_string(Arg::StringValue<char>) {
- return FMT_DISPATCH(visit_unhandled_arg());
- }
- Result visit_wstring(Arg::StringValue<wchar_t>) {
- return FMT_DISPATCH(visit_unhandled_arg());
- }
- Result visit_pointer(const void *) {
- return FMT_DISPATCH(visit_unhandled_arg());
- }
- Result visit_custom(Arg::CustomValue) {
- return FMT_DISPATCH(visit_unhandled_arg());
- }
+ Result visit_cstring(const char *)
+ {
+ return FMT_DISPATCH(visit_unhandled_arg());
+ }
+ Result visit_string(Arg::StringValue<char>)
+ {
+ return FMT_DISPATCH(visit_unhandled_arg());
+ }
+ Result visit_wstring(Arg::StringValue<wchar_t>)
+ {
+ return FMT_DISPATCH(visit_unhandled_arg());
+ }
+ Result visit_pointer(const void *)
+ {
+ return FMT_DISPATCH(visit_unhandled_arg());
+ }
+ Result visit_custom(Arg::CustomValue)
+ {
+ return FMT_DISPATCH(visit_unhandled_arg());
+ }
- Result visit(const Arg &arg) {
- switch (arg.type) {
- default:
- FMT_ASSERT(false, "invalid argument type");
- return Result();
- case Arg::INT:
- return FMT_DISPATCH(visit_int(arg.int_value));
- case Arg::UINT:
- return FMT_DISPATCH(visit_uint(arg.uint_value));
- case Arg::LONG_LONG:
- return FMT_DISPATCH(visit_long_long(arg.long_long_value));
- case Arg::ULONG_LONG:
- return FMT_DISPATCH(visit_ulong_long(arg.ulong_long_value));
- case Arg::BOOL:
- return FMT_DISPATCH(visit_bool(arg.int_value != 0));
- case Arg::CHAR:
- return FMT_DISPATCH(visit_char(arg.int_value));
- case Arg::DOUBLE:
- return FMT_DISPATCH(visit_double(arg.double_value));
- case Arg::LONG_DOUBLE:
- return FMT_DISPATCH(visit_long_double(arg.long_double_value));
- case Arg::CSTRING: {
- Arg::StringValue<char> str = arg.string;
- str.size = 0;
- return FMT_DISPATCH(visit_string(str));
- }
- case Arg::STRING:
- return FMT_DISPATCH(visit_string(arg.string));
- case Arg::WSTRING:
- return FMT_DISPATCH(visit_wstring(arg.wstring));
- case Arg::POINTER:
- return FMT_DISPATCH(visit_pointer(arg.pointer));
- case Arg::CUSTOM:
- return FMT_DISPATCH(visit_custom(arg.custom));
+ Result visit(const Arg &arg)
+ {
+ switch (arg.type)
+ {
+ default:
+ FMT_ASSERT(false, "invalid argument type");
+ return Result();
+ case Arg::INT:
+ return FMT_DISPATCH(visit_int(arg.int_value));
+ case Arg::UINT:
+ return FMT_DISPATCH(visit_uint(arg.uint_value));
+ case Arg::LONG_LONG:
+ return FMT_DISPATCH(visit_long_long(arg.long_long_value));
+ case Arg::ULONG_LONG:
+ return FMT_DISPATCH(visit_ulong_long(arg.ulong_long_value));
+ case Arg::BOOL:
+ return FMT_DISPATCH(visit_bool(arg.int_value != 0));
+ case Arg::CHAR:
+ return FMT_DISPATCH(visit_char(arg.int_value));
+ case Arg::DOUBLE:
+ return FMT_DISPATCH(visit_double(arg.double_value));
+ case Arg::LONG_DOUBLE:
+ return FMT_DISPATCH(visit_long_double(arg.long_double_value));
+ case Arg::CSTRING:
+ return FMT_DISPATCH(visit_cstring(arg.string.value));
+ case Arg::STRING:
+ return FMT_DISPATCH(visit_string(arg.string));
+ case Arg::WSTRING:
+ return FMT_DISPATCH(visit_wstring(arg.wstring));
+ case Arg::POINTER:
+ return FMT_DISPATCH(visit_pointer(arg.pointer));
+ case Arg::CUSTOM:
+ return FMT_DISPATCH(visit_custom(arg.custom));
+ }
}
- }
};
-class RuntimeError : public std::runtime_error {
- protected:
- RuntimeError() : std::runtime_error("") {}
+class RuntimeError : public std::runtime_error
+{
+protected:
+ RuntimeError() : std::runtime_error("") {}
};
-template <typename Impl, typename Char>
-class BasicArgFormatter;
-
template <typename Char>
class PrintfArgFormatter;
@@ -1185,312 +1602,275 @@ class ArgMap;
} // namespace internal
/** An argument list. */
-class ArgList {
- private:
- // To reduce compiled code size per formatting function call, types of first
- // MAX_PACKED_ARGS arguments are passed in the types_ field.
- uint64_t types_;
- union {
- // If the number of arguments is less than MAX_PACKED_ARGS, the argument
- // values are stored in values_, otherwise they are stored in args_.
- // This is done to reduce compiled code size as 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 internal::Value *values_;
- const internal::Arg *args_;
- };
-
- internal::Arg::Type type(unsigned index) const {
- unsigned shift = index * 4;
- uint64_t mask = 0xf;
- return static_cast<internal::Arg::Type>(
- (types_ & (mask << shift)) >> shift);
- }
-
- template <typename Char>
- friend class internal::ArgMap;
+class ArgList
+{
+private:
+ // To reduce compiled code size per formatting function call, types of first
+ // MAX_PACKED_ARGS arguments are passed in the types_ field.
+ uint64_t types_;
+ union
+ {
+ // If the number of arguments is less than MAX_PACKED_ARGS, the argument
+ // values are stored in values_, otherwise they are stored in args_.
+ // This is done to reduce compiled code size as 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 internal::Value *values_;
+ const internal::Arg *args_;
+ };
+
+ internal::Arg::Type type(unsigned index) const
+ {
+ unsigned shift = index * 4;
+ uint64_t mask = 0xf;
+ return static_cast<internal::Arg::Type>(
+ (types_ & (mask << shift)) >> shift);
+ }
- public:
- // Maximum number of arguments with packed types.
- enum { MAX_PACKED_ARGS = 16 };
+ template <typename Char>
+ friend class internal::ArgMap;
+
+public:
+ // Maximum number of arguments with packed types.
+ enum { MAX_PACKED_ARGS = 16 };
+
+ ArgList() : types_(0) {}
+
+ ArgList(ULongLong types, const internal::Value *values)
+ : types_(types), values_(values) {}
+ ArgList(ULongLong types, const internal::Arg *args)
+ : types_(types), args_(args) {}
+
+ /** Returns the argument at specified index. */
+ internal::Arg operator[](unsigned index) const
+ {
+ using internal::Arg;
+ Arg arg;
+ bool use_values = type(MAX_PACKED_ARGS - 1) == Arg::NONE;
+ if (index < MAX_PACKED_ARGS)
+ {
+ Arg::Type arg_type = type(index);
+ internal::Value &val = arg;
+ if (arg_type != Arg::NONE)
+ val = use_values ? values_[index] : args_[index];
+ arg.type = arg_type;
+ return arg;
+ }
+ if (use_values)
+ {
+ // The index is greater than the number of arguments that can be stored
+ // in values, so return a "none" argument.
+ arg.type = Arg::NONE;
+ return arg;
+ }
+ for (unsigned i = MAX_PACKED_ARGS; i <= index; ++i)
+ {
+ if (args_[i].type == Arg::NONE)
+ return args_[i];
+ }
+ return args_[index];
+ }
+};
- ArgList() : types_(0) {}
+enum Alignment
+{
+ ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC
+};
- ArgList(ULongLong types, const internal::Value *values)
- : types_(types), values_(values) {}
- ArgList(ULongLong types, const internal::Arg *args)
- : types_(types), args_(args) {}
-
- /** Returns the argument at specified index. */
- internal::Arg operator[](unsigned index) const {
- using internal::Arg;
- Arg arg;
- bool use_values = type(MAX_PACKED_ARGS - 1) == Arg::NONE;
- if (index < MAX_PACKED_ARGS) {
- Arg::Type arg_type = type(index);
- internal::Value &val = arg;
- if (arg_type != Arg::NONE)
- val = use_values ? values_[index] : args_[index];
- arg.type = arg_type;
- return arg;
- }
- if (use_values) {
- // The index is greater than the number of arguments that can be stored
- // in values, so return a "none" argument.
- arg.type = Arg::NONE;
- return arg;
- }
- for (unsigned i = MAX_PACKED_ARGS; i <= index; ++i) {
- if (args_[i].type == Arg::NONE)
- return args_[i];
- }
- return args_[index];
- }
-};
-
-struct FormatSpec;
-
-namespace internal {
-
-template <typename Char>
-class ArgMap {
- private:
- typedef std::map<fmt::BasicStringRef<Char>, internal::Arg> MapType;
- typedef typename MapType::value_type Pair;
-
- MapType map_;
-
- public:
- void init(const ArgList &args);
-
- const internal::Arg* find(const fmt::BasicStringRef<Char> &name) const {
- typename MapType::const_iterator it = map_.find(name);
- return it != map_.end() ? &it->second : 0;
- }
-};
-
-class FormatterBase {
- private:
- ArgList args_;
- int next_arg_index_;
-
- // Returns the argument with specified index.
- Arg do_get_arg(unsigned arg_index, const char *&error);
-
- protected:
- const ArgList &args() const { return args_; }
-
- explicit FormatterBase(const ArgList &args) {
- args_ = args;
- next_arg_index_ = 0;
- }
-
- // Returns the next argument.
- Arg next_arg(const char *&error);
-
- // Checks if manual indexing is used and returns the argument with
- // specified index.
- Arg get_arg(unsigned arg_index, const char *&error);
-
- bool check_no_auto_index(const char *&error);
-
- template <typename Char>
- void write(BasicWriter<Char> &w, const Char *start, const Char *end) {
- if (start != end)
- w << BasicStringRef<Char>(start, end - start);
- }
-};
-
-// A printf formatter.
-template <typename Char>
-class PrintfFormatter : private FormatterBase {
- private:
- void parse_flags(FormatSpec &spec, const Char *&s);
-
- // Returns the argument with specified index or, if arg_index is equal
- // to the maximum unsigned value, the next argument.
- Arg get_arg(const Char *s,
- unsigned arg_index = (std::numeric_limits<unsigned>::max)());
-
- // Parses argument index, flags and width and returns the argument index.
- unsigned parse_header(const Char *&s, FormatSpec &spec);
-
- public:
- explicit PrintfFormatter(const ArgList &args) : FormatterBase(args) {}
- void format(BasicWriter<Char> &writer, BasicCStringRef<Char> format_str);
-};
-} // namespace internal
-
-// A formatter.
-template <typename Char>
-class BasicFormatter : private internal::FormatterBase {
- private:
- BasicWriter<Char> &writer_;
- internal::ArgMap<Char> map_;
-
- FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter);
-
- using FormatterBase::get_arg;
-
- // Checks if manual indexing is used and returns the argument with
- // specified name.
- internal::Arg get_arg(BasicStringRef<Char> arg_name, const char *&error);
-
- // Parses argument index and returns corresponding argument.
- internal::Arg parse_arg_index(const Char *&s);
-
- // Parses argument name and returns corresponding argument.
- internal::Arg parse_arg_name(const Char *&s);
-
- public:
- BasicFormatter(const ArgList &args, BasicWriter<Char> &w)
- : FormatterBase(args), writer_(w) {}
-
- BasicWriter<Char> &writer() { return writer_; }
-
- void format(BasicCStringRef<Char> format_str);
-
- const Char *format(const Char *&format_str, const internal::Arg &arg);
-};
-
-enum Alignment {
- ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC
-};
-
-// Flags.
-enum {
- SIGN_FLAG = 1, PLUS_FLAG = 2, MINUS_FLAG = 4, HASH_FLAG = 8,
- CHAR_FLAG = 0x10 // Argument has char type - used in error reporting.
-};
+// Flags.
+enum
+{
+ SIGN_FLAG = 1, PLUS_FLAG = 2, MINUS_FLAG = 4, HASH_FLAG = 8,
+ CHAR_FLAG = 0x10 // Argument has char type - used in error reporting.
+};
// An empty format specifier.
struct EmptySpec {};
// A type specifier.
template <char TYPE>
-struct TypeSpec : EmptySpec {
- Alignment align() const { return ALIGN_DEFAULT; }
- unsigned width() const { return 0; }
- int precision() const { return -1; }
- bool flag(unsigned) const { return false; }
- char type() const { return TYPE; }
- char fill() const { return ' '; }
+struct TypeSpec : EmptySpec
+{
+ Alignment align() const
+ {
+ return ALIGN_DEFAULT;
+ }
+ unsigned width() const
+ {
+ return 0;
+ }
+ int precision() const
+ {
+ return -1;
+ }
+ bool flag(unsigned) const
+ {
+ return false;
+ }
+ char type() const
+ {
+ return TYPE;
+ }
+ char fill() const
+ {
+ return ' ';
+ }
};
// A width specifier.
-struct WidthSpec {
- unsigned width_;
- // Fill is always wchar_t and cast to char if necessary to avoid having
- // two specialization of WidthSpec and its subclasses.
- wchar_t fill_;
-
- WidthSpec(unsigned width, wchar_t fill) : width_(width), fill_(fill) {}
-
- unsigned width() const { return width_; }
- wchar_t fill() const { return fill_; }
+struct WidthSpec
+{
+ unsigned width_;
+ // Fill is always wchar_t and cast to char if necessary to avoid having
+ // two specialization of WidthSpec and its subclasses.
+ wchar_t fill_;
+
+ WidthSpec(unsigned width, wchar_t fill) : width_(width), fill_(fill) {}
+
+ unsigned width() const
+ {
+ return width_;
+ }
+ wchar_t fill() const
+ {
+ return fill_;
+ }
};
// An alignment specifier.
-struct AlignSpec : WidthSpec {
- Alignment align_;
+struct AlignSpec : WidthSpec
+{
+ Alignment align_;
- AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT)
- : WidthSpec(width, fill), align_(align) {}
+ AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT)
+ : WidthSpec(width, fill), align_(align) {}
- Alignment align() const { return align_; }
+ Alignment align() const
+ {
+ return align_;
+ }
- int precision() const { return -1; }
+ int precision() const
+ {
+ return -1;
+ }
};
// An alignment and type specifier.
template <char TYPE>
-struct AlignTypeSpec : AlignSpec {
- AlignTypeSpec(unsigned width, wchar_t fill) : AlignSpec(width, fill) {}
+struct AlignTypeSpec : AlignSpec
+{
+ AlignTypeSpec(unsigned width, wchar_t fill) : AlignSpec(width, fill) {}
- bool flag(unsigned) const { return false; }
- char type() const { return TYPE; }
+ bool flag(unsigned) const
+ {
+ return false;
+ }
+ char type() const
+ {
+ return TYPE;
+ }
};
// A full format specifier.
-struct FormatSpec : AlignSpec {
- unsigned flags_;
- int precision_;
- char type_;
-
- FormatSpec(
- unsigned width = 0, char type = 0, wchar_t fill = ' ')
- : AlignSpec(width, fill), flags_(0), precision_(-1), type_(type) {}
-
- bool flag(unsigned f) const { return (flags_ & f) != 0; }
- int precision() const { return precision_; }
- char type() const { return type_; }
+struct FormatSpec : AlignSpec
+{
+ unsigned flags_;
+ int precision_;
+ char type_;
+
+ FormatSpec(
+ unsigned width = 0, char type = 0, wchar_t fill = ' ')
+ : AlignSpec(width, fill), flags_(0), precision_(-1), type_(type) {}
+
+ bool flag(unsigned f) const
+ {
+ return (flags_ & f) != 0;
+ }
+ int precision() const
+ {
+ return precision_;
+ }
+ char type() const
+ {
+ return type_;
+ }
};
// An integer format specifier.
template <typename T, typename SpecT = TypeSpec<0>, typename Char = char>
-class IntFormatSpec : public SpecT {
- private:
- T value_;
-
- public:
- IntFormatSpec(T val, const SpecT &spec = SpecT())
- : SpecT(spec), value_(val) {}
-
- T value() const { return value_; }
+class IntFormatSpec : public SpecT
+{
+private:
+ T value_;
+
+public:
+ IntFormatSpec(T val, const SpecT &spec = SpecT())
+ : SpecT(spec), value_(val) {}
+
+ T value() const
+ {
+ return value_;
+ }
};
// A string format specifier.
template <typename Char>
-class StrFormatSpec : public AlignSpec {
- private:
- const Char *str_;
-
- public:
- template <typename FillChar>
- StrFormatSpec(const Char *str, unsigned width, FillChar fill)
- : AlignSpec(width, fill), str_(str) {
- internal::CharTraits<Char>::convert(FillChar());
- }
+class StrFormatSpec : public AlignSpec
+{
+private:
+ const Char *str_;
+
+public:
+ template <typename FillChar>
+ StrFormatSpec(const Char *str, unsigned width, FillChar fill)
+ : AlignSpec(width, fill), str_(str)
+ {
+ internal::CharTraits<Char>::convert(FillChar());
+ }
- const Char *str() const { return str_; }
+ const Char *str() const
+ {
+ return str_;
+ }
};
/**
- Returns an integer format specifier to format the value in base 2.
- */
+Returns an integer format specifier to format the value in base 2.
+*/
IntFormatSpec<int, TypeSpec<'b'> > bin(int value);
/**
- Returns an integer format specifier to format the value in base 8.
- */
+Returns an integer format specifier to format the value in base 8.
+*/
IntFormatSpec<int, TypeSpec<'o'> > oct(int value);
/**
- Returns an integer format specifier to format the value in base 16 using
- lower-case letters for the digits above 9.
- */
+Returns an integer format specifier to format the value in base 16 using
+lower-case letters for the digits above 9.
+*/
IntFormatSpec<int, TypeSpec<'x'> > hex(int value);
/**
- Returns an integer formatter format specifier to format in base 16 using
- upper-case letters for the digits above 9.
- */
+Returns an integer formatter format specifier to format in base 16 using
+upper-case letters for the digits above 9.
+*/
IntFormatSpec<int, TypeSpec<'X'> > hexu(int value);
/**
- \rst
- Returns an integer format specifier to pad the formatted argument with the
- fill character to the specified width using the default (right) numeric
- alignment.
+\rst
+Returns an integer format specifier to pad the formatted argument with the
+fill character to the specified width using the default (right) numeric
+alignment.
- **Example**::
+**Example**::
- MemoryWriter out;
- out << pad(hex(0xcafe), 8, '0');
- // out.str() == "0000cafe"
+MemoryWriter out;
+out << pad(hex(0xcafe), 8, '0');
+// out.str() == "0000cafe"
- \endrst
- */
+\endrst
+*/
template <char TYPE_CODE, typename Char>
IntFormatSpec<int, AlignTypeSpec<TYPE_CODE>, Char> pad(
int value, unsigned width, Char fill = ' ');
@@ -1498,26 +1878,26 @@ IntFormatSpec<int, AlignTypeSpec<TYPE_CODE>, Char> pad(
#define FMT_DEFINE_INT_FORMATTERS(TYPE) \
inline IntFormatSpec<TYPE, TypeSpec<'b'> > bin(TYPE value) { \
return IntFormatSpec<TYPE, TypeSpec<'b'> >(value, TypeSpec<'b'>()); \
-} \
+ } \
\
inline IntFormatSpec<TYPE, TypeSpec<'o'> > oct(TYPE value) { \
return IntFormatSpec<TYPE, TypeSpec<'o'> >(value, TypeSpec<'o'>()); \
-} \
+ } \
\
inline IntFormatSpec<TYPE, TypeSpec<'x'> > hex(TYPE value) { \
return IntFormatSpec<TYPE, TypeSpec<'x'> >(value, TypeSpec<'x'>()); \
-} \
+ } \
\
inline IntFormatSpec<TYPE, TypeSpec<'X'> > hexu(TYPE value) { \
return IntFormatSpec<TYPE, TypeSpec<'X'> >(value, TypeSpec<'X'>()); \
-} \
+ } \
\
template <char TYPE_CODE> \
inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> > pad( \
IntFormatSpec<TYPE, TypeSpec<TYPE_CODE> > f, unsigned width) { \
return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> >( \
f.value(), AlignTypeSpec<TYPE_CODE>(width, ' ')); \
-} \
+ } \
\
/* For compatibility with older compilers we provide two overloads for pad, */ \
/* one that takes a fill character and one that doesn't. In the future this */ \
@@ -1529,20 +1909,20 @@ inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char> pad( \
unsigned width, Char fill) { \
return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char>( \
f.value(), AlignTypeSpec<TYPE_CODE>(width, fill)); \
-} \
+ } \
\
inline IntFormatSpec<TYPE, AlignTypeSpec<0> > pad( \
TYPE value, unsigned width) { \
return IntFormatSpec<TYPE, AlignTypeSpec<0> >( \
value, AlignTypeSpec<0>(width, ' ')); \
-} \
+ } \
\
template <typename Char> \
inline IntFormatSpec<TYPE, AlignTypeSpec<0>, Char> pad( \
TYPE value, unsigned width, Char fill) { \
return IntFormatSpec<TYPE, AlignTypeSpec<0>, Char>( \
value, AlignTypeSpec<0>(width, fill)); \
-}
+ }
FMT_DEFINE_INT_FORMATTERS(int)
FMT_DEFINE_INT_FORMATTERS(long)
@@ -1552,28 +1932,318 @@ FMT_DEFINE_INT_FORMATTERS(LongLong)
FMT_DEFINE_INT_FORMATTERS(ULongLong)
/**
- \rst
- Returns a string formatter that pads the formatted argument with the fill
- character to the specified width using the default (left) string alignment.
+\rst
+Returns a string formatter that pads the formatted argument with the fill
+character to the specified width using the default (left) string alignment.
- **Example**::
+**Example**::
- std::string s = str(MemoryWriter() << pad("abc", 8));
- // s == "abc "
+std::string s = str(MemoryWriter() << pad("abc", 8));
+// s == "abc "
- \endrst
- */
+\endrst
+*/
template <typename Char>
inline StrFormatSpec<Char> pad(
- const Char *str, unsigned width, Char fill = ' ') {
- return StrFormatSpec<Char>(str, width, fill);
+ const Char *str, unsigned width, Char fill = ' ')
+{
+ return StrFormatSpec<Char>(str, width, fill);
}
inline StrFormatSpec<wchar_t> pad(
- const wchar_t *str, unsigned width, char fill = ' ') {
- return StrFormatSpec<wchar_t>(str, width, fill);
+ const wchar_t *str, unsigned width, char fill = ' ')
+{
+ return StrFormatSpec<wchar_t>(str, width, fill);
}
+namespace internal
+{
+
+template <typename Char>
+class ArgMap
+{
+private:
+ typedef std::map<fmt::BasicStringRef<Char>, internal::Arg> MapType;
+ typedef typename MapType::value_type Pair;
+
+ MapType map_;
+
+public:
+ FMT_API void init(const ArgList &args);
+
+ const internal::Arg* find(const fmt::BasicStringRef<Char> &name) const
+ {
+ typename MapType::const_iterator it = map_.find(name);
+ return it != map_.end() ? &it->second : 0;
+ }
+};
+
+template <typename Impl, typename Char>
+class ArgFormatterBase : public ArgVisitor<Impl, void>
+{
+private:
+ BasicWriter<Char> &writer_;
+ FormatSpec &spec_;
+
+ FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatterBase);
+
+ void write_pointer(const void *p)
+ {
+ spec_.flags_ = HASH_FLAG;
+ spec_.type_ = 'x';
+ writer_.write_int(reinterpret_cast<uintptr_t>(p), spec_);
+ }
+
+protected:
+ BasicWriter<Char> &writer()
+ {
+ return writer_;
+ }
+ FormatSpec &spec()
+ {
+ return spec_;
+ }
+
+ void write(bool value)
+ {
+ const char *str_value = value ? "true" : "false";
+ Arg::StringValue<char> str = { str_value, std::strlen(str_value) };
+ writer_.write_str(str, spec_);
+ }
+
+ void write(const char *value)
+ {
+ Arg::StringValue<char> str = { value, value != 0 ? std::strlen(value) : 0 };
+ writer_.write_str(str, spec_);
+ }
+
+public:
+ ArgFormatterBase(BasicWriter<Char> &w, FormatSpec &s)
+ : writer_(w), spec_(s) {}
+
+ template <typename T>
+ void visit_any_int(T value)
+ {
+ writer_.write_int(value, spec_);
+ }
+
+ template <typename T>
+ void visit_any_double(T value)
+ {
+ writer_.write_double(value, spec_);
+ }
+
+ void visit_bool(bool value)
+ {
+ if (spec_.type_)
+ return visit_any_int(value);
+ write(value);
+ }
+
+ void visit_char(int value)
+ {
+ if (spec_.type_ && spec_.type_ != 'c')
+ {
+ spec_.flags_ |= CHAR_FLAG;
+ writer_.write_int(value, spec_);
+ return;
+ }
+ if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0)
+ FMT_THROW(FormatError("invalid format specifier for char"));
+ typedef typename BasicWriter<Char>::CharPtr CharPtr;
+ Char fill = internal::CharTraits<Char>::cast(spec_.fill());
+ CharPtr out = CharPtr();
+ const unsigned CHAR_WIDTH = 1;
+ if (spec_.width_ > CHAR_WIDTH)
+ {
+ out = writer_.grow_buffer(spec_.width_);
+ if (spec_.align_ == ALIGN_RIGHT)
+ {
+ std::uninitialized_fill_n(out, spec_.width_ - CHAR_WIDTH, fill);
+ out += spec_.width_ - CHAR_WIDTH;
+ }
+ else if (spec_.align_ == ALIGN_CENTER)
+ {
+ out = writer_.fill_padding(out, spec_.width_,
+ internal::check(CHAR_WIDTH), fill);
+ }
+ else
+ {
+ std::uninitialized_fill_n(out + CHAR_WIDTH,
+ spec_.width_ - CHAR_WIDTH, fill);
+ }
+ }
+ else
+ {
+ out = writer_.grow_buffer(CHAR_WIDTH);
+ }
+ *out = internal::CharTraits<Char>::cast(value);
+ }
+
+ void visit_cstring(const char *value)
+ {
+ if (spec_.type_ == 'p')
+ return write_pointer(value);
+ write(value);
+ }
+
+ void visit_string(Arg::StringValue<char> value)
+ {
+ writer_.write_str(value, spec_);
+ }
+
+ using ArgVisitor<Impl, void>::visit_wstring;
+
+ void visit_wstring(Arg::StringValue<Char> value)
+ {
+ writer_.write_str(value, spec_);
+ }
+
+ void visit_pointer(const void *value)
+ {
+ if (spec_.type_ && spec_.type_ != 'p')
+ report_unknown_type(spec_.type_, "pointer");
+ write_pointer(value);
+ }
+};
+
+// An argument formatter.
+template <typename Char>
+class BasicArgFormatter :
+ public ArgFormatterBase<BasicArgFormatter<Char>, Char>
+{
+private:
+ BasicFormatter<Char> &formatter_;
+ const Char *format_;
+
+public:
+ BasicArgFormatter(BasicFormatter<Char> &f, FormatSpec &s, const Char *fmt)
+ : ArgFormatterBase<BasicArgFormatter<Char>, Char>(f.writer(), s),
+ formatter_(f), format_(fmt) {}
+
+ void visit_custom(Arg::CustomValue c)
+ {
+ c.format(&formatter_, c.value, &format_);
+ }
+};
+
+class FormatterBase
+{
+private:
+ ArgList args_;
+ int next_arg_index_;
+
+ // Returns the argument with specified index.
+ FMT_API Arg do_get_arg(unsigned arg_index, const char *&error);
+
+protected:
+ const ArgList &args() const
+ {
+ return args_;
+ }
+
+ explicit FormatterBase(const ArgList &args)
+ {
+ args_ = args;
+ next_arg_index_ = 0;
+ }
+
+ // Returns the next argument.
+ Arg next_arg(const char *&error)
+ {
+ if (next_arg_index_ >= 0)
+ return do_get_arg(next_arg_index_++, error);
+ error = "cannot switch from manual to automatic argument indexing";
+ return Arg();
+ }
+
+ // Checks if manual indexing is used and returns the argument with
+ // specified index.
+ Arg get_arg(unsigned arg_index, const char *&error)
+ {
+ return check_no_auto_index(error) ? do_get_arg(arg_index, error) : Arg();
+ }
+
+ bool check_no_auto_index(const char *&error)
+ {
+ if (next_arg_index_ > 0)
+ {
+ error = "cannot switch from automatic to manual argument indexing";
+ return false;
+ }
+ next_arg_index_ = -1;
+ return true;
+ }
+
+ template <typename Char>
+ void write(BasicWriter<Char> &w, const Char *start, const Char *end)
+ {
+ if (start != end)
+ w << BasicStringRef<Char>(start, end - start);
+ }
+};
+
+// A printf formatter.
+template <typename Char>
+class PrintfFormatter : private FormatterBase
+{
+private:
+ void parse_flags(FormatSpec &spec, const Char *&s);
+
+ // Returns the argument with specified index or, if arg_index is equal
+ // to the maximum unsigned value, the next argument.
+ Arg get_arg(const Char *s,
+ unsigned arg_index = (std::numeric_limits<unsigned>::max)());
+
+ // Parses argument index, flags and width and returns the argument index.
+ unsigned parse_header(const Char *&s, FormatSpec &spec);
+
+public:
+ explicit PrintfFormatter(const ArgList &args) : FormatterBase(args) {}
+ FMT_API void format(BasicWriter<Char> &writer,
+ BasicCStringRef<Char> format_str);
+};
+} // namespace internal
+
+// A formatter.
+template <typename CharType>
+class BasicFormatter : private internal::FormatterBase
+{
+public:
+ typedef CharType Char;
+
+private:
+ BasicWriter<Char> &writer_;
+ internal::ArgMap<Char> map_;
+
+ FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter);
+
+ using internal::FormatterBase::get_arg;
+
+ // Checks if manual indexing is used and returns the argument with
+ // specified name.
+ internal::Arg get_arg(BasicStringRef<Char> arg_name, const char *&error);
+
+ // Parses argument index and returns corresponding argument.
+ internal::Arg parse_arg_index(const Char *&s);
+
+ // Parses argument name and returns corresponding argument.
+ internal::Arg parse_arg_name(const Char *&s);
+
+public:
+ BasicFormatter(const ArgList &args, BasicWriter<Char> &w)
+ : internal::FormatterBase(args), writer_(w) {}
+
+ BasicWriter<Char> &writer()
+ {
+ return writer_;
+ }
+
+ void format(BasicCStringRef<Char> format_str);
+
+ const Char *format(const Char *&format_str, const internal::Arg &arg);
+};
+
// Generates a comma-separated list with results of applying f to
// numbers 0..n-1.
# define FMT_GEN(n, f) FMT_GEN##n(f)
@@ -1593,97 +2263,153 @@ inline StrFormatSpec<wchar_t> pad(
# define FMT_GEN14(f) FMT_GEN13(f), f(13)
# define FMT_GEN15(f) FMT_GEN14(f), f(14)
-namespace internal {
-inline uint64_t make_type() { return 0; }
+namespace internal
+{
+inline uint64_t make_type()
+{
+ return 0;
+}
template <typename T>
-inline uint64_t make_type(const T &arg) { return MakeValue<char>::type(arg); }
+inline uint64_t make_type(const T &arg)
+{
+ return MakeValue< BasicFormatter<char> >::type(arg);
+}
template <unsigned N>
-struct ArgArray {
- // Computes the argument array size by adding 1 to N, which is the number of
- // arguments, if N is zero, because array of zero size is invalid, or if N
- // is greater than ArgList::MAX_PACKED_ARGS to accommodate for an extra
- // argument that marks the end of the list.
- enum { SIZE = N + (N == 0 || N >= ArgList::MAX_PACKED_ARGS ? 1 : 0) };
-
- typedef typename Conditional<
+struct ArgArray
+{
+ // Computes the argument array size by adding 1 to N, which is the number of
+ // arguments, if N is zero, because array of zero size is invalid, or if N
+ // is greater than ArgList::MAX_PACKED_ARGS to accommodate for an extra
+ // argument that marks the end of the list.
+ enum { SIZE = N + (N == 0 || N >= ArgList::MAX_PACKED_ARGS ? 1 : 0) };
+
+ typedef typename Conditional<
(N < ArgList::MAX_PACKED_ARGS), Value, Arg>::type Type[SIZE];
};
#if FMT_USE_VARIADIC_TEMPLATES
template <typename Arg, typename... Args>
-inline uint64_t make_type(const Arg &first, const Args & ... tail) {
- return make_type(first) | (make_type(tail...) << 4);
+inline uint64_t make_type(const Arg &first, const Args & ... tail)
+{
+ return make_type(first) | (make_type(tail...) << 4);
}
inline void do_set_types(Arg *) {}
template <typename T, typename... Args>
-inline void do_set_types(Arg *args, const T &arg, const Args & ... tail) {
- args->type = static_cast<Arg::Type>(MakeValue<T>::type(arg));
- do_set_types(args + 1, tail...);
+inline void do_set_types(Arg *args, const T &arg, const Args & ... tail)
+{
+ args->type = static_cast<Arg::Type>(
+ MakeValue< BasicFormatter<char> >::type(arg));
+ do_set_types(args + 1, tail...);
}
template <typename... Args>
-inline void set_types(Arg *array, const Args & ... args) {
- if (check(sizeof...(Args) > ArgList::MAX_PACKED_ARGS))
- do_set_types(array, args...);
- array[sizeof...(Args)].type = Arg::NONE;
+inline void set_types(Arg *array, const Args & ... args)
+{
+ if (check(sizeof...(Args) > ArgList::MAX_PACKED_ARGS))
+ do_set_types(array, args...);
+ array[sizeof...(Args)].type = Arg::NONE;
}
template <typename... Args>
-inline void set_types(Value *, const Args & ...) {
- // Do nothing as types are passed separately from values.
+inline void set_types(Value *, const Args & ...)
+{
+ // Do nothing as types are passed separately from values.
}
-template <typename Char, typename Value>
+template <typename Formatter, typename Value>
inline void store_args(Value *) {}
-template <typename Char, typename Arg, typename T, typename... Args>
-inline void store_args(Arg *args, const T &arg, const Args & ... tail) {
- // Assign only the Value subobject of Arg and don't overwrite type (if any)
- // that is assigned by set_types.
- Value &value = *args;
- value = MakeValue<Char>(arg);
- store_args<Char>(args + 1, tail...);
+template <typename Formatter, typename Arg, typename T, typename... Args>
+inline void store_args(Arg *args, const T &arg, const Args & ... tail)
+{
+ // Assign only the Value subobject of Arg and don't overwrite type (if any)
+ // that is assigned by set_types.
+ Value &value = *args;
+ value = MakeValue<Formatter>(arg);
+ store_args<Formatter>(args + 1, tail...);
}
-template <typename Char, typename... Args>
+template <typename Formatter, typename... Args>
ArgList make_arg_list(typename ArgArray<sizeof...(Args)>::Type array,
- const Args & ... args) {
- if (check(sizeof...(Args) >= ArgList::MAX_PACKED_ARGS))
- set_types(array, args...);
- store_args<Char>(array, args...);
- return ArgList(make_type(args...), array);
+ const Args & ... args)
+{
+ if (check(sizeof...(Args) >= ArgList::MAX_PACKED_ARGS))
+ set_types(array, args...);
+ store_args<Formatter>(array, args...);
+ return ArgList(make_type(args...), array);
}
#else
-struct ArgType {
- uint64_t type;
+struct ArgType
+{
+ uint64_t type;
- ArgType() : type(0) {}
+ ArgType() : type(0) {}
- template <typename T>
- ArgType(const T &arg) : type(make_type(arg)) {}
+ template <typename T>
+ ArgType(const T &arg) : type(make_type(arg)) {}
};
# define FMT_ARG_TYPE_DEFAULT(n) ArgType t##n = ArgType()
-inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
- return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) |
- (t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) |
- (t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) |
- (t12.type << 48) | (t13.type << 52) | (t14.type << 56);
+inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT))
+{
+ return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) |
+ (t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) |
+ (t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) |
+ (t12.type << 48) | (t13.type << 52) | (t14.type << 56);
}
#endif
+
+template <class Char>
+class FormatBuf : public std::basic_streambuf<Char>
+{
+private:
+ typedef typename std::basic_streambuf<Char>::int_type int_type;
+ typedef typename std::basic_streambuf<Char>::traits_type traits_type;
+
+ Buffer<Char> &buffer_;
+ Char *start_;
+
+public:
+ FormatBuf(Buffer<Char> &buffer) : buffer_(buffer), start_(&buffer[0])
+ {
+ this->setp(start_, start_ + buffer_.capacity());
+ }
+
+ int_type overflow(int_type ch = traits_type::eof())
+ {
+ if (!traits_type::eq_int_type(ch, traits_type::eof()))
+ {
+ size_t size = this->pptr() - start_;
+ buffer_.resize(size);
+ buffer_.reserve(size * 2);
+
+ start_ = &buffer_[0];
+ start_[size] = traits_type::to_char_type(ch);
+ this->setp(start_ + size + 1, start_ + size * 2);
+ }
+ return ch;
+ }
+
+ size_t size() const
+ {
+ return this->pptr() - start_;
+ }
+};
} // namespace internal
# define FMT_MAKE_TEMPLATE_ARG(n) typename T##n
# define FMT_MAKE_ARG_TYPE(n) T##n
# define FMT_MAKE_ARG(n) const T##n &v##n
-# define FMT_MAKE_REF_char(n) fmt::internal::MakeValue<char>(v##n)
-# define FMT_MAKE_REF_wchar_t(n) fmt::internal::MakeValue<wchar_t>(v##n)
+# define FMT_ASSIGN_char(n) \
+ arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter<char> >(v##n)
+# define FMT_ASSIGN_wchar_t(n) \
+ arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter<wchar_t> >(v##n)
#if FMT_USE_VARIADIC_TEMPLATES
// Defines a variadic function returning void.
@@ -1691,20 +2417,23 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
template <typename... Args> \
void func(arg_type arg0, const Args & ... args) { \
typename fmt::internal::ArgArray<sizeof...(Args)>::Type array; \
- func(arg0, fmt::internal::make_arg_list<Char>(array, args...)); \
- }
+ func(arg0, fmt::internal::make_arg_list< \
+ fmt::BasicFormatter<Char> >(array, args...)); \
+ }
// Defines a variadic constructor.
# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \
template <typename... Args> \
ctor(arg0_type arg0, arg1_type arg1, const Args & ... args) { \
typename fmt::internal::ArgArray<sizeof...(Args)>::Type array; \
- func(arg0, arg1, fmt::internal::make_arg_list<Char>(array, args...)); \
- }
+ func(arg0, arg1, fmt::internal::make_arg_list< \
+ fmt::BasicFormatter<Char> >(array, args...)); \
+ }
#else
-# define FMT_MAKE_REF(n) fmt::internal::MakeValue<Char>(v##n)
+# define FMT_MAKE_REF(n) \
+ fmt::internal::MakeValue< fmt::BasicFormatter<Char> >(v##n)
# define FMT_MAKE_REF2(n) v##n
// Defines a wrapper for a function taking one argument of type arg_type
@@ -1715,7 +2444,7 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \
func(arg1, fmt::ArgList( \
fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \
- }
+ }
// Emulates a variadic function returning void on a pre-C++11 compiler.
# define FMT_VARIADIC_VOID(func, arg_type) \
@@ -1732,7 +2461,7 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \
func(arg0, arg1, fmt::ArgList( \
fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \
- }
+ }
// Emulates a variadic constructor on a pre-C++11 compiler.
# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \
@@ -1771,740 +2500,889 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8), f(x9, 9)
/**
- An error returned by an operating system or a language runtime,
- for example a file opening error.
+An error returned by an operating system or a language runtime,
+for example a file opening error.
*/
-class SystemError : public internal::RuntimeError {
- private:
- void init(int err_code, CStringRef format_str, ArgList args);
-
- protected:
- int error_code_;
-
- typedef char Char; // For FMT_VARIADIC_CTOR.
-
- SystemError() {}
-
- public:
- /**
- \rst
- Constructs a :class:`fmt::SystemError` object with the description
- of the form
-
- .. parsed-literal::
- *<message>*: *<system-message>*
-
- where *<message>* is the formatted message and *<system-message>* is
- the system message corresponding to the error code.
- *error_code* is a system error code as given by ``errno``.
- If *error_code* is not a valid error code such as -1, the system message
- may look like "Unknown error -1" and is platform-dependent.
-
- **Example**::
-
- // This throws a SystemError 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::SystemError(errno, "cannot open file '{}'", filename);
- \endrst
- */
- SystemError(int error_code, CStringRef message) {
- init(error_code, message, ArgList());
- }
- FMT_VARIADIC_CTOR(SystemError, init, int, CStringRef)
+class SystemError : public internal::RuntimeError
+{
+private:
+ void init(int err_code, CStringRef format_str, ArgList args);
+
+protected:
+ int error_code_;
+
+ typedef char Char; // For FMT_VARIADIC_CTOR.
+
+ SystemError() {}
- int error_code() const { return error_code_; }
+public:
+ /**
+ \rst
+ Constructs a :class:`fmt::SystemError` object with the description
+ of the form
+
+ .. parsed-literal::
+ *<message>*: *<system-message>*
+
+ where *<message>* is the formatted message and *<system-message>* is
+ the system message corresponding to the error code.
+ *error_code* is a system error code as given by ``errno``.
+ If *error_code* is not a valid error code such as -1, the system message
+ may look like "Unknown error -1" and is platform-dependent.
+
+ **Example**::
+
+ // This throws a SystemError 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::SystemError(errno, "cannot open file '{}'", filename);
+ \endrst
+ */
+ SystemError(int error_code, CStringRef message)
+ {
+ init(error_code, message, ArgList());
+ }
+ FMT_VARIADIC_CTOR(SystemError, init, int, CStringRef)
+
+ int error_code() const
+ {
+ return error_code_;
+ }
};
/**
- \rst
- This template provides operations for formatting and writing data into
- a character stream. The output is stored in a buffer provided by a subclass
- such as :class:`fmt::BasicMemoryWriter`.
-
- You can use one of the following typedefs for common character types:
-
- +---------+----------------------+
- | Type | Definition |
- +=========+======================+
- | Writer | BasicWriter<char> |
- +---------+----------------------+
- | WWriter | BasicWriter<wchar_t> |
- +---------+----------------------+
-
- \endrst
- */
+\rst
+This template provides operations for formatting and writing data into
+a character stream. The output is stored in a buffer provided by a subclass
+such as :class:`fmt::BasicMemoryWriter`.
+
+You can use one of the following typedefs for common character types:
+
++---------+----------------------+
+| Type | Definition |
++=========+======================+
+| Writer | BasicWriter<char> |
++---------+----------------------+
+| WWriter | BasicWriter<wchar_t> |
++---------+----------------------+
+
+\endrst
+*/
template <typename Char>
-class BasicWriter {
- private:
- // Output buffer.
- Buffer<Char> &buffer_;
+class BasicWriter
+{
+private:
+ // Output buffer.
+ Buffer<Char> &buffer_;
- FMT_DISALLOW_COPY_AND_ASSIGN(BasicWriter);
+ FMT_DISALLOW_COPY_AND_ASSIGN(BasicWriter);
- typedef typename internal::CharTraits<Char>::CharPtr CharPtr;
+ typedef typename internal::CharTraits<Char>::CharPtr CharPtr;
-#if _SECURE_SCL
- // Returns pointer value.
- static Char *get(CharPtr p) { return p.base(); }
+#if FMT_SECURE_SCL
+ // Returns pointer value.
+ static Char *get(CharPtr p)
+ {
+ return p.base();
+ }
#else
- static Char *get(Char *p) { return p; }
+ static Char *get(Char *p)
+ {
+ return p;
+ }
#endif
- // Fills the padding around the content and returns the pointer to the
- // content area.
- static CharPtr fill_padding(CharPtr buffer,
- unsigned total_size, std::size_t content_size, wchar_t fill);
-
- // Grows the buffer by n characters and returns a pointer to the newly
- // allocated area.
- CharPtr grow_buffer(std::size_t n) {
- std::size_t size = buffer_.size();
- buffer_.resize(size + n);
- return internal::make_ptr(&buffer_[size], n);
- }
+ // Fills the padding around the content and returns the pointer to the
+ // content area.
+ static CharPtr fill_padding(CharPtr buffer,
+ unsigned total_size, std::size_t content_size, wchar_t fill);
+
+ // Grows the buffer by n characters and returns a pointer to the newly
+ // allocated area.
+ CharPtr grow_buffer(std::size_t n)
+ {
+ std::size_t size = buffer_.size();
+ buffer_.resize(size + n);
+ return internal::make_ptr(&buffer_[size], n);
+ }
- // Writes an unsigned decimal integer.
- template <typename UInt>
- Char *write_unsigned_decimal(UInt value, unsigned prefix_size = 0) {
- unsigned num_digits = internal::count_digits(value);
- Char *ptr = get(grow_buffer(prefix_size + num_digits));
- internal::format_decimal(ptr + prefix_size, value, num_digits);
- return ptr;
- }
+ // Writes an unsigned decimal integer.
+ template <typename UInt>
+ Char *write_unsigned_decimal(UInt value, unsigned prefix_size = 0)
+ {
+ unsigned num_digits = internal::count_digits(value);
+ Char *ptr = get(grow_buffer(prefix_size + num_digits));
+ internal::format_decimal(ptr + prefix_size, value, num_digits);
+ return ptr;
+ }
- // Writes a decimal integer.
- template <typename Int>
- void write_decimal(Int value) {
- typename internal::IntTraits<Int>::MainType abs_value = value;
- if (internal::is_negative(value)) {
- abs_value = 0 - abs_value;
- *write_unsigned_decimal(abs_value, 1) = '-';
- } else {
- write_unsigned_decimal(abs_value, 0);
+ // Writes a decimal integer.
+ template <typename Int>
+ void write_decimal(Int value)
+ {
+ typename internal::IntTraits<Int>::MainType abs_value = value;
+ if (internal::is_negative(value))
+ {
+ abs_value = 0 - abs_value;
+ *write_unsigned_decimal(abs_value, 1) = '-';
+ }
+ else
+ {
+ write_unsigned_decimal(abs_value, 0);
+ }
}
- }
- // Prepare a buffer for integer formatting.
- CharPtr prepare_int_buffer(unsigned num_digits,
- const EmptySpec &, const char *prefix, unsigned prefix_size) {
- unsigned size = prefix_size + num_digits;
- CharPtr p = grow_buffer(size);
- std::copy(prefix, prefix + prefix_size, p);
- return p + size - 1;
- }
+ // Prepare a buffer for integer formatting.
+ CharPtr prepare_int_buffer(unsigned num_digits,
+ const EmptySpec &, const char *prefix, unsigned prefix_size)
+ {
+ unsigned size = prefix_size + num_digits;
+ CharPtr p = grow_buffer(size);
+ std::uninitialized_copy(prefix, prefix + prefix_size, p);
+ return p + size - 1;
+ }
- template <typename Spec>
- CharPtr prepare_int_buffer(unsigned num_digits,
- const Spec &spec, const char *prefix, unsigned prefix_size);
-
- // Formats an integer.
- template <typename T, typename Spec>
- void write_int(T value, Spec spec);
-
- // Formats a floating-point number (double or long double).
- template <typename T>
- void write_double(T value, const FormatSpec &spec);
-
- // Writes a formatted string.
- template <typename StrChar>
- CharPtr write_str(
- const StrChar *s, std::size_t size, const AlignSpec &spec);
-
- template <typename StrChar>
- void write_str(
- const internal::Arg::StringValue<StrChar> &str, const FormatSpec &spec);
-
- // This following methods are private to disallow writing wide characters
- // and strings to a char stream. If you want to print a wide string as a
- // pointer as std::ostream does, cast it to const void*.
- // Do not implement!
- void operator<<(typename internal::WCharHelper<wchar_t, Char>::Unsupported);
- void operator<<(
- typename internal::WCharHelper<const wchar_t *, Char>::Unsupported);
-
- // Appends floating-point length specifier to the format string.
- // The second argument is only used for overload resolution.
- void append_float_length(Char *&format_ptr, long double) {
- *format_ptr++ = 'L';
- }
+ template <typename Spec>
+ CharPtr prepare_int_buffer(unsigned num_digits,
+ const Spec &spec, const char *prefix, unsigned prefix_size);
+
+ // Formats an integer.
+ template <typename T, typename Spec>
+ void write_int(T value, Spec spec);
+
+ // Formats a floating-point number (double or long double).
+ template <typename T>
+ void write_double(T value, const FormatSpec &spec);
+
+ // Writes a formatted string.
+ template <typename StrChar>
+ CharPtr write_str(const StrChar *s, std::size_t size, const AlignSpec &spec);
+
+ template <typename StrChar>
+ void write_str(const internal::Arg::StringValue<StrChar> &str,
+ const FormatSpec &spec);
+
+ // This following methods are private to disallow writing wide characters
+ // and strings to a char stream. If you want to print a wide string as a
+ // pointer as std::ostream does, cast it to const void*.
+ // Do not implement!
+ void operator<<(typename internal::WCharHelper<wchar_t, Char>::Unsupported);
+ void operator<<(
+ typename internal::WCharHelper<const wchar_t *, Char>::Unsupported);
+
+ // Appends floating-point length specifier to the format string.
+ // The second argument is only used for overload resolution.
+ void append_float_length(Char *&format_ptr, long double)
+ {
+ *format_ptr++ = 'L';
+ }
- template<typename T>
- void append_float_length(Char *&, T) {}
+ template<typename T>
+ void append_float_length(Char *&, T) {}
- template <typename Impl, typename Char_>
- friend class internal::BasicArgFormatter;
+ template <typename Impl, typename Char_>
+ friend class internal::ArgFormatterBase;
- friend class internal::PrintfArgFormatter<Char>;
+ friend class internal::PrintfArgFormatter<Char>;
- protected:
- /**
+protected:
+ /**
Constructs a ``BasicWriter`` object.
- */
- explicit BasicWriter(Buffer<Char> &b) : buffer_(b) {}
+ */
+ explicit BasicWriter(Buffer<Char> &b) : buffer_(b) {}
- public:
- /**
+public:
+ /**
\rst
Destroys a ``BasicWriter`` object.
\endrst
- */
- virtual ~BasicWriter() {}
+ */
+ virtual ~BasicWriter() {}
- /**
+ /**
Returns the total number of characters written.
- */
- std::size_t size() const { return buffer_.size(); }
+ */
+ std::size_t size() const
+ {
+ return buffer_.size();
+ }
- /**
+ /**
Returns a pointer to the output buffer content. No terminating null
character is appended.
- */
- const Char *data() const FMT_NOEXCEPT { return &buffer_[0]; }
+ */
+ const Char *data() const FMT_NOEXCEPT
+ {
+ return &buffer_[0];
+ }
- /**
+ /**
Returns a pointer to the output buffer content with terminating null
character appended.
- */
- const Char *c_str() const {
- std::size_t size = buffer_.size();
- buffer_.reserve(size + 1);
- buffer_[size] = '\0';
- return &buffer_[0];
- }
+ */
+ const Char *c_str() const
+ {
+ std::size_t size = buffer_.size();
+ buffer_.reserve(size + 1);
+ buffer_[size] = '\0';
+ return &buffer_[0];
+ }
- /**
+ /**
\rst
Returns the content of the output buffer as an `std::string`.
\endrst
- */
- std::basic_string<Char> str() const {
- return std::basic_string<Char>(&buffer_[0], buffer_.size());
- }
+ */
+ std::basic_string<Char> str() const
+ {
+ return std::basic_string<Char>(&buffer_[0], buffer_.size());
+ }
- /**
+ /**
\rst
Writes formatted data.
-
+
*args* is an argument list representing arbitrary arguments.
**Example**::
- MemoryWriter out;
- out.write("Current point:\n");
- out.write("({:+f}, {:+f})", -3.14, 3.14);
+ MemoryWriter out;
+ out.write("Current point:\n");
+ out.write("({:+f}, {:+f})", -3.14, 3.14);
This will write the following output to the ``out`` object:
.. code-block:: none
- Current point:
- (-3.140000, +3.140000)
+ Current point:
+ (-3.140000, +3.140000)
The output can be accessed using :func:`data()`, :func:`c_str` or
:func:`str` methods.
See also :ref:`syntax`.
\endrst
- */
- void write(BasicCStringRef<Char> format, ArgList args) {
- BasicFormatter<Char>(args, *this).format(format);
- }
- FMT_VARIADIC_VOID(write, BasicCStringRef<Char>)
+ */
+ void write(BasicCStringRef<Char> format, ArgList args)
+ {
+ BasicFormatter<Char>(args, *this).format(format);
+ }
+ FMT_VARIADIC_VOID(write, BasicCStringRef<Char>)
- BasicWriter &operator<<(int value) {
- write_decimal(value);
- return *this;
- }
- BasicWriter &operator<<(unsigned value) {
- return *this << IntFormatSpec<unsigned>(value);
- }
- BasicWriter &operator<<(long value) {
- write_decimal(value);
- return *this;
- }
- BasicWriter &operator<<(unsigned long value) {
- return *this << IntFormatSpec<unsigned long>(value);
- }
- BasicWriter &operator<<(LongLong value) {
- write_decimal(value);
- return *this;
- }
+ BasicWriter &operator<<(int value)
+ {
+ write_decimal(value);
+ return *this;
+ }
+ BasicWriter &operator<<(unsigned value)
+ {
+ return *this << IntFormatSpec<unsigned>(value);
+ }
+ BasicWriter &operator<<(long value)
+ {
+ write_decimal(value);
+ return *this;
+ }
+ BasicWriter &operator<<(unsigned long value)
+ {
+ return *this << IntFormatSpec<unsigned long>(value);
+ }
+ BasicWriter &operator<<(LongLong value)
+ {
+ write_decimal(value);
+ return *this;
+ }
- /**
+ /**
\rst
Formats *value* and writes it to the stream.
\endrst
- */
- BasicWriter &operator<<(ULongLong value) {
- return *this << IntFormatSpec<ULongLong>(value);
- }
+ */
+ BasicWriter &operator<<(ULongLong value)
+ {
+ return *this << IntFormatSpec<ULongLong>(value);
+ }
- BasicWriter &operator<<(double value) {
- write_double(value, FormatSpec());
- return *this;
- }
+ BasicWriter &operator<<(double value)
+ {
+ write_double(value, FormatSpec());
+ return *this;
+ }
- /**
+ /**
\rst
Formats *value* using the general format for floating-point numbers
(``'g'``) and writes it to the stream.
\endrst
- */
- BasicWriter &operator<<(long double value) {
- write_double(value, FormatSpec());
- return *this;
- }
+ */
+ BasicWriter &operator<<(long double value)
+ {
+ write_double(value, FormatSpec());
+ return *this;
+ }
- /**
+ /**
Writes a character to the stream.
- */
- BasicWriter &operator<<(char value) {
- buffer_.push_back(value);
- return *this;
- }
+ */
+ BasicWriter &operator<<(char value)
+ {
+ buffer_.push_back(value);
+ return *this;
+ }
- BasicWriter &operator<<(
- typename internal::WCharHelper<wchar_t, Char>::Supported value) {
- buffer_.push_back(value);
- return *this;
- }
+ BasicWriter &operator<<(
+ typename internal::WCharHelper<wchar_t, Char>::Supported value)
+ {
+ buffer_.push_back(value);
+ return *this;
+ }
- /**
+ /**
\rst
Writes *value* to the stream.
\endrst
- */
- BasicWriter &operator<<(fmt::BasicStringRef<Char> value) {
- const Char *str = value.data();
- buffer_.append(str, str + value.size());
- return *this;
- }
+ */
+ BasicWriter &operator<<(fmt::BasicStringRef<Char> value)
+ {
+ const Char *str = value.data();
+ buffer_.append(str, str + value.size());
+ return *this;
+ }
- BasicWriter &operator<<(
- typename internal::WCharHelper<StringRef, Char>::Supported value) {
- const char *str = value.data();
- buffer_.append(str, str + value.size());
- return *this;
- }
+ BasicWriter &operator<<(
+ typename internal::WCharHelper<StringRef, Char>::Supported value)
+ {
+ const char *str = value.data();
+ buffer_.append(str, str + value.size());
+ return *this;
+ }
- template <typename T, typename Spec, typename FillChar>
- BasicWriter &operator<<(IntFormatSpec<T, Spec, FillChar> spec) {
- internal::CharTraits<Char>::convert(FillChar());
- write_int(spec.value(), spec);
- return *this;
- }
+ template <typename T, typename Spec, typename FillChar>
+ BasicWriter &operator<<(IntFormatSpec<T, Spec, FillChar> spec)
+ {
+ internal::CharTraits<Char>::convert(FillChar());
+ write_int(spec.value(), spec);
+ return *this;
+ }
- template <typename StrChar>
- BasicWriter &operator<<(const StrFormatSpec<StrChar> &spec) {
- const StrChar *s = spec.str();
- write_str(s, std::char_traits<Char>::length(s), spec);
- return *this;
- }
+ template <typename StrChar>
+ BasicWriter &operator<<(const StrFormatSpec<StrChar> &spec)
+ {
+ const StrChar *s = spec.str();
+ write_str(s, std::char_traits<Char>::length(s), spec);
+ return *this;
+ }
- void clear() FMT_NOEXCEPT { buffer_.clear(); }
+ void clear() FMT_NOEXCEPT { buffer_.clear(); }
};
template <typename Char>
template <typename StrChar>
typename BasicWriter<Char>::CharPtr BasicWriter<Char>::write_str(
- const StrChar *s, std::size_t size, const AlignSpec &spec) {
- CharPtr out = CharPtr();
- if (spec.width() > size) {
- out = grow_buffer(spec.width());
- Char fill = internal::CharTraits<Char>::cast(spec.fill());
- if (spec.align() == ALIGN_RIGHT) {
- std::fill_n(out, spec.width() - size, fill);
- out += spec.width() - size;
- } else if (spec.align() == ALIGN_CENTER) {
- out = fill_padding(out, spec.width(), size, fill);
- } else {
- std::fill_n(out + size, spec.width() - size, fill);
- }
- } else {
- out = grow_buffer(size);
- }
- std::copy(s, s + size, out);
- return out;
+ const StrChar *s, std::size_t size, const AlignSpec &spec)
+{
+ CharPtr out = CharPtr();
+ if (spec.width() > size)
+ {
+ out = grow_buffer(spec.width());
+ Char fill = internal::CharTraits<Char>::cast(spec.fill());
+ if (spec.align() == ALIGN_RIGHT)
+ {
+ std::uninitialized_fill_n(out, spec.width() - size, fill);
+ out += spec.width() - size;
+ }
+ else if (spec.align() == ALIGN_CENTER)
+ {
+ out = fill_padding(out, spec.width(), size, fill);
+ }
+ else
+ {
+ std::uninitialized_fill_n(out + size, spec.width() - size, fill);
+ }
+ }
+ else
+ {
+ out = grow_buffer(size);
+ }
+ std::uninitialized_copy(s, s + size, out);
+ return out;
+}
+
+template <typename Char>
+template <typename StrChar>
+void BasicWriter<Char>::write_str(
+ const internal::Arg::StringValue<StrChar> &s, const FormatSpec &spec)
+{
+ // Check if StrChar is convertible to Char.
+ internal::CharTraits<Char>::convert(StrChar());
+ if (spec.type_ && spec.type_ != 's')
+ internal::report_unknown_type(spec.type_, "string");
+ const StrChar *str_value = s.value;
+ std::size_t str_size = s.size;
+ if (str_size == 0)
+ {
+ if (!str_value)
+ {
+ FMT_THROW(FormatError("string pointer is null"));
+ return;
+ }
+ }
+ std::size_t precision = spec.precision_;
+ if (spec.precision_ >= 0 && precision < str_size)
+ str_size = spec.precision_;
+ write_str(str_value, str_size, spec);
}
template <typename Char>
typename BasicWriter<Char>::CharPtr
- BasicWriter<Char>::fill_padding(
+BasicWriter<Char>::fill_padding(
CharPtr buffer, unsigned total_size,
- std::size_t content_size, wchar_t fill) {
- std::size_t padding = total_size - content_size;
- std::size_t left_padding = padding / 2;
- Char fill_char = internal::CharTraits<Char>::cast(fill);
- std::fill_n(buffer, left_padding, fill_char);
- buffer += left_padding;
- CharPtr content = buffer;
- std::fill_n(buffer + content_size, padding - left_padding, fill_char);
- return content;
+ std::size_t content_size, wchar_t fill)
+{
+ std::size_t padding = total_size - content_size;
+ std::size_t left_padding = padding / 2;
+ Char fill_char = internal::CharTraits<Char>::cast(fill);
+ std::uninitialized_fill_n(buffer, left_padding, fill_char);
+ buffer += left_padding;
+ CharPtr content = buffer;
+ std::uninitialized_fill_n(buffer + content_size,
+ padding - left_padding, fill_char);
+ return content;
}
template <typename Char>
template <typename Spec>
typename BasicWriter<Char>::CharPtr
- BasicWriter<Char>::prepare_int_buffer(
+BasicWriter<Char>::prepare_int_buffer(
unsigned num_digits, const Spec &spec,
- const char *prefix, unsigned prefix_size) {
- unsigned width = spec.width();
- Alignment align = spec.align();
- Char fill = internal::CharTraits<Char>::cast(spec.fill());
- if (spec.precision() > static_cast<int>(num_digits)) {
- // Octal prefix '0' is counted as a digit, so ignore it if precision
- // is specified.
- if (prefix_size > 0 && prefix[prefix_size - 1] == '0')
- --prefix_size;
- unsigned number_size = prefix_size + spec.precision();
- AlignSpec subspec(number_size, '0', ALIGN_NUMERIC);
- if (number_size >= width)
- return prepare_int_buffer(num_digits, subspec, prefix, prefix_size);
- buffer_.reserve(width);
- unsigned fill_size = width - number_size;
- if (align != ALIGN_LEFT) {
- CharPtr p = grow_buffer(fill_size);
- std::fill(p, p + fill_size, fill);
- }
- CharPtr result = prepare_int_buffer(
- num_digits, subspec, prefix, prefix_size);
- if (align == ALIGN_LEFT) {
- CharPtr p = grow_buffer(fill_size);
- std::fill(p, p + fill_size, fill);
- }
- return result;
- }
- unsigned size = prefix_size + num_digits;
- if (width <= size) {
- CharPtr p = grow_buffer(size);
- std::copy(prefix, prefix + prefix_size, p);
- return p + size - 1;
- }
- CharPtr p = grow_buffer(width);
- CharPtr end = p + width;
- if (align == ALIGN_LEFT) {
- std::copy(prefix, prefix + prefix_size, p);
- p += size;
- std::fill(p, end, fill);
- } else if (align == ALIGN_CENTER) {
- p = fill_padding(p, width, size, fill);
- std::copy(prefix, prefix + prefix_size, p);
- p += size;
- } else {
- if (align == ALIGN_NUMERIC) {
- if (prefix_size != 0) {
- p = std::copy(prefix, prefix + prefix_size, p);
- size -= prefix_size;
- }
- } else {
- std::copy(prefix, prefix + prefix_size, end - size);
+ const char *prefix, unsigned prefix_size)
+{
+ unsigned width = spec.width();
+ Alignment align = spec.align();
+ Char fill = internal::CharTraits<Char>::cast(spec.fill());
+ if (spec.precision() > static_cast<int>(num_digits))
+ {
+ // Octal prefix '0' is counted as a digit, so ignore it if precision
+ // is specified.
+ if (prefix_size > 0 && prefix[prefix_size - 1] == '0')
+ --prefix_size;
+ unsigned number_size = prefix_size + spec.precision();
+ AlignSpec subspec(number_size, '0', ALIGN_NUMERIC);
+ if (number_size >= width)
+ return prepare_int_buffer(num_digits, subspec, prefix, prefix_size);
+ buffer_.reserve(width);
+ unsigned fill_size = width - number_size;
+ if (align != ALIGN_LEFT)
+ {
+ CharPtr p = grow_buffer(fill_size);
+ std::uninitialized_fill(p, p + fill_size, fill);
+ }
+ CharPtr result = prepare_int_buffer(
+ num_digits, subspec, prefix, prefix_size);
+ if (align == ALIGN_LEFT)
+ {
+ CharPtr p = grow_buffer(fill_size);
+ std::uninitialized_fill(p, p + fill_size, fill);
+ }
+ return result;
}
- std::fill(p, end - size, fill);
- p = end;
- }
- return p - 1;
+ unsigned size = prefix_size + num_digits;
+ if (width <= size)
+ {
+ CharPtr p = grow_buffer(size);
+ std::uninitialized_copy(prefix, prefix + prefix_size, p);
+ return p + size - 1;
+ }
+ CharPtr p = grow_buffer(width);
+ CharPtr end = p + width;
+ if (align == ALIGN_LEFT)
+ {
+ std::uninitialized_copy(prefix, prefix + prefix_size, p);
+ p += size;
+ std::uninitialized_fill(p, end, fill);
+ }
+ else if (align == ALIGN_CENTER)
+ {
+ p = fill_padding(p, width, size, fill);
+ std::uninitialized_copy(prefix, prefix + prefix_size, p);
+ p += size;
+ }
+ else
+ {
+ if (align == ALIGN_NUMERIC)
+ {
+ if (prefix_size != 0)
+ {
+ p = std::uninitialized_copy(prefix, prefix + prefix_size, p);
+ size -= prefix_size;
+ }
+ }
+ else
+ {
+ std::uninitialized_copy(prefix, prefix + prefix_size, end - size);
+ }
+ std::uninitialized_fill(p, end - size, fill);
+ p = end;
+ }
+ return p - 1;
}
template <typename Char>
template <typename T, typename Spec>
-void BasicWriter<Char>::write_int(T value, Spec spec) {
- unsigned prefix_size = 0;
- typedef typename internal::IntTraits<T>::MainType UnsignedType;
- UnsignedType abs_value = value;
- char prefix[4] = "";
- if (internal::is_negative(value)) {
- prefix[0] = '-';
- ++prefix_size;
- abs_value = 0 - abs_value;
- } else if (spec.flag(SIGN_FLAG)) {
- prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' ';
- ++prefix_size;
- }
- switch (spec.type()) {
- case 0: case 'd': {
- unsigned num_digits = internal::count_digits(abs_value);
- CharPtr p = prepare_int_buffer(
- num_digits, spec, prefix, prefix_size) + 1 - num_digits;
- internal::format_decimal(get(p), abs_value, num_digits);
- break;
- }
- case 'x': case 'X': {
- UnsignedType n = abs_value;
- if (spec.flag(HASH_FLAG)) {
- prefix[prefix_size++] = '0';
- prefix[prefix_size++] = spec.type();
- }
- unsigned num_digits = 0;
- do {
- ++num_digits;
- } while ((n >>= 4) != 0);
- Char *p = get(prepare_int_buffer(
- num_digits, spec, prefix, prefix_size));
- n = abs_value;
- const char *digits = spec.type() == 'x' ?
- "0123456789abcdef" : "0123456789ABCDEF";
- do {
- *p-- = digits[n & 0xf];
- } while ((n >>= 4) != 0);
- break;
- }
- case 'b': case 'B': {
- UnsignedType n = abs_value;
- if (spec.flag(HASH_FLAG)) {
- prefix[prefix_size++] = '0';
- prefix[prefix_size++] = spec.type();
- }
- unsigned num_digits = 0;
- do {
- ++num_digits;
- } while ((n >>= 1) != 0);
- Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
- n = abs_value;
- do {
- *p-- = '0' + (n & 1);
- } while ((n >>= 1) != 0);
- break;
- }
- case 'o': {
- UnsignedType n = abs_value;
- if (spec.flag(HASH_FLAG))
- prefix[prefix_size++] = '0';
- unsigned num_digits = 0;
- do {
- ++num_digits;
- } while ((n >>= 3) != 0);
- Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
- n = abs_value;
- do {
- *p-- = '0' + (n & 7);
- } while ((n >>= 3) != 0);
- break;
- }
- default:
- internal::report_unknown_type(
- spec.type(), spec.flag(CHAR_FLAG) ? "char" : "integer");
- break;
- }
+void BasicWriter<Char>::write_int(T value, Spec spec)
+{
+ unsigned prefix_size = 0;
+ typedef typename internal::IntTraits<T>::MainType UnsignedType;
+ UnsignedType abs_value = value;
+ char prefix[4] = "";
+ if (internal::is_negative(value))
+ {
+ prefix[0] = '-';
+ ++prefix_size;
+ abs_value = 0 - abs_value;
+ }
+ else if (spec.flag(SIGN_FLAG))
+ {
+ prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' ';
+ ++prefix_size;
+ }
+ switch (spec.type())
+ {
+ case 0:
+ case 'd':
+ {
+ unsigned num_digits = internal::count_digits(abs_value);
+ CharPtr p = prepare_int_buffer(
+ num_digits, spec, prefix, prefix_size) + 1 - num_digits;
+ internal::format_decimal(get(p), abs_value, num_digits);
+ break;
+ }
+ case 'x':
+ case 'X':
+ {
+ UnsignedType n = abs_value;
+ if (spec.flag(HASH_FLAG))
+ {
+ prefix[prefix_size++] = '0';
+ prefix[prefix_size++] = spec.type();
+ }
+ unsigned num_digits = 0;
+ do
+ {
+ ++num_digits;
+ }
+ while ((n >>= 4) != 0);
+ Char *p = get(prepare_int_buffer(
+ num_digits, spec, prefix, prefix_size));
+ n = abs_value;
+ const char *digits = spec.type() == 'x' ?
+ "0123456789abcdef" : "0123456789ABCDEF";
+ do
+ {
+ *p-- = digits[n & 0xf];
+ }
+ while ((n >>= 4) != 0);
+ break;
+ }
+ case 'b':
+ case 'B':
+ {
+ UnsignedType n = abs_value;
+ if (spec.flag(HASH_FLAG))
+ {
+ prefix[prefix_size++] = '0';
+ prefix[prefix_size++] = spec.type();
+ }
+ unsigned num_digits = 0;
+ do
+ {
+ ++num_digits;
+ }
+ while ((n >>= 1) != 0);
+ Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
+ n = abs_value;
+ do
+ {
+ *p-- = static_cast<Char>('0' + (n & 1));
+ }
+ while ((n >>= 1) != 0);
+ break;
+ }
+ case 'o':
+ {
+ UnsignedType n = abs_value;
+ if (spec.flag(HASH_FLAG))
+ prefix[prefix_size++] = '0';
+ unsigned num_digits = 0;
+ do
+ {
+ ++num_digits;
+ }
+ while ((n >>= 3) != 0);
+ Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
+ n = abs_value;
+ do
+ {
+ *p-- = static_cast<Char>('0' + (n & 7));
+ }
+ while ((n >>= 3) != 0);
+ break;
+ }
+ default:
+ internal::report_unknown_type(
+ spec.type(), spec.flag(CHAR_FLAG) ? "char" : "integer");
+ break;
+ }
}
template <typename Char>
template <typename T>
void BasicWriter<Char>::write_double(
- T value, const FormatSpec &spec) {
- // Check type.
- char type = spec.type();
- bool upper = false;
- switch (type) {
- case 0:
- type = 'g';
- break;
- case 'e': case 'f': case 'g': case 'a':
- break;
- case 'F':
+ T value, const FormatSpec &spec)
+{
+ // Check type.
+ char type = spec.type();
+ bool upper = false;
+ switch (type)
+ {
+ case 0:
+ type = 'g';
+ break;
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'a':
+ break;
+ case 'F':
#ifdef _MSC_VER
- // MSVC's printf doesn't support 'F'.
- type = 'f';
+ // MSVC's printf doesn't support 'F'.
+ type = 'f';
#endif
// Fall through.
- case 'E': case 'G': case 'A':
- upper = true;
- break;
- default:
- internal::report_unknown_type(type, "double");
- break;
- }
+ case 'E':
+ case 'G':
+ case 'A':
+ upper = true;
+ break;
+ default:
+ internal::report_unknown_type(type, "double");
+ break;
+ }
- char sign = 0;
- // Use getsign instead of value < 0 because the latter is always
- // false for NaN.
- if (internal::getsign(static_cast<double>(value))) {
- sign = '-';
- value = -value;
- } else if (spec.flag(SIGN_FLAG)) {
- sign = spec.flag(PLUS_FLAG) ? '+' : ' ';
- }
+ char sign = 0;
+ // Use isnegative instead of value < 0 because the latter is always
+ // false for NaN.
+ if (internal::FPUtil::isnegative(static_cast<double>(value)))
+ {
+ sign = '-';
+ value = -value;
+ }
+ else if (spec.flag(SIGN_FLAG))
+ {
+ sign = spec.flag(PLUS_FLAG) ? '+' : ' ';
+ }
- if (value != value) {
- // Format NaN ourselves because sprintf's output is not consistent
- // across platforms.
- std::size_t nan_size = 4;
- const char *nan = upper ? " NAN" : " nan";
- if (!sign) {
- --nan_size;
- ++nan;
+ if (internal::FPUtil::isnotanumber(value))
+ {
+ // Format NaN ourselves because sprintf's output is not consistent
+ // across platforms.
+ std::size_t nan_size = 4;
+ const char *nan = upper ? " NAN" : " nan";
+ if (!sign)
+ {
+ --nan_size;
+ ++nan;
+ }
+ CharPtr out = write_str(nan, nan_size, spec);
+ if (sign)
+ *out = sign;
+ return;
}
- CharPtr out = write_str(nan, nan_size, spec);
- if (sign)
- *out = sign;
- return;
- }
- if (internal::isinfinity(value)) {
- // Format infinity ourselves because sprintf's output is not consistent
- // across platforms.
- std::size_t inf_size = 4;
- const char *inf = upper ? " INF" : " inf";
- if (!sign) {
- --inf_size;
- ++inf;
+ if (internal::FPUtil::isinfinity(value))
+ {
+ // Format infinity ourselves because sprintf's output is not consistent
+ // across platforms.
+ std::size_t inf_size = 4;
+ const char *inf = upper ? " INF" : " inf";
+ if (!sign)
+ {
+ --inf_size;
+ ++inf;
+ }
+ CharPtr out = write_str(inf, inf_size, spec);
+ if (sign)
+ *out = sign;
+ return;
}
- CharPtr out = write_str(inf, inf_size, spec);
+
+ std::size_t offset = buffer_.size();
+ unsigned width = spec.width();
if (sign)
- *out = sign;
- return;
- }
+ {
+ buffer_.reserve(buffer_.size() + (width > 1u ? width : 1u));
+ if (width > 0)
+ --width;
+ ++offset;
+ }
- std::size_t offset = buffer_.size();
- unsigned width = spec.width();
- if (sign) {
- buffer_.reserve(buffer_.size() + (std::max)(width, 1u));
- if (width > 0)
- --width;
- ++offset;
- }
+ // Build format string.
+ enum { MAX_FORMAT_SIZE = 10 }; // longest format: %#-*.*Lg
+ Char format[MAX_FORMAT_SIZE];
+ Char *format_ptr = format;
+ *format_ptr++ = '%';
+ unsigned width_for_sprintf = width;
+ if (spec.flag(HASH_FLAG))
+ *format_ptr++ = '#';
+ if (spec.align() == ALIGN_CENTER)
+ {
+ width_for_sprintf = 0;
+ }
+ else
+ {
+ if (spec.align() == ALIGN_LEFT)
+ *format_ptr++ = '-';
+ if (width != 0)
+ *format_ptr++ = '*';
+ }
+ if (spec.precision() >= 0)
+ {
+ *format_ptr++ = '.';
+ *format_ptr++ = '*';
+ }
- // Build format string.
- enum { MAX_FORMAT_SIZE = 10}; // longest format: %#-*.*Lg
- Char format[MAX_FORMAT_SIZE];
- Char *format_ptr = format;
- *format_ptr++ = '%';
- unsigned width_for_sprintf = width;
- if (spec.flag(HASH_FLAG))
- *format_ptr++ = '#';
- if (spec.align() == ALIGN_CENTER) {
- width_for_sprintf = 0;
- } else {
- if (spec.align() == ALIGN_LEFT)
- *format_ptr++ = '-';
- if (width != 0)
- *format_ptr++ = '*';
- }
- if (spec.precision() >= 0) {
- *format_ptr++ = '.';
- *format_ptr++ = '*';
- }
+ append_float_length(format_ptr, value);
+ *format_ptr++ = type;
+ *format_ptr = '\0';
- append_float_length(format_ptr, value);
- *format_ptr++ = type;
- *format_ptr = '\0';
-
- // Format using snprintf.
- Char fill = internal::CharTraits<Char>::cast(spec.fill());
- for (;;) {
- std::size_t buffer_size = buffer_.capacity() - offset;
-#if _MSC_VER
- // MSVC's vsnprintf_s doesn't work with zero size, so reserve
- // space for at least one extra character to make the size non-zero.
- // Note that the buffer's capacity will increase by more than 1.
- if (buffer_size == 0) {
- buffer_.reserve(offset + 1);
- buffer_size = buffer_.capacity() - offset;
- }
+ // Format using snprintf.
+ Char fill = internal::CharTraits<Char>::cast(spec.fill());
+ for (;;)
+ {
+ std::size_t buffer_size = buffer_.capacity() - offset;
+#ifdef _MSC_VER
+ // MSVC's vsnprintf_s doesn't work with zero size, so reserve
+ // space for at least one extra character to make the size non-zero.
+ // Note that the buffer's capacity will increase by more than 1.
+ if (buffer_size == 0)
+ {
+ buffer_.reserve(offset + 1);
+ buffer_size = buffer_.capacity() - offset;
+ }
#endif
- Char *start = &buffer_[offset];
- int n = internal::CharTraits<Char>::format_float(
- start, buffer_size, format, width_for_sprintf, spec.precision(), value);
- if (n >= 0 && offset + n < buffer_.capacity()) {
- if (sign) {
- if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) ||
- *start != ' ') {
- *(start - 1) = sign;
- sign = 0;
- } else {
- *(start - 1) = fill;
+ Char *start = &buffer_[offset];
+ int n = internal::CharTraits<Char>::format_float(
+ start, buffer_size, format, width_for_sprintf, spec.precision(), value);
+ if (n >= 0 && offset + n < buffer_.capacity())
+ {
+ if (sign)
+ {
+ if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) ||
+ *start != ' ')
+ {
+ *(start - 1) = sign;
+ sign = 0;
+ }
+ else
+ {
+ *(start - 1) = fill;
+ }
+ ++n;
+ }
+ if (spec.align() == ALIGN_CENTER &&
+ spec.width() > static_cast<unsigned>(n))
+ {
+ width = spec.width();
+ CharPtr p = grow_buffer(width);
+ std::memmove(get(p) + (width - n) / 2, get(p), n * sizeof(Char));
+ fill_padding(p, spec.width(), n, fill);
+ return;
+ }
+ if (spec.fill() != ' ' || sign)
+ {
+ while (*start == ' ')
+ *start++ = fill;
+ if (sign)
+ *(start - 1) = sign;
+ }
+ grow_buffer(n);
+ return;
}
- ++n;
- }
- if (spec.align() == ALIGN_CENTER &&
- spec.width() > static_cast<unsigned>(n)) {
- width = spec.width();
- CharPtr p = grow_buffer(width);
- std::copy(p, p + n, p + (width - n) / 2);
- fill_padding(p, spec.width(), n, fill);
- return;
- }
- if (spec.fill() != ' ' || sign) {
- while (*start == ' ')
- *start++ = fill;
- if (sign)
- *(start - 1) = sign;
- }
- grow_buffer(n);
- return;
+ // If n is negative we ask to increase the capacity by at least 1,
+ // but as std::vector, the buffer grows exponentially.
+ buffer_.reserve(n >= 0 ? offset + n + 1 : buffer_.capacity() + 1);
}
- // If n is negative we ask to increase the capacity by at least 1,
- // but as std::vector, the buffer grows exponentially.
- buffer_.reserve(n >= 0 ? offset + n + 1 : buffer_.capacity() + 1);
- }
}
/**
- \rst
- This class template provides operations for formatting and writing data
- into a character stream. The output is stored in a memory buffer that grows
- dynamically.
+\rst
+This class template provides operations for formatting and writing data
+into a character stream. The output is stored in a memory buffer that grows
+dynamically.
- You can use one of the following typedefs for common character types
- and the standard allocator:
+You can use one of the following typedefs for common character types
+and the standard allocator:
- +---------------+-----------------------------------------------------+
- | Type | Definition |
- +===============+=====================================================+
- | MemoryWriter | BasicMemoryWriter<char, std::allocator<char>> |
- +---------------+-----------------------------------------------------+
- | WMemoryWriter | BasicMemoryWriter<wchar_t, std::allocator<wchar_t>> |
- +---------------+-----------------------------------------------------+
++---------------+-----------------------------------------------------+
+| Type | Definition |
++===============+=====================================================+
+| MemoryWriter | BasicMemoryWriter<char, std::allocator<char>> |
++---------------+-----------------------------------------------------+
+| WMemoryWriter | BasicMemoryWriter<wchar_t, std::allocator<wchar_t>> |
++---------------+-----------------------------------------------------+
- **Example**::
+**Example**::
- MemoryWriter out;
- out << "The answer is " << 42 << "\n";
- out.write("({:+f}, {:+f})", -3.14, 3.14);
+MemoryWriter out;
+out << "The answer is " << 42 << "\n";
+out.write("({:+f}, {:+f})", -3.14, 3.14);
- This will write the following output to the ``out`` object:
+This will write the following output to the ``out`` object:
- .. code-block:: none
+.. code-block:: none
- The answer is 42
- (-3.140000, +3.140000)
+The answer is 42
+(-3.140000, +3.140000)
- The output can be converted to an ``std::string`` with ``out.str()`` or
- accessed as a C string with ``out.c_str()``.
- \endrst
- */
+The output can be converted to an ``std::string`` with ``out.str()`` or
+accessed as a C string with ``out.c_str()``.
+\endrst
+*/
template <typename Char, typename Allocator = std::allocator<Char> >
-class BasicMemoryWriter : public BasicWriter<Char> {
- private:
- internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE, Allocator> buffer_;
+class BasicMemoryWriter : public BasicWriter<Char>
+{
+private:
+ internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE, Allocator> buffer_;
- public:
- explicit BasicMemoryWriter(const Allocator& alloc = Allocator())
- : BasicWriter<Char>(buffer_), buffer_(alloc) {}
+public:
+ explicit BasicMemoryWriter(const Allocator& alloc = Allocator())
+ : BasicWriter<Char>(buffer_), buffer_(alloc) {}
#if FMT_USE_RVALUE_REFERENCES
- /**
+ /**
\rst
Constructs a :class:`fmt::BasicMemoryWriter` object moving the content
of the other object to it.
\endrst
- */
- BasicMemoryWriter(BasicMemoryWriter &&other)
- : BasicWriter<Char>(buffer_), buffer_(std::move(other.buffer_)) {
- }
+ */
+ BasicMemoryWriter(BasicMemoryWriter &&other)
+ : BasicWriter<Char>(buffer_), buffer_(std::move(other.buffer_))
+ {
+ }
- /**
+ /**
\rst
Moves the content of the other ``BasicMemoryWriter`` object to this one.
\endrst
- */
- BasicMemoryWriter &operator=(BasicMemoryWriter &&other) {
- buffer_ = std::move(other.buffer_);
- return *this;
- }
+ */
+ BasicMemoryWriter &operator=(BasicMemoryWriter &&other)
+ {
+ buffer_ = std::move(other.buffer_);
+ return *this;
+ }
#endif
};
@@ -2512,49 +3390,50 @@ typedef BasicMemoryWriter<char> MemoryWriter;
typedef BasicMemoryWriter<wchar_t> WMemoryWriter;
/**
- \rst
- This class template provides operations for formatting and writing data
- into a fixed-size array. For writing into a dynamically growing buffer
- use :class:`fmt::BasicMemoryWriter`.
-
- Any write method will throw ``std::runtime_error`` if the output doesn't fit
- into the array.
-
- You can use one of the following typedefs for common character types:
-
- +--------------+---------------------------+
- | Type | Definition |
- +==============+===========================+
- | ArrayWriter | BasicArrayWriter<char> |
- +--------------+---------------------------+
- | WArrayWriter | BasicArrayWriter<wchar_t> |
- +--------------+---------------------------+
- \endrst
- */
+\rst
+This class template provides operations for formatting and writing data
+into a fixed-size array. For writing into a dynamically growing buffer
+use :class:`fmt::BasicMemoryWriter`.
+
+Any write method will throw ``std::runtime_error`` if the output doesn't fit
+into the array.
+
+You can use one of the following typedefs for common character types:
+
++--------------+---------------------------+
+| Type | Definition |
++==============+===========================+
+| ArrayWriter | BasicArrayWriter<char> |
++--------------+---------------------------+
+| WArrayWriter | BasicArrayWriter<wchar_t> |
++--------------+---------------------------+
+\endrst
+*/
template <typename Char>
-class BasicArrayWriter : public BasicWriter<Char> {
- private:
- internal::FixedBuffer<Char> buffer_;
-
- public:
- /**
- \rst
- Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the
- given size.
- \endrst
- */
- BasicArrayWriter(Char *array, std::size_t size)
- : BasicWriter<Char>(buffer_), buffer_(array, size) {}
-
- /**
- \rst
- Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the
- size known at compile time.
- \endrst
- */
- template <std::size_t SIZE>
- explicit BasicArrayWriter(Char (&array)[SIZE])
- : BasicWriter<Char>(buffer_), buffer_(array, SIZE) {}
+class BasicArrayWriter : public BasicWriter<Char>
+{
+private:
+ internal::FixedBuffer<Char> buffer_;
+
+public:
+ /**
+ \rst
+ Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the
+ given size.
+ \endrst
+ */
+ BasicArrayWriter(Char *array, std::size_t size)
+ : BasicWriter<Char>(buffer_), buffer_(array, size) {}
+
+ /**
+ \rst
+ Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the
+ size known at compile time.
+ \endrst
+ */
+ template <std::size_t SIZE>
+ explicit BasicArrayWriter(Char(&array)[SIZE])
+ : BasicWriter<Char>(buffer_), buffer_(array, SIZE) {}
};
typedef BasicArrayWriter<char> ArrayWriter;
@@ -2562,298 +3441,338 @@ typedef BasicArrayWriter<wchar_t> WArrayWriter;
// Formats a value.
template <typename Char, typename T>
-void format(BasicFormatter<Char> &f, const Char *&format_str, const T &value) {
- std::basic_ostringstream<Char> os;
- os << value;
- std::basic_string<Char> str = os.str();
- internal::Arg arg = internal::MakeValue<Char>(str);
- arg.type = static_cast<internal::Arg::Type>(
- internal::MakeValue<Char>::type(str));
- format_str = f.format(format_str, arg);
+void format(BasicFormatter<Char> &f, const Char *&format_str, const T &value)
+{
+ internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer;
+
+ internal::FormatBuf<Char> format_buf(buffer);
+ std::basic_ostream<Char> output(&format_buf);
+ output << value;
+
+ BasicStringRef<Char> str(&buffer[0], format_buf.size());
+ typedef internal::MakeValue< BasicFormatter<Char> > MakeValue;
+ internal::Arg arg = MakeValue(str);
+ arg.type = static_cast<internal::Arg::Type>(MakeValue::type(str));
+ format_str = f.format(format_str, arg);
}
// Reports a system error without throwing an exception.
// Can be used to report errors from destructors.
-void report_system_error(int error_code, StringRef message) FMT_NOEXCEPT;
+FMT_API void report_system_error(int error_code,
+ StringRef message) FMT_NOEXCEPT;
#if FMT_USE_WINDOWS_H
/** A Windows error. */
-class WindowsError : public SystemError {
- private:
- void init(int error_code, CStringRef format_str, ArgList args);
-
- public:
- /**
- \rst
- Constructs a :class:`fmt::WindowsError` object with the description
- of the form
-
- .. parsed-literal::
- *<message>*: *<system-message>*
-
- where *<message>* is the formatted message and *<system-message>* 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 WindowsError 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::WindowsError(GetLastError(),
- "cannot open file '{}'", filename);
- }
- \endrst
- */
- WindowsError(int error_code, CStringRef message) {
- init(error_code, message, ArgList());
- }
- FMT_VARIADIC_CTOR(WindowsError, init, int, CStringRef)
+class WindowsError : public SystemError
+{
+private:
+ FMT_API void init(int error_code, CStringRef format_str, ArgList args);
+
+public:
+ /**
+ \rst
+ Constructs a :class:`fmt::WindowsError` object with the description
+ of the form
+
+ .. parsed-literal::
+ *<message>*: *<system-message>*
+
+ where *<message>* is the formatted message and *<system-message>* 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 WindowsError 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::WindowsError(GetLastError(),
+ "cannot open file '{}'", filename);
+ }
+ \endrst
+ */
+ WindowsError(int error_code, CStringRef message)
+ {
+ init(error_code, message, ArgList());
+ }
+ FMT_VARIADIC_CTOR(WindowsError, init, int, CStringRef)
};
// Reports a Windows error without throwing an exception.
// Can be used to report errors from destructors.
-void report_windows_error(int error_code, StringRef message) FMT_NOEXCEPT;
+FMT_API void report_windows_error(int error_code,
+ StringRef message) FMT_NOEXCEPT;
#endif
enum Color { BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE };
/**
- Formats a string and prints it to stdout using ANSI escape sequences
- to specify color (experimental).
- Example:
- PrintColored(fmt::RED, "Elapsed time: {0:.2f} seconds") << 1.23;
- */
-void print_colored(Color c, CStringRef format, ArgList args);
+Formats a string and prints it to stdout using ANSI escape sequences
+to specify color (experimental).
+Example:
+print_colored(fmt::RED, "Elapsed time: {0:.2f} seconds", 1.23);
+*/
+FMT_API void print_colored(Color c, CStringRef format, ArgList args);
/**
- \rst
- Formats arguments and returns the result as a string.
+\rst
+Formats arguments and returns the result as a string.
- **Example**::
+**Example**::
- std::string message = format("The answer is {}", 42);
- \endrst
+std::string message = format("The answer is {}", 42);
+\endrst
*/
-inline std::string format(CStringRef format_str, ArgList args) {
- MemoryWriter w;
- w.write(format_str, args);
- return w.str();
+inline std::string format(CStringRef format_str, ArgList args)
+{
+ MemoryWriter w;
+ w.write(format_str, args);
+ return w.str();
}
-inline std::wstring format(WCStringRef format_str, ArgList args) {
- WMemoryWriter w;
- w.write(format_str, args);
- return w.str();
+inline std::wstring format(WCStringRef format_str, ArgList args)
+{
+ WMemoryWriter w;
+ w.write(format_str, args);
+ return w.str();
}
/**
- \rst
- Prints formatted data to the file *f*.
-
- **Example**::
+\rst
+Prints formatted data to the file *f*.
- print(stderr, "Don't {}!", "panic");
- \endrst
- */
-void print(std::FILE *f, CStringRef format_str, ArgList args);
+**Example**::
-/**
- \rst
- Prints formatted data to ``stdout``.
-
- **Example**::
-
- print("Elapsed time: {0:.2f} seconds", 1.23);
- \endrst
- */
-void print(CStringRef format_str, ArgList args);
+print(stderr, "Don't {}!", "panic");
+\endrst
+*/
+FMT_API void print(std::FILE *f, CStringRef format_str, ArgList args);
/**
- \rst
- Prints formatted data to the stream *os*.
+\rst
+Prints formatted data to ``stdout``.
- **Example**::
+**Example**::
- print(cerr, "Don't {}!", "panic");
- \endrst
- */
-void print(std::ostream &os, CStringRef format_str, ArgList args);
+print("Elapsed time: {0:.2f} seconds", 1.23);
+\endrst
+*/
+FMT_API void print(CStringRef format_str, ArgList args);
template <typename Char>
-void printf(BasicWriter<Char> &w, BasicCStringRef<Char> format, ArgList args) {
- internal::PrintfFormatter<Char>(args).format(w, format);
+void printf(BasicWriter<Char> &w, BasicCStringRef<Char> format, ArgList args)
+{
+ internal::PrintfFormatter<Char>(args).format(w, format);
}
/**
- \rst
- Formats arguments and returns the result as a string.
+\rst
+Formats arguments and returns the result as a string.
- **Example**::
+**Example**::
- std::string message = fmt::sprintf("The answer is %d", 42);
- \endrst
+std::string message = fmt::sprintf("The answer is %d", 42);
+\endrst
*/
-inline std::string sprintf(CStringRef format, ArgList args) {
- MemoryWriter w;
- printf(w, format, args);
- return w.str();
+inline std::string sprintf(CStringRef format, ArgList args)
+{
+ MemoryWriter w;
+ printf(w, format, args);
+ return w.str();
+}
+
+inline std::wstring sprintf(WCStringRef format, ArgList args)
+{
+ WMemoryWriter w;
+ printf(w, format, args);
+ return w.str();
}
/**
- \rst
- Prints formatted data to the file *f*.
+\rst
+Prints formatted data to the file *f*.
- **Example**::
+**Example**::
- fmt::fprintf(stderr, "Don't %s!", "panic");
- \endrst
- */
-int fprintf(std::FILE *f, CStringRef format, ArgList args);
+fmt::fprintf(stderr, "Don't %s!", "panic");
+\endrst
+*/
+FMT_API int fprintf(std::FILE *f, CStringRef format, ArgList args);
/**
- \rst
- Prints formatted data to ``stdout``.
+\rst
+Prints formatted data to ``stdout``.
- **Example**::
+**Example**::
- fmt::printf("Elapsed time: %.2f seconds", 1.23);
- \endrst
- */
-inline int printf(CStringRef format, ArgList args) {
- return fprintf(stdout, format, args);
+fmt::printf("Elapsed time: %.2f seconds", 1.23);
+\endrst
+*/
+inline int printf(CStringRef format, ArgList args)
+{
+ return fprintf(stdout, format, args);
}
/**
- Fast integer formatter.
- */
-class FormatInt {
- private:
- // Buffer should be large enough to hold all digits (digits10 + 1),
- // a sign and a null character.
- enum {BUFFER_SIZE = std::numeric_limits<ULongLong>::digits10 + 3};
- mutable char buffer_[BUFFER_SIZE];
- char *str_;
-
- // Formats value in reverse and returns the number of digits.
- char *format_decimal(ULongLong value) {
- char *buffer_end = buffer_ + BUFFER_SIZE - 1;
- 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.
- unsigned index = (value % 100) * 2;
- value /= 100;
- *--buffer_end = internal::Data::DIGITS[index + 1];
- *--buffer_end = internal::Data::DIGITS[index];
- }
- if (value < 10) {
- *--buffer_end = static_cast<char>('0' + value);
- return buffer_end;
+Fast integer formatter.
+*/
+class FormatInt
+{
+private:
+ // Buffer should be large enough to hold all digits (digits10 + 1),
+ // a sign and a null character.
+ enum { BUFFER_SIZE = std::numeric_limits<ULongLong>::digits10 + 3 };
+ mutable char buffer_[BUFFER_SIZE];
+ char *str_;
+
+ // Formats value in reverse and returns the number of digits.
+ char *format_decimal(ULongLong value)
+ {
+ char *buffer_end = buffer_ + BUFFER_SIZE - 1;
+ 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.
+ unsigned index = static_cast<unsigned>((value % 100) * 2);
+ value /= 100;
+ *--buffer_end = internal::Data::DIGITS[index + 1];
+ *--buffer_end = internal::Data::DIGITS[index];
+ }
+ if (value < 10)
+ {
+ *--buffer_end = static_cast<char>('0' + value);
+ return buffer_end;
+ }
+ unsigned index = static_cast<unsigned>(value * 2);
+ *--buffer_end = internal::Data::DIGITS[index + 1];
+ *--buffer_end = internal::Data::DIGITS[index];
+ return buffer_end;
}
- unsigned index = static_cast<unsigned>(value * 2);
- *--buffer_end = internal::Data::DIGITS[index + 1];
- *--buffer_end = internal::Data::DIGITS[index];
- return buffer_end;
- }
- void FormatSigned(LongLong value) {
- ULongLong abs_value = static_cast<ULongLong>(value);
- bool negative = value < 0;
- if (negative)
- abs_value = 0 - abs_value;
- str_ = format_decimal(abs_value);
- if (negative)
- *--str_ = '-';
- }
+ void FormatSigned(LongLong value)
+ {
+ ULongLong abs_value = static_cast<ULongLong>(value);
+ bool negative = value < 0;
+ if (negative)
+ abs_value = 0 - abs_value;
+ str_ = format_decimal(abs_value);
+ if (negative)
+ *--str_ = '-';
+ }
- public:
- explicit FormatInt(int value) { FormatSigned(value); }
- explicit FormatInt(long value) { FormatSigned(value); }
- explicit FormatInt(LongLong value) { FormatSigned(value); }
- explicit FormatInt(unsigned value) : str_(format_decimal(value)) {}
- explicit FormatInt(unsigned long value) : str_(format_decimal(value)) {}
- explicit FormatInt(ULongLong value) : str_(format_decimal(value)) {}
+public:
+ explicit FormatInt(int value)
+ {
+ FormatSigned(value);
+ }
+ explicit FormatInt(long value)
+ {
+ FormatSigned(value);
+ }
+ explicit FormatInt(LongLong value)
+ {
+ FormatSigned(value);
+ }
+ explicit FormatInt(unsigned value) : str_(format_decimal(value)) {}
+ explicit FormatInt(unsigned long value) : str_(format_decimal(value)) {}
+ explicit FormatInt(ULongLong value) : str_(format_decimal(value)) {}
- /**
+ /**
Returns the number of characters written to the output buffer.
- */
- std::size_t size() const { return buffer_ - str_ + BUFFER_SIZE - 1; }
+ */
+ std::size_t size() const
+ {
+ return buffer_ - str_ + BUFFER_SIZE - 1;
+ }
- /**
+ /**
Returns a pointer to the output buffer content. No terminating null
character is appended.
- */
- const char *data() const { return str_; }
+ */
+ const char *data() const
+ {
+ return str_;
+ }
- /**
+ /**
Returns a pointer to the output buffer content with terminating null
character appended.
- */
- const char *c_str() const {
- buffer_[BUFFER_SIZE - 1] = '\0';
- return str_;
- }
+ */
+ const char *c_str() const
+ {
+ buffer_[BUFFER_SIZE - 1] = '\0';
+ return str_;
+ }
- /**
+ /**
\rst
Returns the content of the output buffer as an ``std::string``.
\endrst
- */
- std::string str() const { return std::string(str_, size()); }
+ */
+ std::string str() const
+ {
+ return std::string(str_, size());
+ }
};
// Formats a decimal integer value writing into buffer and returns
// a pointer to the end of the formatted string. This function doesn't
// write a terminating null character.
template <typename T>
-inline void format_decimal(char *&buffer, T value) {
- typename internal::IntTraits<T>::MainType abs_value = value;
- if (internal::is_negative(value)) {
- *buffer++ = '-';
- abs_value = 0 - abs_value;
- }
- if (abs_value < 100) {
- if (abs_value < 10) {
- *buffer++ = static_cast<char>('0' + abs_value);
- return;
- }
- unsigned index = static_cast<unsigned>(abs_value * 2);
- *buffer++ = internal::Data::DIGITS[index];
- *buffer++ = internal::Data::DIGITS[index + 1];
- return;
- }
- unsigned num_digits = internal::count_digits(abs_value);
- internal::format_decimal(buffer, abs_value, num_digits);
- buffer += num_digits;
+inline void format_decimal(char *&buffer, T value)
+{
+ typename internal::IntTraits<T>::MainType abs_value = value;
+ if (internal::is_negative(value))
+ {
+ *buffer++ = '-';
+ abs_value = 0 - abs_value;
+ }
+ if (abs_value < 100)
+ {
+ if (abs_value < 10)
+ {
+ *buffer++ = static_cast<char>('0' + abs_value);
+ return;
+ }
+ unsigned index = static_cast<unsigned>(abs_value * 2);
+ *buffer++ = internal::Data::DIGITS[index];
+ *buffer++ = internal::Data::DIGITS[index + 1];
+ return;
+ }
+ unsigned num_digits = internal::count_digits(abs_value);
+ internal::format_decimal(buffer, abs_value, num_digits);
+ buffer += num_digits;
}
/**
- \rst
- Returns a named argument for formatting functions.
+\rst
+Returns a named argument for formatting functions.
- **Example**::
+**Example**::
- print("Elapsed time: {s:.2f} seconds", arg("s", 1.23));
+print("Elapsed time: {s:.2f} seconds", arg("s", 1.23));
- \endrst
- */
+\endrst
+*/
template <typename T>
-inline internal::NamedArg<char> arg(StringRef name, const T &arg) {
- return internal::NamedArg<char>(name, arg);
+inline internal::NamedArg<char> arg(StringRef name, const T &arg)
+{
+ return internal::NamedArg<char>(name, arg);
}
template <typename T>
-inline internal::NamedArg<wchar_t> arg(WStringRef name, const T &arg) {
- return internal::NamedArg<wchar_t>(name, arg);
+inline internal::NamedArg<wchar_t> arg(WStringRef name, const T &arg)
+{
+ return internal::NamedArg<wchar_t>(name, arg);
}
// The following two functions are deleted intentionally to disable
@@ -2898,7 +3817,8 @@ void arg(WStringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
const Args & ... args) { \
typename fmt::internal::ArgArray<sizeof...(Args)>::Type array; \
call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), \
- fmt::internal::make_arg_list<Char>(array, args...)); \
+ fmt::internal::make_arg_list< \
+ fmt::BasicFormatter<Char> >(array, args...)); \
}
#else
// Defines a wrapper for a function taking __VA_ARGS__ arguments
@@ -2907,7 +3827,8 @@ void arg(WStringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \
FMT_GEN(n, FMT_MAKE_ARG)) { \
- fmt::internal::ArgArray<n>::Type arr = {FMT_GEN(n, FMT_MAKE_REF_##Char)}; \
+ fmt::internal::ArgArray<n>::Type arr; \
+ FMT_GEN(n, FMT_ASSIGN_##Char); \
call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList( \
fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), arr)); \
}
@@ -2934,32 +3855,32 @@ void arg(WStringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
#endif // FMT_USE_VARIADIC_TEMPLATES
/**
- \rst
- Defines a variadic function with the specified return type, function name
- and argument types passed as variable arguments to this macro.
+\rst
+Defines a variadic function with the specified return type, function name
+and argument types passed as variable arguments to this macro.
- **Example**::
+**Example**::
- void print_error(const char *file, int line, const char *format,
- fmt::ArgList args) {
- fmt::print("{}: {}: ", file, line);
- fmt::print(format, args);
- }
- FMT_VARIADIC(void, print_error, const char *, int, const char *)
+void print_error(const char *file, int line, const char *format,
+fmt::ArgList args) {
+fmt::print("{}: {}: ", file, line);
+fmt::print(format, args);
+}
+FMT_VARIADIC(void, print_error, const char *, int, const char *)
- ``FMT_VARIADIC`` is used for compatibility with legacy C++ compilers that
- don't implement variadic templates. You don't have to use this macro if
- you don't need legacy compiler support and can use variadic templates
- directly::
+``FMT_VARIADIC`` is used for compatibility with legacy C++ compilers that
+don't implement variadic templates. You don't have to use this macro if
+you don't need legacy compiler support and can use variadic templates
+directly::
- template <typename... Args>
- void print_error(const char *file, int line, const char *format,
- const Args & ... args) {
- fmt::print("{}: {}: ", file, line);
- fmt::print(format, args...);
- }
- \endrst
- */
+template <typename... Args>
+void print_error(const char *file, int line, const char *format,
+const Args & ... args) {
+fmt::print("{}: {}: ", file, line);
+fmt::print(format, args...);
+}
+\endrst
+*/
#define FMT_VARIADIC(ReturnType, func, ...) \
FMT_VARIADIC_(char, ReturnType, func, return func, __VA_ARGS__)
@@ -2971,41 +3892,465 @@ void arg(WStringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
#define FMT_CAPTURE_ARG_W_(id, index) ::fmt::arg(L###id, id)
/**
- \rst
- Convenient macro to capture the arguments' names and values into several
- ``fmt::arg(name, value)``.
+\rst
+Convenient macro to capture the arguments' names and values into several
+``fmt::arg(name, value)``.
- **Example**::
+**Example**::
- int x = 1, y = 2;
- print("point: ({x}, {y})", FMT_CAPTURE(x, y));
- // same as:
- // print("point: ({x}, {y})", arg("x", x), arg("y", y));
+int x = 1, y = 2;
+print("point: ({x}, {y})", FMT_CAPTURE(x, y));
+// same as:
+// print("point: ({x}, {y})", arg("x", x), arg("y", y));
- \endrst
- */
+\endrst
+*/
#define FMT_CAPTURE(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_, __VA_ARGS__)
#define FMT_CAPTURE_W(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_W_, __VA_ARGS__)
-namespace fmt {
+namespace fmt
+{
FMT_VARIADIC(std::string, format, CStringRef)
FMT_VARIADIC_W(std::wstring, format, WCStringRef)
FMT_VARIADIC(void, print, CStringRef)
FMT_VARIADIC(void, print, std::FILE *, CStringRef)
-FMT_VARIADIC(void, print, std::ostream &, CStringRef)
+
FMT_VARIADIC(void, print_colored, Color, CStringRef)
FMT_VARIADIC(std::string, sprintf, CStringRef)
+FMT_VARIADIC_W(std::wstring, sprintf, WCStringRef)
FMT_VARIADIC(int, printf, CStringRef)
FMT_VARIADIC(int, fprintf, std::FILE *, CStringRef)
+
+#if FMT_USE_IOSTREAMS
+/**
+\rst
+Prints formatted data to the stream *os*.
+
+**Example**::
+
+print(cerr, "Don't {}!", "panic");
+\endrst
+*/
+FMT_API void print(std::ostream &os, CStringRef format_str, ArgList args);
+FMT_VARIADIC(void, print, std::ostream &, CStringRef)
+#endif
+
+namespace internal
+{
+template <typename Char>
+inline bool is_name_start(Char c)
+{
+ return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
}
+// Parses an unsigned integer advancing s to the end of the parsed input.
+// This function assumes that the first character of s is a digit.
+template <typename Char>
+int parse_nonnegative_int(const Char *&s)
+{
+ assert('0' <= *s && *s <= '9');
+ unsigned value = 0;
+ do
+ {
+ unsigned new_value = value * 10 + (*s++ - '0');
+ // Check if value wrapped around.
+ if (new_value < value)
+ {
+ value = (std::numeric_limits<unsigned>::max)();
+ break;
+ }
+ value = new_value;
+ }
+ while ('0' <= *s && *s <= '9');
+ // Convert to unsigned to prevent a warning.
+ unsigned max_int = (std::numeric_limits<int>::max)();
+ if (value > max_int)
+ FMT_THROW(FormatError("number is too big"));
+ return value;
+}
+
+inline void require_numeric_argument(const Arg &arg, char spec)
+{
+ if (arg.type > Arg::LAST_NUMERIC_TYPE)
+ {
+ std::string message =
+ fmt::format("format specifier '{}' requires numeric argument", spec);
+ FMT_THROW(fmt::FormatError(message));
+ }
+}
+
+template <typename Char>
+void check_sign(const Char *&s, const Arg &arg)
+{
+ char sign = static_cast<char>(*s);
+ require_numeric_argument(arg, sign);
+ if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG)
+ {
+ FMT_THROW(FormatError(fmt::format(
+ "format specifier '{}' requires signed argument", sign)));
+ }
+ ++s;
+}
+} // namespace internal
+
+template <typename Char>
+inline internal::Arg BasicFormatter<Char>::get_arg(
+ BasicStringRef<Char> arg_name, const char *&error)
+{
+ if (check_no_auto_index(error))
+ {
+ map_.init(args());
+ const internal::Arg *arg = map_.find(arg_name);
+ if (arg)
+ return *arg;
+ error = "argument not found";
+ }
+ return internal::Arg();
+}
+
+template <typename Char>
+inline internal::Arg BasicFormatter<Char>::parse_arg_index(const Char *&s)
+{
+ const char *error = 0;
+ internal::Arg arg = *s < '0' || *s > '9' ?
+ next_arg(error) : get_arg(internal::parse_nonnegative_int(s), error);
+ if (error)
+ {
+ FMT_THROW(FormatError(
+ *s != '}' && *s != ':' ? "invalid format string" : error));
+ }
+ return arg;
+}
+
+template <typename Char>
+inline internal::Arg BasicFormatter<Char>::parse_arg_name(const Char *&s)
+{
+ assert(internal::is_name_start(*s));
+ const Char *start = s;
+ Char c;
+ do
+ {
+ c = *++s;
+ }
+ while (internal::is_name_start(c) || ('0' <= c && c <= '9'));
+ const char *error = 0;
+ internal::Arg arg = get_arg(BasicStringRef<Char>(start, s - start), error);
+ if (error)
+ FMT_THROW(FormatError(error));
+ return arg;
+}
+
+// Should be after FormatSpec
+template <typename Char>
+const Char *BasicFormatter<Char>::format(
+ const Char *&format_str, const internal::Arg &arg)
+{
+ using internal::Arg;
+ const Char *s = format_str;
+ FormatSpec spec;
+ if (*s == ':')
+ {
+ if (arg.type == Arg::CUSTOM)
+ {
+ arg.custom.format(this, arg.custom.value, &s);
+ return s;
+ }
+ ++s;
+ // Parse fill and alignment.
+ if (Char c = *s)
+ {
+ const Char *p = s + 1;
+ spec.align_ = ALIGN_DEFAULT;
+ do
+ {
+ switch (*p)
+ {
+ case '<':
+ spec.align_ = ALIGN_LEFT;
+ break;
+ case '>':
+ spec.align_ = ALIGN_RIGHT;
+ break;
+ case '=':
+ spec.align_ = ALIGN_NUMERIC;
+ break;
+ case '^':
+ spec.align_ = ALIGN_CENTER;
+ break;
+ }
+ if (spec.align_ != ALIGN_DEFAULT)
+ {
+ if (p != s)
+ {
+ if (c == '}') break;
+ if (c == '{')
+ FMT_THROW(FormatError("invalid fill character '{'"));
+ s += 2;
+ spec.fill_ = c;
+ }
+ else ++s;
+ if (spec.align_ == ALIGN_NUMERIC)
+ require_numeric_argument(arg, '=');
+ break;
+ }
+ }
+ while (--p >= s);
+ }
+
+ // Parse sign.
+ switch (*s)
+ {
+ case '+':
+ check_sign(s, arg);
+ spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
+ break;
+ case '-':
+ check_sign(s, arg);
+ spec.flags_ |= MINUS_FLAG;
+ break;
+ case ' ':
+ check_sign(s, arg);
+ spec.flags_ |= SIGN_FLAG;
+ break;
+ }
+
+ if (*s == '#')
+ {
+ require_numeric_argument(arg, '#');
+ spec.flags_ |= HASH_FLAG;
+ ++s;
+ }
+
+ // Parse zero flag.
+ if (*s == '0')
+ {
+ require_numeric_argument(arg, '0');
+ spec.align_ = ALIGN_NUMERIC;
+ spec.fill_ = '0';
+ ++s;
+ }
+
+ // Parse width.
+ if ('0' <= *s && *s <= '9')
+ {
+ spec.width_ = internal::parse_nonnegative_int(s);
+ }
+ else if (*s == '{')
+ {
+ ++s;
+ Arg width_arg = internal::is_name_start(*s) ?
+ parse_arg_name(s) : parse_arg_index(s);
+ if (*s++ != '}')
+ FMT_THROW(FormatError("invalid format string"));
+ ULongLong value = 0;
+ switch (width_arg.type)
+ {
+ case Arg::INT:
+ if (width_arg.int_value < 0)
+ FMT_THROW(FormatError("negative width"));
+ value = width_arg.int_value;
+ break;
+ case Arg::UINT:
+ value = width_arg.uint_value;
+ break;
+ case Arg::LONG_LONG:
+ if (width_arg.long_long_value < 0)
+ FMT_THROW(FormatError("negative width"));
+ value = width_arg.long_long_value;
+ break;
+ case Arg::ULONG_LONG:
+ value = width_arg.ulong_long_value;
+ break;
+ default:
+ FMT_THROW(FormatError("width is not integer"));
+ }
+ if (value >(std::numeric_limits<int>::max)())
+ FMT_THROW(FormatError("number is too big"));
+ spec.width_ = static_cast<int>(value);
+ }
+
+ // Parse precision.
+ if (*s == '.')
+ {
+ ++s;
+ spec.precision_ = 0;
+ if ('0' <= *s && *s <= '9')
+ {
+ spec.precision_ = internal::parse_nonnegative_int(s);
+ }
+ else if (*s == '{')
+ {
+ ++s;
+ Arg precision_arg = internal::is_name_start(*s) ?
+ parse_arg_name(s) : parse_arg_index(s);
+ if (*s++ != '}')
+ FMT_THROW(FormatError("invalid format string"));
+ ULongLong value = 0;
+ switch (precision_arg.type)
+ {
+ case Arg::INT:
+ if (precision_arg.int_value < 0)
+ FMT_THROW(FormatError("negative precision"));
+ value = precision_arg.int_value;
+ break;
+ case Arg::UINT:
+ value = precision_arg.uint_value;
+ break;
+ case Arg::LONG_LONG:
+ if (precision_arg.long_long_value < 0)
+ FMT_THROW(FormatError("negative precision"));
+ value = precision_arg.long_long_value;
+ break;
+ case Arg::ULONG_LONG:
+ value = precision_arg.ulong_long_value;
+ break;
+ default:
+ FMT_THROW(FormatError("precision is not integer"));
+ }
+ if (value >(std::numeric_limits<int>::max)())
+ FMT_THROW(FormatError("number is too big"));
+ spec.precision_ = static_cast<int>(value);
+ }
+ else
+ {
+ FMT_THROW(FormatError("missing precision specifier"));
+ }
+ if (arg.type <= Arg::LAST_INTEGER_TYPE || arg.type == Arg::POINTER)
+ {
+ FMT_THROW(FormatError(
+ fmt::format("precision not allowed in {} format specifier",
+ arg.type == Arg::POINTER ? "pointer" : "integer")));
+ }
+ }
+
+ // Parse type.
+ if (*s != '}' && *s)
+ spec.type_ = static_cast<char>(*s++);
+ }
+
+ if (*s++ != '}')
+ FMT_THROW(FormatError("missing '}' in format string"));
+
+ // Format argument.
+ internal::BasicArgFormatter<Char>(*this, spec, s - 1).visit(arg);
+ return s;
+}
+
+template <typename Char>
+void BasicFormatter<Char>::format(BasicCStringRef<Char> format_str)
+{
+ const Char *s = format_str.c_str();
+ const Char *start = s;
+ while (*s)
+ {
+ Char c = *s++;
+ if (c != '{' && c != '}') continue;
+ if (*s == c)
+ {
+ write(writer_, start, s);
+ start = ++s;
+ continue;
+ }
+ if (c == '}')
+ FMT_THROW(FormatError("unmatched '}' in format string"));
+ write(writer_, start, s - 1);
+ internal::Arg arg = internal::is_name_start(*s) ?
+ parse_arg_name(s) : parse_arg_index(s);
+ start = s = format(s, arg);
+ }
+ write(writer_, start, s);
+}
+} // namespace fmt
+
+#if FMT_USE_USER_DEFINED_LITERALS
+namespace fmt
+{
+namespace internal
+{
+
+template <typename Char>
+struct UdlFormat
+{
+ const Char *str;
+
+ template <typename... Args>
+ auto operator()(Args && ... args) const
+ -> decltype(format(str, std::forward<Args>(args)...))
+ {
+ return format(str, std::forward<Args>(args)...);
+ }
+};
+
+template <typename Char>
+struct UdlArg
+{
+ const Char *str;
+
+ template <typename T>
+ NamedArg<Char> operator=(T &&value) const
+ {
+ return { str, std::forward<T>(value) };
+ }
+};
+
+} // namespace internal
+
+inline namespace literals
+{
+
+/**
+\rst
+C++11 literal equivalent of :func:`fmt::format`.
+
+**Example**::
+
+using namespace fmt::literals;
+std::string message = "The answer is {}"_format(42);
+\endrst
+*/
+inline internal::UdlFormat<char>
+operator"" _format(const char *s, std::size_t)
+{
+ return { s };
+}
+inline internal::UdlFormat<wchar_t>
+operator"" _format(const wchar_t *s, std::size_t)
+{
+ return { s };
+}
+
+/**
+\rst
+C++11 literal equivalent of :func:`fmt::arg`.
+
+**Example**::
+
+using namespace fmt::literals;
+print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
+\endrst
+*/
+inline internal::UdlArg<char>
+operator"" _a(const char *s, std::size_t)
+{
+ return { s };
+}
+inline internal::UdlArg<wchar_t>
+operator"" _a(const wchar_t *s, std::size_t)
+{
+ return { s };
+}
+
+} // inline namespace literals
+} // namespace fmt
+#endif // FMT_USE_USER_DEFINED_LITERALS
+
// Restore warnings.
#if FMT_GCC_VERSION >= 406
# pragma GCC diagnostic pop
#endif
-#ifdef __clang__
+#if defined(__clang__) && !defined(__INTEL_COMPILER)
# pragma clang diagnostic pop
#endif
diff --git a/include/spdlog/details/line_logger.h b/include/spdlog/details/line_logger.h
deleted file mode 100644
index 80d7cc1..0000000
--- a/include/spdlog/details/line_logger.h
+++ /dev/null
@@ -1,221 +0,0 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
-
-#pragma once
-#include <type_traits>
-#include "../common.h"
-#include "../logger.h"
-
-// Line logger class - aggregates operator<< calls to fast ostream
-// and logs upon destruction
-
-namespace spdlog
-{
-namespace details
-{
-class line_logger
-{
-public:
- line_logger(logger* callback_logger, level::level_enum msg_level, bool enabled):
- _callback_logger(callback_logger),
- _log_msg(msg_level),
- _enabled(enabled)
- {}
-
- // No copy intended. Only move
- line_logger(const line_logger& other) = delete;
- line_logger& operator=(const line_logger&) = delete;
- line_logger& operator=(line_logger&&) = delete;
-
-
- line_logger(line_logger&& other) :
- _callback_logger(other._callback_logger),
- _log_msg(std::move(other._log_msg)),
- _enabled(other._enabled)
- {
- other.disable();
- }
-
- //Log the log message using the callback logger
- ~line_logger()
- {
- if (_enabled)
- {
-#ifndef SPDLOG_NO_NAME
- _log_msg.logger_name = _callback_logger->name();
-#endif
-#ifndef SPDLOG_NO_DATETIME
- _log_msg.time = os::now();
-#endif
-
-#ifndef SPDLOG_NO_THREAD_ID
- _log_msg.thread_id = os::thread_id();
-#endif
- _callback_logger->_log_msg(_log_msg);
- }
- }
-
- //
- // Support for format string with variadic args
- //
-
-
- void write(const char* what)
- {
- if (_enabled)
- _log_msg.raw << what;
- }
-
- template <typename... Args>
- void write(const char* fmt, const Args&... args)
- {
- if (!_enabled)
- return;
- try
- {
- _log_msg.raw.write(fmt, args...);
- }
- catch (const fmt::FormatError& e)
- {
- throw spdlog_ex(fmt::format("formatting error while processing format string '{}': {}", fmt, e.what()));
- }
- }
-
-
- //
- // Support for operator<<
- //
- line_logger& operator<<(const char* what)
- {
- if (_enabled)
- _log_msg.raw << what;
- return *this;
- }
-
- line_logger& operator<<(const std::string& what)
- {
- if (_enabled)
- _log_msg.raw << what;
- return *this;
- }
-
- line_logger& operator<<(int what)
- {
- if (_enabled)
- _log_msg.raw << what;
- return *this;
- }
-
- line_logger& operator<<(unsigned int what)
- {
- if (_enabled)
- _log_msg.raw << what;
- return *this;
- }
-
-
- line_logger& operator<<(long what)
- {
- if (_enabled)
- _log_msg.raw << what;
- return *this;
- }
-
- line_logger& operator<<(unsigned long what)
- {
- if (_enabled)
- _log_msg.raw << what;
- return *this;
- }
-
- line_logger& operator<<(long long what)
- {
- if (_enabled)
- _log_msg.raw << what;
- return *this;
- }
-
- line_logger& operator<<(unsigned long long what)
- {
- if (_enabled)
- _log_msg.raw << what;
- return *this;
- }
-
- line_logger& operator<<(double what)
- {
- if (_enabled)
- _log_msg.raw << what;
- return *this;
- }
-
- line_logger& operator<<(long double what)
- {
- if (_enabled)
- _log_msg.raw << what;
- return *this;
- }
-
- line_logger& operator<<(float what)
- {
- if (_enabled)
- _log_msg.raw << what;
- return *this;
- }
-
- line_logger& operator<<(char what)
- {
- if (_enabled)
- _log_msg.raw << what;
- return *this;
- }
-
- //Support user types which implements operator<<
- template<typename T>
- line_logger& operator<<(const T& what)
- {
- if (_enabled)
- _log_msg.raw.write("{}", what);
- return *this;
- }
-
-
- void disable()
- {
- _enabled = false;
- }
-
- bool is_enabled() const
- {
- return _enabled;
- }
-
-
-private:
- logger* _callback_logger;
- log_msg _log_msg;
- bool _enabled;
-};
-} //Namespace details
-} // Namespace spdlog
diff --git a/include/spdlog/details/line_logger_fwd.h b/include/spdlog/details/line_logger_fwd.h
new file mode 100644
index 0000000..a8bc58f
--- /dev/null
+++ b/include/spdlog/details/line_logger_fwd.h
@@ -0,0 +1,78 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+#pragma once
+
+#include <spdlog/common.h>
+#include <spdlog/details/log_msg.h>
+
+#include <string>
+
+// Line logger class - aggregates operator<< calls to fast ostream
+// and logs upon destruction
+
+namespace spdlog
+{
+
+// Forward declaration
+class logger;
+
+namespace details
+{
+class line_logger
+{
+public:
+ line_logger(logger* callback_logger, level::level_enum msg_level, bool enabled);
+
+ // No copy intended. Only move
+ line_logger(const line_logger& other) = delete;
+ line_logger& operator=(const line_logger&) = delete;
+ line_logger& operator=(line_logger&&) = delete;
+
+
+ line_logger(line_logger&& other);
+
+ //Log the log message using the callback logger
+ ~line_logger();
+
+ //
+ // Support for format string with variadic args
+ //
+
+
+ void write(const char* what);
+
+ template <typename... Args>
+ void write(const char* fmt, const Args&... args);
+
+ //
+ // Support for operator<<
+ //
+ line_logger& operator<<(const char* what);
+ line_logger& operator<<(const std::string& what);
+ line_logger& operator<<(int what);
+ line_logger& operator<<(unsigned int what);
+ line_logger& operator<<(long what);
+ line_logger& operator<<(unsigned long what);
+ line_logger& operator<<(long long what);
+ line_logger& operator<<(unsigned long long what);
+ line_logger& operator<<(double what);
+ line_logger& operator<<(long double what);
+ line_logger& operator<<(float what);
+ line_logger& operator<<(char what);
+ //Support user types which implements operator<<
+ template<typename T>
+ line_logger& operator<<(const T& what);
+
+ void disable();
+ bool is_enabled() const;
+
+private:
+ logger* _callback_logger;
+ log_msg _log_msg;
+ bool _enabled;
+};
+} //Namespace details
+} // Namespace spdlog
+
diff --git a/include/spdlog/details/line_logger_impl.h b/include/spdlog/details/line_logger_impl.h
new file mode 100644
index 0000000..d61225a
--- /dev/null
+++ b/include/spdlog/details/line_logger_impl.h
@@ -0,0 +1,185 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+#pragma once
+#include <type_traits>
+
+#include <spdlog/details/line_logger_fwd.h>
+#include <spdlog/common.h>
+#include <spdlog/logger.h>
+
+#include <string>
+#include <utility>
+
+// Line logger class - aggregates operator<< calls to fast ostream
+// and logs upon destruction
+
+inline spdlog::details::line_logger::line_logger(logger* callback_logger, level::level_enum msg_level, bool enabled):
+ _callback_logger(callback_logger),
+ _log_msg(msg_level),
+ _enabled(enabled)
+{}
+
+inline spdlog::details::line_logger::line_logger(line_logger&& other) :
+ _callback_logger(other._callback_logger),
+ _log_msg(std::move(other._log_msg)),
+ _enabled(other._enabled)
+{
+ other.disable();
+}
+
+//Log the log message using the callback logger
+inline spdlog::details::line_logger::~line_logger()
+{
+ if (_enabled)
+ {
+#ifndef SPDLOG_NO_NAME
+ _log_msg.logger_name = _callback_logger->name();
+#endif
+#ifndef SPDLOG_NO_DATETIME
+ _log_msg.time = os::now();
+#endif
+
+#ifndef SPDLOG_NO_THREAD_ID
+ _log_msg.thread_id = os::thread_id();
+#endif
+ _callback_logger->_log_msg(_log_msg);
+ }
+}
+
+//
+// Support for format string with variadic args
+//
+
+
+inline void spdlog::details::line_logger::write(const char* what)
+{
+ if (_enabled)
+ _log_msg.raw << what;
+}
+
+template <typename... Args>
+inline void spdlog::details::line_logger::write(const char* fmt, const Args&... args)
+{
+ if (!_enabled)
+ return;
+ try
+ {
+ _log_msg.raw.write(fmt, args...);
+ }
+ catch (const fmt::FormatError& e)
+ {
+ throw spdlog_ex(fmt::format("formatting error while processing format string '{}': {}", fmt, e.what()));
+ }
+}
+
+
+//
+// Support for operator<<
+//
+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(const char* what)
+{
+ if (_enabled)
+ _log_msg.raw << what;
+ return *this;
+}
+
+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(const std::string& what)
+{
+ if (_enabled)
+ _log_msg.raw << what;
+ return *this;
+}
+
+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(int what)
+{
+ if (_enabled)
+ _log_msg.raw << what;
+ return *this;
+}
+
+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(unsigned int what)
+{
+ if (_enabled)
+ _log_msg.raw << what;
+ return *this;
+}
+
+
+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(long what)
+{
+ if (_enabled)
+ _log_msg.raw << what;
+ return *this;
+}
+
+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(unsigned long what)
+{
+ if (_enabled)
+ _log_msg.raw << what;
+ return *this;
+}
+
+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(long long what)
+{
+ if (_enabled)
+ _log_msg.raw << what;
+ return *this;
+}
+
+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(unsigned long long what)
+{
+ if (_enabled)
+ _log_msg.raw << what;
+ return *this;
+}
+
+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(double what)
+{
+ if (_enabled)
+ _log_msg.raw << what;
+ return *this;
+}
+
+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(long double what)
+{
+ if (_enabled)
+ _log_msg.raw << what;
+ return *this;
+}
+
+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(float what)
+{
+ if (_enabled)
+ _log_msg.raw << what;
+ return *this;
+}
+
+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(char what)
+{
+ if (_enabled)
+ _log_msg.raw << what;
+ return *this;
+}
+
+//Support user types which implements operator<<
+template<typename T>
+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(const T& what)
+{
+ if (_enabled)
+ _log_msg.raw.write("{}", what);
+ return *this;
+}
+
+
+inline void spdlog::details::line_logger::disable()
+{
+ _enabled = false;
+}
+
+inline bool spdlog::details::line_logger::is_enabled() const
+{
+ return _enabled;
+}
+
diff --git a/include/spdlog/details/log_msg.h b/include/spdlog/details/log_msg.h
index bf58aca..0d50b68 100644
--- a/include/spdlog/details/log_msg.h
+++ b/include/spdlog/details/log_msg.h
@@ -1,32 +1,15 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#pragma once
-#include <thread>
-#include "../common.h"
-#include "./format.h"
+#include <spdlog/common.h>
+#include <spdlog/details/format.h>
+
+#include <string>
+#include <utility>
namespace spdlog
{
diff --git a/include/spdlog/details/logger_impl.h b/include/spdlog/details/logger_impl.h
index d658ac0..c096382 100644
--- a/include/spdlog/details/logger_impl.h
+++ b/include/spdlog/details/logger_impl.h
@@ -1,34 +1,15 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
-
-#pragma once
//
-// Logger implementation
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
//
-#include "./line_logger.h"
+#pragma once
+
+#include <spdlog/logger.h>
+#include <atomic>
+#include <memory>
+#include <string>
// create logger with given name, sinks and the default pattern formatter
// all other ctors will call this one
@@ -50,7 +31,8 @@ inline spdlog::logger::logger(const std::string& logger_name, sinks_init_list si
// ctor with single sink
inline spdlog::logger::logger(const std::string& logger_name, spdlog::sink_ptr single_sink) :
- logger(logger_name, {
+ logger(logger_name,
+{
single_sink
}) {}
@@ -314,7 +296,8 @@ inline void spdlog::logger::_set_formatter(formatter_ptr msg_formatter)
_formatter = msg_formatter;
}
-inline void spdlog::logger::flush() {
+inline void spdlog::logger::flush()
+{
for (auto& sink : _sinks)
sink->flush();
-}
\ No newline at end of file
+}
diff --git a/include/spdlog/details/mpmc_bounded_q.h b/include/spdlog/details/mpmc_bounded_q.h
index 7cbcfd7..ad14d6f 100644
--- a/include/spdlog/details/mpmc_bounded_q.h
+++ b/include/spdlog/details/mpmc_bounded_q.h
@@ -36,33 +36,17 @@ should not be interpreted as representing official policies, either expressed or
/*
The code in its current form adds the license below:
-spdlog - an extremely fast and easy to use c++11 logging library.
-Copyright (c) 2014 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.
+Copyright(c) 2015 Gabi Melman.
+Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
*/
#pragma once
+#include <spdlog/common.h>
+
#include <atomic>
-#include "../common.h"
+#include <utility>
namespace spdlog
{
diff --git a/include/spdlog/details/null_mutex.h b/include/spdlog/details/null_mutex.h
index ebb56a5..19e90bf 100644
--- a/include/spdlog/details/null_mutex.h
+++ b/include/spdlog/details/null_mutex.h
@@ -1,26 +1,7 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#pragma once
diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h
index 5748033..ac05a3b 100644
--- a/include/spdlog/details/os.h
+++ b/include/spdlog/details/os.h
@@ -1,37 +1,21 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
-
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#pragma once
-#include<string>
-#include<cstdio>
-#include<ctime>
+
+#include <spdlog/common.h>
+
+#include <cstdio>
+#include <ctime>
+#include <functional>
+#include <string>
#ifdef _WIN32
# ifndef WIN32_LEAN_AND_MEAN
# define WIN32_LEAN_AND_MEAN
# endif
-# include <Windows.h>
+# include <windows.h>
#ifdef __MINGW32__
#include <share.h>
@@ -39,13 +23,13 @@
#elif __linux__
#include <sys/syscall.h> //Use gettid() syscall under linux to get thread id
+#include <sys/stat.h>
#include <unistd.h>
+#include <chrono>
#else
#include <thread>
#endif
-#include "../common.h"
-
namespace spdlog
{
namespace details
@@ -63,6 +47,7 @@ inline spdlog::log_clock::time_point now()
std::chrono::duration_cast<typename log_clock::duration>(
std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
+
#else
return log_clock::now();
#endif
@@ -157,20 +142,52 @@ inline int fopen_s(FILE** fp, const std::string& filename, const char* mode)
return *fp == nullptr;
#endif
+}
+
+
+//Return if file exists
+inline bool file_exists(const std::string& filename)
+{
+#ifdef _WIN32
+ auto attribs = GetFileAttributesA(filename.c_str());
+ return (attribs != INVALID_FILE_ATTRIBUTES && !(attribs & FILE_ATTRIBUTE_DIRECTORY));
+#elif __linux__
+ struct stat buffer;
+ return (stat (filename.c_str(), &buffer) == 0);
+#else
+ auto *file = fopen(filename.c_str(), "r");
+ if (file != nullptr)
+ {
+ fclose(file);
+ return true;
+ }
+ return false;
+
+#endif
}
-//Return utc offset in minutes or -1 on failure
+//Return utc offset in minutes or throw spdlog_ex on failure
inline int utc_minutes_offset(const std::tm& tm = details::os::localtime())
{
#ifdef _WIN32
- (void)tm; // avoid unused param warning
+#if _WIN32_WINNT < _WIN32_WINNT_WS08
+ TIME_ZONE_INFORMATION tzinfo;
+ auto rv = GetTimeZoneInformation(&tzinfo);
+#else
DYNAMIC_TIME_ZONE_INFORMATION tzinfo;
auto rv = GetDynamicTimeZoneInformation(&tzinfo);
- if (!rv)
- return -1;
- return -1 * (tzinfo.Bias + tzinfo.DaylightBias);
+#endif
+ if (rv == TIME_ZONE_ID_INVALID)
+ throw spdlog::spdlog_ex("Failed getting timezone info. Last error: " + GetLastError());
+
+ int offset = -tzinfo.Bias;
+ if (tm.tm_isdst)
+ offset -= tzinfo.DaylightBias;
+ else
+ offset -= tzinfo.StandardBias;
+ return offset;
#else
return static_cast<int>(tm.tm_gmtoff / 60);
#endif
@@ -183,6 +200,9 @@ inline size_t thread_id()
#ifdef _WIN32
return static_cast<size_t>(::GetCurrentThreadId());
#elif __linux__
+# if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
+# define SYS_gettid __NR_gettid
+# endif
return static_cast<size_t>(syscall(SYS_gettid));
#else //Default to standard C++11 (OSX and other Unix)
return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h
index 137037e..3965b83 100644
--- a/include/spdlog/details/pattern_formatter_impl.h
+++ b/include/spdlog/details/pattern_formatter_impl.h
@@ -1,39 +1,23 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#pragma once
-#include <string>
+#include <spdlog/formatter.h>
+#include <spdlog/details/log_msg.h>
+#include <spdlog/details/os.h>
+#include <spdlog/details/format.h>
+
#include <chrono>
+#include <ctime>
#include <memory>
-#include <vector>
+#include <mutex>
+#include <string>
#include <thread>
-
-
-#include "../formatter.h"
-#include "./log_msg.h"
-#include "./os.h"
+#include <utility>
+#include <vector>
namespace spdlog
{
@@ -225,7 +209,7 @@ class I_formatter :public flag_formatter
}
};
-// ninutes 0-59
+// minutes 0-59
class M_formatter :public flag_formatter
{
void format(details::log_msg& msg, const std::tm& tm_time) override
@@ -336,8 +320,10 @@ public:
int h = total_minutes / 60;
int m = total_minutes % 60;
- char sign = h >= 0 ? '+' : '-';
- msg.formatted << sign;
+ if (h >= 0) //minus sign will be printed anyway if negative
+ {
+ msg.formatted << '+';
+ }
pad_n_join(msg.formatted, h, m, ':');
}
private:
diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h
index fd8e4be..78a47fe 100644
--- a/include/spdlog/details/registry.h
+++ b/include/spdlog/details/registry.h
@@ -1,42 +1,26 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#pragma once
+
// Loggers registy of unique name->logger pointer
-// An attempt to create a logger with an alreasy existing name will be ignored
+// An attempt to create a logger with an already existing name will be ignored
// If user requests a non existing logger, nullptr will be returned
// This class is thread safe
-#include <string>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/logger.h>
+#include <spdlog/async_logger.h>
+#include <spdlog/common.h>
+
+#include <chrono>
+#include <functional>
+#include <memory>
#include <mutex>
+#include <string>
#include <unordered_map>
-#include <functional>
-
-#include "./null_mutex.h"
-#include "../logger.h"
-#include "../async_logger.h"
-#include "../common.h"
namespace spdlog
{
@@ -49,7 +33,9 @@ public:
void register_logger(std::shared_ptr<logger> logger)
{
std::lock_guard<Mutex> lock(_mutex);
- register_logger_impl(logger);
+ auto logger_name = logger->name();
+ throw_if_exists(logger_name);
+ _loggers[logger_name] = logger;
}
@@ -62,13 +48,10 @@ public:
template<class It>
std::shared_ptr<logger> create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end)
- {
-
- std::shared_ptr<logger> new_logger;
-
+ {
std::lock_guard<Mutex> lock(_mutex);
-
-
+ throw_if_exists(logger_name);
+ std::shared_ptr<logger> new_logger;
if (_async_mode)
new_logger = std::make_shared<async_logger>(logger_name, sinks_begin, sinks_end, _async_q_size, _overflow_policy, _worker_warmup_cb, _flush_interval_ms);
else
@@ -78,7 +61,8 @@ public:
new_logger->set_formatter(_formatter);
new_logger->set_level(_level);
- register_logger_impl(new_logger);
+ //Add to registry
+ _loggers[logger_name] = new_logger;
return new_logger;
}
@@ -150,17 +134,16 @@ public:
return s_instance;
}
-private:
- void register_logger_impl(std::shared_ptr<logger> logger)
- {
- auto logger_name = logger->name();
- if (_loggers.find(logger_name) != std::end(_loggers))
- throw spdlog_ex("logger with name " + logger_name + " already exists");
- _loggers[logger->name()] = logger;
- }
- registry_t<Mutex>(){}
+private:
+ registry_t<Mutex>() {}
registry_t<Mutex>(const registry_t<Mutex>&) = delete;
registry_t<Mutex>& operator=(const registry_t<Mutex>&) = delete;
+
+ void 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");
+ }
Mutex _mutex;
std::unordered_map <std::string, std::shared_ptr<logger>> _loggers;
formatter_ptr _formatter;
diff --git a/include/spdlog/details/spdlog_impl.h b/include/spdlog/details/spdlog_impl.h
index cfd6f82..e3c966d 100644
--- a/include/spdlog/details/spdlog_impl.h
+++ b/include/spdlog/details/spdlog_impl.h
@@ -1,36 +1,23 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#pragma once
//
// Global registry functions
//
-#include "registry.h"
-#include "../sinks/file_sinks.h"
-#include "../sinks/stdout_sinks.h"
-#include "../sinks/syslog_sink.h"
+#include <spdlog/spdlog.h>
+#include <spdlog/details/registry.h>
+#include <spdlog/sinks/file_sinks.h>
+#include <spdlog/sinks/stdout_sinks.h>
+#include <spdlog/sinks/syslog_sink.h>
+
+#include <chrono>
+#include <functional>
+#include <memory>
+#include <string>
inline void spdlog::register_logger(std::shared_ptr<logger> logger)
{
@@ -90,7 +77,7 @@ inline std::shared_ptr<spdlog::logger> spdlog::stderr_logger_st(const std::strin
return details::registry::instance().create(logger_name, spdlog::sinks::stderr_sink_st::instance());
}
-#ifdef __linux__
+#if defined(__linux__) || defined(__APPLE__)
// Create syslog logger
inline std::shared_ptr<spdlog::logger> spdlog::syslog_logger(const std::string& logger_name, const std::string& syslog_ident, int syslog_option)
{
@@ -108,7 +95,7 @@ inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_
template <typename Sink, typename... Args>
-inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, const Args&... args)
+inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, Args... args)
{
sink_ptr sink = std::make_shared<Sink>(args...);
return details::registry::instance().create(logger_name, { sink });
diff --git a/include/spdlog/formatter.h b/include/spdlog/formatter.h
index 35ea041..0ffcec0 100644
--- a/include/spdlog/formatter.h
+++ b/include/spdlog/formatter.h
@@ -1,29 +1,16 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
#pragma once
-#include "details/log_msg.h"
+#include <spdlog/details/log_msg.h>
+
+#include <vector>
+#include <string>
+#include <memory>
+
namespace spdlog
{
namespace details
@@ -54,5 +41,5 @@ private:
};
}
-#include "details/pattern_formatter_impl.h"
+#include <spdlog/details/pattern_formatter_impl.h>
diff --git a/include/spdlog/logger.h b/include/spdlog/logger.h
index 7a5a31a..ebd2dd0 100644
--- a/include/spdlog/logger.h
+++ b/include/spdlog/logger.h
@@ -1,26 +1,7 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#pragma once
@@ -31,19 +12,18 @@
// 2. Format the message using the formatter function
// 3. Pass the formatted message to its sinks to performa the actual logging
-#include<vector>
-#include<memory>
-#include "sinks/base_sink.h"
-#include "common.h"
+#include <spdlog/sinks/base_sink.h>
+#include <spdlog/common.h>
+#include <spdlog/details/line_logger_fwd.h>
+
+#include <vector>
+#include <memory>
+#include <atomic>
+#include <string>
namespace spdlog
{
-namespace details
-{
-class line_logger;
-}
-
class logger
{
public:
@@ -107,7 +87,7 @@ public:
void set_pattern(const std::string&);
void set_formatter(formatter_ptr);
- void flush();
+ virtual void flush();
protected:
virtual void _log_msg(details::log_msg&);
@@ -129,4 +109,6 @@ protected:
};
}
-#include "./details/logger_impl.h"
+#include <spdlog/details/logger_impl.h>
+#include <spdlog/details/line_logger_impl.h>
+
diff --git a/include/spdlog/sinks/android_sink.h b/include/spdlog/sinks/android_sink.h
new file mode 100644
index 0000000..885f78d
--- /dev/null
+++ b/include/spdlog/sinks/android_sink.h
@@ -0,0 +1,92 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#pragma once
+
+#if defined(__ANDROID__)
+
+#include <spdlog/sinks/base_sink.h>
+#include <spdlog/details/null_mutex.h>
+
+#include <android/log.h>
+
+#include <mutex>
+#include <string>
+
+namespace spdlog
+{
+namespace sinks
+{
+/*
+* Android sink (logging using __android_log_write)
+*/
+template<class Mutex>
+class base_android_sink : public base_sink < Mutex >
+{
+public:
+ explicit base_android_sink(std::string tag="spdlog"): _tag(tag)
+ {
+ }
+
+ void flush() override
+ {
+ }
+
+protected:
+ void _sink_it(const details::log_msg& msg) override
+ {
+ const android_LogPriority priority = convert_to_android(msg.level);
+ const int expected_size = msg.formatted.size();
+ const int size = __android_log_write(
+ priority, _tag.c_str(), msg.formatted.c_str()
+ );
+ if (size > expected_size)
+ {
+ // Will write a little bit more than original message
+ }
+ else
+ {
+ throw spdlog_ex("Send to Android logcat failed");
+ }
+ }
+
+private:
+ 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::notice:
+ 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;
+ case spdlog::level::alert:
+ return ANDROID_LOG_FATAL;
+ case spdlog::level::emerg:
+ return ANDROID_LOG_FATAL;
+ default:
+ throw spdlog_ex("Incorrect level value");
+ }
+ }
+
+ std::string _tag;
+};
+
+typedef base_android_sink<std::mutex> android_sink_mt;
+typedef base_android_sink<details::null_mutex> android_sink_st;
+
+}
+}
+
+#endif
diff --git a/include/spdlog/sinks/base_sink.h b/include/spdlog/sinks/base_sink.h
index 12d63ea..615bb6f 100644
--- a/include/spdlog/sinks/base_sink.h
+++ b/include/spdlog/sinks/base_sink.h
@@ -1,26 +1,7 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#pragma once
//
@@ -29,14 +10,12 @@
// all locking is taken care of here so no locking needed by the implementors..
//
-#include<string>
-#include<mutex>
-#include<atomic>
-#include "./sink.h"
-#include "../formatter.h"
-#include "../common.h"
-#include "../details/log_msg.h"
+#include <spdlog/sinks/sink.h>
+#include <spdlog/formatter.h>
+#include <spdlog/common.h>
+#include <spdlog/details/log_msg.h>
+#include <mutex>
namespace spdlog
{
diff --git a/include/spdlog/sinks/dist_sink.h b/include/spdlog/sinks/dist_sink.h
new file mode 100644
index 0000000..0e7cfc1
--- /dev/null
+++ b/include/spdlog/sinks/dist_sink.h
@@ -0,0 +1,72 @@
+//
+// Copyright (c) 2015 David Schury, Gabi Melman
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#pragma once
+
+#include <spdlog/details/log_msg.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/sinks/base_sink.h>
+#include <spdlog/sinks/sink.h>
+
+#include <algorithm>
+#include <memory>
+#include <mutex>
+#include <vector>
+
+namespace spdlog
+{
+namespace sinks
+{
+template<class Mutex>
+class dist_sink: public base_sink<Mutex>
+{
+public:
+ explicit dist_sink() :_sinks() {}
+ dist_sink(const dist_sink&) = delete;
+ dist_sink& operator=(const dist_sink&) = delete;
+ virtual ~dist_sink() = default;
+
+protected:
+ void _sink_it(const details::log_msg& msg) override
+ {
+ for (auto iter = _sinks.begin(); iter != _sinks.end(); iter++)
+ (*iter)->log(msg);
+ }
+
+ std::vector<std::shared_ptr<sink>> _sinks;
+
+public:
+ void flush() override
+ {
+ std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
+ for (auto iter = _sinks.begin(); iter != _sinks.end(); iter++)
+ (*iter)->flush();
+ }
+
+ void add_sink(std::shared_ptr<sink> sink)
+ {
+ std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
+ if (sink &&
+ _sinks.end() == std::find(_sinks.begin(), _sinks.end(), sink))
+ {
+ _sinks.push_back(sink);
+ }
+ }
+
+ void remove_sink(std::shared_ptr<sink> sink)
+ {
+ std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
+ auto pos = std::find(_sinks.begin(), _sinks.end(), sink);
+ if (pos != _sinks.end())
+ {
+ _sinks.erase(pos);
+ }
+ }
+};
+
+typedef dist_sink<std::mutex> dist_sink_mt;
+typedef dist_sink<details::null_mutex> dist_sink_st;
+}
+}
diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h
index 6c8f2df..c3d214f 100644
--- a/include/spdlog/sinks/file_sinks.h
+++ b/include/spdlog/sinks/file_sinks.h
@@ -1,34 +1,21 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#pragma once
+#include <spdlog/sinks/base_sink.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/details/file_helper.h>
+#include <spdlog/details/format.h>
+
+#include <algorithm>
+#include <chrono>
+#include <cstdio>
+#include <ctime>
#include <mutex>
-#include "base_sink.h"
-#include "../details/null_mutex.h"
-#include "../details/file_helper.h"
-#include "../details/format.h"
+#include <string>
namespace spdlog
{
@@ -230,4 +217,4 @@ private:
typedef daily_file_sink<std::mutex> daily_file_sink_mt;
typedef daily_file_sink<details::null_mutex> daily_file_sink_st;
}
-}
\ No newline at end of file
+}
diff --git a/include/spdlog/sinks/msvc_sink.h b/include/spdlog/sinks/msvc_sink.h
new file mode 100644
index 0000000..9e101ad
--- /dev/null
+++ b/include/spdlog/sinks/msvc_sink.h
@@ -0,0 +1,50 @@
+//
+// Copyright(c) 2016 Alexander Dalshov.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#pragma once
+
+#if defined(_MSC_VER)
+
+#include <spdlog/sinks/base_sink.h>
+#include <spdlog/details/null_mutex.h>
+
+#include <WinBase.h>
+
+#include <mutex>
+#include <string>
+
+namespace spdlog
+{
+namespace sinks
+{
+/*
+* MSVC sink (logging using OutputDebugStringA)
+*/
+template<class Mutex>
+class msvc_sink : public base_sink < Mutex >
+{
+public:
+ explicit msvc_sink()
+ {
+ }
+
+ void flush() override
+ {
+ }
+
+protected:
+ void _sink_it(const details::log_msg& msg) override
+ {
+ OutputDebugStringA(msg.formatted.c_str());
+ }
+};
+
+typedef msvc_sink<std::mutex> msvc_sink_mt;
+typedef msvc_sink<details::null_mutex> msvc_sink_st;
+
+}
+}
+
+#endif
diff --git a/include/spdlog/sinks/null_sink.h b/include/spdlog/sinks/null_sink.h
index 992b3b7..68bd9c9 100644
--- a/include/spdlog/sinks/null_sink.h
+++ b/include/spdlog/sinks/null_sink.h
@@ -1,32 +1,14 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#pragma once
-#include <mutex>
-#include "./base_sink.h"
-#include "../details/null_mutex.h"
+#include <spdlog/sinks/base_sink.h>
+#include <spdlog/details/null_mutex.h>
+
+#include <mutex>
namespace spdlog
{
diff --git a/include/spdlog/sinks/ostream_sink.h b/include/spdlog/sinks/ostream_sink.h
index f2fe3b2..feb5efa 100644
--- a/include/spdlog/sinks/ostream_sink.h
+++ b/include/spdlog/sinks/ostream_sink.h
@@ -1,35 +1,15 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#pragma once
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/sinks/base_sink.h>
+
#include <ostream>
#include <mutex>
-#include <memory>
-
-#include "../details/null_mutex.h"
-#include "./base_sink.h"
namespace spdlog
{
diff --git a/include/spdlog/sinks/sink.h b/include/spdlog/sinks/sink.h
index 88c423a..39dc771 100644
--- a/include/spdlog/sinks/sink.h
+++ b/include/spdlog/sinks/sink.h
@@ -1,30 +1,12 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
#pragma once
-#include "../details/log_msg.h"
+#include <spdlog/details/log_msg.h>
namespace spdlog
{
diff --git a/include/spdlog/sinks/stdout_sinks.h b/include/spdlog/sinks/stdout_sinks.h
index 5ad06c2..85db334 100644
--- a/include/spdlog/sinks/stdout_sinks.h
+++ b/include/spdlog/sinks/stdout_sinks.h
@@ -1,33 +1,16 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#pragma once
+#include <spdlog/sinks/ostream_sink.h>
+#include <spdlog/details/null_mutex.h>
+
#include <iostream>
+#include <memory>
#include <mutex>
-#include "./ostream_sink.h"
-#include "../details/null_mutex.h"
namespace spdlog
{
diff --git a/include/spdlog/sinks/syslog_sink.h b/include/spdlog/sinks/syslog_sink.h
index 37b6513..5d7ccf8 100644
--- a/include/spdlog/sinks/syslog_sink.h
+++ b/include/spdlog/sinks/syslog_sink.h
@@ -1,39 +1,20 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#pragma once
-#ifdef __linux__
+#if defined(__linux__) || defined(__APPLE__)
+
+#include <spdlog/sinks/sink.h>
+#include <spdlog/common.h>
+#include <spdlog/details/log_msg.h>
#include <array>
#include <string>
#include <syslog.h>
-#include "./sink.h"
-#include "../common.h"
-#include "../details/log_msg.h"
-
namespace spdlog
{
@@ -75,7 +56,7 @@ public:
void log(const details::log_msg &msg) override
{
- ::syslog(syslog_prio_from_level(msg), "%s", msg.formatted.str().c_str());
+ ::syslog(syslog_prio_from_level(msg), "%s", msg.raw.str().c_str());
}
void flush() override
diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h
index aef0406..b92a239 100644
--- a/include/spdlog/spdlog.h
+++ b/include/spdlog/spdlog.h
@@ -1,36 +1,21 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
-
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
// spdlog main header file.
-//see example.cpp for usage example
+// see example.cpp for usage example
#pragma once
-#include "tweakme.h"
-#include "common.h"
-#include "logger.h"
+#include <spdlog/tweakme.h>
+#include <spdlog/common.h>
+#include <spdlog/logger.h>
+
+#include <memory>
+#include <functional>
+#include <chrono>
+#include <string>
namespace spdlog
{
@@ -98,7 +83,7 @@ std::shared_ptr<logger> stderr_logger_st(const std::string& logger_name);
//
// Create and register a syslog logger
//
-#ifdef __linux__
+#if defined(__linux__) || defined(__APPLE__)
std::shared_ptr<logger> syslog_logger(const std::string& logger_name, const std::string& ident = "", int syslog_option = 0);
#endif
@@ -112,7 +97,7 @@ std::shared_ptr<logger> create(const std::string& logger_name, const It& sinks_b
// Create and register a logger with templated sink type
// Example: spdlog::create<daily_file_sink_st>("mylog", "dailylog_filename", "txt");
template <typename Sink, typename... Args>
-std::shared_ptr<spdlog::logger> create(const std::string& logger_name, const Args&...);
+std::shared_ptr<spdlog::logger> create(const std::string& logger_name, Args...);
// Register the given logger with the given name
@@ -152,4 +137,4 @@ void drop_all();
}
-#include "details/spdlog_impl.h"
+#include <spdlog/details/spdlog_impl.h>
diff --git a/include/spdlog/tweakme.h b/include/spdlog/tweakme.h
index b651658..f136514 100644
--- a/include/spdlog/tweakme.h
+++ b/include/spdlog/tweakme.h
@@ -1,34 +1,13 @@
-/*************************************************************************/
-/* spdlog - an extremely fast and easy to use c++11 logging library. */
-/* Copyright (c) 2014 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. */
-/*************************************************************************/
-
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
#pragma once
-///////////////////////////////////////////////////////////////////////////////
+//
// Edit this file to squeeze every last drop of performance out of spdlog.
-///////////////////////////////////////////////////////////////////////////////
-
+//
///////////////////////////////////////////////////////////////////////////////
// Under Linux, the much faster CLOCK_REALTIME_COARSE clock can be used.
diff --git a/tests/Makefile b/tests/Makefile
index 5be7be5..0eec327 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -1,5 +1,5 @@
CXX ?= g++
-CXXFLAGS = -Wall -pedantic -std=c++11 -pthread -O2
+CXXFLAGS = -Wall -pedantic -std=c++11 -pthread -O2 -I../include
LDPFALGS = -pthread
CPP_FILES := $(wildcard *.cpp)
diff --git a/tests/file_helper.cpp b/tests/file_helper.cpp
new file mode 100644
index 0000000..f57ab70
--- /dev/null
+++ b/tests/file_helper.cpp
@@ -0,0 +1,77 @@
+/*
+* This content is released under the MIT License as specified in https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE
+*/
+#include "includes.h"
+
+using namespace spdlog::details;
+
+static const std::string filename = "logs/file_helper_test.txt";
+
+static void write_with_helper(file_helper &helper, size_t howmany)
+{
+ log_msg msg;
+ msg.formatted << std::string(howmany, '1');
+ helper.write(msg);
+}
+
+
+TEST_CASE("file_helper_filename", "[file_helper::filename()]]")
+{
+ prepare_logdir();
+
+ file_helper helper(false);
+ helper.open(filename);
+ REQUIRE(helper.filename() == filename);
+}
+
+
+
+TEST_CASE("file_helper_size", "[file_helper::size()]]")
+{
+ prepare_logdir();
+ auto expected_size = 123;
+ {
+ file_helper helper(true);
+ helper.open(filename);
+ write_with_helper(helper, expected_size);
+ REQUIRE(helper.size() == expected_size);
+ }
+ REQUIRE(get_filesize(filename) == expected_size);
+}
+
+
+TEST_CASE("file_helper_exists", "[file_helper::file_exists()]]")
+{
+ prepare_logdir();
+ REQUIRE(!file_helper::file_exists(filename));
+ file_helper helper(false);
+ helper.open(filename);
+ REQUIRE(file_helper::file_exists(filename));
+}
+
+TEST_CASE("file_helper_reopen", "[file_helper::reopen()]]")
+{
+ prepare_logdir();
+ file_helper helper(true);
+ helper.open(filename);
+ write_with_helper(helper, 12);
+ REQUIRE(helper.size() == 12);
+ helper.reopen(true);
+ REQUIRE(helper.size() == 0);
+}
+
+TEST_CASE("file_helper_reopen2", "[file_helper::reopen(false)]]")
+{
+ prepare_logdir();
+ auto expected_size = 14;
+ file_helper helper(true);
+ helper.open(filename);
+ write_with_helper(helper, expected_size);
+ REQUIRE(helper.size() == expected_size);
+ helper.reopen(false);
+ REQUIRE(helper.size() == expected_size);
+}
+
+
+
+
diff --git a/tests/file_log.cpp b/tests/file_log.cpp
index d8e5aa1..2abd021 100644
--- a/tests/file_log.cpp
+++ b/tests/file_log.cpp
@@ -1,48 +1,8 @@
+/*
+ * This content is released under the MIT License as specified in https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE
+ */
#include "includes.h"
-static std::string file_contents(const std::string& filename)
-{
- std::ifstream ifs(filename);
- if (!ifs)
- throw std::runtime_error("Failed open file ");
- return std::string((std::istreambuf_iterator<char>(ifs)),
- (std::istreambuf_iterator<char>()));
-
-}
-
-static std::size_t count_lines(const std::string& filename)
-{
- std::ifstream ifs(filename);
- if (!ifs)
- throw std::runtime_error("Failed open file ");
-
- std::string line;
- size_t counter = 0;
- while(std::getline(ifs, line))
- counter++;
- return counter;
-}
-
-std::ifstream::pos_type filesize(const std::string& filename)
-{
- std::ifstream ifs(filename, std::ifstream::ate | std::ifstream::binary);
- if (!ifs)
- throw std::runtime_error("Failed open file ");
-
- return ifs.tellg();
-}
-
-static void prepare_logdir()
-{
- spdlog::drop_all();
-#ifdef _WIN32
- auto rv = system("del /F /Q logs\\*");
-#else
- auto rv = system("rm -f logs/*");
-#endif
-}
-
-
TEST_CASE("simple_file_logger", "[simple_logger]]")
{
@@ -52,7 +12,7 @@ TEST_CASE("simple_file_logger", "[simple_logger]]")
auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger", filename);
logger->set_pattern("%v");
-
+
logger->info("Test message {}", 1);
logger->info("Test message {}", 2);
logger->flush();
@@ -61,7 +21,6 @@ TEST_CASE("simple_file_logger", "[simple_logger]]")
}
-
TEST_CASE("rotating_file_logger1", "[rotating_logger]]")
{
prepare_logdir();
@@ -93,9 +52,9 @@ TEST_CASE("rotating_file_logger2", "[rotating_logger]]")
logger->info("Test message {}", i);
logger->flush();
- REQUIRE(filesize(filename) <= 1024);
+ REQUIRE(get_filesize(filename) <= 1024);
auto filename1 = basename + ".1.txt";
- REQUIRE(filesize(filename1) <= 1024);
+ REQUIRE(get_filesize(filename1) <= 1024);
}
diff --git a/tests/includes.h b/tests/includes.h
index 7cda161..9cdee27 100644
--- a/tests/includes.h
+++ b/tests/includes.h
@@ -8,5 +8,8 @@
#include <exception>
#include "catch.hpp"
+#include "utils.h"
+
#include "../include/spdlog/spdlog.h"
#include "../include/spdlog/sinks/null_sink.h"
+
diff --git a/tests/tests.vcxproj b/tests/tests.vcxproj
index 58cfd52..56787c7 100644
--- a/tests/tests.vcxproj
+++ b/tests/tests.vcxproj
@@ -1,5 +1,5 @@
<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
@@ -26,26 +26,26 @@
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
- <PlatformToolset>v120</PlatformToolset>
+ <PlatformToolset>v140</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
- <PlatformToolset>v120</PlatformToolset>
+ <PlatformToolset>v140</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
- <PlatformToolset>v120</PlatformToolset>
+ <PlatformToolset>v140</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
- <PlatformToolset>v120</PlatformToolset>
+ <PlatformToolset>v140</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
@@ -82,6 +82,8 @@
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<SDLCheck>true</SDLCheck>
+ <PreprocessorDefinitions>_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <AdditionalIncludeDirectories>$(SolutionDir)..\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<GenerateDebugInformation>true</GenerateDebugInformation>
@@ -110,6 +112,8 @@
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
+ <PreprocessorDefinitions>_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <AdditionalIncludeDirectories>$(SolutionDir)..\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<GenerateDebugInformation>true</GenerateDebugInformation>
@@ -119,14 +123,17 @@
</Link>
</ItemDefinitionGroup>
<ItemGroup>
+ <ClCompile Include="file_helper.cpp" />
<ClCompile Include="file_log.cpp" />
<ClCompile Include="format.cpp" />
<ClCompile Include="main.cpp" />
<ClCompile Include="registry.cpp" />
+ <ClCompile Include="utils.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="catch.hpp" />
<ClInclude Include="includes.h" />
+ <ClInclude Include="utils.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
diff --git a/tests/tests.vcxproj.filters b/tests/tests.vcxproj.filters
index 36fe0a8..8a1a5d6 100644
--- a/tests/tests.vcxproj.filters
+++ b/tests/tests.vcxproj.filters
@@ -27,6 +27,12 @@
<ClCompile Include="registry.cpp">
<Filter>Source Files</Filter>
</ClCompile>
+ <ClCompile Include="file_helper.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="utils.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="includes.h">
@@ -35,5 +41,8 @@
<ClInclude Include="catch.hpp">
<Filter>Header Files</Filter>
</ClInclude>
+ <ClInclude Include="utils.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
</ItemGroup>
</Project>
\ No newline at end of file
diff --git a/tests/utils.cpp b/tests/utils.cpp
new file mode 100644
index 0000000..83fdf84
--- /dev/null
+++ b/tests/utils.cpp
@@ -0,0 +1,45 @@
+#include "includes.h"
+
+void prepare_logdir()
+{
+ spdlog::drop_all();
+#ifdef _WIN32
+ system("del /F /Q logs\\*");
+#else
+ system("rm -f logs/*");
+#endif
+}
+
+
+std::string file_contents(const std::string& filename)
+{
+ std::ifstream ifs(filename);
+ if (!ifs)
+ throw std::runtime_error("Failed open file ");
+ return std::string((std::istreambuf_iterator<char>(ifs)),
+ (std::istreambuf_iterator<char>()));
+
+}
+
+std::size_t count_lines(const std::string& filename)
+{
+ std::ifstream ifs(filename);
+ if (!ifs)
+ throw std::runtime_error("Failed open file ");
+
+ std::string line;
+ size_t counter = 0;
+ while(std::getline(ifs, line))
+ counter++;
+ return counter;
+}
+
+std::size_t get_filesize(const std::string& filename)
+{
+ std::ifstream ifs(filename, std::ifstream::ate | std::ifstream::binary);
+ if (!ifs)
+ throw std::runtime_error("Failed open file ");
+
+ return ifs.tellg();
+}
+
diff --git a/tests/utils.h b/tests/utils.h
new file mode 100644
index 0000000..1d9b621
--- /dev/null
+++ b/tests/utils.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <string>
+#include<cstddef>
+
+std::size_t count_lines(const std::string& filename);
+
+void prepare_logdir();
+
+std::string file_contents(const std::string& filename);
+
+std::size_t count_lines(const std::string& filename);
+
+std::size_t get_filesize(const std::string& filename);
+
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-med/spdlog.git
More information about the debian-med-commit
mailing list