plastichub/nodeguy
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Adds linters, code formatters for both js and c++ and adds prepush hook (#178)

Browse Source
This commit is contained in:
Atul R 2019-11-08 19:30:01 +01:00 committed by GitHub
parent fbbfa97d4b
commit bd65329641
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
306 changed files with 14456 additions and 14336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
.clang-format Normal file
View File

@ -0,0 +1,8 @@
BasedOnStyle: Google
IndentWidth: 2
---
Language: Cpp
PointerAlignment: Left
AlwaysBreakAfterReturnType: None
SortIncludes: true

28
.eslintrc.js Normal file
View File

@ -0,0 +1,28 @@
module.exports = {
extends: [
"plugin:prettier/recommended" // Enables eslint-plugin-prettier and eslint-config-prettier. This will display prettier errors as ESLint errors. Make sure this is always the last configuration in the extends array.
],
parserOptions: {
ecmaVersion: 2018, // Allows for the parsing of modern ECMAScript features
sourceType: "module" // Allows for the use of imports
},
overrides: [
{
files: ["*.ts", "*.tsx"],
parser: "@typescript-eslint/parser", // Specifies the ESLint parser
extends: [
"plugin:@typescript-eslint/recommended", // Uses the recommended rules from the @typescript-eslint/eslint-plugin
"prettier/@typescript-eslint", // Uses eslint-config-prettier to disable ESLint rules from @typescript-eslint/eslint-plugin that would conflict with prettier
"plugin:prettier/recommended" // Enables eslint-plugin-prettier and eslint-config-prettier. This will display prettier errors as ESLint errors. Make sure this is always the last configuration in the extends array.
],
parserOptions: {
ecmaVersion: 2018, // Allows for the parsing of modern ECMAScript features
sourceType: "module" // Allows for the use of imports
},
rules: {
"@typescript-eslint/camelcase": 0,
"@typescript-eslint/no-var-requires": 0
}
}
]
};

7
.prettierrc.js Normal file
View File

@ -0,0 +1,7 @@
module.exports = {
semi: true,
trailingComma: 'all',
singleQuote: true,
printWidth: 120,
tabWidth: 4,
};

1582
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

96
package.json
View File

@ -1,43 +1,57 @@
{ {
"name": "@nodegui/nodegui", "name": "@nodegui/nodegui",
"version": "0.3.1", "version": "0.3.1",
"description": "A cross platform library to build native desktop apps.", "description": "A cross platform library to build native desktop apps.",
"main": "dist/index.js", "main": "dist/index.js",
"typings": "dist/index.d.ts", "typings": "dist/index.d.ts",
"files": [ "files": [
"dist", "dist",
"config", "config",
"CMakeLists.txt", "CMakeLists.txt",
"src/cpp", "src/cpp",
"extras/legal", "extras/legal",
"plugin" "plugin"
], ],
"author": "Atul R <atulanand94@gmail.com>", "author": "Atul R <atulanand94@gmail.com>",
"license": "MIT", "license": "MIT",
"private": false, "private": false,
"scripts": { "scripts": {
"dev": "npm run build && qode dist/demo.js", "dev": "npm run build && qode dist/demo.js",
"postinstall": "npm run build:addon", "postinstall": "npm run build:addon",
"build": "tsc && npm run build:addon", "build": "tsc && npm run build:addon",
"build:addon": "cross-env CMAKE_BUILD_PARALLEL_LEVEL=8 cmake-js build", "build:addon": "cross-env CMAKE_BUILD_PARALLEL_LEVEL=8 cmake-js build",
"test": "qode ./node_modules/.bin/jest" "test": "qode ./node_modules/.bin/jest",
}, "lint:cpp": "clang-format -i --glob=src/cpp/**/*.[h,c]*",
"dependencies": { "lint:ts": "tsc --noEmit && eslint './src/**/*.{ts,tsx}' --fix"
"@nodegui/qode": "^1.0.5", },
"cmake-js": "^6.0.0", "dependencies": {
"cross-env": "^6.0.0", "@nodegui/qode": "^1.0.5",
"cuid": "^2.1.6", "cmake-js": "^6.0.0",
"node-addon-api": "^1.6.3", "cross-env": "^6.0.0",
"postcss-nodegui-autoprefixer": "0.0.7" "cuid": "^2.1.6",
}, "node-addon-api": "^1.6.3",
"devDependencies": { "postcss-nodegui-autoprefixer": "0.0.7"
"@types/bindings": "^1.3.0", },
"@types/jest": "^24.0.18", "devDependencies": {
"@types/node": "^12.0.2", "@types/bindings": "^1.3.0",
"jest": "^24.9.0", "@types/jest": "^24.0.18",
"prettier": "^1.17.1", "@types/node": "^12.0.2",
"serve": "^11.1.0", "@typescript-eslint/eslint-plugin": "^2.6.1",
"ts-jest": "^24.1.0", "@typescript-eslint/parser": "^2.6.1",
"typescript": "^3.6.3" "clang-format": "^1.3.0",
} "eslint": "^6.6.0",
"eslint-config-prettier": "^6.5.0",
"eslint-plugin-prettier": "^3.1.1",
"husky": "^3.0.9",
"jest": "^24.9.0",
"prettier": "^1.18.2",
"serve": "^11.1.0",
"ts-jest": "^24.1.0",
"typescript": "^3.6.3"
},
"husky": {
"hooks": {
"pre-push": "npm run lint:ts && npm run lint:cpp && npm run test"
}
}
} }

81
src/cpp/include/deps/spdlog/async.h Executable file → Normal file
View File

@ -17,13 +17,13 @@
// This is because each message in the queue holds a shared_ptr to the // This is because each message in the queue holds a shared_ptr to the
// originating logger. // originating logger.
#include <memory>
#include <mutex>
#include "spdlog/async_logger.h" #include "spdlog/async_logger.h"
#include "spdlog/details/registry.h" #include "spdlog/details/registry.h"
#include "spdlog/details/thread_pool.h" #include "spdlog/details/thread_pool.h"
#include <memory>
#include <mutex>
namespace spdlog { namespace spdlog {
namespace details { namespace details {
@ -33,55 +33,56 @@ static const size_t default_async_q_size = 8192;
// async logger factory - creates async loggers backed with thread pool. // async logger factory - creates async loggers backed with thread pool.
// if a global thread pool doesn't already exist, create it with default queue // if a global thread pool doesn't already exist, create it with default queue
// size of 8192 items and single thread. // size of 8192 items and single thread.
template<async_overflow_policy OverflowPolicy = async_overflow_policy::block> template <async_overflow_policy OverflowPolicy = async_overflow_policy::block>
struct async_factory_impl struct async_factory_impl {
{ template <typename Sink, typename... SinkArgs>
template<typename Sink, typename... SinkArgs> static std::shared_ptr<async_logger> create(std::string logger_name,
static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&... args) SinkArgs &&... args) {
{ auto &registry_inst = details::registry::instance();
auto &registry_inst = details::registry::instance();
// create global thread pool if not already exists.. // create global thread pool if not already exists..
std::lock_guard<std::recursive_mutex> tp_lock(registry_inst.tp_mutex()); std::lock_guard<std::recursive_mutex> tp_lock(registry_inst.tp_mutex());
auto tp = registry_inst.get_tp(); auto tp = registry_inst.get_tp();
if (tp == nullptr) if (tp == nullptr) {
{ tp = std::make_shared<details::thread_pool>(details::default_async_q_size,
tp = std::make_shared<details::thread_pool>(details::default_async_q_size, 1); 1);
registry_inst.set_tp(tp); registry_inst.set_tp(tp);
}
auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink), std::move(tp), OverflowPolicy);
registry_inst.initialize_logger(new_logger);
return new_logger;
} }
auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
auto new_logger = std::make_shared<async_logger>(
std::move(logger_name), std::move(sink), std::move(tp), OverflowPolicy);
registry_inst.initialize_logger(new_logger);
return new_logger;
}
}; };
using async_factory = async_factory_impl<async_overflow_policy::block>; using async_factory = async_factory_impl<async_overflow_policy::block>;
using async_factory_nonblock = async_factory_impl<async_overflow_policy::overrun_oldest>; using async_factory_nonblock =
async_factory_impl<async_overflow_policy::overrun_oldest>;
template<typename Sink, typename... SinkArgs> template <typename Sink, typename... SinkArgs>
inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name, SinkArgs &&... sink_args) inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name,
{ SinkArgs &&... sink_args) {
return async_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...); return async_factory::create<Sink>(std::move(logger_name),
std::forward<SinkArgs>(sink_args)...);
} }
template<typename Sink, typename... SinkArgs> template <typename Sink, typename... SinkArgs>
inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name, SinkArgs &&... sink_args) inline std::shared_ptr<spdlog::logger> create_async_nb(
{ std::string logger_name, SinkArgs &&... sink_args) {
return async_factory_nonblock::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...); return async_factory_nonblock::create<Sink>(
std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
} }
// set global thread pool. // set global thread pool.
inline void init_thread_pool(size_t q_size, size_t thread_count) inline void init_thread_pool(size_t q_size, size_t thread_count) {
{ auto tp = std::make_shared<details::thread_pool>(q_size, thread_count);
auto tp = std::make_shared<details::thread_pool>(q_size, thread_count); details::registry::instance().set_tp(std::move(tp));
details::registry::instance().set_tp(std::move(tp));
} }
// get the global thread pool. // get the global thread pool.
inline std::shared_ptr<spdlog::details::thread_pool> thread_pool() inline std::shared_ptr<spdlog::details::thread_pool> thread_pool() {
{ return details::registry::instance().get_tp();
return details::registry::instance().get_tp();
} }
} // namespace spdlog } // namespace spdlog

63
src/cpp/include/deps/spdlog/async_logger.h Executable file → Normal file
View File

@ -19,55 +19,60 @@
// Upon destruction, logs all remaining messages in the queue before // Upon destruction, logs all remaining messages in the queue before
// destructing.. // destructing..
#include "spdlog/common.h"
#include "spdlog/logger.h"
#include <chrono> #include <chrono>
#include <memory> #include <memory>
#include <string> #include <string>
#include "spdlog/common.h"
#include "spdlog/logger.h"
namespace spdlog { namespace spdlog {
// Async overflow policy - block by default. // Async overflow policy - block by default.
enum class async_overflow_policy enum class async_overflow_policy {
{ block, // Block until message can be enqueued
block, // Block until message can be enqueued overrun_oldest // Discard oldest message in the queue if full when trying to
overrun_oldest // Discard oldest message in the queue if full when trying to // add new item.
// add new item.
}; };
namespace details { namespace details {
class thread_pool; class thread_pool;
} }
class async_logger final : public std::enable_shared_from_this<async_logger>, public logger class async_logger final : public std::enable_shared_from_this<async_logger>,
{ public logger {
friend class details::thread_pool; friend class details::thread_pool;
public: public:
template<typename It> template <typename It>
async_logger(std::string logger_name, It begin, It end, std::weak_ptr<details::thread_pool> tp, async_logger(
async_overflow_policy overflow_policy = async_overflow_policy::block); std::string logger_name, It begin, It end,
std::weak_ptr<details::thread_pool> tp,
async_overflow_policy overflow_policy = async_overflow_policy::block);
async_logger(std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp, async_logger(
async_overflow_policy overflow_policy = async_overflow_policy::block); std::string logger_name, sinks_init_list sinks_list,
std::weak_ptr<details::thread_pool> tp,
async_overflow_policy overflow_policy = async_overflow_policy::block);
async_logger(std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp, async_logger(
async_overflow_policy overflow_policy = async_overflow_policy::block); std::string logger_name, sink_ptr single_sink,
std::weak_ptr<details::thread_pool> tp,
async_overflow_policy overflow_policy = async_overflow_policy::block);
std::shared_ptr<logger> clone(std::string new_name) override; std::shared_ptr<logger> clone(std::string new_name) override;
protected: protected:
void sink_it_(details::log_msg &msg) override; void sink_it_(details::log_msg &msg) override;
void flush_() override; void flush_() override;
void backend_log_(const details::log_msg &incoming_log_msg); void backend_log_(const details::log_msg &incoming_log_msg);
void backend_flush_(); void backend_flush_();
private: private:
std::weak_ptr<details::thread_pool> thread_pool_; std::weak_ptr<details::thread_pool> thread_pool_;
async_overflow_policy overflow_policy_; async_overflow_policy overflow_policy_;
}; };
} // namespace spdlog } // namespace spdlog
#include "details/async_logger_impl.h" #include "details/async_logger_impl.h"

149
src/cpp/include/deps/spdlog/common.h Executable file → Normal file
View File

@ -5,26 +5,25 @@
#pragma once #pragma once
#include "spdlog/tweakme.h"
#include <atomic> #include <atomic>
#include <chrono> #include <chrono>
#include <cstring>
#include <functional> #include <functional>
#include <initializer_list> #include <initializer_list>
#include <memory> #include <memory>
#include <stdexcept> #include <stdexcept>
#include <string> #include <string>
#include <cstring>
#include <type_traits> #include <type_traits>
#include <unordered_map> #include <unordered_map>
#include "spdlog/tweakme.h"
#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
#include <codecvt> #include <codecvt>
#include <locale> #include <locale>
#endif #endif
#include "spdlog/details/null_mutex.h" #include "spdlog/details/null_mutex.h"
#include "spdlog/fmt/fmt.h" #include "spdlog/fmt/fmt.h"
// visual studio upto 2013 does not support noexcept nor constexpr // visual studio upto 2013 does not support noexcept nor constexpr
@ -56,7 +55,7 @@
#define SPDLOG_STRRCHR(str, sep) __builtin_strrchr(str, sep) #define SPDLOG_STRRCHR(str, sep) __builtin_strrchr(str, sep)
#else #else
#define SPDLOG_STRRCHR(str, sep) strrchr(str, sep) #define SPDLOG_STRRCHR(str, sep) strrchr(str, sep)
#endif //__builtin_strrchr not defined #endif //__builtin_strrchr not defined
#ifdef _WIN32 #ifdef _WIN32
#define SPDLOG_FILE_BASENAME(file) SPDLOG_STRRCHR("\\" file, '\\') + 1 #define SPDLOG_FILE_BASENAME(file) SPDLOG_STRRCHR("\\" file, '\\') + 1
@ -108,89 +107,74 @@ using level_t = std::atomic<int>;
// Log level enum // Log level enum
namespace level { namespace level {
enum level_enum enum level_enum {
{ trace = SPDLOG_LEVEL_TRACE,
trace = SPDLOG_LEVEL_TRACE, debug = SPDLOG_LEVEL_DEBUG,
debug = SPDLOG_LEVEL_DEBUG, info = SPDLOG_LEVEL_INFO,
info = SPDLOG_LEVEL_INFO, warn = SPDLOG_LEVEL_WARN,
warn = SPDLOG_LEVEL_WARN, err = SPDLOG_LEVEL_ERROR,
err = SPDLOG_LEVEL_ERROR, critical = SPDLOG_LEVEL_CRITICAL,
critical = SPDLOG_LEVEL_CRITICAL, off = SPDLOG_LEVEL_OFF,
off = SPDLOG_LEVEL_OFF,
}; };
#if !defined(SPDLOG_LEVEL_NAMES) #if !defined(SPDLOG_LEVEL_NAMES)
#define SPDLOG_LEVEL_NAMES \ #define SPDLOG_LEVEL_NAMES \
{ \ { "trace", "debug", "info", "warning", "error", "critical", "off" }
"trace", "debug", "info", "warning", "error", "critical", "off" \
}
#endif #endif
static string_view_t level_string_views[] SPDLOG_LEVEL_NAMES; static string_view_t level_string_views[] SPDLOG_LEVEL_NAMES;
static const char *short_level_names[]{"T", "D", "I", "W", "E", "C", "O"}; static const char *short_level_names[]{"T", "D", "I", "W", "E", "C", "O"};
inline string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT inline string_view_t &to_string_view(spdlog::level::level_enum l)
{ SPDLOG_NOEXCEPT {
return level_string_views[l]; return level_string_views[l];
} }
inline const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT inline const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT {
{ return short_level_names[l];
return short_level_names[l];
} }
inline spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT inline spdlog::level::level_enum from_str(const std::string &name)
{ SPDLOG_NOEXCEPT {
int level = 0; int level = 0;
for (const auto &level_str : level_string_views) for (const auto &level_str : level_string_views) {
{ if (level_str == name) {
if (level_str == name) return static_cast<level::level_enum>(level);
{
return static_cast<level::level_enum>(level);
}
level++;
} }
return level::off; level++;
}
return level::off;
} }
using level_hasher = std::hash<int>; using level_hasher = std::hash<int>;
} // namespace level } // namespace level
// //
// Pattern time - specific time getting to use for pattern_formatter. // Pattern time - specific time getting to use for pattern_formatter.
// local time by default // local time by default
// //
enum class pattern_time_type enum class pattern_time_type {
{ local, // log localtime
local, // log localtime utc // log utc
utc // log utc
}; };
// //
// Log exception // Log exception
// //
class spdlog_ex : public std::exception class spdlog_ex : public std::exception {
{ public:
public: explicit spdlog_ex(std::string msg) : msg_(std::move(msg)) {}
explicit spdlog_ex(std::string msg)
: msg_(std::move(msg))
{
}
spdlog_ex(const std::string &msg, int last_errno) spdlog_ex(const std::string &msg, int last_errno) {
{ fmt::memory_buffer outbuf;
fmt::memory_buffer outbuf; fmt::format_system_error(outbuf, last_errno, msg);
fmt::format_system_error(outbuf, last_errno, msg); msg_ = fmt::to_string(outbuf);
msg_ = fmt::to_string(outbuf); }
}
const char *what() const SPDLOG_NOEXCEPT override const char *what() const SPDLOG_NOEXCEPT override { return msg_.c_str(); }
{
return msg_.c_str();
}
private: private:
std::string msg_; std::string msg_;
}; };
// //
@ -202,42 +186,31 @@ using filename_t = std::wstring;
using filename_t = std::string; using filename_t = std::string;
#endif #endif
struct source_loc struct source_loc {
{ SPDLOG_CONSTEXPR source_loc() : filename{""}, line{0}, funcname{""} {}
SPDLOG_CONSTEXPR source_loc() SPDLOG_CONSTEXPR source_loc(const char *filename, int line,
: filename{""} const char *funcname)
, line{0} : filename{filename},
, funcname{""} line{static_cast<uint32_t>(line)},
{ funcname{funcname} {}
}
SPDLOG_CONSTEXPR source_loc(const char *filename, int line, const char *funcname)
: filename{filename}
, line{static_cast<uint32_t>(line)}
, funcname{funcname}
{
}
SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT { return line == 0; }
{ const char *filename;
return line == 0; uint32_t line;
} const char *funcname;
const char *filename;
uint32_t line;
const char *funcname;
}; };
namespace details { namespace details {
// make_unique support for pre c++14 // make_unique support for pre c++14
#if __cplusplus >= 201402L // C++14 and beyond #if __cplusplus >= 201402L // C++14 and beyond
using std::make_unique; using std::make_unique;
#else #else
template<typename T, typename... Args> template <typename T, typename... Args>
std::unique_ptr<T> make_unique(Args &&... args) std::unique_ptr<T> make_unique(Args &&... args) {
{ static_assert(!std::is_array<T>::value, "arrays not supported");
static_assert(!std::is_array<T>::value, "arrays not supported"); return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
} }
#endif #endif
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

129
src/cpp/include/deps/spdlog/details/async_logger_impl.h Executable file → Normal file
View File

@ -8,103 +8,92 @@
// async logger implementation // async logger implementation
// uses a thread pool to perform the actual logging // uses a thread pool to perform the actual logging
#include "spdlog/details/thread_pool.h"
#include <chrono> #include <chrono>
#include <memory> #include <memory>
#include <string> #include <string>
template<typename It> #include "spdlog/details/thread_pool.h"
template <typename It>
inline spdlog::async_logger::async_logger( inline spdlog::async_logger::async_logger(
std::string logger_name, It begin, It end, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy) std::string logger_name, It begin, It end,
: logger(std::move(logger_name), begin, end) std::weak_ptr<details::thread_pool> tp,
, thread_pool_(std::move(tp)) async_overflow_policy overflow_policy)
, overflow_policy_(overflow_policy) : logger(std::move(logger_name), begin, end),
{ thread_pool_(std::move(tp)),
} overflow_policy_(overflow_policy) {}
inline spdlog::async_logger::async_logger( inline spdlog::async_logger::async_logger(
std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy) std::string logger_name, sinks_init_list sinks_list,
: async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(), std::move(tp), overflow_policy) std::weak_ptr<details::thread_pool> tp,
{ async_overflow_policy overflow_policy)
} : async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(),
std::move(tp), overflow_policy) {}
inline spdlog::async_logger::async_logger( inline spdlog::async_logger::async_logger(
std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy) std::string logger_name, sink_ptr single_sink,
: async_logger(std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy) std::weak_ptr<details::thread_pool> tp,
{ async_overflow_policy overflow_policy)
} : async_logger(std::move(logger_name), {std::move(single_sink)},
std::move(tp), overflow_policy) {}
// send the log message to the thread pool // send the log message to the thread pool
inline void spdlog::async_logger::sink_it_(details::log_msg &msg) inline void spdlog::async_logger::sink_it_(details::log_msg &msg) {
{
#if defined(SPDLOG_ENABLE_MESSAGE_COUNTER) #if defined(SPDLOG_ENABLE_MESSAGE_COUNTER)
incr_msg_counter_(msg); incr_msg_counter_(msg);
#endif #endif
if (auto pool_ptr = thread_pool_.lock()) if (auto pool_ptr = thread_pool_.lock()) {
{ pool_ptr->post_log(shared_from_this(), msg, overflow_policy_);
pool_ptr->post_log(shared_from_this(), msg, overflow_policy_); } else {
} throw spdlog_ex("async log: thread pool doesn't exist anymore");
else }
{
throw spdlog_ex("async log: thread pool doesn't exist anymore");
}
} }
// send flush request to the thread pool // send flush request to the thread pool
inline void spdlog::async_logger::flush_() inline void spdlog::async_logger::flush_() {
{ if (auto pool_ptr = thread_pool_.lock()) {
if (auto pool_ptr = thread_pool_.lock()) pool_ptr->post_flush(shared_from_this(), overflow_policy_);
{ } else {
pool_ptr->post_flush(shared_from_this(), overflow_policy_); throw spdlog_ex("async flush: thread pool doesn't exist anymore");
} }
else
{
throw spdlog_ex("async flush: thread pool doesn't exist anymore");
}
} }
// //
// backend functions - called from the thread pool to do the actual job // backend functions - called from the thread pool to do the actual job
// //
inline void spdlog::async_logger::backend_log_(const details::log_msg &incoming_log_msg) inline void spdlog::async_logger::backend_log_(
{ const details::log_msg &incoming_log_msg) {
try try {
{ for (auto &s : sinks_) {
for (auto &s : sinks_) if (s->should_log(incoming_log_msg.level)) {
{ s->log(incoming_log_msg);
if (s->should_log(incoming_log_msg.level)) }
{
s->log(incoming_log_msg);
}
}
} }
SPDLOG_CATCH_AND_HANDLE }
SPDLOG_CATCH_AND_HANDLE
if (should_flush_(incoming_log_msg)) if (should_flush_(incoming_log_msg)) {
{ backend_flush_();
backend_flush_(); }
}
} }
inline void spdlog::async_logger::backend_flush_() inline void spdlog::async_logger::backend_flush_() {
{ try {
try for (auto &sink : sinks_) {
{ sink->flush();
for (auto &sink : sinks_)
{
sink->flush();
}
} }
SPDLOG_CATCH_AND_HANDLE }
SPDLOG_CATCH_AND_HANDLE
} }
inline std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name) inline std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(
{ std::string new_name) {
auto cloned = std::make_shared<spdlog::async_logger>(std::move(new_name), sinks_.begin(), sinks_.end(), thread_pool_, overflow_policy_); auto cloned = std::make_shared<spdlog::async_logger>(
std::move(new_name), sinks_.begin(), sinks_.end(), thread_pool_,
overflow_policy_);
cloned->set_level(this->level()); cloned->set_level(this->level());
cloned->flush_on(this->flush_level()); cloned->flush_on(this->flush_level());
cloned->set_error_handler(this->error_handler()); cloned->set_error_handler(this->error_handler());
return std::move(cloned); return std::move(cloned);
} }

87
src/cpp/include/deps/spdlog/details/circular_q.h Executable file → Normal file
View File

@ -10,63 +10,52 @@
namespace spdlog { namespace spdlog {
namespace details { namespace details {
template<typename T> template <typename T>
class circular_q class circular_q {
{ public:
public: using item_type = T;
using item_type = T;
explicit circular_q(size_t max_items) explicit circular_q(size_t max_items)
: max_items_(max_items + 1) // one item is reserved as marker for full q : max_items_(max_items + 1) // one item is reserved as marker for full q
, v_(max_items_) ,
v_(max_items_) {}
// push back, overrun (oldest) item if no room left
void push_back(T &&item) {
v_[tail_] = std::move(item);
tail_ = (tail_ + 1) % max_items_;
if (tail_ == head_) // overrun last item if full
{ {
head_ = (head_ + 1) % max_items_;
++overrun_counter_;
} }
}
// push back, overrun (oldest) item if no room left // Pop item from front.
void push_back(T &&item) // If there are no elements in the container, the behavior is undefined.
{ void pop_front(T &popped_item) {
v_[tail_] = std::move(item); popped_item = std::move(v_[head_]);
tail_ = (tail_ + 1) % max_items_; head_ = (head_ + 1) % max_items_;
}
if (tail_ == head_) // overrun last item if full bool empty() { return tail_ == head_; }
{
head_ = (head_ + 1) % max_items_;
++overrun_counter_;
}
}
// Pop item from front. bool full() {
// If there are no elements in the container, the behavior is undefined. // head is ahead of the tail by 1
void pop_front(T &popped_item) return ((tail_ + 1) % max_items_) == head_;
{ }
popped_item = std::move(v_[head_]);
head_ = (head_ + 1) % max_items_;
}
bool empty() size_t overrun_counter() const { return overrun_counter_; }
{
return tail_ == head_;
}
bool full() private:
{ size_t max_items_;
// head is ahead of the tail by 1 typename std::vector<T>::size_type head_ = 0;
return ((tail_ + 1) % max_items_) == head_; typename std::vector<T>::size_type tail_ = 0;
}
size_t overrun_counter() const std::vector<T> v_;
{
return overrun_counter_;
}
private: size_t overrun_counter_ = 0;
size_t max_items_;
typename std::vector<T>::size_type head_ = 0;
typename std::vector<T>::size_type tail_ = 0;
std::vector<T> v_;
size_t overrun_counter_ = 0;
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

63
src/cpp/include/deps/spdlog/details/console_globals.h Executable file → Normal file
View File

@ -4,14 +4,15 @@
// Distributed under the MIT License (http://opensource.org/licenses/MIT) // Distributed under the MIT License (http://opensource.org/licenses/MIT)
// //
#include "spdlog/details/null_mutex.h"
#include <cstdio> #include <cstdio>
#include <mutex> #include <mutex>
#include "spdlog/details/null_mutex.h"
#ifdef _WIN32 #ifdef _WIN32
#ifndef NOMINMAX #ifndef NOMINMAX
#define NOMINMAX // prevent windows redefining min/max #define NOMINMAX // prevent windows redefining min/max
#endif #endif
#ifndef WIN32_LEAN_AND_MEAN #ifndef WIN32_LEAN_AND_MEAN
@ -23,52 +24,34 @@
namespace spdlog { namespace spdlog {
namespace details { namespace details {
struct console_stdout struct console_stdout {
{ static std::FILE *stream() { return stdout; }
static std::FILE *stream()
{
return stdout;
}
#ifdef _WIN32 #ifdef _WIN32
static HANDLE handle() static HANDLE handle() { return ::GetStdHandle(STD_OUTPUT_HANDLE); }
{
return ::GetStdHandle(STD_OUTPUT_HANDLE);
}
#endif #endif
}; };
struct console_stderr struct console_stderr {
{ static std::FILE *stream() { return stderr; }
static std::FILE *stream()
{
return stderr;
}
#ifdef _WIN32 #ifdef _WIN32
static HANDLE handle() static HANDLE handle() { return ::GetStdHandle(STD_ERROR_HANDLE); }
{
return ::GetStdHandle(STD_ERROR_HANDLE);
}
#endif #endif
}; };
struct console_mutex struct console_mutex {
{ using mutex_t = std::mutex;
using mutex_t = std::mutex; static mutex_t &mutex() {
static mutex_t &mutex() static mutex_t s_mutex;
{ return s_mutex;
static mutex_t s_mutex; }
return s_mutex;
}
}; };
struct console_nullmutex struct console_nullmutex {
{ using mutex_t = null_mutex;
using mutex_t = null_mutex; static mutex_t &mutex() {
static mutex_t &mutex() static mutex_t s_mutex;
{ return s_mutex;
static mutex_t s_mutex; }
return s_mutex;
}
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

218
src/cpp/include/deps/spdlog/details/file_helper.h Executable file → Normal file
View File

@ -6,11 +6,8 @@
#pragma once #pragma once
// Helper class for file sinks. // Helper class for file sinks.
// When failing to open a file, retry several times(5) with a delay interval(10 ms). // When failing to open a file, retry several times(5) with a delay interval(10
// Throw spdlog_ex exception on errors. // ms). Throw spdlog_ex exception on errors.
#include "spdlog/details/log_msg.h"
#include "spdlog/details/os.h"
#include <cerrno> #include <cerrno>
#include <chrono> #include <chrono>
@ -19,134 +16,117 @@
#include <thread> #include <thread>
#include <tuple> #include <tuple>
#include "spdlog/details/log_msg.h"
#include "spdlog/details/os.h"
namespace spdlog { namespace spdlog {
namespace details { namespace details {
class file_helper class file_helper {
{ public:
const int open_tries = 5;
const int open_interval = 10;
public: explicit file_helper() = default;
const int open_tries = 5;
const int open_interval = 10;
explicit file_helper() = default; file_helper(const file_helper &) = delete;
file_helper &operator=(const file_helper &) = delete;
file_helper(const file_helper &) = delete; ~file_helper() { close(); }
file_helper &operator=(const file_helper &) = delete;
~file_helper() void open(const filename_t &fname, bool truncate = false) {
{ close();
close(); auto *mode = truncate ? SPDLOG_FILENAME_T("wb") : SPDLOG_FILENAME_T("ab");
_filename = fname;
for (int tries = 0; tries < open_tries; ++tries) {
if (!os::fopen_s(&fd_, fname, mode)) {
return;
}
details::os::sleep_for_millis(open_interval);
} }
void open(const filename_t &fname, bool truncate = false) throw spdlog_ex("Failed opening file " + os::filename_to_str(_filename) +
{ " for writing",
close(); errno);
auto *mode = truncate ? SPDLOG_FILENAME_T("wb") : SPDLOG_FILENAME_T("ab"); }
_filename = fname;
for (int tries = 0; tries < open_tries; ++tries)
{
if (!os::fopen_s(&fd_, fname, mode))
{
return;
}
details::os::sleep_for_millis(open_interval); void reopen(bool truncate) {
} if (_filename.empty()) {
throw spdlog_ex("Failed re opening file - was not opened before");
}
open(_filename, truncate);
}
throw spdlog_ex("Failed opening file " + os::filename_to_str(_filename) + " for writing", errno); void flush() { std::fflush(fd_); }
void close() {
if (fd_ != nullptr) {
std::fclose(fd_);
fd_ = nullptr;
}
}
void write(const fmt::memory_buffer &buf) {
size_t msg_size = buf.size();
auto data = buf.data();
if (std::fwrite(data, 1, msg_size, fd_) != msg_size) {
throw spdlog_ex(
"Failed writing to file " + os::filename_to_str(_filename), errno);
}
}
size_t size() const {
if (fd_ == nullptr) {
throw spdlog_ex("Cannot use size() on closed file " +
os::filename_to_str(_filename));
}
return os::filesize(fd_);
}
const filename_t &filename() const { return _filename; }
static bool file_exists(const filename_t &fname) {
return os::file_exists(fname);
}
//
// return file path and its extension:
//
// "mylog.txt" => ("mylog", ".txt")
// "mylog" => ("mylog", "")
// "mylog." => ("mylog.", "")
// "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt")
//
// the starting dot in filenames is ignored (hidden files):
//
// ".mylog" => (".mylog". "")
// "my_folder/.mylog" => ("my_folder/.mylog", "")
// "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt")
static std::tuple<filename_t, filename_t> split_by_extension(
const spdlog::filename_t &fname) {
auto ext_index = fname.rfind('.');
// no valid extension found - return whole path and empty string as
// extension
if (ext_index == filename_t::npos || ext_index == 0 ||
ext_index == fname.size() - 1) {
return std::make_tuple(fname, spdlog::filename_t());
} }
void reopen(bool truncate) // treat casese like "/etc/rc.d/somelogfile or "/abc/.hiddenfile"
{ auto folder_index = fname.rfind(details::os::folder_sep);
if (_filename.empty()) if (folder_index != filename_t::npos && folder_index >= ext_index - 1) {
{ return std::make_tuple(fname, spdlog::filename_t());
throw spdlog_ex("Failed re opening file - was not opened before");
}
open(_filename, truncate);
} }
void flush() // finally - return a valid base and extension tuple
{ return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index));
std::fflush(fd_); }
}
void close() private:
{ std::FILE *fd_{nullptr};
if (fd_ != nullptr) filename_t _filename;
{
std::fclose(fd_);
fd_ = nullptr;
}
}
void write(const fmt::memory_buffer &buf)
{
size_t msg_size = buf.size();
auto data = buf.data();
if (std::fwrite(data, 1, msg_size, fd_) != msg_size)
{
throw spdlog_ex("Failed writing to file " + os::filename_to_str(_filename), errno);
}
}
size_t size() const
{
if (fd_ == nullptr)
{
throw spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(_filename));
}
return os::filesize(fd_);
}
const filename_t &filename() const
{
return _filename;
}
static bool file_exists(const filename_t &fname)
{
return os::file_exists(fname);
}
//
// return file path and its extension:
//
// "mylog.txt" => ("mylog", ".txt")
// "mylog" => ("mylog", "")
// "mylog." => ("mylog.", "")
// "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt")
//
// the starting dot in filenames is ignored (hidden files):
//
// ".mylog" => (".mylog". "")
// "my_folder/.mylog" => ("my_folder/.mylog", "")
// "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt")
static std::tuple<filename_t, filename_t> split_by_extension(const spdlog::filename_t &fname)
{
auto ext_index = fname.rfind('.');
// no valid extension found - return whole path and empty string as
// extension
if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1)
{
return std::make_tuple(fname, spdlog::filename_t());
}
// treat casese like "/etc/rc.d/somelogfile or "/abc/.hiddenfile"
auto folder_index = fname.rfind(details::os::folder_sep);
if (folder_index != filename_t::npos && folder_index >= ext_index - 1)
{
return std::make_tuple(fname, spdlog::filename_t());
}
// finally - return a valid base and extension tuple
return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index));
}
private:
std::FILE *fd_{nullptr};
filename_t _filename;
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

157
src/cpp/include/deps/spdlog/details/fmt_helper.h Executable file → Normal file
View File

@ -6,6 +6,7 @@
#include <chrono> #include <chrono>
#include <type_traits> #include <type_traits>
#include "spdlog/fmt/fmt.h" #include "spdlog/fmt/fmt.h"
// Some fmt helpers to efficiently format and pad ints and strings // Some fmt helpers to efficiently format and pad ints and strings
@ -13,110 +14,100 @@ namespace spdlog {
namespace details { namespace details {
namespace fmt_helper { namespace fmt_helper {
template<size_t Buffer_Size> template <size_t Buffer_Size>
inline spdlog::string_view_t to_string_view(const fmt::basic_memory_buffer<char, Buffer_Size> &buf) SPDLOG_NOEXCEPT inline spdlog::string_view_t to_string_view(
{ const fmt::basic_memory_buffer<char, Buffer_Size> &buf) SPDLOG_NOEXCEPT {
return spdlog::string_view_t(buf.data(), buf.size()); return spdlog::string_view_t(buf.data(), buf.size());
} }
template<size_t Buffer_Size1, size_t Buffer_Size2> template <size_t Buffer_Size1, size_t Buffer_Size2>
inline void append_buf(const fmt::basic_memory_buffer<char, Buffer_Size1> &buf, fmt::basic_memory_buffer<char, Buffer_Size2> &dest) inline void append_buf(const fmt::basic_memory_buffer<char, Buffer_Size1> &buf,
{ fmt::basic_memory_buffer<char, Buffer_Size2> &dest) {
auto *buf_ptr = buf.data(); auto *buf_ptr = buf.data();
dest.append(buf_ptr, buf_ptr + buf.size()); dest.append(buf_ptr, buf_ptr + buf.size());
} }
template<size_t Buffer_Size> template <size_t Buffer_Size>
inline void append_string_view(spdlog::string_view_t view, fmt::basic_memory_buffer<char, Buffer_Size> &dest) inline void append_string_view(
{ spdlog::string_view_t view,
auto *buf_ptr = view.data(); fmt::basic_memory_buffer<char, Buffer_Size> &dest) {
if (buf_ptr != nullptr) auto *buf_ptr = view.data();
{ if (buf_ptr != nullptr) {
dest.append(buf_ptr, buf_ptr + view.size()); dest.append(buf_ptr, buf_ptr + view.size());
} }
} }
template<typename T, size_t Buffer_Size> template <typename T, size_t Buffer_Size>
inline void append_int(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest) inline void append_int(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest) {
{ fmt::format_int i(n);
fmt::format_int i(n); dest.append(i.data(), i.data() + i.size());
dest.append(i.data(), i.data() + i.size());
} }
template<typename T> template <typename T>
inline unsigned count_digits(T n) inline unsigned count_digits(T n) {
{ using count_type = typename std::conditional<(sizeof(T) > sizeof(uint32_t)),
using count_type = typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type; uint64_t, uint32_t>::type;
return static_cast<unsigned>(fmt::internal::count_digits(static_cast<count_type>(n))); return static_cast<unsigned>(
fmt::internal::count_digits(static_cast<count_type>(n)));
} }
template<size_t Buffer_Size> template <size_t Buffer_Size>
inline void pad2(int n, fmt::basic_memory_buffer<char, Buffer_Size> &dest) inline void pad2(int n, fmt::basic_memory_buffer<char, Buffer_Size> &dest) {
{ if (n > 99) {
if (n > 99)
{
append_int(n, dest);
}
else if (n > 9) // 10-99
{
dest.push_back(static_cast<char>('0' + n / 10));
dest.push_back(static_cast<char>('0' + n % 10));
}
else if (n >= 0) // 0-9
{
dest.push_back('0');
dest.push_back(static_cast<char>('0' + n));
}
else // negatives (unlikely, but just in case, let fmt deal with it)
{
fmt::format_to(dest, "{:02}", n);
}
}
template<typename T, size_t Buffer_Size>
inline void pad_uint(T n, unsigned int width, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
{
static_assert(std::is_unsigned<T>::value, "pad_uint must get unsigned T");
auto digits = count_digits(n);
if (width > digits)
{
const char *zeroes = "0000000000000000000";
dest.append(zeroes, zeroes + width - digits);
}
append_int(n, dest); append_int(n, dest);
} else if (n > 9) // 10-99
{
dest.push_back(static_cast<char>('0' + n / 10));
dest.push_back(static_cast<char>('0' + n % 10));
} else if (n >= 0) // 0-9
{
dest.push_back('0');
dest.push_back(static_cast<char>('0' + n));
} else // negatives (unlikely, but just in case, let fmt deal with it)
{
fmt::format_to(dest, "{:02}", n);
}
} }
template<typename T, size_t Buffer_Size> template <typename T, size_t Buffer_Size>
inline void pad3(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest) inline void pad_uint(T n, unsigned int width,
{ fmt::basic_memory_buffer<char, Buffer_Size> &dest) {
pad_uint(n, 3, dest); static_assert(std::is_unsigned<T>::value, "pad_uint must get unsigned T");
auto digits = count_digits(n);
if (width > digits) {
const char *zeroes = "0000000000000000000";
dest.append(zeroes, zeroes + width - digits);
}
append_int(n, dest);
} }
template<typename T, size_t Buffer_Size> template <typename T, size_t Buffer_Size>
inline void pad6(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest) inline void pad3(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest) {
{ pad_uint(n, 3, dest);
pad_uint(n, 6, dest);
} }
template<typename T, size_t Buffer_Size> template <typename T, size_t Buffer_Size>
inline void pad9(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest) inline void pad6(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest) {
{ pad_uint(n, 6, dest);
pad_uint(n, 9, dest); }
template <typename T, size_t Buffer_Size>
inline void pad9(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest) {
pad_uint(n, 9, dest);
} }
// return fraction of a second of the given time_point. // return fraction of a second of the given time_point.
// e.g. // e.g.
// fraction<std::milliseconds>(tp) -> will return the millis part of the second // fraction<std::milliseconds>(tp) -> will return the millis part of the second
template<typename ToDuration> template <typename ToDuration>
inline ToDuration time_fraction(const log_clock::time_point &tp) inline ToDuration time_fraction(const log_clock::time_point &tp) {
{ using std::chrono::duration_cast;
using std::chrono::duration_cast; using std::chrono::seconds;
using std::chrono::seconds; auto duration = tp.time_since_epoch();
auto duration = tp.time_since_epoch(); auto secs = duration_cast<seconds>(duration);
auto secs = duration_cast<seconds>(duration); return duration_cast<ToDuration>(duration) - duration_cast<ToDuration>(secs);
return duration_cast<ToDuration>(duration) - duration_cast<ToDuration>(secs);
} }
} // namespace fmt_helper } // namespace fmt_helper
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

64
src/cpp/include/deps/spdlog/details/log_msg.h Executable file → Normal file
View File

@ -5,51 +5,51 @@
#pragma once #pragma once
#include "spdlog/common.h"
#include "spdlog/details/os.h"
#include <string> #include <string>
#include <utility> #include <utility>
#include "spdlog/common.h"
#include "spdlog/details/os.h"
namespace spdlog { namespace spdlog {
namespace details { namespace details {
struct log_msg struct log_msg {
{ log_msg(source_loc loc, const std::string *loggers_name,
level::level_enum lvl, string_view_t view)
log_msg(source_loc loc, const std::string *loggers_name, level::level_enum lvl, string_view_t view) : logger_name(loggers_name),
: logger_name(loggers_name) level(lvl)
, level(lvl)
#ifndef SPDLOG_NO_DATETIME #ifndef SPDLOG_NO_DATETIME
, time(os::now()) ,
time(os::now())
#endif #endif
#ifndef SPDLOG_NO_THREAD_ID #ifndef SPDLOG_NO_THREAD_ID
, thread_id(os::thread_id()) ,
thread_id(os::thread_id())
#endif #endif
, source(loc) ,
, payload(view) source(loc),
{ payload(view) {
} }
log_msg(const std::string *loggers_name, level::level_enum lvl, string_view_t view) log_msg(const std::string *loggers_name, level::level_enum lvl,
: log_msg(source_loc{}, loggers_name, lvl, view) string_view_t view)
{ : log_msg(source_loc{}, loggers_name, lvl, view) {}
}
log_msg(const log_msg &other) = default; log_msg(const log_msg &other) = default;
const std::string *logger_name{nullptr}; const std::string *logger_name{nullptr};
level::level_enum level{level::off}; level::level_enum level{level::off};
log_clock::time_point time; log_clock::time_point time;
size_t thread_id{0}; size_t thread_id{0};
size_t msg_id{0}; size_t msg_id{0};
// wrapping the formatted text with color (updated by pattern_formatter). // wrapping the formatted text with color (updated by pattern_formatter).
mutable size_t color_range_start{0}; mutable size_t color_range_start{0};
mutable size_t color_range_end{0}; mutable size_t color_range_end{0};
source_loc source; source_loc source;
const string_view_t payload; const string_view_t payload;
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

562
src/cpp/include/deps/spdlog/details/logger_impl.h Executable file → Normal file
View File

@ -5,437 +5,385 @@
#pragma once #pragma once
#include "spdlog/details/fmt_helper.h"
#include <memory> #include <memory>
#include <string> #include <string>
#define SPDLOG_CATCH_AND_HANDLE \ #include "spdlog/details/fmt_helper.h"
catch (const std::exception &ex) \
{ \ #define SPDLOG_CATCH_AND_HANDLE \
err_handler_(ex.what()); \ catch (const std::exception &ex) { \
} \ err_handler_(ex.what()); \
catch (...) \ } \
{ \ catch (...) { \
err_handler_("Unknown exception in logger"); \ err_handler_("Unknown exception in logger"); \
} }
// create logger with given name, sinks and the default pattern formatter // create logger with given name, sinks and the default pattern formatter
// all other ctors will call this one // all other ctors will call this one
template<typename It> template <typename It>
inline spdlog::logger::logger(std::string logger_name, It begin, It end) inline spdlog::logger::logger(std::string logger_name, It begin, It end)
: name_(std::move(logger_name)) : name_(std::move(logger_name)), sinks_(begin, end) {}
, sinks_(begin, end)
{
}
// ctor with sinks as init list // ctor with sinks as init list
inline spdlog::logger::logger(std::string logger_name, sinks_init_list sinks_list) inline spdlog::logger::logger(std::string logger_name,
: logger(std::move(logger_name), sinks_list.begin(), sinks_list.end()) sinks_init_list sinks_list)
{ : logger(std::move(logger_name), sinks_list.begin(), sinks_list.end()) {}
}
// ctor with single sink // ctor with single sink
inline spdlog::logger::logger(std::string logger_name, spdlog::sink_ptr single_sink) inline spdlog::logger::logger(std::string logger_name,
: logger(std::move(logger_name), {std::move(single_sink)}) spdlog::sink_ptr single_sink)
{ : logger(std::move(logger_name), {std::move(single_sink)}) {}
}
inline spdlog::logger::~logger() = default; inline spdlog::logger::~logger() = default;
inline void spdlog::logger::set_formatter(std::unique_ptr<spdlog::formatter> f) inline void spdlog::logger::set_formatter(
{ std::unique_ptr<spdlog::formatter> f) {
for (auto &sink : sinks_) for (auto &sink : sinks_) {
{ sink->set_formatter(f->clone());
sink->set_formatter(f->clone()); }
}
} }
inline void spdlog::logger::set_pattern(std::string pattern, pattern_time_type time_type) inline void spdlog::logger::set_pattern(std::string pattern,
{ pattern_time_type time_type) {
auto new_formatter = details::make_unique<spdlog::pattern_formatter>(std::move(pattern), time_type); auto new_formatter = details::make_unique<spdlog::pattern_formatter>(
set_formatter(std::move(new_formatter)); std::move(pattern), time_type);
set_formatter(std::move(new_formatter));
} }
template<typename... Args> template <typename... Args>
inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const char *fmt, const Args &... args) inline void spdlog::logger::log(source_loc source, level::level_enum lvl,
{ const char *fmt, const Args &... args) {
if (!should_log(lvl)) if (!should_log(lvl)) {
{ return;
return; }
}
try try {
{ using details::fmt_helper::to_string_view;
using details::fmt_helper::to_string_view; fmt::memory_buffer buf;
fmt::memory_buffer buf; fmt::format_to(buf, fmt, args...);
fmt::format_to(buf, fmt, args...); details::log_msg log_msg(source, &name_, lvl, to_string_view(buf));
details::log_msg log_msg(source, &name_, lvl, to_string_view(buf)); sink_it_(log_msg);
sink_it_(log_msg); }
} SPDLOG_CATCH_AND_HANDLE
SPDLOG_CATCH_AND_HANDLE
} }
template<typename... Args> template <typename... Args>
inline void spdlog::logger::log(level::level_enum lvl, const char *fmt, const Args &... args) inline void spdlog::logger::log(level::level_enum lvl, const char *fmt,
{ const Args &... args) {
log(source_loc{}, lvl, fmt, args...); log(source_loc{}, lvl, fmt, args...);
} }
inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const char *msg) inline void spdlog::logger::log(source_loc source, level::level_enum lvl,
{ const char *msg) {
if (!should_log(lvl)) if (!should_log(lvl)) {
{ return;
return; }
}
try try {
{ details::log_msg log_msg(source, &name_, lvl, spdlog::string_view_t(msg));
details::log_msg log_msg(source, &name_, lvl, spdlog::string_view_t(msg)); sink_it_(log_msg);
sink_it_(log_msg); }
} SPDLOG_CATCH_AND_HANDLE
SPDLOG_CATCH_AND_HANDLE
} }
inline void spdlog::logger::log(level::level_enum lvl, const char *msg) inline void spdlog::logger::log(level::level_enum lvl, const char *msg) {
{ log(source_loc{}, lvl, msg);
log(source_loc{}, lvl, msg);
} }
template<class T, typename std::enable_if<std::is_convertible<T, spdlog::string_view_t>::value, T>::type *> template <class T,
inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const T &msg) typename std::enable_if<
{ std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
if (!should_log(lvl)) inline void spdlog::logger::log(source_loc source, level::level_enum lvl,
{ const T &msg) {
return; if (!should_log(lvl)) {
} return;
try }
{ try {
details::log_msg log_msg(source, &name_, lvl, msg); details::log_msg log_msg(source, &name_, lvl, msg);
sink_it_(log_msg); sink_it_(log_msg);
} }
SPDLOG_CATCH_AND_HANDLE SPDLOG_CATCH_AND_HANDLE
} }
template<class T, typename std::enable_if<std::is_convertible<T, spdlog::string_view_t>::value, T>::type *> template <class T,
inline void spdlog::logger::log(level::level_enum lvl, const T &msg) typename std::enable_if<
{ std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
log(source_loc{}, lvl, msg); inline void spdlog::logger::log(level::level_enum lvl, const T &msg) {
log(source_loc{}, lvl, msg);
} }
template<class T, typename std::enable_if<!std::is_convertible<T, spdlog::string_view_t>::value, T>::type *> template <class T,
inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const T &msg) typename std::enable_if<
{ !std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
if (!should_log(lvl)) inline void spdlog::logger::log(source_loc source, level::level_enum lvl,
{ const T &msg) {
return; if (!should_log(lvl)) {
} return;
try }
{ try {
using details::fmt_helper::to_string_view; using details::fmt_helper::to_string_view;
fmt::memory_buffer buf; fmt::memory_buffer buf;
fmt::format_to(buf, "{}", msg); fmt::format_to(buf, "{}", msg);
details::log_msg log_msg(source, &name_, lvl, to_string_view(buf)); details::log_msg log_msg(source, &name_, lvl, to_string_view(buf));
sink_it_(log_msg); sink_it_(log_msg);
} }
SPDLOG_CATCH_AND_HANDLE SPDLOG_CATCH_AND_HANDLE
} }
template<class T, typename std::enable_if<!std::is_convertible<T, spdlog::string_view_t>::value, T>::type *> template <class T,
inline void spdlog::logger::log(level::level_enum lvl, const T &msg) typename std::enable_if<
{ !std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
log(source_loc{}, lvl, msg); inline void spdlog::logger::log(level::level_enum lvl, const T &msg) {
log(source_loc{}, lvl, msg);
} }
template<typename... Args> template <typename... Args>
inline void spdlog::logger::trace(const char *fmt, const Args &... args) inline void spdlog::logger::trace(const char *fmt, const Args &... args) {
{ log(level::trace, fmt, args...);
log(level::trace, fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void spdlog::logger::debug(const char *fmt, const Args &... args) inline void spdlog::logger::debug(const char *fmt, const Args &... args) {
{ log(level::debug, fmt, args...);
log(level::debug, fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void spdlog::logger::info(const char *fmt, const Args &... args) inline void spdlog::logger::info(const char *fmt, const Args &... args) {
{ log(level::info, fmt, args...);
log(level::info, fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void spdlog::logger::warn(const char *fmt, const Args &... args) inline void spdlog::logger::warn(const char *fmt, const Args &... args) {
{ log(level::warn, fmt, args...);
log(level::warn, fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void spdlog::logger::error(const char *fmt, const Args &... args) inline void spdlog::logger::error(const char *fmt, const Args &... args) {
{ log(level::err, fmt, args...);
log(level::err, fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void spdlog::logger::critical(const char *fmt, const Args &... args) inline void spdlog::logger::critical(const char *fmt, const Args &... args) {
{ log(level::critical, fmt, args...);
log(level::critical, fmt, args...);
} }
template<typename T> template <typename T>
inline void spdlog::logger::trace(const T &msg) inline void spdlog::logger::trace(const T &msg) {
{ log(level::trace, msg);
log(level::trace, msg);
} }
template<typename T> template <typename T>
inline void spdlog::logger::debug(const T &msg) inline void spdlog::logger::debug(const T &msg) {
{ log(level::debug, msg);
log(level::debug, msg);
} }
template<typename T> template <typename T>
inline void spdlog::logger::info(const T &msg) inline void spdlog::logger::info(const T &msg) {
{ log(level::info, msg);
log(level::info, msg);
} }
template<typename T> template <typename T>
inline void spdlog::logger::warn(const T &msg) inline void spdlog::logger::warn(const T &msg) {
{ log(level::warn, msg);
log(level::warn, msg);
} }
template<typename T> template <typename T>
inline void spdlog::logger::error(const T &msg) inline void spdlog::logger::error(const T &msg) {
{ log(level::err, msg);
log(level::err, msg);
} }
template<typename T> template <typename T>
inline void spdlog::logger::critical(const T &msg) inline void spdlog::logger::critical(const T &msg) {
{ log(level::critical, msg);
log(level::critical, msg);
} }
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
inline void wbuf_to_utf8buf(const fmt::wmemory_buffer &wbuf, fmt::memory_buffer &target) inline void wbuf_to_utf8buf(const fmt::wmemory_buffer &wbuf,
{ fmt::memory_buffer &target) {
int wbuf_size = static_cast<int>(wbuf.size()); int wbuf_size = static_cast<int>(wbuf.size());
if (wbuf_size == 0) if (wbuf_size == 0) {
{ return;
return; }
}
auto result_size = ::WideCharToMultiByte(CP_UTF8, 0, wbuf.data(), wbuf_size, NULL, 0, NULL, NULL); auto result_size = ::WideCharToMultiByte(CP_UTF8, 0, wbuf.data(), wbuf_size,
NULL, 0, NULL, NULL);
if (result_size > 0) if (result_size > 0) {
{ target.resize(result_size);
target.resize(result_size); ::WideCharToMultiByte(CP_UTF8, 0, wbuf.data(), wbuf_size, &target.data()[0],
::WideCharToMultiByte(CP_UTF8, 0, wbuf.data(), wbuf_size, &target.data()[0], result_size, NULL, NULL); result_size, NULL, NULL);
} } else {
else throw spdlog::spdlog_ex(fmt::format(
{ "WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
throw spdlog::spdlog_ex(fmt::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError())); }
}
} }
template<typename... Args> template <typename... Args>
inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const wchar_t *fmt, const Args &... args) inline void spdlog::logger::log(source_loc source, level::level_enum lvl,
{ const wchar_t *fmt, const Args &... args) {
if (!should_log(lvl)) if (!should_log(lvl)) {
{ return;
return; }
}
try try {
{ // format to wmemory_buffer and convert to utf8
// format to wmemory_buffer and convert to utf8 using details::fmt_helper::to_string_view;
using details::fmt_helper::to_string_view; fmt::wmemory_buffer wbuf;
fmt::wmemory_buffer wbuf; fmt::format_to(wbuf, fmt, args...);
fmt::format_to(wbuf, fmt, args...); fmt::memory_buffer buf;
fmt::memory_buffer buf; wbuf_to_utf8buf(wbuf, buf);
wbuf_to_utf8buf(wbuf, buf); details::log_msg log_msg(source, &name_, lvl, to_string_view(buf));
details::log_msg log_msg(source, &name_, lvl, to_string_view(buf)); sink_it_(log_msg);
sink_it_(log_msg); }
} SPDLOG_CATCH_AND_HANDLE
SPDLOG_CATCH_AND_HANDLE
} }
template<typename... Args> template <typename... Args>
inline void spdlog::logger::log(level::level_enum lvl, const wchar_t *fmt, const Args &... args) inline void spdlog::logger::log(level::level_enum lvl, const wchar_t *fmt,
{ const Args &... args) {
log(source_loc{}, lvl, fmt, args...); log(source_loc{}, lvl, fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void spdlog::logger::trace(const wchar_t *fmt, const Args &... args) inline void spdlog::logger::trace(const wchar_t *fmt, const Args &... args) {
{ log(level::trace, fmt, args...);
log(level::trace, fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void spdlog::logger::debug(const wchar_t *fmt, const Args &... args) inline void spdlog::logger::debug(const wchar_t *fmt, const Args &... args) {
{ log(level::debug, fmt, args...);
log(level::debug, fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void spdlog::logger::info(const wchar_t *fmt, const Args &... args) inline void spdlog::logger::info(const wchar_t *fmt, const Args &... args) {
{ log(level::info, fmt, args...);
log(level::info, fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void spdlog::logger::warn(const wchar_t *fmt, const Args &... args) inline void spdlog::logger::warn(const wchar_t *fmt, const Args &... args) {
{ log(level::warn, fmt, args...);
log(level::warn, fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void spdlog::logger::error(const wchar_t *fmt, const Args &... args) inline void spdlog::logger::error(const wchar_t *fmt, const Args &... args) {
{ log(level::err, fmt, args...);
log(level::err, fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void spdlog::logger::critical(const wchar_t *fmt, const Args &... args) inline void spdlog::logger::critical(const wchar_t *fmt, const Args &... args) {
{ log(level::critical, fmt, args...);
log(level::critical, fmt, args...);
} }
#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT #endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
// //
// name and level // name and level
// //
inline const std::string &spdlog::logger::name() const inline const std::string &spdlog::logger::name() const { return name_; }
{
return name_; inline void spdlog::logger::set_level(spdlog::level::level_enum log_level) {
level_.store(log_level);
} }
inline void spdlog::logger::set_level(spdlog::level::level_enum log_level) inline void spdlog::logger::set_error_handler(
{ spdlog::log_err_handler err_handler) {
level_.store(log_level); err_handler_ = std::move(err_handler);
} }
inline void spdlog::logger::set_error_handler(spdlog::log_err_handler err_handler) inline spdlog::log_err_handler spdlog::logger::error_handler() const {
{ return err_handler_;
err_handler_ = std::move(err_handler);
} }
inline spdlog::log_err_handler spdlog::logger::error_handler() const inline void spdlog::logger::flush() {
{ try {
return err_handler_; flush_();
}
SPDLOG_CATCH_AND_HANDLE
} }
inline void spdlog::logger::flush() inline void spdlog::logger::flush_on(level::level_enum log_level) {
{ flush_level_.store(log_level);
try
{
flush_();
}
SPDLOG_CATCH_AND_HANDLE
} }
inline void spdlog::logger::flush_on(level::level_enum log_level) inline spdlog::level::level_enum spdlog::logger::flush_level() const {
{ return static_cast<spdlog::level::level_enum>(
flush_level_.store(log_level); flush_level_.load(std::memory_order_relaxed));
} }
inline spdlog::level::level_enum spdlog::logger::flush_level() const inline bool spdlog::logger::should_flush_(const details::log_msg &msg) {
{ auto flush_level = flush_level_.load(std::memory_order_relaxed);
return static_cast<spdlog::level::level_enum>(flush_level_.load(std::memory_order_relaxed)); return (msg.level >= flush_level) && (msg.level != level::off);
} }
inline bool spdlog::logger::should_flush_(const details::log_msg &msg) inline spdlog::level::level_enum spdlog::logger::default_level() {
{ return static_cast<spdlog::level::level_enum>(SPDLOG_ACTIVE_LEVEL);
auto flush_level = flush_level_.load(std::memory_order_relaxed);
return (msg.level >= flush_level) && (msg.level != level::off);
} }
inline spdlog::level::level_enum spdlog::logger::default_level() inline spdlog::level::level_enum spdlog::logger::level() const {
{ return static_cast<spdlog::level::level_enum>(
return static_cast<spdlog::level::level_enum>(SPDLOG_ACTIVE_LEVEL); level_.load(std::memory_order_relaxed));
} }
inline spdlog::level::level_enum spdlog::logger::level() const inline bool spdlog::logger::should_log(
{ spdlog::level::level_enum msg_level) const {
return static_cast<spdlog::level::level_enum>(level_.load(std::memory_order_relaxed)); return msg_level >= level_.load(std::memory_order_relaxed);
}
inline bool spdlog::logger::should_log(spdlog::level::level_enum msg_level) const
{
return msg_level >= level_.load(std::memory_order_relaxed);
} }
// //
// protected virtual called at end of each user log call (if enabled) by the // protected virtual called at end of each user log call (if enabled) by the
// line_logger // line_logger
// //
inline void spdlog::logger::sink_it_(details::log_msg &msg) inline void spdlog::logger::sink_it_(details::log_msg &msg) {
{
#if defined(SPDLOG_ENABLE_MESSAGE_COUNTER) #if defined(SPDLOG_ENABLE_MESSAGE_COUNTER)
incr_msg_counter_(msg); incr_msg_counter_(msg);
#endif #endif
for (auto &sink : sinks_) for (auto &sink : sinks_) {
{ if (sink->should_log(msg.level)) {
if (sink->should_log(msg.level)) sink->log(msg);
{
sink->log(msg);
}
} }
}
if (should_flush_(msg)) if (should_flush_(msg)) {
{ flush_();
flush_(); }
}
} }
inline void spdlog::logger::flush_() inline void spdlog::logger::flush_() {
{ for (auto &sink : sinks_) {
for (auto &sink : sinks_) sink->flush();
{ }
sink->flush();
}
} }
inline void spdlog::logger::default_err_handler_(const std::string &msg) inline void spdlog::logger::default_err_handler_(const std::string &msg) {
{ auto now = time(nullptr);
auto now = time(nullptr); if (now - last_err_time_ < 60) {
if (now - last_err_time_ < 60) return;
{ }
return; last_err_time_ = now;
} auto tm_time = details::os::localtime(now);
last_err_time_ = now; char date_buf[100];
auto tm_time = details::os::localtime(now); std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time);
char date_buf[100]; fmt::print(stderr, "[*** LOG ERROR ***] [{}] [{}] {}\n", date_buf, name(),
std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time); msg);
fmt::print(stderr, "[*** LOG ERROR ***] [{}] [{}] {}\n", date_buf, name(), msg);
} }
inline void spdlog::logger::incr_msg_counter_(details::log_msg &msg) inline void spdlog::logger::incr_msg_counter_(details::log_msg &msg) {
{ msg.msg_id = msg_counter_.fetch_add(1, std::memory_order_relaxed);
msg.msg_id = msg_counter_.fetch_add(1, std::memory_order_relaxed);
} }
inline const std::vector<spdlog::sink_ptr> &spdlog::logger::sinks() const inline const std::vector<spdlog::sink_ptr> &spdlog::logger::sinks() const {
{ return sinks_;
return sinks_;
} }
inline std::vector<spdlog::sink_ptr> &spdlog::logger::sinks() inline std::vector<spdlog::sink_ptr> &spdlog::logger::sinks() { return sinks_; }
{
return sinks_;
}
inline std::shared_ptr<spdlog::logger> spdlog::logger::clone(std::string logger_name) inline std::shared_ptr<spdlog::logger> spdlog::logger::clone(
{ std::string logger_name) {
auto cloned = std::make_shared<spdlog::logger>(std::move(logger_name), sinks_.begin(), sinks_.end()); auto cloned = std::make_shared<spdlog::logger>(std::move(logger_name),
cloned->set_level(this->level()); sinks_.begin(), sinks_.end());
cloned->flush_on(this->flush_level()); cloned->set_level(this->level());
cloned->set_error_handler(this->error_handler()); cloned->flush_on(this->flush_level());
return cloned; cloned->set_error_handler(this->error_handler());
return cloned;
} }

149
src/cpp/include/deps/spdlog/details/mpmc_blocking_q.h Executable file → Normal file
View File

@ -12,110 +12,99 @@
// dequeue_for(..) - will block until the queue is not empty or timeout have // dequeue_for(..) - will block until the queue is not empty or timeout have
// passed. // passed.
#include "spdlog/details/circular_q.h"
#include <condition_variable> #include <condition_variable>
#include <mutex> #include <mutex>
#include "spdlog/details/circular_q.h"
namespace spdlog { namespace spdlog {
namespace details { namespace details {
template<typename T> template <typename T>
class mpmc_blocking_queue class mpmc_blocking_queue {
{ public:
public: using item_type = T;
using item_type = T; explicit mpmc_blocking_queue(size_t max_items) : q_(max_items) {}
explicit mpmc_blocking_queue(size_t max_items)
: q_(max_items)
{
}
#ifndef __MINGW32__ #ifndef __MINGW32__
// try to enqueue and block if no room left // try to enqueue and block if no room left
void enqueue(T &&item) void enqueue(T &&item) {
{ {
{ std::unique_lock<std::mutex> lock(queue_mutex_);
std::unique_lock<std::mutex> lock(queue_mutex_); pop_cv_.wait(lock, [this] { return !this->q_.full(); });
pop_cv_.wait(lock, [this] { return !this->q_.full(); }); q_.push_back(std::move(item));
q_.push_back(std::move(item));
}
push_cv_.notify_one();
} }
push_cv_.notify_one();
}
// enqueue immediately. overrun oldest message in the queue if no room left. // enqueue immediately. overrun oldest message in the queue if no room left.
void enqueue_nowait(T &&item) void enqueue_nowait(T &&item) {
{ {
{ std::unique_lock<std::mutex> lock(queue_mutex_);
std::unique_lock<std::mutex> lock(queue_mutex_); q_.push_back(std::move(item));
q_.push_back(std::move(item));
}
push_cv_.notify_one();
} }
push_cv_.notify_one();
}
// try to dequeue item. if no item found. wait upto timeout and try again // try to dequeue item. if no item found. wait upto timeout and try again
// Return true, if succeeded dequeue item, false otherwise // Return true, if succeeded dequeue item, false otherwise
bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) {
{ {
{ std::unique_lock<std::mutex> lock(queue_mutex_);
std::unique_lock<std::mutex> lock(queue_mutex_); if (!push_cv_.wait_for(lock, wait_duration,
if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) [this] { return !this->q_.empty(); })) {
{ return false;
return false; }
} q_.pop_front(popped_item);
q_.pop_front(popped_item);
}
pop_cv_.notify_one();
return true;
} }
pop_cv_.notify_one();
return true;
}
#else #else
// apparently mingw deadlocks if the mutex is released before cv.notify_one(), // apparently mingw deadlocks if the mutex is released before cv.notify_one(),
// so release the mutex at the very end each function. // so release the mutex at the very end each function.
// try to enqueue and block if no room left // try to enqueue and block if no room left
void enqueue(T &&item) void enqueue(T &&item) {
{ std::unique_lock<std::mutex> lock(queue_mutex_);
std::unique_lock<std::mutex> lock(queue_mutex_); pop_cv_.wait(lock, [this] { return !this->q_.full(); });
pop_cv_.wait(lock, [this] { return !this->q_.full(); }); q_.push_back(std::move(item));
q_.push_back(std::move(item)); push_cv_.notify_one();
push_cv_.notify_one(); }
}
// enqueue immediately. overrun oldest message in the queue if no room left. // enqueue immediately. overrun oldest message in the queue if no room left.
void enqueue_nowait(T &&item) void enqueue_nowait(T &&item) {
{ std::unique_lock<std::mutex> lock(queue_mutex_);
std::unique_lock<std::mutex> lock(queue_mutex_); q_.push_back(std::move(item));
q_.push_back(std::move(item)); push_cv_.notify_one();
push_cv_.notify_one(); }
}
// try to dequeue item. if no item found. wait upto timeout and try again // try to dequeue item. if no item found. wait upto timeout and try again
// Return true, if succeeded dequeue item, false otherwise // Return true, if succeeded dequeue item, false otherwise
bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) {
{ std::unique_lock<std::mutex> lock(queue_mutex_);
std::unique_lock<std::mutex> lock(queue_mutex_); if (!push_cv_.wait_for(lock, wait_duration,
if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) [this] { return !this->q_.empty(); })) {
{ return false;
return false;
}
q_.pop_front(popped_item);
pop_cv_.notify_one();
return true;
} }
q_.pop_front(popped_item);
pop_cv_.notify_one();
return true;
}
#endif #endif
size_t overrun_counter() size_t overrun_counter() {
{ std::unique_lock<std::mutex> lock(queue_mutex_);
std::unique_lock<std::mutex> lock(queue_mutex_); return q_.overrun_counter();
return q_.overrun_counter(); }
}
private: private:
std::mutex queue_mutex_; std::mutex queue_mutex_;
std::condition_variable push_cv_; std::condition_variable push_cv_;
std::condition_variable pop_cv_; std::condition_variable pop_cv_;
spdlog::details::circular_q<T> q_; spdlog::details::circular_q<T> q_;
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

38
src/cpp/include/deps/spdlog/details/null_mutex.h Executable file → Normal file
View File

@ -10,36 +10,22 @@
namespace spdlog { namespace spdlog {
namespace details { namespace details {
struct null_mutex struct null_mutex {
{ void lock() {}
void lock() {} void unlock() {}
void unlock() {} bool try_lock() { return true; }
bool try_lock()
{
return true;
}
}; };
struct null_atomic_int struct null_atomic_int {
{ int value;
int value; null_atomic_int() = default;
null_atomic_int() = default;
explicit null_atomic_int(int val) explicit null_atomic_int(int val) : value(val) {}
: value(val)
{
}
int load(std::memory_order) const int load(std::memory_order) const { return value; }
{
return value;
}
void store(int val) void store(int val) { value = val; }
{
value = val;
}
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

403
src/cpp/include/deps/spdlog/details/os.h Executable file → Normal file
View File

@ -4,7 +4,8 @@
// //
#pragma once #pragma once
#include "../common.h" #include <sys/stat.h>
#include <sys/types.h>
#include <algorithm> #include <algorithm>
#include <chrono> #include <chrono>
@ -14,98 +15,92 @@
#include <ctime> #include <ctime>
#include <functional> #include <functional>
#include <string> #include <string>
#include <sys/stat.h>
#include <sys/types.h>
#include <thread> #include <thread>
#include "../common.h"
#ifdef _WIN32 #ifdef _WIN32
#ifndef NOMINMAX #ifndef NOMINMAX
#define NOMINMAX // prevent windows redefining min/max #define NOMINMAX // prevent windows redefining min/max
#endif #endif
#ifndef WIN32_LEAN_AND_MEAN #ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN #define WIN32_LEAN_AND_MEAN
#endif #endif
#include <io.h> // _get_osfhandle and _isatty support #include <io.h> // _get_osfhandle and _isatty support
#include <process.h> // _get_pid support #include <process.h> // _get_pid support
#include <windows.h> #include <windows.h>
#ifdef __MINGW32__ #ifdef __MINGW32__
#include <share.h> #include <share.h>
#endif #endif
#else // unix #else // unix
#include <fcntl.h> #include <fcntl.h>
#include <unistd.h> #include <unistd.h>
#ifdef __linux__ #ifdef __linux__
#include <sys/syscall.h> //Use gettid() syscall under linux to get thread id #include <sys/syscall.h> //Use gettid() syscall under linux to get thread id
#elif __FreeBSD__ #elif __FreeBSD__
#include <sys/thr.h> //Use thr_self() syscall under FreeBSD to get thread id #include <sys/thr.h> //Use thr_self() syscall under FreeBSD to get thread id
#endif #endif
#endif // unix #endif // unix
#ifndef __has_feature // Clang - feature checking macros. #ifndef __has_feature // Clang - feature checking macros.
#define __has_feature(x) 0 // Compatibility with non-clang compilers. #define __has_feature(x) 0 // Compatibility with non-clang compilers.
#endif #endif
namespace spdlog { namespace spdlog {
namespace details { namespace details {
namespace os { namespace os {
inline spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT inline spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT {
{
#if defined __linux__ && defined SPDLOG_CLOCK_COARSE #if defined __linux__ && defined SPDLOG_CLOCK_COARSE
timespec ts; timespec ts;
::clock_gettime(CLOCK_REALTIME_COARSE, &ts); ::clock_gettime(CLOCK_REALTIME_COARSE, &ts);
return std::chrono::time_point<log_clock, typename log_clock::duration>( return std::chrono::time_point<log_clock, typename log_clock::duration>(
std::chrono::duration_cast<typename log_clock::duration>(std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec))); std::chrono::duration_cast<typename log_clock::duration>(
std::chrono::seconds(ts.tv_sec) +
std::chrono::nanoseconds(ts.tv_nsec)));
#else #else
return log_clock::now(); return log_clock::now();
#endif #endif
} }
inline std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT inline std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT {
{
#ifdef _WIN32 #ifdef _WIN32
std::tm tm; std::tm tm;
localtime_s(&tm, &time_tt); localtime_s(&tm, &time_tt);
#else #else
std::tm tm; std::tm tm;
localtime_r(&time_tt, &tm); localtime_r(&time_tt, &tm);
#endif #endif
return tm; return tm;
} }
inline std::tm localtime() SPDLOG_NOEXCEPT inline std::tm localtime() SPDLOG_NOEXCEPT {
{ std::time_t now_t = time(nullptr);
std::time_t now_t = time(nullptr); return localtime(now_t);
return localtime(now_t);
} }
inline std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT inline std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT {
{
#ifdef _WIN32 #ifdef _WIN32
std::tm tm; std::tm tm;
gmtime_s(&tm, &time_tt); gmtime_s(&tm, &time_tt);
#else #else
std::tm tm; std::tm tm;
gmtime_r(&time_tt, &tm); gmtime_r(&time_tt, &tm);
#endif #endif
return tm; return tm;
} }
inline std::tm gmtime() SPDLOG_NOEXCEPT inline std::tm gmtime() SPDLOG_NOEXCEPT {
{ std::time_t now_t = time(nullptr);
std::time_t now_t = time(nullptr); return gmtime(now_t);
return gmtime(now_t);
} }
// eol definition // eol definition
@ -126,296 +121,274 @@ SPDLOG_CONSTEXPR static const char folder_sep = '\\';
SPDLOG_CONSTEXPR static const char folder_sep = '/'; SPDLOG_CONSTEXPR static const char folder_sep = '/';
#endif #endif
inline void prevent_child_fd(FILE *f) inline void prevent_child_fd(FILE *f) {
{
#ifdef _WIN32 #ifdef _WIN32
#if !defined(__cplusplus_winrt) #if !defined(__cplusplus_winrt)
auto file_handle = (HANDLE)_get_osfhandle(_fileno(f)); auto file_handle = (HANDLE)_get_osfhandle(_fileno(f));
if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0)) if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0))
throw spdlog_ex("SetHandleInformation failed", errno); throw spdlog_ex("SetHandleInformation failed", errno);
#endif #endif
#else #else
auto fd = fileno(f); auto fd = fileno(f);
if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1) if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1) {
{ throw spdlog_ex("fcntl with FD_CLOEXEC failed", errno);
throw spdlog_ex("fcntl with FD_CLOEXEC failed", errno); }
}
#endif #endif
} }
// fopen_s on non windows for writing // fopen_s on non windows for writing
inline bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode) inline bool fopen_s(FILE **fp, const filename_t &filename,
{ const filename_t &mode) {
#ifdef _WIN32 #ifdef _WIN32
#ifdef SPDLOG_WCHAR_FILENAMES #ifdef SPDLOG_WCHAR_FILENAMES
*fp = _wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO); *fp = _wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
#else #else
*fp = _fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO); *fp = _fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
#endif #endif
#else // unix #else // unix
*fp = fopen((filename.c_str()), mode.c_str()); *fp = fopen((filename.c_str()), mode.c_str());
#endif #endif
#ifdef SPDLOG_PREVENT_CHILD_FD #ifdef SPDLOG_PREVENT_CHILD_FD
if (*fp != nullptr) if (*fp != nullptr) {
{ prevent_child_fd(*fp);
prevent_child_fd(*fp); }
}
#endif #endif
return *fp == nullptr; return *fp == nullptr;
} }
inline int remove(const filename_t &filename) SPDLOG_NOEXCEPT inline int remove(const filename_t &filename) SPDLOG_NOEXCEPT {
{
#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
return _wremove(filename.c_str()); return _wremove(filename.c_str());
#else #else
return std::remove(filename.c_str()); return std::remove(filename.c_str());
#endif #endif
} }
inline int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT inline int rename(const filename_t &filename1,
{ const filename_t &filename2) SPDLOG_NOEXCEPT {
#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
return _wrename(filename1.c_str(), filename2.c_str()); return _wrename(filename1.c_str(), filename2.c_str());
#else #else
return std::rename(filename1.c_str(), filename2.c_str()); return std::rename(filename1.c_str(), filename2.c_str());
#endif #endif
} }
// Return if file exists // Return if file exists
inline bool file_exists(const filename_t &filename) SPDLOG_NOEXCEPT inline bool file_exists(const filename_t &filename) SPDLOG_NOEXCEPT {
{
#ifdef _WIN32 #ifdef _WIN32
#ifdef SPDLOG_WCHAR_FILENAMES #ifdef SPDLOG_WCHAR_FILENAMES
auto attribs = GetFileAttributesW(filename.c_str()); auto attribs = GetFileAttributesW(filename.c_str());
#else #else
auto attribs = GetFileAttributesA(filename.c_str()); auto attribs = GetFileAttributesA(filename.c_str());
#endif #endif
return (attribs != INVALID_FILE_ATTRIBUTES && !(attribs & FILE_ATTRIBUTE_DIRECTORY)); return (attribs != INVALID_FILE_ATTRIBUTES &&
#else // common linux/unix all have the stat system call !(attribs & FILE_ATTRIBUTE_DIRECTORY));
struct stat buffer; #else // common linux/unix all have the stat system call
return (stat(filename.c_str(), &buffer) == 0); struct stat buffer;
return (stat(filename.c_str(), &buffer) == 0);
#endif #endif
} }
// Return file size according to open FILE* object // Return file size according to open FILE* object
inline size_t filesize(FILE *f) inline size_t filesize(FILE *f) {
{ if (f == nullptr) {
if (f == nullptr) throw spdlog_ex("Failed getting file size. fd is null");
{ }
throw spdlog_ex("Failed getting file size. fd is null");
}
#if defined(_WIN32) && !defined(__CYGWIN__) #if defined(_WIN32) && !defined(__CYGWIN__)
int fd = _fileno(f); int fd = _fileno(f);
#if _WIN64 // 64 bits #if _WIN64 // 64 bits
__int64 ret = _filelengthi64(fd); __int64 ret = _filelengthi64(fd);
if (ret >= 0) if (ret >= 0) {
{ return static_cast<size_t>(ret);
return static_cast<size_t>(ret); }
}
#else // windows 32 bits #else // windows 32 bits
long ret = _filelength(fd); long ret = _filelength(fd);
if (ret >= 0) if (ret >= 0) {
{ return static_cast<size_t>(ret);
return static_cast<size_t>(ret); }
}
#endif #endif
#else // unix #else // unix
int fd = fileno(f); int fd = fileno(f);
// 64 bits(but not in osx or cygwin, where fstat64 is deprecated) // 64 bits(but not in osx or cygwin, where fstat64 is deprecated)
#if !defined(__FreeBSD__) && !defined(__APPLE__) && (defined(__x86_64__) || defined(__ppc64__)) && !defined(__CYGWIN__) #if !defined(__FreeBSD__) && !defined(__APPLE__) && \
struct stat64 st; (defined(__x86_64__) || defined(__ppc64__)) && !defined(__CYGWIN__)
if (fstat64(fd, &st) == 0) struct stat64 st;
{ if (fstat64(fd, &st) == 0) {
return static_cast<size_t>(st.st_size); return static_cast<size_t>(st.st_size);
} }
#else // unix 32 bits or cygwin #else // unix 32 bits or cygwin
struct stat st; struct stat st;
if (fstat(fd, &st) == 0) if (fstat(fd, &st) == 0) {
{ return static_cast<size_t>(st.st_size);
return static_cast<size_t>(st.st_size); }
}
#endif #endif
#endif #endif
throw spdlog_ex("Failed getting file size from fd", errno); throw spdlog_ex("Failed getting file size from fd", errno);
} }
// Return utc offset in minutes or throw spdlog_ex 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()) inline int utc_minutes_offset(const std::tm &tm = details::os::localtime()) {
{
#ifdef _WIN32 #ifdef _WIN32
#if _WIN32_WINNT < _WIN32_WINNT_WS08 #if _WIN32_WINNT < _WIN32_WINNT_WS08
TIME_ZONE_INFORMATION tzinfo; TIME_ZONE_INFORMATION tzinfo;
auto rv = GetTimeZoneInformation(&tzinfo); auto rv = GetTimeZoneInformation(&tzinfo);
#else #else
DYNAMIC_TIME_ZONE_INFORMATION tzinfo; DYNAMIC_TIME_ZONE_INFORMATION tzinfo;
auto rv = GetDynamicTimeZoneInformation(&tzinfo); auto rv = GetDynamicTimeZoneInformation(&tzinfo);
#endif #endif
if (rv == TIME_ZONE_ID_INVALID) if (rv == TIME_ZONE_ID_INVALID)
throw spdlog::spdlog_ex("Failed getting timezone info. ", errno); throw spdlog::spdlog_ex("Failed getting timezone info. ", errno);
int offset = -tzinfo.Bias; int offset = -tzinfo.Bias;
if (tm.tm_isdst) if (tm.tm_isdst) {
{ offset -= tzinfo.DaylightBias;
offset -= tzinfo.DaylightBias; } else {
} offset -= tzinfo.StandardBias;
else }
{ return offset;
offset -= tzinfo.StandardBias;
}
return offset;
#else #else
#if defined(sun) || defined(__sun) || defined(_AIX) #if defined(sun) || defined(__sun) || defined(_AIX)
// 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris
struct helper struct helper {
{ static long int calculate_gmt_offset(
static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(), const std::tm &gmtm = details::os::gmtime()) const std::tm &localtm = details::os::localtime(),
{ const std::tm &gmtm = details::os::gmtime()) {
int local_year = localtm.tm_year + (1900 - 1); int local_year = localtm.tm_year + (1900 - 1);
int gmt_year = gmtm.tm_year + (1900 - 1); int gmt_year = gmtm.tm_year + (1900 - 1);
long int days = ( long int days = (
// difference in day of year // difference in day of year
localtm.tm_yday - localtm.tm_yday -
gmtm.tm_yday gmtm.tm_yday
// + intervening leap days // + intervening leap days
+ ((local_year >> 2) - (gmt_year >> 2)) - (local_year / 100 - gmt_year / 100) + + ((local_year >> 2) - (gmt_year >> 2)) -
((local_year / 100 >> 2) - (gmt_year / 100 >> 2)) (local_year / 100 - gmt_year / 100) +
((local_year / 100 >> 2) - (gmt_year / 100 >> 2))
// + difference in years * 365 */ // + difference in years * 365 */
+ (long int)(local_year - gmt_year) * 365); + (long int)(local_year - gmt_year) * 365);
long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour); long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour);
long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min); long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min);
long int secs = (60 * mins) + (localtm.tm_sec - gmtm.tm_sec); long int secs = (60 * mins) + (localtm.tm_sec - gmtm.tm_sec);
return secs; return secs;
} }
}; };
auto offset_seconds = helper::calculate_gmt_offset(tm); auto offset_seconds = helper::calculate_gmt_offset(tm);
#else #else
auto offset_seconds = tm.tm_gmtoff; auto offset_seconds = tm.tm_gmtoff;
#endif #endif
return static_cast<int>(offset_seconds / 60); return static_cast<int>(offset_seconds / 60);
#endif #endif
} }
// Return current thread id as size_t // Return current thread id as size_t
// It exists because the std::this_thread::get_id() is much slower(especially // It exists because the std::this_thread::get_id() is much slower(especially
// under VS 2013) // under VS 2013)
inline size_t _thread_id() SPDLOG_NOEXCEPT inline size_t _thread_id() SPDLOG_NOEXCEPT {
{
#ifdef _WIN32 #ifdef _WIN32
return static_cast<size_t>(::GetCurrentThreadId()); return static_cast<size_t>(::GetCurrentThreadId());
#elif __linux__ #elif __linux__
#if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21) #if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
#define SYS_gettid __NR_gettid #define SYS_gettid __NR_gettid
#endif #endif
return static_cast<size_t>(syscall(SYS_gettid)); return static_cast<size_t>(syscall(SYS_gettid));
#elif __FreeBSD__ #elif __FreeBSD__
long tid; long tid;
thr_self(&tid); thr_self(&tid);
return static_cast<size_t>(tid); return static_cast<size_t>(tid);
#elif __APPLE__ #elif __APPLE__
uint64_t tid; uint64_t tid;
pthread_threadid_np(nullptr, &tid); pthread_threadid_np(nullptr, &tid);
return static_cast<size_t>(tid); return static_cast<size_t>(tid);
#else // Default to standard C++11 (other Unix) #else // Default to standard C++11 (other Unix)
return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id())); return static_cast<size_t>(
std::hash<std::thread::id>()(std::this_thread::get_id()));
#endif #endif
} }
// Return current thread id as size_t (from thread local storage) // Return current thread id as size_t (from thread local storage)
inline size_t thread_id() SPDLOG_NOEXCEPT inline size_t thread_id() SPDLOG_NOEXCEPT {
{
#if defined(SPDLOG_NO_TLS) #if defined(SPDLOG_NO_TLS)
return _thread_id(); return _thread_id();
#else // cache thread id in tls #else // cache thread id in tls
static thread_local const size_t tid = _thread_id(); static thread_local const size_t tid = _thread_id();
return tid; return tid;
#endif #endif
} }
// This is avoid msvc issue in sleep_for that happens if the clock changes. // This is avoid msvc issue in sleep_for that happens if the clock changes.
// See https://github.com/gabime/spdlog/issues/609 // See https://github.com/gabime/spdlog/issues/609
inline void sleep_for_millis(int milliseconds) SPDLOG_NOEXCEPT inline void sleep_for_millis(int milliseconds) SPDLOG_NOEXCEPT {
{
#if defined(_WIN32) #if defined(_WIN32)
::Sleep(milliseconds); ::Sleep(milliseconds);
#else #else
std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds)); std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
#endif #endif
} }
// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined) // wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
#define SPDLOG_FILENAME_T(s) L##s #define SPDLOG_FILENAME_T(s) L##s
inline std::string filename_to_str(const filename_t &filename) inline std::string filename_to_str(const filename_t &filename) {
{ std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> c;
std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> c; return c.to_bytes(filename);
return c.to_bytes(filename);
} }
#else #else
#define SPDLOG_FILENAME_T(s) s #define SPDLOG_FILENAME_T(s) s
inline std::string filename_to_str(const filename_t &filename) inline std::string filename_to_str(const filename_t &filename) {
{ return filename;
return filename;
} }
#endif #endif
inline int pid() inline int pid() {
{
#ifdef _WIN32 #ifdef _WIN32
return static_cast<int>(::GetCurrentProcessId()); return static_cast<int>(::GetCurrentProcessId());
#else #else
return static_cast<int>(::getpid()); return static_cast<int>(::getpid());
#endif #endif
} }
// Determine if the terminal supports colors // Determine if the terminal supports colors
// Source: https://github.com/agauniyal/rang/ // Source: https://github.com/agauniyal/rang/
inline bool is_color_terminal() SPDLOG_NOEXCEPT inline bool is_color_terminal() SPDLOG_NOEXCEPT {
{
#ifdef _WIN32 #ifdef _WIN32
return true; return true;
#else #else
static constexpr const char *Terms[] = { static constexpr const char *Terms[] = {
"ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux", "msys", "putty", "rxvt", "screen", "vt100", "xterm"}; "ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm",
"linux", "msys", "putty", "rxvt", "screen", "vt100", "xterm"};
const char *env_p = std::getenv("TERM"); const char *env_p = std::getenv("TERM");
if (env_p == nullptr) if (env_p == nullptr) {
{ return false;
return false; }
}
static const bool result = static const bool result = std::any_of(
std::any_of(std::begin(Terms), std::end(Terms), [&](const char *term) { return std::strstr(env_p, term) != nullptr; }); std::begin(Terms), std::end(Terms),
return result; [&](const char *term) { return std::strstr(env_p, term) != nullptr; });
return result;
#endif #endif
} }
// Detrmine if the terminal attached // Detrmine if the terminal attached
// Source: https://github.com/agauniyal/rang/ // Source: https://github.com/agauniyal/rang/
inline bool in_terminal(FILE *file) SPDLOG_NOEXCEPT inline bool in_terminal(FILE *file) SPDLOG_NOEXCEPT {
{
#ifdef _WIN32 #ifdef _WIN32
return _isatty(_fileno(file)) != 0; return _isatty(_fileno(file)) != 0;
#else #else
return isatty(fileno(file)) != 0; return isatty(fileno(file)) != 0;
#endif #endif
} }
} // namespace os } // namespace os
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

1910
src/cpp/include/deps/spdlog/details/pattern_formatter.h Executable file → Normal file
View File

File diff suppressed because it is too large Load Diff

86
src/cpp/include/deps/spdlog/details/periodic_worker.h Executable file → Normal file
View File

@ -10,7 +10,8 @@
// //
// RAII over the owned thread: // RAII over the owned thread:
// creates the thread on construction. // creates the thread on construction.
// stops and joins the thread on destruction (if the thread is executing a callback, wait for it to finish first). // stops and joins the thread on destruction (if the thread is executing a
// callback, wait for it to finish first).
#include <chrono> #include <chrono>
#include <condition_variable> #include <condition_variable>
@ -20,52 +21,47 @@
namespace spdlog { namespace spdlog {
namespace details { namespace details {
class periodic_worker class periodic_worker {
{ public:
public: periodic_worker(const std::function<void()> &callback_fun,
periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval) std::chrono::seconds interval) {
{ active_ = (interval > std::chrono::seconds::zero());
active_ = (interval > std::chrono::seconds::zero()); if (!active_) {
if (!active_) return;
{
return;
}
worker_thread_ = std::thread([this, callback_fun, interval]() {
for (;;)
{
std::unique_lock<std::mutex> lock(this->mutex_);
if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; }))
{
return; // active_ == false, so exit this thread
}
callback_fun();
}
});
} }
periodic_worker(const periodic_worker &) = delete; worker_thread_ = std::thread([this, callback_fun, interval]() {
periodic_worker &operator=(const periodic_worker &) = delete; for (;;) {
std::unique_lock<std::mutex> lock(this->mutex_);
// stop the worker thread and join it if (this->cv_.wait_for(lock, interval,
~periodic_worker() [this] { return !this->active_; })) {
{ return; // active_ == false, so exit this thread
if (worker_thread_.joinable())
{
{
std::lock_guard<std::mutex> lock(mutex_);
active_ = false;
}
cv_.notify_one();
worker_thread_.join();
} }
} callback_fun();
}
});
}
private: periodic_worker(const periodic_worker &) = delete;
bool active_; periodic_worker &operator=(const periodic_worker &) = delete;
std::thread worker_thread_;
std::mutex mutex_; // stop the worker thread and join it
std::condition_variable cv_; ~periodic_worker() {
if (worker_thread_.joinable()) {
{
std::lock_guard<std::mutex> lock(mutex_);
active_ = false;
}
cv_.notify_one();
worker_thread_.join();
}
}
private:
bool active_;
std::thread worker_thread_;
std::mutex mutex_;
std::condition_variable cv_;
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

419
src/cpp/include/deps/spdlog/details/registry.h Executable file → Normal file
View File

@ -21,7 +21,7 @@
#else #else
#include "spdlog/sinks/ansicolor_sink.h" #include "spdlog/sinks/ansicolor_sink.h"
#endif #endif
#endif // SPDLOG_DISABLE_DEFAULT_LOGGER #endif // SPDLOG_DISABLE_DEFAULT_LOGGER
#include <chrono> #include <chrono>
#include <functional> #include <functional>
@ -33,253 +33,216 @@ namespace spdlog {
namespace details { namespace details {
class thread_pool; class thread_pool;
class registry class registry {
{ public:
public: registry(const registry &) = delete;
registry(const registry &) = delete; registry &operator=(const registry &) = delete;
registry &operator=(const registry &) = delete;
void register_logger(std::shared_ptr<logger> new_logger) void register_logger(std::shared_ptr<logger> new_logger) {
{ std::lock_guard<std::mutex> lock(logger_map_mutex_);
std::lock_guard<std::mutex> lock(logger_map_mutex_); register_logger_(std::move(new_logger));
register_logger_(std::move(new_logger)); }
void initialize_logger(std::shared_ptr<logger> new_logger) {
std::lock_guard<std::mutex> lock(logger_map_mutex_);
new_logger->set_formatter(formatter_->clone());
if (err_handler_) {
new_logger->set_error_handler(err_handler_);
} }
void initialize_logger(std::shared_ptr<logger> new_logger) new_logger->set_level(level_);
new_logger->flush_on(flush_level_);
if (automatic_registration_) {
register_logger_(std::move(new_logger));
}
}
std::shared_ptr<logger> get(const std::string &logger_name) {
std::lock_guard<std::mutex> lock(logger_map_mutex_);
auto found = loggers_.find(logger_name);
return found == loggers_.end() ? nullptr : found->second;
}
std::shared_ptr<logger> default_logger() {
std::lock_guard<std::mutex> lock(logger_map_mutex_);
return default_logger_;
}
// Return raw ptr to the default logger.
// To be used directly by the spdlog default api (e.g. spdlog::info)
// This make the default API faster, but cannot be used concurrently with
// set_default_logger(). e.g do not call set_default_logger() from one thread
// while calling spdlog::info() from another.
logger *get_default_raw() { return default_logger_.get(); }
// set default logger.
// default logger is stored in default_logger_ (for faster retrieval) and in
// the loggers_ map.
void set_default_logger(std::shared_ptr<logger> new_default_logger) {
std::lock_guard<std::mutex> lock(logger_map_mutex_);
// remove previous default logger from the map
if (default_logger_ != nullptr) {
loggers_.erase(default_logger_->name());
}
if (new_default_logger != nullptr) {
loggers_[new_default_logger->name()] = new_default_logger;
}
default_logger_ = std::move(new_default_logger);
}
void set_tp(std::shared_ptr<thread_pool> tp) {
std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
tp_ = std::move(tp);
}
std::shared_ptr<thread_pool> get_tp() {
std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
return tp_;
}
// Set global formatter. Each sink in each logger will get a clone of this
// object
void set_formatter(std::unique_ptr<formatter> formatter) {
std::lock_guard<std::mutex> lock(logger_map_mutex_);
formatter_ = std::move(formatter);
for (auto &l : loggers_) {
l.second->set_formatter(formatter_->clone());
}
}
void set_level(level::level_enum log_level) {
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_) {
l.second->set_level(log_level);
}
level_ = log_level;
}
void flush_on(level::level_enum log_level) {
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_) {
l.second->flush_on(log_level);
}
flush_level_ = log_level;
}
void flush_every(std::chrono::seconds interval) {
std::lock_guard<std::mutex> lock(flusher_mutex_);
std::function<void()> clbk = std::bind(&registry::flush_all, this);
periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
}
void set_error_handler(log_err_handler handler) {
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_) {
l.second->set_error_handler(handler);
}
err_handler_ = handler;
}
void apply_all(
const std::function<void(const std::shared_ptr<logger>)> &fun) {
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_) {
fun(l.second);
}
}
void flush_all() {
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_) {
l.second->flush();
}
}
void drop(const std::string &logger_name) {
std::lock_guard<std::mutex> lock(logger_map_mutex_);
loggers_.erase(logger_name);
if (default_logger_ && default_logger_->name() == logger_name) {
default_logger_.reset();
}
}
void drop_all() {
std::lock_guard<std::mutex> lock(logger_map_mutex_);
loggers_.clear();
default_logger_.reset();
}
// clean all resources and threads started by the registry
void shutdown() {
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(flusher_mutex_);
new_logger->set_formatter(formatter_->clone()); periodic_flusher_.reset();
if (err_handler_)
{
new_logger->set_error_handler(err_handler_);
}
new_logger->set_level(level_);
new_logger->flush_on(flush_level_);
if (automatic_registration_)
{
register_logger_(std::move(new_logger));
}
} }
std::shared_ptr<logger> get(const std::string &logger_name) drop_all();
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
auto found = loggers_.find(logger_name); tp_.reset();
return found == loggers_.end() ? nullptr : found->second;
} }
}
std::shared_ptr<logger> default_logger() std::recursive_mutex &tp_mutex() { return tp_mutex_; }
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
return default_logger_;
}
// Return raw ptr to the default logger. void set_automatic_registration(bool automatic_regsistration) {
// To be used directly by the spdlog default api (e.g. spdlog::info) std::lock_guard<std::mutex> lock(logger_map_mutex_);
// This make the default API faster, but cannot be used concurrently with set_default_logger(). automatic_registration_ = automatic_regsistration;
// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another. }
logger *get_default_raw()
{
return default_logger_.get();
}
// set default logger. static registry &instance() {
// default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map. static registry s_instance;
void set_default_logger(std::shared_ptr<logger> new_default_logger) return s_instance;
{ }
std::lock_guard<std::mutex> lock(logger_map_mutex_);
// remove previous default logger from the map
if (default_logger_ != nullptr)
{
loggers_.erase(default_logger_->name());
}
if (new_default_logger != nullptr)
{
loggers_[new_default_logger->name()] = new_default_logger;
}
default_logger_ = std::move(new_default_logger);
}
void set_tp(std::shared_ptr<thread_pool> tp)
{
std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
tp_ = std::move(tp);
}
std::shared_ptr<thread_pool> get_tp()
{
std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
return tp_;
}
// Set global formatter. Each sink in each logger will get a clone of this object
void set_formatter(std::unique_ptr<formatter> formatter)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
formatter_ = std::move(formatter);
for (auto &l : loggers_)
{
l.second->set_formatter(formatter_->clone());
}
}
void set_level(level::level_enum log_level)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_)
{
l.second->set_level(log_level);
}
level_ = log_level;
}
void flush_on(level::level_enum log_level)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_)
{
l.second->flush_on(log_level);
}
flush_level_ = log_level;
}
void flush_every(std::chrono::seconds interval)
{
std::lock_guard<std::mutex> lock(flusher_mutex_);
std::function<void()> clbk = std::bind(&registry::flush_all, this);
periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
}
void set_error_handler(log_err_handler handler)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_)
{
l.second->set_error_handler(handler);
}
err_handler_ = handler;
}
void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_)
{
fun(l.second);
}
}
void flush_all()
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_)
{
l.second->flush();
}
}
void drop(const std::string &logger_name)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
loggers_.erase(logger_name);
if (default_logger_ && default_logger_->name() == logger_name)
{
default_logger_.reset();
}
}
void drop_all()
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
loggers_.clear();
default_logger_.reset();
}
// clean all resources and threads started by the registry
void shutdown()
{
{
std::lock_guard<std::mutex> lock(flusher_mutex_);
periodic_flusher_.reset();
}
drop_all();
{
std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
tp_.reset();
}
}
std::recursive_mutex &tp_mutex()
{
return tp_mutex_;
}
void set_automatic_registration(bool automatic_regsistration)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
automatic_registration_ = automatic_regsistration;
}
static registry &instance()
{
static registry s_instance;
return s_instance;
}
private:
registry()
: formatter_(new pattern_formatter())
{
private:
registry() : formatter_(new pattern_formatter()) {
#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER #ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
// create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows). // create default logger (ansicolor_stdout_sink_mt or
// wincolor_stdout_sink_mt in windows).
#ifdef _WIN32 #ifdef _WIN32
auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>(); auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>();
#else #else
auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>(); auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>();
#endif #endif
const char *default_logger_name = ""; const char *default_logger_name = "";
default_logger_ = std::make_shared<spdlog::logger>(default_logger_name, std::move(color_sink)); default_logger_ = std::make_shared<spdlog::logger>(default_logger_name,
loggers_[default_logger_name] = default_logger_; std::move(color_sink));
loggers_[default_logger_name] = default_logger_;
#endif // SPDLOG_DISABLE_DEFAULT_LOGGER #endif // SPDLOG_DISABLE_DEFAULT_LOGGER
}
~registry() = default;
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");
} }
}
~registry() = default; void register_logger_(std::shared_ptr<logger> new_logger) {
auto logger_name = new_logger->name();
throw_if_exists_(logger_name);
loggers_[logger_name] = std::move(new_logger);
}
void throw_if_exists_(const std::string &logger_name) std::mutex logger_map_mutex_, flusher_mutex_;
{ std::recursive_mutex tp_mutex_;
if (loggers_.find(logger_name) != loggers_.end()) std::unordered_map<std::string, std::shared_ptr<logger>> loggers_;
{ std::unique_ptr<formatter> formatter_;
throw spdlog_ex("logger with name '" + logger_name + "' already exists"); level::level_enum level_ = spdlog::logger::default_level();
} level::level_enum flush_level_ = level::off;
} log_err_handler err_handler_;
std::shared_ptr<thread_pool> tp_;
void register_logger_(std::shared_ptr<logger> new_logger) std::unique_ptr<periodic_worker> periodic_flusher_;
{ std::shared_ptr<logger> default_logger_;
auto logger_name = new_logger->name(); bool automatic_registration_ = true;
throw_if_exists_(logger_name);
loggers_[logger_name] = std::move(new_logger);
}
std::mutex logger_map_mutex_, flusher_mutex_;
std::recursive_mutex tp_mutex_;
std::unordered_map<std::string, std::shared_ptr<logger>> loggers_;
std::unique_ptr<formatter> formatter_;
level::level_enum level_ = spdlog::logger::default_level();
level::level_enum flush_level_ = level::off;
log_err_handler err_handler_;
std::shared_ptr<thread_pool> tp_;
std::unique_ptr<periodic_worker> periodic_flusher_;
std::shared_ptr<logger> default_logger_;
bool automatic_registration_ = true;
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

372
src/cpp/include/deps/spdlog/details/thread_pool.h Executable file → Normal file
View File

@ -1,238 +1,206 @@
#pragma once #pragma once
#include "spdlog/details/fmt_helper.h"
#include "spdlog/details/log_msg.h"
#include "spdlog/details/mpmc_blocking_q.h"
#include "spdlog/details/os.h"
#include <chrono> #include <chrono>
#include <memory> #include <memory>
#include <thread> #include <thread>
#include <vector> #include <vector>
#include "spdlog/details/fmt_helper.h"
#include "spdlog/details/log_msg.h"
#include "spdlog/details/mpmc_blocking_q.h"
#include "spdlog/details/os.h"
namespace spdlog { namespace spdlog {
namespace details { namespace details {
using async_logger_ptr = std::shared_ptr<spdlog::async_logger>; using async_logger_ptr = std::shared_ptr<spdlog::async_logger>;
enum class async_msg_type enum class async_msg_type { log, flush, terminate };
{
log,
flush,
terminate
};
// Async msg to move to/from the queue // Async msg to move to/from the queue
// Movable only. should never be copied // Movable only. should never be copied
struct async_msg struct async_msg {
{ async_msg_type msg_type;
async_msg_type msg_type; level::level_enum level;
level::level_enum level; log_clock::time_point time;
log_clock::time_point time; size_t thread_id;
size_t thread_id; fmt::basic_memory_buffer<char, 176> raw;
fmt::basic_memory_buffer<char, 176> raw;
size_t msg_id; size_t msg_id;
source_loc source; source_loc source;
async_logger_ptr worker_ptr; async_logger_ptr worker_ptr;
async_msg() = default; async_msg() = default;
~async_msg() = default; ~async_msg() = default;
// should only be moved in or out of the queue.. // should only be moved in or out of the queue..
async_msg(const async_msg &) = delete; async_msg(const async_msg &) = delete;
// support for vs2013 move // support for vs2013 move
#if defined(_MSC_VER) && _MSC_VER <= 1800 #if defined(_MSC_VER) && _MSC_VER <= 1800
async_msg(async_msg &&other) SPDLOG_NOEXCEPT : msg_type(other.msg_type), async_msg(async_msg &&other) SPDLOG_NOEXCEPT
level(other.level), : msg_type(other.msg_type),
time(other.time), level(other.level),
thread_id(other.thread_id), time(other.time),
raw(move(other.raw)), thread_id(other.thread_id),
msg_id(other.msg_id), raw(move(other.raw)),
source(other.source), msg_id(other.msg_id),
worker_ptr(std::move(other.worker_ptr)) source(other.source),
{ worker_ptr(std::move(other.worker_ptr)) {}
}
async_msg &operator=(async_msg &&other) SPDLOG_NOEXCEPT async_msg &operator=(async_msg &&other) SPDLOG_NOEXCEPT {
{ msg_type = other.msg_type;
msg_type = other.msg_type; level = other.level;
level = other.level; time = other.time;
time = other.time; thread_id = other.thread_id;
thread_id = other.thread_id; raw = std::move(other.raw);
raw = std::move(other.raw); msg_id = other.msg_id;
msg_id = other.msg_id; source = other.source;
source = other.source; worker_ptr = std::move(other.worker_ptr);
worker_ptr = std::move(other.worker_ptr); return *this;
return *this; }
} #else // (_MSC_VER) && _MSC_VER <= 1800
#else // (_MSC_VER) && _MSC_VER <= 1800 async_msg(async_msg &&) = default;
async_msg(async_msg &&) = default; async_msg &operator=(async_msg &&) = default;
async_msg &operator=(async_msg &&) = default;
#endif #endif
// construct from log_msg with given type // construct from log_msg with given type
async_msg(async_logger_ptr &&worker, async_msg_type the_type, details::log_msg &m) async_msg(async_logger_ptr &&worker, async_msg_type the_type,
: msg_type(the_type) details::log_msg &m)
, level(m.level) : msg_type(the_type),
, time(m.time) level(m.level),
, thread_id(m.thread_id) time(m.time),
, msg_id(m.msg_id) thread_id(m.thread_id),
, source(m.source) msg_id(m.msg_id),
, worker_ptr(std::move(worker)) source(m.source),
{ worker_ptr(std::move(worker)) {
fmt_helper::append_string_view(m.payload, raw); fmt_helper::append_string_view(m.payload, raw);
} }
async_msg(async_logger_ptr &&worker, async_msg_type the_type) async_msg(async_logger_ptr &&worker, async_msg_type the_type)
: msg_type(the_type) : msg_type(the_type),
, level(level::off) level(level::off),
, time() time(),
, thread_id(0) thread_id(0),
, msg_id(0) msg_id(0),
, source() source(),
, worker_ptr(std::move(worker)) worker_ptr(std::move(worker)) {}
{
}
explicit async_msg(async_msg_type the_type) explicit async_msg(async_msg_type the_type) : async_msg(nullptr, the_type) {}
: async_msg(nullptr, the_type)
{
}
// copy into log_msg // copy into log_msg
log_msg to_log_msg() log_msg to_log_msg() {
{ log_msg msg(&worker_ptr->name(), level,
log_msg msg(&worker_ptr->name(), level, string_view_t(raw.data(), raw.size())); string_view_t(raw.data(), raw.size()));
msg.time = time; msg.time = time;
msg.thread_id = thread_id; msg.thread_id = thread_id;
msg.msg_id = msg_id; msg.msg_id = msg_id;
msg.source = source; msg.source = source;
msg.color_range_start = 0; msg.color_range_start = 0;
msg.color_range_end = 0; msg.color_range_end = 0;
return msg; return msg;
} }
}; };
class thread_pool class thread_pool {
{ public:
public: using item_type = async_msg;
using item_type = async_msg; using q_type = details::mpmc_blocking_queue<item_type>;
using q_type = details::mpmc_blocking_queue<item_type>;
thread_pool(size_t q_max_items, size_t threads_n) thread_pool(size_t q_max_items, size_t threads_n) : q_(q_max_items) {
: q_(q_max_items) // std::cout << "thread_pool() q_size_bytes: " << q_size_bytes <<
{ // "\tthreads_n: " << threads_n << std::endl;
// std::cout << "thread_pool() q_size_bytes: " << q_size_bytes << if (threads_n == 0 || threads_n > 1000) {
// "\tthreads_n: " << threads_n << std::endl; throw spdlog_ex(
if (threads_n == 0 || threads_n > 1000) "spdlog::thread_pool(): invalid threads_n param (valid "
{ "range is 1-1000)");
throw spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid " }
"range is 1-1000)"); for (size_t i = 0; i < threads_n; i++) {
} threads_.emplace_back(&thread_pool::worker_loop_, this);
for (size_t i = 0; i < threads_n; i++) }
{ }
threads_.emplace_back(&thread_pool::worker_loop_, this);
} // message all threads to terminate gracefully join them
~thread_pool() {
try {
for (size_t i = 0; i < threads_.size(); i++) {
post_async_msg_(async_msg(async_msg_type::terminate),
async_overflow_policy::block);
}
for (auto &t : threads_) {
t.join();
}
} catch (...) {
}
}
thread_pool(const thread_pool &) = delete;
thread_pool &operator=(thread_pool &&) = delete;
void post_log(async_logger_ptr &&worker_ptr, details::log_msg &msg,
async_overflow_policy overflow_policy) {
async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg);
post_async_msg_(std::move(async_m), overflow_policy);
}
void post_flush(async_logger_ptr &&worker_ptr,
async_overflow_policy overflow_policy) {
post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush),
overflow_policy);
}
size_t overrun_counter() { return q_.overrun_counter(); }
private:
q_type q_;
std::vector<std::thread> threads_;
void post_async_msg_(async_msg &&new_msg,
async_overflow_policy overflow_policy) {
if (overflow_policy == async_overflow_policy::block) {
q_.enqueue(std::move(new_msg));
} else {
q_.enqueue_nowait(std::move(new_msg));
}
}
void worker_loop_() {
while (process_next_msg_()) {
};
}
// process next message in the queue
// return true if this thread should still be active (while no terminate msg
// was received)
bool process_next_msg_() {
async_msg incoming_async_msg;
bool dequeued =
q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10));
if (!dequeued) {
return true;
} }
// message all threads to terminate gracefully join them switch (incoming_async_msg.msg_type) {
~thread_pool() case async_msg_type::log: {
{ auto msg = incoming_async_msg.to_log_msg();
try incoming_async_msg.worker_ptr->backend_log_(msg);
{
for (size_t i = 0; i < threads_.size(); i++)
{
post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block);
}
for (auto &t : threads_)
{
t.join();
}
}
catch (...)
{
}
}
thread_pool(const thread_pool &) = delete;
thread_pool &operator=(thread_pool &&) = delete;
void post_log(async_logger_ptr &&worker_ptr, details::log_msg &msg, async_overflow_policy overflow_policy)
{
async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg);
post_async_msg_(std::move(async_m), overflow_policy);
}
void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy)
{
post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);
}
size_t overrun_counter()
{
return q_.overrun_counter();
}
private:
q_type q_;
std::vector<std::thread> threads_;
void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy)
{
if (overflow_policy == async_overflow_policy::block)
{
q_.enqueue(std::move(new_msg));
}
else
{
q_.enqueue_nowait(std::move(new_msg));
}
}
void worker_loop_()
{
while (process_next_msg_()) {};
}
// process next message in the queue
// return true if this thread should still be active (while no terminate msg
// was received)
bool process_next_msg_()
{
async_msg incoming_async_msg;
bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10));
if (!dequeued)
{
return true;
}
switch (incoming_async_msg.msg_type)
{
case async_msg_type::log:
{
auto msg = incoming_async_msg.to_log_msg();
incoming_async_msg.worker_ptr->backend_log_(msg);
return true;
}
case async_msg_type::flush:
{
incoming_async_msg.worker_ptr->backend_flush_();
return true;
}
case async_msg_type::terminate:
{
return false;
}
}
assert(false && "Unexpected async_msg_type");
return true; return true;
}
case async_msg_type::flush: {
incoming_async_msg.worker_ptr->backend_flush_();
return true;
}
case async_msg_type::terminate: {
return false;
}
} }
assert(false && "Unexpected async_msg_type");
return true;
}
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

213
src/cpp/include/deps/spdlog/fmt/bin_to_hex.h Executable file → Normal file
View File

@ -19,154 +19,135 @@
// std::vector<char> v(200, 0x0b); // std::vector<char> v(200, 0x0b);
// logger->info("Some buffer {}", spdlog::to_hex(v)); // logger->info("Some buffer {}", spdlog::to_hex(v));
// char buf[128]; // char buf[128];
// logger->info("Some buffer {:X}", spdlog::to_hex(std::begin(buf), std::end(buf))); // logger->info("Some buffer {:X}", spdlog::to_hex(std::begin(buf),
// std::end(buf)));
namespace spdlog { namespace spdlog {
namespace details { namespace details {
template<typename It> template <typename It>
class bytes_range class bytes_range {
{ public:
public: bytes_range(It range_begin, It range_end)
bytes_range(It range_begin, It range_end) : begin_(range_begin), end_(range_end) {}
: begin_(range_begin)
, end_(range_end)
{
}
It begin() const It begin() const { return begin_; }
{ It end() const { return end_; }
return begin_;
}
It end() const
{
return end_;
}
private: private:
It begin_, end_; It begin_, end_;
}; };
} // namespace details } // namespace details
// create a bytes_range that wraps the given container // create a bytes_range that wraps the given container
template<typename Container> template <typename Container>
inline details::bytes_range<typename Container::const_iterator> to_hex(const Container &container) inline details::bytes_range<typename Container::const_iterator> to_hex(
{ const Container &container) {
static_assert(sizeof(typename Container::value_type) == 1, "sizeof(Container::value_type) != 1"); static_assert(sizeof(typename Container::value_type) == 1,
using Iter = typename Container::const_iterator; "sizeof(Container::value_type) != 1");
return details::bytes_range<Iter>(std::begin(container), std::end(container)); using Iter = typename Container::const_iterator;
return details::bytes_range<Iter>(std::begin(container), std::end(container));
} }
// create bytes_range from ranges // create bytes_range from ranges
template<typename It> template <typename It>
inline details::bytes_range<It> to_hex(const It range_begin, const It range_end) inline details::bytes_range<It> to_hex(const It range_begin,
{ const It range_end) {
return details::bytes_range<It>(range_begin, range_end); return details::bytes_range<It>(range_begin, range_end);
} }
} // namespace spdlog } // namespace spdlog
namespace fmt { namespace fmt {
template<typename T> template <typename T>
struct formatter<spdlog::details::bytes_range<T>> struct formatter<spdlog::details::bytes_range<T>> {
{ const std::size_t line_size = 100;
const std::size_t line_size = 100; const char delimiter = ' ';
const char delimiter = ' ';
bool put_newlines = true; bool put_newlines = true;
bool put_delimiters = true; bool put_delimiters = true;
bool use_uppercase = false; bool use_uppercase = false;
bool put_positions = true; // position on start of each line bool put_positions = true; // position on start of each line
// parse the format string flags // parse the format string flags
template<typename ParseContext> template <typename ParseContext>
auto parse(ParseContext &ctx) -> decltype(ctx.begin()) auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
{ auto it = ctx.begin();
auto it = ctx.begin(); while (*it && *it != '}') {
while (*it && *it != '}') switch (*it) {
{ case 'X':
switch (*it) use_uppercase = true;
{ break;
case 'X': case 's':
use_uppercase = true; put_delimiters = false;
break; break;
case 's': case 'p':
put_delimiters = false; put_positions = false;
break; break;
case 'p': case 'n':
put_positions = false; put_newlines = false;
break; break;
case 'n': }
put_newlines = false;
break;
}
++it; ++it;
}
return it;
} }
return it;
}
// format the given bytes range as hex // format the given bytes range as hex
template<typename FormatContext, typename Container> template <typename FormatContext, typename Container>
auto format(const spdlog::details::bytes_range<Container> &the_range, FormatContext &ctx) -> decltype(ctx.out()) auto format(const spdlog::details::bytes_range<Container> &the_range,
{ FormatContext &ctx) -> decltype(ctx.out()) {
SPDLOG_CONSTEXPR const char *hex_upper = "0123456789ABCDEF"; SPDLOG_CONSTEXPR const char *hex_upper = "0123456789ABCDEF";
SPDLOG_CONSTEXPR const char *hex_lower = "0123456789abcdef"; SPDLOG_CONSTEXPR const char *hex_lower = "0123456789abcdef";
const char *hex_chars = use_uppercase ? hex_upper : hex_lower; const char *hex_chars = use_uppercase ? hex_upper : hex_lower;
std::size_t pos = 0; std::size_t pos = 0;
std::size_t column = line_size; std::size_t column = line_size;
auto inserter = ctx.begin(); auto inserter = ctx.begin();
for (auto &item : the_range) for (auto &item : the_range) {
{ auto ch = static_cast<unsigned char>(item);
auto ch = static_cast<unsigned char>(item); pos++;
pos++;
if (put_newlines && column >= line_size) if (put_newlines && column >= line_size) {
{ column = put_newline(inserter, pos);
column = put_newline(inserter, pos);
// put first byte without delimiter in front of it // put first byte without delimiter in front of it
*inserter++ = hex_chars[(ch >> 4) & 0x0f]; *inserter++ = hex_chars[(ch >> 4) & 0x0f];
*inserter++ = hex_chars[ch & 0x0f]; *inserter++ = hex_chars[ch & 0x0f];
column += 2; column += 2;
continue; continue;
} }
if (put_delimiters) if (put_delimiters) {
{ *inserter++ = delimiter;
*inserter++ = delimiter; ++column;
++column; }
}
*inserter++ = hex_chars[(ch >> 4) & 0x0f]; *inserter++ = hex_chars[(ch >> 4) & 0x0f];
*inserter++ = hex_chars[ch & 0x0f]; *inserter++ = hex_chars[ch & 0x0f];
column += 2; column += 2;
}
return inserter;
} }
return inserter;
}
// put newline(and position header) // put newline(and position header)
// return the next column // return the next column
template<typename It> template <typename It>
std::size_t put_newline(It inserter, std::size_t pos) std::size_t put_newline(It inserter, std::size_t pos) {
{
#ifdef _WIN32 #ifdef _WIN32
*inserter++ = '\r'; *inserter++ = '\r';
#endif #endif
*inserter++ = '\n'; *inserter++ = '\n';
if (put_positions) if (put_positions) {
{ fmt::format_to(inserter, "{:<04X}: ", pos - 1);
fmt::format_to(inserter, "{:<04X}: ", pos - 1); return 7;
return 7; } else {
} return 1;
else
{
return 1;
}
} }
}
}; };
} // namespace fmt } // namespace fmt

367
src/cpp/include/deps/spdlog/fmt/bundled/chrono.h Executable file → Normal file
View File

@ -8,17 +8,17 @@
#ifndef FMT_CHRONO_H_ #ifndef FMT_CHRONO_H_
#define FMT_CHRONO_H_ #define FMT_CHRONO_H_
#include "format.h"
#include "locale.h"
#include <chrono> #include <chrono>
#include <ctime> #include <ctime>
#include <locale> #include <locale>
#include <sstream> #include <sstream>
#include "format.h"
#include "locale.h"
FMT_BEGIN_NAMESPACE FMT_BEGIN_NAMESPACE
namespace internal{ namespace internal {
enum class numeric_system { enum class numeric_system {
standard, standard,
@ -28,8 +28,9 @@ enum class numeric_system {
// Parses a put_time-like format string and invokes handler actions. // Parses a put_time-like format string and invokes handler actions.
template <typename Char, typename Handler> template <typename Char, typename Handler>
FMT_CONSTEXPR const Char *parse_chrono_format( FMT_CONSTEXPR const Char *parse_chrono_format(const Char *begin,
const Char *begin, const Char *end, Handler &&handler) { const Char *end,
Handler &&handler) {
auto ptr = begin; auto ptr = begin;
while (ptr != end) { while (ptr != end) {
auto c = *ptr; auto c = *ptr;
@ -38,147 +39,142 @@ FMT_CONSTEXPR const Char *parse_chrono_format(
++ptr; ++ptr;
continue; continue;
} }
if (begin != ptr) if (begin != ptr) handler.on_text(begin, ptr);
handler.on_text(begin, ptr); ++ptr; // consume '%'
++ptr; // consume '%' if (ptr == end) throw format_error("invalid format");
if (ptr == end)
throw format_error("invalid format");
c = *ptr++; c = *ptr++;
switch (c) { switch (c) {
case '%': case '%':
handler.on_text(ptr - 1, ptr); handler.on_text(ptr - 1, ptr);
break;
case 'n': {
const char newline[] = "\n";
handler.on_text(newline, newline + 1);
break;
}
case 't': {
const char tab[] = "\t";
handler.on_text(tab, tab + 1);
break;
}
// Day of the week:
case 'a':
handler.on_abbr_weekday();
break;
case 'A':
handler.on_full_weekday();
break;
case 'w':
handler.on_dec0_weekday(numeric_system::standard);
break;
case 'u':
handler.on_dec1_weekday(numeric_system::standard);
break;
// Month:
case 'b':
handler.on_abbr_month();
break;
case 'B':
handler.on_full_month();
break;
// Hour, minute, second:
case 'H':
handler.on_24_hour(numeric_system::standard);
break;
case 'I':
handler.on_12_hour(numeric_system::standard);
break;
case 'M':
handler.on_minute(numeric_system::standard);
break;
case 'S':
handler.on_second(numeric_system::standard);
break;
// Other:
case 'c':
handler.on_datetime(numeric_system::standard);
break;
case 'x':
handler.on_loc_date(numeric_system::standard);
break;
case 'X':
handler.on_loc_time(numeric_system::standard);
break;
case 'D':
handler.on_us_date();
break;
case 'F':
handler.on_iso_date();
break;
case 'r':
handler.on_12_hour_time();
break;
case 'R':
handler.on_24_hour_time();
break;
case 'T':
handler.on_iso_time();
break;
case 'p':
handler.on_am_pm();
break;
case 'z':
handler.on_utc_offset();
break;
case 'Z':
handler.on_tz_name();
break;
// Alternative representation:
case 'E': {
if (ptr == end)
throw format_error("invalid format");
c = *ptr++;
switch (c) {
case 'c':
handler.on_datetime(numeric_system::alternative);
break; break;
case 'x': case 'n': {
handler.on_loc_date(numeric_system::alternative); const char newline[] = "\n";
handler.on_text(newline, newline + 1);
break; break;
case 'X':
handler.on_loc_time(numeric_system::alternative);
break;
default:
throw format_error("invalid format");
} }
break; case 't': {
} const char tab[] = "\t";
case 'O': handler.on_text(tab, tab + 1);
if (ptr == end) break;
throw format_error("invalid format"); }
c = *ptr++; // Day of the week:
switch (c) { case 'a':
handler.on_abbr_weekday();
break;
case 'A':
handler.on_full_weekday();
break;
case 'w': case 'w':
handler.on_dec0_weekday(numeric_system::alternative); handler.on_dec0_weekday(numeric_system::standard);
break; break;
case 'u': case 'u':
handler.on_dec1_weekday(numeric_system::alternative); handler.on_dec1_weekday(numeric_system::standard);
break; break;
// Month:
case 'b':
handler.on_abbr_month();
break;
case 'B':
handler.on_full_month();
break;
// Hour, minute, second:
case 'H': case 'H':
handler.on_24_hour(numeric_system::alternative); handler.on_24_hour(numeric_system::standard);
break; break;
case 'I': case 'I':
handler.on_12_hour(numeric_system::alternative); handler.on_12_hour(numeric_system::standard);
break; break;
case 'M': case 'M':
handler.on_minute(numeric_system::alternative); handler.on_minute(numeric_system::standard);
break; break;
case 'S': case 'S':
handler.on_second(numeric_system::alternative); handler.on_second(numeric_system::standard);
break;
// Other:
case 'c':
handler.on_datetime(numeric_system::standard);
break;
case 'x':
handler.on_loc_date(numeric_system::standard);
break;
case 'X':
handler.on_loc_time(numeric_system::standard);
break;
case 'D':
handler.on_us_date();
break;
case 'F':
handler.on_iso_date();
break;
case 'r':
handler.on_12_hour_time();
break;
case 'R':
handler.on_24_hour_time();
break;
case 'T':
handler.on_iso_time();
break;
case 'p':
handler.on_am_pm();
break;
case 'z':
handler.on_utc_offset();
break;
case 'Z':
handler.on_tz_name();
break;
// Alternative representation:
case 'E': {
if (ptr == end) throw format_error("invalid format");
c = *ptr++;
switch (c) {
case 'c':
handler.on_datetime(numeric_system::alternative);
break;
case 'x':
handler.on_loc_date(numeric_system::alternative);
break;
case 'X':
handler.on_loc_time(numeric_system::alternative);
break;
default:
throw format_error("invalid format");
}
break;
}
case 'O':
if (ptr == end) throw format_error("invalid format");
c = *ptr++;
switch (c) {
case 'w':
handler.on_dec0_weekday(numeric_system::alternative);
break;
case 'u':
handler.on_dec1_weekday(numeric_system::alternative);
break;
case 'H':
handler.on_24_hour(numeric_system::alternative);
break;
case 'I':
handler.on_12_hour(numeric_system::alternative);
break;
case 'M':
handler.on_minute(numeric_system::alternative);
break;
case 'S':
handler.on_second(numeric_system::alternative);
break;
default:
throw format_error("invalid format");
}
break; break;
default: default:
throw format_error("invalid format"); throw format_error("invalid format");
}
break;
default:
throw format_error("invalid format");
} }
begin = ptr; begin = ptr;
} }
if (begin != ptr) if (begin != ptr) handler.on_text(begin, ptr);
handler.on_text(begin, ptr);
return ptr; return ptr;
} }
@ -213,7 +209,8 @@ struct chrono_format_checker {
template <typename Int> template <typename Int>
inline int to_int(Int value) { inline int to_int(Int value) {
FMT_ASSERT(value >= (std::numeric_limits<int>::min)() && FMT_ASSERT(value >= (std::numeric_limits<int>::min)() &&
value <= (std::numeric_limits<int>::max)(), "invalid value"); value <= (std::numeric_limits<int>::max)(),
"invalid value");
return static_cast<int>(value); return static_cast<int>(value);
} }
@ -227,7 +224,7 @@ struct chrono_formatter {
typedef typename FormatContext::char_type char_type; typedef typename FormatContext::char_type char_type;
explicit chrono_formatter(FormatContext &ctx, OutputIt o) explicit chrono_formatter(FormatContext &ctx, OutputIt o)
: context(ctx), out(o) {} : context(ctx), out(o) {}
int hour() const { return to_int((s.count() / 3600) % 24); } int hour() const { return to_int((s.count() / 3600) % 24); }
@ -251,8 +248,7 @@ struct chrono_formatter {
typedef typename int_traits<int>::main_type main_type; typedef typename int_traits<int>::main_type main_type;
main_type n = to_unsigned(value); main_type n = to_unsigned(value);
int num_digits = internal::count_digits(n); int num_digits = internal::count_digits(n);
if (width > num_digits) if (width > num_digits) out = std::fill_n(out, width - num_digits, '0');
out = std::fill_n(out, width - num_digits, '0');
out = format_decimal<char_type>(out, n, num_digits); out = format_decimal<char_type>(out, n, num_digits);
} }
@ -286,24 +282,21 @@ struct chrono_formatter {
void on_tz_name() {} void on_tz_name() {}
void on_24_hour(numeric_system ns) { void on_24_hour(numeric_system ns) {
if (ns == numeric_system::standard) if (ns == numeric_system::standard) return write(hour(), 2);
return write(hour(), 2);
auto time = tm(); auto time = tm();
time.tm_hour = hour(); time.tm_hour = hour();
format_localized(time, "%OH"); format_localized(time, "%OH");
} }
void on_12_hour(numeric_system ns) { void on_12_hour(numeric_system ns) {
if (ns == numeric_system::standard) if (ns == numeric_system::standard) return write(hour12(), 2);
return write(hour12(), 2);
auto time = tm(); auto time = tm();
time.tm_hour = hour(); time.tm_hour = hour();
format_localized(time, "%OI"); format_localized(time, "%OI");
} }
void on_minute(numeric_system ns) { void on_minute(numeric_system ns) {
if (ns == numeric_system::standard) if (ns == numeric_system::standard) return write(minute(), 2);
return write(minute(), 2);
auto time = tm(); auto time = tm();
time.tm_min = minute(); time.tm_min = minute();
format_localized(time, "%OM"); format_localized(time, "%OM");
@ -341,30 +334,84 @@ struct chrono_formatter {
}; };
} // namespace internal } // namespace internal
template <typename Period> FMT_CONSTEXPR const char *get_units() { template <typename Period>
FMT_CONSTEXPR const char *get_units() {
return FMT_NULL; return FMT_NULL;
} }
template <> FMT_CONSTEXPR const char *get_units<std::atto>() { return "as"; } template <>
template <> FMT_CONSTEXPR const char *get_units<std::femto>() { return "fs"; } FMT_CONSTEXPR const char *get_units<std::atto>() {
template <> FMT_CONSTEXPR const char *get_units<std::pico>() { return "ps"; } return "as";
template <> FMT_CONSTEXPR const char *get_units<std::nano>() { return "ns"; } }
template <> FMT_CONSTEXPR const char *get_units<std::micro>() { return "µs"; } template <>
template <> FMT_CONSTEXPR const char *get_units<std::milli>() { return "ms"; } FMT_CONSTEXPR const char *get_units<std::femto>() {
template <> FMT_CONSTEXPR const char *get_units<std::centi>() { return "cs"; } return "fs";
template <> FMT_CONSTEXPR const char *get_units<std::deci>() { return "ds"; } }
template <> FMT_CONSTEXPR const char *get_units<std::ratio<1>>() { return "s"; } template <>
template <> FMT_CONSTEXPR const char *get_units<std::deca>() { return "das"; } FMT_CONSTEXPR const char *get_units<std::pico>() {
template <> FMT_CONSTEXPR const char *get_units<std::hecto>() { return "hs"; } return "ps";
template <> FMT_CONSTEXPR const char *get_units<std::kilo>() { return "ks"; } }
template <> FMT_CONSTEXPR const char *get_units<std::mega>() { return "Ms"; } template <>
template <> FMT_CONSTEXPR const char *get_units<std::giga>() { return "Gs"; } FMT_CONSTEXPR const char *get_units<std::nano>() {
template <> FMT_CONSTEXPR const char *get_units<std::tera>() { return "Ts"; } return "ns";
template <> FMT_CONSTEXPR const char *get_units<std::peta>() { return "Ps"; } }
template <> FMT_CONSTEXPR const char *get_units<std::exa>() { return "Es"; } template <>
template <> FMT_CONSTEXPR const char *get_units<std::ratio<60>>() { FMT_CONSTEXPR const char *get_units<std::micro>() {
return "µs";
}
template <>
FMT_CONSTEXPR const char *get_units<std::milli>() {
return "ms";
}
template <>
FMT_CONSTEXPR const char *get_units<std::centi>() {
return "cs";
}
template <>
FMT_CONSTEXPR const char *get_units<std::deci>() {
return "ds";
}
template <>
FMT_CONSTEXPR const char *get_units<std::ratio<1>>() {
return "s";
}
template <>
FMT_CONSTEXPR const char *get_units<std::deca>() {
return "das";
}
template <>
FMT_CONSTEXPR const char *get_units<std::hecto>() {
return "hs";
}
template <>
FMT_CONSTEXPR const char *get_units<std::kilo>() {
return "ks";
}
template <>
FMT_CONSTEXPR const char *get_units<std::mega>() {
return "Ms";
}
template <>
FMT_CONSTEXPR const char *get_units<std::giga>() {
return "Gs";
}
template <>
FMT_CONSTEXPR const char *get_units<std::tera>() {
return "Ts";
}
template <>
FMT_CONSTEXPR const char *get_units<std::peta>() {
return "Ps";
}
template <>
FMT_CONSTEXPR const char *get_units<std::exa>() {
return "Es";
}
template <>
FMT_CONSTEXPR const char *get_units<std::ratio<60>>() {
return "m"; return "m";
} }
template <> FMT_CONSTEXPR const char *get_units<std::ratio<3600>>() { template <>
FMT_CONSTEXPR const char *get_units<std::ratio<3600>>() {
return "h"; return "h";
} }
@ -415,13 +462,13 @@ struct formatter<std::chrono::duration<Rep, Period>, Char> {
if (begin == end) return begin; if (begin == end) return begin;
begin = internal::parse_width(begin, end, handler); begin = internal::parse_width(begin, end, handler);
end = parse_chrono_format(begin, end, internal::chrono_format_checker()); end = parse_chrono_format(begin, end, internal::chrono_format_checker());
format_str = basic_string_view<Char>(&*begin, internal::to_unsigned(end - begin)); format_str =
basic_string_view<Char>(&*begin, internal::to_unsigned(end - begin));
return end; return end;
} }
template <typename FormatContext> template <typename FormatContext>
auto format(const duration &d, FormatContext &ctx) auto format(const duration &d, FormatContext &ctx) -> decltype(ctx.out()) {
-> decltype(ctx.out()) {
auto begin = format_str.begin(), end = format_str.end(); auto begin = format_str.begin(), end = format_str.end();
memory_buffer buf; memory_buffer buf;
typedef output_range<decltype(ctx.out()), Char> range; typedef output_range<decltype(ctx.out()), Char> range;
@ -433,8 +480,8 @@ struct formatter<std::chrono::duration<Rep, Period>, Char> {
format_to(buf, "{}[{}]s", d.count(), Period::num); format_to(buf, "{}[{}]s", d.count(), Period::num);
else else
format_to(buf, "{}[{}/{}]s", d.count(), Period::num, Period::den); format_to(buf, "{}[{}/{}]s", d.count(), Period::num, Period::den);
internal::handle_dynamic_spec<internal::width_checker>( internal::handle_dynamic_spec<internal::width_checker>(spec.width_,
spec.width_, width_ref, ctx); width_ref, ctx);
} else { } else {
auto out = std::back_inserter(buf); auto out = std::back_inserter(buf);
internal::chrono_formatter<FormatContext, decltype(out)> f(ctx, out); internal::chrono_formatter<FormatContext, decltype(out)> f(ctx, out);

402
src/cpp/include/deps/spdlog/fmt/bundled/color.h Executable file → Normal file
View File

@ -20,12 +20,12 @@ FMT_API void vprint_colored(color c, string_view format, format_args args);
FMT_API void vprint_colored(color c, wstring_view format, wformat_args args); FMT_API void vprint_colored(color c, wstring_view format, wformat_args args);
template <typename... Args> template <typename... Args>
inline void print_colored(color c, string_view format_str, inline void print_colored(color c, string_view format_str,
const Args & ... args) { const Args&... args) {
vprint_colored(c, format_str, make_format_args(args...)); vprint_colored(c, format_str, make_format_args(args...));
} }
template <typename... Args> template <typename... Args>
inline void print_colored(color c, wstring_view format_str, inline void print_colored(color c, wstring_view format_str,
const Args & ... args) { const Args&... args) {
vprint_colored(c, format_str, make_format_args<wformat_context>(args...)); vprint_colored(c, format_str, make_format_args<wformat_context>(args...));
} }
@ -48,148 +48,148 @@ inline void vprint_colored(color c, wstring_view format, wformat_args args) {
#else #else
enum class color : uint32_t { enum class color : uint32_t {
alice_blue = 0xF0F8FF, // rgb(240,248,255) alice_blue = 0xF0F8FF, // rgb(240,248,255)
antique_white = 0xFAEBD7, // rgb(250,235,215) antique_white = 0xFAEBD7, // rgb(250,235,215)
aqua = 0x00FFFF, // rgb(0,255,255) aqua = 0x00FFFF, // rgb(0,255,255)
aquamarine = 0x7FFFD4, // rgb(127,255,212) aquamarine = 0x7FFFD4, // rgb(127,255,212)
azure = 0xF0FFFF, // rgb(240,255,255) azure = 0xF0FFFF, // rgb(240,255,255)
beige = 0xF5F5DC, // rgb(245,245,220) beige = 0xF5F5DC, // rgb(245,245,220)
bisque = 0xFFE4C4, // rgb(255,228,196) bisque = 0xFFE4C4, // rgb(255,228,196)
black = 0x000000, // rgb(0,0,0) black = 0x000000, // rgb(0,0,0)
blanched_almond = 0xFFEBCD, // rgb(255,235,205) blanched_almond = 0xFFEBCD, // rgb(255,235,205)
blue = 0x0000FF, // rgb(0,0,255) blue = 0x0000FF, // rgb(0,0,255)
blue_violet = 0x8A2BE2, // rgb(138,43,226) blue_violet = 0x8A2BE2, // rgb(138,43,226)
brown = 0xA52A2A, // rgb(165,42,42) brown = 0xA52A2A, // rgb(165,42,42)
burly_wood = 0xDEB887, // rgb(222,184,135) burly_wood = 0xDEB887, // rgb(222,184,135)
cadet_blue = 0x5F9EA0, // rgb(95,158,160) cadet_blue = 0x5F9EA0, // rgb(95,158,160)
chartreuse = 0x7FFF00, // rgb(127,255,0) chartreuse = 0x7FFF00, // rgb(127,255,0)
chocolate = 0xD2691E, // rgb(210,105,30) chocolate = 0xD2691E, // rgb(210,105,30)
coral = 0xFF7F50, // rgb(255,127,80) coral = 0xFF7F50, // rgb(255,127,80)
cornflower_blue = 0x6495ED, // rgb(100,149,237) cornflower_blue = 0x6495ED, // rgb(100,149,237)
cornsilk = 0xFFF8DC, // rgb(255,248,220) cornsilk = 0xFFF8DC, // rgb(255,248,220)
crimson = 0xDC143C, // rgb(220,20,60) crimson = 0xDC143C, // rgb(220,20,60)
cyan = 0x00FFFF, // rgb(0,255,255) cyan = 0x00FFFF, // rgb(0,255,255)
dark_blue = 0x00008B, // rgb(0,0,139) dark_blue = 0x00008B, // rgb(0,0,139)
dark_cyan = 0x008B8B, // rgb(0,139,139) dark_cyan = 0x008B8B, // rgb(0,139,139)
dark_golden_rod = 0xB8860B, // rgb(184,134,11) dark_golden_rod = 0xB8860B, // rgb(184,134,11)
dark_gray = 0xA9A9A9, // rgb(169,169,169) dark_gray = 0xA9A9A9, // rgb(169,169,169)
dark_green = 0x006400, // rgb(0,100,0) dark_green = 0x006400, // rgb(0,100,0)
dark_khaki = 0xBDB76B, // rgb(189,183,107) dark_khaki = 0xBDB76B, // rgb(189,183,107)
dark_magenta = 0x8B008B, // rgb(139,0,139) dark_magenta = 0x8B008B, // rgb(139,0,139)
dark_olive_green = 0x556B2F, // rgb(85,107,47) dark_olive_green = 0x556B2F, // rgb(85,107,47)
dark_orange = 0xFF8C00, // rgb(255,140,0) dark_orange = 0xFF8C00, // rgb(255,140,0)
dark_orchid = 0x9932CC, // rgb(153,50,204) dark_orchid = 0x9932CC, // rgb(153,50,204)
dark_red = 0x8B0000, // rgb(139,0,0) dark_red = 0x8B0000, // rgb(139,0,0)
dark_salmon = 0xE9967A, // rgb(233,150,122) dark_salmon = 0xE9967A, // rgb(233,150,122)
dark_sea_green = 0x8FBC8F, // rgb(143,188,143) dark_sea_green = 0x8FBC8F, // rgb(143,188,143)
dark_slate_blue = 0x483D8B, // rgb(72,61,139) dark_slate_blue = 0x483D8B, // rgb(72,61,139)
dark_slate_gray = 0x2F4F4F, // rgb(47,79,79) dark_slate_gray = 0x2F4F4F, // rgb(47,79,79)
dark_turquoise = 0x00CED1, // rgb(0,206,209) dark_turquoise = 0x00CED1, // rgb(0,206,209)
dark_violet = 0x9400D3, // rgb(148,0,211) dark_violet = 0x9400D3, // rgb(148,0,211)
deep_pink = 0xFF1493, // rgb(255,20,147) deep_pink = 0xFF1493, // rgb(255,20,147)
deep_sky_blue = 0x00BFFF, // rgb(0,191,255) deep_sky_blue = 0x00BFFF, // rgb(0,191,255)
dim_gray = 0x696969, // rgb(105,105,105) dim_gray = 0x696969, // rgb(105,105,105)
dodger_blue = 0x1E90FF, // rgb(30,144,255) dodger_blue = 0x1E90FF, // rgb(30,144,255)
fire_brick = 0xB22222, // rgb(178,34,34) fire_brick = 0xB22222, // rgb(178,34,34)
floral_white = 0xFFFAF0, // rgb(255,250,240) floral_white = 0xFFFAF0, // rgb(255,250,240)
forest_green = 0x228B22, // rgb(34,139,34) forest_green = 0x228B22, // rgb(34,139,34)
fuchsia = 0xFF00FF, // rgb(255,0,255) fuchsia = 0xFF00FF, // rgb(255,0,255)
gainsboro = 0xDCDCDC, // rgb(220,220,220) gainsboro = 0xDCDCDC, // rgb(220,220,220)
ghost_white = 0xF8F8FF, // rgb(248,248,255) ghost_white = 0xF8F8FF, // rgb(248,248,255)
gold = 0xFFD700, // rgb(255,215,0) gold = 0xFFD700, // rgb(255,215,0)
golden_rod = 0xDAA520, // rgb(218,165,32) golden_rod = 0xDAA520, // rgb(218,165,32)
gray = 0x808080, // rgb(128,128,128) gray = 0x808080, // rgb(128,128,128)
green = 0x008000, // rgb(0,128,0) green = 0x008000, // rgb(0,128,0)
green_yellow = 0xADFF2F, // rgb(173,255,47) green_yellow = 0xADFF2F, // rgb(173,255,47)
honey_dew = 0xF0FFF0, // rgb(240,255,240) honey_dew = 0xF0FFF0, // rgb(240,255,240)
hot_pink = 0xFF69B4, // rgb(255,105,180) hot_pink = 0xFF69B4, // rgb(255,105,180)
indian_red = 0xCD5C5C, // rgb(205,92,92) indian_red = 0xCD5C5C, // rgb(205,92,92)
indigo = 0x4B0082, // rgb(75,0,130) indigo = 0x4B0082, // rgb(75,0,130)
ivory = 0xFFFFF0, // rgb(255,255,240) ivory = 0xFFFFF0, // rgb(255,255,240)
khaki = 0xF0E68C, // rgb(240,230,140) khaki = 0xF0E68C, // rgb(240,230,140)
lavender = 0xE6E6FA, // rgb(230,230,250) lavender = 0xE6E6FA, // rgb(230,230,250)
lavender_blush = 0xFFF0F5, // rgb(255,240,245) lavender_blush = 0xFFF0F5, // rgb(255,240,245)
lawn_green = 0x7CFC00, // rgb(124,252,0) lawn_green = 0x7CFC00, // rgb(124,252,0)
lemon_chiffon = 0xFFFACD, // rgb(255,250,205) lemon_chiffon = 0xFFFACD, // rgb(255,250,205)
light_blue = 0xADD8E6, // rgb(173,216,230) light_blue = 0xADD8E6, // rgb(173,216,230)
light_coral = 0xF08080, // rgb(240,128,128) light_coral = 0xF08080, // rgb(240,128,128)
light_cyan = 0xE0FFFF, // rgb(224,255,255) light_cyan = 0xE0FFFF, // rgb(224,255,255)
light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210) light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210)
light_gray = 0xD3D3D3, // rgb(211,211,211) light_gray = 0xD3D3D3, // rgb(211,211,211)
light_green = 0x90EE90, // rgb(144,238,144) light_green = 0x90EE90, // rgb(144,238,144)
light_pink = 0xFFB6C1, // rgb(255,182,193) light_pink = 0xFFB6C1, // rgb(255,182,193)
light_salmon = 0xFFA07A, // rgb(255,160,122) light_salmon = 0xFFA07A, // rgb(255,160,122)
light_sea_green = 0x20B2AA, // rgb(32,178,170) light_sea_green = 0x20B2AA, // rgb(32,178,170)
light_sky_blue = 0x87CEFA, // rgb(135,206,250) light_sky_blue = 0x87CEFA, // rgb(135,206,250)
light_slate_gray = 0x778899, // rgb(119,136,153) light_slate_gray = 0x778899, // rgb(119,136,153)
light_steel_blue = 0xB0C4DE, // rgb(176,196,222) light_steel_blue = 0xB0C4DE, // rgb(176,196,222)
light_yellow = 0xFFFFE0, // rgb(255,255,224) light_yellow = 0xFFFFE0, // rgb(255,255,224)
lime = 0x00FF00, // rgb(0,255,0) lime = 0x00FF00, // rgb(0,255,0)
lime_green = 0x32CD32, // rgb(50,205,50) lime_green = 0x32CD32, // rgb(50,205,50)
linen = 0xFAF0E6, // rgb(250,240,230) linen = 0xFAF0E6, // rgb(250,240,230)
magenta = 0xFF00FF, // rgb(255,0,255) magenta = 0xFF00FF, // rgb(255,0,255)
maroon = 0x800000, // rgb(128,0,0) maroon = 0x800000, // rgb(128,0,0)
medium_aquamarine = 0x66CDAA, // rgb(102,205,170) medium_aquamarine = 0x66CDAA, // rgb(102,205,170)
medium_blue = 0x0000CD, // rgb(0,0,205) medium_blue = 0x0000CD, // rgb(0,0,205)
medium_orchid = 0xBA55D3, // rgb(186,85,211) medium_orchid = 0xBA55D3, // rgb(186,85,211)
medium_purple = 0x9370DB, // rgb(147,112,219) medium_purple = 0x9370DB, // rgb(147,112,219)
medium_sea_green = 0x3CB371, // rgb(60,179,113) medium_sea_green = 0x3CB371, // rgb(60,179,113)
medium_slate_blue = 0x7B68EE, // rgb(123,104,238) medium_slate_blue = 0x7B68EE, // rgb(123,104,238)
medium_spring_green = 0x00FA9A, // rgb(0,250,154) medium_spring_green = 0x00FA9A, // rgb(0,250,154)
medium_turquoise = 0x48D1CC, // rgb(72,209,204) medium_turquoise = 0x48D1CC, // rgb(72,209,204)
medium_violet_red = 0xC71585, // rgb(199,21,133) medium_violet_red = 0xC71585, // rgb(199,21,133)
midnight_blue = 0x191970, // rgb(25,25,112) midnight_blue = 0x191970, // rgb(25,25,112)
mint_cream = 0xF5FFFA, // rgb(245,255,250) mint_cream = 0xF5FFFA, // rgb(245,255,250)
misty_rose = 0xFFE4E1, // rgb(255,228,225) misty_rose = 0xFFE4E1, // rgb(255,228,225)
moccasin = 0xFFE4B5, // rgb(255,228,181) moccasin = 0xFFE4B5, // rgb(255,228,181)
navajo_white = 0xFFDEAD, // rgb(255,222,173) navajo_white = 0xFFDEAD, // rgb(255,222,173)
navy = 0x000080, // rgb(0,0,128) navy = 0x000080, // rgb(0,0,128)
old_lace = 0xFDF5E6, // rgb(253,245,230) old_lace = 0xFDF5E6, // rgb(253,245,230)
olive = 0x808000, // rgb(128,128,0) olive = 0x808000, // rgb(128,128,0)
olive_drab = 0x6B8E23, // rgb(107,142,35) olive_drab = 0x6B8E23, // rgb(107,142,35)
orange = 0xFFA500, // rgb(255,165,0) orange = 0xFFA500, // rgb(255,165,0)
orange_red = 0xFF4500, // rgb(255,69,0) orange_red = 0xFF4500, // rgb(255,69,0)
orchid = 0xDA70D6, // rgb(218,112,214) orchid = 0xDA70D6, // rgb(218,112,214)
pale_golden_rod = 0xEEE8AA, // rgb(238,232,170) pale_golden_rod = 0xEEE8AA, // rgb(238,232,170)
pale_green = 0x98FB98, // rgb(152,251,152) pale_green = 0x98FB98, // rgb(152,251,152)
pale_turquoise = 0xAFEEEE, // rgb(175,238,238) pale_turquoise = 0xAFEEEE, // rgb(175,238,238)
pale_violet_red = 0xDB7093, // rgb(219,112,147) pale_violet_red = 0xDB7093, // rgb(219,112,147)
papaya_whip = 0xFFEFD5, // rgb(255,239,213) papaya_whip = 0xFFEFD5, // rgb(255,239,213)
peach_puff = 0xFFDAB9, // rgb(255,218,185) peach_puff = 0xFFDAB9, // rgb(255,218,185)
peru = 0xCD853F, // rgb(205,133,63) peru = 0xCD853F, // rgb(205,133,63)
pink = 0xFFC0CB, // rgb(255,192,203) pink = 0xFFC0CB, // rgb(255,192,203)
plum = 0xDDA0DD, // rgb(221,160,221) plum = 0xDDA0DD, // rgb(221,160,221)
powder_blue = 0xB0E0E6, // rgb(176,224,230) powder_blue = 0xB0E0E6, // rgb(176,224,230)
purple = 0x800080, // rgb(128,0,128) purple = 0x800080, // rgb(128,0,128)
rebecca_purple = 0x663399, // rgb(102,51,153) rebecca_purple = 0x663399, // rgb(102,51,153)
red = 0xFF0000, // rgb(255,0,0) red = 0xFF0000, // rgb(255,0,0)
rosy_brown = 0xBC8F8F, // rgb(188,143,143) rosy_brown = 0xBC8F8F, // rgb(188,143,143)
royal_blue = 0x4169E1, // rgb(65,105,225) royal_blue = 0x4169E1, // rgb(65,105,225)
saddle_brown = 0x8B4513, // rgb(139,69,19) saddle_brown = 0x8B4513, // rgb(139,69,19)
salmon = 0xFA8072, // rgb(250,128,114) salmon = 0xFA8072, // rgb(250,128,114)
sandy_brown = 0xF4A460, // rgb(244,164,96) sandy_brown = 0xF4A460, // rgb(244,164,96)
sea_green = 0x2E8B57, // rgb(46,139,87) sea_green = 0x2E8B57, // rgb(46,139,87)
sea_shell = 0xFFF5EE, // rgb(255,245,238) sea_shell = 0xFFF5EE, // rgb(255,245,238)
sienna = 0xA0522D, // rgb(160,82,45) sienna = 0xA0522D, // rgb(160,82,45)
silver = 0xC0C0C0, // rgb(192,192,192) silver = 0xC0C0C0, // rgb(192,192,192)
sky_blue = 0x87CEEB, // rgb(135,206,235) sky_blue = 0x87CEEB, // rgb(135,206,235)
slate_blue = 0x6A5ACD, // rgb(106,90,205) slate_blue = 0x6A5ACD, // rgb(106,90,205)
slate_gray = 0x708090, // rgb(112,128,144) slate_gray = 0x708090, // rgb(112,128,144)
snow = 0xFFFAFA, // rgb(255,250,250) snow = 0xFFFAFA, // rgb(255,250,250)
spring_green = 0x00FF7F, // rgb(0,255,127) spring_green = 0x00FF7F, // rgb(0,255,127)
steel_blue = 0x4682B4, // rgb(70,130,180) steel_blue = 0x4682B4, // rgb(70,130,180)
tan = 0xD2B48C, // rgb(210,180,140) tan = 0xD2B48C, // rgb(210,180,140)
teal = 0x008080, // rgb(0,128,128) teal = 0x008080, // rgb(0,128,128)
thistle = 0xD8BFD8, // rgb(216,191,216) thistle = 0xD8BFD8, // rgb(216,191,216)
tomato = 0xFF6347, // rgb(255,99,71) tomato = 0xFF6347, // rgb(255,99,71)
turquoise = 0x40E0D0, // rgb(64,224,208) turquoise = 0x40E0D0, // rgb(64,224,208)
violet = 0xEE82EE, // rgb(238,130,238) violet = 0xEE82EE, // rgb(238,130,238)
wheat = 0xF5DEB3, // rgb(245,222,179) wheat = 0xF5DEB3, // rgb(245,222,179)
white = 0xFFFFFF, // rgb(255,255,255) white = 0xFFFFFF, // rgb(255,255,255)
white_smoke = 0xF5F5F5, // rgb(245,245,245) white_smoke = 0xF5F5F5, // rgb(245,245,245)
yellow = 0xFFFF00, // rgb(255,255,0) yellow = 0xFFFF00, // rgb(255,255,0)
yellow_green = 0x9ACD32 // rgb(154,205,50) yellow_green = 0x9ACD32 // rgb(154,205,50)
}; // enum class color }; // enum class color
enum class terminal_color : uint8_t { enum class terminal_color : uint8_t {
black = 30, black = 30,
@ -223,12 +223,13 @@ enum class emphasis : uint8_t {
struct rgb { struct rgb {
FMT_CONSTEXPR_DECL rgb() : r(0), g(0), b(0) {} FMT_CONSTEXPR_DECL rgb() : r(0), g(0), b(0) {}
FMT_CONSTEXPR_DECL rgb(uint8_t r_, uint8_t g_, uint8_t b_) FMT_CONSTEXPR_DECL rgb(uint8_t r_, uint8_t g_, uint8_t b_)
: r(r_), g(g_), b(b_) {} : r(r_), g(g_), b(b_) {}
FMT_CONSTEXPR_DECL rgb(uint32_t hex) FMT_CONSTEXPR_DECL rgb(uint32_t hex)
: r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b((hex) & 0xFF) {} : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b((hex)&0xFF) {}
FMT_CONSTEXPR_DECL rgb(color hex) FMT_CONSTEXPR_DECL rgb(color hex)
: r((uint32_t(hex) >> 16) & 0xFF), g((uint32_t(hex) >> 8) & 0xFF), : r((uint32_t(hex) >> 16) & 0xFF),
b(uint32_t(hex) & 0xFF) {} g((uint32_t(hex) >> 8) & 0xFF),
b(uint32_t(hex) & 0xFF) {}
uint8_t r; uint8_t r;
uint8_t g; uint8_t g;
uint8_t b; uint8_t b;
@ -238,19 +239,17 @@ namespace internal {
// color is a struct of either a rgb color or a terminal color. // color is a struct of either a rgb color or a terminal color.
struct color_type { struct color_type {
FMT_CONSTEXPR color_type() FMT_NOEXCEPT FMT_CONSTEXPR color_type() FMT_NOEXCEPT : is_rgb(), value{} {}
: is_rgb(), value{} {} FMT_CONSTEXPR color_type(color rgb_color) FMT_NOEXCEPT : is_rgb(true),
FMT_CONSTEXPR color_type(color rgb_color) FMT_NOEXCEPT value{} {
: is_rgb(true), value{} {
value.rgb_color = static_cast<uint32_t>(rgb_color); value.rgb_color = static_cast<uint32_t>(rgb_color);
} }
FMT_CONSTEXPR color_type(rgb rgb_color) FMT_NOEXCEPT FMT_CONSTEXPR color_type(rgb rgb_color) FMT_NOEXCEPT : is_rgb(true), value{} {
: is_rgb(true), value{} { value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16) |
value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16) (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
| (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
} }
FMT_CONSTEXPR color_type(terminal_color term_color) FMT_NOEXCEPT FMT_CONSTEXPR color_type(terminal_color term_color) FMT_NOEXCEPT : is_rgb(),
: is_rgb(), value{} { value{} {
value.term_color = static_cast<uint8_t>(term_color); value.term_color = static_cast<uint8_t>(term_color);
} }
bool is_rgb; bool is_rgb;
@ -259,13 +258,15 @@ struct color_type {
uint32_t rgb_color; uint32_t rgb_color;
} value; } value;
}; };
} // namespace internal } // namespace internal
// Experimental text formatting support. // Experimental text formatting support.
class text_style { class text_style {
public: public:
FMT_CONSTEXPR text_style(emphasis em = emphasis()) FMT_NOEXCEPT FMT_CONSTEXPR text_style(emphasis em = emphasis()) FMT_NOEXCEPT
: set_foreground_color(), set_background_color(), ems(em) {} : set_foreground_color(),
set_background_color(),
ems(em) {}
FMT_CONSTEXPR text_style &operator|=(const text_style &rhs) { FMT_CONSTEXPR text_style &operator|=(const text_style &rhs) {
if (!set_foreground_color) { if (!set_foreground_color) {
@ -291,8 +292,8 @@ class text_style {
return *this; return *this;
} }
friend FMT_CONSTEXPR friend FMT_CONSTEXPR text_style operator|(text_style lhs,
text_style operator|(text_style lhs, const text_style &rhs) { const text_style &rhs) {
return lhs |= rhs; return lhs |= rhs;
} }
@ -320,8 +321,8 @@ class text_style {
return *this; return *this;
} }
friend FMT_CONSTEXPR friend FMT_CONSTEXPR text_style operator&(text_style lhs,
text_style operator&(text_style lhs, const text_style &rhs) { const text_style &rhs) {
return lhs &= rhs; return lhs &= rhs;
} }
@ -347,20 +348,20 @@ class text_style {
return ems; return ems;
} }
private: private:
FMT_CONSTEXPR text_style(bool is_foreground, FMT_CONSTEXPR text_style(bool is_foreground,
internal::color_type text_color) FMT_NOEXCEPT internal::color_type text_color) FMT_NOEXCEPT
: set_foreground_color(), : set_foreground_color(),
set_background_color(), set_background_color(),
ems() { ems() {
if (is_foreground) { if (is_foreground) {
foreground_color = text_color; foreground_color = text_color;
set_foreground_color = true; set_foreground_color = true;
} else { } else {
background_color = text_color; background_color = text_color;
set_background_color = true; set_background_color = true;
} }
} }
friend FMT_CONSTEXPR_DECL text_style fg(internal::color_type foreground) friend FMT_CONSTEXPR_DECL text_style fg(internal::color_type foreground)
FMT_NOEXCEPT; FMT_NOEXCEPT;
@ -391,7 +392,7 @@ namespace internal {
template <typename Char> template <typename Char>
struct ansi_color_escape { struct ansi_color_escape {
FMT_CONSTEXPR ansi_color_escape(internal::color_type text_color, FMT_CONSTEXPR ansi_color_escape(internal::color_type text_color,
const char * esc) FMT_NOEXCEPT { const char *esc) FMT_NOEXCEPT {
// If we have a terminal color, we need to output another escape code // If we have a terminal color, we need to output another escape code
// sequence. // sequence.
if (!text_color.is_rgb) { if (!text_color.is_rgb) {
@ -399,8 +400,7 @@ struct ansi_color_escape {
uint32_t value = text_color.value.term_color; uint32_t value = text_color.value.term_color;
// Background ASCII codes are the same as the foreground ones but with // Background ASCII codes are the same as the foreground ones but with
// 10 more. // 10 more.
if (is_background) if (is_background) value += 10u;
value += 10u;
std::size_t index = 0; std::size_t index = 0;
buffer[index++] = static_cast<Char>('\x1b'); buffer[index++] = static_cast<Char>('\x1b');
@ -422,7 +422,7 @@ struct ansi_color_escape {
buffer[i] = static_cast<Char>(esc[i]); buffer[i] = static_cast<Char>(esc[i]);
} }
rgb color(text_color.value.rgb_color); rgb color(text_color.value.rgb_color);
to_esc(color.r, buffer + 7, ';'); to_esc(color.r, buffer + 7, ';');
to_esc(color.g, buffer + 11, ';'); to_esc(color.g, buffer + 11, ';');
to_esc(color.b, buffer + 15, 'm'); to_esc(color.b, buffer + 15, 'm');
buffer[19] = static_cast<Char>(0); buffer[19] = static_cast<Char>(0);
@ -430,19 +430,15 @@ struct ansi_color_escape {
FMT_CONSTEXPR ansi_color_escape(emphasis em) FMT_NOEXCEPT { FMT_CONSTEXPR ansi_color_escape(emphasis em) FMT_NOEXCEPT {
uint8_t em_codes[4] = {}; uint8_t em_codes[4] = {};
uint8_t em_bits = static_cast<uint8_t>(em); uint8_t em_bits = static_cast<uint8_t>(em);
if (em_bits & static_cast<uint8_t>(emphasis::bold)) if (em_bits & static_cast<uint8_t>(emphasis::bold)) em_codes[0] = 1;
em_codes[0] = 1; if (em_bits & static_cast<uint8_t>(emphasis::italic)) em_codes[1] = 3;
if (em_bits & static_cast<uint8_t>(emphasis::italic)) if (em_bits & static_cast<uint8_t>(emphasis::underline)) em_codes[2] = 4;
em_codes[1] = 3;
if (em_bits & static_cast<uint8_t>(emphasis::underline))
em_codes[2] = 4;
if (em_bits & static_cast<uint8_t>(emphasis::strikethrough)) if (em_bits & static_cast<uint8_t>(emphasis::strikethrough))
em_codes[3] = 9; em_codes[3] = 9;
std::size_t index = 0; std::size_t index = 0;
for (int i = 0; i < 4; ++i) { for (int i = 0; i < 4; ++i) {
if (!em_codes[i]) if (!em_codes[i]) continue;
continue;
buffer[index++] = static_cast<Char>('\x1b'); buffer[index++] = static_cast<Char>('\x1b');
buffer[index++] = static_cast<Char>('['); buffer[index++] = static_cast<Char>('[');
buffer[index++] = static_cast<Char>('0' + em_codes[i]); buffer[index++] = static_cast<Char>('0' + em_codes[i]);
@ -452,7 +448,7 @@ struct ansi_color_escape {
} }
FMT_CONSTEXPR operator const Char *() const FMT_NOEXCEPT { return buffer; } FMT_CONSTEXPR operator const Char *() const FMT_NOEXCEPT { return buffer; }
private: private:
Char buffer[7u + 3u * 4u + 1u]; Char buffer[7u + 3u * 4u + 1u];
static FMT_CONSTEXPR void to_esc(uint8_t c, Char *out, static FMT_CONSTEXPR void to_esc(uint8_t c, Char *out,
@ -465,20 +461,19 @@ private:
}; };
template <typename Char> template <typename Char>
FMT_CONSTEXPR ansi_color_escape<Char> FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color(
make_foreground_color(internal::color_type foreground) FMT_NOEXCEPT { internal::color_type foreground) FMT_NOEXCEPT {
return ansi_color_escape<Char>(foreground, internal::data::FOREGROUND_COLOR); return ansi_color_escape<Char>(foreground, internal::data::FOREGROUND_COLOR);
} }
template <typename Char> template <typename Char>
FMT_CONSTEXPR ansi_color_escape<Char> FMT_CONSTEXPR ansi_color_escape<Char> make_background_color(
make_background_color(internal::color_type background) FMT_NOEXCEPT { internal::color_type background) FMT_NOEXCEPT {
return ansi_color_escape<Char>(background, internal::data::BACKGROUND_COLOR); return ansi_color_escape<Char>(background, internal::data::BACKGROUND_COLOR);
} }
template <typename Char> template <typename Char>
FMT_CONSTEXPR ansi_color_escape<Char> FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) FMT_NOEXCEPT {
make_emphasis(emphasis em) FMT_NOEXCEPT {
return ansi_color_escape<Char>(em); return ansi_color_escape<Char>(em);
} }
@ -510,22 +505,20 @@ template <>
struct is_string<std::FILE *> : std::false_type {}; struct is_string<std::FILE *> : std::false_type {};
template <> template <>
struct is_string<const std::FILE *> : std::false_type {}; struct is_string<const std::FILE *> : std::false_type {};
} // namespace internal } // namespace internal
template < template <typename S, typename Char = typename internal::char_t<S>::type>
typename S, typename Char = typename internal::char_t<S>::type>
void vprint(std::FILE *f, const text_style &ts, const S &format, void vprint(std::FILE *f, const text_style &ts, const S &format,
basic_format_args<typename buffer_context<Char>::type> args) { basic_format_args<typename buffer_context<Char>::type> args) {
bool has_style = false; bool has_style = false;
if (ts.has_emphasis()) { if (ts.has_emphasis()) {
has_style = true; has_style = true;
internal::fputs<Char>( internal::fputs<Char>(internal::make_emphasis<Char>(ts.get_emphasis()), f);
internal::make_emphasis<Char>(ts.get_emphasis()), f);
} }
if (ts.has_foreground()) { if (ts.has_foreground()) {
has_style = true; has_style = true;
internal::fputs<Char>( internal::fputs<Char>(
internal::make_foreground_color<Char>(ts.get_foreground()), f); internal::make_foreground_color<Char>(ts.get_foreground()), f);
} }
if (ts.has_background()) { if (ts.has_background()) {
has_style = true; has_style = true;
@ -565,8 +558,7 @@ typename std::enable_if<internal::is_string<String>::value>::type print(
*/ */
template <typename String, typename... Args> template <typename String, typename... Args>
typename std::enable_if<internal::is_string<String>::value>::type print( typename std::enable_if<internal::is_string<String>::value>::type print(
const text_style &ts, const String &format_str, const text_style &ts, const String &format_str, const Args &... args) {
const Args &... args) {
return print(stdout, ts, format_str, args...); return print(stdout, ts, format_str, args...);
} }

657
src/cpp/include/deps/spdlog/fmt/bundled/core.h Executable file → Normal file
View File

File diff suppressed because it is too large Load Diff

489
src/cpp/include/deps/spdlog/fmt/bundled/format-inl.h Executable file → Normal file
View File

@ -8,8 +8,6 @@
#ifndef FMT_FORMAT_INL_H_ #ifndef FMT_FORMAT_INL_H_
#define FMT_FORMAT_INL_H_ #define FMT_FORMAT_INL_H_
#include "format.h"
#include <string.h> #include <string.h>
#include <cctype> #include <cctype>
@ -19,38 +17,40 @@
#include <cstdarg> #include <cstdarg>
#include <cstddef> // for std::ptrdiff_t #include <cstddef> // for std::ptrdiff_t
#include <cstring> // for std::memmove #include <cstring> // for std::memmove
#include "format.h"
#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR) #if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
# include <locale> #include <locale>
#endif #endif
#if FMT_USE_WINDOWS_H #if FMT_USE_WINDOWS_H
# if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN) #if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN)
# define WIN32_LEAN_AND_MEAN #define WIN32_LEAN_AND_MEAN
# endif #endif
# if defined(NOMINMAX) || defined(FMT_WIN_MINMAX) #if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)
# include <windows.h> #include <windows.h>
# else #else
# define NOMINMAX #define NOMINMAX
# include <windows.h> #include <windows.h>
# undef NOMINMAX #undef NOMINMAX
# endif #endif
#endif #endif
#if FMT_EXCEPTIONS #if FMT_EXCEPTIONS
# define FMT_TRY try #define FMT_TRY try
# define FMT_CATCH(x) catch (x) #define FMT_CATCH(x) catch (x)
#else #else
# define FMT_TRY if (true) #define FMT_TRY if (true)
# define FMT_CATCH(x) if (false) #define FMT_CATCH(x) if (false)
#endif #endif
#ifdef _MSC_VER #ifdef _MSC_VER
# pragma warning(push) #pragma warning(push)
# pragma warning(disable: 4127) // conditional expression is constant #pragma warning(disable : 4127) // conditional expression is constant
# pragma warning(disable: 4702) // unreachable code #pragma warning(disable : 4702) // unreachable code
// Disable deprecation warning for strerror. The latter is not called but // Disable deprecation warning for strerror. The latter is not called but
// MSVC fails to detect it. // MSVC fails to detect it.
# pragma warning(disable: 4996) #pragma warning(disable : 4996)
#endif #endif
// Dummy implementations of strerror_r and strerror_s called if corresponding // Dummy implementations of strerror_r and strerror_s called if corresponding
@ -67,7 +67,7 @@ FMT_BEGIN_NAMESPACE
namespace { namespace {
#ifndef _MSC_VER #ifndef _MSC_VER
# define FMT_SNPRINTF snprintf #define FMT_SNPRINTF snprintf
#else // _MSC_VER #else // _MSC_VER
inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) { inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) {
va_list args; va_list args;
@ -76,14 +76,14 @@ inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) {
va_end(args); va_end(args);
return result; return result;
} }
# define FMT_SNPRINTF fmt_snprintf #define FMT_SNPRINTF fmt_snprintf
#endif // _MSC_VER #endif // _MSC_VER
#if defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT) #if defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
# define FMT_SWPRINTF snwprintf #define FMT_SWPRINTF snwprintf
#else #else
# define FMT_SWPRINTF swprintf #define FMT_SWPRINTF swprintf
#endif // defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT) #endif // defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
typedef void (*FormatFunc)(internal::buffer &, int, string_view); typedef void (*FormatFunc)(internal::buffer &, int, string_view);
@ -96,8 +96,8 @@ typedef void (*FormatFunc)(internal::buffer &, int, string_view);
// ERANGE - buffer is not large enough to store the error message // ERANGE - buffer is not large enough to store the error message
// other - failure // other - failure
// Buffer should be at least of size 1. // Buffer should be at least of size 1.
int safe_strerror( int safe_strerror(int error_code, char *&buffer,
int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT { std::size_t buffer_size) FMT_NOEXCEPT {
FMT_ASSERT(buffer != FMT_NULL && buffer_size != 0, "invalid buffer"); FMT_ASSERT(buffer != FMT_NULL && buffer_size != 0, "invalid buffer");
class dispatcher { class dispatcher {
@ -132,8 +132,8 @@ int safe_strerror(
// Fallback to strerror_s when strerror_r is not available. // Fallback to strerror_s when strerror_r is not available.
int fallback(int result) { int fallback(int result) {
// If the buffer is full then the message is probably truncated. // If the buffer is full then the message is probably truncated.
return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? ERANGE
ERANGE : result; : result;
} }
#if !FMT_MSC_VER #if !FMT_MSC_VER
@ -147,11 +147,9 @@ int safe_strerror(
public: public:
dispatcher(int err_code, char *&buf, std::size_t buf_size) dispatcher(int err_code, char *&buf, std::size_t buf_size)
: error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {} : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
int run() { int run() { return handle(strerror_r(error_code_, buffer_, buffer_size_)); }
return handle(strerror_r(error_code_, buffer_, buffer_size_));
}
}; };
return dispatcher(error_code, buffer, buffer_size).run(); return dispatcher(error_code, buffer, buffer_size).run();
} }
@ -198,8 +196,7 @@ FMT_FUNC size_t internal::count_code_points(basic_string_view<char8_t> s) {
const char8_t *data = s.data(); const char8_t *data = s.data();
size_t num_code_points = 0; size_t num_code_points = 0;
for (size_t i = 0, size = s.size(); i != size; ++i) { for (size_t i = 0, size = s.size(); i != size; ++i) {
if ((data[i] & 0xc0) != 0x80) if ((data[i] & 0xc0) != 0x80) ++num_code_points;
++num_code_points;
} }
return num_code_points; return num_code_points;
} }
@ -215,15 +212,15 @@ locale_ref::locale_ref(const Locale &loc) : locale_(&loc) {
template <typename Locale> template <typename Locale>
Locale locale_ref::get() const { Locale locale_ref::get() const {
static_assert(std::is_same<Locale, std::locale>::value, ""); static_assert(std::is_same<Locale, std::locale>::value, "");
return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale(); return locale_ ? *static_cast<const std::locale *>(locale_) : std::locale();
} }
template <typename Char> template <typename Char>
FMT_FUNC Char thousands_sep_impl(locale_ref loc) { FMT_FUNC Char thousands_sep_impl(locale_ref loc) {
return std::use_facet<std::numpunct<Char> >( return std::use_facet<std::numpunct<Char> >(loc.get<std::locale>())
loc.get<std::locale>()).thousands_sep(); .thousands_sep();
}
} }
} // namespace internal
#else #else
template <typename Char> template <typename Char>
FMT_FUNC Char internal::thousands_sep_impl(locale_ref) { FMT_FUNC Char internal::thousands_sep_impl(locale_ref) {
@ -231,8 +228,8 @@ FMT_FUNC Char internal::thousands_sep_impl(locale_ref) {
} }
#endif #endif
FMT_FUNC void system_error::init( FMT_FUNC void system_error::init(int err_code, string_view format_str,
int err_code, string_view format_str, format_args args) { format_args args) {
error_code_ = err_code; error_code_ = err_code;
memory_buffer buffer; memory_buffer buffer;
format_system_error(buffer, err_code, vformat(format_str, args)); format_system_error(buffer, err_code, vformat(format_str, args));
@ -242,20 +239,19 @@ FMT_FUNC void system_error::init(
namespace internal { namespace internal {
template <typename T> template <typename T>
int char_traits<char>::format_float( int char_traits<char>::format_float(char *buf, std::size_t size,
char *buf, std::size_t size, const char *format, int precision, T value) { const char *format, int precision,
return precision < 0 ? T value) {
FMT_SNPRINTF(buf, size, format, value) : return precision < 0 ? FMT_SNPRINTF(buf, size, format, value)
FMT_SNPRINTF(buf, size, format, precision, value); : FMT_SNPRINTF(buf, size, format, precision, value);
} }
template <typename T> template <typename T>
int char_traits<wchar_t>::format_float( int char_traits<wchar_t>::format_float(wchar_t *buf, std::size_t size,
wchar_t *buf, std::size_t size, const wchar_t *format, int precision, const wchar_t *format, int precision,
T value) { T value) {
return precision < 0 ? return precision < 0 ? FMT_SWPRINTF(buf, size, format, value)
FMT_SWPRINTF(buf, size, format, value) : : FMT_SWPRINTF(buf, size, format, precision, value);
FMT_SWPRINTF(buf, size, format, precision, value);
} }
template <typename T> template <typename T>
@ -266,88 +262,79 @@ const char basic_data<T>::DIGITS[] =
"6061626364656667686970717273747576777879" "6061626364656667686970717273747576777879"
"8081828384858687888990919293949596979899"; "8081828384858687888990919293949596979899";
#define FMT_POWERS_OF_10(factor) \ #define FMT_POWERS_OF_10(factor) \
factor * 10, \ factor * 10, factor * 100, factor * 1000, factor * 10000, factor * 100000, \
factor * 100, \ factor * 1000000, factor * 10000000, factor * 100000000, \
factor * 1000, \ factor * 1000000000
factor * 10000, \
factor * 100000, \
factor * 1000000, \
factor * 10000000, \
factor * 100000000, \
factor * 1000000000
template <typename T> template <typename T>
const uint32_t basic_data<T>::POWERS_OF_10_32[] = { const uint32_t basic_data<T>::POWERS_OF_10_32[] = {1, FMT_POWERS_OF_10(1)};
1, FMT_POWERS_OF_10(1)
};
template <typename T> template <typename T>
const uint32_t basic_data<T>::ZERO_OR_POWERS_OF_10_32[] = { const uint32_t basic_data<T>::ZERO_OR_POWERS_OF_10_32[] = {0,
0, FMT_POWERS_OF_10(1) FMT_POWERS_OF_10(1)};
};
template <typename T> template <typename T>
const uint64_t basic_data<T>::ZERO_OR_POWERS_OF_10_64[] = { const uint64_t basic_data<T>::ZERO_OR_POWERS_OF_10_64[] = {
0, 0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ull),
FMT_POWERS_OF_10(1), 10000000000000000000ull};
FMT_POWERS_OF_10(1000000000ull),
10000000000000000000ull
};
// Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340. // Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
// These are generated by support/compute-powers.py. // These are generated by support/compute-powers.py.
template <typename T> template <typename T>
const uint64_t basic_data<T>::POW10_SIGNIFICANDS[] = { const uint64_t basic_data<T>::POW10_SIGNIFICANDS[] = {
0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76, 0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76,
0xcf42894a5dce35ea, 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df, 0xcf42894a5dce35ea, 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df,
0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c, 0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c,
0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5, 0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57, 0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57,
0xc21094364dfb5637, 0x9096ea6f3848984f, 0xd77485cb25823ac7, 0xc21094364dfb5637, 0x9096ea6f3848984f, 0xd77485cb25823ac7,
0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e, 0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e,
0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996, 0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126, 0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126,
0xb5b5ada8aaff80b8, 0x87625f056c7c4a8b, 0xc9bcff6034c13053, 0xb5b5ada8aaff80b8, 0x87625f056c7c4a8b, 0xc9bcff6034c13053,
0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f, 0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f,
0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b, 0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06, 0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06,
0xaa242499697392d3, 0xfd87b5f28300ca0e, 0xbce5086492111aeb, 0xaa242499697392d3, 0xfd87b5f28300ca0e, 0xbce5086492111aeb,
0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000, 0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000,
0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984, 0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068, 0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068,
0x9f4f2726179a2245, 0xed63a231d4c4fb27, 0xb0de65388cc8ada8, 0x9f4f2726179a2245, 0xed63a231d4c4fb27, 0xb0de65388cc8ada8,
0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758, 0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758,
0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85, 0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d, 0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d,
0x952ab45cfa97a0b3, 0xde469fbd99a05fe3, 0xa59bc234db398c25, 0x952ab45cfa97a0b3, 0xde469fbd99a05fe3, 0xa59bc234db398c25,
0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2, 0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2,
0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a, 0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410, 0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410,
0x8bab8eefb6409c1a, 0xd01fef10a657842c, 0x9b10a4e5e9913129, 0x8bab8eefb6409c1a, 0xd01fef10a657842c, 0x9b10a4e5e9913129,
0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85, 0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85,
0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841, 0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b, 0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b,
}; };
// Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding // Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
// to significands above. // to significands above.
template <typename T> template <typename T>
const int16_t basic_data<T>::POW10_EXPONENTS[] = { const int16_t basic_data<T>::POW10_EXPONENTS[] = {
-1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954, -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954,
-927, -901, -874, -847, -821, -794, -768, -741, -715, -688, -661, -927, -901, -874, -847, -821, -794, -768, -741, -715, -688, -661,
-635, -608, -582, -555, -529, -502, -475, -449, -422, -396, -369, -635, -608, -582, -555, -529, -502, -475, -449, -422, -396, -369,
-343, -316, -289, -263, -236, -210, -183, -157, -130, -103, -77, -343, -316, -289, -263, -236, -210, -183, -157, -130, -103, -77,
-50, -24, 3, 30, 56, 83, 109, 136, 162, 189, 216, -50, -24, 3, 30, 56, 83, 109, 136, 162, 189, 216,
242, 269, 295, 322, 348, 375, 402, 428, 455, 481, 508, 242, 269, 295, 322, 348, 375, 402, 428, 455, 481, 508,
534, 561, 588, 614, 641, 667, 694, 720, 747, 774, 800, 534, 561, 588, 614, 641, 667, 694, 720, 747, 774, 800,
827, 853, 880, 907, 933, 960, 986, 1013, 1039, 1066 827, 853, 880, 907, 933, 960, 986, 1013, 1039, 1066};
};
template <typename T> const char basic_data<T>::FOREGROUND_COLOR[] = "\x1b[38;2;"; template <typename T>
template <typename T> const char basic_data<T>::BACKGROUND_COLOR[] = "\x1b[48;2;"; const char basic_data<T>::FOREGROUND_COLOR[] = "\x1b[38;2;";
template <typename T> const char basic_data<T>::RESET_COLOR[] = "\x1b[0m"; template <typename T>
template <typename T> const wchar_t basic_data<T>::WRESET_COLOR[] = L"\x1b[0m"; const char basic_data<T>::BACKGROUND_COLOR[] = "\x1b[48;2;";
template <typename T>
const char basic_data<T>::RESET_COLOR[] = "\x1b[0m";
template <typename T>
const wchar_t basic_data<T>::WRESET_COLOR[] = L"\x1b[0m";
// A handmade floating-point number f * pow(2, e). // A handmade floating-point number f * pow(2, e).
class fp { class fp {
@ -356,23 +343,23 @@ class fp {
// All sizes are in bits. // All sizes are in bits.
static FMT_CONSTEXPR_DECL const int char_size = static FMT_CONSTEXPR_DECL const int char_size =
std::numeric_limits<unsigned char>::digits; std::numeric_limits<unsigned char>::digits;
// Subtract 1 to account for an implicit most significant bit in the // Subtract 1 to account for an implicit most significant bit in the
// normalized form. // normalized form.
static FMT_CONSTEXPR_DECL const int double_significand_size = static FMT_CONSTEXPR_DECL const int double_significand_size =
std::numeric_limits<double>::digits - 1; std::numeric_limits<double>::digits - 1;
static FMT_CONSTEXPR_DECL const uint64_t implicit_bit = static FMT_CONSTEXPR_DECL const uint64_t implicit_bit =
1ull << double_significand_size; 1ull << double_significand_size;
public: public:
significand_type f; significand_type f;
int e; int e;
static FMT_CONSTEXPR_DECL const int significand_size = static FMT_CONSTEXPR_DECL const int significand_size =
sizeof(significand_type) * char_size; sizeof(significand_type) * char_size;
fp(): f(0), e(0) {} fp() : f(0), e(0) {}
fp(uint64_t f_val, int e_val): f(f_val), e(e_val) {} fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {}
// Constructs fp from an IEEE754 double. It is a template to prevent compile // Constructs fp from an IEEE754 double. It is a template to prevent compile
// errors on platforms where double is not IEEE754. // errors on platforms where double is not IEEE754.
@ -382,7 +369,7 @@ class fp {
typedef std::numeric_limits<Double> limits; typedef std::numeric_limits<Double> limits;
const int double_size = static_cast<int>(sizeof(Double) * char_size); const int double_size = static_cast<int>(sizeof(Double) * char_size);
const int exponent_size = const int exponent_size =
double_size - double_significand_size - 1; // -1 for sign double_size - double_significand_size - 1; // -1 for sign
const uint64_t significand_mask = implicit_bit - 1; const uint64_t significand_mask = implicit_bit - 1;
const uint64_t exponent_mask = (~0ull >> 1) & ~significand_mask; const uint64_t exponent_mask = (~0ull >> 1) & ~significand_mask;
const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1; const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1;
@ -416,8 +403,8 @@ class fp {
// (lower) or successor (upper). The upper boundary is normalized and lower // (lower) or successor (upper). The upper boundary is normalized and lower
// has the same exponent but may be not normalized. // has the same exponent but may be not normalized.
void compute_boundaries(fp &lower, fp &upper) const { void compute_boundaries(fp &lower, fp &upper) const {
lower = f == implicit_bit ? lower =
fp((f << 2) - 1, e - 2) : fp((f << 1) - 1, e - 1); f == implicit_bit ? fp((f << 2) - 1, e - 2) : fp((f << 1) - 1, e - 1);
upper = fp((f << 1) + 1, e - 1); upper = fp((f << 1) + 1, e - 1);
upper.normalize<1>(); // 1 is to account for the exponent shift above. upper.normalize<1>(); // 1 is to account for the exponent shift above.
lower.f <<= lower.e - upper.e; lower.f <<= lower.e - upper.e;
@ -432,7 +419,8 @@ inline fp operator-(fp x, fp y) {
} }
// Computes an fp number r with r.f = x.f * y.f / pow(2, 64) rounded to nearest // Computes an fp number r with r.f = x.f * y.f / pow(2, 64) rounded to nearest
// with half-up tie breaking, r.e = x.e + y.e + 64. Result may not be normalized. // with half-up tie breaking, r.e = x.e + y.e + 64. Result may not be
// normalized.
FMT_API fp operator*(fp x, fp y); FMT_API fp operator*(fp x, fp y);
// Returns cached power (of 10) c_k = c_k.f * pow(2, c_k.e) such that its // Returns cached power (of 10) c_k = c_k.f * pow(2, c_k.e) such that its
@ -452,8 +440,8 @@ FMT_FUNC fp operator*(fp x, fp y) {
FMT_FUNC fp get_cached_power(int min_exponent, int &pow10_exponent) { FMT_FUNC fp get_cached_power(int min_exponent, int &pow10_exponent) {
const double one_over_log2_10 = 0.30102999566398114; // 1 / log2(10) const double one_over_log2_10 = 0.30102999566398114; // 1 / log2(10)
int index = static_cast<int>(std::ceil( int index = static_cast<int>(
(min_exponent + fp::significand_size - 1) * one_over_log2_10)); std::ceil((min_exponent + fp::significand_size - 1) * one_over_log2_10));
// Decimal exponent of the first (smallest) cached power of 10. // Decimal exponent of the first (smallest) cached power of 10.
const int first_dec_exp = -348; const int first_dec_exp = -348;
// Difference between 2 consecutive decimal exponents in cached powers of 10. // Difference between 2 consecutive decimal exponents in cached powers of 10.
@ -463,55 +451,84 @@ FMT_FUNC fp get_cached_power(int min_exponent, int &pow10_exponent) {
return fp(data::POW10_SIGNIFICANDS[index], data::POW10_EXPONENTS[index]); return fp(data::POW10_SIGNIFICANDS[index], data::POW10_EXPONENTS[index]);
} }
FMT_FUNC bool grisu2_round( FMT_FUNC bool grisu2_round(char *buf, int &size, int max_digits, uint64_t delta,
char *buf, int &size, int max_digits, uint64_t delta, uint64_t remainder, uint64_t exp, uint64_t diff,
uint64_t remainder, uint64_t exp, uint64_t diff, int &exp10) { int &exp10) {
while (remainder < diff && delta - remainder >= exp && while (
(remainder + exp < diff || diff - remainder > remainder + exp - diff)) { remainder < diff && delta - remainder >= exp &&
(remainder + exp < diff || diff - remainder > remainder + exp - diff)) {
--buf[size - 1]; --buf[size - 1];
remainder += exp; remainder += exp;
} }
if (size > max_digits) { if (size > max_digits) {
--size; --size;
++exp10; ++exp10;
if (buf[size] >= '5') if (buf[size] >= '5') return false;
return false;
} }
return true; return true;
} }
// Generates output using Grisu2 digit-gen algorithm. // Generates output using Grisu2 digit-gen algorithm.
FMT_FUNC bool grisu2_gen_digits( FMT_FUNC bool grisu2_gen_digits(char *buf, int &size, uint32_t hi, uint64_t lo,
char *buf, int &size, uint32_t hi, uint64_t lo, int &exp, int &exp, uint64_t delta, const fp &one,
uint64_t delta, const fp &one, const fp &diff, int max_digits) { const fp &diff, int max_digits) {
// Generate digits for the most significant part (hi). // Generate digits for the most significant part (hi).
while (exp > 0) { while (exp > 0) {
uint32_t digit = 0; uint32_t digit = 0;
// This optimization by miloyip reduces the number of integer divisions by // This optimization by miloyip reduces the number of integer divisions by
// one per iteration. // one per iteration.
switch (exp) { switch (exp) {
case 10: digit = hi / 1000000000; hi %= 1000000000; break; case 10:
case 9: digit = hi / 100000000; hi %= 100000000; break; digit = hi / 1000000000;
case 8: digit = hi / 10000000; hi %= 10000000; break; hi %= 1000000000;
case 7: digit = hi / 1000000; hi %= 1000000; break; break;
case 6: digit = hi / 100000; hi %= 100000; break; case 9:
case 5: digit = hi / 10000; hi %= 10000; break; digit = hi / 100000000;
case 4: digit = hi / 1000; hi %= 1000; break; hi %= 100000000;
case 3: digit = hi / 100; hi %= 100; break; break;
case 2: digit = hi / 10; hi %= 10; break; case 8:
case 1: digit = hi; hi = 0; break; digit = hi / 10000000;
default: hi %= 10000000;
FMT_ASSERT(false, "invalid number of digits"); break;
case 7:
digit = hi / 1000000;
hi %= 1000000;
break;
case 6:
digit = hi / 100000;
hi %= 100000;
break;
case 5:
digit = hi / 10000;
hi %= 10000;
break;
case 4:
digit = hi / 1000;
hi %= 1000;
break;
case 3:
digit = hi / 100;
hi %= 100;
break;
case 2:
digit = hi / 10;
hi %= 10;
break;
case 1:
digit = hi;
hi = 0;
break;
default:
FMT_ASSERT(false, "invalid number of digits");
} }
if (digit != 0 || size != 0) if (digit != 0 || size != 0) buf[size++] = static_cast<char>('0' + digit);
buf[size++] = static_cast<char>('0' + digit);
--exp; --exp;
uint64_t remainder = (static_cast<uint64_t>(hi) << -one.e) + lo; uint64_t remainder = (static_cast<uint64_t>(hi) << -one.e) + lo;
if (remainder <= delta || size > max_digits) { if (remainder <= delta || size > max_digits) {
return grisu2_round( return grisu2_round(
buf, size, max_digits, delta, remainder, buf, size, max_digits, delta, remainder,
static_cast<uint64_t>(data::POWERS_OF_10_32[exp]) << -one.e, static_cast<uint64_t>(data::POWERS_OF_10_32[exp]) << -one.e, diff.f,
diff.f, exp); exp);
} }
} }
// Generate digits for the least significant part (lo). // Generate digits for the least significant part (lo).
@ -519,8 +536,7 @@ FMT_FUNC bool grisu2_gen_digits(
lo *= 10; lo *= 10;
delta *= 10; delta *= 10;
char digit = static_cast<char>(lo >> -one.e); char digit = static_cast<char>(lo >> -one.e);
if (digit != 0 || size != 0) if (digit != 0 || size != 0) buf[size++] = static_cast<char>('0' + digit);
buf[size++] = static_cast<char>('0' + digit);
lo &= one.f - 1; lo &= one.f - 1;
--exp; --exp;
if (lo < delta || size > max_digits) { if (lo < delta || size > max_digits) {
@ -531,11 +547,11 @@ FMT_FUNC bool grisu2_gen_digits(
} }
#if FMT_CLANG_VERSION #if FMT_CLANG_VERSION
# define FMT_FALLTHROUGH [[clang::fallthrough]]; #define FMT_FALLTHROUGH [[clang::fallthrough]];
#elif FMT_GCC_VERSION >= 700 #elif FMT_GCC_VERSION >= 700
# define FMT_FALLTHROUGH [[gnu::fallthrough]]; #define FMT_FALLTHROUGH [[gnu::fallthrough]];
#else #else
# define FMT_FALLTHROUGH #define FMT_FALLTHROUGH
#endif #endif
struct gen_digits_params { struct gen_digits_params {
@ -551,7 +567,7 @@ struct prettify_handler {
buffer &buf; buffer &buf;
explicit prettify_handler(buffer &b, ptrdiff_t n) explicit prettify_handler(buffer &b, ptrdiff_t n)
: data(b.data()), size(n), buf(b) {} : data(b.data()), size(n), buf(b) {}
~prettify_handler() { ~prettify_handler() {
assert(buf.size() >= to_unsigned(size)); assert(buf.size() >= to_unsigned(size));
buf.resize(to_unsigned(size)); buf.resize(to_unsigned(size));
@ -616,14 +632,13 @@ struct fill {
// The number is given as v = f * pow(10, exp), where f has size digits. // The number is given as v = f * pow(10, exp), where f has size digits.
template <typename Handler> template <typename Handler>
FMT_FUNC void grisu2_prettify(const gen_digits_params &params, FMT_FUNC void grisu2_prettify(const gen_digits_params &params, int size,
int size, int exp, Handler &&handler) { int exp, Handler &&handler) {
if (!params.fixed) { if (!params.fixed) {
// Insert a decimal point after the first digit and add an exponent. // Insert a decimal point after the first digit and add an exponent.
handler.insert(1, '.'); handler.insert(1, '.');
exp += size - 1; exp += size - 1;
if (size < params.num_digits) if (size < params.num_digits) handler.append(params.num_digits - size, '0');
handler.append(params.num_digits - size, '0');
handler.append(params.upper ? 'E' : 'e'); handler.append(params.upper ? 'E' : 'e');
write_exponent(exp, handler); write_exponent(exp, handler);
return; return;
@ -660,7 +675,9 @@ struct char_counter {
ptrdiff_t size; ptrdiff_t size;
template <typename F> template <typename F>
void insert(ptrdiff_t, ptrdiff_t n, F) { size += n; } void insert(ptrdiff_t, ptrdiff_t n, F) {
size += n;
}
void insert(ptrdiff_t, char) { ++size; } void insert(ptrdiff_t, char) { ++size; }
void append(ptrdiff_t n, char) { size += n; } void append(ptrdiff_t n, char) { size += n; }
void append(char) { ++size; } void append(char) { ++size; }
@ -675,34 +692,34 @@ FMT_FUNC gen_digits_params process_specs(const core_format_specs &specs,
auto params = gen_digits_params(); auto params = gen_digits_params();
int num_digits = specs.precision >= 0 ? specs.precision : 6; int num_digits = specs.precision >= 0 ? specs.precision : 6;
switch (specs.type) { switch (specs.type) {
case 'G': case 'G':
params.upper = true; params.upper = true;
FMT_FALLTHROUGH FMT_FALLTHROUGH
case '\0': case 'g': case '\0':
params.trailing_zeros = (specs.flags & HASH_FLAG) != 0; case 'g':
if (-4 <= exp && exp < num_digits + 1) { params.trailing_zeros = (specs.flags & HASH_FLAG) != 0;
if (-4 <= exp && exp < num_digits + 1) {
params.fixed = true;
if (!specs.type && params.trailing_zeros && exp >= 0)
num_digits = exp + 1;
}
break;
case 'F':
params.upper = true;
FMT_FALLTHROUGH
case 'f': {
params.fixed = true; params.fixed = true;
if (!specs.type && params.trailing_zeros && exp >= 0) params.trailing_zeros = true;
num_digits = exp + 1; int adjusted_min_digits = num_digits + exp;
if (adjusted_min_digits > 0) num_digits = adjusted_min_digits;
break;
} }
break; case 'E':
case 'F': params.upper = true;
params.upper = true; FMT_FALLTHROUGH
FMT_FALLTHROUGH case 'e':
case 'f': { ++num_digits;
params.fixed = true; break;
params.trailing_zeros = true;
int adjusted_min_digits = num_digits + exp;
if (adjusted_min_digits > 0)
num_digits = adjusted_min_digits;
break;
}
case 'E':
params.upper = true;
FMT_FALLTHROUGH
case 'e':
++num_digits;
break;
} }
params.num_digits = num_digits; params.num_digits = num_digits;
char_counter counter{num_digits}; char_counter counter{num_digits};
@ -713,7 +730,7 @@ FMT_FUNC gen_digits_params process_specs(const core_format_specs &specs,
template <typename Double> template <typename Double>
FMT_FUNC typename std::enable_if<sizeof(Double) == sizeof(uint64_t), bool>::type FMT_FUNC typename std::enable_if<sizeof(Double) == sizeof(uint64_t), bool>::type
grisu2_format(Double value, buffer &buf, core_format_specs specs) { grisu2_format(Double value, buffer &buf, core_format_specs specs) {
FMT_ASSERT(value >= 0, "value is negative"); FMT_ASSERT(value >= 0, "value is negative");
if (value == 0) { if (value == 0) {
gen_digits_params params = process_specs(specs, 1, buf); gen_digits_params params = process_specs(specs, 1, buf);
@ -728,13 +745,13 @@ FMT_FUNC typename std::enable_if<sizeof(Double) == sizeof(uint64_t), bool>::type
fp_value.compute_boundaries(lower, upper); fp_value.compute_boundaries(lower, upper);
// Find a cached power of 10 close to 1 / upper and use it to scale upper. // Find a cached power of 10 close to 1 / upper and use it to scale upper.
const int min_exp = -60; // alpha in Grisu. const int min_exp = -60; // alpha in Grisu.
int cached_exp = 0; // K in Grisu. int cached_exp = 0; // K in Grisu.
auto cached_pow = get_cached_power( // \tilde{c}_{-k} in Grisu. auto cached_pow = get_cached_power( // \tilde{c}_{-k} in Grisu.
min_exp - (upper.e + fp::significand_size), cached_exp); min_exp - (upper.e + fp::significand_size), cached_exp);
cached_exp = -cached_exp; cached_exp = -cached_exp;
upper = upper * cached_pow; // \tilde{M}^+ in Grisu. upper = upper * cached_pow; // \tilde{M}^+ in Grisu.
--upper.f; // \tilde{M}^+ - 1 ulp -> M^+_{\downarrow}. --upper.f; // \tilde{M}^+ - 1 ulp -> M^+_{\downarrow}.
fp one(1ull << -upper.e, upper.e); fp one(1ull << -upper.e, upper.e);
// hi (p1 in Grisu) contains the most significant digits of scaled_upper. // hi (p1 in Grisu) contains the most significant digits of scaled_upper.
// hi = floor(upper / one). // hi = floor(upper / one).
@ -744,9 +761,9 @@ FMT_FUNC typename std::enable_if<sizeof(Double) == sizeof(uint64_t), bool>::type
fp_value.normalize(); fp_value.normalize();
fp scaled_value = fp_value * cached_pow; fp scaled_value = fp_value * cached_pow;
lower = lower * cached_pow; // \tilde{M}^- in Grisu. lower = lower * cached_pow; // \tilde{M}^- in Grisu.
++lower.f; // \tilde{M}^- + 1 ulp -> M^-_{\uparrow}. ++lower.f; // \tilde{M}^- + 1 ulp -> M^-_{\uparrow}.
uint64_t delta = upper.f - lower.f; uint64_t delta = upper.f - lower.f;
fp diff = upper - scaled_value; // wp_w in Grisu. fp diff = upper - scaled_value; // wp_w in Grisu.
// lo (p2 in Grisu) contains the least significants digits of scaled_upper. // lo (p2 in Grisu) contains the least significants digits of scaled_upper.
// lo = supper % one. // lo = supper % one.
uint64_t lo = upper.f & (one.f - 1); uint64_t lo = upper.f & (one.f - 1);
@ -767,18 +784,16 @@ void sprintf_format(Double value, internal::buffer &buf,
FMT_ASSERT(buf.capacity() != 0, "empty buffer"); FMT_ASSERT(buf.capacity() != 0, "empty buffer");
// Build format string. // Build format string.
enum { MAX_FORMAT_SIZE = 10}; // longest format: %#-*.*Lg enum { MAX_FORMAT_SIZE = 10 }; // longest format: %#-*.*Lg
char format[MAX_FORMAT_SIZE]; char format[MAX_FORMAT_SIZE];
char *format_ptr = format; char *format_ptr = format;
*format_ptr++ = '%'; *format_ptr++ = '%';
if (spec.has(HASH_FLAG)) if (spec.has(HASH_FLAG)) *format_ptr++ = '#';
*format_ptr++ = '#';
if (spec.precision >= 0) { if (spec.precision >= 0) {
*format_ptr++ = '.'; *format_ptr++ = '.';
*format_ptr++ = '*'; *format_ptr++ = '*';
} }
if (std::is_same<Double, long double>::value) if (std::is_same<Double, long double>::value) *format_ptr++ = 'L';
*format_ptr++ = 'L';
*format_ptr++ = spec.type; *format_ptr++ = spec.type;
*format_ptr = '\0'; *format_ptr = '\0';
@ -819,28 +834,25 @@ FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) {
return; return;
} }
int length = MultiByteToWideChar( int length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(),
CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, FMT_NULL, 0); s_size, FMT_NULL, 0);
if (length == 0) if (length == 0) FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
buffer_.resize(length + 1); buffer_.resize(length + 1);
length = MultiByteToWideChar( length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size,
CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length); &buffer_[0], length);
if (length == 0) if (length == 0) FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
buffer_[length] = 0; buffer_[length] = 0;
} }
FMT_FUNC internal::utf16_to_utf8::utf16_to_utf8(wstring_view s) { FMT_FUNC internal::utf16_to_utf8::utf16_to_utf8(wstring_view s) {
if (int error_code = convert(s)) { if (int error_code = convert(s)) {
FMT_THROW(windows_error(error_code, FMT_THROW(windows_error(error_code,
"cannot convert string from UTF-16 to UTF-8")); "cannot convert string from UTF-16 to UTF-8"));
} }
} }
FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s) { FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s) {
if (s.size() > INT_MAX) if (s.size() > INT_MAX) return ERROR_INVALID_PARAMETER;
return ERROR_INVALID_PARAMETER;
int s_size = static_cast<int>(s.size()); int s_size = static_cast<int>(s.size());
if (s_size == 0) { if (s_size == 0) {
// WideCharToMultiByte does not support zero length, handle separately. // WideCharToMultiByte does not support zero length, handle separately.
@ -849,21 +861,19 @@ FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s) {
return 0; return 0;
} }
int length = WideCharToMultiByte( int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, FMT_NULL, 0,
CP_UTF8, 0, s.data(), s_size, FMT_NULL, 0, FMT_NULL, FMT_NULL); FMT_NULL, FMT_NULL);
if (length == 0) if (length == 0) return GetLastError();
return GetLastError();
buffer_.resize(length + 1); buffer_.resize(length + 1);
length = WideCharToMultiByte( length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, &buffer_[0],
CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, FMT_NULL, FMT_NULL); length, FMT_NULL, FMT_NULL);
if (length == 0) if (length == 0) return GetLastError();
return GetLastError();
buffer_[length] = 0; buffer_[length] = 0;
return 0; return 0;
} }
FMT_FUNC void windows_error::init( FMT_FUNC void windows_error::init(int err_code, string_view format_str,
int err_code, string_view format_str, format_args args) { format_args args) {
error_code_ = err_code; error_code_ = err_code;
memory_buffer buffer; memory_buffer buffer;
internal::format_windows_error(buffer, err_code, vformat(format_str, args)); internal::format_windows_error(buffer, err_code, vformat(format_str, args));
@ -871,17 +881,18 @@ FMT_FUNC void windows_error::init(
base = std::runtime_error(to_string(buffer)); base = std::runtime_error(to_string(buffer));
} }
FMT_FUNC void internal::format_windows_error( FMT_FUNC void internal::format_windows_error(internal::buffer &out,
internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT { int error_code,
string_view message) FMT_NOEXCEPT {
FMT_TRY { FMT_TRY {
wmemory_buffer buf; wmemory_buffer buf;
buf.resize(inline_buffer_size); buf.resize(inline_buffer_size);
for (;;) { for (;;) {
wchar_t *system_message = &buf[0]; wchar_t *system_message = &buf[0];
int result = FormatMessageW( int result = FormatMessageW(
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, FMT_NULL,
FMT_NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), system_message,
system_message, static_cast<uint32_t>(buf.size()), FMT_NULL); static_cast<uint32_t>(buf.size()), FMT_NULL);
if (result != 0) { if (result != 0) {
utf16_to_utf8 utf8_message; utf16_to_utf8 utf8_message;
if (utf8_message.convert(system_message) == ERROR_SUCCESS) { if (utf8_message.convert(system_message) == ERROR_SUCCESS) {
@ -897,14 +908,15 @@ FMT_FUNC void internal::format_windows_error(
break; // Can't get error message, report error code instead. break; // Can't get error message, report error code instead.
buf.resize(buf.size() * 2); buf.resize(buf.size() * 2);
} }
} FMT_CATCH(...) {} }
FMT_CATCH(...) {}
format_error_code(out, error_code, message); format_error_code(out, error_code, message);
} }
#endif // FMT_USE_WINDOWS_H #endif // FMT_USE_WINDOWS_H
FMT_FUNC void format_system_error( FMT_FUNC void format_system_error(internal::buffer &out, int error_code,
internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT { string_view message) FMT_NOEXCEPT {
FMT_TRY { FMT_TRY {
memory_buffer buf; memory_buffer buf;
buf.resize(inline_buffer_size); buf.resize(inline_buffer_size);
@ -922,7 +934,8 @@ FMT_FUNC void format_system_error(
break; // Can't get error message, report error code instead. break; // Can't get error message, report error code instead.
buf.resize(buf.size() * 2); buf.resize(buf.size() * 2);
} }
} FMT_CATCH(...) {} }
FMT_CATCH(...) {}
format_error_code(out, error_code, message); format_error_code(out, error_code, message);
} }
@ -930,14 +943,14 @@ FMT_FUNC void internal::error_handler::on_error(const char *message) {
FMT_THROW(format_error(message)); FMT_THROW(format_error(message));
} }
FMT_FUNC void report_system_error( FMT_FUNC void report_system_error(int error_code,
int error_code, fmt::string_view message) FMT_NOEXCEPT { fmt::string_view message) FMT_NOEXCEPT {
report_error(format_system_error, error_code, message); report_error(format_system_error, error_code, message);
} }
#if FMT_USE_WINDOWS_H #if FMT_USE_WINDOWS_H
FMT_FUNC void report_windows_error( FMT_FUNC void report_windows_error(int error_code,
int error_code, fmt::string_view message) FMT_NOEXCEPT { fmt::string_view message) FMT_NOEXCEPT {
report_error(internal::format_windows_error, error_code, message); report_error(internal::format_windows_error, error_code, message);
} }
#endif #endif
@ -966,7 +979,7 @@ FMT_FUNC void vprint(wstring_view format_str, wformat_args args) {
FMT_END_NAMESPACE FMT_END_NAMESPACE
#ifdef _MSC_VER #ifdef _MSC_VER
# pragma warning(pop) #pragma warning(pop)
#endif #endif
#endif // FMT_FORMAT_INL_H_ #endif // FMT_FORMAT_INL_H_

1252
src/cpp/include/deps/spdlog/fmt/bundled/format.h Executable file → Normal file
View File

File diff suppressed because it is too large Load Diff

33
src/cpp/include/deps/spdlog/fmt/bundled/locale.h Executable file → Normal file
View File

@ -8,9 +8,10 @@
#ifndef FMT_LOCALE_H_ #ifndef FMT_LOCALE_H_
#define FMT_LOCALE_H_ #define FMT_LOCALE_H_
#include "format.h"
#include <locale> #include <locale>
#include "format.h"
FMT_BEGIN_NAMESPACE FMT_BEGIN_NAMESPACE
namespace internal { namespace internal {
@ -19,9 +20,9 @@ typename buffer_context<Char>::type::iterator vformat_to(
const std::locale &loc, basic_buffer<Char> &buf, const std::locale &loc, basic_buffer<Char> &buf,
basic_string_view<Char> format_str, basic_string_view<Char> format_str,
basic_format_args<typename buffer_context<Char>::type> args) { basic_format_args<typename buffer_context<Char>::type> args) {
typedef back_insert_range<basic_buffer<Char> > range; typedef back_insert_range<basic_buffer<Char>> range;
return vformat_to<arg_formatter<range>>( return vformat_to<arg_formatter<range>>(buf, to_string_view(format_str), args,
buf, to_string_view(format_str), args, internal::locale_ref(loc)); internal::locale_ref(loc));
} }
template <typename Char> template <typename Char>
@ -32,7 +33,7 @@ std::basic_string<Char> vformat(
internal::vformat_to(loc, buffer, format_str, args); internal::vformat_to(loc, buffer, format_str, args);
return fmt::to_string(buffer); return fmt::to_string(buffer);
} }
} } // namespace internal
template <typename S, typename Char = FMT_CHAR(S)> template <typename S, typename Char = FMT_CHAR(S)>
inline std::basic_string<Char> vformat( inline std::basic_string<Char> vformat(
@ -42,27 +43,29 @@ inline std::basic_string<Char> vformat(
} }
template <typename S, typename... Args> template <typename S, typename... Args>
inline std::basic_string<FMT_CHAR(S)> format( inline std::basic_string<FMT_CHAR(S)> format(const std::locale &loc,
const std::locale &loc, const S &format_str, const Args &... args) { const S &format_str,
const Args &... args) {
return internal::vformat( return internal::vformat(
loc, to_string_view(format_str), loc, to_string_view(format_str),
*internal::checked_args<S, Args...>(format_str, args...)); *internal::checked_args<S, Args...>(format_str, args...));
} }
template <typename String, typename OutputIt, typename... Args> template <typename String, typename OutputIt, typename... Args>
inline typename std::enable_if<internal::is_output_iterator<OutputIt>::value, inline typename std::enable_if<internal::is_output_iterator<OutputIt>::value,
OutputIt>::type OutputIt>::type
vformat_to(OutputIt out, const std::locale &loc, const String &format_str, vformat_to(OutputIt out, const std::locale &loc, const String &format_str,
typename format_args_t<OutputIt, FMT_CHAR(String)>::type args) { typename format_args_t<OutputIt, FMT_CHAR(String)>::type args) {
typedef output_range<OutputIt, FMT_CHAR(String)> range; typedef output_range<OutputIt, FMT_CHAR(String)> range;
return vformat_to<arg_formatter<range>>( return vformat_to<arg_formatter<range>>(
range(out), to_string_view(format_str), args, internal::locale_ref(loc)); range(out), to_string_view(format_str), args, internal::locale_ref(loc));
} }
template <typename OutputIt, typename S, typename... Args> template <typename OutputIt, typename S, typename... Args>
inline typename std::enable_if< inline
internal::is_string<S>::value && typename std::enable_if<internal::is_string<S>::value &&
internal::is_output_iterator<OutputIt>::value, OutputIt>::type internal::is_output_iterator<OutputIt>::value,
OutputIt>::type
format_to(OutputIt out, const std::locale &loc, const S &format_str, format_to(OutputIt out, const std::locale &loc, const S &format_str,
const Args &... args) { const Args &... args) {
internal::check_format_string<Args...>(format_str); internal::check_format_string<Args...>(format_str);

39
src/cpp/include/deps/spdlog/fmt/bundled/ostream.h Executable file → Normal file
View File

@ -8,9 +8,10 @@
#ifndef FMT_OSTREAM_H_ #ifndef FMT_OSTREAM_H_
#define FMT_OSTREAM_H_ #define FMT_OSTREAM_H_
#include "format.h"
#include <ostream> #include <ostream>
#include "format.h"
FMT_BEGIN_NAMESPACE FMT_BEGIN_NAMESPACE
namespace internal { namespace internal {
@ -53,14 +54,16 @@ struct test_stream : std::basic_ostream<Char> {
void operator<<(null); void operator<<(null);
}; };
// Checks if T has a user-defined operator<< (e.g. not a member of std::ostream). // Checks if T has a user-defined operator<< (e.g. not a member of
// std::ostream).
template <typename T, typename Char> template <typename T, typename Char>
class is_streamable { class is_streamable {
private: private:
template <typename U> template <typename U>
static decltype( static decltype(internal::declval<test_stream<Char> &>()
internal::declval<test_stream<Char>&>() << internal::declval<U>(),
<< internal::declval<U>(), std::true_type()) test(int); std::true_type())
test(int);
template <typename> template <typename>
static std::false_type test(...); static std::false_type test(...);
@ -101,20 +104,18 @@ void format_value(basic_buffer<Char> &buffer, const T &value) {
// function (not a member of std::ostream). // function (not a member of std::ostream).
template <typename T, typename Char> template <typename T, typename Char>
struct convert_to_int<T, Char, void> { struct convert_to_int<T, Char, void> {
static const bool value = static const bool value = convert_to_int<T, Char, int>::value &&
convert_to_int<T, Char, int>::value && !internal::is_streamable<T, Char>::value;
!internal::is_streamable<T, Char>::value;
}; };
// Formats an object of type T that has an overloaded ostream operator<<. // Formats an object of type T that has an overloaded ostream operator<<.
template <typename T, typename Char> template <typename T, typename Char>
struct formatter<T, Char, struct formatter<T, Char,
typename std::enable_if< typename std::enable_if<
internal::is_streamable<T, Char>::value && internal::is_streamable<T, Char>::value &&
!internal::format_type< !internal::format_type<typename buffer_context<Char>::type,
typename buffer_context<Char>::type, T>::value>::type> T>::value>::type>
: formatter<basic_string_view<Char>, Char> { : formatter<basic_string_view<Char>, Char> {
template <typename Context> template <typename Context>
auto format(const T &value, Context &ctx) -> decltype(ctx.out()) { auto format(const T &value, Context &ctx) -> decltype(ctx.out()) {
basic_memory_buffer<Char> buffer; basic_memory_buffer<Char> buffer;
@ -125,9 +126,9 @@ struct formatter<T, Char,
}; };
template <typename Char> template <typename Char>
inline void vprint(std::basic_ostream<Char> &os, inline void vprint(
basic_string_view<Char> format_str, std::basic_ostream<Char> &os, basic_string_view<Char> format_str,
basic_format_args<typename buffer_context<Char>::type> args) { basic_format_args<typename buffer_context<Char>::type> args) {
basic_memory_buffer<Char> buffer; basic_memory_buffer<Char> buffer;
internal::vformat_to(buffer, format_str, args); internal::vformat_to(buffer, format_str, args);
internal::write(os, buffer); internal::write(os, buffer);
@ -142,9 +143,9 @@ inline void vprint(std::basic_ostream<Char> &os,
\endrst \endrst
*/ */
template <typename S, typename... Args> template <typename S, typename... Args>
inline typename std::enable_if<internal::is_string<S>::value>::type inline typename std::enable_if<internal::is_string<S>::value>::type print(
print(std::basic_ostream<FMT_CHAR(S)> &os, const S &format_str, std::basic_ostream<FMT_CHAR(S)> &os, const S &format_str,
const Args & ... args) { const Args &... args) {
internal::checked_args<S, Args...> ca(format_str, args...); internal::checked_args<S, Args...> ca(format_str, args...);
vprint(os, to_string_view(format_str), *ca); vprint(os, to_string_view(format_str), *ca);
} }

70
src/cpp/include/deps/spdlog/fmt/bundled/posix.h Executable file → Normal file
View File

@ -10,7 +10,7 @@
#if defined(__MINGW32__) || defined(__CYGWIN__) #if defined(__MINGW32__) || defined(__CYGWIN__)
// Workaround MinGW bug https://sourceforge.net/p/mingw/bugs/2024/. // Workaround MinGW bug https://sourceforge.net/p/mingw/bugs/2024/.
# undef __STRICT_ANSI__ #undef __STRICT_ANSI__
#endif #endif
#include <errno.h> #include <errno.h>
@ -22,42 +22,42 @@
#include <cstddef> #include <cstddef>
#if defined __APPLE__ || defined(__FreeBSD__) #if defined __APPLE__ || defined(__FreeBSD__)
# include <xlocale.h> // for LC_NUMERIC_MASK on OS X #include <xlocale.h> // for LC_NUMERIC_MASK on OS X
#endif #endif
#include "format.h" #include "format.h"
#ifndef FMT_POSIX #ifndef FMT_POSIX
# if defined(_WIN32) && !defined(__MINGW32__) #if defined(_WIN32) && !defined(__MINGW32__)
// Fix warnings about deprecated symbols. // Fix warnings about deprecated symbols.
# define FMT_POSIX(call) _##call #define FMT_POSIX(call) _##call
# else #else
# define FMT_POSIX(call) call #define FMT_POSIX(call) call
# endif #endif
#endif #endif
// Calls to system functions are wrapped in FMT_SYSTEM for testability. // Calls to system functions are wrapped in FMT_SYSTEM for testability.
#ifdef FMT_SYSTEM #ifdef FMT_SYSTEM
# define FMT_POSIX_CALL(call) FMT_SYSTEM(call) #define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
#else #else
# define FMT_SYSTEM(call) call #define FMT_SYSTEM(call) call
# ifdef _WIN32 #ifdef _WIN32
// Fix warnings about deprecated symbols. // Fix warnings about deprecated symbols.
# define FMT_POSIX_CALL(call) ::_##call #define FMT_POSIX_CALL(call) ::_##call
# else #else
# define FMT_POSIX_CALL(call) ::call #define FMT_POSIX_CALL(call) ::call
# endif #endif
#endif #endif
// Retries the expression while it evaluates to error_result and errno // Retries the expression while it evaluates to error_result and errno
// equals to EINTR. // equals to EINTR.
#ifndef _WIN32 #ifndef _WIN32
# define FMT_RETRY_VAL(result, expression, error_result) \ #define FMT_RETRY_VAL(result, expression, error_result) \
do { \ do { \
result = (expression); \ result = (expression); \
} while (result == error_result && errno == EINTR) } while (result == error_result && errno == EINTR)
#else #else
# define FMT_RETRY_VAL(result, expression, error_result) result = (expression) #define FMT_RETRY_VAL(result, expression, error_result) result = (expression)
#endif #endif
#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1) #define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
@ -143,13 +143,12 @@ class buffered_file {
buffered_file(const buffered_file &) = delete; buffered_file(const buffered_file &) = delete;
void operator=(const buffered_file &) = delete; void operator=(const buffered_file &) = delete;
public: public:
buffered_file(buffered_file &&other) FMT_NOEXCEPT : file_(other.file_) { buffered_file(buffered_file &&other) FMT_NOEXCEPT : file_(other.file_) {
other.file_ = FMT_NULL; other.file_ = FMT_NULL;
} }
buffered_file& operator=(buffered_file &&other) { buffered_file &operator=(buffered_file &&other) {
close(); close();
file_ = other.file_; file_ = other.file_;
other.file_ = FMT_NULL; other.file_ = FMT_NULL;
@ -167,14 +166,14 @@ class buffered_file {
// We place parentheses around fileno to workaround a bug in some versions // We place parentheses around fileno to workaround a bug in some versions
// of MinGW that define fileno as a macro. // of MinGW that define fileno as a macro.
FMT_API int (fileno)() const; FMT_API int(fileno)() const;
void vprint(string_view format_str, format_args args) { void vprint(string_view format_str, format_args args) {
fmt::vprint(file_, format_str, args); fmt::vprint(file_, format_str, args);
} }
template <typename... Args> template <typename... Args>
inline void print(string_view format_str, const Args & ... args) { inline void print(string_view format_str, const Args &... args) {
vprint(format_str, make_format_args(args...)); vprint(format_str, make_format_args(args...));
} }
}; };
@ -195,9 +194,9 @@ class file {
public: public:
// Possible values for the oflag argument to the constructor. // Possible values for the oflag argument to the constructor.
enum { enum {
RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only. RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only.
WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only. WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only.
RDWR = FMT_POSIX(O_RDWR) // Open for reading and writing. RDWR = FMT_POSIX(O_RDWR) // Open for reading and writing.
}; };
// Constructs a file object which doesn't represent any file. // Constructs a file object which doesn't represent any file.
@ -211,11 +210,9 @@ class file {
void operator=(const file &) = delete; void operator=(const file &) = delete;
public: public:
file(file &&other) FMT_NOEXCEPT : fd_(other.fd_) { file(file &&other) FMT_NOEXCEPT : fd_(other.fd_) { other.fd_ = -1; }
other.fd_ = -1;
}
file& operator=(file &&other) { file &operator=(file &&other) {
close(); close();
fd_ = other.fd_; fd_ = other.fd_;
other.fd_ = -1; other.fd_ = -1;
@ -265,17 +262,17 @@ class file {
// Returns the memory page size. // Returns the memory page size.
long getpagesize(); long getpagesize();
#if (defined(LC_NUMERIC_MASK) || defined(_MSC_VER)) && \ #if (defined(LC_NUMERIC_MASK) || defined(_MSC_VER)) && \
!defined(__ANDROID__) && !defined(__CYGWIN__) && !defined(__OpenBSD__) && \ !defined(__ANDROID__) && !defined(__CYGWIN__) && !defined(__OpenBSD__) && \
!defined(__NEWLIB_H__) !defined(__NEWLIB_H__)
# define FMT_LOCALE #define FMT_LOCALE
#endif #endif
#ifdef FMT_LOCALE #ifdef FMT_LOCALE
// A "C" numeric locale. // A "C" numeric locale.
class Locale { class Locale {
private: private:
# ifdef _MSC_VER #ifdef _MSC_VER
typedef _locale_t locale_t; typedef _locale_t locale_t;
enum { LC_NUMERIC_MASK = LC_NUMERIC }; enum { LC_NUMERIC_MASK = LC_NUMERIC };
@ -284,14 +281,12 @@ class Locale {
return _create_locale(category_mask, locale); return _create_locale(category_mask, locale);
} }
static void freelocale(locale_t locale) { static void freelocale(locale_t locale) { _free_locale(locale); }
_free_locale(locale);
}
static double strtod_l(const char *nptr, char **endptr, _locale_t locale) { static double strtod_l(const char *nptr, char **endptr, _locale_t locale) {
return _strtod_l(nptr, endptr, locale); return _strtod_l(nptr, endptr, locale);
} }
# endif #endif
locale_t locale_; locale_t locale_;
@ -302,8 +297,7 @@ class Locale {
typedef locale_t Type; typedef locale_t Type;
Locale() : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL)) { Locale() : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL)) {
if (!locale_) if (!locale_) FMT_THROW(system_error(errno, "cannot create locale"));
FMT_THROW(system_error(errno, "cannot create locale"));
} }
~Locale() { freelocale(locale_); } ~Locale() { freelocale(locale_); }

331
src/cpp/include/deps/spdlog/fmt/bundled/printf.h Executable file → Normal file
View File

@ -24,18 +24,18 @@ class null_terminating_iterator {
public: public:
typedef std::ptrdiff_t difference_type; typedef std::ptrdiff_t difference_type;
typedef Char value_type; typedef Char value_type;
typedef const Char* pointer; typedef const Char *pointer;
typedef const Char& reference; typedef const Char &reference;
typedef std::random_access_iterator_tag iterator_category; typedef std::random_access_iterator_tag iterator_category;
null_terminating_iterator() : ptr_(0), end_(0) {} null_terminating_iterator() : ptr_(0), end_(0) {}
FMT_CONSTEXPR null_terminating_iterator(const Char *ptr, const Char *end) FMT_CONSTEXPR null_terminating_iterator(const Char *ptr, const Char *end)
: ptr_(ptr), end_(end) {} : ptr_(ptr), end_(end) {}
template <typename Range> template <typename Range>
FMT_CONSTEXPR explicit null_terminating_iterator(const Range &r) FMT_CONSTEXPR explicit null_terminating_iterator(const Range &r)
: ptr_(r.begin()), end_(r.end()) {} : ptr_(r.begin()), end_(r.end()) {}
FMT_CONSTEXPR null_terminating_iterator &operator=(const Char *ptr) { FMT_CONSTEXPR null_terminating_iterator &operator=(const Char *ptr) {
assert(ptr <= end_); assert(ptr <= end_);
@ -43,9 +43,7 @@ class null_terminating_iterator {
return *this; return *this;
} }
FMT_CONSTEXPR Char operator*() const { FMT_CONSTEXPR Char operator*() const { return ptr_ != end_ ? *ptr_ : Char(); }
return ptr_ != end_ ? *ptr_ : Char();
}
FMT_CONSTEXPR null_terminating_iterator operator++() { FMT_CONSTEXPR null_terminating_iterator operator++() {
++ptr_; ++ptr_;
@ -76,8 +74,8 @@ class null_terminating_iterator {
return *this; return *this;
} }
FMT_CONSTEXPR difference_type operator-( FMT_CONSTEXPR difference_type
null_terminating_iterator other) const { operator-(null_terminating_iterator other) const {
return ptr_ - other.ptr_; return ptr_ - other.ptr_;
} }
@ -101,7 +99,9 @@ class null_terminating_iterator {
}; };
template <typename T> template <typename T>
FMT_CONSTEXPR const T *pointer_from(const T *p) { return p; } FMT_CONSTEXPR const T *pointer_from(const T *p) {
return p;
}
template <typename Char> template <typename Char>
FMT_CONSTEXPR const Char *pointer_from(null_terminating_iterator<Char> it) { FMT_CONSTEXPR const Char *pointer_from(null_terminating_iterator<Char> it) {
@ -135,8 +135,7 @@ FMT_CONSTEXPR unsigned parse_nonnegative_int(Iterator &it, ErrorHandler &&eh) {
++next; ++next;
it = next; it = next;
} while ('0' <= *it && *it <= '9'); } while ('0' <= *it && *it <= '9');
if (value > max_int) if (value > max_int) eh.on_error("number is too big");
eh.on_error("number is too big");
return value; return value;
} }
@ -162,33 +161,38 @@ struct int_checker<true> {
static bool fits_in_int(int) { return true; } static bool fits_in_int(int) { return true; }
}; };
class printf_precision_handler: public function<int> { class printf_precision_handler : public function<int> {
public: public:
template <typename T> template <typename T>
typename std::enable_if<std::is_integral<T>::value, int>::type typename std::enable_if<std::is_integral<T>::value, int>::type operator()(
operator()(T value) { T value) {
if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value)) if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
FMT_THROW(format_error("number is too big")); FMT_THROW(format_error("number is too big"));
return static_cast<int>(value); return static_cast<int>(value);
} }
template <typename T> template <typename T>
typename std::enable_if<!std::is_integral<T>::value, int>::type operator()(T) { typename std::enable_if<!std::is_integral<T>::value, int>::type operator()(
T) {
FMT_THROW(format_error("precision is not integer")); FMT_THROW(format_error("precision is not integer"));
return 0; return 0;
} }
}; };
// An argument visitor that returns true iff arg is a zero integer. // An argument visitor that returns true iff arg is a zero integer.
class is_zero_int: public function<bool> { class is_zero_int : public function<bool> {
public: public:
template <typename T> template <typename T>
typename std::enable_if<std::is_integral<T>::value, bool>::type typename std::enable_if<std::is_integral<T>::value, bool>::type operator()(
operator()(T value) { return value == 0; } T value) {
return value == 0;
}
template <typename T> template <typename T>
typename std::enable_if<!std::is_integral<T>::value, bool>::type typename std::enable_if<!std::is_integral<T>::value, bool>::type operator()(
operator()(T) { return false; } T) {
return false;
}
}; };
template <typename T> template <typename T>
@ -200,7 +204,7 @@ struct make_unsigned_or_bool<bool> {
}; };
template <typename T, typename Context> template <typename T, typename Context>
class arg_converter: public function<void> { class arg_converter : public function<void> {
private: private:
typedef typename Context::char_type Char; typedef typename Context::char_type Char;
@ -209,28 +213,27 @@ class arg_converter: public function<void> {
public: public:
arg_converter(basic_format_arg<Context> &arg, Char type) arg_converter(basic_format_arg<Context> &arg, Char type)
: arg_(arg), type_(type) {} : arg_(arg), type_(type) {}
void operator()(bool value) { void operator()(bool value) {
if (type_ != 's') if (type_ != 's') operator()<bool>(value);
operator()<bool>(value);
} }
template <typename U> template <typename U>
typename std::enable_if<std::is_integral<U>::value>::type typename std::enable_if<std::is_integral<U>::value>::type operator()(
operator()(U value) { U value) {
bool is_signed = type_ == 'd' || type_ == 'i'; bool is_signed = type_ == 'd' || type_ == 'i';
typedef typename std::conditional< typedef typename std::conditional<std::is_same<T, void>::value, U, T>::type
std::is_same<T, void>::value, U, T>::type TargetType; TargetType;
if (const_check(sizeof(TargetType) <= sizeof(int))) { if (const_check(sizeof(TargetType) <= sizeof(int))) {
// Extra casts are used to silence warnings. // Extra casts are used to silence warnings.
if (is_signed) { if (is_signed) {
arg_ = internal::make_arg<Context>( arg_ = internal::make_arg<Context>(
static_cast<int>(static_cast<TargetType>(value))); static_cast<int>(static_cast<TargetType>(value)));
} else { } else {
typedef typename make_unsigned_or_bool<TargetType>::type Unsigned; typedef typename make_unsigned_or_bool<TargetType>::type Unsigned;
arg_ = internal::make_arg<Context>( arg_ = internal::make_arg<Context>(
static_cast<unsigned>(static_cast<Unsigned>(value))); static_cast<unsigned>(static_cast<Unsigned>(value)));
} }
} else { } else {
if (is_signed) { if (is_signed) {
@ -240,7 +243,7 @@ class arg_converter: public function<void> {
arg_ = internal::make_arg<Context>(static_cast<long long>(value)); arg_ = internal::make_arg<Context>(static_cast<long long>(value));
} else { } else {
arg_ = internal::make_arg<Context>( arg_ = internal::make_arg<Context>(
static_cast<typename make_unsigned_or_bool<U>::type>(value)); static_cast<typename make_unsigned_or_bool<U>::type>(value));
} }
} }
} }
@ -262,7 +265,7 @@ void convert_arg(basic_format_arg<Context> &arg, Char type) {
// Converts an integer argument to char for printf. // Converts an integer argument to char for printf.
template <typename Context> template <typename Context>
class char_converter: public function<void> { class char_converter : public function<void> {
private: private:
basic_format_arg<Context> &arg_; basic_format_arg<Context> &arg_;
@ -270,8 +273,8 @@ class char_converter: public function<void> {
explicit char_converter(basic_format_arg<Context> &arg) : arg_(arg) {} explicit char_converter(basic_format_arg<Context> &arg) : arg_(arg) {}
template <typename T> template <typename T>
typename std::enable_if<std::is_integral<T>::value>::type typename std::enable_if<std::is_integral<T>::value>::type operator()(
operator()(T value) { T value) {
typedef typename Context::char_type Char; typedef typename Context::char_type Char;
arg_ = internal::make_arg<Context>(static_cast<Char>(value)); arg_ = internal::make_arg<Context>(static_cast<Char>(value));
} }
@ -285,7 +288,7 @@ class char_converter: public function<void> {
// Checks if an argument is a valid printf width specifier and sets // Checks if an argument is a valid printf width specifier and sets
// left alignment if it is negative. // left alignment if it is negative.
template <typename Char> template <typename Char>
class printf_width_handler: public function<unsigned> { class printf_width_handler : public function<unsigned> {
private: private:
typedef basic_format_specs<Char> format_specs; typedef basic_format_specs<Char> format_specs;
@ -296,7 +299,7 @@ class printf_width_handler: public function<unsigned> {
template <typename T> template <typename T>
typename std::enable_if<std::is_integral<T>::value, unsigned>::type typename std::enable_if<std::is_integral<T>::value, unsigned>::type
operator()(T value) { operator()(T value) {
typedef typename internal::int_traits<T>::main_type UnsignedType; typedef typename internal::int_traits<T>::main_type UnsignedType;
UnsignedType width = static_cast<UnsignedType>(value); UnsignedType width = static_cast<UnsignedType>(value);
if (internal::is_negative(value)) { if (internal::is_negative(value)) {
@ -304,14 +307,13 @@ class printf_width_handler: public function<unsigned> {
width = 0 - width; width = 0 - width;
} }
unsigned int_max = std::numeric_limits<int>::max(); unsigned int_max = std::numeric_limits<int>::max();
if (width > int_max) if (width > int_max) FMT_THROW(format_error("number is too big"));
FMT_THROW(format_error("number is too big"));
return static_cast<unsigned>(width); return static_cast<unsigned>(width);
} }
template <typename T> template <typename T>
typename std::enable_if<!std::is_integral<T>::value, unsigned>::type typename std::enable_if<!std::is_integral<T>::value, unsigned>::type
operator()(T) { operator()(T) {
FMT_THROW(format_error("width is not integer")); FMT_THROW(format_error("width is not integer"));
return 0; return 0;
} }
@ -329,10 +331,9 @@ using internal::printf; // For printing into memory_buffer.
template <typename Range> template <typename Range>
class printf_arg_formatter; class printf_arg_formatter;
template < template <typename OutputIt, typename Char,
typename OutputIt, typename Char, typename ArgFormatter = printf_arg_formatter<
typename ArgFormatter = back_insert_range<internal::basic_buffer<Char>>>>
printf_arg_formatter<back_insert_range<internal::basic_buffer<Char>>>>
class basic_printf_context; class basic_printf_context;
/** /**
@ -341,10 +342,10 @@ class basic_printf_context;
\endrst \endrst
*/ */
template <typename Range> template <typename Range>
class printf_arg_formatter: class printf_arg_formatter
public internal::function< : public internal::function<
typename internal::arg_formatter_base<Range>::iterator>, typename internal::arg_formatter_base<Range>::iterator>,
public internal::arg_formatter_base<Range> { public internal::arg_formatter_base<Range> {
private: private:
typedef typename Range::value_type char_type; typedef typename Range::value_type char_type;
typedef decltype(internal::declval<Range>().begin()) iterator; typedef decltype(internal::declval<Range>().begin()) iterator;
@ -375,19 +376,18 @@ class printf_arg_formatter:
*/ */
printf_arg_formatter(internal::basic_buffer<char_type> &buffer, printf_arg_formatter(internal::basic_buffer<char_type> &buffer,
format_specs &spec, context_type &ctx) format_specs &spec, context_type &ctx)
: base(back_insert_range<internal::basic_buffer<char_type>>(buffer), &spec, : base(back_insert_range<internal::basic_buffer<char_type>>(buffer),
ctx.locale()), &spec, ctx.locale()),
context_(ctx) {} context_(ctx) {}
template <typename T> template <typename T>
typename std::enable_if<std::is_integral<T>::value, iterator>::type typename std::enable_if<std::is_integral<T>::value, iterator>::type
operator()(T value) { operator()(T value) {
// MSVC2013 fails to compile separate overloads for bool and char_type so // MSVC2013 fails to compile separate overloads for bool and char_type so
// use std::is_same instead. // use std::is_same instead.
if (std::is_same<T, bool>::value) { if (std::is_same<T, bool>::value) {
format_specs &fmt_spec = *this->spec(); format_specs &fmt_spec = *this->spec();
if (fmt_spec.type != 's') if (fmt_spec.type != 's') return base::operator()(value ? 1 : 0);
return base::operator()(value ? 1 : 0);
fmt_spec.type = 0; fmt_spec.type = 0;
this->write(value != 0); this->write(value != 0);
} else if (std::is_same<T, char_type>::value) { } else if (std::is_same<T, char_type>::value) {
@ -405,7 +405,7 @@ class printf_arg_formatter:
template <typename T> template <typename T>
typename std::enable_if<std::is_floating_point<T>::value, iterator>::type typename std::enable_if<std::is_floating_point<T>::value, iterator>::type
operator()(T value) { operator()(T value) {
return base::operator()(value); return base::operator()(value);
} }
@ -435,14 +435,11 @@ class printf_arg_formatter:
return base::operator()(value); return base::operator()(value);
} }
iterator operator()(monostate value) { iterator operator()(monostate value) { return base::operator()(value); }
return base::operator()(value);
}
/** Formats a pointer. */ /** Formats a pointer. */
iterator operator()(const void *value) { iterator operator()(const void *value) {
if (value) if (value) return base::operator()(value);
return base::operator()(value);
this->spec()->type = 0; this->spec()->type = 0;
write_null_pointer(char_type()); write_null_pointer(char_type());
return this->out(); return this->out();
@ -458,7 +455,9 @@ class printf_arg_formatter:
template <typename T> template <typename T>
struct printf_formatter { struct printf_formatter {
template <typename ParseContext> template <typename ParseContext>
auto parse(ParseContext &ctx) -> decltype(ctx.begin()) { return ctx.begin(); } auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
return ctx.begin();
}
template <typename FormatContext> template <typename FormatContext>
auto format(const T &value, FormatContext &ctx) -> decltype(ctx.out()) { auto format(const T &value, FormatContext &ctx) -> decltype(ctx.out()) {
@ -470,16 +469,18 @@ struct printf_formatter {
/** This template formats data and writes the output to a writer. */ /** This template formats data and writes the output to a writer. */
template <typename OutputIt, typename Char, typename ArgFormatter> template <typename OutputIt, typename Char, typename ArgFormatter>
class basic_printf_context : class basic_printf_context :
// Inherit publicly as a workaround for the icc bug // Inherit publicly as a workaround for the icc bug
// https://software.intel.com/en-us/forums/intel-c-compiler/topic/783476. // https://software.intel.com/en-us/forums/intel-c-compiler/topic/783476.
public internal::context_base< public internal::context_base<
OutputIt, basic_printf_context<OutputIt, Char, ArgFormatter>, Char> { OutputIt, basic_printf_context<OutputIt, Char, ArgFormatter>, Char> {
public: public:
/** The character type for the output. */ /** The character type for the output. */
typedef Char char_type; typedef Char char_type;
template <typename T> template <typename T>
struct formatter_type { typedef printf_formatter<T> type; }; struct formatter_type {
typedef printf_formatter<T> type;
};
private: private:
typedef internal::context_base<OutputIt, basic_printf_context, Char> base; typedef internal::context_base<OutputIt, basic_printf_context, Char> base;
@ -492,8 +493,7 @@ class basic_printf_context :
// Returns the argument with specified index or, if arg_index is equal // Returns the argument with specified index or, if arg_index is equal
// to the maximum unsigned value, the next argument. // to the maximum unsigned value, the next argument.
format_arg get_arg( format_arg get_arg(
iterator it, iterator it, unsigned arg_index = (std::numeric_limits<unsigned>::max)());
unsigned arg_index = (std::numeric_limits<unsigned>::max)());
// Parses argument index, flags and width and returns the argument index. // Parses argument index, flags and width and returns the argument index.
unsigned parse_header(iterator &it, format_specs &spec); unsigned parse_header(iterator &it, format_specs &spec);
@ -508,19 +508,19 @@ class basic_printf_context :
*/ */
basic_printf_context(OutputIt out, basic_string_view<char_type> format_str, basic_printf_context(OutputIt out, basic_string_view<char_type> format_str,
basic_format_args<basic_printf_context> args) basic_format_args<basic_printf_context> args)
: base(out, format_str, args) {} : base(out, format_str, args) {}
using base::parse_context;
using base::out;
using base::advance_to; using base::advance_to;
using base::out;
using base::parse_context;
/** Formats stored arguments and writes the output to the range. */ /** Formats stored arguments and writes the output to the range. */
void format(); void format();
}; };
template <typename OutputIt, typename Char, typename AF> template <typename OutputIt, typename Char, typename AF>
void basic_printf_context<OutputIt, Char, AF>::parse_flags( void basic_printf_context<OutputIt, Char, AF>::parse_flags(format_specs &spec,
format_specs &spec, iterator &it) { iterator &it) {
for (;;) { for (;;) {
switch (*it++) { switch (*it++) {
case '-': case '-':
@ -547,8 +547,8 @@ void basic_printf_context<OutputIt, Char, AF>::parse_flags(
template <typename OutputIt, typename Char, typename AF> template <typename OutputIt, typename Char, typename AF>
typename basic_printf_context<OutputIt, Char, AF>::format_arg typename basic_printf_context<OutputIt, Char, AF>::format_arg
basic_printf_context<OutputIt, Char, AF>::get_arg( basic_printf_context<OutputIt, Char, AF>::get_arg(iterator it,
iterator it, unsigned arg_index) { unsigned arg_index) {
(void)it; (void)it;
if (arg_index == std::numeric_limits<unsigned>::max()) if (arg_index == std::numeric_limits<unsigned>::max())
return this->do_get_arg(this->parse_context().next_arg_id()); return this->do_get_arg(this->parse_context().next_arg_id());
@ -557,7 +557,7 @@ typename basic_printf_context<OutputIt, Char, AF>::format_arg
template <typename OutputIt, typename Char, typename AF> template <typename OutputIt, typename Char, typename AF>
unsigned basic_printf_context<OutputIt, Char, AF>::parse_header( unsigned basic_printf_context<OutputIt, Char, AF>::parse_header(
iterator &it, format_specs &spec) { iterator &it, format_specs &spec) {
unsigned arg_index = std::numeric_limits<unsigned>::max(); unsigned arg_index = std::numeric_limits<unsigned>::max();
char_type c = *it; char_type c = *it;
if (c >= '0' && c <= '9') { if (c >= '0' && c <= '9') {
@ -569,8 +569,7 @@ unsigned basic_printf_context<OutputIt, Char, AF>::parse_header(
++it; ++it;
arg_index = value; arg_index = value;
} else { } else {
if (c == '0') if (c == '0') spec.fill_ = '0';
spec.fill_ = '0';
if (value != 0) { if (value != 0) {
// Nonzero value means that we parsed width and don't need to // Nonzero value means that we parsed width and don't need to
// parse it or flags again, so return now. // parse it or flags again, so return now.
@ -587,7 +586,7 @@ unsigned basic_printf_context<OutputIt, Char, AF>::parse_header(
} else if (*it == '*') { } else if (*it == '*') {
++it; ++it;
spec.width_ = visit_format_arg( spec.width_ = visit_format_arg(
internal::printf_width_handler<char_type>(spec), get_arg(it)); internal::printf_width_handler<char_type>(spec), get_arg(it));
} }
return arg_index; return arg_index;
} }
@ -631,7 +630,8 @@ void basic_printf_context<OutputIt, Char, AF>::format() {
format_arg arg = get_arg(it, arg_index); format_arg arg = get_arg(it, arg_index);
if (spec.has(HASH_FLAG) && visit_format_arg(internal::is_zero_int(), arg)) if (spec.has(HASH_FLAG) && visit_format_arg(internal::is_zero_int(), arg))
spec.flags = static_cast<uint_least8_t>(spec.flags & (~internal::to_unsigned<int>(HASH_FLAG))); spec.flags = static_cast<uint_least8_t>(
spec.flags & (~internal::to_unsigned<int>(HASH_FLAG)));
if (spec.fill_ == '0') { if (spec.fill_ == '0') {
if (arg.is_arithmetic()) if (arg.is_arithmetic())
spec.align_ = ALIGN_NUMERIC; spec.align_ = ALIGN_NUMERIC;
@ -642,51 +642,51 @@ void basic_printf_context<OutputIt, Char, AF>::format() {
// Parse length and convert the argument to the required type. // Parse length and convert the argument to the required type.
using internal::convert_arg; using internal::convert_arg;
switch (*it++) { switch (*it++) {
case 'h': case 'h':
if (*it == 'h') if (*it == 'h')
convert_arg<signed char>(arg, *++it); convert_arg<signed char>(arg, *++it);
else else
convert_arg<short>(arg, *it); convert_arg<short>(arg, *it);
break; break;
case 'l': case 'l':
if (*it == 'l') if (*it == 'l')
convert_arg<long long>(arg, *++it); convert_arg<long long>(arg, *++it);
else else
convert_arg<long>(arg, *it); convert_arg<long>(arg, *it);
break; break;
case 'j': case 'j':
convert_arg<intmax_t>(arg, *it); convert_arg<intmax_t>(arg, *it);
break; break;
case 'z': case 'z':
convert_arg<std::size_t>(arg, *it); convert_arg<std::size_t>(arg, *it);
break; break;
case 't': case 't':
convert_arg<std::ptrdiff_t>(arg, *it); convert_arg<std::ptrdiff_t>(arg, *it);
break; break;
case 'L': case 'L':
// printf produces garbage when 'L' is omitted for long double, no // printf produces garbage when 'L' is omitted for long double, no
// need to do the same. // need to do the same.
break; break;
default: default:
--it; --it;
convert_arg<void>(arg, *it); convert_arg<void>(arg, *it);
} }
// Parse type. // Parse type.
if (!*it) if (!*it) FMT_THROW(format_error("invalid format string"));
FMT_THROW(format_error("invalid format string"));
spec.type = static_cast<char>(*it++); spec.type = static_cast<char>(*it++);
if (arg.is_integral()) { if (arg.is_integral()) {
// Normalize type. // Normalize type.
switch (spec.type) { switch (spec.type) {
case 'i': case 'u': case 'i':
spec.type = 'd'; case 'u':
break; spec.type = 'd';
case 'c': break;
// TODO: handle wchar_t better? case 'c':
visit_format_arg( // TODO: handle wchar_t better?
internal::char_converter<basic_printf_context>(arg), arg); visit_format_arg(internal::char_converter<basic_printf_context>(arg),
break; arg);
break;
} }
} }
@ -700,8 +700,9 @@ void basic_printf_context<OutputIt, Char, AF>::format() {
template <typename Buffer> template <typename Buffer>
struct basic_printf_context_t { struct basic_printf_context_t {
typedef basic_printf_context< typedef basic_printf_context<std::back_insert_iterator<Buffer>,
std::back_insert_iterator<Buffer>, typename Buffer::value_type> type; typename Buffer::value_type>
type;
}; };
typedef basic_printf_context_t<internal::buffer>::type printf_context; typedef basic_printf_context_t<internal::buffer>::type printf_context;
@ -713,28 +714,33 @@ typedef basic_format_args<wprintf_context> wprintf_args;
/** /**
\rst \rst
Constructs an `~fmt::format_arg_store` object that contains references to Constructs an `~fmt::format_arg_store` object that contains references to
arguments and can be implicitly converted to `~fmt::printf_args`. arguments and can be implicitly converted to `~fmt::printf_args`.
\endrst \endrst
*/ */
template<typename... Args> template <typename... Args>
inline format_arg_store<printf_context, Args...> inline format_arg_store<printf_context, Args...> make_printf_args(
make_printf_args(const Args &... args) { return {args...}; } const Args &... args) {
return {args...};
}
/** /**
\rst \rst
Constructs an `~fmt::format_arg_store` object that contains references to Constructs an `~fmt::format_arg_store` object that contains references to
arguments and can be implicitly converted to `~fmt::wprintf_args`. arguments and can be implicitly converted to `~fmt::wprintf_args`.
\endrst \endrst
*/ */
template<typename... Args> template <typename... Args>
inline format_arg_store<wprintf_context, Args...> inline format_arg_store<wprintf_context, Args...> make_wprintf_args(
make_wprintf_args(const Args &... args) { return {args...}; } const Args &... args) {
return {args...};
}
template <typename S, typename Char = FMT_CHAR(S)> template <typename S, typename Char = FMT_CHAR(S)>
inline std::basic_string<Char> inline std::basic_string<Char> vsprintf(
vsprintf(const S &format, const S &format,
basic_format_args<typename basic_printf_context_t< basic_format_args<
internal::basic_buffer<Char>>::type> args) { typename basic_printf_context_t<internal::basic_buffer<Char>>::type>
args) {
basic_memory_buffer<Char> buffer; basic_memory_buffer<Char> buffer;
printf(buffer, to_string_view(format), args); printf(buffer, to_string_view(format), args);
return to_string(buffer); return to_string(buffer);
@ -750,26 +756,28 @@ vsprintf(const S &format,
\endrst \endrst
*/ */
template <typename S, typename... Args> template <typename S, typename... Args>
inline FMT_ENABLE_IF_T( inline FMT_ENABLE_IF_T(internal::is_string<S>::value,
internal::is_string<S>::value, std::basic_string<FMT_CHAR(S)>) std::basic_string<FMT_CHAR(S)>)
sprintf(const S &format, const Args & ... args) { sprintf(const S &format, const Args &... args) {
internal::check_format_string<Args...>(format); internal::check_format_string<Args...>(format);
typedef internal::basic_buffer<FMT_CHAR(S)> buffer; typedef internal::basic_buffer<FMT_CHAR(S)> buffer;
typedef typename basic_printf_context_t<buffer>::type context; typedef typename basic_printf_context_t<buffer>::type context;
format_arg_store<context, Args...> as{ args... }; format_arg_store<context, Args...> as{args...};
return vsprintf(to_string_view(format), return vsprintf(to_string_view(format), basic_format_args<context>(as));
basic_format_args<context>(as));
} }
template <typename S, typename Char = FMT_CHAR(S)> template <typename S, typename Char = FMT_CHAR(S)>
inline int vfprintf(std::FILE *f, const S &format, inline int vfprintf(
basic_format_args<typename basic_printf_context_t< std::FILE *f, const S &format,
internal::basic_buffer<Char>>::type> args) { basic_format_args<
typename basic_printf_context_t<internal::basic_buffer<Char>>::type>
args) {
basic_memory_buffer<Char> buffer; basic_memory_buffer<Char> buffer;
printf(buffer, to_string_view(format), args); printf(buffer, to_string_view(format), args);
std::size_t size = buffer.size(); std::size_t size = buffer.size();
return std::fwrite( return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
buffer.data(), sizeof(Char), size, f) < size ? -1 : static_cast<int>(size); ? -1
: static_cast<int>(size);
} }
/** /**
@ -783,19 +791,20 @@ inline int vfprintf(std::FILE *f, const S &format,
*/ */
template <typename S, typename... Args> template <typename S, typename... Args>
inline FMT_ENABLE_IF_T(internal::is_string<S>::value, int) inline FMT_ENABLE_IF_T(internal::is_string<S>::value, int)
fprintf(std::FILE *f, const S &format, const Args & ... args) { fprintf(std::FILE *f, const S &format, const Args &... args) {
internal::check_format_string<Args...>(format); internal::check_format_string<Args...>(format);
typedef internal::basic_buffer<FMT_CHAR(S)> buffer; typedef internal::basic_buffer<FMT_CHAR(S)> buffer;
typedef typename basic_printf_context_t<buffer>::type context; typedef typename basic_printf_context_t<buffer>::type context;
format_arg_store<context, Args...> as{ args... }; format_arg_store<context, Args...> as{args...};
return vfprintf(f, to_string_view(format), return vfprintf(f, to_string_view(format), basic_format_args<context>(as));
basic_format_args<context>(as));
} }
template <typename S, typename Char = FMT_CHAR(S)> template <typename S, typename Char = FMT_CHAR(S)>
inline int vprintf(const S &format, inline int vprintf(
basic_format_args<typename basic_printf_context_t< const S &format,
internal::basic_buffer<Char>>::type> args) { basic_format_args<
typename basic_printf_context_t<internal::basic_buffer<Char>>::type>
args) {
return vfprintf(stdout, to_string_view(format), args); return vfprintf(stdout, to_string_view(format), args);
} }
@ -810,20 +819,20 @@ inline int vprintf(const S &format,
*/ */
template <typename S, typename... Args> template <typename S, typename... Args>
inline FMT_ENABLE_IF_T(internal::is_string<S>::value, int) inline FMT_ENABLE_IF_T(internal::is_string<S>::value, int)
printf(const S &format_str, const Args & ... args) { printf(const S &format_str, const Args &... args) {
internal::check_format_string<Args...>(format_str); internal::check_format_string<Args...>(format_str);
typedef internal::basic_buffer<FMT_CHAR(S)> buffer; typedef internal::basic_buffer<FMT_CHAR(S)> buffer;
typedef typename basic_printf_context_t<buffer>::type context; typedef typename basic_printf_context_t<buffer>::type context;
format_arg_store<context, Args...> as{ args... }; format_arg_store<context, Args...> as{args...};
return vprintf(to_string_view(format_str), return vprintf(to_string_view(format_str), basic_format_args<context>(as));
basic_format_args<context>(as));
} }
template <typename S, typename Char = FMT_CHAR(S)> template <typename S, typename Char = FMT_CHAR(S)>
inline int vfprintf(std::basic_ostream<Char> &os, inline int vfprintf(
const S &format, std::basic_ostream<Char> &os, const S &format,
basic_format_args<typename basic_printf_context_t< basic_format_args<
internal::basic_buffer<Char>>::type> args) { typename basic_printf_context_t<internal::basic_buffer<Char>>::type>
args) {
basic_memory_buffer<Char> buffer; basic_memory_buffer<Char> buffer;
printf(buffer, to_string_view(format), args); printf(buffer, to_string_view(format), args);
internal::write(os, buffer); internal::write(os, buffer);
@ -841,12 +850,12 @@ inline int vfprintf(std::basic_ostream<Char> &os,
*/ */
template <typename S, typename... Args> template <typename S, typename... Args>
inline FMT_ENABLE_IF_T(internal::is_string<S>::value, int) inline FMT_ENABLE_IF_T(internal::is_string<S>::value, int)
fprintf(std::basic_ostream<FMT_CHAR(S)> &os, fprintf(std::basic_ostream<FMT_CHAR(S)> &os, const S &format_str,
const S &format_str, const Args & ... args) { const Args &... args) {
internal::check_format_string<Args...>(format_str); internal::check_format_string<Args...>(format_str);
typedef internal::basic_buffer<FMT_CHAR(S)> buffer; typedef internal::basic_buffer<FMT_CHAR(S)> buffer;
typedef typename basic_printf_context_t<buffer>::type context; typedef typename basic_printf_context_t<buffer>::type context;
format_arg_store<context, Args...> as{ args... }; format_arg_store<context, Args...> as{args...};
return vfprintf(os, to_string_view(format_str), return vfprintf(os, to_string_view(format_str),
basic_format_args<context>(as)); basic_format_args<context>(as));
} }

109
src/cpp/include/deps/spdlog/fmt/bundled/ranges.h Executable file → Normal file
View File

@ -12,12 +12,13 @@
#ifndef FMT_RANGES_H_ #ifndef FMT_RANGES_H_
#define FMT_RANGES_H_ #define FMT_RANGES_H_
#include "format.h"
#include <type_traits> #include <type_traits>
#include "format.h"
// output only up to N items from the range. // output only up to N items from the range.
#ifndef FMT_RANGE_OUTPUT_LENGTH_LIMIT #ifndef FMT_RANGE_OUTPUT_LENGTH_LIMIT
# define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256 #define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
#endif #endif
FMT_BEGIN_NAMESPACE FMT_BEGIN_NAMESPACE
@ -33,7 +34,8 @@ struct formatting_base {
template <typename Char, typename Enable = void> template <typename Char, typename Enable = void>
struct formatting_range : formatting_base<Char> { struct formatting_range : formatting_base<Char> {
static FMT_CONSTEXPR_DECL const std::size_t range_length_limit = static FMT_CONSTEXPR_DECL const std::size_t range_length_limit =
FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the range. FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the
// range.
Char prefix; Char prefix;
Char delimiter; Char delimiter;
Char postfix; Char postfix;
@ -77,14 +79,14 @@ void copy(char ch, OutputIterator out) {
template <typename T> template <typename T>
class is_like_std_string { class is_like_std_string {
template <typename U> template <typename U>
static auto check(U *p) -> static auto check(U *p)
decltype(p->find('a'), p->length(), p->data(), int()); -> decltype(p->find('a'), p->length(), p->data(), int());
template <typename> template <typename>
static void check(...); static void check(...);
public: public:
static FMT_CONSTEXPR_DECL const bool value = static FMT_CONSTEXPR_DECL const bool value =
!std::is_void<decltype(check<T>(FMT_NULL))>::value; !std::is_void<decltype(check<T>(FMT_NULL))>::value;
}; };
template <typename Char> template <typename Char>
@ -98,26 +100,28 @@ struct is_range_ : std::false_type {};
#if !FMT_MSC_VER || FMT_MSC_VER > 1800 #if !FMT_MSC_VER || FMT_MSC_VER > 1800
template <typename T> template <typename T>
struct is_range_<T, typename std::conditional< struct is_range_<
false, T, typename std::conditional<
conditional_helper<decltype(internal::declval<T>().begin()), false,
decltype(internal::declval<T>().end())>, conditional_helper<decltype(internal::declval<T>().begin()),
void>::type> : std::true_type {}; decltype(internal::declval<T>().end())>,
void>::type> : std::true_type {};
#endif #endif
/// tuple_size and tuple_element check. /// tuple_size and tuple_element check.
template <typename T> template <typename T>
class is_tuple_like_ { class is_tuple_like_ {
template <typename U> template <typename U>
static auto check(U *p) -> static auto check(U *p)
decltype(std::tuple_size<U>::value, -> decltype(std::tuple_size<U>::value,
internal::declval<typename std::tuple_element<0, U>::type>(), int()); internal::declval<typename std::tuple_element<0, U>::type>(),
int());
template <typename> template <typename>
static void check(...); static void check(...);
public: public:
static FMT_CONSTEXPR_DECL const bool value = static FMT_CONSTEXPR_DECL const bool value =
!std::is_void<decltype(check<T>(FMT_NULL))>::value; !std::is_void<decltype(check<T>(FMT_NULL))>::value;
}; };
// Check for integer_sequence // Check for integer_sequence
@ -133,9 +137,7 @@ template <typename T, T... N>
struct integer_sequence { struct integer_sequence {
typedef T value_type; typedef T value_type;
static FMT_CONSTEXPR std::size_t size() { static FMT_CONSTEXPR std::size_t size() { return sizeof...(N); }
return sizeof...(N);
}
}; };
template <std::size_t... N> template <std::size_t... N>
@ -159,8 +161,10 @@ void for_each(index_sequence<Is...>, Tuple &&tup, F &&f) FMT_NOEXCEPT {
} }
template <class T> template <class T>
FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(
get_indexes(T const &) { return {}; } T const &) {
return {};
}
template <class Tuple, class F> template <class Tuple, class F>
void for_each(Tuple &&tup, F &&f) { void for_each(Tuple &&tup, F &&f) {
@ -168,32 +172,37 @@ void for_each(Tuple &&tup, F &&f) {
for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f)); for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
} }
template<typename Arg> template <typename Arg>
FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&, FMT_CONSTEXPR const char *format_str_quoted(
typename std::enable_if< bool add_space, const Arg &,
!is_like_std_string<typename std::decay<Arg>::type>::value>::type* = nullptr) { typename std::enable_if<
!is_like_std_string<typename std::decay<Arg>::type>::value>::type * =
nullptr) {
return add_space ? " {}" : "{}"; return add_space ? " {}" : "{}";
} }
template<typename Arg> template <typename Arg>
FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&, FMT_CONSTEXPR const char *format_str_quoted(
typename std::enable_if< bool add_space, const Arg &,
is_like_std_string<typename std::decay<Arg>::type>::value>::type* = nullptr) { typename std::enable_if<
is_like_std_string<typename std::decay<Arg>::type>::value>::type * =
nullptr) {
return add_space ? " \"{}\"" : "\"{}\""; return add_space ? " \"{}\"" : "\"{}\"";
} }
FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char*) { FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const char *) {
return add_space ? " \"{}\"" : "\"{}\""; return add_space ? " \"{}\"" : "\"{}\"";
} }
FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t*) { FMT_CONSTEXPR const wchar_t *format_str_quoted(bool add_space,
return add_space ? L" \"{}\"" : L"\"{}\""; const wchar_t *) {
return add_space ? L" \"{}\"" : L"\"{}\"";
} }
FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char) { FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const char) {
return add_space ? " '{}'" : "'{}'"; return add_space ? " '{}'" : "'{}'";
} }
FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t) { FMT_CONSTEXPR const wchar_t *format_str_quoted(bool add_space, const wchar_t) {
return add_space ? L" '{}'" : L"'{}'"; return add_space ? L" '{}'" : L"'{}'";
} }
} // namespace internal } // namespace internal
@ -201,18 +210,19 @@ FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t) {
template <typename T> template <typename T>
struct is_tuple_like { struct is_tuple_like {
static FMT_CONSTEXPR_DECL const bool value = static FMT_CONSTEXPR_DECL const bool value =
internal::is_tuple_like_<T>::value && !internal::is_range_<T>::value; internal::is_tuple_like_<T>::value && !internal::is_range_<T>::value;
}; };
template <typename TupleT, typename Char> template <typename TupleT, typename Char>
struct formatter<TupleT, Char, struct formatter<
TupleT, Char,
typename std::enable_if<fmt::is_tuple_like<TupleT>::value>::type> { typename std::enable_if<fmt::is_tuple_like<TupleT>::value>::type> {
private: private:
// C++11 generic lambda for format() // C++11 generic lambda for format()
template <typename FormatContext> template <typename FormatContext>
struct format_each { struct format_each {
template <typename T> template <typename T>
void operator()(const T& v) { void operator()(const T &v) {
if (i > 0) { if (i > 0) {
if (formatting.add_prepostfix_space) { if (formatting.add_prepostfix_space) {
*out++ = ' '; *out++ = ' ';
@ -226,12 +236,13 @@ private:
++i; ++i;
} }
formatting_tuple<Char>& formatting; formatting_tuple<Char> &formatting;
std::size_t& i; std::size_t &i;
typename std::add_lvalue_reference<decltype(std::declval<FormatContext>().out())>::type out; typename std::add_lvalue_reference<decltype(
std::declval<FormatContext>().out())>::type out;
}; };
public: public:
formatting_tuple<Char> formatting; formatting_tuple<Char> formatting;
template <typename ParseContext> template <typename ParseContext>
@ -258,13 +269,12 @@ public:
template <typename T> template <typename T>
struct is_range { struct is_range {
static FMT_CONSTEXPR_DECL const bool value = static FMT_CONSTEXPR_DECL const bool value =
internal::is_range_<T>::value && !internal::is_like_std_string<T>::value; internal::is_range_<T>::value && !internal::is_like_std_string<T>::value;
}; };
template <typename RangeT, typename Char> template <typename RangeT, typename Char>
struct formatter<RangeT, Char, struct formatter<RangeT, Char,
typename std::enable_if<fmt::is_range<RangeT>::value>::type> { typename std::enable_if<fmt::is_range<RangeT>::value>::type> {
formatting_range<Char> formatting; formatting_range<Char> formatting;
template <typename ParseContext> template <typename ParseContext>
@ -273,8 +283,8 @@ struct formatter<RangeT, Char,
} }
template <typename FormatContext> template <typename FormatContext>
typename FormatContext::iterator format( typename FormatContext::iterator format(const RangeT &values,
const RangeT &values, FormatContext &ctx) { FormatContext &ctx) {
auto out = ctx.out(); auto out = ctx.out();
internal::copy(formatting.prefix, out); internal::copy(formatting.prefix, out);
std::size_t i = 0; std::size_t i = 0;
@ -304,5 +314,4 @@ struct formatter<RangeT, Char,
FMT_END_NAMESPACE FMT_END_NAMESPACE
#endif // FMT_RANGES_H_ #endif // FMT_RANGES_H_

25
src/cpp/include/deps/spdlog/fmt/bundled/time.h Executable file → Normal file
View File

@ -8,17 +8,18 @@
#ifndef FMT_TIME_H_ #ifndef FMT_TIME_H_
#define FMT_TIME_H_ #define FMT_TIME_H_
#include "format.h"
#include <ctime> #include <ctime>
#include <locale> #include <locale>
#include "format.h"
FMT_BEGIN_NAMESPACE FMT_BEGIN_NAMESPACE
// Prevents expansion of a preceding token as a function-style macro. // Prevents expansion of a preceding token as a function-style macro.
// Usage: f FMT_NOMACRO() // Usage: f FMT_NOMACRO()
#define FMT_NOMACRO #define FMT_NOMACRO
namespace internal{ namespace internal {
inline null<> localtime_r FMT_NOMACRO(...) { return null<>(); } inline null<> localtime_r FMT_NOMACRO(...) { return null<>(); }
inline null<> localtime_s(...) { return null<>(); } inline null<> localtime_s(...) { return null<>(); }
inline null<> gmtime_r(...) { return null<>(); } inline null<> gmtime_r(...) { return null<>(); }
@ -31,7 +32,7 @@ inline std::tm localtime(std::time_t time) {
std::time_t time_; std::time_t time_;
std::tm tm_; std::tm tm_;
dispatcher(std::time_t t): time_(t) {} dispatcher(std::time_t t) : time_(t) {}
bool run() { bool run() {
using namespace fmt::internal; using namespace fmt::internal;
@ -58,8 +59,7 @@ inline std::tm localtime(std::time_t time) {
}; };
dispatcher lt(time); dispatcher lt(time);
// Too big time values may be unsupported. // Too big time values may be unsupported.
if (!lt.run()) if (!lt.run()) FMT_THROW(format_error("time_t value out of range"));
FMT_THROW(format_error("time_t value out of range"));
return lt.tm_; return lt.tm_;
} }
@ -69,7 +69,7 @@ inline std::tm gmtime(std::time_t time) {
std::time_t time_; std::time_t time_;
std::tm tm_; std::tm tm_;
dispatcher(std::time_t t): time_(t) {} dispatcher(std::time_t t) : time_(t) {}
bool run() { bool run() {
using namespace fmt::internal; using namespace fmt::internal;
@ -95,8 +95,7 @@ inline std::tm gmtime(std::time_t time) {
}; };
dispatcher gt(time); dispatcher gt(time);
// Too big time values may be unsupported. // Too big time values may be unsupported.
if (!gt.run()) if (!gt.run()) FMT_THROW(format_error("time_t value out of range"));
FMT_THROW(format_error("time_t value out of range"));
return gt.tm_; return gt.tm_;
} }
@ -110,18 +109,16 @@ inline std::size_t strftime(wchar_t *str, std::size_t count,
const wchar_t *format, const std::tm *time) { const wchar_t *format, const std::tm *time) {
return std::wcsftime(str, count, format, time); return std::wcsftime(str, count, format, time);
} }
} } // namespace internal
template <typename Char> template <typename Char>
struct formatter<std::tm, Char> { struct formatter<std::tm, Char> {
template <typename ParseContext> template <typename ParseContext>
auto parse(ParseContext &ctx) -> decltype(ctx.begin()) { auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
auto it = ctx.begin(); auto it = ctx.begin();
if (it != ctx.end() && *it == ':') if (it != ctx.end() && *it == ':') ++it;
++it;
auto end = it; auto end = it;
while (end != ctx.end() && *end != '}') while (end != ctx.end() && *end != '}') ++end;
++end;
tm_format.reserve(internal::to_unsigned(end - it + 1)); tm_format.reserve(internal::to_unsigned(end - it + 1));
tm_format.append(it, end); tm_format.append(it, end);
tm_format.push_back('\0'); tm_format.push_back('\0');
@ -135,7 +132,7 @@ struct formatter<std::tm, Char> {
for (;;) { for (;;) {
std::size_t size = buf.capacity() - start; std::size_t size = buf.capacity() - start;
std::size_t count = std::size_t count =
internal::strftime(&buf[start], size, &tm_format[0], &tm); internal::strftime(&buf[start], size, &tm_format[0], &tm);
if (count != 0) { if (count != 0) {
buf.resize(start + count); buf.resize(start + count);
break; break;

2
src/cpp/include/deps/spdlog/fmt/fmt.h Executable file → Normal file
View File

@ -19,7 +19,7 @@
#endif #endif
#include "bundled/core.h" #include "bundled/core.h"
#include "bundled/format.h" #include "bundled/format.h"
#else // external fmtlib #else // external fmtlib
#include <fmt/core.h> #include <fmt/core.h>
#include <fmt/format.h> #include <fmt/format.h>
#endif #endif

14
src/cpp/include/deps/spdlog/formatter.h Executable file → Normal file
View File

@ -10,11 +10,11 @@
namespace spdlog { namespace spdlog {
class formatter class formatter {
{ public:
public: virtual ~formatter() = default;
virtual ~formatter() = default; virtual void format(const details::log_msg &msg,
virtual void format(const details::log_msg &msg, fmt::memory_buffer &dest) = 0; fmt::memory_buffer &dest) = 0;
virtual std::unique_ptr<formatter> clone() const = 0; virtual std::unique_ptr<formatter> clone() const = 0;
}; };
} // namespace spdlog } // namespace spdlog

236
src/cpp/include/deps/spdlog/logger.h Executable file → Normal file
View File

@ -18,171 +18,183 @@
// formatted data, // formatted data,
// and support customize format per each sink. // and support customize format per each sink.
#include "spdlog/common.h"
#include "spdlog/formatter.h"
#include "spdlog/sinks/sink.h"
#include <memory> #include <memory>
#include <string> #include <string>
#include <vector> #include <vector>
#include "spdlog/common.h"
#include "spdlog/formatter.h"
#include "spdlog/sinks/sink.h"
namespace spdlog { namespace spdlog {
class logger class logger {
{ public:
public: logger(std::string name, sink_ptr single_sink);
logger(std::string name, sink_ptr single_sink); logger(std::string name, sinks_init_list sinks);
logger(std::string name, sinks_init_list sinks);
template<typename It> template <typename It>
logger(std::string name, It begin, It end); logger(std::string name, It begin, It end);
virtual ~logger(); virtual ~logger();
logger(const logger &) = delete; logger(const logger &) = delete;
logger &operator=(const logger &) = delete; logger &operator=(const logger &) = delete;
template<typename... Args> template <typename... Args>
void log(level::level_enum lvl, const char *fmt, const Args &... args); void log(level::level_enum lvl, const char *fmt, const Args &... args);
template<typename... Args> template <typename... Args>
void log(source_loc loc, level::level_enum lvl, const char *fmt, const Args &... args); void log(source_loc loc, level::level_enum lvl, const char *fmt,
const Args &... args);
void log(level::level_enum lvl, const char *msg); void log(level::level_enum lvl, const char *msg);
void log(source_loc loc, level::level_enum lvl, const char *msg); void log(source_loc loc, level::level_enum lvl, const char *msg);
template<typename... Args> template <typename... Args>
void trace(const char *fmt, const Args &... args); void trace(const char *fmt, const Args &... args);
template<typename... Args> template <typename... Args>
void debug(const char *fmt, const Args &... args); void debug(const char *fmt, const Args &... args);
template<typename... Args> template <typename... Args>
void info(const char *fmt, const Args &... args); void info(const char *fmt, const Args &... args);
template<typename... Args> template <typename... Args>
void warn(const char *fmt, const Args &... args); void warn(const char *fmt, const Args &... args);
template<typename... Args> template <typename... Args>
void error(const char *fmt, const Args &... args); void error(const char *fmt, const Args &... args);
template<typename... Args> template <typename... Args>
void critical(const char *fmt, const Args &... args); void critical(const char *fmt, const Args &... args);
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
#ifndef _WIN32 #ifndef _WIN32
#error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows #error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows
#else #else
template<typename... Args> template <typename... Args>
void log(level::level_enum lvl, const wchar_t *fmt, const Args &... args); void log(level::level_enum lvl, const wchar_t *fmt, const Args &... args);
template<typename... Args> template <typename... Args>
void log(source_loc source, level::level_enum lvl, const wchar_t *fmt, const Args &... args); void log(source_loc source, level::level_enum lvl, const wchar_t *fmt,
const Args &... args);
template<typename... Args> template <typename... Args>
void trace(const wchar_t *fmt, const Args &... args); void trace(const wchar_t *fmt, const Args &... args);
template<typename... Args> template <typename... Args>
void debug(const wchar_t *fmt, const Args &... args); void debug(const wchar_t *fmt, const Args &... args);
template<typename... Args> template <typename... Args>
void info(const wchar_t *fmt, const Args &... args); void info(const wchar_t *fmt, const Args &... args);
template<typename... Args> template <typename... Args>
void warn(const wchar_t *fmt, const Args &... args); void warn(const wchar_t *fmt, const Args &... args);
template<typename... Args> template <typename... Args>
void error(const wchar_t *fmt, const Args &... args); void error(const wchar_t *fmt, const Args &... args);
template<typename... Args> template <typename... Args>
void critical(const wchar_t *fmt, const Args &... args); void critical(const wchar_t *fmt, const Args &... args);
#endif // _WIN32 #endif // _WIN32
#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT #endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
// T can be statically converted to string_view // T can be statically converted to string_view
template<class T, typename std::enable_if<std::is_convertible<T, spdlog::string_view_t>::value, T>::type * = nullptr> template <class T, typename std::enable_if<
void log(level::level_enum lvl, const T &); std::is_convertible<T, spdlog::string_view_t>::value,
T>::type * = nullptr>
void log(level::level_enum lvl, const T &);
// T can be statically converted to string_view // T can be statically converted to string_view
template<class T, typename std::enable_if<std::is_convertible<T, spdlog::string_view_t>::value, T>::type * = nullptr> template <class T, typename std::enable_if<
void log(source_loc loc, level::level_enum lvl, const T &); std::is_convertible<T, spdlog::string_view_t>::value,
T>::type * = nullptr>
void log(source_loc loc, level::level_enum lvl, const T &);
// T cannot be statically converted to string_view // T cannot be statically converted to string_view
template<class T, typename std::enable_if<!std::is_convertible<T, spdlog::string_view_t>::value, T>::type * = nullptr> template <class T, typename std::enable_if<
void log(level::level_enum lvl, const T &); !std::is_convertible<T, spdlog::string_view_t>::value,
T>::type * = nullptr>
void log(level::level_enum lvl, const T &);
// T cannot be statically converted to string_view // T cannot be statically converted to string_view
template<class T, typename std::enable_if<!std::is_convertible<T, spdlog::string_view_t>::value, T>::type * = nullptr> template <class T, typename std::enable_if<
void log(source_loc loc, level::level_enum lvl, const T &); !std::is_convertible<T, spdlog::string_view_t>::value,
T>::type * = nullptr>
void log(source_loc loc, level::level_enum lvl, const T &);
template<typename T> template <typename T>
void trace(const T &msg); void trace(const T &msg);
template<typename T> template <typename T>
void debug(const T &msg); void debug(const T &msg);
template<typename T> template <typename T>
void info(const T &msg); void info(const T &msg);
template<typename T> template <typename T>
void warn(const T &msg); void warn(const T &msg);
template<typename T> template <typename T>
void error(const T &msg); void error(const T &msg);
template<typename T> template <typename T>
void critical(const T &msg); void critical(const T &msg);
bool should_log(level::level_enum msg_level) const; bool should_log(level::level_enum msg_level) const;
void set_level(level::level_enum log_level); void set_level(level::level_enum log_level);
static level::level_enum default_level(); static level::level_enum default_level();
level::level_enum level() const; level::level_enum level() const;
const std::string &name() const; const std::string &name() const;
// set formatting for the sinks in this logger. // set formatting for the sinks in this logger.
// each sink will get a seperate instance of the formatter object. // each sink will get a seperate instance of the formatter object.
void set_formatter(std::unique_ptr<formatter> formatter); void set_formatter(std::unique_ptr<formatter> formatter);
void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local); void set_pattern(std::string pattern,
pattern_time_type time_type = pattern_time_type::local);
// flush functions // flush functions
void flush(); void flush();
void flush_on(level::level_enum log_level); void flush_on(level::level_enum log_level);
level::level_enum flush_level() const; level::level_enum flush_level() const;
// sinks // sinks
const std::vector<sink_ptr> &sinks() const; const std::vector<sink_ptr> &sinks() const;
std::vector<sink_ptr> &sinks(); std::vector<sink_ptr> &sinks();
// error handler // error handler
void set_error_handler(log_err_handler err_handler); void set_error_handler(log_err_handler err_handler);
log_err_handler error_handler() const; log_err_handler error_handler() const;
// create new logger with same sinks and configuration. // create new logger with same sinks and configuration.
virtual std::shared_ptr<logger> clone(std::string logger_name); virtual std::shared_ptr<logger> clone(std::string logger_name);
protected: protected:
virtual void sink_it_(details::log_msg &msg); virtual void sink_it_(details::log_msg &msg);
virtual void flush_(); virtual void flush_();
bool should_flush_(const details::log_msg &msg); bool should_flush_(const details::log_msg &msg);
// default error handler. // default error handler.
// print the error to stderr with the max rate of 1 message/minute. // print the error to stderr with the max rate of 1 message/minute.
void default_err_handler_(const std::string &msg); void default_err_handler_(const std::string &msg);
// increment the message count (only if defined(SPDLOG_ENABLE_MESSAGE_COUNTER)) // increment the message count (only if
void incr_msg_counter_(details::log_msg &msg); // defined(SPDLOG_ENABLE_MESSAGE_COUNTER))
void incr_msg_counter_(details::log_msg &msg);
const std::string name_; const std::string name_;
std::vector<sink_ptr> sinks_; std::vector<sink_ptr> sinks_;
spdlog::level_t level_{spdlog::logger::default_level()}; spdlog::level_t level_{spdlog::logger::default_level()};
spdlog::level_t flush_level_{level::off}; spdlog::level_t flush_level_{level::off};
log_err_handler err_handler_{[this](const std::string &msg) { this->default_err_handler_(msg); }}; log_err_handler err_handler_{
std::atomic<time_t> last_err_time_{0}; [this](const std::string &msg) { this->default_err_handler_(msg); }};
std::atomic<size_t> msg_counter_{1}; std::atomic<time_t> last_err_time_{0};
std::atomic<size_t> msg_counter_{1};
}; };
} // namespace spdlog } // namespace spdlog
#include "details/logger_impl.h" #include "details/logger_impl.h"

142
src/cpp/include/deps/spdlog/sinks/android_sink.h Executable file → Normal file
View File

@ -9,17 +9,18 @@
#include "spdlog/spdlog.h" #include "spdlog/spdlog.h"
#endif #endif
#include "spdlog/details/fmt_helper.h"
#include "spdlog/details/null_mutex.h"
#include "spdlog/details/os.h"
#include "spdlog/sinks/base_sink.h"
#include <android/log.h> #include <android/log.h>
#include <chrono> #include <chrono>
#include <mutex> #include <mutex>
#include <string> #include <string>
#include <thread> #include <thread>
#include "spdlog/details/fmt_helper.h"
#include "spdlog/details/null_mutex.h"
#include "spdlog/details/os.h"
#include "spdlog/sinks/base_sink.h"
#if !defined(SPDLOG_ANDROID_RETRIES) #if !defined(SPDLOG_ANDROID_RETRIES)
#define SPDLOG_ANDROID_RETRIES 2 #define SPDLOG_ANDROID_RETRIES 2
#endif #endif
@ -30,92 +31,81 @@ namespace sinks {
/* /*
* Android sink (logging using __android_log_write) * Android sink (logging using __android_log_write)
*/ */
template<typename Mutex> template <typename Mutex>
class android_sink final : public base_sink<Mutex> class android_sink final : public base_sink<Mutex> {
{ public:
public: explicit android_sink(std::string tag = "spdlog", bool use_raw_msg = false)
explicit android_sink(std::string tag = "spdlog", bool use_raw_msg = false) : tag_(std::move(tag)), use_raw_msg_(use_raw_msg) {}
: tag_(std::move(tag))
, use_raw_msg_(use_raw_msg) protected:
{ void sink_it_(const details::log_msg &msg) override {
const android_LogPriority priority = convert_to_android_(msg.level);
fmt::memory_buffer formatted;
if (use_raw_msg_) {
details::fmt_helper::append_string_view(msg.payload, formatted);
} else {
sink::formatter_->format(msg, formatted);
}
formatted.push_back('\0');
const char *msg_output = formatted.data();
// See system/core/liblog/logger_write.c for explanation of return value
int ret = __android_log_write(priority, tag_.c_str(), msg_output);
int retry_count = 0;
while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES)) {
details::os::sleep_for_millis(5);
ret = __android_log_write(priority, tag_.c_str(), msg_output);
retry_count++;
} }
protected: if (ret < 0) {
void sink_it_(const details::log_msg &msg) override throw spdlog_ex("__android_log_write() failed", ret);
{
const android_LogPriority priority = convert_to_android_(msg.level);
fmt::memory_buffer formatted;
if (use_raw_msg_)
{
details::fmt_helper::append_string_view(msg.payload, formatted);
}
else
{
sink::formatter_->format(msg, formatted);
}
formatted.push_back('\0');
const char *msg_output = formatted.data();
// See system/core/liblog/logger_write.c for explanation of return value
int ret = __android_log_write(priority, tag_.c_str(), msg_output);
int retry_count = 0;
while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES))
{
details::os::sleep_for_millis(5);
ret = __android_log_write(priority, tag_.c_str(), msg_output);
retry_count++;
}
if (ret < 0)
{
throw spdlog_ex("__android_log_write() failed", ret);
}
} }
}
void flush_() override {} void flush_() override {}
private: private:
static android_LogPriority convert_to_android_(spdlog::level::level_enum level) static android_LogPriority convert_to_android_(
{ spdlog::level::level_enum level) {
switch (level) switch (level) {
{ case spdlog::level::trace:
case spdlog::level::trace: return ANDROID_LOG_VERBOSE;
return ANDROID_LOG_VERBOSE; case spdlog::level::debug:
case spdlog::level::debug: return ANDROID_LOG_DEBUG;
return ANDROID_LOG_DEBUG; case spdlog::level::info:
case spdlog::level::info: return ANDROID_LOG_INFO;
return ANDROID_LOG_INFO; case spdlog::level::warn:
case spdlog::level::warn: return ANDROID_LOG_WARN;
return ANDROID_LOG_WARN; case spdlog::level::err:
case spdlog::level::err: return ANDROID_LOG_ERROR;
return ANDROID_LOG_ERROR; case spdlog::level::critical:
case spdlog::level::critical: return ANDROID_LOG_FATAL;
return ANDROID_LOG_FATAL; default:
default: return ANDROID_LOG_DEFAULT;
return ANDROID_LOG_DEFAULT;
}
} }
}
std::string tag_; std::string tag_;
bool use_raw_msg_; bool use_raw_msg_;
}; };
using android_sink_mt = android_sink<std::mutex>; using android_sink_mt = android_sink<std::mutex>;
using android_sink_st = android_sink<details::null_mutex>; using android_sink_st = android_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
// Create and register android syslog logger // Create and register android syslog logger
template<typename Factory = default_factory> template <typename Factory = default_factory>
inline std::shared_ptr<logger> android_logger_mt(const std::string &logger_name, const std::string &tag = "spdlog") inline std::shared_ptr<logger> android_logger_mt(
{ const std::string &logger_name, const std::string &tag = "spdlog") {
return Factory::template create<sinks::android_sink_mt>(logger_name, tag); return Factory::template create<sinks::android_sink_mt>(logger_name, tag);
} }
template<typename Factory = default_factory> template <typename Factory = default_factory>
inline std::shared_ptr<logger> android_logger_st(const std::string &logger_name, const std::string &tag = "spdlog") inline std::shared_ptr<logger> android_logger_st(
{ const std::string &logger_name, const std::string &tag = "spdlog") {
return Factory::template create<sinks::android_sink_st>(logger_name, tag); return Factory::template create<sinks::android_sink_st>(logger_name, tag);
} }
} // namespace spdlog } // namespace spdlog

243
src/cpp/include/deps/spdlog/sinks/ansicolor_sink.h Executable file → Normal file
View File

@ -9,16 +9,16 @@
#include "spdlog/spdlog.h" #include "spdlog/spdlog.h"
#endif #endif
#include "spdlog/details/console_globals.h"
#include "spdlog/details/null_mutex.h"
#include "spdlog/details/os.h"
#include "spdlog/sinks/sink.h"
#include <memory> #include <memory>
#include <mutex> #include <mutex>
#include <string> #include <string>
#include <unordered_map> #include <unordered_map>
#include "spdlog/details/console_globals.h"
#include "spdlog/details/null_mutex.h"
#include "spdlog/details/os.h"
#include "spdlog/sinks/sink.h"
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
@ -28,134 +28,133 @@ namespace sinks {
* of the message. * of the message.
* If no color terminal detected, omit the escape codes. * If no color terminal detected, omit the escape codes.
*/ */
template<typename TargetStream, class ConsoleMutex> template <typename TargetStream, class ConsoleMutex>
class ansicolor_sink final : public sink class ansicolor_sink final : public sink {
{ public:
public: using mutex_t = typename ConsoleMutex::mutex_t;
using mutex_t = typename ConsoleMutex::mutex_t; ansicolor_sink()
ansicolor_sink() : target_file_(TargetStream::stream()),
: target_file_(TargetStream::stream()) mutex_(ConsoleMutex::mutex())
, mutex_(ConsoleMutex::mutex())
{
should_do_colors_ = details::os::in_terminal(target_file_) &&
details::os::is_color_terminal();
colors_[level::trace] = white;
colors_[level::debug] = cyan;
colors_[level::info] = green;
colors_[level::warn] = yellow + bold;
colors_[level::err] = red + bold;
colors_[level::critical] = bold + on_red;
colors_[level::off] = reset;
}
~ansicolor_sink() override = default;
ansicolor_sink(const ansicolor_sink &other) = delete;
ansicolor_sink &operator=(const ansicolor_sink &other) = delete;
void set_color(level::level_enum color_level, const std::string &color) {
std::lock_guard<mutex_t> lock(mutex_);
colors_[color_level] = color;
}
/// Formatting codes
const std::string reset = "\033[m";
const std::string bold = "\033[1m";
const std::string dark = "\033[2m";
const std::string underline = "\033[4m";
const std::string blink = "\033[5m";
const std::string reverse = "\033[7m";
const std::string concealed = "\033[8m";
const std::string clear_line = "\033[K";
// Foreground colors
const std::string black = "\033[30m";
const std::string red = "\033[31m";
const std::string green = "\033[32m";
const std::string yellow = "\033[33m";
const std::string blue = "\033[34m";
const std::string magenta = "\033[35m";
const std::string cyan = "\033[36m";
const std::string white = "\033[37m";
/// Background colors
const std::string on_black = "\033[40m";
const std::string on_red = "\033[41m";
const std::string on_green = "\033[42m";
const std::string on_yellow = "\033[43m";
const std::string on_blue = "\033[44m";
const std::string on_magenta = "\033[45m";
const std::string on_cyan = "\033[46m";
const std::string on_white = "\033[47m";
void log(const details::log_msg &msg) override {
// Wrap the originally formatted message in color codes.
// If color is not supported in the terminal, log as is instead.
std::lock_guard<mutex_t> lock(mutex_);
fmt::memory_buffer formatted;
formatter_->format(msg, formatted);
if (should_do_colors_ && msg.color_range_end > msg.color_range_start) {
// before color range
print_range_(formatted, 0, msg.color_range_start);
// in color range
print_ccode_(colors_[msg.level]);
print_range_(formatted, msg.color_range_start, msg.color_range_end);
print_ccode_(reset);
// after color range
print_range_(formatted, msg.color_range_end, formatted.size());
} else // no color
{ {
should_do_colors_ = details::os::in_terminal(target_file_) && details::os::is_color_terminal(); print_range_(formatted, 0, formatted.size());
colors_[level::trace] = white;
colors_[level::debug] = cyan;
colors_[level::info] = green;
colors_[level::warn] = yellow + bold;
colors_[level::err] = red + bold;
colors_[level::critical] = bold + on_red;
colors_[level::off] = reset;
} }
fflush(target_file_);
}
~ansicolor_sink() override = default; void flush() override {
std::lock_guard<mutex_t> lock(mutex_);
fflush(target_file_);
}
ansicolor_sink(const ansicolor_sink &other) = delete; void set_pattern(const std::string &pattern) final {
ansicolor_sink &operator=(const ansicolor_sink &other) = delete; std::lock_guard<mutex_t> lock(mutex_);
formatter_ =
std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
}
void set_color(level::level_enum color_level, const std::string &color) void set_formatter(
{ std::unique_ptr<spdlog::formatter> sink_formatter) override {
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
colors_[color_level] = color; formatter_ = std::move(sink_formatter);
} }
/// Formatting codes private:
const std::string reset = "\033[m"; void print_ccode_(const std::string &color_code) {
const std::string bold = "\033[1m"; fwrite(color_code.data(), sizeof(char), color_code.size(), target_file_);
const std::string dark = "\033[2m"; }
const std::string underline = "\033[4m"; void print_range_(const fmt::memory_buffer &formatted, size_t start,
const std::string blink = "\033[5m"; size_t end) {
const std::string reverse = "\033[7m"; fwrite(formatted.data() + start, sizeof(char), end - start, target_file_);
const std::string concealed = "\033[8m"; }
const std::string clear_line = "\033[K";
// Foreground colors FILE *target_file_;
const std::string black = "\033[30m"; mutex_t &mutex_;
const std::string red = "\033[31m";
const std::string green = "\033[32m";
const std::string yellow = "\033[33m";
const std::string blue = "\033[34m";
const std::string magenta = "\033[35m";
const std::string cyan = "\033[36m";
const std::string white = "\033[37m";
/// Background colors bool should_do_colors_;
const std::string on_black = "\033[40m"; std::unordered_map<level::level_enum, std::string, level::level_hasher>
const std::string on_red = "\033[41m"; colors_;
const std::string on_green = "\033[42m";
const std::string on_yellow = "\033[43m";
const std::string on_blue = "\033[44m";
const std::string on_magenta = "\033[45m";
const std::string on_cyan = "\033[46m";
const std::string on_white = "\033[47m";
void log(const details::log_msg &msg) override
{
// Wrap the originally formatted message in color codes.
// If color is not supported in the terminal, log as is instead.
std::lock_guard<mutex_t> lock(mutex_);
fmt::memory_buffer formatted;
formatter_->format(msg, formatted);
if (should_do_colors_ && msg.color_range_end > msg.color_range_start)
{
// before color range
print_range_(formatted, 0, msg.color_range_start);
// in color range
print_ccode_(colors_[msg.level]);
print_range_(formatted, msg.color_range_start, msg.color_range_end);
print_ccode_(reset);
// after color range
print_range_(formatted, msg.color_range_end, formatted.size());
}
else // no color
{
print_range_(formatted, 0, formatted.size());
}
fflush(target_file_);
}
void flush() override
{
std::lock_guard<mutex_t> lock(mutex_);
fflush(target_file_);
}
void set_pattern(const std::string &pattern) final
{
std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
}
void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override
{
std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::move(sink_formatter);
}
private:
void print_ccode_(const std::string &color_code)
{
fwrite(color_code.data(), sizeof(char), color_code.size(), target_file_);
}
void print_range_(const fmt::memory_buffer &formatted, size_t start, size_t end)
{
fwrite(formatted.data() + start, sizeof(char), end - start, target_file_);
}
FILE *target_file_;
mutex_t &mutex_;
bool should_do_colors_;
std::unordered_map<level::level_enum, std::string, level::level_hasher> colors_;
}; };
using ansicolor_stdout_sink_mt = ansicolor_sink<details::console_stdout, details::console_mutex>; using ansicolor_stdout_sink_mt =
using ansicolor_stdout_sink_st = ansicolor_sink<details::console_stdout, details::console_nullmutex>; ansicolor_sink<details::console_stdout, details::console_mutex>;
using ansicolor_stdout_sink_st =
ansicolor_sink<details::console_stdout, details::console_nullmutex>;
using ansicolor_stderr_sink_mt = ansicolor_sink<details::console_stderr, details::console_mutex>; using ansicolor_stderr_sink_mt =
using ansicolor_stderr_sink_st = ansicolor_sink<details::console_stderr, details::console_nullmutex>; ansicolor_sink<details::console_stderr, details::console_mutex>;
using ansicolor_stderr_sink_st =
ansicolor_sink<details::console_stderr, details::console_nullmutex>;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

76
src/cpp/include/deps/spdlog/sinks/base_sink.h Executable file → Normal file
View File

@ -18,52 +18,46 @@
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
template<typename Mutex> template <typename Mutex>
class base_sink : public sink class base_sink : public sink {
{ public:
public: base_sink() = default;
base_sink() = default; base_sink(const base_sink &) = delete;
base_sink(const base_sink &) = delete; base_sink &operator=(const base_sink &) = delete;
base_sink &operator=(const base_sink &) = delete;
void log(const details::log_msg &msg) final void log(const details::log_msg &msg) final {
{ std::lock_guard<Mutex> lock(mutex_);
std::lock_guard<Mutex> lock(mutex_); sink_it_(msg);
sink_it_(msg); }
}
void flush() final void flush() final {
{ std::lock_guard<Mutex> lock(mutex_);
std::lock_guard<Mutex> lock(mutex_); flush_();
flush_(); }
}
void set_pattern(const std::string &pattern) final void set_pattern(const std::string &pattern) final {
{ std::lock_guard<Mutex> lock(mutex_);
std::lock_guard<Mutex> lock(mutex_); set_pattern_(pattern);
set_pattern_(pattern); }
}
void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) final void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) final {
{ std::lock_guard<Mutex> lock(mutex_);
std::lock_guard<Mutex> lock(mutex_); set_formatter_(std::move(sink_formatter));
set_formatter_(std::move(sink_formatter)); }
}
protected: protected:
virtual void sink_it_(const details::log_msg &msg) = 0; virtual void sink_it_(const details::log_msg &msg) = 0;
virtual void flush_() = 0; virtual void flush_() = 0;
virtual void set_pattern_(const std::string &pattern) virtual void set_pattern_(const std::string &pattern) {
{ set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern));
set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern)); }
}
virtual void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter) virtual void set_formatter_(
{ std::unique_ptr<spdlog::formatter> sink_formatter) {
formatter_ = std::move(sink_formatter); formatter_ = std::move(sink_formatter);
} }
Mutex mutex_; Mutex mutex_;
}; };
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

66
src/cpp/include/deps/spdlog/sinks/basic_file_sink.h Executable file → Normal file
View File

@ -9,62 +9,60 @@
#include "spdlog/spdlog.h" #include "spdlog/spdlog.h"
#endif #endif
#include <mutex>
#include <string>
#include "spdlog/details/file_helper.h" #include "spdlog/details/file_helper.h"
#include "spdlog/details/null_mutex.h" #include "spdlog/details/null_mutex.h"
#include "spdlog/sinks/base_sink.h" #include "spdlog/sinks/base_sink.h"
#include <mutex>
#include <string>
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
/* /*
* Trivial file sink with single file as target * Trivial file sink with single file as target
*/ */
template<typename Mutex> template <typename Mutex>
class basic_file_sink final : public base_sink<Mutex> class basic_file_sink final : public base_sink<Mutex> {
{ public:
public: explicit basic_file_sink(const filename_t &filename, bool truncate = false) {
explicit basic_file_sink(const filename_t &filename, bool truncate = false) file_helper_.open(filename, truncate);
{ }
file_helper_.open(filename, truncate);
}
protected: protected:
void sink_it_(const details::log_msg &msg) override void sink_it_(const details::log_msg &msg) override {
{ fmt::memory_buffer formatted;
fmt::memory_buffer formatted; sink::formatter_->format(msg, formatted);
sink::formatter_->format(msg, formatted); file_helper_.write(formatted);
file_helper_.write(formatted); }
}
void flush_() override void flush_() override { file_helper_.flush(); }
{
file_helper_.flush();
}
private: private:
details::file_helper file_helper_; details::file_helper file_helper_;
}; };
using basic_file_sink_mt = basic_file_sink<std::mutex>; using basic_file_sink_mt = basic_file_sink<std::mutex>;
using basic_file_sink_st = basic_file_sink<details::null_mutex>; using basic_file_sink_st = basic_file_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
// //
// factory functions // factory functions
// //
template<typename Factory = default_factory> template <typename Factory = default_factory>
inline std::shared_ptr<logger> basic_logger_mt(const std::string &logger_name, const filename_t &filename, bool truncate = false) inline std::shared_ptr<logger> basic_logger_mt(const std::string &logger_name,
{ const filename_t &filename,
return Factory::template create<sinks::basic_file_sink_mt>(logger_name, filename, truncate); bool truncate = false) {
return Factory::template create<sinks::basic_file_sink_mt>(
logger_name, filename, truncate);
} }
template<typename Factory = default_factory> template <typename Factory = default_factory>
inline std::shared_ptr<logger> basic_logger_st(const std::string &logger_name, const filename_t &filename, bool truncate = false) inline std::shared_ptr<logger> basic_logger_st(const std::string &logger_name,
{ const filename_t &filename,
return Factory::template create<sinks::basic_file_sink_st>(logger_name, filename, truncate); bool truncate = false) {
return Factory::template create<sinks::basic_file_sink_st>(
logger_name, filename, truncate);
} }
} // namespace spdlog } // namespace spdlog

179
src/cpp/include/deps/spdlog/sinks/daily_file_sink.h Executable file → Normal file
View File

@ -9,128 +9,127 @@
#include "spdlog/spdlog.h" #include "spdlog/spdlog.h"
#endif #endif
#include "spdlog/details/file_helper.h"
#include "spdlog/details/null_mutex.h"
#include "spdlog/fmt/fmt.h"
#include "spdlog/sinks/base_sink.h"
#include <chrono> #include <chrono>
#include <cstdio> #include <cstdio>
#include <ctime> #include <ctime>
#include <mutex> #include <mutex>
#include <string> #include <string>
#include "spdlog/details/file_helper.h"
#include "spdlog/details/null_mutex.h"
#include "spdlog/fmt/fmt.h"
#include "spdlog/sinks/base_sink.h"
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
/* /*
* Generator of daily log file names in format basename.YYYY-MM-DD.ext * Generator of daily log file names in format basename.YYYY-MM-DD.ext
*/ */
struct daily_filename_calculator struct daily_filename_calculator {
{ // Create filename for the form basename.YYYY-MM-DD
// Create filename for the form basename.YYYY-MM-DD static filename_t calc_filename(const filename_t &filename,
static filename_t calc_filename(const filename_t &filename, const tm &now_tm) const tm &now_tm) {
{ filename_t basename, ext;
filename_t basename, ext; std::tie(basename, ext) =
std::tie(basename, ext) = details::file_helper::split_by_extension(filename); details::file_helper::split_by_extension(filename);
std::conditional<std::is_same<filename_t::value_type, char>::value, fmt::memory_buffer, fmt::wmemory_buffer>::type w; std::conditional<std::is_same<filename_t::value_type, char>::value,
fmt::format_to( fmt::memory_buffer, fmt::wmemory_buffer>::type w;
w, SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}"), basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday, ext); fmt::format_to(w, SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}"), basename,
return fmt::to_string(w); now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday,
} ext);
return fmt::to_string(w);
}
}; };
/* /*
* Rotating file sink based on date. rotates at midnight * Rotating file sink based on date. rotates at midnight
*/ */
template<typename Mutex, typename FileNameCalc = daily_filename_calculator> template <typename Mutex, typename FileNameCalc = daily_filename_calculator>
class daily_file_sink final : public base_sink<Mutex> class daily_file_sink final : public base_sink<Mutex> {
{ public:
public: // create daily file sink which rotates on given time
// create daily file sink which rotates on given time daily_file_sink(filename_t base_filename, int rotation_hour,
daily_file_sink(filename_t base_filename, int rotation_hour, int rotation_minute, bool truncate = false) int rotation_minute, bool truncate = false)
: base_filename_(std::move(base_filename)) : base_filename_(std::move(base_filename)),
, rotation_h_(rotation_hour) rotation_h_(rotation_hour),
, rotation_m_(rotation_minute) rotation_m_(rotation_minute),
, truncate_(truncate) truncate_(truncate) {
{ if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 ||
if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || rotation_minute > 59) rotation_minute > 59) {
{ throw spdlog_ex("daily_file_sink: Invalid rotation time in ctor");
throw spdlog_ex("daily_file_sink: Invalid rotation time in ctor");
}
auto now = log_clock::now();
file_helper_.open(FileNameCalc::calc_filename(base_filename_, now_tm(now)), truncate_);
rotation_tp_ = next_rotation_tp_();
} }
auto now = log_clock::now();
file_helper_.open(FileNameCalc::calc_filename(base_filename_, now_tm(now)),
truncate_);
rotation_tp_ = next_rotation_tp_();
}
protected: protected:
void sink_it_(const details::log_msg &msg) override void sink_it_(const details::log_msg &msg) override {
{ if (msg.time >= rotation_tp_) {
file_helper_.open(
if (msg.time >= rotation_tp_) FileNameCalc::calc_filename(base_filename_, now_tm(msg.time)),
{ truncate_);
file_helper_.open(FileNameCalc::calc_filename(base_filename_, now_tm(msg.time)), truncate_); rotation_tp_ = next_rotation_tp_();
rotation_tp_ = next_rotation_tp_();
}
fmt::memory_buffer formatted;
sink::formatter_->format(msg, formatted);
file_helper_.write(formatted);
} }
fmt::memory_buffer formatted;
sink::formatter_->format(msg, formatted);
file_helper_.write(formatted);
}
void flush_() override void flush_() override { file_helper_.flush(); }
{
file_helper_.flush(); private:
tm now_tm(log_clock::time_point tp) {
time_t tnow = log_clock::to_time_t(tp);
return spdlog::details::os::localtime(tnow);
}
log_clock::time_point next_rotation_tp_() {
auto now = log_clock::now();
tm date = now_tm(now);
date.tm_hour = rotation_h_;
date.tm_min = rotation_m_;
date.tm_sec = 0;
auto rotation_time = log_clock::from_time_t(std::mktime(&date));
if (rotation_time > now) {
return rotation_time;
} }
return {rotation_time + std::chrono::hours(24)};
}
private: filename_t base_filename_;
tm now_tm(log_clock::time_point tp) int rotation_h_;
{ int rotation_m_;
time_t tnow = log_clock::to_time_t(tp); log_clock::time_point rotation_tp_;
return spdlog::details::os::localtime(tnow); details::file_helper file_helper_;
} bool truncate_;
log_clock::time_point next_rotation_tp_()
{
auto now = log_clock::now();
tm date = now_tm(now);
date.tm_hour = rotation_h_;
date.tm_min = rotation_m_;
date.tm_sec = 0;
auto rotation_time = log_clock::from_time_t(std::mktime(&date));
if (rotation_time > now)
{
return rotation_time;
}
return {rotation_time + std::chrono::hours(24)};
}
filename_t base_filename_;
int rotation_h_;
int rotation_m_;
log_clock::time_point rotation_tp_;
details::file_helper file_helper_;
bool truncate_;
}; };
using daily_file_sink_mt = daily_file_sink<std::mutex>; using daily_file_sink_mt = daily_file_sink<std::mutex>;
using daily_file_sink_st = daily_file_sink<details::null_mutex>; using daily_file_sink_st = daily_file_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
// //
// factory functions // factory functions
// //
template<typename Factory = default_factory> template <typename Factory = default_factory>
inline std::shared_ptr<logger> daily_logger_mt( inline std::shared_ptr<logger> daily_logger_mt(const std::string &logger_name,
const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, bool truncate = false) const filename_t &filename,
{ int hour = 0, int minute = 0,
return Factory::template create<sinks::daily_file_sink_mt>(logger_name, filename, hour, minute, truncate); bool truncate = false) {
return Factory::template create<sinks::daily_file_sink_mt>(
logger_name, filename, hour, minute, truncate);
} }
template<typename Factory = default_factory> template <typename Factory = default_factory>
inline std::shared_ptr<logger> daily_logger_st( inline std::shared_ptr<logger> daily_logger_st(const std::string &logger_name,
const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, bool truncate = false) const filename_t &filename,
{ int hour = 0, int minute = 0,
return Factory::template create<sinks::daily_file_sink_st>(logger_name, filename, hour, minute, truncate); bool truncate = false) {
return Factory::template create<sinks::daily_file_sink_st>(
logger_name, filename, hour, minute, truncate);
} }
} // namespace spdlog } // namespace spdlog

110
src/cpp/include/deps/spdlog/sinks/dist_sink.h Executable file → Normal file
View File

@ -9,86 +9,74 @@
#include "spdlog/spdlog.h" #include "spdlog/spdlog.h"
#endif #endif
#include "base_sink.h"
#include "spdlog/details/log_msg.h"
#include "spdlog/details/null_mutex.h"
#include <algorithm> #include <algorithm>
#include <memory> #include <memory>
#include <mutex> #include <mutex>
#include <vector> #include <vector>
#include "base_sink.h"
#include "spdlog/details/log_msg.h"
#include "spdlog/details/null_mutex.h"
// Distribution sink (mux). Stores a vector of sinks which get called when log // Distribution sink (mux). Stores a vector of sinks which get called when log
// is called // is called
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
template<typename Mutex> template <typename Mutex>
class dist_sink : public base_sink<Mutex> class dist_sink : public base_sink<Mutex> {
{ public:
public: dist_sink() = default;
dist_sink() = default; dist_sink(const dist_sink &) = delete;
dist_sink(const dist_sink &) = delete; dist_sink &operator=(const dist_sink &) = delete;
dist_sink &operator=(const dist_sink &) = delete;
void add_sink(std::shared_ptr<sink> sink) void add_sink(std::shared_ptr<sink> sink) {
{ std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); sinks_.push_back(sink);
sinks_.push_back(sink); }
void remove_sink(std::shared_ptr<sink> sink) {
std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sink), sinks_.end());
}
void set_sinks(std::vector<std::shared_ptr<sink>> sinks) {
std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
sinks_ = std::move(sinks);
}
protected:
void sink_it_(const details::log_msg &msg) override {
for (auto &sink : sinks_) {
if (sink->should_log(msg.level)) {
sink->log(msg);
}
} }
}
void remove_sink(std::shared_ptr<sink> sink) void flush_() override {
{ for (auto &sink : sinks_) {
std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); sink->flush();
sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sink), sinks_.end());
} }
}
void set_sinks(std::vector<std::shared_ptr<sink>> sinks) void set_pattern_(const std::string &pattern) override {
{ set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern));
std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); }
sinks_ = std::move(sinks);
void set_formatter_(
std::unique_ptr<spdlog::formatter> sink_formatter) override {
base_sink<Mutex>::formatter_ = std::move(sink_formatter);
for (auto &sink : sinks_) {
sink->set_formatter(base_sink<Mutex>::formatter_->clone());
} }
}
protected: std::vector<std::shared_ptr<sink>> sinks_;
void sink_it_(const details::log_msg &msg) override
{
for (auto &sink : sinks_)
{
if (sink->should_log(msg.level))
{
sink->log(msg);
}
}
}
void flush_() override
{
for (auto &sink : sinks_)
{
sink->flush();
}
}
void set_pattern_(const std::string &pattern) override
{
set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern));
}
void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter) override
{
base_sink<Mutex>::formatter_ = std::move(sink_formatter);
for (auto &sink : sinks_)
{
sink->set_formatter(base_sink<Mutex>::formatter_->clone());
}
}
std::vector<std::shared_ptr<sink>> sinks_;
}; };
using dist_sink_mt = dist_sink<std::mutex>; using dist_sink_mt = dist_sink<std::mutex>;
using dist_sink_st = dist_sink<details::null_mutex>; using dist_sink_st = dist_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

35
src/cpp/include/deps/spdlog/sinks/msvc_sink.h Executable file → Normal file
View File

@ -11,35 +11,32 @@
#if defined(_WIN32) #if defined(_WIN32)
#include "spdlog/details/null_mutex.h"
#include "spdlog/sinks/base_sink.h"
#include <winbase.h> #include <winbase.h>
#include <mutex> #include <mutex>
#include <string> #include <string>
#include "spdlog/details/null_mutex.h"
#include "spdlog/sinks/base_sink.h"
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
/* /*
* MSVC sink (logging using OutputDebugStringA) * MSVC sink (logging using OutputDebugStringA)
*/ */
template<typename Mutex> template <typename Mutex>
class msvc_sink : public base_sink<Mutex> class msvc_sink : public base_sink<Mutex> {
{ public:
public: explicit msvc_sink() {}
explicit msvc_sink() {}
protected: protected:
void sink_it_(const details::log_msg &msg) override void sink_it_(const details::log_msg &msg) override {
{ fmt::memory_buffer formatted;
sink::formatter_->format(msg, formatted);
OutputDebugStringA(fmt::to_string(formatted).c_str());
}
fmt::memory_buffer formatted; void flush_() override {}
sink::formatter_->format(msg, formatted);
OutputDebugStringA(fmt::to_string(formatted).c_str());
}
void flush_() override {}
}; };
using msvc_sink_mt = msvc_sink<std::mutex>; using msvc_sink_mt = msvc_sink<std::mutex>;
@ -48,7 +45,7 @@ using msvc_sink_st = msvc_sink<details::null_mutex>;
using windebug_sink_mt = msvc_sink_mt; using windebug_sink_mt = msvc_sink_mt;
using windebug_sink_st = msvc_sink_st; using windebug_sink_st = msvc_sink_st;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog
#endif #endif

41
src/cpp/include/deps/spdlog/sinks/null_sink.h Executable file → Normal file
View File

@ -9,41 +9,38 @@
#include "spdlog/spdlog.h" #include "spdlog/spdlog.h"
#endif #endif
#include <mutex>
#include "spdlog/details/null_mutex.h" #include "spdlog/details/null_mutex.h"
#include "spdlog/sinks/base_sink.h" #include "spdlog/sinks/base_sink.h"
#include <mutex>
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
template<typename Mutex> template <typename Mutex>
class null_sink : public base_sink<Mutex> class null_sink : public base_sink<Mutex> {
{ protected:
protected: void sink_it_(const details::log_msg &) override {}
void sink_it_(const details::log_msg &) override {} void flush_() override {}
void flush_() override {}
}; };
using null_sink_mt = null_sink<std::mutex>; using null_sink_mt = null_sink<std::mutex>;
using null_sink_st = null_sink<details::null_mutex>; using null_sink_st = null_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
template<typename Factory = default_factory> template <typename Factory = default_factory>
inline std::shared_ptr<logger> null_logger_mt(const std::string &logger_name) inline std::shared_ptr<logger> null_logger_mt(const std::string &logger_name) {
{ auto null_logger = Factory::template create<sinks::null_sink_mt>(logger_name);
auto null_logger = Factory::template create<sinks::null_sink_mt>(logger_name); null_logger->set_level(level::off);
null_logger->set_level(level::off); return null_logger;
return null_logger;
} }
template<typename Factory = default_factory> template <typename Factory = default_factory>
inline std::shared_ptr<logger> null_logger_st(const std::string &logger_name) inline std::shared_ptr<logger> null_logger_st(const std::string &logger_name) {
{ auto null_logger = Factory::template create<sinks::null_sink_st>(logger_name);
auto null_logger = Factory::template create<sinks::null_sink_st>(logger_name); null_logger->set_level(level::off);
null_logger->set_level(level::off); return null_logger;
return null_logger;
} }
} // namespace spdlog } // namespace spdlog

56
src/cpp/include/deps/spdlog/sinks/ostream_sink.h Executable file → Normal file
View File

@ -9,49 +9,41 @@
#include "spdlog/spdlog.h" #include "spdlog/spdlog.h"
#endif #endif
#include "spdlog/details/null_mutex.h"
#include "spdlog/sinks/base_sink.h"
#include <mutex> #include <mutex>
#include <ostream> #include <ostream>
#include "spdlog/details/null_mutex.h"
#include "spdlog/sinks/base_sink.h"
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
template<typename Mutex> template <typename Mutex>
class ostream_sink final : public base_sink<Mutex> class ostream_sink final : public base_sink<Mutex> {
{ public:
public: explicit ostream_sink(std::ostream &os, bool force_flush = false)
explicit ostream_sink(std::ostream &os, bool force_flush = false) : ostream_(os), force_flush_(force_flush) {}
: ostream_(os) ostream_sink(const ostream_sink &) = delete;
, force_flush_(force_flush) ostream_sink &operator=(const ostream_sink &) = delete;
{
}
ostream_sink(const ostream_sink &) = delete;
ostream_sink &operator=(const ostream_sink &) = delete;
protected: protected:
void sink_it_(const details::log_msg &msg) override void sink_it_(const details::log_msg &msg) override {
{ fmt::memory_buffer formatted;
fmt::memory_buffer formatted; sink::formatter_->format(msg, formatted);
sink::formatter_->format(msg, formatted); ostream_.write(formatted.data(),
ostream_.write(formatted.data(), static_cast<std::streamsize>(formatted.size())); static_cast<std::streamsize>(formatted.size()));
if (force_flush_) if (force_flush_) {
{ ostream_.flush();
ostream_.flush();
}
} }
}
void flush_() override void flush_() override { ostream_.flush(); }
{
ostream_.flush();
}
std::ostream &ostream_; std::ostream &ostream_;
bool force_flush_; bool force_flush_;
}; };
using ostream_sink_mt = ostream_sink<std::mutex>; using ostream_sink_mt = ostream_sink<std::mutex>;
using ostream_sink_st = ostream_sink<details::null_mutex>; using ostream_sink_st = ostream_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

216
src/cpp/include/deps/spdlog/sinks/rotating_file_sink.h Executable file → Normal file
View File

@ -9,11 +9,6 @@
#include "spdlog/spdlog.h" #include "spdlog/spdlog.h"
#endif #endif
#include "spdlog/details/file_helper.h"
#include "spdlog/details/null_mutex.h"
#include "spdlog/fmt/fmt.h"
#include "spdlog/sinks/base_sink.h"
#include <cerrno> #include <cerrno>
#include <chrono> #include <chrono>
#include <ctime> #include <ctime>
@ -21,135 +16,134 @@
#include <string> #include <string>
#include <tuple> #include <tuple>
#include "spdlog/details/file_helper.h"
#include "spdlog/details/null_mutex.h"
#include "spdlog/fmt/fmt.h"
#include "spdlog/sinks/base_sink.h"
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
// //
// Rotating file sink based on size // Rotating file sink based on size
// //
template<typename Mutex> template <typename Mutex>
class rotating_file_sink final : public base_sink<Mutex> class rotating_file_sink final : public base_sink<Mutex> {
{ public:
public: rotating_file_sink(filename_t base_filename, std::size_t max_size,
rotating_file_sink(filename_t base_filename, std::size_t max_size, std::size_t max_files) std::size_t max_files)
: base_filename_(std::move(base_filename)) : base_filename_(std::move(base_filename)),
, max_size_(max_size) max_size_(max_size),
, max_files_(max_files) max_files_(max_files) {
{ file_helper_.open(calc_filename(base_filename_, 0));
file_helper_.open(calc_filename(base_filename_, 0)); current_size_ = file_helper_.size(); // expensive. called only once
current_size_ = file_helper_.size(); // expensive. called only once }
}
// calc filename according to index and file extension if exists. // calc filename according to index and file extension if exists.
// e.g. calc_filename("logs/mylog.txt, 3) => "logs/mylog.3.txt". // e.g. calc_filename("logs/mylog.txt, 3) => "logs/mylog.3.txt".
static filename_t calc_filename(const filename_t &filename, std::size_t index) static filename_t calc_filename(const filename_t &filename,
{ std::size_t index) {
typename std::conditional<std::is_same<filename_t::value_type, char>::value, fmt::memory_buffer, fmt::wmemory_buffer>::type w; typename std::conditional<std::is_same<filename_t::value_type, char>::value,
if (index != 0u) fmt::memory_buffer, fmt::wmemory_buffer>::type w;
{ if (index != 0u) {
filename_t basename, ext; filename_t basename, ext;
std::tie(basename, ext) = details::file_helper::split_by_extension(filename); std::tie(basename, ext) =
fmt::format_to(w, SPDLOG_FILENAME_T("{}.{}{}"), basename, index, ext); details::file_helper::split_by_extension(filename);
fmt::format_to(w, SPDLOG_FILENAME_T("{}.{}{}"), basename, index, ext);
} else {
fmt::format_to(w, SPDLOG_FILENAME_T("{}"), filename);
}
return fmt::to_string(w);
}
protected:
void sink_it_(const details::log_msg &msg) override {
fmt::memory_buffer formatted;
sink::formatter_->format(msg, formatted);
current_size_ += formatted.size();
if (current_size_ > max_size_) {
rotate_();
current_size_ = formatted.size();
}
file_helper_.write(formatted);
}
void flush_() override { file_helper_.flush(); }
private:
// Rotate files:
// log.txt -> log.1.txt
// log.1.txt -> log.2.txt
// log.2.txt -> log.3.txt
// log.3.txt -> delete
void rotate_() {
using details::os::filename_to_str;
file_helper_.close();
for (auto i = max_files_; i > 0; --i) {
filename_t src = calc_filename(base_filename_, i - 1);
if (!details::file_helper::file_exists(src)) {
continue;
}
filename_t target = calc_filename(base_filename_, i);
if (!rename_file(src, target)) {
// if failed try again after a small delay.
// this is a workaround to a windows issue, where very high rotation
// rates can cause the rename to fail with permission denied (because of
// antivirus?).
details::os::sleep_for_millis(100);
if (!rename_file(src, target)) {
file_helper_.reopen(true); // truncate the log file anyway to prevent
// it to grow beyond its limit!
current_size_ = 0;
throw spdlog_ex("rotating_file_sink: failed renaming " +
filename_to_str(src) + " to " +
filename_to_str(target),
errno);
} }
else }
{
fmt::format_to(w, SPDLOG_FILENAME_T("{}"), filename);
}
return fmt::to_string(w);
} }
file_helper_.reopen(true);
}
protected: // delete the target if exists, and rename the src file to target
void sink_it_(const details::log_msg &msg) override // return true on success, false otherwise.
{ bool rename_file(const filename_t &src_filename,
fmt::memory_buffer formatted; const filename_t &target_filename) {
sink::formatter_->format(msg, formatted); // try to delete the target file in case it already exists.
current_size_ += formatted.size(); (void)details::os::remove(target_filename);
if (current_size_ > max_size_) return details::os::rename(src_filename, target_filename) == 0;
{ }
rotate_();
current_size_ = formatted.size();
}
file_helper_.write(formatted);
}
void flush_() override filename_t base_filename_;
{ std::size_t max_size_;
file_helper_.flush(); std::size_t max_files_;
} std::size_t current_size_;
details::file_helper file_helper_;
private:
// Rotate files:
// log.txt -> log.1.txt
// log.1.txt -> log.2.txt
// log.2.txt -> log.3.txt
// log.3.txt -> delete
void rotate_()
{
using details::os::filename_to_str;
file_helper_.close();
for (auto i = max_files_; i > 0; --i)
{
filename_t src = calc_filename(base_filename_, i - 1);
if (!details::file_helper::file_exists(src))
{
continue;
}
filename_t target = calc_filename(base_filename_, i);
if (!rename_file(src, target))
{
// if failed try again after a small delay.
// this is a workaround to a windows issue, where very high rotation
// rates can cause the rename to fail with permission denied (because of antivirus?).
details::os::sleep_for_millis(100);
if (!rename_file(src, target))
{
file_helper_.reopen(true); // truncate the log file anyway to prevent it to grow beyond its limit!
current_size_ = 0;
throw spdlog_ex(
"rotating_file_sink: failed renaming " + filename_to_str(src) + " to " + filename_to_str(target), errno);
}
}
}
file_helper_.reopen(true);
}
// delete the target if exists, and rename the src file to target
// return true on success, false otherwise.
bool rename_file(const filename_t &src_filename, const filename_t &target_filename)
{
// try to delete the target file in case it already exists.
(void)details::os::remove(target_filename);
return details::os::rename(src_filename, target_filename) == 0;
}
filename_t base_filename_;
std::size_t max_size_;
std::size_t max_files_;
std::size_t current_size_;
details::file_helper file_helper_;
}; };
using rotating_file_sink_mt = rotating_file_sink<std::mutex>; using rotating_file_sink_mt = rotating_file_sink<std::mutex>;
using rotating_file_sink_st = rotating_file_sink<details::null_mutex>; using rotating_file_sink_st = rotating_file_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
// //
// factory functions // factory functions
// //
template<typename Factory = default_factory> template <typename Factory = default_factory>
inline std::shared_ptr<logger> rotating_logger_mt( inline std::shared_ptr<logger> rotating_logger_mt(
const std::string &logger_name, const filename_t &filename, size_t max_file_size, size_t max_files) const std::string &logger_name, const filename_t &filename,
{ size_t max_file_size, size_t max_files) {
return Factory::template create<sinks::rotating_file_sink_mt>(logger_name, filename, max_file_size, max_files); return Factory::template create<sinks::rotating_file_sink_mt>(
logger_name, filename, max_file_size, max_files);
} }
template<typename Factory = default_factory> template <typename Factory = default_factory>
inline std::shared_ptr<logger> rotating_logger_st( inline std::shared_ptr<logger> rotating_logger_st(
const std::string &logger_name, const filename_t &filename, size_t max_file_size, size_t max_files) const std::string &logger_name, const filename_t &filename,
{ size_t max_file_size, size_t max_files) {
return Factory::template create<sinks::rotating_file_sink_st>(logger_name, filename, max_file_size, max_files); return Factory::template create<sinks::rotating_file_sink_st>(
logger_name, filename, max_file_size, max_files);
} }
} // namespace spdlog } // namespace spdlog

63
src/cpp/include/deps/spdlog/sinks/sink.h Executable file → Normal file
View File

@ -11,49 +11,38 @@
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
class sink class sink {
{ public:
public: sink() : level_(level::trace), formatter_(new pattern_formatter()) {}
sink()
: level_(level::trace)
, formatter_(new pattern_formatter())
{
}
explicit sink(std::unique_ptr<spdlog::pattern_formatter> formatter) explicit sink(std::unique_ptr<spdlog::pattern_formatter> formatter)
: level_(level::trace) : level_(level::trace), formatter_(std::move(formatter)) {}
, formatter_(std::move(formatter))
{
}
virtual ~sink() = default; virtual ~sink() = default;
virtual void log(const details::log_msg &msg) = 0; virtual void log(const details::log_msg &msg) = 0;
virtual void flush() = 0; virtual void flush() = 0;
virtual void set_pattern(const std::string &pattern) = 0; virtual void set_pattern(const std::string &pattern) = 0;
virtual void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) = 0; virtual void set_formatter(
std::unique_ptr<spdlog::formatter> sink_formatter) = 0;
bool should_log(level::level_enum msg_level) const bool should_log(level::level_enum msg_level) const {
{ return msg_level >= level_.load(std::memory_order_relaxed);
return msg_level >= level_.load(std::memory_order_relaxed); }
}
void set_level(level::level_enum log_level) void set_level(level::level_enum log_level) { level_.store(log_level); }
{
level_.store(log_level);
}
level::level_enum level() const level::level_enum level() const {
{ return static_cast<spdlog::level::level_enum>(
return static_cast<spdlog::level::level_enum>(level_.load(std::memory_order_relaxed)); level_.load(std::memory_order_relaxed));
} }
protected: protected:
// sink log level - default is all // sink log level - default is all
level_t level_; level_t level_;
// sink formatter - default is full format // sink formatter - default is full format
std::unique_ptr<spdlog::formatter> formatter_; std::unique_ptr<spdlog::formatter> formatter_;
}; };
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

32
src/cpp/include/deps/spdlog/sinks/stdout_color_sinks.h Executable file → Normal file
View File

@ -28,29 +28,25 @@ using stdout_color_sink_st = ansicolor_stdout_sink_st;
using stderr_color_sink_mt = ansicolor_stderr_sink_mt; using stderr_color_sink_mt = ansicolor_stderr_sink_mt;
using stderr_color_sink_st = ansicolor_stderr_sink_st; using stderr_color_sink_st = ansicolor_stderr_sink_st;
#endif #endif
} // namespace sinks } // namespace sinks
template<typename Factory = default_factory> template <typename Factory = default_factory>
inline std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name) inline std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name) {
{ return Factory::template create<sinks::stdout_color_sink_mt>(logger_name);
return Factory::template create<sinks::stdout_color_sink_mt>(logger_name);
} }
template<typename Factory = default_factory> template <typename Factory = default_factory>
inline std::shared_ptr<logger> stdout_color_st(const std::string &logger_name) inline std::shared_ptr<logger> stdout_color_st(const std::string &logger_name) {
{ return Factory::template create<sinks::stdout_color_sink_st>(logger_name);
return Factory::template create<sinks::stdout_color_sink_st>(logger_name);
} }
template<typename Factory = default_factory> template <typename Factory = default_factory>
inline std::shared_ptr<logger> stderr_color_mt(const std::string &logger_name) inline std::shared_ptr<logger> stderr_color_mt(const std::string &logger_name) {
{ return Factory::template create<sinks::stderr_color_sink_mt>(logger_name);
return Factory::template create<sinks::stderr_color_sink_mt>(logger_name);
} }
template<typename Factory = default_factory> template <typename Factory = default_factory>
inline std::shared_ptr<logger> stderr_color_st(const std::string &logger_name) inline std::shared_ptr<logger> stderr_color_st(const std::string &logger_name) {
{ return Factory::template create<sinks::stderr_color_sink_mt>(logger_name);
return Factory::template create<sinks::stderr_color_sink_mt>(logger_name);
} }
} // namespace spdlog } // namespace spdlog

126
src/cpp/include/deps/spdlog/sinks/stdout_sinks.h Executable file → Normal file
View File

@ -9,94 +9,92 @@
#include "spdlog/spdlog.h" #include "spdlog/spdlog.h"
#endif #endif
#include "spdlog/details/console_globals.h"
#include "spdlog/details/null_mutex.h"
#include <cstdio> #include <cstdio>
#include <memory> #include <memory>
#include <mutex> #include <mutex>
#include "spdlog/details/console_globals.h"
#include "spdlog/details/null_mutex.h"
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
template<typename TargetStream, typename ConsoleMutex> template <typename TargetStream, typename ConsoleMutex>
class stdout_sink final : public sink class stdout_sink final : public sink {
{ public:
public: using mutex_t = typename ConsoleMutex::mutex_t;
using mutex_t = typename ConsoleMutex::mutex_t; stdout_sink()
stdout_sink() : mutex_(ConsoleMutex::mutex()), file_(TargetStream::stream()) {}
: mutex_(ConsoleMutex::mutex()) ~stdout_sink() override = default;
, file_(TargetStream::stream())
{
}
~stdout_sink() override = default;
stdout_sink(const stdout_sink &other) = delete; stdout_sink(const stdout_sink &other) = delete;
stdout_sink &operator=(const stdout_sink &other) = delete; stdout_sink &operator=(const stdout_sink &other) = delete;
void log(const details::log_msg &msg) override void log(const details::log_msg &msg) override {
{ std::lock_guard<mutex_t> lock(mutex_);
std::lock_guard<mutex_t> lock(mutex_); fmt::memory_buffer formatted;
fmt::memory_buffer formatted; formatter_->format(msg, formatted);
formatter_->format(msg, formatted); fwrite(formatted.data(), sizeof(char), formatted.size(), file_);
fwrite(formatted.data(), sizeof(char), formatted.size(), file_); fflush(TargetStream::stream());
fflush(TargetStream::stream()); }
}
void flush() override void flush() override {
{ std::lock_guard<mutex_t> lock(mutex_);
std::lock_guard<mutex_t> lock(mutex_); fflush(file_);
fflush(file_); }
}
void set_pattern(const std::string &pattern) override void set_pattern(const std::string &pattern) override {
{ std::lock_guard<mutex_t> lock(mutex_);
std::lock_guard<mutex_t> lock(mutex_); formatter_ =
formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern)); std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
} }
void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override void set_formatter(
{ std::unique_ptr<spdlog::formatter> sink_formatter) override {
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::move(sink_formatter); formatter_ = std::move(sink_formatter);
} }
private: private:
mutex_t &mutex_; mutex_t &mutex_;
FILE *file_; FILE *file_;
}; };
using stdout_sink_mt = stdout_sink<details::console_stdout, details::console_mutex>; using stdout_sink_mt =
using stdout_sink_st = stdout_sink<details::console_stdout, details::console_nullmutex>; stdout_sink<details::console_stdout, details::console_mutex>;
using stdout_sink_st =
stdout_sink<details::console_stdout, details::console_nullmutex>;
using stderr_sink_mt = stdout_sink<details::console_stderr, details::console_mutex>; using stderr_sink_mt =
using stderr_sink_st = stdout_sink<details::console_stderr, details::console_nullmutex>; stdout_sink<details::console_stderr, details::console_mutex>;
using stderr_sink_st =
stdout_sink<details::console_stderr, details::console_nullmutex>;
} // namespace sinks } // namespace sinks
// factory methods // factory methods
template<typename Factory = default_factory> template <typename Factory = default_factory>
inline std::shared_ptr<logger> stdout_logger_mt(const std::string &logger_name) inline std::shared_ptr<logger> stdout_logger_mt(
{ const std::string &logger_name) {
return Factory::template create<sinks::stdout_sink_mt>(logger_name); return Factory::template create<sinks::stdout_sink_mt>(logger_name);
} }
template<typename Factory = default_factory> template <typename Factory = default_factory>
inline std::shared_ptr<logger> stdout_logger_st(const std::string &logger_name) inline std::shared_ptr<logger> stdout_logger_st(
{ const std::string &logger_name) {
return Factory::template create<sinks::stdout_sink_st>(logger_name); return Factory::template create<sinks::stdout_sink_st>(logger_name);
} }
template<typename Factory = default_factory> template <typename Factory = default_factory>
inline std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name) inline std::shared_ptr<logger> stderr_logger_mt(
{ const std::string &logger_name) {
return Factory::template create<sinks::stderr_sink_mt>(logger_name); return Factory::template create<sinks::stderr_sink_mt>(logger_name);
} }
template<typename Factory = default_factory> template <typename Factory = default_factory>
inline std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name) inline std::shared_ptr<logger> stderr_logger_st(
{ const std::string &logger_name) {
return Factory::template create<sinks::stderr_sink_st>(logger_name); return Factory::template create<sinks::stderr_sink_st>(logger_name);
} }
} // namespace spdlog } // namespace spdlog

107
src/cpp/include/deps/spdlog/sinks/syslog_sink.h Executable file → Normal file
View File

@ -9,11 +9,12 @@
#include "spdlog/spdlog.h" #include "spdlog/spdlog.h"
#endif #endif
#include "spdlog/sinks/base_sink.h" #include <syslog.h>
#include <array> #include <array>
#include <string> #include <string>
#include <syslog.h>
#include "spdlog/sinks/base_sink.h"
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
@ -22,73 +23,71 @@ namespace sinks {
* *
* Locking is not needed, as `syslog()` itself is thread-safe. * Locking is not needed, as `syslog()` itself is thread-safe.
*/ */
template<typename Mutex> template <typename Mutex>
class syslog_sink : public base_sink<Mutex> class syslog_sink : public base_sink<Mutex> {
{ public:
public: //
// explicit syslog_sink(std::string ident = "", int syslog_option = 0,
explicit syslog_sink(std::string ident = "", int syslog_option = 0, int syslog_facility = LOG_USER) int syslog_facility = LOG_USER)
: ident_(std::move(ident)) : ident_(std::move(ident)) {
{ priorities_[static_cast<size_t>(level::trace)] = LOG_DEBUG;
priorities_[static_cast<size_t>(level::trace)] = LOG_DEBUG; priorities_[static_cast<size_t>(level::debug)] = LOG_DEBUG;
priorities_[static_cast<size_t>(level::debug)] = LOG_DEBUG; priorities_[static_cast<size_t>(level::info)] = LOG_INFO;
priorities_[static_cast<size_t>(level::info)] = LOG_INFO; priorities_[static_cast<size_t>(level::warn)] = LOG_WARNING;
priorities_[static_cast<size_t>(level::warn)] = LOG_WARNING; priorities_[static_cast<size_t>(level::err)] = LOG_ERR;
priorities_[static_cast<size_t>(level::err)] = LOG_ERR; priorities_[static_cast<size_t>(level::critical)] = LOG_CRIT;
priorities_[static_cast<size_t>(level::critical)] = LOG_CRIT; priorities_[static_cast<size_t>(level::off)] = LOG_INFO;
priorities_[static_cast<size_t>(level::off)] = LOG_INFO;
// set ident to be program name if empty // set ident to be program name if empty
::openlog(ident_.empty() ? nullptr : ident_.c_str(), syslog_option, syslog_facility); ::openlog(ident_.empty() ? nullptr : ident_.c_str(), syslog_option,
} syslog_facility);
}
~syslog_sink() override ~syslog_sink() override { ::closelog(); }
{
::closelog();
}
syslog_sink(const syslog_sink &) = delete; syslog_sink(const syslog_sink &) = delete;
syslog_sink &operator=(const syslog_sink &) = delete; syslog_sink &operator=(const syslog_sink &) = delete;
protected: protected:
void sink_it_(const details::log_msg &msg) override void sink_it_(const details::log_msg &msg) override {
{ ::syslog(syslog_prio_from_level(msg), "%s",
::syslog(syslog_prio_from_level(msg), "%s", fmt::to_string(msg.payload).c_str()); fmt::to_string(msg.payload).c_str());
} }
void flush_() override {} void flush_() override {}
private: private:
std::array<int, 7> priorities_; std::array<int, 7> priorities_;
// must store the ident because the man says openlog might use the pointer as // must store the ident because the man says openlog might use the pointer as
// is and not a string copy // is and not a string copy
const std::string ident_; const std::string ident_;
// //
// Simply maps spdlog's log level to syslog priority level. // Simply maps spdlog's log level to syslog priority level.
// //
int syslog_prio_from_level(const details::log_msg &msg) const int syslog_prio_from_level(const details::log_msg &msg) const {
{ return priorities_[static_cast<size_t>(msg.level)];
return priorities_[static_cast<size_t>(msg.level)]; }
}
}; };
using syslog_sink_mt = syslog_sink<std::mutex>; using syslog_sink_mt = syslog_sink<std::mutex>;
using syslog_sink_st = syslog_sink<details::null_mutex>; using syslog_sink_st = syslog_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
// Create and register a syslog logger // Create and register a syslog logger
template<typename Factory = default_factory> template <typename Factory = default_factory>
inline std::shared_ptr<logger> syslog_logger_mt( inline std::shared_ptr<logger> syslog_logger_mt(
const std::string &logger_name, const std::string &syslog_ident = "", int syslog_option = 0, int syslog_facility = (1 << 3)) const std::string &logger_name, const std::string &syslog_ident = "",
{ int syslog_option = 0, int syslog_facility = (1 << 3)) {
return Factory::template create<sinks::syslog_sink_mt>(logger_name, syslog_ident, syslog_option, syslog_facility); return Factory::template create<sinks::syslog_sink_mt>(
logger_name, syslog_ident, syslog_option, syslog_facility);
} }
template<typename Factory = default_factory> template <typename Factory = default_factory>
inline std::shared_ptr<logger> syslog_logger_st( inline std::shared_ptr<logger> syslog_logger_st(
const std::string &logger_name, const std::string &syslog_ident = "", int syslog_option = 0, int syslog_facility = (1 << 3)) const std::string &logger_name, const std::string &syslog_ident = "",
{ int syslog_option = 0, int syslog_facility = (1 << 3)) {
return Factory::template create<sinks::syslog_sink_st>(logger_name, syslog_ident, syslog_option, syslog_facility); return Factory::template create<sinks::syslog_sink_st>(
logger_name, syslog_ident, syslog_option, syslog_facility);
} }
} // namespace spdlog } // namespace spdlog

210
src/cpp/include/deps/spdlog/sinks/wincolor_sink.h Executable file → Normal file
View File

@ -9,16 +9,17 @@
#include "spdlog/spdlog.h" #include "spdlog/spdlog.h"
#endif #endif
#include "spdlog/common.h" #include <wincon.h>
#include "spdlog/details/console_globals.h"
#include "spdlog/details/null_mutex.h"
#include "spdlog/sinks/sink.h"
#include <memory> #include <memory>
#include <mutex> #include <mutex>
#include <string> #include <string>
#include <unordered_map> #include <unordered_map>
#include <wincon.h>
#include "spdlog/common.h"
#include "spdlog/details/console_globals.h"
#include "spdlog/details/null_mutex.h"
#include "spdlog/sinks/sink.h"
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
@ -26,118 +27,113 @@ namespace sinks {
* Windows color console sink. Uses WriteConsoleA to write to the console with * Windows color console sink. Uses WriteConsoleA to write to the console with
* colors * colors
*/ */
template<typename OutHandle, typename ConsoleMutex> template <typename OutHandle, typename ConsoleMutex>
class wincolor_sink : public sink class wincolor_sink : public sink {
{ public:
public: const WORD BOLD = FOREGROUND_INTENSITY;
const WORD BOLD = FOREGROUND_INTENSITY; const WORD RED = FOREGROUND_RED;
const WORD RED = FOREGROUND_RED; const WORD GREEN = FOREGROUND_GREEN;
const WORD GREEN = FOREGROUND_GREEN; const WORD CYAN = FOREGROUND_GREEN | FOREGROUND_BLUE;
const WORD CYAN = FOREGROUND_GREEN | FOREGROUND_BLUE; const WORD WHITE = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
const WORD WHITE = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; const WORD YELLOW = FOREGROUND_RED | FOREGROUND_GREEN;
const WORD YELLOW = FOREGROUND_RED | FOREGROUND_GREEN;
wincolor_sink() wincolor_sink()
: out_handle_(OutHandle::handle()) : out_handle_(OutHandle::handle()), mutex_(ConsoleMutex::mutex()) {
, mutex_(ConsoleMutex::mutex()) colors_[level::trace] = WHITE;
colors_[level::debug] = CYAN;
colors_[level::info] = GREEN;
colors_[level::warn] = YELLOW | BOLD;
colors_[level::err] = RED | BOLD; // red bold
colors_[level::critical] =
BACKGROUND_RED | WHITE | BOLD; // white bold on red background
colors_[level::off] = 0;
}
~wincolor_sink() override { this->flush(); }
wincolor_sink(const wincolor_sink &other) = delete;
wincolor_sink &operator=(const wincolor_sink &other) = delete;
// change the color for the given level
void set_color(level::level_enum level, WORD color) {
std::lock_guard<mutex_t> lock(mutex_);
colors_[level] = color;
}
void log(const details::log_msg &msg) final override {
std::lock_guard<mutex_t> lock(mutex_);
fmt::memory_buffer formatted;
formatter_->format(msg, formatted);
if (msg.color_range_end > msg.color_range_start) {
// before color range
print_range_(formatted, 0, msg.color_range_start);
// in color range
auto orig_attribs = set_console_attribs(colors_[msg.level]);
print_range_(formatted, msg.color_range_start, msg.color_range_end);
::SetConsoleTextAttribute(out_handle_,
orig_attribs); // reset to orig colors
// after color range
print_range_(formatted, msg.color_range_end, formatted.size());
} else // print without colors if color range is invalid
{ {
colors_[level::trace] = WHITE; print_range_(formatted, 0, formatted.size());
colors_[level::debug] = CYAN;
colors_[level::info] = GREEN;
colors_[level::warn] = YELLOW | BOLD;
colors_[level::err] = RED | BOLD; // red bold
colors_[level::critical] = BACKGROUND_RED | WHITE | BOLD; // white bold on red background
colors_[level::off] = 0;
} }
}
~wincolor_sink() override void flush() final override {
{ // windows console always flushed?
this->flush(); }
}
wincolor_sink(const wincolor_sink &other) = delete; void set_pattern(const std::string &pattern) override final {
wincolor_sink &operator=(const wincolor_sink &other) = delete; std::lock_guard<mutex_t> lock(mutex_);
formatter_ =
std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
}
// change the color for the given level void set_formatter(
void set_color(level::level_enum level, WORD color) std::unique_ptr<spdlog::formatter> sink_formatter) override final {
{ std::lock_guard<mutex_t> lock(mutex_);
std::lock_guard<mutex_t> lock(mutex_); formatter_ = std::move(sink_formatter);
colors_[level] = color; }
}
void log(const details::log_msg &msg) final override private:
{ using mutex_t = typename ConsoleMutex::mutex_t;
std::lock_guard<mutex_t> lock(mutex_); // set color and return the orig console attributes (for resetting later)
fmt::memory_buffer formatted; WORD set_console_attribs(WORD attribs) {
formatter_->format(msg, formatted); CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info;
if (msg.color_range_end > msg.color_range_start) ::GetConsoleScreenBufferInfo(out_handle_, &orig_buffer_info);
{ WORD back_color = orig_buffer_info.wAttributes;
// before color range // retrieve the current background color
print_range_(formatted, 0, msg.color_range_start); back_color &= static_cast<WORD>(~(FOREGROUND_RED | FOREGROUND_GREEN |
FOREGROUND_BLUE | FOREGROUND_INTENSITY));
// keep the background color unchanged
::SetConsoleTextAttribute(out_handle_, attribs | back_color);
return orig_buffer_info.wAttributes; // return orig attribs
}
// in color range // print a range of formatted message to console
auto orig_attribs = set_console_attribs(colors_[msg.level]); void print_range_(const fmt::memory_buffer &formatted, size_t start,
print_range_(formatted, msg.color_range_start, msg.color_range_end); size_t end) {
::SetConsoleTextAttribute(out_handle_, auto size = static_cast<DWORD>(end - start);
orig_attribs); // reset to orig colors ::WriteConsoleA(out_handle_, formatted.data() + start, size, nullptr,
// after color range nullptr);
print_range_(formatted, msg.color_range_end, formatted.size()); }
}
else // print without colors if color range is invalid
{
print_range_(formatted, 0, formatted.size());
}
}
void flush() final override HANDLE out_handle_;
{ mutex_t &mutex_;
// windows console always flushed? std::unordered_map<level::level_enum, WORD, level::level_hasher> colors_;
}
void set_pattern(const std::string &pattern) override final
{
std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
}
void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override final
{
std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::move(sink_formatter);
}
private:
using mutex_t = typename ConsoleMutex::mutex_t;
// set color and return the orig console attributes (for resetting later)
WORD set_console_attribs(WORD attribs)
{
CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info;
::GetConsoleScreenBufferInfo(out_handle_, &orig_buffer_info);
WORD back_color = orig_buffer_info.wAttributes;
// retrieve the current background color
back_color &= static_cast<WORD>(~(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY));
// keep the background color unchanged
::SetConsoleTextAttribute(out_handle_, attribs | back_color);
return orig_buffer_info.wAttributes; // return orig attribs
}
// print a range of formatted message to console
void print_range_(const fmt::memory_buffer &formatted, size_t start, size_t end)
{
auto size = static_cast<DWORD>(end - start);
::WriteConsoleA(out_handle_, formatted.data() + start, size, nullptr, nullptr);
}
HANDLE out_handle_;
mutex_t &mutex_;
std::unordered_map<level::level_enum, WORD, level::level_hasher> colors_;
}; };
using wincolor_stdout_sink_mt = wincolor_sink<details::console_stdout, details::console_mutex>; using wincolor_stdout_sink_mt =
using wincolor_stdout_sink_st = wincolor_sink<details::console_stdout, details::console_nullmutex>; wincolor_sink<details::console_stdout, details::console_mutex>;
using wincolor_stdout_sink_st =
wincolor_sink<details::console_stdout, details::console_nullmutex>;
using wincolor_stderr_sink_mt = wincolor_sink<details::console_stderr, details::console_mutex>; using wincolor_stderr_sink_mt =
using wincolor_stderr_sink_st = wincolor_sink<details::console_stderr, details::console_nullmutex>; wincolor_sink<details::console_stderr, details::console_mutex>;
using wincolor_stderr_sink_st =
wincolor_sink<details::console_stderr, details::console_nullmutex>;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

340
src/cpp/include/deps/spdlog/spdlog.h Executable file → Normal file
View File

@ -9,29 +9,29 @@
#define SPDLOG_H #define SPDLOG_H
#pragma once #pragma once
#include "spdlog/common.h"
#include "spdlog/details/registry.h"
#include "spdlog/logger.h"
#include "spdlog/version.h"
#include <chrono> #include <chrono>
#include <functional> #include <functional>
#include <memory> #include <memory>
#include <string> #include <string>
#include "spdlog/common.h"
#include "spdlog/details/registry.h"
#include "spdlog/logger.h"
#include "spdlog/version.h"
namespace spdlog { namespace spdlog {
// Default logger factory- creates synchronous loggers // Default logger factory- creates synchronous loggers
struct synchronous_factory struct synchronous_factory {
{ template <typename Sink, typename... SinkArgs>
template<typename Sink, typename... SinkArgs> static std::shared_ptr<spdlog::logger> create(std::string logger_name,
static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&... args) SinkArgs &&... args) {
{ auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...); auto new_logger =
auto new_logger = std::make_shared<logger>(std::move(logger_name), std::move(sink)); std::make_shared<logger>(std::move(logger_name), std::move(sink));
details::registry::instance().initialize_logger(new_logger); details::registry::instance().initialize_logger(new_logger);
return new_logger; return new_logger;
} }
}; };
using default_factory = synchronous_factory; using default_factory = synchronous_factory;
@ -40,95 +40,85 @@ using default_factory = synchronous_factory;
// The logger's level, formatter and flush level will be set according the // The logger's level, formatter and flush level will be set according the
// global settings. // global settings.
// Example: // Example:
// spdlog::create<daily_file_sink_st>("logger_name", "dailylog_filename", 11, 59); // spdlog::create<daily_file_sink_st>("logger_name", "dailylog_filename", 11,
template<typename Sink, typename... SinkArgs> // 59);
inline std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&... sink_args) template <typename Sink, typename... SinkArgs>
{ inline std::shared_ptr<spdlog::logger> create(std::string logger_name,
return default_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...); SinkArgs &&... sink_args) {
return default_factory::create<Sink>(std::move(logger_name),
std::forward<SinkArgs>(sink_args)...);
} }
// Return an existing logger or nullptr if a logger with such name doesn't // Return an existing logger or nullptr if a logger with such name doesn't
// exist. // exist.
// example: spdlog::get("my_logger")->info("hello {}", "world"); // example: spdlog::get("my_logger")->info("hello {}", "world");
inline std::shared_ptr<logger> get(const std::string &name) inline std::shared_ptr<logger> get(const std::string &name) {
{ return details::registry::instance().get(name);
return details::registry::instance().get(name);
} }
// Set global formatter. Each sink in each logger will get a clone of this object // Set global formatter. Each sink in each logger will get a clone of this
inline void set_formatter(std::unique_ptr<spdlog::formatter> formatter) // object
{ inline void set_formatter(std::unique_ptr<spdlog::formatter> formatter) {
details::registry::instance().set_formatter(std::move(formatter)); details::registry::instance().set_formatter(std::move(formatter));
} }
// Set global format string. // Set global format string.
// example: spdlog::set_pattern("%Y-%m-%d %H:%M:%S.%e %l : %v"); // example: spdlog::set_pattern("%Y-%m-%d %H:%M:%S.%e %l : %v");
inline void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local) inline void set_pattern(std::string pattern, pattern_time_type time_type =
{ pattern_time_type::local) {
set_formatter(std::unique_ptr<spdlog::formatter>(new pattern_formatter(std::move(pattern), time_type))); set_formatter(std::unique_ptr<spdlog::formatter>(
new pattern_formatter(std::move(pattern), time_type)));
} }
// Set global logging level // Set global logging level
inline void set_level(level::level_enum log_level) inline void set_level(level::level_enum log_level) {
{ details::registry::instance().set_level(log_level);
details::registry::instance().set_level(log_level);
} }
// Set global flush level // Set global flush level
inline void flush_on(level::level_enum log_level) inline void flush_on(level::level_enum log_level) {
{ details::registry::instance().flush_on(log_level);
details::registry::instance().flush_on(log_level);
} }
// Start/Restart a periodic flusher thread // Start/Restart a periodic flusher thread
// Warning: Use only if all your loggers are thread safe! // Warning: Use only if all your loggers are thread safe!
inline void flush_every(std::chrono::seconds interval) inline void flush_every(std::chrono::seconds interval) {
{ details::registry::instance().flush_every(interval);
details::registry::instance().flush_every(interval);
} }
// Set global error handler // Set global error handler
inline void set_error_handler(log_err_handler handler) inline void set_error_handler(log_err_handler handler) {
{ details::registry::instance().set_error_handler(std::move(handler));
details::registry::instance().set_error_handler(std::move(handler));
} }
// Register the given logger with the given name // Register the given logger with the given name
inline void register_logger(std::shared_ptr<logger> logger) inline void register_logger(std::shared_ptr<logger> logger) {
{ details::registry::instance().register_logger(std::move(logger));
details::registry::instance().register_logger(std::move(logger));
} }
// Apply a user defined function on all registered loggers // Apply a user defined function on all registered loggers
// Example: // Example:
// spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) {l->flush();}); // spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) {l->flush();});
inline void apply_all(const std::function<void(std::shared_ptr<logger>)> &fun) inline void apply_all(const std::function<void(std::shared_ptr<logger>)> &fun) {
{ details::registry::instance().apply_all(fun);
details::registry::instance().apply_all(fun);
} }
// Drop the reference to the given logger // Drop the reference to the given logger
inline void drop(const std::string &name) inline void drop(const std::string &name) {
{ details::registry::instance().drop(name);
details::registry::instance().drop(name);
} }
// Drop all references from the registry // Drop all references from the registry
inline void drop_all() inline void drop_all() { details::registry::instance().drop_all(); }
{
details::registry::instance().drop_all();
}
// stop any running threads started by spdlog and clean registry loggers // stop any running threads started by spdlog and clean registry loggers
inline void shutdown() inline void shutdown() { details::registry::instance().shutdown(); }
{
details::registry::instance().shutdown();
}
// Automatic registration of loggers when using spdlog::create() or spdlog::create_async // Automatic registration of loggers when using spdlog::create() or
inline void set_automatic_registration(bool automatic_registation) // spdlog::create_async
{ inline void set_automatic_registration(bool automatic_registation) {
details::registry::instance().set_automatic_registration(automatic_registation); details::registry::instance().set_automatic_registration(
automatic_registation);
} }
// API for using default logger (stdout_color_mt), // API for using default logger (stdout_color_mt),
@ -144,159 +134,137 @@ inline void set_automatic_registration(bool automatic_registation)
// IMPORTANT: // IMPORTANT:
// The default API is thread safe (for _mt loggers), but: // The default API is thread safe (for _mt loggers), but:
// set_default_logger() *should not* be used concurrently with the default API. // set_default_logger() *should not* be used concurrently with the default API.
// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another. // e.g do not call set_default_logger() from one thread while calling
// spdlog::info() from another.
inline std::shared_ptr<spdlog::logger> default_logger() inline std::shared_ptr<spdlog::logger> default_logger() {
{ return details::registry::instance().default_logger();
return details::registry::instance().default_logger();
} }
inline spdlog::logger *default_logger_raw() inline spdlog::logger *default_logger_raw() {
{ return details::registry::instance().get_default_raw();
return details::registry::instance().get_default_raw();
} }
inline void set_default_logger(std::shared_ptr<spdlog::logger> default_logger) inline void set_default_logger(std::shared_ptr<spdlog::logger> default_logger) {
{ details::registry::instance().set_default_logger(std::move(default_logger));
details::registry::instance().set_default_logger(std::move(default_logger));
} }
template<typename... Args> template <typename... Args>
inline void log(source_loc source, level::level_enum lvl, const char *fmt, const Args &... args) inline void log(source_loc source, level::level_enum lvl, const char *fmt,
{ const Args &... args) {
default_logger_raw()->log(source, lvl, fmt, args...); default_logger_raw()->log(source, lvl, fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void log(level::level_enum lvl, const char *fmt, const Args &... args) inline void log(level::level_enum lvl, const char *fmt, const Args &... args) {
{ default_logger_raw()->log(source_loc{}, lvl, fmt, args...);
default_logger_raw()->log(source_loc{}, lvl, fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void trace(const char *fmt, const Args &... args) inline void trace(const char *fmt, const Args &... args) {
{ default_logger_raw()->trace(fmt, args...);
default_logger_raw()->trace(fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void debug(const char *fmt, const Args &... args) inline void debug(const char *fmt, const Args &... args) {
{ default_logger_raw()->debug(fmt, args...);
default_logger_raw()->debug(fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void info(const char *fmt, const Args &... args) inline void info(const char *fmt, const Args &... args) {
{ default_logger_raw()->info(fmt, args...);
default_logger_raw()->info(fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void warn(const char *fmt, const Args &... args) inline void warn(const char *fmt, const Args &... args) {
{ default_logger_raw()->warn(fmt, args...);
default_logger_raw()->warn(fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void error(const char *fmt, const Args &... args) inline void error(const char *fmt, const Args &... args) {
{ default_logger_raw()->error(fmt, args...);
default_logger_raw()->error(fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void critical(const char *fmt, const Args &... args) inline void critical(const char *fmt, const Args &... args) {
{ default_logger_raw()->critical(fmt, args...);
default_logger_raw()->critical(fmt, args...);
} }
template<typename T> template <typename T>
inline void log(level::level_enum lvl, const T &msg) inline void log(level::level_enum lvl, const T &msg) {
{ default_logger_raw()->log(lvl, msg);
default_logger_raw()->log(lvl, msg);
} }
template<typename T> template <typename T>
inline void trace(const T &msg) inline void trace(const T &msg) {
{ default_logger_raw()->trace(msg);
default_logger_raw()->trace(msg);
} }
template<typename T> template <typename T>
inline void debug(const T &msg) inline void debug(const T &msg) {
{ default_logger_raw()->debug(msg);
default_logger_raw()->debug(msg);
} }
template<typename T> template <typename T>
inline void info(const T &msg) inline void info(const T &msg) {
{ default_logger_raw()->info(msg);
default_logger_raw()->info(msg);
} }
template<typename T> template <typename T>
inline void warn(const T &msg) inline void warn(const T &msg) {
{ default_logger_raw()->warn(msg);
default_logger_raw()->warn(msg);
} }
template<typename T> template <typename T>
inline void error(const T &msg) inline void error(const T &msg) {
{ default_logger_raw()->error(msg);
default_logger_raw()->error(msg);
} }
template<typename T> template <typename T>
inline void critical(const T &msg) inline void critical(const T &msg) {
{ default_logger_raw()->critical(msg);
default_logger_raw()->critical(msg);
} }
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
template<typename... Args> template <typename... Args>
inline void log(level::level_enum lvl, const wchar_t *fmt, const Args &... args) inline void log(level::level_enum lvl, const wchar_t *fmt,
{ const Args &... args) {
default_logger_raw()->log(lvl, fmt, args...); default_logger_raw()->log(lvl, fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void trace(const wchar_t *fmt, const Args &... args) inline void trace(const wchar_t *fmt, const Args &... args) {
{ default_logger_raw()->trace(fmt, args...);
default_logger_raw()->trace(fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void debug(const wchar_t *fmt, const Args &... args) inline void debug(const wchar_t *fmt, const Args &... args) {
{ default_logger_raw()->debug(fmt, args...);
default_logger_raw()->debug(fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void info(const wchar_t *fmt, const Args &... args) inline void info(const wchar_t *fmt, const Args &... args) {
{ default_logger_raw()->info(fmt, args...);
default_logger_raw()->info(fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void warn(const wchar_t *fmt, const Args &... args) inline void warn(const wchar_t *fmt, const Args &... args) {
{ default_logger_raw()->warn(fmt, args...);
default_logger_raw()->warn(fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void error(const wchar_t *fmt, const Args &... args) inline void error(const wchar_t *fmt, const Args &... args) {
{ default_logger_raw()->error(fmt, args...);
default_logger_raw()->error(fmt, args...);
} }
template<typename... Args> template <typename... Args>
inline void critical(const wchar_t *fmt, const Args &... args) inline void critical(const wchar_t *fmt, const Args &... args) {
{ default_logger_raw()->critical(fmt, args...);
default_logger_raw()->critical(fmt, args...);
} }
#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT #endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
} // namespace spdlog } // namespace spdlog
// //
// enable/disable log calls at compile time according to global level. // enable/disable log calls at compile time according to global level.
@ -311,56 +279,70 @@ inline void critical(const wchar_t *fmt, const Args &... args)
// SPDLOG_LEVEL_OFF // SPDLOG_LEVEL_OFF
// //
#define SPDLOG_LOGGER_CALL(logger, level, ...) \ #define SPDLOG_LOGGER_CALL(logger, level, ...) \
if (logger->should_log(level)) \ if (logger->should_log(level)) \
logger->log(spdlog::source_loc{SPDLOG_FILE_BASENAME(__FILE__), __LINE__, SPDLOG_FUNCTION}, level, __VA_ARGS__) logger->log(spdlog::source_loc{SPDLOG_FILE_BASENAME(__FILE__), __LINE__, \
SPDLOG_FUNCTION}, \
level, __VA_ARGS__)
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_TRACE #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_TRACE
#define SPDLOG_LOGGER_TRACE(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__) #define SPDLOG_LOGGER_TRACE(logger, ...) \
#define SPDLOG_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), __VA_ARGS__) SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__)
#define SPDLOG_TRACE(...) \
SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), __VA_ARGS__)
#else #else
#define SPDLOG_LOGGER_TRACE(logger, ...) (void)0 #define SPDLOG_LOGGER_TRACE(logger, ...) (void)0
#define SPDLOG_TRACE(...) (void)0 #define SPDLOG_TRACE(...) (void)0
#endif #endif
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_DEBUG #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_DEBUG
#define SPDLOG_LOGGER_DEBUG(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__) #define SPDLOG_LOGGER_DEBUG(logger, ...) \
#define SPDLOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), __VA_ARGS__) SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__)
#define SPDLOG_DEBUG(...) \
SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), __VA_ARGS__)
#else #else
#define SPDLOG_LOGGER_DEBUG(logger, ...) (void)0 #define SPDLOG_LOGGER_DEBUG(logger, ...) (void)0
#define SPDLOG_DEBUG(...) (void)0 #define SPDLOG_DEBUG(...) (void)0
#endif #endif
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_INFO #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_INFO
#define SPDLOG_LOGGER_INFO(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__) #define SPDLOG_LOGGER_INFO(logger, ...) \
#define SPDLOG_INFO(...) SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), __VA_ARGS__) SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__)
#define SPDLOG_INFO(...) \
SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), __VA_ARGS__)
#else #else
#define SPDLOG_LOGGER_INFO(logger, ...) (void)0 #define SPDLOG_LOGGER_INFO(logger, ...) (void)0
#define SPDLOG_INFO(...) (void)0 #define SPDLOG_INFO(...) (void)0
#endif #endif
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_WARN #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_WARN
#define SPDLOG_LOGGER_WARN(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__) #define SPDLOG_LOGGER_WARN(logger, ...) \
#define SPDLOG_WARN(...) SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), __VA_ARGS__) SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__)
#define SPDLOG_WARN(...) \
SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), __VA_ARGS__)
#else #else
#define SPDLOG_LOGGER_WARN(logger, ...) (void)0 #define SPDLOG_LOGGER_WARN(logger, ...) (void)0
#define SPDLOG_WARN(...) (void)0 #define SPDLOG_WARN(...) (void)0
#endif #endif
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_ERROR #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_ERROR
#define SPDLOG_LOGGER_ERROR(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__) #define SPDLOG_LOGGER_ERROR(logger, ...) \
#define SPDLOG_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), __VA_ARGS__) SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__)
#define SPDLOG_ERROR(...) \
SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), __VA_ARGS__)
#else #else
#define SPDLOG_LOGGER_ERROR(logger, ...) (void)0 #define SPDLOG_LOGGER_ERROR(logger, ...) (void)0
#define SPDLOG_ERROR(...) (void)0 #define SPDLOG_ERROR(...) (void)0
#endif #endif
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_CRITICAL #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_CRITICAL
#define SPDLOG_LOGGER_CRITICAL(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__) #define SPDLOG_LOGGER_CRITICAL(logger, ...) \
#define SPDLOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), __VA_ARGS__) SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__)
#define SPDLOG_CRITICAL(...) \
SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), __VA_ARGS__)
#else #else
#define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0 #define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0
#define SPDLOG_CRITICAL(...) (void)0 #define SPDLOG_CRITICAL(...) (void)0
#endif #endif
#endif // SPDLOG_H #endif // SPDLOG_H

6
src/cpp/include/deps/spdlog/tweakme.h Executable file → Normal file
View File

@ -123,14 +123,16 @@
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// Uncomment to disable default logger creation. // Uncomment to disable default logger creation.
// This might save some (very) small initialization time if no default logger is needed. // This might save some (very) small initialization time if no default logger is
// needed.
// //
// #define SPDLOG_DISABLE_DEFAULT_LOGGER // #define SPDLOG_DISABLE_DEFAULT_LOGGER
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// Uncomment and set to compile time level with zero cost (default is INFO). // Uncomment and set to compile time level with zero cost (default is INFO).
// Macros like SPDLOG_DEBUG(..), SPDLOG_INFO(..) will expand to empty statements if not enabled // Macros like SPDLOG_DEBUG(..), SPDLOG_INFO(..) will expand to empty
// statements if not enabled
// //
// #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO // #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////

3
src/cpp/include/deps/spdlog/version.h Executable file → Normal file
View File

@ -9,4 +9,5 @@
#define SPDLOG_VER_MINOR 3 #define SPDLOG_VER_MINOR 3
#define SPDLOG_VER_PATCH 1 #define SPDLOG_VER_PATCH 1
#define SPDLOG_VERSION (SPDLOG_VER_MAJOR * 10000 + SPDLOG_VER_MINOR * 100 + SPDLOG_VER_PATCH) #define SPDLOG_VERSION \
(SPDLOG_VER_MAJOR * 10000 + SPDLOG_VER_MINOR * 100 + SPDLOG_VER_PATCH)

43
src/cpp/include/deps/yoga/Bitfield.h
View File

@ -6,10 +6,11 @@
*/ */
#pragma once #pragma once
#include <yoga/YGEnums.h>
#include <cstddef> #include <cstddef>
#include <limits> #include <limits>
#include <type_traits> #include <type_traits>
#include <yoga/YGEnums.h>
namespace facebook { namespace facebook {
namespace yoga { namespace yoga {
@ -23,8 +24,8 @@ constexpr size_t log2ceil(size_t n) {
// The number of bits necessary to represent enums defined with YG_ENUM_SEQ_DECL // The number of bits necessary to represent enums defined with YG_ENUM_SEQ_DECL
template <typename Enum> template <typename Enum>
constexpr size_t bitWidth() { constexpr size_t bitWidth() {
static_assert( static_assert(enums::count<Enum>() > 0,
enums::count<Enum>() > 0, "Enums must have at least one entries"); "Enums must have at least one entries");
return log2ceil(enums::count<Enum>() - 1); return log2ceil(enums::count<Enum>() - 1);
} }
@ -71,25 +72,22 @@ struct IndexedType<0, T, Ts...> {
using Type = T; using Type = T;
}; };
} // namespace detail } // namespace detail
template <typename Storage, typename... Fields> template <typename Storage, typename... Fields>
class Bitfield { class Bitfield {
static_assert( static_assert(std::is_integral<Storage>::value,
std::is_integral<Storage>::value, "Bitfield needs an integral storage type");
"Bitfield needs an integral storage type"); static_assert(std::is_unsigned<Storage>::value,
static_assert( "Bitfield needs an unsigned storage type");
std::is_unsigned<Storage>::value,
"Bitfield needs an unsigned storage type");
static_assert(sizeof...(Fields) > 0, "Bitfield needs at least one member"); static_assert(sizeof...(Fields) > 0, "Bitfield needs at least one member");
using BitTraits = detail::BitTraits<Storage, Fields...>; using BitTraits = detail::BitTraits<Storage, Fields...>;
#if !defined(_MSC_VER) || _MSC_VER > 1914 #if !defined(_MSC_VER) || _MSC_VER > 1914
static_assert( static_assert(BitTraits::shift(0) + BitTraits::width(0) <=
BitTraits::shift(0) + BitTraits::width(0) <= std::numeric_limits<Storage>::digits,
std::numeric_limits<Storage>::digits, "Specified storage type is too narrow to hold all types");
"Specified storage type is too narrow to hold all types");
#endif #endif
template <size_t Idx> template <size_t Idx>
@ -98,7 +96,7 @@ class Bitfield {
template <size_t Idx, typename Value, typename... Values> template <size_t Idx, typename Value, typename... Values>
static constexpr Storage initStorage(Value value, Values... values) { static constexpr Storage initStorage(Value value, Values... values) {
return ((value << BitTraits::shift(Idx)) & BitTraits::mask(Idx)) | return ((value << BitTraits::shift(Idx)) & BitTraits::mask(Idx)) |
initStorage<Idx + 1, Values...>(values...); initStorage<Idx + 1, Values...>(values...);
} }
template <size_t Idx> template <size_t Idx>
@ -108,15 +106,16 @@ class Bitfield {
Storage storage_ = 0; Storage storage_ = 0;
public: public:
template <size_t Idx> template <size_t Idx>
class Ref { class Ref {
Bitfield& bitfield_; Bitfield& bitfield_;
public: public:
Ref(Bitfield& bitfield) : bitfield_(bitfield) {} Ref(Bitfield& bitfield) : bitfield_(bitfield) {}
Ref& operator=(TypeAt<Idx> value) { Ref& operator=(TypeAt<Idx> value) {
bitfield_.storage_ = (bitfield_.storage_ & ~BitTraits::mask(Idx)) | bitfield_.storage_ =
(bitfield_.storage_ & ~BitTraits::mask(Idx)) |
((value << BitTraits::shift(Idx)) & BitTraits::mask(Idx)); ((value << BitTraits::shift(Idx)) & BitTraits::mask(Idx));
return *this; return *this;
} }
@ -130,8 +129,8 @@ public:
template <size_t Idx> template <size_t Idx>
constexpr TypeAt<Idx> at() const { constexpr TypeAt<Idx> at() const {
return static_cast<TypeAt<Idx>>( return static_cast<TypeAt<Idx>>((storage_ & BitTraits::mask(Idx)) >>
(storage_ & BitTraits::mask(Idx)) >> BitTraits::shift(Idx)); BitTraits::shift(Idx));
} }
template <size_t Idx> template <size_t Idx>
@ -140,5 +139,5 @@ public:
} }
}; };
} // namespace yoga } // namespace yoga
} // namespace facebook } // namespace facebook

19
src/cpp/include/deps/yoga/CompactValue.h
View File

@ -6,12 +6,12 @@
*/ */
#pragma once #pragma once
#include "YGValue.h"
#include <cmath> #include <cmath>
#include <cstdint> #include <cstdint>
#include <limits> #include <limits>
#include "YGValue.h"
static_assert( static_assert(
std::numeric_limits<float>::is_iec559, std::numeric_limits<float>::is_iec559,
"facebook::yoga::detail::CompactValue only works with IEEE754 floats"); "facebook::yoga::detail::CompactValue only works with IEEE754 floats");
@ -42,7 +42,7 @@ namespace detail {
class CompactValue { class CompactValue {
friend constexpr bool operator==(CompactValue, CompactValue) noexcept; friend constexpr bool operator==(CompactValue, CompactValue) noexcept;
public: public:
static constexpr auto LOWER_BOUND = 1.08420217e-19f; static constexpr auto LOWER_BOUND = 1.08420217e-19f;
static constexpr auto UPPER_BOUND_POINT = 36893485948395847680.0f; static constexpr auto UPPER_BOUND_POINT = 36893485948395847680.0f;
static constexpr auto UPPER_BOUND_PERCENT = 18446742974197923840.0f; static constexpr auto UPPER_BOUND_PERCENT = 18446742974197923840.0f;
@ -129,14 +129,13 @@ public:
} }
bool isUndefined() const noexcept { bool isUndefined() const noexcept {
return ( return (payload_.repr != AUTO_BITS && payload_.repr != ZERO_BITS_POINT &&
payload_.repr != AUTO_BITS && payload_.repr != ZERO_BITS_POINT && payload_.repr != ZERO_BITS_PERCENT && std::isnan(payload_.value));
payload_.repr != ZERO_BITS_PERCENT && std::isnan(payload_.value));
} }
bool isAuto() const noexcept { return payload_.repr == AUTO_BITS; } bool isAuto() const noexcept { return payload_.repr == AUTO_BITS; }
private: private:
union Payload { union Payload {
float value; float value;
uint32_t repr; uint32_t repr;
@ -178,6 +177,6 @@ constexpr bool operator!=(CompactValue a, CompactValue b) noexcept {
return !(a == b); return !(a == b);
} }
} // namespace detail } // namespace detail
} // namespace yoga } // namespace yoga
} // namespace facebook } // namespace facebook

9
src/cpp/include/deps/yoga/Utils.cpp
View File

@ -8,12 +8,11 @@
using namespace facebook; using namespace facebook;
YGFlexDirection YGFlexDirectionCross( YGFlexDirection YGFlexDirectionCross(const YGFlexDirection flexDirection,
const YGFlexDirection flexDirection, const YGDirection direction) {
const YGDirection direction) {
return YGFlexDirectionIsColumn(flexDirection) return YGFlexDirectionIsColumn(flexDirection)
? YGResolveFlexDirection(YGFlexDirectionRow, direction) ? YGResolveFlexDirection(YGFlexDirectionRow, direction)
: YGFlexDirectionColumn; : YGFlexDirectionColumn;
} }
float YGFloatMax(const float a, const float b) { float YGFloatMax(const float a, const float b) {

48
src/cpp/include/deps/yoga/Utils.h
View File

@ -5,9 +5,9 @@
* file in the root directory of this source tree. * file in the root directory of this source tree.
*/ */
#pragma once #pragma once
#include "CompactValue.h"
#include "YGNode.h" #include "YGNode.h"
#include "Yoga-internal.h" #include "Yoga-internal.h"
#include "CompactValue.h"
// This struct is an helper model to hold the data for step 4 of flexbox algo, // This struct is an helper model to hold the data for step 4 of flexbox algo,
// which is collecting the flex items in a line. // which is collecting the flex items in a line.
@ -53,10 +53,9 @@ struct YGCollectFlexItemsRowValues {
}; };
bool YGValueEqual(const YGValue& a, const YGValue& b); bool YGValueEqual(const YGValue& a, const YGValue& b);
inline bool YGValueEqual( inline bool YGValueEqual(facebook::yoga::detail::CompactValue a,
facebook::yoga::detail::CompactValue a, facebook::yoga::detail::CompactValue b) {
facebook::yoga::detail::CompactValue b) { return YGValueEqual((YGValue)a, (YGValue)b);
return YGValueEqual((YGValue) a, (YGValue) b);
} }
// This custom float equality function returns true if either absolute // This custom float equality function returns true if either absolute
@ -65,9 +64,8 @@ bool YGFloatsEqual(const float a, const float b);
float YGFloatMax(const float a, const float b); float YGFloatMax(const float a, const float b);
YGFloatOptional YGFloatOptionalMax( YGFloatOptional YGFloatOptionalMax(const YGFloatOptional op1,
const YGFloatOptional op1, const YGFloatOptional op2);
const YGFloatOptional op2);
float YGFloatMin(const float a, const float b); float YGFloatMin(const float a, const float b);
@ -75,9 +73,8 @@ float YGFloatMin(const float a, const float b);
// YGFloatsEqual, as the default float comparison operator will not work(Look // YGFloatsEqual, as the default float comparison operator will not work(Look
// at the comments of YGFloatsEqual function). // at the comments of YGFloatsEqual function).
template <std::size_t size> template <std::size_t size>
bool YGFloatArrayEqual( bool YGFloatArrayEqual(const std::array<float, size>& val1,
const std::array<float, size>& val1, const std::array<float, size>& val2) {
const std::array<float, size>& val2) {
bool areEqual = true; bool areEqual = true;
for (std::size_t i = 0; i < size && areEqual; ++i) { for (std::size_t i = 0; i < size && areEqual; ++i) {
areEqual = YGFloatsEqual(val1[i], val2[i]); areEqual = YGFloatsEqual(val1[i], val2[i]);
@ -88,18 +85,16 @@ bool YGFloatArrayEqual(
// This function returns 0 if YGFloatIsUndefined(val) is true and val otherwise // This function returns 0 if YGFloatIsUndefined(val) is true and val otherwise
float YGFloatSanitize(const float val); float YGFloatSanitize(const float val);
YGFlexDirection YGFlexDirectionCross( YGFlexDirection YGFlexDirectionCross(const YGFlexDirection flexDirection,
const YGFlexDirection flexDirection, const YGDirection direction);
const YGDirection direction);
inline bool YGFlexDirectionIsRow(const YGFlexDirection flexDirection) { inline bool YGFlexDirectionIsRow(const YGFlexDirection flexDirection) {
return flexDirection == YGFlexDirectionRow || return flexDirection == YGFlexDirectionRow ||
flexDirection == YGFlexDirectionRowReverse; flexDirection == YGFlexDirectionRowReverse;
} }
inline YGFloatOptional YGResolveValue( inline YGFloatOptional YGResolveValue(const YGValue value,
const YGValue value, const float ownerSize) {
const float ownerSize) {
switch (value.unit) { switch (value.unit) {
case YGUnitPoint: case YGUnitPoint:
return YGFloatOptional{value.value}; return YGFloatOptional{value.value};
@ -110,20 +105,18 @@ inline YGFloatOptional YGResolveValue(
} }
} }
inline YGFloatOptional YGResolveValue( inline YGFloatOptional YGResolveValue(yoga::detail::CompactValue value,
yoga::detail::CompactValue value, float ownerSize) {
float ownerSize) { return YGResolveValue((YGValue)value, ownerSize);
return YGResolveValue((YGValue) value, ownerSize);
} }
inline bool YGFlexDirectionIsColumn(const YGFlexDirection flexDirection) { inline bool YGFlexDirectionIsColumn(const YGFlexDirection flexDirection) {
return flexDirection == YGFlexDirectionColumn || return flexDirection == YGFlexDirectionColumn ||
flexDirection == YGFlexDirectionColumnReverse; flexDirection == YGFlexDirectionColumnReverse;
} }
inline YGFlexDirection YGResolveFlexDirection( inline YGFlexDirection YGResolveFlexDirection(
const YGFlexDirection flexDirection, const YGFlexDirection flexDirection, const YGDirection direction) {
const YGDirection direction) {
if (direction == YGDirectionRTL) { if (direction == YGDirectionRTL) {
if (flexDirection == YGFlexDirectionRow) { if (flexDirection == YGFlexDirectionRow) {
return YGFlexDirectionRowReverse; return YGFlexDirectionRowReverse;
@ -135,8 +128,7 @@ inline YGFlexDirection YGResolveFlexDirection(
return flexDirection; return flexDirection;
} }
inline YGFloatOptional YGResolveValueMargin( inline YGFloatOptional YGResolveValueMargin(yoga::detail::CompactValue value,
yoga::detail::CompactValue value, const float ownerSize) {
const float ownerSize) {
return value.isAuto() ? YGFloatOptional{0} : YGResolveValue(value, ownerSize); return value.isAuto() ? YGFloatOptional{0} : YGResolveValue(value, ownerSize);
} }

21
src/cpp/include/deps/yoga/YGConfig.cpp
View File

@ -11,13 +11,8 @@ YGConfig::YGConfig(YGLogger logger) : cloneNodeCallback_{nullptr} {
loggerUsesContext_ = false; loggerUsesContext_ = false;
} }
void YGConfig::log( void YGConfig::log(YGConfig* config, YGNode* node, YGLogLevel logLevel,
YGConfig* config, void* logContext, const char* format, va_list args) {
YGNode* node,
YGLogLevel logLevel,
void* logContext,
const char* format,
va_list args) {
if (loggerUsesContext_) { if (loggerUsesContext_) {
logger_.withContext(config, node, logLevel, logContext, format, args); logger_.withContext(config, node, logLevel, logContext, format, args);
} else { } else {
@ -25,16 +20,14 @@ void YGConfig::log(
} }
} }
YGNodeRef YGConfig::cloneNode( YGNodeRef YGConfig::cloneNode(YGNodeRef node, YGNodeRef owner, int childIndex,
YGNodeRef node, void* cloneContext) {
YGNodeRef owner,
int childIndex,
void* cloneContext) {
YGNodeRef clone = nullptr; YGNodeRef clone = nullptr;
if (cloneNodeCallback_.noContext != nullptr) { if (cloneNodeCallback_.noContext != nullptr) {
clone = cloneNodeUsesContext_ clone = cloneNodeUsesContext_
? cloneNodeCallback_.withContext(node, owner, childIndex, cloneContext) ? cloneNodeCallback_.withContext(node, owner, childIndex,
: cloneNodeCallback_.noContext(node, owner, childIndex); cloneContext)
: cloneNodeCallback_.noContext(node, owner, childIndex);
} }
if (clone == nullptr) { if (clone == nullptr) {
clone = YGNodeClone(node); clone = YGNodeClone(node);

28
src/cpp/include/deps/yoga/YGConfig.h
View File

@ -9,20 +9,13 @@
#include "Yoga.h" #include "Yoga.h"
struct YGConfig { struct YGConfig {
using LogWithContextFn = int (*)( using LogWithContextFn = int (*)(YGConfigRef config, YGNodeRef node,
YGConfigRef config, YGLogLevel level, void* context,
YGNodeRef node, const char* format, va_list args);
YGLogLevel level, using CloneWithContextFn = YGNodeRef (*)(YGNodeRef node, YGNodeRef owner,
void* context, int childIndex, void* cloneContext);
const char* format,
va_list args);
using CloneWithContextFn = YGNodeRef (*)(
YGNodeRef node,
YGNodeRef owner,
int childIndex,
void* cloneContext);
private: private:
union { union {
CloneWithContextFn withContext; CloneWithContextFn withContext;
YGCloneNodeFunc noContext; YGCloneNodeFunc noContext;
@ -34,7 +27,7 @@ private:
bool cloneNodeUsesContext_; bool cloneNodeUsesContext_;
bool loggerUsesContext_; bool loggerUsesContext_;
public: public:
bool useWebDefaults = false; bool useWebDefaults = false;
bool useLegacyStretchBehaviour = false; bool useLegacyStretchBehaviour = false;
bool shouldDiffLayoutWithoutLegacyStretchBehaviour = false; bool shouldDiffLayoutWithoutLegacyStretchBehaviour = false;
@ -56,11 +49,8 @@ public:
} }
void setLogger(std::nullptr_t) { setLogger(YGLogger{nullptr}); } void setLogger(std::nullptr_t) { setLogger(YGLogger{nullptr}); }
YGNodeRef cloneNode( YGNodeRef cloneNode(YGNodeRef node, YGNodeRef owner, int childIndex,
YGNodeRef node, void* cloneContext);
YGNodeRef owner,
int childIndex,
void* cloneContext);
void setCloneNodeCallback(YGCloneNodeFunc cloneNode) { void setCloneNodeCallback(YGCloneNodeFunc cloneNode) {
cloneNodeCallback_.noContext = cloneNode; cloneNodeCallback_.noContext = cloneNode;
cloneNodeUsesContext_ = false; cloneNodeUsesContext_ = false;

103
src/cpp/include/deps/yoga/YGEnums.h
View File

@ -14,18 +14,18 @@ namespace yoga {
namespace enums { namespace enums {
template <typename T> template <typename T>
constexpr int count(); // can't use `= delete` due to a defect in clang < 3.9 constexpr int count(); // can't use `= delete` due to a defect in clang < 3.9
namespace detail { namespace detail {
template <int... xs> template <int... xs>
constexpr int n() { constexpr int n() {
return sizeof...(xs); return sizeof...(xs);
} }
} // namespace detail } // namespace detail
} // namespace enums } // namespace enums
} // namespace yoga } // namespace yoga
} // namespace facebook } // namespace facebook
#endif #endif
#define YG_ENUM_DECL(NAME, ...) \ #define YG_ENUM_DECL(NAME, ...) \
@ -53,94 +53,49 @@ constexpr int n() {
YG_EXTERN_C_BEGIN YG_EXTERN_C_BEGIN
YG_ENUM_SEQ_DECL( YG_ENUM_SEQ_DECL(YGAlign, YGAlignAuto, YGAlignFlexStart, YGAlignCenter,
YGAlign, YGAlignFlexEnd, YGAlignStretch, YGAlignBaseline,
YGAlignAuto, YGAlignSpaceBetween, YGAlignSpaceAround);
YGAlignFlexStart,
YGAlignCenter,
YGAlignFlexEnd,
YGAlignStretch,
YGAlignBaseline,
YGAlignSpaceBetween,
YGAlignSpaceAround);
YG_ENUM_SEQ_DECL(YGDimension, YGDimensionWidth, YGDimensionHeight) YG_ENUM_SEQ_DECL(YGDimension, YGDimensionWidth, YGDimensionHeight)
YG_ENUM_SEQ_DECL( YG_ENUM_SEQ_DECL(YGDirection, YGDirectionInherit, YGDirectionLTR,
YGDirection, YGDirectionRTL)
YGDirectionInherit,
YGDirectionLTR,
YGDirectionRTL)
YG_ENUM_SEQ_DECL(YGDisplay, YGDisplayFlex, YGDisplayNone) YG_ENUM_SEQ_DECL(YGDisplay, YGDisplayFlex, YGDisplayNone)
YG_ENUM_SEQ_DECL( YG_ENUM_SEQ_DECL(YGEdge, YGEdgeLeft, YGEdgeTop, YGEdgeRight, YGEdgeBottom,
YGEdge, YGEdgeStart, YGEdgeEnd, YGEdgeHorizontal, YGEdgeVertical,
YGEdgeLeft, YGEdgeAll)
YGEdgeTop,
YGEdgeRight,
YGEdgeBottom,
YGEdgeStart,
YGEdgeEnd,
YGEdgeHorizontal,
YGEdgeVertical,
YGEdgeAll)
YG_ENUM_SEQ_DECL(YGExperimentalFeature, YGExperimentalFeatureWebFlexBasis) YG_ENUM_SEQ_DECL(YGExperimentalFeature, YGExperimentalFeatureWebFlexBasis)
YG_ENUM_SEQ_DECL( YG_ENUM_SEQ_DECL(YGFlexDirection, YGFlexDirectionColumn,
YGFlexDirection, YGFlexDirectionColumnReverse, YGFlexDirectionRow,
YGFlexDirectionColumn, YGFlexDirectionRowReverse)
YGFlexDirectionColumnReverse,
YGFlexDirectionRow,
YGFlexDirectionRowReverse)
YG_ENUM_SEQ_DECL( YG_ENUM_SEQ_DECL(YGJustify, YGJustifyFlexStart, YGJustifyCenter,
YGJustify, YGJustifyFlexEnd, YGJustifySpaceBetween, YGJustifySpaceAround,
YGJustifyFlexStart, YGJustifySpaceEvenly)
YGJustifyCenter,
YGJustifyFlexEnd,
YGJustifySpaceBetween,
YGJustifySpaceAround,
YGJustifySpaceEvenly)
YG_ENUM_SEQ_DECL( YG_ENUM_SEQ_DECL(YGLogLevel, YGLogLevelError, YGLogLevelWarn, YGLogLevelInfo,
YGLogLevel, YGLogLevelDebug, YGLogLevelVerbose, YGLogLevelFatal)
YGLogLevelError,
YGLogLevelWarn,
YGLogLevelInfo,
YGLogLevelDebug,
YGLogLevelVerbose,
YGLogLevelFatal)
YG_ENUM_SEQ_DECL( YG_ENUM_SEQ_DECL(YGMeasureMode, YGMeasureModeUndefined, YGMeasureModeExactly,
YGMeasureMode, YGMeasureModeAtMost)
YGMeasureModeUndefined,
YGMeasureModeExactly,
YGMeasureModeAtMost)
YG_ENUM_SEQ_DECL(YGNodeType, YGNodeTypeDefault, YGNodeTypeText) YG_ENUM_SEQ_DECL(YGNodeType, YGNodeTypeDefault, YGNodeTypeText)
YG_ENUM_SEQ_DECL( YG_ENUM_SEQ_DECL(YGOverflow, YGOverflowVisible, YGOverflowHidden,
YGOverflow, YGOverflowScroll)
YGOverflowVisible,
YGOverflowHidden,
YGOverflowScroll)
YG_ENUM_SEQ_DECL(YGPositionType, YGPositionTypeRelative, YGPositionTypeAbsolute) YG_ENUM_SEQ_DECL(YGPositionType, YGPositionTypeRelative, YGPositionTypeAbsolute)
YG_ENUM_DECL( YG_ENUM_DECL(YGPrintOptions, YGPrintOptionsLayout = 1, YGPrintOptionsStyle = 2,
YGPrintOptions, YGPrintOptionsChildren = 4)
YGPrintOptionsLayout = 1,
YGPrintOptionsStyle = 2,
YGPrintOptionsChildren = 4)
YG_ENUM_SEQ_DECL( YG_ENUM_SEQ_DECL(YGUnit, YGUnitUndefined, YGUnitPoint, YGUnitPercent,
YGUnit, YGUnitAuto)
YGUnitUndefined,
YGUnitPoint,
YGUnitPercent,
YGUnitAuto)
YG_ENUM_SEQ_DECL(YGWrap, YGWrapNoWrap, YGWrapWrap, YGWrapWrapReverse) YG_ENUM_SEQ_DECL(YGWrap, YGWrapNoWrap, YGWrapWrap, YGWrapWrapReverse)

19
src/cpp/include/deps/yoga/YGFloatOptional.h
View File

@ -8,13 +8,14 @@
#include <cmath> #include <cmath>
#include <limits> #include <limits>
#include "Yoga-internal.h" #include "Yoga-internal.h"
struct YGFloatOptional { struct YGFloatOptional {
private: private:
float value_ = std::numeric_limits<float>::quiet_NaN(); float value_ = std::numeric_limits<float>::quiet_NaN();
public: public:
explicit constexpr YGFloatOptional(float value) : value_(value) {} explicit constexpr YGFloatOptional(float value) : value_(value) {}
constexpr YGFloatOptional() = default; constexpr YGFloatOptional() = default;
@ -28,7 +29,7 @@ public:
inline bool operator==(YGFloatOptional lhs, YGFloatOptional rhs) { inline bool operator==(YGFloatOptional lhs, YGFloatOptional rhs) {
return lhs.unwrap() == rhs.unwrap() || return lhs.unwrap() == rhs.unwrap() ||
(lhs.isUndefined() && rhs.isUndefined()); (lhs.isUndefined() && rhs.isUndefined());
} }
inline bool operator!=(YGFloatOptional lhs, YGFloatOptional rhs) { inline bool operator!=(YGFloatOptional lhs, YGFloatOptional rhs) {
return !(lhs == rhs); return !(lhs == rhs);
@ -37,16 +38,10 @@ inline bool operator!=(YGFloatOptional lhs, YGFloatOptional rhs) {
inline bool operator==(YGFloatOptional lhs, float rhs) { inline bool operator==(YGFloatOptional lhs, float rhs) {
return lhs == YGFloatOptional{rhs}; return lhs == YGFloatOptional{rhs};
} }
inline bool operator!=(YGFloatOptional lhs, float rhs) { inline bool operator!=(YGFloatOptional lhs, float rhs) { return !(lhs == rhs); }
return !(lhs == rhs);
}
inline bool operator==(float lhs, YGFloatOptional rhs) { inline bool operator==(float lhs, YGFloatOptional rhs) { return rhs == lhs; }
return rhs == lhs; inline bool operator!=(float lhs, YGFloatOptional rhs) { return !(lhs == rhs); }
}
inline bool operator!=(float lhs, YGFloatOptional rhs) {
return !(lhs == rhs);
}
inline YGFloatOptional operator+(YGFloatOptional lhs, YGFloatOptional rhs) { inline YGFloatOptional operator+(YGFloatOptional lhs, YGFloatOptional rhs) {
return YGFloatOptional{lhs.unwrap() + rhs.unwrap()}; return YGFloatOptional{lhs.unwrap() + rhs.unwrap()};

4
src/cpp/include/deps/yoga/YGLayout.cpp
View File

@ -5,12 +5,14 @@
* file in the root directory of this source tree. * file in the root directory of this source tree.
*/ */
#include "YGLayout.h" #include "YGLayout.h"
#include "Utils.h" #include "Utils.h"
using namespace facebook; using namespace facebook;
bool YGLayout::operator==(YGLayout layout) const { bool YGLayout::operator==(YGLayout layout) const {
bool isEqual = YGFloatArrayEqual(position, layout.position) && bool isEqual =
YGFloatArrayEqual(position, layout.position) &&
YGFloatArrayEqual(dimensions, layout.dimensions) && YGFloatArrayEqual(dimensions, layout.dimensions) &&
YGFloatArrayEqual(margin, layout.margin) && YGFloatArrayEqual(margin, layout.margin) &&
YGFloatArrayEqual(border, layout.border) && YGFloatArrayEqual(border, layout.border) &&

10
src/cpp/include/deps/yoga/YGLayout.h
View File

@ -16,22 +16,22 @@ struct YGLayout {
std::array<float, 4> border = {}; std::array<float, 4> border = {};
std::array<float, 4> padding = {}; std::array<float, 4> padding = {};
private: private:
static constexpr size_t directionIdx = 0; static constexpr size_t directionIdx = 0;
static constexpr size_t didUseLegacyFlagIdx = 1; static constexpr size_t didUseLegacyFlagIdx = 1;
static constexpr size_t doesLegacyStretchFlagAffectsLayoutIdx = 2; static constexpr size_t doesLegacyStretchFlagAffectsLayoutIdx = 2;
static constexpr size_t hadOverflowIdx = 3; static constexpr size_t hadOverflowIdx = 3;
facebook::yoga::Bitfield<uint8_t, YGDirection, bool, bool, bool> flags_ = facebook::yoga::Bitfield<uint8_t, YGDirection, bool, bool, bool> flags_ = {
{YGDirectionInherit, false, false, false}; YGDirectionInherit, false, false, false};
public: public:
uint32_t computedFlexBasisGeneration = 0; uint32_t computedFlexBasisGeneration = 0;
YGFloatOptional computedFlexBasis = {}; YGFloatOptional computedFlexBasis = {};
// Instead of recomputing the entire layout every single time, we cache some // Instead of recomputing the entire layout every single time, we cache some
// information to break early when nothing changed // information to break early when nothing changed
uint32_t generationCount = 0; uint32_t generationCount = 0;
YGDirection lastOwnerDirection = (YGDirection) -1; YGDirection lastOwnerDirection = (YGDirection)-1;
uint32_t nextCachedMeasurementsIndex = 0; uint32_t nextCachedMeasurementsIndex = 0;
std::array<YGCachedMeasurement, YG_MAX_CACHED_RESULT_COUNT> std::array<YGCachedMeasurement, YG_MAX_CACHED_RESULT_COUNT>

172
src/cpp/include/deps/yoga/YGNode.cpp
View File

@ -5,8 +5,10 @@
* file in the root directory of this source tree. * file in the root directory of this source tree.
*/ */
#include "YGNode.h" #include "YGNode.h"
#include <algorithm> #include <algorithm>
#include <iostream> #include <iostream>
#include "CompactValue.h" #include "CompactValue.h"
#include "Utils.h" #include "Utils.h"
@ -49,114 +51,104 @@ void YGNode::print(void* printContext) {
} }
} }
YGFloatOptional YGNode::getLeadingPosition( YGFloatOptional YGNode::getLeadingPosition(const YGFlexDirection axis,
const YGFlexDirection axis, const float axisSize) const {
const float axisSize) const {
if (YGFlexDirectionIsRow(axis)) { if (YGFlexDirectionIsRow(axis)) {
auto leadingPosition = YGComputedEdgeValue( auto leadingPosition = YGComputedEdgeValue(style_.position(), YGEdgeStart,
style_.position(), YGEdgeStart, CompactValue::ofUndefined()); CompactValue::ofUndefined());
if (!leadingPosition.isUndefined()) { if (!leadingPosition.isUndefined()) {
return YGResolveValue(leadingPosition, axisSize); return YGResolveValue(leadingPosition, axisSize);
} }
} }
auto leadingPosition = YGComputedEdgeValue( auto leadingPosition = YGComputedEdgeValue(style_.position(), leading[axis],
style_.position(), leading[axis], CompactValue::ofUndefined()); CompactValue::ofUndefined());
return leadingPosition.isUndefined() return leadingPosition.isUndefined()
? YGFloatOptional{0} ? YGFloatOptional{0}
: YGResolveValue(leadingPosition, axisSize); : YGResolveValue(leadingPosition, axisSize);
} }
YGFloatOptional YGNode::getTrailingPosition( YGFloatOptional YGNode::getTrailingPosition(const YGFlexDirection axis,
const YGFlexDirection axis, const float axisSize) const {
const float axisSize) const {
if (YGFlexDirectionIsRow(axis)) { if (YGFlexDirectionIsRow(axis)) {
auto trailingPosition = YGComputedEdgeValue( auto trailingPosition = YGComputedEdgeValue(style_.position(), YGEdgeEnd,
style_.position(), YGEdgeEnd, CompactValue::ofUndefined()); CompactValue::ofUndefined());
if (!trailingPosition.isUndefined()) { if (!trailingPosition.isUndefined()) {
return YGResolveValue(trailingPosition, axisSize); return YGResolveValue(trailingPosition, axisSize);
} }
} }
auto trailingPosition = YGComputedEdgeValue( auto trailingPosition = YGComputedEdgeValue(style_.position(), trailing[axis],
style_.position(), trailing[axis], CompactValue::ofUndefined()); CompactValue::ofUndefined());
return trailingPosition.isUndefined() return trailingPosition.isUndefined()
? YGFloatOptional{0} ? YGFloatOptional{0}
: YGResolveValue(trailingPosition, axisSize); : YGResolveValue(trailingPosition, axisSize);
} }
bool YGNode::isLeadingPositionDefined(const YGFlexDirection axis) const { bool YGNode::isLeadingPositionDefined(const YGFlexDirection axis) const {
return (YGFlexDirectionIsRow(axis) && return (YGFlexDirectionIsRow(axis) &&
!YGComputedEdgeValue( !YGComputedEdgeValue(style_.position(), YGEdgeStart,
style_.position(), YGEdgeStart, CompactValue::ofUndefined()) CompactValue::ofUndefined())
.isUndefined()) || .isUndefined()) ||
!YGComputedEdgeValue( !YGComputedEdgeValue(style_.position(), leading[axis],
style_.position(), leading[axis], CompactValue::ofUndefined()) CompactValue::ofUndefined())
.isUndefined(); .isUndefined();
} }
bool YGNode::isTrailingPosDefined(const YGFlexDirection axis) const { bool YGNode::isTrailingPosDefined(const YGFlexDirection axis) const {
return (YGFlexDirectionIsRow(axis) && return (YGFlexDirectionIsRow(axis) &&
!YGComputedEdgeValue( !YGComputedEdgeValue(style_.position(), YGEdgeEnd,
style_.position(), YGEdgeEnd, CompactValue::ofUndefined()) CompactValue::ofUndefined())
.isUndefined()) || .isUndefined()) ||
!YGComputedEdgeValue( !YGComputedEdgeValue(style_.position(), trailing[axis],
style_.position(), trailing[axis], CompactValue::ofUndefined()) CompactValue::ofUndefined())
.isUndefined(); .isUndefined();
} }
YGFloatOptional YGNode::getLeadingMargin( YGFloatOptional YGNode::getLeadingMargin(const YGFlexDirection axis,
const YGFlexDirection axis, const float widthSize) const {
const float widthSize) const {
if (YGFlexDirectionIsRow(axis) && if (YGFlexDirectionIsRow(axis) &&
!style_.margin()[YGEdgeStart].isUndefined()) { !style_.margin()[YGEdgeStart].isUndefined()) {
return YGResolveValueMargin(style_.margin()[YGEdgeStart], widthSize); return YGResolveValueMargin(style_.margin()[YGEdgeStart], widthSize);
} }
return YGResolveValueMargin( return YGResolveValueMargin(
YGComputedEdgeValue( YGComputedEdgeValue(style_.margin(), leading[axis],
style_.margin(), leading[axis], CompactValue::ofZero()), CompactValue::ofZero()),
widthSize); widthSize);
} }
YGFloatOptional YGNode::getTrailingMargin( YGFloatOptional YGNode::getTrailingMargin(const YGFlexDirection axis,
const YGFlexDirection axis, const float widthSize) const {
const float widthSize) const {
if (YGFlexDirectionIsRow(axis) && !style_.margin()[YGEdgeEnd].isUndefined()) { if (YGFlexDirectionIsRow(axis) && !style_.margin()[YGEdgeEnd].isUndefined()) {
return YGResolveValueMargin(style_.margin()[YGEdgeEnd], widthSize); return YGResolveValueMargin(style_.margin()[YGEdgeEnd], widthSize);
} }
return YGResolveValueMargin( return YGResolveValueMargin(
YGComputedEdgeValue( YGComputedEdgeValue(style_.margin(), trailing[axis],
style_.margin(), trailing[axis], CompactValue::ofZero()), CompactValue::ofZero()),
widthSize); widthSize);
} }
YGFloatOptional YGNode::getMarginForAxis( YGFloatOptional YGNode::getMarginForAxis(const YGFlexDirection axis,
const YGFlexDirection axis, const float widthSize) const {
const float widthSize) const {
return getLeadingMargin(axis, widthSize) + getTrailingMargin(axis, widthSize); return getLeadingMargin(axis, widthSize) + getTrailingMargin(axis, widthSize);
} }
YGSize YGNode::measure( YGSize YGNode::measure(float width, YGMeasureMode widthMode, float height,
float width, YGMeasureMode heightMode, void* layoutContext) {
YGMeasureMode widthMode,
float height,
YGMeasureMode heightMode,
void* layoutContext) {
return flags_.at<measureUsesContext_>() return flags_.at<measureUsesContext_>()
? measure_.withContext( ? measure_.withContext(this, width, widthMode, height, heightMode,
this, width, widthMode, height, heightMode, layoutContext) layoutContext)
: measure_.noContext(this, width, widthMode, height, heightMode); : measure_.noContext(this, width, widthMode, height, heightMode);
} }
float YGNode::baseline(float width, float height, void* layoutContext) { float YGNode::baseline(float width, float height, void* layoutContext) {
return flags_.at<baselineUsesContext_>() return flags_.at<baselineUsesContext_>()
? baseline_.withContext(this, width, height, layoutContext) ? baseline_.withContext(this, width, height, layoutContext)
: baseline_.noContext(this, width, height); : baseline_.noContext(this, width, height);
} }
// Setters // Setters
@ -168,8 +160,7 @@ void YGNode::setMeasureFunc(decltype(YGNode::measure_) measureFunc) {
flags_.at<nodeType_>() = YGNodeTypeDefault; flags_.at<nodeType_>() = YGNodeTypeDefault;
} else { } else {
YGAssertWithNode( YGAssertWithNode(
this, this, children_.size() == 0,
children_.size() == 0,
"Cannot set measure function: Nodes with measure functions cannot have " "Cannot set measure function: Nodes with measure functions cannot have "
"children."); "children.");
// TODO: t18095186 Move nodeType to opt-in function and mark appropriate // TODO: t18095186 Move nodeType to opt-in function and mark appropriate
@ -278,9 +269,8 @@ void YGNode::setLayoutDimension(float dimension, int index) {
// If both left and right are defined, then use left. Otherwise return +left or // If both left and right are defined, then use left. Otherwise return +left or
// -right depending on which is defined. // -right depending on which is defined.
YGFloatOptional YGNode::relativePosition( YGFloatOptional YGNode::relativePosition(const YGFlexDirection axis,
const YGFlexDirection axis, const float axisSize) const {
const float axisSize) const {
if (isLeadingPositionDefined(axis)) { if (isLeadingPositionDefined(axis)) {
return getLeadingPosition(axis, axisSize); return getLeadingPosition(axis, axisSize);
} }
@ -292,11 +282,8 @@ YGFloatOptional YGNode::relativePosition(
return trailingPosition; return trailingPosition;
} }
void YGNode::setPosition( void YGNode::setPosition(const YGDirection direction, const float mainSize,
const YGDirection direction, const float crossSize, const float ownerWidth) {
const float mainSize,
const float crossSize,
const float ownerWidth) {
/* Root nodes should be always layouted as LTR, so we don't return negative /* Root nodes should be always layouted as LTR, so we don't return negative
* values. */ * values. */
const YGDirection directionRespectingRoot = const YGDirection directionRespectingRoot =
@ -435,9 +422,8 @@ float YGNode::resolveFlexShrink() const {
} }
bool YGNode::isNodeFlexible() { bool YGNode::isNodeFlexible() {
return ( return ((style_.positionType() == YGPositionTypeRelative) &&
(style_.positionType() == YGPositionTypeRelative) && (resolveFlexGrow() != 0 || resolveFlexShrink() != 0));
(resolveFlexGrow() != 0 || resolveFlexShrink() != 0));
} }
float YGNode::getLeadingBorder(const YGFlexDirection axis) const { float YGNode::getLeadingBorder(const YGFlexDirection axis) const {
@ -450,8 +436,8 @@ float YGNode::getLeadingBorder(const YGFlexDirection axis) const {
} }
} }
leadingBorder = YGComputedEdgeValue( leadingBorder = YGComputedEdgeValue(style_.border(), leading[axis],
style_.border(), leading[axis], CompactValue::ofZero()); CompactValue::ofZero());
return YGFloatMax(leadingBorder.value, 0.0f); return YGFloatMax(leadingBorder.value, 0.0f);
} }
@ -465,14 +451,13 @@ float YGNode::getTrailingBorder(const YGFlexDirection flexDirection) const {
} }
} }
trailingBorder = YGComputedEdgeValue( trailingBorder = YGComputedEdgeValue(style_.border(), trailing[flexDirection],
style_.border(), trailing[flexDirection], CompactValue::ofZero()); CompactValue::ofZero());
return YGFloatMax(trailingBorder.value, 0.0f); return YGFloatMax(trailingBorder.value, 0.0f);
} }
YGFloatOptional YGNode::getLeadingPadding( YGFloatOptional YGNode::getLeadingPadding(const YGFlexDirection axis,
const YGFlexDirection axis, const float widthSize) const {
const float widthSize) const {
const YGFloatOptional paddingEdgeStart = const YGFloatOptional paddingEdgeStart =
YGResolveValue(style_.padding()[YGEdgeStart], widthSize); YGResolveValue(style_.padding()[YGEdgeStart], widthSize);
if (YGFlexDirectionIsRow(axis) && if (YGFlexDirectionIsRow(axis) &&
@ -481,42 +466,39 @@ YGFloatOptional YGNode::getLeadingPadding(
return paddingEdgeStart; return paddingEdgeStart;
} }
YGFloatOptional resolvedValue = YGResolveValue( YGFloatOptional resolvedValue =
YGComputedEdgeValue( YGResolveValue(YGComputedEdgeValue(style_.padding(), leading[axis],
style_.padding(), leading[axis], CompactValue::ofZero()), CompactValue::ofZero()),
widthSize); widthSize);
return YGFloatOptionalMax(resolvedValue, YGFloatOptional(0.0f)); return YGFloatOptionalMax(resolvedValue, YGFloatOptional(0.0f));
} }
YGFloatOptional YGNode::getTrailingPadding( YGFloatOptional YGNode::getTrailingPadding(const YGFlexDirection axis,
const YGFlexDirection axis, const float widthSize) const {
const float widthSize) const {
const YGFloatOptional paddingEdgeEnd = const YGFloatOptional paddingEdgeEnd =
YGResolveValue(style_.padding()[YGEdgeEnd], widthSize); YGResolveValue(style_.padding()[YGEdgeEnd], widthSize);
if (YGFlexDirectionIsRow(axis) && paddingEdgeEnd >= YGFloatOptional{0.0f}) { if (YGFlexDirectionIsRow(axis) && paddingEdgeEnd >= YGFloatOptional{0.0f}) {
return paddingEdgeEnd; return paddingEdgeEnd;
} }
YGFloatOptional resolvedValue = YGResolveValue( YGFloatOptional resolvedValue =
YGComputedEdgeValue( YGResolveValue(YGComputedEdgeValue(style_.padding(), trailing[axis],
style_.padding(), trailing[axis], CompactValue::ofZero()), CompactValue::ofZero()),
widthSize); widthSize);
return YGFloatOptionalMax(resolvedValue, YGFloatOptional(0.0f)); return YGFloatOptionalMax(resolvedValue, YGFloatOptional(0.0f));
} }
YGFloatOptional YGNode::getLeadingPaddingAndBorder( YGFloatOptional YGNode::getLeadingPaddingAndBorder(
const YGFlexDirection axis, const YGFlexDirection axis, const float widthSize) const {
const float widthSize) const {
return getLeadingPadding(axis, widthSize) + return getLeadingPadding(axis, widthSize) +
YGFloatOptional(getLeadingBorder(axis)); YGFloatOptional(getLeadingBorder(axis));
} }
YGFloatOptional YGNode::getTrailingPaddingAndBorder( YGFloatOptional YGNode::getTrailingPaddingAndBorder(
const YGFlexDirection axis, const YGFlexDirection axis, const float widthSize) const {
const float widthSize) const {
return getTrailingPadding(axis, widthSize) + return getTrailingPadding(axis, widthSize) +
YGFloatOptional(getTrailingBorder(axis)); YGFloatOptional(getTrailingBorder(axis));
} }
bool YGNode::didUseLegacyFlag() { bool YGNode::didUseLegacyFlag() {
@ -567,12 +549,10 @@ bool YGNode::isLayoutTreeEqualToNode(const YGNode& node) const {
} }
void YGNode::reset() { void YGNode::reset() {
YGAssertWithNode( YGAssertWithNode(this, children_.size() == 0,
this, "Cannot reset a node which still has children attached");
children_.size() == 0, YGAssertWithNode(this, owner_ == nullptr,
"Cannot reset a node which still has children attached"); "Cannot reset a node still attached to a owner");
YGAssertWithNode(
this, owner_ == nullptr, "Cannot reset a node still attached to a owner");
clearChildren(); clearChildren();

81
src/cpp/include/deps/yoga/YGNode.h
View File

@ -5,25 +5,27 @@
* file in the root directory of this source tree. * file in the root directory of this source tree.
*/ */
#pragma once #pragma once
#include <cstdint>
#include <stdio.h> #include <stdio.h>
#include <cstdint>
#include "Bitfield.h" #include "Bitfield.h"
#include "CompactValue.h" #include "CompactValue.h"
#include "YGConfig.h" #include "YGConfig.h"
#include "YGLayout.h" #include "YGLayout.h"
#include "YGStyle.h"
#include "YGMacros.h" #include "YGMacros.h"
#include "YGStyle.h"
#include "Yoga-internal.h" #include "Yoga-internal.h"
YGConfigRef YGConfigGetDefault(); YGConfigRef YGConfigGetDefault();
struct YGNode { struct YGNode {
using MeasureWithContextFn = using MeasureWithContextFn = YGSize (*)(YGNode*, float, YGMeasureMode, float,
YGSize (*)(YGNode*, float, YGMeasureMode, float, YGMeasureMode, void*); YGMeasureMode, void*);
using BaselineWithContextFn = float (*)(YGNode*, float, float, void*); using BaselineWithContextFn = float (*)(YGNode*, float, float, void*);
using PrintWithContextFn = void (*)(YGNode*, void*); using PrintWithContextFn = void (*)(YGNode*, void*);
private: private:
static constexpr size_t hasNewLayout_ = 0; static constexpr size_t hasNewLayout_ = 0;
static constexpr size_t isReferenceBaseline_ = 1; static constexpr size_t isReferenceBaseline_ = 1;
static constexpr size_t isDirty_ = 2; static constexpr size_t isDirty_ = 2;
@ -34,10 +36,10 @@ private:
static constexpr size_t useWebDefaults_ = 7; static constexpr size_t useWebDefaults_ = 7;
void* context_ = nullptr; void* context_ = nullptr;
using Flags = facebook::yoga:: using Flags = facebook::yoga::Bitfield<uint8_t, bool, bool, bool, YGNodeType,
Bitfield<uint8_t, bool, bool, bool, YGNodeType, bool, bool, bool, bool>; bool, bool, bool, bool>;
Flags flags_ = Flags flags_ = {true, false, false, YGNodeTypeDefault,
{true, false, false, YGNodeTypeDefault, false, false, false, false}; false, false, false, false};
uint8_t reserved_ = 0; uint8_t reserved_ = 0;
union { union {
YGMeasureFunc noContext; YGMeasureFunc noContext;
@ -61,9 +63,8 @@ private:
std::array<YGValue, 2> resolvedDimensions_ = { std::array<YGValue, 2> resolvedDimensions_ = {
{YGValueUndefined, YGValueUndefined}}; {YGValueUndefined, YGValueUndefined}};
YGFloatOptional relativePosition( YGFloatOptional relativePosition(const YGFlexDirection axis,
const YGFlexDirection axis, const float axisSize) const;
const float axisSize) const;
void setMeasureFunc(decltype(measure_)); void setMeasureFunc(decltype(measure_));
void setBaselineFunc(decltype(baseline_)); void setBaselineFunc(decltype(baseline_));
@ -83,14 +84,14 @@ private:
using CompactValue = facebook::yoga::detail::CompactValue; using CompactValue = facebook::yoga::detail::CompactValue;
public: public:
YGNode() : YGNode{YGConfigGetDefault()} {} YGNode() : YGNode{YGConfigGetDefault()} {}
explicit YGNode(const YGConfigRef config) : config_{config} { explicit YGNode(const YGConfigRef config) : config_{config} {
if (config->useWebDefaults) { if (config->useWebDefaults) {
useWebDefaults(); useWebDefaults();
} }
}; };
~YGNode() = default; // cleanup of owner/children relationships in YGNodeFree ~YGNode() = default; // cleanup of owner/children relationships in YGNodeFree
YGNode(YGNode&&); YGNode(YGNode&&);
@ -185,37 +186,28 @@ public:
} }
// Methods related to positions, margin, padding and border // Methods related to positions, margin, padding and border
YGFloatOptional getLeadingPosition( YGFloatOptional getLeadingPosition(const YGFlexDirection axis,
const YGFlexDirection axis, const float axisSize) const;
const float axisSize) const;
bool isLeadingPositionDefined(const YGFlexDirection axis) const; bool isLeadingPositionDefined(const YGFlexDirection axis) const;
bool isTrailingPosDefined(const YGFlexDirection axis) const; bool isTrailingPosDefined(const YGFlexDirection axis) const;
YGFloatOptional getTrailingPosition( YGFloatOptional getTrailingPosition(const YGFlexDirection axis,
const YGFlexDirection axis, const float axisSize) const;
const float axisSize) const; YGFloatOptional getLeadingMargin(const YGFlexDirection axis,
YGFloatOptional getLeadingMargin( const float widthSize) const;
const YGFlexDirection axis, YGFloatOptional getTrailingMargin(const YGFlexDirection axis,
const float widthSize) const; const float widthSize) const;
YGFloatOptional getTrailingMargin(
const YGFlexDirection axis,
const float widthSize) const;
float getLeadingBorder(const YGFlexDirection flexDirection) const; float getLeadingBorder(const YGFlexDirection flexDirection) const;
float getTrailingBorder(const YGFlexDirection flexDirection) const; float getTrailingBorder(const YGFlexDirection flexDirection) const;
YGFloatOptional getLeadingPadding( YGFloatOptional getLeadingPadding(const YGFlexDirection axis,
const YGFlexDirection axis, const float widthSize) const;
const float widthSize) const; YGFloatOptional getTrailingPadding(const YGFlexDirection axis,
YGFloatOptional getTrailingPadding( const float widthSize) const;
const YGFlexDirection axis, YGFloatOptional getLeadingPaddingAndBorder(const YGFlexDirection axis,
const float widthSize) const; const float widthSize) const;
YGFloatOptional getLeadingPaddingAndBorder( YGFloatOptional getTrailingPaddingAndBorder(const YGFlexDirection axis,
const YGFlexDirection axis, const float widthSize) const;
const float widthSize) const; YGFloatOptional getMarginForAxis(const YGFlexDirection axis,
YGFloatOptional getTrailingPaddingAndBorder( const float widthSize) const;
const YGFlexDirection axis,
const float widthSize) const;
YGFloatOptional getMarginForAxis(
const YGFlexDirection axis,
const float widthSize) const;
// Setters // Setters
void setContext(void* context) { context_ = context; } void setContext(void* context) { context_ = context; }
@ -287,11 +279,8 @@ public:
void setLayoutBorder(float border, int index); void setLayoutBorder(float border, int index);
void setLayoutPadding(float padding, int index); void setLayoutPadding(float padding, int index);
void setLayoutPosition(float position, int index); void setLayoutPosition(float position, int index);
void setPosition( void setPosition(const YGDirection direction, const float mainSize,
const YGDirection direction, const float crossSize, const float ownerWidth);
const float mainSize,
const float crossSize,
const float ownerWidth);
void setLayoutDoesLegacyFlagAffectsLayout(bool doesLegacyFlagAffectsLayout); void setLayoutDoesLegacyFlagAffectsLayout(bool doesLegacyFlagAffectsLayout);
void setLayoutDidUseLegacyFlag(bool didUseLegacyFlag); void setLayoutDidUseLegacyFlag(bool didUseLegacyFlag);
void markDirtyAndPropogateDownwards(); void markDirtyAndPropogateDownwards();

134
src/cpp/include/deps/yoga/YGNodePrint.cpp
View File

@ -6,11 +6,13 @@
*/ */
#ifdef DEBUG #ifdef DEBUG
#include "YGNodePrint.h" #include "YGNodePrint.h"
#include <stdarg.h> #include <stdarg.h>
#include "Utils.h"
#include "YGEnums.h" #include "YGEnums.h"
#include "YGNode.h" #include "YGNode.h"
#include "Yoga-internal.h" #include "Yoga-internal.h"
#include "Utils.h"
namespace facebook { namespace facebook {
namespace yoga { namespace yoga {
@ -24,7 +26,7 @@ static void indent(string& base, uint32_t level) {
static bool areFourValuesEqual(const YGStyle::Edges& four) { static bool areFourValuesEqual(const YGStyle::Edges& four) {
return YGValueEqual(four[0], four[1]) && YGValueEqual(four[0], four[2]) && return YGValueEqual(four[0], four[1]) && YGValueEqual(four[0], four[2]) &&
YGValueEqual(four[0], four[3]); YGValueEqual(four[0], four[3]);
} }
static void appendFormatedString(string& str, const char* fmt, ...) { static void appendFormatedString(string& str, const char* fmt, ...) {
@ -40,43 +42,35 @@ static void appendFormatedString(string& str, const char* fmt, ...) {
str.append(result); str.append(result);
} }
static void appendFloatOptionalIfDefined( static void appendFloatOptionalIfDefined(string& base, const string key,
string& base, const YGFloatOptional num) {
const string key,
const YGFloatOptional num) {
if (!num.isUndefined()) { if (!num.isUndefined()) {
appendFormatedString(base, "%s: %g; ", key.c_str(), num.unwrap()); appendFormatedString(base, "%s: %g; ", key.c_str(), num.unwrap());
} }
} }
static void appendNumberIfNotUndefined( static void appendNumberIfNotUndefined(string& base, const string key,
string& base, const YGValue number) {
const string key,
const YGValue number) {
if (number.unit != YGUnitUndefined) { if (number.unit != YGUnitUndefined) {
if (number.unit == YGUnitAuto) { if (number.unit == YGUnitAuto) {
base.append(key + ": auto; "); base.append(key + ": auto; ");
} else { } else {
string unit = number.unit == YGUnitPoint ? "px" : "%%"; string unit = number.unit == YGUnitPoint ? "px" : "%%";
appendFormatedString( appendFormatedString(base, "%s: %g%s; ", key.c_str(), number.value,
base, "%s: %g%s; ", key.c_str(), number.value, unit.c_str()); unit.c_str());
} }
} }
} }
static void appendNumberIfNotAuto( static void appendNumberIfNotAuto(string& base, const string& key,
string& base, const YGValue number) {
const string& key,
const YGValue number) {
if (number.unit != YGUnitAuto) { if (number.unit != YGUnitAuto) {
appendNumberIfNotUndefined(base, key, number); appendNumberIfNotUndefined(base, key, number);
} }
} }
static void appendNumberIfNotZero( static void appendNumberIfNotZero(string& base, const string& str,
string& base, const YGValue number) {
const string& str,
const YGValue number) {
if (number.unit == YGUnitAuto) { if (number.unit == YGUnitAuto) {
base.append(str + ": auto; "); base.append(str + ": auto; ");
} else if (!YGFloatsEqual(number.value, 0)) { } else if (!YGFloatsEqual(number.value, 0)) {
@ -84,10 +78,8 @@ static void appendNumberIfNotZero(
} }
} }
static void appendEdges( static void appendEdges(string& base, const string& key,
string& base, const YGStyle::Edges& edges) {
const string& key,
const YGStyle::Edges& edges) {
if (areFourValuesEqual(edges)) { if (areFourValuesEqual(edges)) {
appendNumberIfNotZero(base, key, edges[YGEdgeLeft]); appendNumberIfNotZero(base, key, edges[YGEdgeLeft]);
} else { } else {
@ -98,35 +90,29 @@ static void appendEdges(
} }
} }
static void appendEdgeIfNotUndefined( static void appendEdgeIfNotUndefined(string& base, const string& str,
string& base, const YGStyle::Edges& edges,
const string& str, const YGEdge edge) {
const YGStyle::Edges& edges,
const YGEdge edge) {
appendNumberIfNotUndefined( appendNumberIfNotUndefined(
base, base, str,
str,
YGComputedEdgeValue(edges, edge, detail::CompactValue::ofUndefined())); YGComputedEdgeValue(edges, edge, detail::CompactValue::ofUndefined()));
} }
void YGNodeToString( void YGNodeToString(std::string& str, YGNodeRef node, YGPrintOptions options,
std::string& str, uint32_t level) {
YGNodeRef node,
YGPrintOptions options,
uint32_t level) {
indent(str, level); indent(str, level);
appendFormatedString(str, "<div "); appendFormatedString(str, "<div ");
if (options & YGPrintOptionsLayout) { if (options & YGPrintOptionsLayout) {
appendFormatedString(str, "layout=\""); appendFormatedString(str, "layout=\"");
appendFormatedString( appendFormatedString(str, "width: %g; ",
str, "width: %g; ", node->getLayout().dimensions[YGDimensionWidth]); node->getLayout().dimensions[YGDimensionWidth]);
appendFormatedString( appendFormatedString(str, "height: %g; ",
str, "height: %g; ", node->getLayout().dimensions[YGDimensionHeight]); node->getLayout().dimensions[YGDimensionHeight]);
appendFormatedString( appendFormatedString(str, "top: %g; ",
str, "top: %g; ", node->getLayout().position[YGEdgeTop]); node->getLayout().position[YGEdgeTop]);
appendFormatedString( appendFormatedString(str, "left: %g;",
str, "left: %g;", node->getLayout().position[YGEdgeLeft]); node->getLayout().position[YGEdgeLeft]);
appendFormatedString(str, "\" "); appendFormatedString(str, "\" ");
} }
@ -134,28 +120,24 @@ void YGNodeToString(
appendFormatedString(str, "style=\""); appendFormatedString(str, "style=\"");
const auto& style = node->getStyle(); const auto& style = node->getStyle();
if (style.flexDirection() != YGNode().getStyle().flexDirection()) { if (style.flexDirection() != YGNode().getStyle().flexDirection()) {
appendFormatedString( appendFormatedString(str, "flex-direction: %s; ",
str, YGFlexDirectionToString(style.flexDirection()));
"flex-direction: %s; ",
YGFlexDirectionToString(style.flexDirection()));
} }
if (style.justifyContent() != YGNode().getStyle().justifyContent()) { if (style.justifyContent() != YGNode().getStyle().justifyContent()) {
appendFormatedString( appendFormatedString(str, "justify-content: %s; ",
str, YGJustifyToString(style.justifyContent()));
"justify-content: %s; ",
YGJustifyToString(style.justifyContent()));
} }
if (style.alignItems() != YGNode().getStyle().alignItems()) { if (style.alignItems() != YGNode().getStyle().alignItems()) {
appendFormatedString( appendFormatedString(str, "align-items: %s; ",
str, "align-items: %s; ", YGAlignToString(style.alignItems())); YGAlignToString(style.alignItems()));
} }
if (style.alignContent() != YGNode().getStyle().alignContent()) { if (style.alignContent() != YGNode().getStyle().alignContent()) {
appendFormatedString( appendFormatedString(str, "align-content: %s; ",
str, "align-content: %s; ", YGAlignToString(style.alignContent())); YGAlignToString(style.alignContent()));
} }
if (style.alignSelf() != YGNode().getStyle().alignSelf()) { if (style.alignSelf() != YGNode().getStyle().alignSelf()) {
appendFormatedString( appendFormatedString(str, "align-self: %s; ",
str, "align-self: %s; ", YGAlignToString(style.alignSelf())); YGAlignToString(style.alignSelf()));
} }
appendFloatOptionalIfDefined(str, "flex-grow", style.flexGrow()); appendFloatOptionalIfDefined(str, "flex-grow", style.flexGrow());
appendFloatOptionalIfDefined(str, "flex-shrink", style.flexShrink()); appendFloatOptionalIfDefined(str, "flex-shrink", style.flexShrink());
@ -163,18 +145,18 @@ void YGNodeToString(
appendFloatOptionalIfDefined(str, "flex", style.flex()); appendFloatOptionalIfDefined(str, "flex", style.flex());
if (style.flexWrap() != YGNode().getStyle().flexWrap()) { if (style.flexWrap() != YGNode().getStyle().flexWrap()) {
appendFormatedString( appendFormatedString(str, "flex-wrap: %s; ",
str, "flex-wrap: %s; ", YGWrapToString(style.flexWrap())); YGWrapToString(style.flexWrap()));
} }
if (style.overflow() != YGNode().getStyle().overflow()) { if (style.overflow() != YGNode().getStyle().overflow()) {
appendFormatedString( appendFormatedString(str, "overflow: %s; ",
str, "overflow: %s; ", YGOverflowToString(style.overflow())); YGOverflowToString(style.overflow()));
} }
if (style.display() != YGNode().getStyle().display()) { if (style.display() != YGNode().getStyle().display()) {
appendFormatedString( appendFormatedString(str, "display: %s; ",
str, "display: %s; ", YGDisplayToString(style.display())); YGDisplayToString(style.display()));
} }
appendEdges(str, "margin", style.margin()); appendEdges(str, "margin", style.margin());
appendEdges(str, "padding", style.padding()); appendEdges(str, "padding", style.padding());
@ -182,18 +164,18 @@ void YGNodeToString(
appendNumberIfNotAuto(str, "width", style.dimensions()[YGDimensionWidth]); appendNumberIfNotAuto(str, "width", style.dimensions()[YGDimensionWidth]);
appendNumberIfNotAuto(str, "height", style.dimensions()[YGDimensionHeight]); appendNumberIfNotAuto(str, "height", style.dimensions()[YGDimensionHeight]);
appendNumberIfNotAuto( appendNumberIfNotAuto(str, "max-width",
str, "max-width", style.maxDimensions()[YGDimensionWidth]); style.maxDimensions()[YGDimensionWidth]);
appendNumberIfNotAuto( appendNumberIfNotAuto(str, "max-height",
str, "max-height", style.maxDimensions()[YGDimensionHeight]); style.maxDimensions()[YGDimensionHeight]);
appendNumberIfNotAuto( appendNumberIfNotAuto(str, "min-width",
str, "min-width", style.minDimensions()[YGDimensionWidth]); style.minDimensions()[YGDimensionWidth]);
appendNumberIfNotAuto( appendNumberIfNotAuto(str, "min-height",
str, "min-height", style.minDimensions()[YGDimensionHeight]); style.minDimensions()[YGDimensionHeight]);
if (style.positionType() != YGNode().getStyle().positionType()) { if (style.positionType() != YGNode().getStyle().positionType()) {
appendFormatedString( appendFormatedString(str, "position: %s; ",
str, "position: %s; ", YGPositionTypeToString(style.positionType())); YGPositionTypeToString(style.positionType()));
} }
appendEdgeIfNotUndefined(str, "left", style.position(), YGEdgeLeft); appendEdgeIfNotUndefined(str, "left", style.position(), YGEdgeLeft);
@ -219,6 +201,6 @@ void YGNodeToString(
} }
appendFormatedString(str, "</div>"); appendFormatedString(str, "</div>");
} }
} // namespace yoga } // namespace yoga
} // namespace facebook } // namespace facebook
#endif #endif

11
src/cpp/include/deps/yoga/YGNodePrint.h
View File

@ -13,12 +13,9 @@
namespace facebook { namespace facebook {
namespace yoga { namespace yoga {
void YGNodeToString( void YGNodeToString(std::string& str, YGNodeRef node, YGPrintOptions options,
std::string& str, uint32_t level);
YGNodeRef node,
YGPrintOptions options,
uint32_t level);
} // namespace yoga } // namespace yoga
} // namespace facebook } // namespace facebook
#endif #endif

12
src/cpp/include/deps/yoga/YGStyle.cpp
View File

@ -5,11 +5,13 @@
* file in the root directory of this source tree. * file in the root directory of this source tree.
*/ */
#include "YGStyle.h" #include "YGStyle.h"
#include "Utils.h" #include "Utils.h"
// Yoga specific properties, not compatible with flexbox specification // Yoga specific properties, not compatible with flexbox specification
bool operator==(const YGStyle& lhs, const YGStyle& rhs) { bool operator==(const YGStyle& lhs, const YGStyle& rhs) {
bool areNonFloatValuesEqual = lhs.direction() == rhs.direction() && bool areNonFloatValuesEqual =
lhs.direction() == rhs.direction() &&
lhs.flexDirection() == rhs.flexDirection() && lhs.flexDirection() == rhs.flexDirection() &&
lhs.justifyContent() == rhs.justifyContent() && lhs.justifyContent() == rhs.justifyContent() &&
lhs.alignContent() == rhs.alignContent() && lhs.alignContent() == rhs.alignContent() &&
@ -26,20 +28,22 @@ bool operator==(const YGStyle& lhs, const YGStyle& rhs) {
lhs.maxDimensions() == rhs.maxDimensions(); lhs.maxDimensions() == rhs.maxDimensions();
areNonFloatValuesEqual = areNonFloatValuesEqual && areNonFloatValuesEqual = areNonFloatValuesEqual &&
lhs.flex().isUndefined() == rhs.flex().isUndefined(); lhs.flex().isUndefined() == rhs.flex().isUndefined();
if (areNonFloatValuesEqual && !lhs.flex().isUndefined() && if (areNonFloatValuesEqual && !lhs.flex().isUndefined() &&
!rhs.flex().isUndefined()) { !rhs.flex().isUndefined()) {
areNonFloatValuesEqual = areNonFloatValuesEqual && lhs.flex() == rhs.flex(); areNonFloatValuesEqual = areNonFloatValuesEqual && lhs.flex() == rhs.flex();
} }
areNonFloatValuesEqual = areNonFloatValuesEqual && areNonFloatValuesEqual =
areNonFloatValuesEqual &&
lhs.flexGrow().isUndefined() == rhs.flexGrow().isUndefined(); lhs.flexGrow().isUndefined() == rhs.flexGrow().isUndefined();
if (areNonFloatValuesEqual && !lhs.flexGrow().isUndefined()) { if (areNonFloatValuesEqual && !lhs.flexGrow().isUndefined()) {
areNonFloatValuesEqual = areNonFloatValuesEqual =
areNonFloatValuesEqual && lhs.flexGrow() == rhs.flexGrow(); areNonFloatValuesEqual && lhs.flexGrow() == rhs.flexGrow();
} }
areNonFloatValuesEqual = areNonFloatValuesEqual && areNonFloatValuesEqual =
areNonFloatValuesEqual &&
lhs.flexShrink().isUndefined() == rhs.flexShrink().isUndefined(); lhs.flexShrink().isUndefined() == rhs.flexShrink().isUndefined();
if (areNonFloatValuesEqual && !rhs.flexShrink().isUndefined()) { if (areNonFloatValuesEqual && !rhs.flexShrink().isUndefined()) {
areNonFloatValuesEqual = areNonFloatValuesEqual =

38
src/cpp/include/deps/yoga/YGStyle.h
View File

@ -9,6 +9,7 @@
#include <array> #include <array>
#include <cstdint> #include <cstdint>
#include <type_traits> #include <type_traits>
#include "Bitfield.h" #include "Bitfield.h"
#include "CompactValue.h" #include "CompactValue.h"
#include "YGEnums.h" #include "YGEnums.h"
@ -22,7 +23,7 @@ class YGStyle {
facebook::yoga::detail::Values<facebook::yoga::enums::count<Enum>()>; facebook::yoga::detail::Values<facebook::yoga::enums::count<Enum>()>;
using CompactValue = facebook::yoga::detail::CompactValue; using CompactValue = facebook::yoga::detail::CompactValue;
public: public:
using Dimensions = Values<YGDimension>; using Dimensions = Values<YGDimension>;
using Edges = Values<YGEdge>; using Edges = Values<YGEdge>;
@ -62,7 +63,7 @@ public:
YGStyle() = default; YGStyle() = default;
~YGStyle() = default; ~YGStyle() = default;
private: private:
static constexpr size_t directionIdx = 0; static constexpr size_t directionIdx = 0;
static constexpr size_t flexDirectionIdx = 1; static constexpr size_t flexDirectionIdx = 1;
static constexpr size_t justifyContentIdx = 2; static constexpr size_t justifyContentIdx = 2;
@ -73,29 +74,16 @@ private:
static constexpr size_t flexWrapIdx = 7; static constexpr size_t flexWrapIdx = 7;
static constexpr size_t overflowIdx = 8; static constexpr size_t overflowIdx = 8;
static constexpr size_t displayIdx = 9; static constexpr size_t displayIdx = 9;
using Flags = facebook::yoga::Bitfield< using Flags =
uint32_t, facebook::yoga::Bitfield<uint32_t, YGDirection, YGFlexDirection,
YGDirection, YGJustify, YGAlign, YGAlign, YGAlign,
YGFlexDirection, YGPositionType, YGWrap, YGOverflow, YGDisplay>;
YGJustify,
YGAlign,
YGAlign,
YGAlign,
YGPositionType,
YGWrap,
YGOverflow,
YGDisplay>;
Flags flags_ = {YGDirectionInherit, Flags flags_ = {YGDirectionInherit, YGFlexDirectionColumn,
YGFlexDirectionColumn, YGJustifyFlexStart, YGAlignFlexStart,
YGJustifyFlexStart, YGAlignStretch, YGAlignAuto,
YGAlignFlexStart, YGPositionTypeRelative, YGWrapNoWrap,
YGAlignStretch, YGOverflowVisible, YGDisplayFlex};
YGAlignAuto,
YGPositionTypeRelative,
YGWrapNoWrap,
YGOverflowVisible,
YGDisplayFlex};
YGFloatOptional flex_ = {}; YGFloatOptional flex_ = {};
YGFloatOptional flexGrow_ = {}; YGFloatOptional flexGrow_ = {};
YGFloatOptional flexShrink_ = {}; YGFloatOptional flexShrink_ = {};
@ -110,7 +98,7 @@ private:
// Yoga specific properties, not compatible with flexbox specification // Yoga specific properties, not compatible with flexbox specification
YGFloatOptional aspectRatio_ = {}; YGFloatOptional aspectRatio_ = {};
public: public:
// for library users needing a type // for library users needing a type
using ValueRepr = std::remove_reference<decltype(margin_[0])>::type; using ValueRepr = std::remove_reference<decltype(margin_[0])>::type;

9
src/cpp/include/deps/yoga/YGValue.h
View File

@ -7,6 +7,7 @@
#pragma once #pragma once
#include <math.h> #include <math.h>
#include "YGEnums.h" #include "YGEnums.h"
#include "YGMacros.h" #include "YGMacros.h"
@ -15,7 +16,7 @@ YG_EXTERN_C_BEGIN
// Not defined in MSVC++ // Not defined in MSVC++
#ifndef NAN #ifndef NAN
static const uint32_t __nan = 0x7fc00000; static const uint32_t __nan = 0x7fc00000;
#define NAN (*(const float*) __nan) #define NAN (*(const float*)__nan)
#endif #endif
#define YGUndefined NAN #define YGUndefined NAN
@ -76,8 +77,8 @@ inline YGValue operator"" _percent(unsigned long long value) {
return operator"" _percent(static_cast<long double>(value)); return operator"" _percent(static_cast<long double>(value));
} }
} // namespace literals } // namespace literals
} // namespace yoga } // namespace yoga
} // namespace facebook } // namespace facebook
#endif #endif

38
src/cpp/include/deps/yoga/Yoga-internal.h
View File

@ -9,6 +9,7 @@
#include <array> #include <array>
#include <cmath> #include <cmath>
#include <vector> #include <vector>
#include "CompactValue.h" #include "CompactValue.h"
#include "Yoga.h" #include "Yoga.h"
@ -16,24 +17,20 @@ using YGVector = std::vector<YGNodeRef>;
YG_EXTERN_C_BEGIN YG_EXTERN_C_BEGIN
void YGNodeCalculateLayoutWithContext( void YGNodeCalculateLayoutWithContext(YGNodeRef node, float availableWidth,
YGNodeRef node, float availableHeight,
float availableWidth, YGDirection ownerDirection,
float availableHeight, void* layoutContext);
YGDirection ownerDirection,
void* layoutContext);
YG_EXTERN_C_END YG_EXTERN_C_END
namespace facebook { namespace facebook {
namespace yoga { namespace yoga {
inline bool isUndefined(float value) { inline bool isUndefined(float value) { return std::isnan(value); }
return std::isnan(value);
}
} // namespace yoga } // namespace yoga
} // namespace facebook } // namespace facebook
using namespace facebook; using namespace facebook;
@ -55,14 +52,14 @@ struct YGCachedMeasurement {
YGCachedMeasurement() YGCachedMeasurement()
: availableWidth(0), : availableWidth(0),
availableHeight(0), availableHeight(0),
widthMeasureMode((YGMeasureMode) -1), widthMeasureMode((YGMeasureMode)-1),
heightMeasureMode((YGMeasureMode) -1), heightMeasureMode((YGMeasureMode)-1),
computedWidth(-1), computedWidth(-1),
computedHeight(-1) {} computedHeight(-1) {}
bool operator==(YGCachedMeasurement measurement) const { bool operator==(YGCachedMeasurement measurement) const {
bool isEqual = widthMeasureMode == measurement.widthMeasureMode && bool isEqual = widthMeasureMode == measurement.widthMeasureMode &&
heightMeasureMode == measurement.heightMeasureMode; heightMeasureMode == measurement.heightMeasureMode;
if (!yoga::isUndefined(availableWidth) || if (!yoga::isUndefined(availableWidth) ||
!yoga::isUndefined(measurement.availableWidth)) { !yoga::isUndefined(measurement.availableWidth)) {
@ -95,10 +92,10 @@ namespace detail {
template <size_t Size> template <size_t Size>
class Values { class Values {
private: private:
std::array<CompactValue, Size> values_; std::array<CompactValue, Size> values_;
public: public:
Values() = default; Values() = default;
explicit Values(const YGValue& defaultValue) noexcept { explicit Values(const YGValue& defaultValue) noexcept {
values_.fill(defaultValue); values_.fill(defaultValue);
@ -134,9 +131,9 @@ public:
Values& operator=(const Values& other) = default; Values& operator=(const Values& other) = default;
}; };
} // namespace detail } // namespace detail
} // namespace yoga } // namespace yoga
} // namespace facebook } // namespace facebook
static const float kDefaultFlexGrow = 0.0f; static const float kDefaultFlexGrow = 0.0f;
static const float kDefaultFlexShrink = 0.0f; static const float kDefaultFlexShrink = 0.0f;
@ -146,5 +143,4 @@ extern bool YGFloatsEqual(const float a, const float b);
extern facebook::yoga::detail::CompactValue YGComputedEdgeValue( extern facebook::yoga::detail::CompactValue YGComputedEdgeValue(
const facebook::yoga::detail::Values< const facebook::yoga::detail::Values<
facebook::yoga::enums::count<YGEdge>()>& edges, facebook::yoga::enums::count<YGEdge>()>& edges,
YGEdge edge, YGEdge edge, facebook::yoga::detail::CompactValue defaultValue);
facebook::yoga::detail::CompactValue defaultValue);

2278
src/cpp/include/deps/yoga/Yoga.cpp
View File

File diff suppressed because it is too large Load Diff

164
src/cpp/include/deps/yoga/Yoga.h
View File

@ -33,40 +33,30 @@ typedef struct YGConfig* YGConfigRef;
typedef struct YGNode* YGNodeRef; typedef struct YGNode* YGNodeRef;
typedef const struct YGNode* YGNodeConstRef; typedef const struct YGNode* YGNodeConstRef;
typedef YGSize (*YGMeasureFunc)( typedef YGSize (*YGMeasureFunc)(YGNodeRef node, float width,
YGNodeRef node, YGMeasureMode widthMode, float height,
float width, YGMeasureMode heightMode);
YGMeasureMode widthMode,
float height,
YGMeasureMode heightMode);
typedef float (*YGBaselineFunc)(YGNodeRef node, float width, float height); typedef float (*YGBaselineFunc)(YGNodeRef node, float width, float height);
typedef void (*YGDirtiedFunc)(YGNodeRef node); typedef void (*YGDirtiedFunc)(YGNodeRef node);
typedef void (*YGPrintFunc)(YGNodeRef node); typedef void (*YGPrintFunc)(YGNodeRef node);
typedef void (*YGNodeCleanupFunc)(YGNodeRef node); typedef void (*YGNodeCleanupFunc)(YGNodeRef node);
typedef int (*YGLogger)( typedef int (*YGLogger)(YGConfigRef config, YGNodeRef node, YGLogLevel level,
YGConfigRef config, const char* format, va_list args);
YGNodeRef node, typedef YGNodeRef (*YGCloneNodeFunc)(YGNodeRef oldNode, YGNodeRef owner,
YGLogLevel level, int childIndex);
const char* format,
va_list args);
typedef YGNodeRef (
*YGCloneNodeFunc)(YGNodeRef oldNode, YGNodeRef owner, int childIndex);
// YGNode // YGNode
WIN_EXPORT YGNodeRef YGNodeNew(void); WIN_EXPORT YGNodeRef YGNodeNew(void);
WIN_EXPORT YGNodeRef YGNodeNewWithConfig(YGConfigRef config); WIN_EXPORT YGNodeRef YGNodeNewWithConfig(YGConfigRef config);
WIN_EXPORT YGNodeRef YGNodeClone(YGNodeRef node); WIN_EXPORT YGNodeRef YGNodeClone(YGNodeRef node);
WIN_EXPORT void YGNodeFree(YGNodeRef node); WIN_EXPORT void YGNodeFree(YGNodeRef node);
WIN_EXPORT void YGNodeFreeRecursiveWithCleanupFunc( WIN_EXPORT void YGNodeFreeRecursiveWithCleanupFunc(YGNodeRef node,
YGNodeRef node, YGNodeCleanupFunc cleanup);
YGNodeCleanupFunc cleanup);
WIN_EXPORT void YGNodeFreeRecursive(YGNodeRef node); WIN_EXPORT void YGNodeFreeRecursive(YGNodeRef node);
WIN_EXPORT void YGNodeReset(YGNodeRef node); WIN_EXPORT void YGNodeReset(YGNodeRef node);
WIN_EXPORT void YGNodeInsertChild( WIN_EXPORT void YGNodeInsertChild(YGNodeRef node, YGNodeRef child,
YGNodeRef node, uint32_t index);
YGNodeRef child,
uint32_t index);
WIN_EXPORT void YGNodeRemoveChild(YGNodeRef node, YGNodeRef child); WIN_EXPORT void YGNodeRemoveChild(YGNodeRef node, YGNodeRef child);
WIN_EXPORT void YGNodeRemoveAllChildren(YGNodeRef node); WIN_EXPORT void YGNodeRemoveAllChildren(YGNodeRef node);
@ -74,22 +64,17 @@ WIN_EXPORT YGNodeRef YGNodeGetChild(YGNodeRef node, uint32_t index);
WIN_EXPORT YGNodeRef YGNodeGetOwner(YGNodeRef node); WIN_EXPORT YGNodeRef YGNodeGetOwner(YGNodeRef node);
WIN_EXPORT YGNodeRef YGNodeGetParent(YGNodeRef node); WIN_EXPORT YGNodeRef YGNodeGetParent(YGNodeRef node);
WIN_EXPORT uint32_t YGNodeGetChildCount(YGNodeRef node); WIN_EXPORT uint32_t YGNodeGetChildCount(YGNodeRef node);
WIN_EXPORT void YGNodeSetChildren( WIN_EXPORT void YGNodeSetChildren(YGNodeRef owner, const YGNodeRef children[],
YGNodeRef owner, uint32_t count);
const YGNodeRef children[],
uint32_t count);
WIN_EXPORT void YGNodeSetIsReferenceBaseline( WIN_EXPORT void YGNodeSetIsReferenceBaseline(YGNodeRef node,
YGNodeRef node, bool isReferenceBaseline);
bool isReferenceBaseline);
WIN_EXPORT bool YGNodeIsReferenceBaseline(YGNodeRef node); WIN_EXPORT bool YGNodeIsReferenceBaseline(YGNodeRef node);
WIN_EXPORT void YGNodeCalculateLayout( WIN_EXPORT void YGNodeCalculateLayout(YGNodeRef node, float availableWidth,
YGNodeRef node, float availableHeight,
float availableWidth, YGDirection ownerDirection);
float availableHeight,
YGDirection ownerDirection);
// Mark a node as dirty. Only valid for nodes with a custom measure function // Mark a node as dirty. Only valid for nodes with a custom measure function
// set. // set.
@ -110,18 +95,10 @@ WIN_EXPORT void YGNodePrint(YGNodeRef node, YGPrintOptions options);
WIN_EXPORT bool YGFloatIsUndefined(float value); WIN_EXPORT bool YGFloatIsUndefined(float value);
WIN_EXPORT bool YGNodeCanUseCachedMeasurement( WIN_EXPORT bool YGNodeCanUseCachedMeasurement(
YGMeasureMode widthMode, YGMeasureMode widthMode, float width, YGMeasureMode heightMode,
float width, float height, YGMeasureMode lastWidthMode, float lastWidth,
YGMeasureMode heightMode, YGMeasureMode lastHeightMode, float lastHeight, float lastComputedWidth,
float height, float lastComputedHeight, float marginRow, float marginColumn,
YGMeasureMode lastWidthMode,
float lastWidth,
YGMeasureMode lastHeightMode,
float lastHeight,
float lastComputedWidth,
float lastComputedHeight,
float marginRow,
float marginColumn,
YGConfigRef config); YGConfigRef config);
WIN_EXPORT void YGNodeCopyStyle(YGNodeRef dstNode, YGNodeRef srcNode); WIN_EXPORT void YGNodeCopyStyle(YGNodeRef dstNode, YGNodeRef srcNode);
@ -146,19 +123,16 @@ bool YGNodeLayoutGetDidUseLegacyFlag(YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetDirection(YGNodeRef node, YGDirection direction); WIN_EXPORT void YGNodeStyleSetDirection(YGNodeRef node, YGDirection direction);
WIN_EXPORT YGDirection YGNodeStyleGetDirection(YGNodeConstRef node); WIN_EXPORT YGDirection YGNodeStyleGetDirection(YGNodeConstRef node);
WIN_EXPORT void YGNodeStyleSetFlexDirection( WIN_EXPORT void YGNodeStyleSetFlexDirection(YGNodeRef node,
YGNodeRef node, YGFlexDirection flexDirection);
YGFlexDirection flexDirection);
WIN_EXPORT YGFlexDirection YGNodeStyleGetFlexDirection(YGNodeConstRef node); WIN_EXPORT YGFlexDirection YGNodeStyleGetFlexDirection(YGNodeConstRef node);
WIN_EXPORT void YGNodeStyleSetJustifyContent( WIN_EXPORT void YGNodeStyleSetJustifyContent(YGNodeRef node,
YGNodeRef node, YGJustify justifyContent);
YGJustify justifyContent);
WIN_EXPORT YGJustify YGNodeStyleGetJustifyContent(YGNodeConstRef node); WIN_EXPORT YGJustify YGNodeStyleGetJustifyContent(YGNodeConstRef node);
WIN_EXPORT void YGNodeStyleSetAlignContent( WIN_EXPORT void YGNodeStyleSetAlignContent(YGNodeRef node,
YGNodeRef node, YGAlign alignContent);
YGAlign alignContent);
WIN_EXPORT YGAlign YGNodeStyleGetAlignContent(YGNodeConstRef node); WIN_EXPORT YGAlign YGNodeStyleGetAlignContent(YGNodeConstRef node);
WIN_EXPORT void YGNodeStyleSetAlignItems(YGNodeRef node, YGAlign alignItems); WIN_EXPORT void YGNodeStyleSetAlignItems(YGNodeRef node, YGAlign alignItems);
@ -167,9 +141,8 @@ WIN_EXPORT YGAlign YGNodeStyleGetAlignItems(YGNodeConstRef node);
WIN_EXPORT void YGNodeStyleSetAlignSelf(YGNodeRef node, YGAlign alignSelf); WIN_EXPORT void YGNodeStyleSetAlignSelf(YGNodeRef node, YGAlign alignSelf);
WIN_EXPORT YGAlign YGNodeStyleGetAlignSelf(YGNodeConstRef node); WIN_EXPORT YGAlign YGNodeStyleGetAlignSelf(YGNodeConstRef node);
WIN_EXPORT void YGNodeStyleSetPositionType( WIN_EXPORT void YGNodeStyleSetPositionType(YGNodeRef node,
YGNodeRef node, YGPositionType positionType);
YGPositionType positionType);
WIN_EXPORT YGPositionType YGNodeStyleGetPositionType(YGNodeConstRef node); WIN_EXPORT YGPositionType YGNodeStyleGetPositionType(YGNodeConstRef node);
WIN_EXPORT void YGNodeStyleSetFlexWrap(YGNodeRef node, YGWrap flexWrap); WIN_EXPORT void YGNodeStyleSetFlexWrap(YGNodeRef node, YGWrap flexWrap);
@ -195,32 +168,22 @@ WIN_EXPORT void YGNodeStyleSetFlexBasisPercent(YGNodeRef node, float flexBasis);
WIN_EXPORT void YGNodeStyleSetFlexBasisAuto(YGNodeRef node); WIN_EXPORT void YGNodeStyleSetFlexBasisAuto(YGNodeRef node);
WIN_EXPORT YGValue YGNodeStyleGetFlexBasis(YGNodeConstRef node); WIN_EXPORT YGValue YGNodeStyleGetFlexBasis(YGNodeConstRef node);
WIN_EXPORT void YGNodeStyleSetPosition( WIN_EXPORT void YGNodeStyleSetPosition(YGNodeRef node, YGEdge edge,
YGNodeRef node, float position);
YGEdge edge, WIN_EXPORT void YGNodeStyleSetPositionPercent(YGNodeRef node, YGEdge edge,
float position); float position);
WIN_EXPORT void YGNodeStyleSetPositionPercent(
YGNodeRef node,
YGEdge edge,
float position);
WIN_EXPORT YGValue YGNodeStyleGetPosition(YGNodeConstRef node, YGEdge edge); WIN_EXPORT YGValue YGNodeStyleGetPosition(YGNodeConstRef node, YGEdge edge);
WIN_EXPORT void YGNodeStyleSetMargin(YGNodeRef node, YGEdge edge, float margin); WIN_EXPORT void YGNodeStyleSetMargin(YGNodeRef node, YGEdge edge, float margin);
WIN_EXPORT void YGNodeStyleSetMarginPercent( WIN_EXPORT void YGNodeStyleSetMarginPercent(YGNodeRef node, YGEdge edge,
YGNodeRef node, float margin);
YGEdge edge,
float margin);
WIN_EXPORT void YGNodeStyleSetMarginAuto(YGNodeRef node, YGEdge edge); WIN_EXPORT void YGNodeStyleSetMarginAuto(YGNodeRef node, YGEdge edge);
WIN_EXPORT YGValue YGNodeStyleGetMargin(YGNodeConstRef node, YGEdge edge); WIN_EXPORT YGValue YGNodeStyleGetMargin(YGNodeConstRef node, YGEdge edge);
WIN_EXPORT void YGNodeStyleSetPadding( WIN_EXPORT void YGNodeStyleSetPadding(YGNodeRef node, YGEdge edge,
YGNodeRef node, float padding);
YGEdge edge, WIN_EXPORT void YGNodeStyleSetPaddingPercent(YGNodeRef node, YGEdge edge,
float padding); float padding);
WIN_EXPORT void YGNodeStyleSetPaddingPercent(
YGNodeRef node,
YGEdge edge,
float padding);
WIN_EXPORT YGValue YGNodeStyleGetPadding(YGNodeConstRef node, YGEdge edge); WIN_EXPORT YGValue YGNodeStyleGetPadding(YGNodeConstRef node, YGEdge edge);
WIN_EXPORT void YGNodeStyleSetBorder(YGNodeRef node, YGEdge edge, float border); WIN_EXPORT void YGNodeStyleSetBorder(YGNodeRef node, YGEdge edge, float border);
@ -290,22 +253,16 @@ WIN_EXPORT float YGNodeLayoutGetPadding(YGNodeRef node, YGEdge edge);
WIN_EXPORT void YGConfigSetLogger(YGConfigRef config, YGLogger logger); WIN_EXPORT void YGConfigSetLogger(YGConfigRef config, YGLogger logger);
WIN_EXPORT void YGAssert(bool condition, const char* message); WIN_EXPORT void YGAssert(bool condition, const char* message);
WIN_EXPORT void YGAssertWithNode( WIN_EXPORT void YGAssertWithNode(YGNodeRef node, bool condition,
YGNodeRef node, const char* message);
bool condition, WIN_EXPORT void YGAssertWithConfig(YGConfigRef config, bool condition,
const char* message); const char* message);
WIN_EXPORT void YGAssertWithConfig(
YGConfigRef config,
bool condition,
const char* message);
// Set this to number of pixels in 1 point to round calculation results If you // Set this to number of pixels in 1 point to round calculation results If you
// want to avoid rounding - set PointScaleFactor to 0 // want to avoid rounding - set PointScaleFactor to 0
WIN_EXPORT void YGConfigSetPointScaleFactor( WIN_EXPORT void YGConfigSetPointScaleFactor(YGConfigRef config,
YGConfigRef config, float pixelsInPoint);
float pixelsInPoint);
void YGConfigSetShouldDiffLayoutWithoutLegacyStretchBehaviour( void YGConfigSetShouldDiffLayoutWithoutLegacyStretchBehaviour(
YGConfigRef config, YGConfigRef config, bool shouldDiffLayout);
bool shouldDiffLayout);
// Yoga previously had an error where containers would take the maximum space // Yoga previously had an error where containers would take the maximum space
// possible instead of the minimum like they are supposed to. In practice this // possible instead of the minimum like they are supposed to. In practice this
@ -313,8 +270,7 @@ void YGConfigSetShouldDiffLayoutWithoutLegacyStretchBehaviour(
// was such a long-standing bug we must allow legacy users to switch back to // was such a long-standing bug we must allow legacy users to switch back to
// this behaviour. // this behaviour.
WIN_EXPORT void YGConfigSetUseLegacyStretchBehaviour( WIN_EXPORT void YGConfigSetUseLegacyStretchBehaviour(
YGConfigRef config, YGConfigRef config, bool useLegacyStretchBehaviour);
bool useLegacyStretchBehaviour);
// YGConfig // YGConfig
WIN_EXPORT YGConfigRef YGConfigNew(void); WIN_EXPORT YGConfigRef YGConfigNew(void);
@ -323,21 +279,17 @@ WIN_EXPORT void YGConfigCopy(YGConfigRef dest, YGConfigRef src);
WIN_EXPORT int32_t YGConfigGetInstanceCount(void); WIN_EXPORT int32_t YGConfigGetInstanceCount(void);
WIN_EXPORT void YGConfigSetExperimentalFeatureEnabled( WIN_EXPORT void YGConfigSetExperimentalFeatureEnabled(
YGConfigRef config, YGConfigRef config, YGExperimentalFeature feature, bool enabled);
YGExperimentalFeature feature,
bool enabled);
WIN_EXPORT bool YGConfigIsExperimentalFeatureEnabled( WIN_EXPORT bool YGConfigIsExperimentalFeatureEnabled(
YGConfigRef config, YGConfigRef config, YGExperimentalFeature feature);
YGExperimentalFeature feature);
// Using the web defaults is the preferred configuration for new projects. Usage // Using the web defaults is the preferred configuration for new projects. Usage
// of non web defaults should be considered as legacy. // of non web defaults should be considered as legacy.
WIN_EXPORT void YGConfigSetUseWebDefaults(YGConfigRef config, bool enabled); WIN_EXPORT void YGConfigSetUseWebDefaults(YGConfigRef config, bool enabled);
WIN_EXPORT bool YGConfigGetUseWebDefaults(YGConfigRef config); WIN_EXPORT bool YGConfigGetUseWebDefaults(YGConfigRef config);
WIN_EXPORT void YGConfigSetCloneNodeFunc( WIN_EXPORT void YGConfigSetCloneNodeFunc(YGConfigRef config,
YGConfigRef config, YGCloneNodeFunc callback);
YGCloneNodeFunc callback);
// Export only for C# // Export only for C#
WIN_EXPORT YGConfigRef YGConfigGetDefault(void); WIN_EXPORT YGConfigRef YGConfigGetDefault(void);
@ -345,11 +297,8 @@ WIN_EXPORT YGConfigRef YGConfigGetDefault(void);
WIN_EXPORT void YGConfigSetContext(YGConfigRef config, void* context); WIN_EXPORT void YGConfigSetContext(YGConfigRef config, void* context);
WIN_EXPORT void* YGConfigGetContext(YGConfigRef config); WIN_EXPORT void* YGConfigGetContext(YGConfigRef config);
WIN_EXPORT float YGRoundValueToPixelGrid( WIN_EXPORT float YGRoundValueToPixelGrid(float value, float pointScaleFactor,
float value, bool forceCeil, bool forceFloor);
float pointScaleFactor,
bool forceCeil,
bool forceFloor);
YG_EXTERN_C_END YG_EXTERN_C_END
@ -359,9 +308,8 @@ YG_EXTERN_C_END
#include <vector> #include <vector>
// Calls f on each node in the tree including the given node argument. // Calls f on each node in the tree including the given node argument.
void YGTraversePreOrder( void YGTraversePreOrder(YGNodeRef node,
YGNodeRef node, std::function<void(YGNodeRef node)>&& f);
std::function<void(YGNodeRef node)>&& f);
void YGNodeSetChildren(YGNodeRef owner, const std::vector<YGNodeRef>& children); void YGNodeSetChildren(YGNodeRef owner, const std::vector<YGNodeRef>& children);

10
src/cpp/include/deps/yoga/event/event.cpp
View File

@ -5,6 +5,7 @@
* file in the root directory of this source tree. * file in the root directory of this source tree.
*/ */
#include "event.h" #include "event.h"
#include <atomic> #include <atomic>
#include <memory> #include <memory>
#include <stdexcept> #include <stdexcept>
@ -59,7 +60,7 @@ Node* push(Node* newHead) {
return oldHead; return oldHead;
} }
} // namespace } // namespace
void Event::reset() { void Event::reset() {
auto head = push(nullptr); auto head = push(nullptr);
@ -76,11 +77,10 @@ void Event::subscribe(std::function<Subscriber>&& subscriber) {
void Event::publish(const YGNode& node, Type eventType, const Data& eventData) { void Event::publish(const YGNode& node, Type eventType, const Data& eventData) {
for (auto subscriber = subscribers.load(std::memory_order_relaxed); for (auto subscriber = subscribers.load(std::memory_order_relaxed);
subscriber != nullptr; subscriber != nullptr; subscriber = subscriber->next) {
subscriber = subscriber->next) {
subscriber->subscriber(node, eventType, eventData); subscriber->subscriber(node, eventType, eventData);
} }
} }
} // namespace yoga } // namespace yoga
} // namespace facebook } // namespace facebook

13
src/cpp/include/deps/yoga/event/event.h
View File

@ -6,10 +6,11 @@
*/ */
#pragma once #pragma once
#include <yoga/YGEnums.h>
#include <array>
#include <functional> #include <functional>
#include <vector> #include <vector>
#include <array>
#include <yoga/YGEnums.h>
struct YGConfig; struct YGConfig;
struct YGNode; struct YGNode;
@ -71,7 +72,7 @@ struct Event {
class Data { class Data {
const void* data_; const void* data_;
public: public:
template <Type E> template <Type E>
Data(const TypedData<E>& data) : data_{&data} {} Data(const TypedData<E>& data) : data_{&data} {}
@ -97,7 +98,7 @@ struct Event {
publish<E>(*node, eventData); publish<E>(*node, eventData);
} }
private: private:
static void publish(const YGNode&, Type, const Data&); static void publish(const YGNode&, Type, const Data&);
}; };
@ -140,5 +141,5 @@ struct Event::TypedData<Event::NodeLayout> {
void* layoutContext; void* layoutContext;
}; };
} // namespace yoga } // namespace yoga
} // namespace facebook } // namespace facebook

16
src/cpp/include/deps/yoga/internal/experiments-inl.h
View File

@ -6,26 +6,24 @@
*/ */
#pragma once #pragma once
#include "experiments.h"
#include <bitset> #include <bitset>
#include "experiments.h"
namespace facebook { namespace facebook {
namespace yoga { namespace yoga {
namespace internal { namespace internal {
namespace detail { namespace detail {
extern std::bitset<sizeof(int)> enabledExperiments; extern std::bitset<sizeof(int)> enabledExperiments;
} // namespace detail } // namespace detail
inline bool isEnabled(Experiment experiment) { inline bool isEnabled(Experiment experiment) {
return detail::enabledExperiments.test(static_cast<size_t>(experiment)); return detail::enabledExperiments.test(static_cast<size_t>(experiment));
} }
inline void disableAllExperiments() { inline void disableAllExperiments() { detail::enabledExperiments = 0; }
detail::enabledExperiments = 0;
}
} // namespace internal } // namespace internal
} // namespace yoga } // namespace yoga
} // namespace facebook } // namespace facebook

9
src/cpp/include/deps/yoga/internal/experiments.cpp
View File

@ -5,6 +5,7 @@
* file in the root directory of this source tree. * file in the root directory of this source tree.
*/ */
#include "experiments.h" #include "experiments.h"
#include "experiments-inl.h" #include "experiments-inl.h"
namespace facebook { namespace facebook {
@ -15,7 +16,7 @@ namespace detail {
std::bitset<sizeof(int)> enabledExperiments = 0; std::bitset<sizeof(int)> enabledExperiments = 0;
} // namespace detail } // namespace detail
void enable(Experiment experiment) { void enable(Experiment experiment) {
detail::enabledExperiments.set(static_cast<size_t>(experiment)); detail::enabledExperiments.set(static_cast<size_t>(experiment));
@ -32,6 +33,6 @@ bool toggle(Experiment experiment) {
return previousState; return previousState;
} }
} // namespace internal } // namespace internal
} // namespace yoga } // namespace yoga
} // namespace facebook } // namespace facebook

6
src/cpp/include/deps/yoga/internal/experiments.h
View File

@ -20,6 +20,6 @@ void enable(Experiment);
void disable(Experiment); void disable(Experiment);
bool toggle(Experiment); bool toggle(Experiment);
} // namespace internal } // namespace internal
} // namespace yoga } // namespace yoga
} // namespace facebook } // namespace facebook

44
src/cpp/include/deps/yoga/log.cpp
View File

@ -6,9 +6,9 @@
*/ */
#include "log.h" #include "log.h"
#include "Yoga.h"
#include "YGConfig.h" #include "YGConfig.h"
#include "YGNode.h" #include "YGNode.h"
#include "Yoga.h"
namespace facebook { namespace facebook {
namespace yoga { namespace yoga {
@ -16,13 +16,8 @@ namespace detail {
namespace { namespace {
void vlog( void vlog(YGConfig* config, YGNode* node, YGLogLevel level, void* context,
YGConfig* config, const char* format, va_list args) {
YGNode* node,
YGLogLevel level,
void* context,
const char* format,
va_list args) {
YGConfig* logConfig = config != nullptr ? config : YGConfigGetDefault(); YGConfig* logConfig = config != nullptr ? config : YGConfigGetDefault();
logConfig->log(logConfig, node, level, context, format, args); logConfig->log(logConfig, node, level, context, format, args);
@ -30,38 +25,25 @@ void vlog(
abort(); abort();
} }
} }
} // namespace } // namespace
void Log::log( void Log::log(YGNode* node, YGLogLevel level, void* context, const char* format,
YGNode* node, ...) noexcept {
YGLogLevel level,
void* context,
const char* format,
...) noexcept {
va_list args; va_list args;
va_start(args, format); va_start(args, format);
vlog( vlog(node == nullptr ? nullptr : node->getConfig(), node, level, context,
node == nullptr ? nullptr : node->getConfig(), format, args);
node,
level,
context,
format,
args);
va_end(args); va_end(args);
} }
void Log::log( void Log::log(YGConfig* config, YGLogLevel level, void* context,
YGConfig* config, const char* format, ...) noexcept {
YGLogLevel level,
void* context,
const char* format,
...) noexcept {
va_list args; va_list args;
va_start(args, format); va_start(args, format);
vlog(config, nullptr, level, context, format, args); vlog(config, nullptr, level, context, format, args);
va_end(args); va_end(args);
} }
} // namespace detail } // namespace detail
} // namespace yoga } // namespace yoga
} // namespace facebook } // namespace facebook

22
src/cpp/include/deps/yoga/log.h
View File

@ -17,21 +17,13 @@ namespace yoga {
namespace detail { namespace detail {
struct Log { struct Log {
static void log( static void log(YGNode* node, YGLogLevel level, void*, const char* message,
YGNode* node, ...) noexcept;
YGLogLevel level,
void*,
const char* message,
...) noexcept;
static void log( static void log(YGConfig* config, YGLogLevel level, void*, const char* format,
YGConfig* config, ...) noexcept;
YGLogLevel level,
void*,
const char* format,
...) noexcept;
}; };
} // namespace detail } // namespace detail
} // namespace yoga } // namespace yoga
} // namespace facebook } // namespace facebook

4
src/cpp/include/nodegui/Extras/Utils/nutils.h
View File

@ -3,6 +3,6 @@
#include "core/FlexLayout/flexlayout.h" #include "core/FlexLayout/flexlayout.h"
namespace extrautils { namespace extrautils {
YGSize measureQtWidget (YGNodeRef node, float width, YGMeasureMode widthMode, float height, YGMeasureMode heightMode); YGSize measureQtWidget(YGNodeRef node, float width, YGMeasureMode widthMode,
float height, YGMeasureMode heightMode);
} }

47
src/cpp/include/nodegui/QtCore/QObject/qobject_macro.h
View File

@ -1,36 +1,35 @@
#pragma once #pragma once
#include "core/Events/eventwidget_macro.h"
#include "core/Component/component_macro.h" #include "core/Component/component_macro.h"
#include "core/Events/eventwidget_macro.h"
/* /*
This macro adds common QObject exported methods This macro adds common QObject exported methods
The exported methods are taken into this macro to avoid writing them in each and every widget we export. The exported methods are taken into this macro to avoid writing them in each
and every widget we export.
*/ */
#ifndef QOBJECT_WRAPPED_METHODS_DECLARATION #ifndef QOBJECT_WRAPPED_METHODS_DECLARATION
#define QOBJECT_WRAPPED_METHODS_DECLARATION \ #define QOBJECT_WRAPPED_METHODS_DECLARATION \
\ \
EVENTWIDGET_WRAPPED_METHODS_DECLARATION \ EVENTWIDGET_WRAPPED_METHODS_DECLARATION \
\ \
Napi::Value inherits(const Napi::CallbackInfo& info){ \ Napi::Value inherits(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \ Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \ Napi::HandleScope scope(env); \
Napi::String className = info[0].As<Napi::String>(); \ Napi::String className = info[0].As<Napi::String>(); \
bool doesIt = this->instance->inherits(className.Utf8Value().c_str()); \ bool doesIt = this->instance->inherits(className.Utf8Value().c_str()); \
return Napi::Value::From(env, doesIt); \ return Napi::Value::From(env, doesIt); \
} \ }
\
#endif //QOBJECT_WRAPPED_METHODS_DECLARATION #endif // QOBJECT_WRAPPED_METHODS_DECLARATION
#ifndef QOBJECT_WRAPPED_METHODS_EXPORT_DEFINE #ifndef QOBJECT_WRAPPED_METHODS_EXPORT_DEFINE
#define QOBJECT_WRAPPED_METHODS_EXPORT_DEFINE(ComponentWrapName) \ #define QOBJECT_WRAPPED_METHODS_EXPORT_DEFINE(ComponentWrapName) \
\ \
EVENTWIDGET_WRAPPED_METHODS_EXPORT_DEFINE(ComponentWrapName) \ EVENTWIDGET_WRAPPED_METHODS_EXPORT_DEFINE(ComponentWrapName) \
COMPONENT_WRAPPED_METHODS_EXPORT_DEFINE \ COMPONENT_WRAPPED_METHODS_EXPORT_DEFINE \
\ \
InstanceMethod("inherits", &ComponentWrapName::inherits),\ InstanceMethod("inherits", &ComponentWrapName::inherits),
\
#endif // QOBJECT_WRAPPED_METHODS_EXPORT_DEFINE #endif // QOBJECT_WRAPPED_METHODS_EXPORT_DEFINE

44
src/cpp/include/nodegui/QtGui/QApplication/qapplication_wrap.h
View File

@ -1,32 +1,32 @@
#pragma once #pragma once
#include <napi.h> #include <napi.h>
#include <QApplication> #include <QApplication>
class QApplicationWrap : public Napi::ObjectWrap<QApplicationWrap> { class QApplicationWrap : public Napi::ObjectWrap<QApplicationWrap> {
private: private:
QApplication* instance; QApplication* instance;
static int argc; static int argc;
static char** argv; static char** argv;
bool _wasManuallyCreated = false; bool _wasManuallyCreated = false;
public: public:
static Napi::FunctionReference constructor; static Napi::FunctionReference constructor;
static Napi::Object init(Napi::Env env, Napi::Object exports); static Napi::Object init(Napi::Env env, Napi::Object exports);
QApplicationWrap(const Napi::CallbackInfo& info); QApplicationWrap(const Napi::CallbackInfo& info);
~QApplicationWrap(); ~QApplicationWrap();
QApplication* getInternalInstance(); QApplication* getInternalInstance();
// Wrapped methods // Wrapped methods
Napi::Value processEvents(const Napi::CallbackInfo& info); Napi::Value processEvents(const Napi::CallbackInfo& info);
Napi::Value exec(const Napi::CallbackInfo& info); Napi::Value exec(const Napi::CallbackInfo& info);
Napi::Value quit(const Napi::CallbackInfo& info); Napi::Value quit(const Napi::CallbackInfo& info);
Napi::Value exit(const Napi::CallbackInfo& info); Napi::Value exit(const Napi::CallbackInfo& info);
Napi::Value setQuitOnLastWindowClosed(const Napi::CallbackInfo& info); Napi::Value setQuitOnLastWindowClosed(const Napi::CallbackInfo& info);
Napi::Value quitOnLastWindowClosed(const Napi::CallbackInfo& info); Napi::Value quitOnLastWindowClosed(const Napi::CallbackInfo& info);
}; };
namespace StaticQApplicationWrapMethods { namespace StaticQApplicationWrapMethods {
Napi::Value instance(const Napi::CallbackInfo& info); Napi::Value instance(const Napi::CallbackInfo& info);
Napi::Value clipboard(const Napi::CallbackInfo& info); Napi::Value clipboard(const Napi::CallbackInfo& info);
} } // namespace StaticQApplicationWrapMethods

28
src/cpp/include/nodegui/QtGui/QClipboard/qclipboard_wrap.h
View File

@ -1,20 +1,22 @@
#pragma once #pragma once
#include <napi.h> #include <napi.h>
#include <QClipboard> #include <QClipboard>
#include "core/Component/component_macro.h" #include "core/Component/component_macro.h"
class QClipboardWrap : public Napi::ObjectWrap<QClipboardWrap> class QClipboardWrap : public Napi::ObjectWrap<QClipboardWrap> {
{ private:
private: QClipboard* instance;
QClipboard* instance;
public: public:
static Napi::FunctionReference constructor; static Napi::FunctionReference constructor;
static Napi::Object init(Napi::Env env, Napi::Object exports); static Napi::Object init(Napi::Env env, Napi::Object exports);
QClipboardWrap(const Napi::CallbackInfo &info); QClipboardWrap(const Napi::CallbackInfo& info);
QClipboard *getInternalInstance(); QClipboard* getInternalInstance();
// Wrapped methods // Wrapped methods
Napi::Value clear(const Napi::CallbackInfo& info); Napi::Value clear(const Napi::CallbackInfo& info);
Napi::Value setText(const Napi::CallbackInfo& info); Napi::Value setText(const Napi::CallbackInfo& info);
Napi::Value text(const Napi::CallbackInfo& info); Napi::Value text(const Napi::CallbackInfo& info);
}; };

28
src/cpp/include/nodegui/QtGui/QCursor/qcursor_wrap.h
View File

@ -2,20 +2,22 @@
#include <napi.h> #include <napi.h>
#include <stdlib.h> #include <stdlib.h>
#include <QCursor> #include <QCursor>
#include "core/Component/component_macro.h" #include "core/Component/component_macro.h"
class QCursorWrap : public Napi::ObjectWrap<QCursorWrap> class QCursorWrap : public Napi::ObjectWrap<QCursorWrap> {
{ private:
private: std::unique_ptr<QCursor> instance;
std::unique_ptr<QCursor> instance;
public: public:
static Napi::FunctionReference constructor; static Napi::FunctionReference constructor;
static Napi::Object init(Napi::Env env, Napi::Object exports); static Napi::Object init(Napi::Env env, Napi::Object exports);
QCursorWrap(const Napi::CallbackInfo &info); QCursorWrap(const Napi::CallbackInfo& info);
~QCursorWrap(); ~QCursorWrap();
QCursor *getInternalInstance(); QCursor* getInternalInstance();
// Wrapped methods // Wrapped methods
Napi::Value pos(const Napi::CallbackInfo& info); Napi::Value pos(const Napi::CallbackInfo& info);
Napi::Value setPos(const Napi::CallbackInfo& info); Napi::Value setPos(const Napi::CallbackInfo& info);
}; };

9
src/cpp/include/nodegui/QtGui/QEvent/QKeyEvent/qkeyevent_wrap.h
View File

@ -2,20 +2,21 @@
#include <napi.h> #include <napi.h>
#include <stdlib.h> #include <stdlib.h>
#include <QKeyEvent> #include <QKeyEvent>
class QKeyEventWrap : public Napi::ObjectWrap<QKeyEventWrap>{ class QKeyEventWrap : public Napi::ObjectWrap<QKeyEventWrap> {
private: private:
QKeyEvent* instance; QKeyEvent* instance;
public: public:
static Napi::Object init(Napi::Env env, Napi::Object exports); static Napi::Object init(Napi::Env env, Napi::Object exports);
QKeyEventWrap(const Napi::CallbackInfo& info); QKeyEventWrap(const Napi::CallbackInfo& info);
~QKeyEventWrap(); ~QKeyEventWrap();
QKeyEvent* getInternalInstance(); QKeyEvent* getInternalInstance();
//class constructor // class constructor
static Napi::FunctionReference constructor; static Napi::FunctionReference constructor;
//wrapped methods // wrapped methods
Napi::Value text(const Napi::CallbackInfo& info); Napi::Value text(const Napi::CallbackInfo& info);
// Napi::Value setFlexNode(const Napi::CallbackInfo& info); // Napi::Value setFlexNode(const Napi::CallbackInfo& info);
}; };

29
src/cpp/include/nodegui/QtGui/QIcon/qicon_wrap.h
View File

@ -2,22 +2,23 @@
#include <napi.h> #include <napi.h>
#include <stdlib.h> #include <stdlib.h>
#include <QIcon> #include <QIcon>
#include "core/Component/component_macro.h" #include "core/Component/component_macro.h"
class QIconWrap : public Napi::ObjectWrap<QIconWrap> class QIconWrap : public Napi::ObjectWrap<QIconWrap> {
{ private:
private: std::unique_ptr<QIcon> instance;
std::unique_ptr<QIcon> instance;
public: public:
static Napi::FunctionReference constructor; static Napi::FunctionReference constructor;
static Napi::Object init(Napi::Env env, Napi::Object exports); static Napi::Object init(Napi::Env env, Napi::Object exports);
QIconWrap(const Napi::CallbackInfo &info); QIconWrap(const Napi::CallbackInfo& info);
~QIconWrap(); ~QIconWrap();
QIcon *getInternalInstance(); QIcon* getInternalInstance();
// Wrapped methods // Wrapped methods
Napi::Value pixmap(const Napi::CallbackInfo& info); Napi::Value pixmap(const Napi::CallbackInfo& info);
Napi::Value isMask(const Napi::CallbackInfo& info); Napi::Value isMask(const Napi::CallbackInfo& info);
Napi::Value setIsMask(const Napi::CallbackInfo& info); Napi::Value setIsMask(const Napi::CallbackInfo& info);
}; };

25
src/cpp/include/nodegui/QtGui/QKeySequence/qkeysequence_wrap.h
View File

@ -2,20 +2,21 @@
#include <napi.h> #include <napi.h>
#include <stdlib.h> #include <stdlib.h>
#include <QKeySequence> #include <QKeySequence>
#include "core/Component/component_macro.h" #include "core/Component/component_macro.h"
class QKeySequenceWrap : public Napi::ObjectWrap<QKeySequenceWrap> class QKeySequenceWrap : public Napi::ObjectWrap<QKeySequenceWrap> {
{ private:
private: std::unique_ptr<QKeySequence> instance;
std::unique_ptr<QKeySequence> instance;
public: public:
static Napi::FunctionReference constructor; static Napi::FunctionReference constructor;
static Napi::Object init(Napi::Env env, Napi::Object exports); static Napi::Object init(Napi::Env env, Napi::Object exports);
QKeySequenceWrap(const Napi::CallbackInfo &info); QKeySequenceWrap(const Napi::CallbackInfo &info);
~QKeySequenceWrap(); ~QKeySequenceWrap();
QKeySequence *getInternalInstance(); QKeySequence *getInternalInstance();
// Wrapped methods // Wrapped methods
Napi::Value count(const Napi::CallbackInfo& info); Napi::Value count(const Napi::CallbackInfo &info);
}; };

28
src/cpp/include/nodegui/QtGui/QPixmap/qpixmap_wrap.h
View File

@ -2,21 +2,23 @@
#include <napi.h> #include <napi.h>
#include <stdlib.h> #include <stdlib.h>
#include <QPixmap> #include <QPixmap>
#include "core/Component/component_macro.h" #include "core/Component/component_macro.h"
class QPixmapWrap : public Napi::ObjectWrap<QPixmapWrap> { class QPixmapWrap : public Napi::ObjectWrap<QPixmapWrap> {
private: private:
std::unique_ptr<QPixmap> instance; std::unique_ptr<QPixmap> instance;
public:
static Napi::FunctionReference constructor;
static Napi::Object init(Napi::Env env, Napi::Object exports);
QPixmapWrap(const Napi::CallbackInfo& info);
~QPixmapWrap();
QPixmap* getInternalInstance();
// Wrapped methods
Napi::Value load(const Napi::CallbackInfo& info);
Napi::Value save(const Napi::CallbackInfo& info);
Napi::Value scaled(const Napi::CallbackInfo& info);
};
public:
static Napi::FunctionReference constructor;
static Napi::Object init(Napi::Env env, Napi::Object exports);
QPixmapWrap(const Napi::CallbackInfo& info);
~QPixmapWrap();
QPixmap* getInternalInstance();
// Wrapped methods
Napi::Value load(const Napi::CallbackInfo& info);
Napi::Value save(const Napi::CallbackInfo& info);
Napi::Value scaled(const Napi::CallbackInfo& info);
};

62
src/cpp/include/nodegui/QtWidgets/QAbstractScrollArea/qabstractscrollarea_macro.h
View File

@ -1,43 +1,45 @@
#pragma once #pragma once
#include "QtWidgets/QWidget/qwidget_wrap.h"
#include "QtWidgets/QWidget/qwidget_macro.h" #include "QtWidgets/QWidget/qwidget_macro.h"
#include "QtWidgets/QWidget/qwidget_wrap.h"
#include "deps/spdlog/spdlog.h" #include "deps/spdlog/spdlog.h"
/* /*
This macro adds common QAbstractScrollArea exported methods This macro adds common QAbstractScrollArea exported methods
The exported methods are taken into this macro to avoid writing them in each and every widget we export. The exported methods are taken into this macro to avoid writing them in each
and every widget we export.
*/ */
#ifndef QABSTRACTSCROLLAREA_WRAPPED_METHODS_DECLARATION #ifndef QABSTRACTSCROLLAREA_WRAPPED_METHODS_DECLARATION
#define QABSTRACTSCROLLAREA_WRAPPED_METHODS_DECLARATION \ #define QABSTRACTSCROLLAREA_WRAPPED_METHODS_DECLARATION \
QWIDGET_WRAPPED_METHODS_DECLARATION \ QWIDGET_WRAPPED_METHODS_DECLARATION \
Napi::Value setViewport(const Napi::CallbackInfo& info) { \ Napi::Value setViewport(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \ Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \ Napi::HandleScope scope(env); \
Napi::Object viewPortObject = info[0].As<Napi::Object>(); \ Napi::Object viewPortObject = info[0].As<Napi::Object>(); \
QWidgetWrap* viewPortWidgetWrap = Napi::ObjectWrap<QWidgetWrap>::Unwrap(viewPortObject); \ QWidgetWrap* viewPortWidgetWrap = \
Napi::ObjectWrap<QWidgetWrap>::Unwrap(viewPortObject); \
QWidget* viewPort = viewPortWidgetWrap->getInternalInstance(); \ QWidget* viewPort = viewPortWidgetWrap->getInternalInstance(); \
this->instance->setViewport(viewPort); \ this->instance->setViewport(viewPort); \
return env.Null(); \ return env.Null(); \
} \ } \
\ \
Napi::Value viewport(const Napi::CallbackInfo& info) { \ Napi::Value viewport(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \ Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \ Napi::HandleScope scope(env); \
QWidget* viewPort = this->instance->viewport(); \ QWidget* viewPort = this->instance->viewport(); \
NWidget* nviewPort = reinterpret_cast<NWidget*>(viewPort); \ NWidget* nviewPort = reinterpret_cast<NWidget*>(viewPort); \
auto instance = QWidgetWrap::constructor.New({ Napi::External<NWidget>::New(env, nviewPort) }); \ auto instance = QWidgetWrap::constructor.New( \
return instance; \ {Napi::External<NWidget>::New(env, nviewPort)}); \
} \ return instance; \
\ }
#endif //QABSTRACTSCROLLAREA_WRAPPED_METHODS_DECLARATION #endif // QABSTRACTSCROLLAREA_WRAPPED_METHODS_DECLARATION
#ifndef QABSTRACTSCROLLAREA_WRAPPED_METHODS_EXPORT_DEFINE #ifndef QABSTRACTSCROLLAREA_WRAPPED_METHODS_EXPORT_DEFINE
#define QABSTRACTSCROLLAREA_WRAPPED_METHODS_EXPORT_DEFINE(WidgetWrapName) \ #define QABSTRACTSCROLLAREA_WRAPPED_METHODS_EXPORT_DEFINE(WidgetWrapName) \
QWIDGET_WRAPPED_METHODS_EXPORT_DEFINE(WidgetWrapName) \ QWIDGET_WRAPPED_METHODS_EXPORT_DEFINE(WidgetWrapName) \
InstanceMethod("setViewport", &WidgetWrapName::setViewport), \ InstanceMethod("setViewport", &WidgetWrapName::setViewport), \
InstanceMethod("viewport",&WidgetWrapName::viewport), \ InstanceMethod("viewport", &WidgetWrapName::viewport),
#endif // QABSTRACTSCROLLAREA_WRAPPED_METHODS_EXPORT_DEFINE #endif // QABSTRACTSCROLLAREA_WRAPPED_METHODS_EXPORT_DEFINE

157
src/cpp/include/nodegui/QtWidgets/QAbstractSlider/qabstractslider_macro.h
View File

@ -1,91 +1,92 @@
#pragma once #pragma once
#include "QtWidgets/QWidget/qwidget_wrap.h"
#include "QtWidgets/QWidget/qwidget_macro.h" #include "QtWidgets/QWidget/qwidget_macro.h"
#include "QtWidgets/QWidget/qwidget_wrap.h"
#include "deps/spdlog/spdlog.h" #include "deps/spdlog/spdlog.h"
/* /*
This macro adds common QAbstractSlider exported methods This macro adds common QAbstractSlider exported methods
The exported methods are taken into this macro to avoid writing them in each and every widget we export. The exported methods are taken into this macro to avoid writing them in each
and every widget we export.
*/ */
#ifndef QABSTRACTSLIDER_WRAPPED_METHODS_DECLARATION #ifndef QABSTRACTSLIDER_WRAPPED_METHODS_DECLARATION
#define QABSTRACTSLIDER_WRAPPED_METHODS_DECLARATION \ #define QABSTRACTSLIDER_WRAPPED_METHODS_DECLARATION \
QWIDGET_WRAPPED_METHODS_DECLARATION \ QWIDGET_WRAPPED_METHODS_DECLARATION \
Napi::Value setSingleStep(const Napi::CallbackInfo& info) { \ Napi::Value setSingleStep(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \ Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \ Napi::HandleScope scope(env); \
Napi::Number step = info[0].As<Napi::Number>(); \ Napi::Number step = info[0].As<Napi::Number>(); \
this->instance->setSingleStep(step.Int32Value()); \ this->instance->setSingleStep(step.Int32Value()); \
return env.Null(); \ return env.Null(); \
} \ } \
\ \
Napi::Value setMaximum(const Napi::CallbackInfo& info) { \ Napi::Value setMaximum(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \ Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \ Napi::HandleScope scope(env); \
Napi::Number maximum = info[0].As<Napi::Number>(); \ Napi::Number maximum = info[0].As<Napi::Number>(); \
this->instance->setMaximum(maximum.Int32Value()); \ this->instance->setMaximum(maximum.Int32Value()); \
return env.Null(); \ return env.Null(); \
} \ } \
\ \
Napi::Value setMinimum(const Napi::CallbackInfo& info) { \ Napi::Value setMinimum(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \ Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \ Napi::HandleScope scope(env); \
Napi::Number minimum = info[0].As<Napi::Number>(); \ Napi::Number minimum = info[0].As<Napi::Number>(); \
this->instance->setMinimum(minimum.Int32Value()); \ this->instance->setMinimum(minimum.Int32Value()); \
return env.Null(); \ return env.Null(); \
} \ } \
\ \
Napi::Value setValue(const Napi::CallbackInfo& info) { \ Napi::Value setValue(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \ Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \ Napi::HandleScope scope(env); \
Napi::Number value = info[0].As<Napi::Number>(); \ Napi::Number value = info[0].As<Napi::Number>(); \
this->instance->setValue(value.Int32Value()); \ this->instance->setValue(value.Int32Value()); \
return env.Null(); \ return env.Null(); \
} \ } \
\ \
Napi::Value setOrientation(const Napi::CallbackInfo& info) { \ Napi::Value setOrientation(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \ Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \ Napi::HandleScope scope(env); \
Napi::Number orientation = info[0].As<Napi::Number>(); \ Napi::Number orientation = info[0].As<Napi::Number>(); \
this->instance->setOrientation(static_cast<Qt::Orientation>(orientation.Int32Value())); \ this->instance->setOrientation( \
return env.Null(); \ static_cast<Qt::Orientation>(orientation.Int32Value())); \
} \ return env.Null(); \
\ } \
Napi::Value maximum(const Napi::CallbackInfo& info) { \ \
Napi::Env env = info.Env(); \ Napi::Value maximum(const Napi::CallbackInfo& info) { \
Napi::HandleScope scope(env); \ Napi::Env env = info.Env(); \
int maximum = this->instance->maximum(); \ Napi::HandleScope scope(env); \
return Napi::Number::New(env, maximum); \ int maximum = this->instance->maximum(); \
} \ return Napi::Number::New(env, maximum); \
\ } \
Napi::Value minimum(const Napi::CallbackInfo& info) { \ \
Napi::Env env = info.Env(); \ Napi::Value minimum(const Napi::CallbackInfo& info) { \
Napi::HandleScope scope(env); \ Napi::Env env = info.Env(); \
int minimum = this->instance->minimum(); \ Napi::HandleScope scope(env); \
return Napi::Number::New(env, minimum); \ int minimum = this->instance->minimum(); \
} \ return Napi::Number::New(env, minimum); \
\ } \
Napi::Value value(const Napi::CallbackInfo& info) { \ \
Napi::Env env = info.Env(); \ Napi::Value value(const Napi::CallbackInfo& info) { \
Napi::HandleScope scope(env); \ Napi::Env env = info.Env(); \
int value = this->instance->value(); \ Napi::HandleScope scope(env); \
return Napi::Number::New(env, value); \ int value = this->instance->value(); \
} \ return Napi::Number::New(env, value); \
\ }
#endif //QABSTRACTSLIDER_WRAPPED_METHODS_DECLARATION #endif // QABSTRACTSLIDER_WRAPPED_METHODS_DECLARATION
#ifndef QABSTRACTSLIDER_WRAPPED_METHODS_EXPORT_DEFINE #ifndef QABSTRACTSLIDER_WRAPPED_METHODS_EXPORT_DEFINE
#define QABSTRACTSLIDER_WRAPPED_METHODS_EXPORT_DEFINE(WidgetWrapName) \ #define QABSTRACTSLIDER_WRAPPED_METHODS_EXPORT_DEFINE(WidgetWrapName) \
QWIDGET_WRAPPED_METHODS_EXPORT_DEFINE(WidgetWrapName) \ QWIDGET_WRAPPED_METHODS_EXPORT_DEFINE(WidgetWrapName) \
InstanceMethod("setSingleStep", &WidgetWrapName::setSingleStep), \ InstanceMethod("setSingleStep", &WidgetWrapName::setSingleStep), \
InstanceMethod("setMaximum", &WidgetWrapName::setMaximum), \ InstanceMethod("setMaximum", &WidgetWrapName::setMaximum), \
InstanceMethod("setMinimum", &WidgetWrapName::setMinimum), \ InstanceMethod("setMinimum", &WidgetWrapName::setMinimum), \
InstanceMethod("setValue", &WidgetWrapName::setValue), \ InstanceMethod("setValue", &WidgetWrapName::setValue), \
InstanceMethod("setOrientation", &WidgetWrapName::setOrientation), \ InstanceMethod("setOrientation", &WidgetWrapName::setOrientation), \
InstanceMethod("maximum", &WidgetWrapName::maximum), \ InstanceMethod("maximum", &WidgetWrapName::maximum), \
InstanceMethod("minimum", &WidgetWrapName::minimum), \ InstanceMethod("minimum", &WidgetWrapName::minimum), \
InstanceMethod("value", &WidgetWrapName::value), \ InstanceMethod("value", &WidgetWrapName::value),
#endif // QABSTRACTSLIDER_WRAPPED_METHODS_EXPORT_DEFINE #endif // QABSTRACTSLIDER_WRAPPED_METHODS_EXPORT_DEFINE

62
src/cpp/include/nodegui/QtWidgets/QAction/naction.hpp
View File

@ -1,38 +1,38 @@
#pragma once #pragma once
#include <QAction> #include <QAction>
#include "core/NodeWidget/nodewidget.h" #include "core/NodeWidget/nodewidget.h"
#include "napi.h" #include "napi.h"
class NAction: public QAction, public EventWidget class NAction : public QAction, public EventWidget {
{ Q_OBJECT
Q_OBJECT EVENTWIDGET_IMPLEMENTATIONS(QAction)
EVENTWIDGET_IMPLEMENTATIONS(QAction) public:
public: using QAction::QAction; // inherit all constructors of QAction
using QAction::QAction; //inherit all constructors of QAction void connectWidgetSignalsToEventEmitter() {
void connectWidgetSignalsToEventEmitter() { // Qt Connects: Implement all signal connects here
// Qt Connects: Implement all signal connects here QObject::connect(this, &QAction::triggered, [=](bool checked) {
QObject::connect(this, &QAction::triggered, [=](bool checked) { Napi::Env env = this->emitOnNode.Env();
Napi::Env env = this->emitOnNode.Env(); Napi::HandleScope scope(env);
Napi::HandleScope scope(env); this->emitOnNode.Call({Napi::String::New(env, "triggered"),
this->emitOnNode.Call({ Napi::String::New(env, "triggered"), Napi::Value::From(env, checked) }); Napi::Value::From(env, checked)});
}); });
QObject::connect(this, &QAction::changed, [=]() { QObject::connect(this, &QAction::changed, [=]() {
Napi::Env env = this->emitOnNode.Env(); Napi::Env env = this->emitOnNode.Env();
Napi::HandleScope scope(env); Napi::HandleScope scope(env);
this->emitOnNode.Call({ Napi::String::New(env, "changed") }); this->emitOnNode.Call({Napi::String::New(env, "changed")});
}); });
QObject::connect(this, &QAction::hovered, [=]() { QObject::connect(this, &QAction::hovered, [=]() {
Napi::Env env = this->emitOnNode.Env(); Napi::Env env = this->emitOnNode.Env();
Napi::HandleScope scope(env); Napi::HandleScope scope(env);
this->emitOnNode.Call({ Napi::String::New(env, "hovered") }); this->emitOnNode.Call({Napi::String::New(env, "hovered")});
}); });
QObject::connect(this, &QAction::toggled, [=](bool checked) { QObject::connect(this, &QAction::toggled, [=](bool checked) {
Napi::Env env = this->emitOnNode.Env(); Napi::Env env = this->emitOnNode.Env();
Napi::HandleScope scope(env); Napi::HandleScope scope(env);
this->emitOnNode.Call({ Napi::String::New(env, "toggled"), Napi::Value::From(env, checked) }); this->emitOnNode.Call(
}); {Napi::String::New(env, "toggled"), Napi::Value::From(env, checked)});
} });
}
}; };

13
src/cpp/include/nodegui/QtWidgets/QAction/qaction_wrap.h
View File

@ -1,20 +1,22 @@
#pragma once #pragma once
#include <napi.h> #include <napi.h>
#include "naction.hpp"
#include "QtWidgets/QWidget/qwidget_macro.h"
class QActionWrap : public Napi::ObjectWrap<QActionWrap>{ #include "QtWidgets/QWidget/qwidget_macro.h"
#include "naction.hpp"
class QActionWrap : public Napi::ObjectWrap<QActionWrap> {
private: private:
NAction* instance; NAction* instance;
public: public:
static Napi::Object init(Napi::Env env, Napi::Object exports); static Napi::Object init(Napi::Env env, Napi::Object exports);
QActionWrap(const Napi::CallbackInfo& info); QActionWrap(const Napi::CallbackInfo& info);
~QActionWrap(); ~QActionWrap();
NAction* getInternalInstance(); NAction* getInternalInstance();
//class constructor // class constructor
static Napi::FunctionReference constructor; static Napi::FunctionReference constructor;
//wrapped methods // wrapped methods
Napi::Value setText(const Napi::CallbackInfo& info); Napi::Value setText(const Napi::CallbackInfo& info);
Napi::Value setEnabled(const Napi::CallbackInfo& info); Napi::Value setEnabled(const Napi::CallbackInfo& info);
Napi::Value setIcon(const Napi::CallbackInfo& info); Napi::Value setIcon(const Napi::CallbackInfo& info);
@ -30,4 +32,3 @@ class QActionWrap : public Napi::ObjectWrap<QActionWrap>{
EVENTWIDGET_WRAPPED_METHODS_DECLARATION EVENTWIDGET_WRAPPED_METHODS_DECLARATION
}; };

29
src/cpp/include/nodegui/QtWidgets/QCheckBox/ncheckbox.hpp
View File

@ -1,23 +1,22 @@
#pragma once #pragma once
#include <QCheckBox> #include <QCheckBox>
#include "core/NodeWidget/nodewidget.h" #include "core/NodeWidget/nodewidget.h"
#include "napi.h" #include "napi.h"
class NCheckBox: public QCheckBox, public NodeWidget class NCheckBox : public QCheckBox, public NodeWidget {
{ Q_OBJECT
Q_OBJECT NODEWIDGET_IMPLEMENTATIONS(QCheckBox)
NODEWIDGET_IMPLEMENTATIONS(QCheckBox) public:
public: using QCheckBox::QCheckBox; // inherit all constructors of QCheckBox
using QCheckBox::QCheckBox; //inherit all constructors of QCheckBox
void connectWidgetSignalsToEventEmitter() { void connectWidgetSignalsToEventEmitter() {
QObject::connect(this, &QCheckBox::toggled, [=](bool checked) { QObject::connect(this, &QCheckBox::toggled, [=](bool checked) {
Napi::Env env = this->emitOnNode.Env(); Napi::Env env = this->emitOnNode.Env();
Napi::HandleScope scope(env); Napi::HandleScope scope(env);
this->emitOnNode.Call({ Napi::String::New(env, "toggled"), Napi::Value::From(env, checked) }); this->emitOnNode.Call(
}); {Napi::String::New(env, "toggled"), Napi::Value::From(env, checked)});
} });
}
}; };

12
src/cpp/include/nodegui/QtWidgets/QCheckBox/qcheckbox_wrap.h
View File

@ -2,25 +2,25 @@
#include <napi.h> #include <napi.h>
#include <stdlib.h> #include <stdlib.h>
#include "ncheckbox.hpp"
#include "QtWidgets/QWidget/qwidget_macro.h" #include "QtWidgets/QWidget/qwidget_macro.h"
#include "ncheckbox.hpp"
class QCheckBoxWrap : public Napi::ObjectWrap<QCheckBoxWrap> {
class QCheckBoxWrap : public Napi::ObjectWrap<QCheckBoxWrap>{
private: private:
std::unique_ptr<NCheckBox> instance; std::unique_ptr<NCheckBox> instance;
public: public:
static Napi::Object init(Napi::Env env, Napi::Object exports); static Napi::Object init(Napi::Env env, Napi::Object exports);
QCheckBoxWrap(const Napi::CallbackInfo& info); QCheckBoxWrap(const Napi::CallbackInfo& info);
~QCheckBoxWrap(); ~QCheckBoxWrap();
NCheckBox* getInternalInstance(); NCheckBox* getInternalInstance();
//class constructor // class constructor
static Napi::FunctionReference constructor; static Napi::FunctionReference constructor;
//wrapped methods // wrapped methods
Napi::Value setText(const Napi::CallbackInfo& info); Napi::Value setText(const Napi::CallbackInfo& info);
Napi::Value isChecked(const Napi::CallbackInfo& info); Napi::Value isChecked(const Napi::CallbackInfo& info);
Napi::Value setChecked(const Napi::CallbackInfo& info); Napi::Value setChecked(const Napi::CallbackInfo& info);
QWIDGET_WRAPPED_METHODS_DECLARATION QWIDGET_WRAPPED_METHODS_DECLARATION
}; };

70
src/cpp/include/nodegui/QtWidgets/QDial/ndial.hpp
View File

@ -1,43 +1,41 @@
#pragma once #pragma once
#include <QDial> #include <QDial>
#include "core/NodeWidget/nodewidget.h" #include "core/NodeWidget/nodewidget.h"
class NDial: public QDial, public NodeWidget class NDial : public QDial, public NodeWidget {
{ Q_OBJECT
Q_OBJECT NODEWIDGET_IMPLEMENTATIONS(QDial)
NODEWIDGET_IMPLEMENTATIONS(QDial) public:
public: using QDial::QDial; // inherit all constructors of QDial
using QDial::QDial; //inherit all constructors of QDial
void connectWidgetSignalsToEventEmitter() { void connectWidgetSignalsToEventEmitter() {
// Qt Connects: Implement all signal connects here // Qt Connects: Implement all signal connects here
QObject::connect(this, &QDial::valueChanged, [=]() { QObject::connect(this, &QDial::valueChanged, [=]() {
Napi::Env env = this->emitOnNode.Env(); Napi::Env env = this->emitOnNode.Env();
Napi::HandleScope scope(env); Napi::HandleScope scope(env);
this->emitOnNode.Call({ Napi::String::New(env, "valueChanged") }); this->emitOnNode.Call({Napi::String::New(env, "valueChanged")});
}); });
QObject::connect(this, &QDial::rangeChanged, [=]() { QObject::connect(this, &QDial::rangeChanged, [=]() {
Napi::Env env = this->emitOnNode.Env(); Napi::Env env = this->emitOnNode.Env();
Napi::HandleScope scope(env); Napi::HandleScope scope(env);
this->emitOnNode.Call({ Napi::String::New(env, "rangeChanged") }); this->emitOnNode.Call({Napi::String::New(env, "rangeChanged")});
}); });
QObject::connect(this, &QDial::sliderMoved, [=]() { QObject::connect(this, &QDial::sliderMoved, [=]() {
Napi::Env env = this->emitOnNode.Env(); Napi::Env env = this->emitOnNode.Env();
Napi::HandleScope scope(env); Napi::HandleScope scope(env);
this->emitOnNode.Call({ Napi::String::New(env, "sliderMoved") }); this->emitOnNode.Call({Napi::String::New(env, "sliderMoved")});
}); });
QObject::connect(this, &QDial::sliderPressed, [=]() { QObject::connect(this, &QDial::sliderPressed, [=]() {
Napi::Env env = this->emitOnNode.Env(); Napi::Env env = this->emitOnNode.Env();
Napi::HandleScope scope(env); Napi::HandleScope scope(env);
this->emitOnNode.Call({ Napi::String::New(env, "sliderPressed") }); this->emitOnNode.Call({Napi::String::New(env, "sliderPressed")});
}); });
QObject::connect(this, &QDial::sliderReleased, [=]() { QObject::connect(this, &QDial::sliderReleased, [=]() {
Napi::Env env = this->emitOnNode.Env(); Napi::Env env = this->emitOnNode.Env();
Napi::HandleScope scope(env); Napi::HandleScope scope(env);
this->emitOnNode.Call({ Napi::String::New(env, "sliderReleased") }); this->emitOnNode.Call({Napi::String::New(env, "sliderReleased")});
}); });
} }
}; };

17
src/cpp/include/nodegui/QtWidgets/QDial/qdial_wrap.h
View File

@ -2,22 +2,23 @@
#include <napi.h> #include <napi.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdlib.h>
#include "ndial.hpp"
#include "QtWidgets/QWidget/qwidget_macro.h"
#include "QtWidgets/QAbstractSlider/qabstractslider_macro.h"
class QDialWrap : public Napi::ObjectWrap<QDialWrap>{ #include "QtWidgets/QAbstractSlider/qabstractslider_macro.h"
#include "QtWidgets/QWidget/qwidget_macro.h"
#include "ndial.hpp"
class QDialWrap : public Napi::ObjectWrap<QDialWrap> {
private: private:
std::unique_ptr<NDial> instance; std::unique_ptr<NDial> instance;
public: public:
static Napi::Object init(Napi::Env env, Napi::Object exports); static Napi::Object init(Napi::Env env, Napi::Object exports);
QDialWrap(const Napi::CallbackInfo& info); QDialWrap(const Napi::CallbackInfo& info);
~QDialWrap(); ~QDialWrap();
NDial* getInternalInstance(); NDial* getInternalInstance();
//class constructor // class constructor
static Napi::FunctionReference constructor; static Napi::FunctionReference constructor;
//wrapped methods // wrapped methods
Napi::Value setNotchesVisible(const Napi::CallbackInfo& info); Napi::Value setNotchesVisible(const Napi::CallbackInfo& info);
Napi::Value setWrapping(const Napi::CallbackInfo& info); Napi::Value setWrapping(const Napi::CallbackInfo& info);
Napi::Value setNotchTarget(const Napi::CallbackInfo& info); Napi::Value setNotchTarget(const Napi::CallbackInfo& info);
@ -27,5 +28,3 @@ class QDialWrap : public Napi::ObjectWrap<QDialWrap>{
QABSTRACTSLIDER_WRAPPED_METHODS_DECLARATION QABSTRACTSLIDER_WRAPPED_METHODS_DECLARATION
}; };

11
src/cpp/include/nodegui/QtWidgets/QGridLayout/qgridlayout_wrap.h
View File

@ -2,23 +2,24 @@
#include <napi.h> #include <napi.h>
#include <stdlib.h> #include <stdlib.h>
#include <QGridLayout> #include <QGridLayout>
#include "QtWidgets/QLayout/qlayout_macro.h" #include "QtWidgets/QLayout/qlayout_macro.h"
class QGridLayoutWrap : public Napi::ObjectWrap<QGridLayoutWrap>{ class QGridLayoutWrap : public Napi::ObjectWrap<QGridLayoutWrap> {
private: private:
std::unique_ptr<QGridLayout> instance; std::unique_ptr<QGridLayout> instance;
public: public:
static Napi::Object init(Napi::Env env, Napi::Object exports); static Napi::Object init(Napi::Env env, Napi::Object exports);
QGridLayoutWrap(const Napi::CallbackInfo& info); QGridLayoutWrap(const Napi::CallbackInfo& info);
~QGridLayoutWrap(); ~QGridLayoutWrap();
QGridLayout* getInternalInstance(); QGridLayout* getInternalInstance();
//class constructor // class constructor
static Napi::FunctionReference constructor; static Napi::FunctionReference constructor;
//wrapped methods // wrapped methods
Napi::Value addWidget(const Napi::CallbackInfo& info); Napi::Value addWidget(const Napi::CallbackInfo& info);
Napi::Value removeWidget(const Napi::CallbackInfo& info); Napi::Value removeWidget(const Napi::CallbackInfo& info);
QLAYOUT_WRAPPED_METHODS_DECLARATION QLAYOUT_WRAPPED_METHODS_DECLARATION
}; };

Some files were not shown because too many files have changed in this diff Show More