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,
};

1580
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

18
package.json
View File

@ -20,7 +20,9 @@
"postinstall": "npm run build:addon",
"build": "tsc && npm run build:addon",
"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]*",
"lint:ts": "tsc --noEmit && eslint './src/**/*.{ts,tsx}' --fix"
},
"dependencies": {
"@nodegui/qode": "^1.0.5",
@ -34,10 +36,22 @@
"@types/bindings": "^1.3.0",
"@types/jest": "^24.0.18",
"@types/node": "^12.0.2",
"@typescript-eslint/eslint-plugin": "^2.6.1",
"@typescript-eslint/parser": "^2.6.1",
"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.17.1",
"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"
}
}
}

53
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
// originating logger.
#include <memory>
#include <mutex>
#include "spdlog/async_logger.h"
#include "spdlog/details/registry.h"
#include "spdlog/details/thread_pool.h"
#include <memory>
#include <mutex>
namespace spdlog {
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.
// if a global thread pool doesn't already exist, create it with default queue
// size of 8192 items and single thread.
template<async_overflow_policy OverflowPolicy = async_overflow_policy::block>
struct async_factory_impl
{
template<typename Sink, typename... SinkArgs>
static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&... args)
{
template <async_overflow_policy OverflowPolicy = async_overflow_policy::block>
struct async_factory_impl {
template <typename Sink, typename... SinkArgs>
static std::shared_ptr<async_logger> create(std::string logger_name,
SinkArgs &&... args) {
auto &registry_inst = details::registry::instance();
// create global thread pool if not already exists..
std::lock_guard<std::recursive_mutex> tp_lock(registry_inst.tp_mutex());
auto tp = registry_inst.get_tp();
if (tp == nullptr)
{
tp = std::make_shared<details::thread_pool>(details::default_async_q_size, 1);
if (tp == nullptr) {
tp = std::make_shared<details::thread_pool>(details::default_async_q_size,
1);
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);
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_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>
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)...);
template <typename Sink, typename... SinkArgs>
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)...);
}
template<typename Sink, typename... SinkArgs>
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)...);
template <typename Sink, typename... SinkArgs>
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)...);
}
// 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);
details::registry::instance().set_tp(std::move(tp));
}
// 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();
}
} // namespace spdlog

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

@ -19,18 +19,17 @@
// Upon destruction, logs all remaining messages in the queue before
// destructing..
#include "spdlog/common.h"
#include "spdlog/logger.h"
#include <chrono>
#include <memory>
#include <string>
#include "spdlog/common.h"
#include "spdlog/logger.h"
namespace spdlog {
// Async overflow policy - block by default.
enum class async_overflow_policy
{
enum class async_overflow_policy {
block, // Block until message can be enqueued
overrun_oldest // Discard oldest message in the queue if full when trying to
// add new item.
@ -40,31 +39,37 @@ namespace details {
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;
public:
template<typename It>
async_logger(std::string logger_name, It begin, It end, std::weak_ptr<details::thread_pool> tp,
public:
template <typename It>
async_logger(
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(
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(
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;
protected:
protected:
void sink_it_(details::log_msg &msg) override;
void flush_() override;
void backend_log_(const details::log_msg &incoming_log_msg);
void backend_flush_();
private:
private:
std::weak_ptr<details::thread_pool> thread_pool_;
async_overflow_policy overflow_policy_;
};

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

@ -5,26 +5,25 @@
#pragma once
#include "spdlog/tweakme.h"
#include <atomic>
#include <chrono>
#include <cstring>
#include <functional>
#include <initializer_list>
#include <memory>
#include <stdexcept>
#include <string>
#include <cstring>
#include <type_traits>
#include <unordered_map>
#include "spdlog/tweakme.h"
#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
#include <codecvt>
#include <locale>
#endif
#include "spdlog/details/null_mutex.h"
#include "spdlog/fmt/fmt.h"
// visual studio upto 2013 does not support noexcept nor constexpr
@ -108,8 +107,7 @@ using level_t = std::atomic<int>;
// Log level enum
namespace level {
enum level_enum
{
enum level_enum {
trace = SPDLOG_LEVEL_TRACE,
debug = SPDLOG_LEVEL_DEBUG,
info = SPDLOG_LEVEL_INFO,
@ -121,31 +119,26 @@ enum level_enum
#if !defined(SPDLOG_LEVEL_NAMES)
#define SPDLOG_LEVEL_NAMES \
{ \
"trace", "debug", "info", "warning", "error", "critical", "off" \
}
{ "trace", "debug", "info", "warning", "error", "critical", "off" }
#endif
static string_view_t level_string_views[] SPDLOG_LEVEL_NAMES;
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];
}
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];
}
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;
for (const auto &level_str : level_string_views)
{
if (level_str == name)
{
for (const auto &level_str : level_string_views) {
if (level_str == name) {
return static_cast<level::level_enum>(level);
}
level++;
@ -160,8 +153,7 @@ using level_hasher = std::hash<int>;
// Pattern time - specific time getting to use for pattern_formatter.
// local time by default
//
enum class pattern_time_type
{
enum class pattern_time_type {
local, // log localtime
utc // log utc
};
@ -169,27 +161,19 @@ enum class pattern_time_type
//
// Log exception
//
class spdlog_ex : public std::exception
{
public:
explicit spdlog_ex(std::string msg)
: msg_(std::move(msg))
{
}
class spdlog_ex : public std::exception {
public:
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::format_system_error(outbuf, last_errno, msg);
msg_ = fmt::to_string(outbuf);
}
const char *what() const SPDLOG_NOEXCEPT override
{
return msg_.c_str();
}
const char *what() const SPDLOG_NOEXCEPT override { return msg_.c_str(); }
private:
private:
std::string msg_;
};
@ -202,25 +186,15 @@ using filename_t = std::wstring;
using filename_t = std::string;
#endif
struct source_loc
{
SPDLOG_CONSTEXPR source_loc()
: filename{""}
, line{0}
, funcname{""}
{
}
SPDLOG_CONSTEXPR source_loc(const char *filename, int line, const char *funcname)
: filename{filename}
, line{static_cast<uint32_t>(line)}
, funcname{funcname}
{
}
struct source_loc {
SPDLOG_CONSTEXPR source_loc() : filename{""}, line{0}, 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
{
return line == 0;
}
SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT { return line == 0; }
const char *filename;
uint32_t line;
const char *funcname;
@ -232,9 +206,8 @@ namespace details {
#if __cplusplus >= 201402L // C++14 and beyond
using std::make_unique;
#else
template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args &&... args)
{
template <typename T, typename... Args>
std::unique_ptr<T> make_unique(Args &&... args) {
static_assert(!std::is_array<T>::value, "arrays not supported");
return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

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

@ -8,58 +8,52 @@
// async logger implementation
// uses a thread pool to perform the actual logging
#include "spdlog/details/thread_pool.h"
#include <chrono>
#include <memory>
#include <string>
template<typename It>
#include "spdlog/details/thread_pool.h"
template <typename It>
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)
: logger(std::move(logger_name), begin, end)
, thread_pool_(std::move(tp))
, overflow_policy_(overflow_policy)
{
}
std::string logger_name, It begin, It end,
std::weak_ptr<details::thread_pool> tp,
async_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(
std::string logger_name, sinks_init_list sinks_list, 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)
{
}
std::string logger_name, sinks_init_list sinks_list,
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(
std::string logger_name, sink_ptr single_sink, 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)
{
}
std::string logger_name, sink_ptr single_sink,
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
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)
incr_msg_counter_(msg);
#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_);
}
else
{
} else {
throw spdlog_ex("async log: thread pool doesn't exist anymore");
}
}
// send flush request to the thread pool
inline void spdlog::async_logger::flush_()
{
if (auto pool_ptr = thread_pool_.lock())
{
inline void spdlog::async_logger::flush_() {
if (auto pool_ptr = thread_pool_.lock()) {
pool_ptr->post_flush(shared_from_this(), overflow_policy_);
}
else
{
} else {
throw spdlog_ex("async flush: thread pool doesn't exist anymore");
}
}
@ -67,41 +61,36 @@ inline void spdlog::async_logger::flush_()
//
// 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)
{
try
{
for (auto &s : sinks_)
{
if (s->should_log(incoming_log_msg.level))
{
inline void spdlog::async_logger::backend_log_(
const details::log_msg &incoming_log_msg) {
try {
for (auto &s : sinks_) {
if (s->should_log(incoming_log_msg.level)) {
s->log(incoming_log_msg);
}
}
}
SPDLOG_CATCH_AND_HANDLE
if (should_flush_(incoming_log_msg))
{
if (should_flush_(incoming_log_msg)) {
backend_flush_();
}
}
inline void spdlog::async_logger::backend_flush_()
{
try
{
for (auto &sink : sinks_)
{
inline void spdlog::async_logger::backend_flush_() {
try {
for (auto &sink : sinks_) {
sink->flush();
}
}
SPDLOG_CATCH_AND_HANDLE
}
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_);
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_);
cloned->set_level(this->level());
cloned->flush_on(this->flush_level());

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

@ -10,21 +10,18 @@
namespace spdlog {
namespace details {
template<typename T>
class circular_q
{
public:
template <typename T>
class circular_q {
public:
using item_type = T;
explicit circular_q(size_t max_items)
: 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)
{
void push_back(T &&item) {
v_[tail_] = std::move(item);
tail_ = (tail_ + 1) % max_items_;
@ -37,29 +34,21 @@ public:
// Pop item from front.
// If there are no elements in the container, the behavior is undefined.
void pop_front(T &popped_item)
{
void pop_front(T &popped_item) {
popped_item = std::move(v_[head_]);
head_ = (head_ + 1) % max_items_;
}
bool empty()
{
return tail_ == head_;
}
bool empty() { return tail_ == head_; }
bool full()
{
bool full() {
// head is ahead of the tail by 1
return ((tail_ + 1) % max_items_) == head_;
}
size_t overrun_counter() const
{
return overrun_counter_;
}
size_t overrun_counter() const { return overrun_counter_; }
private:
private:
size_t max_items_;
typename std::vector<T>::size_type head_ = 0;
typename std::vector<T>::size_type tail_ = 0;

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

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

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

@ -6,11 +6,8 @@
#pragma once
// Helper class for file sinks.
// When failing to open a file, retry several times(5) with a delay interval(10 ms).
// Throw spdlog_ex exception on errors.
#include "spdlog/details/log_msg.h"
#include "spdlog/details/os.h"
// When failing to open a file, retry several times(5) with a delay interval(10
// ms). Throw spdlog_ex exception on errors.
#include <cerrno>
#include <chrono>
@ -19,13 +16,14 @@
#include <thread>
#include <tuple>
#include "spdlog/details/log_msg.h"
#include "spdlog/details/os.h"
namespace spdlog {
namespace details {
class file_helper
{
public:
class file_helper {
public:
const int open_tries = 5;
const int open_interval = 10;
@ -34,78 +32,61 @@ public:
file_helper(const file_helper &) = delete;
file_helper &operator=(const file_helper &) = delete;
~file_helper()
{
close();
}
~file_helper() { close(); }
void open(const filename_t &fname, bool truncate = false)
{
void open(const filename_t &fname, bool truncate = false) {
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))
{
for (int tries = 0; tries < open_tries; ++tries) {
if (!os::fopen_s(&fd_, fname, mode)) {
return;
}
details::os::sleep_for_millis(open_interval);
}
throw spdlog_ex("Failed opening file " + os::filename_to_str(_filename) + " for writing", errno);
throw spdlog_ex("Failed opening file " + os::filename_to_str(_filename) +
" for writing",
errno);
}
void reopen(bool truncate)
{
if (_filename.empty())
{
void reopen(bool truncate) {
if (_filename.empty()) {
throw spdlog_ex("Failed re opening file - was not opened before");
}
open(_filename, truncate);
}
void flush()
{
std::fflush(fd_);
}
void flush() { std::fflush(fd_); }
void close()
{
if (fd_ != nullptr)
{
void close() {
if (fd_ != nullptr) {
std::fclose(fd_);
fd_ = nullptr;
}
}
void write(const fmt::memory_buffer &buf)
{
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);
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));
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;
}
const filename_t &filename() const { return _filename; }
static bool file_exists(const filename_t &fname)
{
static bool file_exists(const filename_t &fname) {
return os::file_exists(fname);
}
@ -122,21 +103,20 @@ public:
// ".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)
{
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)
{
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)
{
if (folder_index != filename_t::npos && folder_index >= ext_index - 1) {
return std::make_tuple(fname, spdlog::filename_t());
}
@ -144,7 +124,7 @@ public:
return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index));
}
private:
private:
std::FILE *fd_{nullptr};
filename_t _filename;
};

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

@ -6,6 +6,7 @@
#include <chrono>
#include <type_traits>
#include "spdlog/fmt/fmt.h"
// Some fmt helpers to efficiently format and pad ints and strings
@ -13,103 +14,93 @@ namespace spdlog {
namespace details {
namespace fmt_helper {
template<size_t Buffer_Size>
inline spdlog::string_view_t to_string_view(const fmt::basic_memory_buffer<char, Buffer_Size> &buf) SPDLOG_NOEXCEPT
{
template <size_t Buffer_Size>
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());
}
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)
{
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) {
auto *buf_ptr = buf.data();
dest.append(buf_ptr, buf_ptr + buf.size());
}
template<size_t Buffer_Size>
inline void append_string_view(spdlog::string_view_t view, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
{
template <size_t Buffer_Size>
inline void append_string_view(
spdlog::string_view_t view,
fmt::basic_memory_buffer<char, Buffer_Size> &dest) {
auto *buf_ptr = view.data();
if (buf_ptr != nullptr)
{
if (buf_ptr != nullptr) {
dest.append(buf_ptr, buf_ptr + view.size());
}
}
template<typename T, size_t Buffer_Size>
inline void append_int(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
{
template <typename T, size_t Buffer_Size>
inline void append_int(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest) {
fmt::format_int i(n);
dest.append(i.data(), i.data() + i.size());
}
template<typename T>
inline unsigned count_digits(T n)
{
using count_type = typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type;
return static_cast<unsigned>(fmt::internal::count_digits(static_cast<count_type>(n)));
template <typename T>
inline unsigned count_digits(T n) {
using count_type = typename std::conditional<(sizeof(T) > sizeof(uint32_t)),
uint64_t, uint32_t>::type;
return static_cast<unsigned>(
fmt::internal::count_digits(static_cast<count_type>(n)));
}
template<size_t Buffer_Size>
inline void pad2(int n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
{
if (n > 99)
{
template <size_t Buffer_Size>
inline void pad2(int n, fmt::basic_memory_buffer<char, Buffer_Size> &dest) {
if (n > 99) {
append_int(n, dest);
}
else if (n > 9) // 10-99
} 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
} 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)
} 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)
{
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)
{
if (width > digits) {
const char *zeroes = "0000000000000000000";
dest.append(zeroes, zeroes + width - digits);
}
append_int(n, dest);
}
template<typename T, size_t Buffer_Size>
inline void pad3(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
{
template <typename T, size_t Buffer_Size>
inline void pad3(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest) {
pad_uint(n, 3, dest);
}
template<typename T, size_t Buffer_Size>
inline void pad6(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
{
template <typename T, size_t Buffer_Size>
inline void pad6(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest) {
pad_uint(n, 6, dest);
}
template<typename T, size_t Buffer_Size>
inline void pad9(T n, fmt::basic_memory_buffer<char, Buffer_Size> &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.
// e.g.
// fraction<std::milliseconds>(tp) -> will return the millis part of the second
template<typename ToDuration>
inline ToDuration time_fraction(const log_clock::time_point &tp)
{
template <typename ToDuration>
inline ToDuration time_fraction(const log_clock::time_point &tp) {
using std::chrono::duration_cast;
using std::chrono::seconds;
auto duration = tp.time_since_epoch();

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

@ -5,36 +5,36 @@
#pragma once
#include "spdlog/common.h"
#include "spdlog/details/os.h"
#include <string>
#include <utility>
#include "spdlog/common.h"
#include "spdlog/details/os.h"
namespace spdlog {
namespace details {
struct log_msg
{
log_msg(source_loc loc, const std::string *loggers_name, level::level_enum lvl, string_view_t view)
: logger_name(loggers_name)
, level(lvl)
struct log_msg {
log_msg(source_loc loc, const std::string *loggers_name,
level::level_enum lvl, string_view_t view)
: logger_name(loggers_name),
level(lvl)
#ifndef SPDLOG_NO_DATETIME
, time(os::now())
,
time(os::now())
#endif
#ifndef SPDLOG_NO_THREAD_ID
, thread_id(os::thread_id())
,
thread_id(os::thread_id())
#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(source_loc{}, loggers_name, lvl, view)
{
}
log_msg(const std::string *loggers_name, level::level_enum lvl,
string_view_t view)
: log_msg(source_loc{}, loggers_name, lvl, view) {}
log_msg(const log_msg &other) = default;

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

@ -5,68 +5,59 @@
#pragma once
#include "spdlog/details/fmt_helper.h"
#include <memory>
#include <string>
#include "spdlog/details/fmt_helper.h"
#define SPDLOG_CATCH_AND_HANDLE \
catch (const std::exception &ex) \
{ \
catch (const std::exception &ex) { \
err_handler_(ex.what()); \
} \
catch (...) \
{ \
catch (...) { \
err_handler_("Unknown exception in logger"); \
}
// create logger with given name, sinks and the default pattern formatter
// 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)
: name_(std::move(logger_name))
, sinks_(begin, end)
{
}
: name_(std::move(logger_name)), sinks_(begin, end) {}
// ctor with sinks as init list
inline spdlog::logger::logger(std::string logger_name, sinks_init_list sinks_list)
: logger(std::move(logger_name), sinks_list.begin(), sinks_list.end())
{
}
inline spdlog::logger::logger(std::string logger_name,
sinks_init_list sinks_list)
: logger(std::move(logger_name), sinks_list.begin(), sinks_list.end()) {}
// ctor with single sink
inline spdlog::logger::logger(std::string logger_name, spdlog::sink_ptr single_sink)
: logger(std::move(logger_name), {std::move(single_sink)})
{
}
inline spdlog::logger::logger(std::string logger_name,
spdlog::sink_ptr single_sink)
: logger(std::move(logger_name), {std::move(single_sink)}) {}
inline spdlog::logger::~logger() = default;
inline void spdlog::logger::set_formatter(std::unique_ptr<spdlog::formatter> f)
{
for (auto &sink : sinks_)
{
inline void spdlog::logger::set_formatter(
std::unique_ptr<spdlog::formatter> f) {
for (auto &sink : sinks_) {
sink->set_formatter(f->clone());
}
}
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);
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);
set_formatter(std::move(new_formatter));
}
template<typename... Args>
inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const char *fmt, const Args &... args)
{
if (!should_log(lvl))
{
template <typename... Args>
inline void spdlog::logger::log(source_loc source, level::level_enum lvl,
const char *fmt, const Args &... args) {
if (!should_log(lvl)) {
return;
}
try
{
try {
using details::fmt_helper::to_string_view;
fmt::memory_buffer buf;
fmt::format_to(buf, fmt, args...);
@ -76,62 +67,60 @@ inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const
SPDLOG_CATCH_AND_HANDLE
}
template<typename... Args>
inline void spdlog::logger::log(level::level_enum lvl, const char *fmt, const Args &... args)
{
template <typename... Args>
inline void spdlog::logger::log(level::level_enum lvl, const char *fmt,
const Args &... args) {
log(source_loc{}, lvl, fmt, args...);
}
inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const char *msg)
{
if (!should_log(lvl))
{
inline void spdlog::logger::log(source_loc source, level::level_enum lvl,
const char *msg) {
if (!should_log(lvl)) {
return;
}
try
{
try {
details::log_msg log_msg(source, &name_, lvl, spdlog::string_view_t(msg));
sink_it_(log_msg);
}
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);
}
template<class T, typename std::enable_if<std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const T &msg)
{
if (!should_log(lvl))
{
template <class T,
typename std::enable_if<
std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
inline void spdlog::logger::log(source_loc source, level::level_enum lvl,
const T &msg) {
if (!should_log(lvl)) {
return;
}
try
{
try {
details::log_msg log_msg(source, &name_, lvl, msg);
sink_it_(log_msg);
}
SPDLOG_CATCH_AND_HANDLE
}
template<class T, typename std::enable_if<std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
inline void spdlog::logger::log(level::level_enum lvl, const T &msg)
{
template <class T,
typename std::enable_if<
std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
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 *>
inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const T &msg)
{
if (!should_log(lvl))
{
template <class T,
typename std::enable_if<
!std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
inline void spdlog::logger::log(source_loc source, level::level_enum lvl,
const T &msg) {
if (!should_log(lvl)) {
return;
}
try
{
try {
using details::fmt_helper::to_string_view;
fmt::memory_buffer buf;
fmt::format_to(buf, "{}", msg);
@ -141,117 +130,103 @@ inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const
SPDLOG_CATCH_AND_HANDLE
}
template<class T, typename std::enable_if<!std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
inline void spdlog::logger::log(level::level_enum lvl, const T &msg)
{
template <class T,
typename std::enable_if<
!std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
inline void spdlog::logger::log(level::level_enum lvl, const T &msg) {
log(source_loc{}, lvl, msg);
}
template<typename... Args>
inline void spdlog::logger::trace(const char *fmt, const Args &... args)
{
template <typename... Args>
inline void spdlog::logger::trace(const char *fmt, const Args &... args) {
log(level::trace, fmt, args...);
}
template<typename... Args>
inline void spdlog::logger::debug(const char *fmt, const Args &... args)
{
template <typename... Args>
inline void spdlog::logger::debug(const char *fmt, const Args &... args) {
log(level::debug, fmt, args...);
}
template<typename... Args>
inline void spdlog::logger::info(const char *fmt, const Args &... args)
{
template <typename... Args>
inline void spdlog::logger::info(const char *fmt, const Args &... args) {
log(level::info, fmt, args...);
}
template<typename... Args>
inline void spdlog::logger::warn(const char *fmt, const Args &... args)
{
template <typename... Args>
inline void spdlog::logger::warn(const char *fmt, const Args &... args) {
log(level::warn, fmt, args...);
}
template<typename... Args>
inline void spdlog::logger::error(const char *fmt, const Args &... args)
{
template <typename... Args>
inline void spdlog::logger::error(const char *fmt, const Args &... args) {
log(level::err, fmt, args...);
}
template<typename... Args>
inline void spdlog::logger::critical(const char *fmt, const Args &... args)
{
template <typename... Args>
inline void spdlog::logger::critical(const char *fmt, const Args &... args) {
log(level::critical, fmt, args...);
}
template<typename T>
inline void spdlog::logger::trace(const T &msg)
{
template <typename T>
inline void spdlog::logger::trace(const T &msg) {
log(level::trace, msg);
}
template<typename T>
inline void spdlog::logger::debug(const T &msg)
{
template <typename T>
inline void spdlog::logger::debug(const T &msg) {
log(level::debug, msg);
}
template<typename T>
inline void spdlog::logger::info(const T &msg)
{
template <typename T>
inline void spdlog::logger::info(const T &msg) {
log(level::info, msg);
}
template<typename T>
inline void spdlog::logger::warn(const T &msg)
{
template <typename T>
inline void spdlog::logger::warn(const T &msg) {
log(level::warn, msg);
}
template<typename T>
inline void spdlog::logger::error(const T &msg)
{
template <typename T>
inline void spdlog::logger::error(const T &msg) {
log(level::err, msg);
}
template<typename T>
inline void spdlog::logger::critical(const T &msg)
{
template <typename T>
inline void spdlog::logger::critical(const T &msg) {
log(level::critical, msg);
}
#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());
if (wbuf_size == 0)
{
if (wbuf_size == 0) {
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);
::WideCharToMultiByte(CP_UTF8, 0, wbuf.data(), wbuf_size, &target.data()[0], result_size, NULL, NULL);
}
else
{
throw spdlog::spdlog_ex(fmt::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
::WideCharToMultiByte(CP_UTF8, 0, wbuf.data(), wbuf_size, &target.data()[0],
result_size, NULL, NULL);
} else {
throw spdlog::spdlog_ex(fmt::format(
"WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
}
}
template<typename... Args>
inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const wchar_t *fmt, const Args &... args)
{
if (!should_log(lvl))
{
template <typename... Args>
inline void spdlog::logger::log(source_loc source, level::level_enum lvl,
const wchar_t *fmt, const Args &... args) {
if (!should_log(lvl)) {
return;
}
try
{
try {
// format to wmemory_buffer and convert to utf8
using details::fmt_helper::to_string_view;
fmt::wmemory_buffer wbuf;
@ -264,45 +239,39 @@ inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const
SPDLOG_CATCH_AND_HANDLE
}
template<typename... Args>
inline void spdlog::logger::log(level::level_enum lvl, const wchar_t *fmt, const Args &... args)
{
template <typename... Args>
inline void spdlog::logger::log(level::level_enum lvl, const wchar_t *fmt,
const Args &... args) {
log(source_loc{}, lvl, fmt, args...);
}
template<typename... Args>
inline void spdlog::logger::trace(const wchar_t *fmt, const Args &... args)
{
template <typename... Args>
inline void spdlog::logger::trace(const wchar_t *fmt, const Args &... args) {
log(level::trace, fmt, args...);
}
template<typename... Args>
inline void spdlog::logger::debug(const wchar_t *fmt, const Args &... args)
{
template <typename... Args>
inline void spdlog::logger::debug(const wchar_t *fmt, const Args &... args) {
log(level::debug, fmt, args...);
}
template<typename... Args>
inline void spdlog::logger::info(const wchar_t *fmt, const Args &... args)
{
template <typename... Args>
inline void spdlog::logger::info(const wchar_t *fmt, const Args &... args) {
log(level::info, fmt, args...);
}
template<typename... Args>
inline void spdlog::logger::warn(const wchar_t *fmt, const Args &... args)
{
template <typename... Args>
inline void spdlog::logger::warn(const wchar_t *fmt, const Args &... args) {
log(level::warn, fmt, args...);
}
template<typename... Args>
inline void spdlog::logger::error(const wchar_t *fmt, const Args &... args)
{
template <typename... Args>
inline void spdlog::logger::error(const wchar_t *fmt, const Args &... args) {
log(level::err, fmt, args...);
}
template<typename... Args>
inline void spdlog::logger::critical(const wchar_t *fmt, const Args &... args)
{
template <typename... Args>
inline void spdlog::logger::critical(const wchar_t *fmt, const Args &... args) {
log(level::critical, fmt, args...);
}
@ -311,63 +280,53 @@ inline void spdlog::logger::critical(const wchar_t *fmt, const Args &... args)
//
// name and level
//
inline const std::string &spdlog::logger::name() const
{
return name_;
}
inline const std::string &spdlog::logger::name() const { return name_; }
inline void spdlog::logger::set_level(spdlog::level::level_enum log_level)
{
inline void spdlog::logger::set_level(spdlog::level::level_enum log_level) {
level_.store(log_level);
}
inline void spdlog::logger::set_error_handler(spdlog::log_err_handler err_handler)
{
inline void spdlog::logger::set_error_handler(
spdlog::log_err_handler err_handler) {
err_handler_ = std::move(err_handler);
}
inline spdlog::log_err_handler spdlog::logger::error_handler() const
{
inline spdlog::log_err_handler spdlog::logger::error_handler() const {
return err_handler_;
}
inline void spdlog::logger::flush()
{
try
{
inline void spdlog::logger::flush() {
try {
flush_();
}
SPDLOG_CATCH_AND_HANDLE
}
inline void spdlog::logger::flush_on(level::level_enum log_level)
{
inline void spdlog::logger::flush_on(level::level_enum log_level) {
flush_level_.store(log_level);
}
inline spdlog::level::level_enum spdlog::logger::flush_level() const
{
return static_cast<spdlog::level::level_enum>(flush_level_.load(std::memory_order_relaxed));
inline spdlog::level::level_enum spdlog::logger::flush_level() const {
return static_cast<spdlog::level::level_enum>(
flush_level_.load(std::memory_order_relaxed));
}
inline bool spdlog::logger::should_flush_(const details::log_msg &msg)
{
inline bool spdlog::logger::should_flush_(const details::log_msg &msg) {
auto flush_level = flush_level_.load(std::memory_order_relaxed);
return (msg.level >= flush_level) && (msg.level != level::off);
}
inline spdlog::level::level_enum spdlog::logger::default_level()
{
inline spdlog::level::level_enum spdlog::logger::default_level() {
return static_cast<spdlog::level::level_enum>(SPDLOG_ACTIVE_LEVEL);
}
inline spdlog::level::level_enum spdlog::logger::level() const
{
return static_cast<spdlog::level::level_enum>(level_.load(std::memory_order_relaxed));
inline spdlog::level::level_enum spdlog::logger::level() const {
return static_cast<spdlog::level::level_enum>(
level_.load(std::memory_order_relaxed));
}
inline bool spdlog::logger::should_log(spdlog::level::level_enum msg_level) const
{
inline bool spdlog::logger::should_log(
spdlog::level::level_enum msg_level) const {
return msg_level >= level_.load(std::memory_order_relaxed);
}
@ -375,65 +334,54 @@ inline bool spdlog::logger::should_log(spdlog::level::level_enum msg_level) cons
// protected virtual called at end of each user log call (if enabled) by the
// 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)
incr_msg_counter_(msg);
#endif
for (auto &sink : sinks_)
{
if (sink->should_log(msg.level))
{
for (auto &sink : sinks_) {
if (sink->should_log(msg.level)) {
sink->log(msg);
}
}
if (should_flush_(msg))
{
if (should_flush_(msg)) {
flush_();
}
}
inline void spdlog::logger::flush_()
{
for (auto &sink : sinks_)
{
inline void spdlog::logger::flush_() {
for (auto &sink : sinks_) {
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);
if (now - last_err_time_ < 60)
{
if (now - last_err_time_ < 60) {
return;
}
last_err_time_ = now;
auto tm_time = details::os::localtime(now);
char date_buf[100];
std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time);
fmt::print(stderr, "[*** LOG ERROR ***] [{}] [{}] {}\n", date_buf, name(), 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);
}
inline const std::vector<spdlog::sink_ptr> &spdlog::logger::sinks() const
{
inline const std::vector<spdlog::sink_ptr> &spdlog::logger::sinks() const {
return sinks_;
}
inline std::vector<spdlog::sink_ptr> &spdlog::logger::sinks()
{
return sinks_;
}
inline std::vector<spdlog::sink_ptr> &spdlog::logger::sinks() { return sinks_; }
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());
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());
cloned->set_level(this->level());
cloned->flush_on(this->flush_level());
cloned->set_error_handler(this->error_handler());

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

@ -12,28 +12,23 @@
// dequeue_for(..) - will block until the queue is not empty or timeout have
// passed.
#include "spdlog/details/circular_q.h"
#include <condition_variable>
#include <mutex>
#include "spdlog/details/circular_q.h"
namespace spdlog {
namespace details {
template<typename T>
class mpmc_blocking_queue
{
public:
template <typename T>
class mpmc_blocking_queue {
public:
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__
// 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_);
pop_cv_.wait(lock, [this] { return !this->q_.full(); });
@ -43,8 +38,7 @@ public:
}
// 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_);
q_.push_back(std::move(item));
@ -54,12 +48,11 @@ public:
// try to dequeue item. if no item found. wait upto timeout and try again
// 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_);
if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
{
if (!push_cv_.wait_for(lock, wait_duration,
[this] { return !this->q_.empty(); })) {
return false;
}
q_.pop_front(popped_item);
@ -73,8 +66,7 @@ public:
// so release the mutex at the very end each function.
// 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_);
pop_cv_.wait(lock, [this] { return !this->q_.full(); });
q_.push_back(std::move(item));
@ -82,8 +74,7 @@ public:
}
// 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_);
q_.push_back(std::move(item));
push_cv_.notify_one();
@ -91,11 +82,10 @@ public:
// try to dequeue item. if no item found. wait upto timeout and try again
// 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_);
if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
{
if (!push_cv_.wait_for(lock, wait_duration,
[this] { return !this->q_.empty(); })) {
return false;
}
q_.pop_front(popped_item);
@ -105,13 +95,12 @@ public:
#endif
size_t overrun_counter()
{
size_t overrun_counter() {
std::unique_lock<std::mutex> lock(queue_mutex_);
return q_.overrun_counter();
}
private:
private:
std::mutex queue_mutex_;
std::condition_variable push_cv_;
std::condition_variable pop_cv_;

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

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

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

@ -4,7 +4,8 @@
//
#pragma once
#include "../common.h"
#include <sys/stat.h>
#include <sys/types.h>
#include <algorithm>
#include <chrono>
@ -14,10 +15,10 @@
#include <ctime>
#include <functional>
#include <string>
#include <sys/stat.h>
#include <sys/types.h>
#include <thread>
#include "../common.h"
#ifdef _WIN32
#ifndef NOMINMAX
@ -57,22 +58,20 @@ namespace spdlog {
namespace details {
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
timespec ts;
::clock_gettime(CLOCK_REALTIME_COARSE, &ts);
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
return log_clock::now();
#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
std::tm tm;
localtime_s(&tm, &time_tt);
@ -83,15 +82,12 @@ inline std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
return tm;
}
inline std::tm localtime() SPDLOG_NOEXCEPT
{
inline std::tm localtime() SPDLOG_NOEXCEPT {
std::time_t now_t = time(nullptr);
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
std::tm tm;
gmtime_s(&tm, &time_tt);
@ -102,8 +98,7 @@ inline std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
return tm;
}
inline std::tm gmtime() SPDLOG_NOEXCEPT
{
inline std::tm gmtime() SPDLOG_NOEXCEPT {
std::time_t now_t = time(nullptr);
return gmtime(now_t);
}
@ -126,9 +121,7 @@ SPDLOG_CONSTEXPR static const char folder_sep = '\\';
SPDLOG_CONSTEXPR static const char folder_sep = '/';
#endif
inline void prevent_child_fd(FILE *f)
{
inline void prevent_child_fd(FILE *f) {
#ifdef _WIN32
#if !defined(__cplusplus_winrt)
auto file_handle = (HANDLE)_get_osfhandle(_fileno(f));
@ -137,16 +130,15 @@ inline void prevent_child_fd(FILE *f)
#endif
#else
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);
}
#endif
}
// 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 SPDLOG_WCHAR_FILENAMES
*fp = _wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
@ -158,16 +150,14 @@ inline bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mod
#endif
#ifdef SPDLOG_PREVENT_CHILD_FD
if (*fp != nullptr)
{
if (*fp != nullptr) {
prevent_child_fd(*fp);
}
#endif
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)
return _wremove(filename.c_str());
#else
@ -175,8 +165,8 @@ inline int remove(const filename_t &filename) SPDLOG_NOEXCEPT
#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)
return _wrename(filename1.c_str(), filename2.c_str());
#else
@ -185,15 +175,15 @@ inline int rename(const filename_t &filename1, const filename_t &filename2) SPDL
}
// 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 SPDLOG_WCHAR_FILENAMES
auto attribs = GetFileAttributesW(filename.c_str());
#else
auto attribs = GetFileAttributesA(filename.c_str());
#endif
return (attribs != INVALID_FILE_ATTRIBUTES && !(attribs & FILE_ATTRIBUTE_DIRECTORY));
return (attribs != INVALID_FILE_ATTRIBUTES &&
!(attribs & FILE_ATTRIBUTE_DIRECTORY));
#else // common linux/unix all have the stat system call
struct stat buffer;
return (stat(filename.c_str(), &buffer) == 0);
@ -201,25 +191,21 @@ inline bool file_exists(const filename_t &filename) SPDLOG_NOEXCEPT
}
// Return file size according to open FILE* object
inline size_t filesize(FILE *f)
{
if (f == nullptr)
{
inline size_t filesize(FILE *f) {
if (f == nullptr) {
throw spdlog_ex("Failed getting file size. fd is null");
}
#if defined(_WIN32) && !defined(__CYGWIN__)
int fd = _fileno(f);
#if _WIN64 // 64 bits
__int64 ret = _filelengthi64(fd);
if (ret >= 0)
{
if (ret >= 0) {
return static_cast<size_t>(ret);
}
#else // windows 32 bits
long ret = _filelength(fd);
if (ret >= 0)
{
if (ret >= 0) {
return static_cast<size_t>(ret);
}
#endif
@ -227,17 +213,16 @@ inline size_t filesize(FILE *f)
#else // unix
int fd = fileno(f);
// 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__) && \
(defined(__x86_64__) || defined(__ppc64__)) && !defined(__CYGWIN__)
struct stat64 st;
if (fstat64(fd, &st) == 0)
{
if (fstat64(fd, &st) == 0) {
return static_cast<size_t>(st.st_size);
}
#else // unix 32 bits or cygwin
struct stat st;
if (fstat(fd, &st) == 0)
{
if (fstat(fd, &st) == 0) {
return static_cast<size_t>(st.st_size);
}
#endif
@ -246,9 +231,7 @@ inline size_t filesize(FILE *f)
}
// 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
#if _WIN32_WINNT < _WIN32_WINNT_WS08
TIME_ZONE_INFORMATION tzinfo;
@ -261,12 +244,9 @@ inline int utc_minutes_offset(const std::tm &tm = details::os::localtime())
throw spdlog::spdlog_ex("Failed getting timezone info. ", errno);
int offset = -tzinfo.Bias;
if (tm.tm_isdst)
{
if (tm.tm_isdst) {
offset -= tzinfo.DaylightBias;
}
else
{
} else {
offset -= tzinfo.StandardBias;
}
return offset;
@ -274,10 +254,10 @@ inline int utc_minutes_offset(const std::tm &tm = details::os::localtime())
#if defined(sun) || defined(__sun) || defined(_AIX)
// 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris
struct helper
{
static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(), const std::tm &gmtm = details::os::gmtime())
{
struct helper {
static long int calculate_gmt_offset(
const std::tm &localtm = details::os::localtime(),
const std::tm &gmtm = details::os::gmtime()) {
int local_year = localtm.tm_year + (1900 - 1);
int gmt_year = gmtm.tm_year + (1900 - 1);
@ -287,7 +267,8 @@ inline int utc_minutes_offset(const std::tm &tm = details::os::localtime())
gmtm.tm_yday
// + intervening leap days
+ ((local_year >> 2) - (gmt_year >> 2)) - (local_year / 100 - gmt_year / 100) +
+ ((local_year >> 2) - (gmt_year >> 2)) -
(local_year / 100 - gmt_year / 100) +
((local_year / 100 >> 2) - (gmt_year / 100 >> 2))
// + difference in years * 365 */
@ -313,8 +294,7 @@ inline int utc_minutes_offset(const std::tm &tm = details::os::localtime())
// Return current thread id as size_t
// It exists because the std::this_thread::get_id() is much slower(especially
// under VS 2013)
inline size_t _thread_id() SPDLOG_NOEXCEPT
{
inline size_t _thread_id() SPDLOG_NOEXCEPT {
#ifdef _WIN32
return static_cast<size_t>(::GetCurrentThreadId());
#elif __linux__
@ -331,13 +311,13 @@ inline size_t _thread_id() SPDLOG_NOEXCEPT
pthread_threadid_np(nullptr, &tid);
return static_cast<size_t>(tid);
#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
}
// 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)
return _thread_id();
#else // cache thread id in tls
@ -348,8 +328,7 @@ inline size_t thread_id() SPDLOG_NOEXCEPT
// This is avoid msvc issue in sleep_for that happens if the clock changes.
// See https://github.com/gabime/spdlog/issues/609
inline void sleep_for_millis(int milliseconds) SPDLOG_NOEXCEPT
{
inline void sleep_for_millis(int milliseconds) SPDLOG_NOEXCEPT {
#if defined(_WIN32)
::Sleep(milliseconds);
#else
@ -360,22 +339,18 @@ inline void sleep_for_millis(int milliseconds) SPDLOG_NOEXCEPT
// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
#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;
return c.to_bytes(filename);
}
#else
#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;
}
#endif
inline int pid()
{
inline int pid() {
#ifdef _WIN32
return static_cast<int>(::GetCurrentProcessId());
#else
@ -385,31 +360,29 @@ inline int pid()
// Determine if the terminal supports colors
// Source: https://github.com/agauniyal/rang/
inline bool is_color_terminal() SPDLOG_NOEXCEPT
{
inline bool is_color_terminal() SPDLOG_NOEXCEPT {
#ifdef _WIN32
return true;
#else
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");
if (env_p == nullptr)
{
if (env_p == nullptr) {
return false;
}
static const bool result =
std::any_of(std::begin(Terms), std::end(Terms), [&](const char *term) { return std::strstr(env_p, term) != nullptr; });
static const bool result = std::any_of(
std::begin(Terms), std::end(Terms),
[&](const char *term) { return std::strstr(env_p, term) != nullptr; });
return result;
#endif
}
// Detrmine if the terminal attached
// Source: https://github.com/agauniyal/rang/
inline bool in_terminal(FILE *file) SPDLOG_NOEXCEPT
{
inline bool in_terminal(FILE *file) SPDLOG_NOEXCEPT {
#ifdef _WIN32
return _isatty(_fileno(file)) != 0;
#else

944
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

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

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

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

@ -33,174 +33,146 @@ namespace spdlog {
namespace details {
class thread_pool;
class registry
{
public:
class registry {
public:
registry(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_);
register_logger_(std::move(new_logger));
}
void initialize_logger(std::shared_ptr<logger> 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_)
{
if (err_handler_) {
new_logger->set_error_handler(err_handler_);
}
new_logger->set_level(level_);
new_logger->flush_on(flush_level_);
if (automatic_registration_)
{
if (automatic_registration_) {
register_logger_(std::move(new_logger));
}
}
std::shared_ptr<logger> get(const std::string &logger_name)
{
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::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();
}
// 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)
{
// 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)
{
if (default_logger_ != nullptr) {
loggers_.erase(default_logger_->name());
}
if (new_default_logger != nullptr)
{
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)
{
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::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)
{
// 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_)
{
for (auto &l : loggers_) {
l.second->set_formatter(formatter_->clone());
}
}
void set_level(level::level_enum log_level)
{
void set_level(level::level_enum log_level) {
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_)
{
for (auto &l : loggers_) {
l.second->set_level(log_level);
}
level_ = log_level;
}
void flush_on(level::level_enum log_level)
{
void flush_on(level::level_enum log_level) {
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_)
{
for (auto &l : loggers_) {
l.second->flush_on(log_level);
}
flush_level_ = log_level;
}
void flush_every(std::chrono::seconds interval)
{
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)
{
void set_error_handler(log_err_handler handler) {
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_)
{
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)
{
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_)
{
for (auto &l : loggers_) {
fun(l.second);
}
}
void flush_all()
{
void flush_all() {
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_)
{
for (auto &l : loggers_) {
l.second->flush();
}
}
void drop(const std::string &logger_name)
{
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)
{
if (default_logger_ && default_logger_->name() == logger_name) {
default_logger_.reset();
}
}
void drop_all()
{
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()
{
void shutdown() {
{
std::lock_guard<std::mutex> lock(flusher_mutex_);
periodic_flusher_.reset();
@ -214,30 +186,23 @@ public:
}
}
std::recursive_mutex &tp_mutex()
{
return tp_mutex_;
}
std::recursive_mutex &tp_mutex() { return tp_mutex_; }
void set_automatic_registration(bool automatic_regsistration)
{
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 &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
// 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
auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>();
#else
@ -245,7 +210,8 @@ private:
#endif
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,
std::move(color_sink));
loggers_[default_logger_name] = default_logger_;
#endif // SPDLOG_DISABLE_DEFAULT_LOGGER
@ -253,16 +219,13 @@ private:
~registry() = default;
void throw_if_exists_(const std::string &logger_name)
{
if (loggers_.find(logger_name) != loggers_.end())
{
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");
}
}
void register_logger_(std::shared_ptr<logger> new_logger)
{
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);

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

@ -1,31 +1,25 @@
#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 <memory>
#include <thread>
#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 details {
using async_logger_ptr = std::shared_ptr<spdlog::async_logger>;
enum class async_msg_type
{
log,
flush,
terminate
};
enum class async_msg_type { log, flush, terminate };
// Async msg to move to/from the queue
// Movable only. should never be copied
struct async_msg
{
struct async_msg {
async_msg_type msg_type;
level::level_enum level;
log_clock::time_point time;
@ -44,19 +38,17 @@ struct async_msg
// support for vs2013 move
#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
: msg_type(other.msg_type),
level(other.level),
time(other.time),
thread_id(other.thread_id),
raw(move(other.raw)),
msg_id(other.msg_id),
source(other.source),
worker_ptr(std::move(other.worker_ptr))
{
}
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;
level = other.level;
time = other.time;
@ -73,38 +65,33 @@ struct async_msg
#endif
// construct from log_msg with given type
async_msg(async_logger_ptr &&worker, async_msg_type the_type, details::log_msg &m)
: msg_type(the_type)
, level(m.level)
, time(m.time)
, thread_id(m.thread_id)
, msg_id(m.msg_id)
, source(m.source)
, worker_ptr(std::move(worker))
{
async_msg(async_logger_ptr &&worker, async_msg_type the_type,
details::log_msg &m)
: msg_type(the_type),
level(m.level),
time(m.time),
thread_id(m.thread_id),
msg_id(m.msg_id),
source(m.source),
worker_ptr(std::move(worker)) {
fmt_helper::append_string_view(m.payload, raw);
}
async_msg(async_logger_ptr &&worker, async_msg_type the_type)
: msg_type(the_type)
, level(level::off)
, time()
, thread_id(0)
, msg_id(0)
, source()
, worker_ptr(std::move(worker))
{
}
: msg_type(the_type),
level(level::off),
time(),
thread_id(0),
msg_id(0),
source(),
worker_ptr(std::move(worker)) {}
explicit async_msg(async_msg_type the_type)
: async_msg(nullptr, the_type)
{
}
explicit async_msg(async_msg_type the_type) : async_msg(nullptr, the_type) {}
// copy into log_msg
log_msg to_log_msg()
{
log_msg msg(&worker_ptr->name(), level, string_view_t(raw.data(), raw.size()));
log_msg to_log_msg() {
log_msg msg(&worker_ptr->name(), level,
string_view_t(raw.data(), raw.size()));
msg.time = time;
msg.thread_id = thread_id;
msg.msg_id = msg_id;
@ -115,117 +102,98 @@ struct async_msg
}
};
class thread_pool
{
public:
class thread_pool {
public:
using item_type = async_msg;
using q_type = details::mpmc_blocking_queue<item_type>;
thread_pool(size_t q_max_items, size_t threads_n)
: q_(q_max_items)
{
thread_pool(size_t q_max_items, size_t threads_n) : q_(q_max_items) {
// std::cout << "thread_pool() q_size_bytes: " << q_size_bytes <<
// "\tthreads_n: " << threads_n << std::endl;
if (threads_n == 0 || threads_n > 1000)
{
throw spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid "
if (threads_n == 0 || threads_n > 1000) {
throw spdlog_ex(
"spdlog::thread_pool(): invalid threads_n param (valid "
"range is 1-1000)");
}
for (size_t i = 0; i < threads_n; i++)
{
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);
~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_)
{
for (auto &t : threads_) {
t.join();
}
}
catch (...)
{
} 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)
{
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);
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();
}
size_t overrun_counter() { return q_.overrun_counter(); }
private:
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)
{
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
{
} else {
q_.enqueue_nowait(std::move(new_msg));
}
}
void worker_loop_()
{
while (process_next_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_()
{
bool process_next_msg_() {
async_msg incoming_async_msg;
bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10));
if (!dequeued)
{
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:
{
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:
{
case async_msg_type::flush: {
incoming_async_msg.worker_ptr->backend_flush_();
return true;
}
case async_msg_type::terminate:
{
case async_msg_type::terminate: {
return false;
}
}

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

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

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

@ -8,17 +8,17 @@
#ifndef FMT_CHRONO_H_
#define FMT_CHRONO_H_
#include "format.h"
#include "locale.h"
#include <chrono>
#include <ctime>
#include <locale>
#include <sstream>
#include "format.h"
#include "locale.h"
FMT_BEGIN_NAMESPACE
namespace internal{
namespace internal {
enum class numeric_system {
standard,
@ -28,8 +28,9 @@ enum class numeric_system {
// Parses a put_time-like format string and invokes handler actions.
template <typename Char, typename Handler>
FMT_CONSTEXPR const Char *parse_chrono_format(
const Char *begin, const Char *end, Handler &&handler) {
FMT_CONSTEXPR const Char *parse_chrono_format(const Char *begin,
const Char *end,
Handler &&handler) {
auto ptr = begin;
while (ptr != end) {
auto c = *ptr;
@ -38,11 +39,9 @@ FMT_CONSTEXPR const Char *parse_chrono_format(
++ptr;
continue;
}
if (begin != ptr)
handler.on_text(begin, ptr);
if (begin != ptr) handler.on_text(begin, ptr);
++ptr; // consume '%'
if (ptr == end)
throw format_error("invalid format");
if (ptr == end) throw format_error("invalid format");
c = *ptr++;
switch (c) {
case '%':
@ -127,8 +126,7 @@ FMT_CONSTEXPR const Char *parse_chrono_format(
break;
// Alternative representation:
case 'E': {
if (ptr == end)
throw format_error("invalid format");
if (ptr == end) throw format_error("invalid format");
c = *ptr++;
switch (c) {
case 'c':
@ -146,8 +144,7 @@ FMT_CONSTEXPR const Char *parse_chrono_format(
break;
}
case 'O':
if (ptr == end)
throw format_error("invalid format");
if (ptr == end) throw format_error("invalid format");
c = *ptr++;
switch (c) {
case 'w':
@ -177,8 +174,7 @@ FMT_CONSTEXPR const Char *parse_chrono_format(
}
begin = ptr;
}
if (begin != ptr)
handler.on_text(begin, ptr);
if (begin != ptr) handler.on_text(begin, ptr);
return ptr;
}
@ -213,7 +209,8 @@ struct chrono_format_checker {
template <typename Int>
inline int to_int(Int value) {
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);
}
@ -251,8 +248,7 @@ struct chrono_formatter {
typedef typename int_traits<int>::main_type main_type;
main_type n = to_unsigned(value);
int num_digits = internal::count_digits(n);
if (width > num_digits)
out = std::fill_n(out, width - num_digits, '0');
if (width > num_digits) out = std::fill_n(out, width - num_digits, '0');
out = format_decimal<char_type>(out, n, num_digits);
}
@ -286,24 +282,21 @@ struct chrono_formatter {
void on_tz_name() {}
void on_24_hour(numeric_system ns) {
if (ns == numeric_system::standard)
return write(hour(), 2);
if (ns == numeric_system::standard) return write(hour(), 2);
auto time = tm();
time.tm_hour = hour();
format_localized(time, "%OH");
}
void on_12_hour(numeric_system ns) {
if (ns == numeric_system::standard)
return write(hour12(), 2);
if (ns == numeric_system::standard) return write(hour12(), 2);
auto time = tm();
time.tm_hour = hour();
format_localized(time, "%OI");
}
void on_minute(numeric_system ns) {
if (ns == numeric_system::standard)
return write(minute(), 2);
if (ns == numeric_system::standard) return write(minute(), 2);
auto time = tm();
time.tm_min = minute();
format_localized(time, "%OM");
@ -341,30 +334,84 @@ struct chrono_formatter {
};
} // namespace internal
template <typename Period> FMT_CONSTEXPR const char *get_units() {
template <typename Period>
FMT_CONSTEXPR const char *get_units() {
return FMT_NULL;
}
template <> FMT_CONSTEXPR const char *get_units<std::atto>() { return "as"; }
template <> FMT_CONSTEXPR const char *get_units<std::femto>() { return "fs"; }
template <> FMT_CONSTEXPR const char *get_units<std::pico>() { return "ps"; }
template <> FMT_CONSTEXPR const char *get_units<std::nano>() { return "ns"; }
template <> 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>>() {
template <>
FMT_CONSTEXPR const char *get_units<std::atto>() {
return "as";
}
template <>
FMT_CONSTEXPR const char *get_units<std::femto>() {
return "fs";
}
template <>
FMT_CONSTEXPR const char *get_units<std::pico>() {
return "ps";
}
template <>
FMT_CONSTEXPR const char *get_units<std::nano>() {
return "ns";
}
template <>
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";
}
template <> FMT_CONSTEXPR const char *get_units<std::ratio<3600>>() {
template <>
FMT_CONSTEXPR const char *get_units<std::ratio<3600>>() {
return "h";
}
@ -415,13 +462,13 @@ struct formatter<std::chrono::duration<Rep, Period>, Char> {
if (begin == end) return begin;
begin = internal::parse_width(begin, end, handler);
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;
}
template <typename FormatContext>
auto format(const duration &d, FormatContext &ctx)
-> decltype(ctx.out()) {
auto format(const duration &d, FormatContext &ctx) -> decltype(ctx.out()) {
auto begin = format_str.begin(), end = format_str.end();
memory_buffer buf;
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);
else
format_to(buf, "{}[{}/{}]s", d.count(), Period::num, Period::den);
internal::handle_dynamic_spec<internal::width_checker>(
spec.width_, width_ref, ctx);
internal::handle_dynamic_spec<internal::width_checker>(spec.width_,
width_ref, ctx);
} else {
auto out = std::back_inserter(buf);
internal::chrono_formatter<FormatContext, decltype(out)> f(ctx, out);

80
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);
template <typename... Args>
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...));
}
template <typename... Args>
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...));
}
@ -225,9 +225,10 @@ struct rgb {
FMT_CONSTEXPR_DECL rgb(uint8_t r_, uint8_t g_, uint8_t b_)
: r(r_), g(g_), b(b_) {}
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)
: r((uint32_t(hex) >> 16) & 0xFF), g((uint32_t(hex) >> 8) & 0xFF),
: r((uint32_t(hex) >> 16) & 0xFF),
g((uint32_t(hex) >> 8) & 0xFF),
b(uint32_t(hex) & 0xFF) {}
uint8_t r;
uint8_t g;
@ -238,19 +239,17 @@ namespace internal {
// color is a struct of either a rgb color or a terminal color.
struct color_type {
FMT_CONSTEXPR color_type() FMT_NOEXCEPT
: is_rgb(), value{} {}
FMT_CONSTEXPR color_type(color rgb_color) FMT_NOEXCEPT
: is_rgb(true), value{} {
FMT_CONSTEXPR color_type() FMT_NOEXCEPT : is_rgb(), value{} {}
FMT_CONSTEXPR color_type(color rgb_color) FMT_NOEXCEPT : is_rgb(true),
value{} {
value.rgb_color = static_cast<uint32_t>(rgb_color);
}
FMT_CONSTEXPR color_type(rgb rgb_color) FMT_NOEXCEPT
: is_rgb(true), value{} {
value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16)
| (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
FMT_CONSTEXPR color_type(rgb rgb_color) FMT_NOEXCEPT : is_rgb(true), value{} {
value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16) |
(static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
}
FMT_CONSTEXPR color_type(terminal_color term_color) FMT_NOEXCEPT
: is_rgb(), value{} {
FMT_CONSTEXPR color_type(terminal_color term_color) FMT_NOEXCEPT : is_rgb(),
value{} {
value.term_color = static_cast<uint8_t>(term_color);
}
bool is_rgb;
@ -265,7 +264,9 @@ struct color_type {
class text_style {
public:
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) {
if (!set_foreground_color) {
@ -291,8 +292,8 @@ class text_style {
return *this;
}
friend FMT_CONSTEXPR
text_style operator|(text_style lhs, const text_style &rhs) {
friend FMT_CONSTEXPR text_style operator|(text_style lhs,
const text_style &rhs) {
return lhs |= rhs;
}
@ -320,8 +321,8 @@ class text_style {
return *this;
}
friend FMT_CONSTEXPR
text_style operator&(text_style lhs, const text_style &rhs) {
friend FMT_CONSTEXPR text_style operator&(text_style lhs,
const text_style &rhs) {
return lhs &= rhs;
}
@ -347,7 +348,7 @@ class text_style {
return ems;
}
private:
private:
FMT_CONSTEXPR text_style(bool is_foreground,
internal::color_type text_color) FMT_NOEXCEPT
: set_foreground_color(),
@ -391,7 +392,7 @@ namespace internal {
template <typename Char>
struct ansi_color_escape {
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
// sequence.
if (!text_color.is_rgb) {
@ -399,8 +400,7 @@ struct ansi_color_escape {
uint32_t value = text_color.value.term_color;
// Background ASCII codes are the same as the foreground ones but with
// 10 more.
if (is_background)
value += 10u;
if (is_background) value += 10u;
std::size_t index = 0;
buffer[index++] = static_cast<Char>('\x1b');
@ -430,19 +430,15 @@ struct ansi_color_escape {
FMT_CONSTEXPR ansi_color_escape(emphasis em) FMT_NOEXCEPT {
uint8_t em_codes[4] = {};
uint8_t em_bits = static_cast<uint8_t>(em);
if (em_bits & static_cast<uint8_t>(emphasis::bold))
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::underline))
em_codes[2] = 4;
if (em_bits & static_cast<uint8_t>(emphasis::bold)) 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::underline)) em_codes[2] = 4;
if (em_bits & static_cast<uint8_t>(emphasis::strikethrough))
em_codes[3] = 9;
std::size_t index = 0;
for (int i = 0; i < 4; ++i) {
if (!em_codes[i])
continue;
if (!em_codes[i]) continue;
buffer[index++] = static_cast<Char>('\x1b');
buffer[index++] = static_cast<Char>('[');
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; }
private:
private:
Char buffer[7u + 3u * 4u + 1u];
static FMT_CONSTEXPR void to_esc(uint8_t c, Char *out,
@ -465,20 +461,19 @@ private:
};
template <typename Char>
FMT_CONSTEXPR ansi_color_escape<Char>
make_foreground_color(internal::color_type foreground) FMT_NOEXCEPT {
FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color(
internal::color_type foreground) FMT_NOEXCEPT {
return ansi_color_escape<Char>(foreground, internal::data::FOREGROUND_COLOR);
}
template <typename Char>
FMT_CONSTEXPR ansi_color_escape<Char>
make_background_color(internal::color_type background) FMT_NOEXCEPT {
FMT_CONSTEXPR ansi_color_escape<Char> make_background_color(
internal::color_type background) FMT_NOEXCEPT {
return ansi_color_escape<Char>(background, internal::data::BACKGROUND_COLOR);
}
template <typename Char>
FMT_CONSTEXPR ansi_color_escape<Char>
make_emphasis(emphasis em) FMT_NOEXCEPT {
FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) FMT_NOEXCEPT {
return ansi_color_escape<Char>(em);
}
@ -512,15 +507,13 @@ template <>
struct is_string<const std::FILE *> : std::false_type {};
} // namespace internal
template <
typename S, typename Char = typename internal::char_t<S>::type>
template <typename S, typename Char = typename internal::char_t<S>::type>
void vprint(std::FILE *f, const text_style &ts, const S &format,
basic_format_args<typename buffer_context<Char>::type> args) {
bool has_style = false;
if (ts.has_emphasis()) {
has_style = true;
internal::fputs<Char>(
internal::make_emphasis<Char>(ts.get_emphasis()), f);
internal::fputs<Char>(internal::make_emphasis<Char>(ts.get_emphasis()), f);
}
if (ts.has_foreground()) {
has_style = true;
@ -565,8 +558,7 @@ typename std::enable_if<internal::is_string<String>::value>::type print(
*/
template <typename String, typename... Args>
typename std::enable_if<internal::is_string<String>::value>::type print(
const text_style &ts, const String &format_str,
const Args &... args) {
const text_style &ts, const String &format_str, const Args &... args) {
return print(stdout, ts, format_str, args...);
}

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

@ -19,171 +19,178 @@
#define FMT_VERSION 50300
#ifdef __has_feature
# define FMT_HAS_FEATURE(x) __has_feature(x)
#define FMT_HAS_FEATURE(x) __has_feature(x)
#else
# define FMT_HAS_FEATURE(x) 0
#define FMT_HAS_FEATURE(x) 0
#endif
#if defined(__has_include) && !defined(__INTELLISENSE__) && \
!(defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1600)
# define FMT_HAS_INCLUDE(x) __has_include(x)
#define FMT_HAS_INCLUDE(x) __has_include(x)
#else
# define FMT_HAS_INCLUDE(x) 0
#define FMT_HAS_INCLUDE(x) 0
#endif
#ifdef __has_cpp_attribute
# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
#define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
#else
# define FMT_HAS_CPP_ATTRIBUTE(x) 0
#define FMT_HAS_CPP_ATTRIBUTE(x) 0
#endif
#if defined(__GNUC__) && !defined(__clang__)
# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
#define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
#else
# define FMT_GCC_VERSION 0
#define FMT_GCC_VERSION 0
#endif
#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
# define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION
#define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION
#else
# define FMT_HAS_GXX_CXX11 0
#define FMT_HAS_GXX_CXX11 0
#endif
#ifdef _MSC_VER
# define FMT_MSC_VER _MSC_VER
#define FMT_MSC_VER _MSC_VER
#else
# define FMT_MSC_VER 0
#define FMT_MSC_VER 0
#endif
// Check if relaxed C++14 constexpr is supported.
// GCC doesn't allow throw in constexpr until version 6 (bug 67371).
#ifndef FMT_USE_CONSTEXPR
# define FMT_USE_CONSTEXPR \
#define FMT_USE_CONSTEXPR \
(FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 || \
(FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L))
#endif
#if FMT_USE_CONSTEXPR
# define FMT_CONSTEXPR constexpr
# define FMT_CONSTEXPR_DECL constexpr
#define FMT_CONSTEXPR constexpr
#define FMT_CONSTEXPR_DECL constexpr
#else
# define FMT_CONSTEXPR inline
# define FMT_CONSTEXPR_DECL
#define FMT_CONSTEXPR inline
#define FMT_CONSTEXPR_DECL
#endif
#ifndef FMT_USE_CONSTEXPR11
# define FMT_USE_CONSTEXPR11 \
#define FMT_USE_CONSTEXPR11 \
(FMT_USE_CONSTEXPR || FMT_GCC_VERSION >= 406 || FMT_MSC_VER >= 1900)
#endif
#if FMT_USE_CONSTEXPR11
# define FMT_CONSTEXPR11 constexpr
#define FMT_CONSTEXPR11 constexpr
#else
# define FMT_CONSTEXPR11
#define FMT_CONSTEXPR11
#endif
#ifndef FMT_OVERRIDE
# if FMT_HAS_FEATURE(cxx_override) || \
#if FMT_HAS_FEATURE(cxx_override) || \
(FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
# define FMT_OVERRIDE override
# else
# define FMT_OVERRIDE
# endif
#define FMT_OVERRIDE override
#else
#define FMT_OVERRIDE
#endif
#endif
#if FMT_HAS_FEATURE(cxx_explicit_conversions) || \
FMT_GCC_VERSION >= 405 || FMT_MSC_VER >= 1800
# define FMT_USE_EXPLICIT 1
# define FMT_EXPLICIT explicit
#if FMT_HAS_FEATURE(cxx_explicit_conversions) || FMT_GCC_VERSION >= 405 || \
FMT_MSC_VER >= 1800
#define FMT_USE_EXPLICIT 1
#define FMT_EXPLICIT explicit
#else
# define FMT_USE_EXPLICIT 0
# define FMT_EXPLICIT
#define FMT_USE_EXPLICIT 0
#define FMT_EXPLICIT
#endif
#ifndef FMT_NULL
# if FMT_HAS_FEATURE(cxx_nullptr) || \
#if FMT_HAS_FEATURE(cxx_nullptr) || \
(FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1600
# define FMT_NULL nullptr
# define FMT_USE_NULLPTR 1
# else
# define FMT_NULL NULL
# endif
#define FMT_NULL nullptr
#define FMT_USE_NULLPTR 1
#else
#define FMT_NULL NULL
#endif
#endif
#ifndef FMT_USE_NULLPTR
# define FMT_USE_NULLPTR 0
#define FMT_USE_NULLPTR 0
#endif
// Check if exceptions are disabled.
#ifndef FMT_EXCEPTIONS
# if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \
#if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \
FMT_MSC_VER && !_HAS_EXCEPTIONS
# define FMT_EXCEPTIONS 0
# else
# define FMT_EXCEPTIONS 1
# endif
#define FMT_EXCEPTIONS 0
#else
#define FMT_EXCEPTIONS 1
#endif
#endif
// Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature).
#ifndef FMT_USE_NOEXCEPT
# define FMT_USE_NOEXCEPT 0
#define FMT_USE_NOEXCEPT 0
#endif
#if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
(FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
# define FMT_DETECTED_NOEXCEPT noexcept
# define FMT_HAS_CXX11_NOEXCEPT 1
#define FMT_DETECTED_NOEXCEPT noexcept
#define FMT_HAS_CXX11_NOEXCEPT 1
#else
# define FMT_DETECTED_NOEXCEPT throw()
# define FMT_HAS_CXX11_NOEXCEPT 0
#define FMT_DETECTED_NOEXCEPT throw()
#define FMT_HAS_CXX11_NOEXCEPT 0
#endif
#ifndef FMT_NOEXCEPT
# if FMT_EXCEPTIONS || FMT_HAS_CXX11_NOEXCEPT
# define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT
# else
# define FMT_NOEXCEPT
# endif
#if FMT_EXCEPTIONS || FMT_HAS_CXX11_NOEXCEPT
#define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT
#else
#define FMT_NOEXCEPT
#endif
#endif
#ifndef FMT_BEGIN_NAMESPACE
# if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || \
#if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || \
FMT_MSC_VER >= 1900
# define FMT_INLINE_NAMESPACE inline namespace
# define FMT_END_NAMESPACE }}
# else
# define FMT_INLINE_NAMESPACE namespace
# define FMT_END_NAMESPACE } using namespace v5; }
# endif
# define FMT_BEGIN_NAMESPACE namespace fmt { FMT_INLINE_NAMESPACE v5 {
#define FMT_INLINE_NAMESPACE inline namespace
#define FMT_END_NAMESPACE \
} \
}
#else
#define FMT_INLINE_NAMESPACE namespace
#define FMT_END_NAMESPACE \
} \
using namespace v5; \
}
#endif
#define FMT_BEGIN_NAMESPACE \
namespace fmt { \
FMT_INLINE_NAMESPACE v5 {
#endif
#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
# ifdef FMT_EXPORT
# define FMT_API __declspec(dllexport)
# elif defined(FMT_SHARED)
# define FMT_API __declspec(dllimport)
# endif
#ifdef FMT_EXPORT
#define FMT_API __declspec(dllexport)
#elif defined(FMT_SHARED)
#define FMT_API __declspec(dllimport)
#endif
#endif
#ifndef FMT_API
# define FMT_API
#define FMT_API
#endif
#ifndef FMT_ASSERT
# define FMT_ASSERT(condition, message) assert((condition) && message)
#define FMT_ASSERT(condition, message) assert((condition) && message)
#endif
// libc++ supports string_view in pre-c++17.
#if (FMT_HAS_INCLUDE(<string_view>) && \
(__cplusplus > 201402L || defined(_LIBCPP_VERSION))) || \
(defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)
# include <string_view>
# define FMT_STRING_VIEW std::basic_string_view
#elif FMT_HAS_INCLUDE(<experimental/string_view>) && __cplusplus >= 201402L
# include <experimental/string_view>
# define FMT_STRING_VIEW std::experimental::basic_string_view
#include <string_view>
#define FMT_STRING_VIEW std::basic_string_view
#elif FMT_HAS_INCLUDE(<experimental / string_view>) && __cplusplus >= 201402L
#include <experimental/string_view>
#define FMT_STRING_VIEW std::experimental::basic_string_view
#endif
// std::result_of is defined in <functional> in gcc 4.4.
#if FMT_GCC_VERSION && FMT_GCC_VERSION <= 404
# include <functional>
#include <functional>
#endif
FMT_BEGIN_NAMESPACE
@ -199,8 +206,8 @@ struct result_of;
template <typename F, typename... Args>
struct result_of<F(Args...)> {
// A workaround for gcc 4.4 that doesn't allow F to be a reference.
typedef typename std::result_of<
typename std::remove_reference<F>::type(Args...)>::type type;
typedef typename std::result_of<typename std::remove_reference<F>::type(
Args...)>::type type;
};
// Casts nonnegative integer to unsigned.
@ -223,10 +230,12 @@ class basic_buffer {
protected:
// Don't initialize ptr_ since it is not accessed to save a few cycles.
basic_buffer(std::size_t sz) FMT_NOEXCEPT: size_(sz), capacity_(sz) {}
basic_buffer(std::size_t sz) FMT_NOEXCEPT : size_(sz), capacity_(sz) {}
basic_buffer(T *p = FMT_NULL, std::size_t sz = 0, std::size_t cap = 0)
FMT_NOEXCEPT: ptr_(p), size_(sz), capacity_(cap) {}
basic_buffer(T *p = FMT_NULL, std::size_t sz = 0,
std::size_t cap = 0) FMT_NOEXCEPT : ptr_(p),
size_(sz),
capacity_(cap) {}
/** Sets the buffer data and capacity. */
void set(T *buf_data, std::size_t buf_capacity) FMT_NOEXCEPT {
@ -271,8 +280,7 @@ class basic_buffer {
/** Reserves space to store at least *capacity* elements. */
void reserve(std::size_t new_capacity) {
if (new_capacity > capacity_)
grow(new_capacity);
if (new_capacity > capacity_) grow(new_capacity);
}
void push_back(const T &value) {
@ -312,7 +320,7 @@ class container_buffer : public basic_buffer<typename Container::value_type> {
template <typename Container>
inline Container &get_container(std::back_insert_iterator<Container> it) {
typedef std::back_insert_iterator<Container> bi_iterator;
struct accessor: bi_iterator {
struct accessor : bi_iterator {
accessor(bi_iterator iter) : bi_iterator(iter) {}
using bi_iterator::container;
};
@ -333,7 +341,7 @@ struct no_formatter_error : std::false_type {};
#if FMT_GCC_VERSION && FMT_GCC_VERSION < 405
template <typename... T>
struct is_constructible: std::false_type {};
struct is_constructible : std::false_type {};
#else
template <typename... T>
struct is_constructible : std::is_constructible<T...> {};
@ -360,7 +368,8 @@ class basic_string_view {
/** Constructs a string reference object from a C string and a size. */
FMT_CONSTEXPR basic_string_view(const Char *s, size_t count) FMT_NOEXCEPT
: data_(s), size_(count) {}
: data_(s),
size_(count) {}
/**
\rst
@ -373,13 +382,14 @@ class basic_string_view {
/** Constructs a string reference from a ``std::basic_string`` object. */
template <typename Alloc>
FMT_CONSTEXPR basic_string_view(
const std::basic_string<Char, Alloc> &s) FMT_NOEXCEPT
: data_(s.data()), size_(s.size()) {}
FMT_CONSTEXPR basic_string_view(const std::basic_string<Char, Alloc> &s)
FMT_NOEXCEPT : data_(s.data()),
size_(s.size()) {}
#ifdef FMT_STRING_VIEW
FMT_CONSTEXPR basic_string_view(FMT_STRING_VIEW<Char> s) FMT_NOEXCEPT
: data_(s.data()), size_(s.size()) {}
: data_(s.data()),
size_(s.size()) {}
#endif
/** Returns a pointer to the string data. */
@ -451,20 +461,26 @@ typedef basic_string_view<wchar_t> wstring_view;
\endrst
*/
template <typename Char>
inline basic_string_view<Char>
to_string_view(basic_string_view<Char> s) { return s; }
inline basic_string_view<Char> to_string_view(basic_string_view<Char> s) {
return s;
}
template <typename Char>
inline basic_string_view<Char>
to_string_view(const std::basic_string<Char> &s) { return s; }
inline basic_string_view<Char> to_string_view(
const std::basic_string<Char> &s) {
return s;
}
template <typename Char>
inline basic_string_view<Char> to_string_view(const Char *s) { return s; }
inline basic_string_view<Char> to_string_view(const Char *s) {
return s;
}
#ifdef FMT_STRING_VIEW
template <typename Char>
inline basic_string_view<Char>
to_string_view(FMT_STRING_VIEW<Char> s) { return s; }
inline basic_string_view<Char> to_string_view(FMT_STRING_VIEW<Char> s) {
return s;
}
#endif
// A base class for compile-time strings. It is defined in the fmt namespace to
@ -474,11 +490,12 @@ struct compile_string {};
template <typename S>
struct is_compile_string : std::is_base_of<compile_string, S> {};
template <
typename S,
typename Enable = typename std::enable_if<is_compile_string<S>::value>::type>
FMT_CONSTEXPR basic_string_view<typename S::char_type>
to_string_view(const S &s) { return s; }
template <typename S, typename Enable = typename std::enable_if<
is_compile_string<S>::value>::type>
FMT_CONSTEXPR basic_string_view<typename S::char_type> to_string_view(
const S &s) {
return s;
}
template <typename Context>
class basic_format_arg;
@ -489,7 +506,8 @@ class basic_format_args;
// A formatter for objects of type T.
template <typename T, typename Char = char, typename Enable = void>
struct formatter {
static_assert(internal::no_formatter_error<T>::value,
static_assert(
internal::no_formatter_error<T>::value,
"don't know how to format the type, include fmt/ostream.h if it provides "
"an operator<< that should be used");
@ -501,19 +519,25 @@ struct formatter {
};
template <typename T, typename Char, typename Enable = void>
struct convert_to_int: std::integral_constant<
bool, !std::is_arithmetic<T>::value && std::is_convertible<T, int>::value> {};
struct convert_to_int
: std::integral_constant<bool, !std::is_arithmetic<T>::value &&
std::is_convertible<T, int>::value> {};
namespace internal {
struct dummy_string_view { typedef void char_type; };
struct dummy_string_view {
typedef void char_type;
};
dummy_string_view to_string_view(...);
using fmt::v5::to_string_view;
// Specifies whether S is a string type convertible to fmt::basic_string_view.
template <typename S>
struct is_string : std::integral_constant<bool, !std::is_same<
dummy_string_view, decltype(to_string_view(declval<S>()))>::value> {};
struct is_string
: std::integral_constant<
bool, !std::is_same<dummy_string_view,
decltype(to_string_view(declval<S>()))>::value> {
};
template <typename S>
struct char_t {
@ -528,13 +552,24 @@ template <typename T, typename Char>
struct named_arg;
enum type {
none_type, named_arg_type,
none_type,
named_arg_type,
// Integer types should go first,
int_type, uint_type, long_long_type, ulong_long_type, bool_type, char_type,
int_type,
uint_type,
long_long_type,
ulong_long_type,
bool_type,
char_type,
last_integer_type = char_type,
// followed by floating-point types.
double_type, long_double_type, last_numeric_type = long_double_type,
cstring_type, string_type, pointer_type, custom_type
double_type,
long_double_type,
last_numeric_type = long_double_type,
cstring_type,
string_type,
pointer_type,
custom_type
};
FMT_CONSTEXPR bool is_integral(type t) {
@ -609,7 +644,7 @@ class value {
}
const named_arg_base<char_type> &as_named_arg() {
return *static_cast<const named_arg_base<char_type>*>(pointer);
return *static_cast<const named_arg_base<char_type> *>(pointer);
}
private:
@ -622,7 +657,7 @@ class value {
typename Context::template formatter_type<T>::type f;
auto &&parse_ctx = ctx.parse_context();
parse_ctx.advance_to(f.parse(parse_ctx));
ctx.advance_to(f.format(*static_cast<const T*>(arg), ctx));
ctx.advance_to(f.format(*static_cast<const T *>(arg), ctx));
}
};
@ -647,7 +682,9 @@ FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T &value);
#define FMT_MAKE_VALUE_SAME(TAG, Type) \
template <typename C> \
FMT_CONSTEXPR init<C, Type, TAG> make_value(Type val) { return val; }
FMT_CONSTEXPR init<C, Type, TAG> make_value(Type val) { \
return val; \
}
FMT_MAKE_VALUE(bool_type, bool, int)
FMT_MAKE_VALUE(int_type, short, int)
@ -659,12 +696,12 @@ FMT_MAKE_VALUE_SAME(uint_type, unsigned)
// either to int or to long long depending on its size.
typedef std::conditional<sizeof(long) == sizeof(int), int, long long>::type
long_type;
FMT_MAKE_VALUE(
(sizeof(long) == sizeof(int) ? int_type : long_long_type), long, long_type)
typedef std::conditional<sizeof(unsigned long) == sizeof(unsigned),
unsigned, unsigned long long>::type ulong_type;
FMT_MAKE_VALUE(
(sizeof(unsigned long) == sizeof(unsigned) ? uint_type : ulong_long_type),
FMT_MAKE_VALUE((sizeof(long) == sizeof(int) ? int_type : long_long_type), long,
long_type)
typedef std::conditional<sizeof(unsigned long) == sizeof(unsigned), unsigned,
unsigned long long>::type ulong_type;
FMT_MAKE_VALUE((sizeof(unsigned long) == sizeof(unsigned) ? uint_type
: ulong_long_type),
unsigned long, ulong_type)
FMT_MAKE_VALUE_SAME(long_long_type, long long)
@ -674,14 +711,20 @@ FMT_MAKE_VALUE(uint_type, unsigned char, unsigned)
// This doesn't use FMT_MAKE_VALUE because of ambiguity in gcc 4.4.
template <typename C, typename Char>
FMT_CONSTEXPR typename std::enable_if<
std::is_same<typename C::char_type, Char>::value,
init<C, int, char_type>>::type make_value(Char val) { return val; }
FMT_CONSTEXPR
typename std::enable_if<std::is_same<typename C::char_type, Char>::value,
init<C, int, char_type>>::type
make_value(Char val) {
return val;
}
template <typename C>
FMT_CONSTEXPR typename std::enable_if<
!std::is_same<typename C::char_type, char>::value,
init<C, int, char_type>>::type make_value(char val) { return val; }
FMT_CONSTEXPR
typename std::enable_if<!std::is_same<typename C::char_type, char>::value,
init<C, int, char_type>>::type
make_value(char val) {
return val;
}
FMT_MAKE_VALUE(double_type, float, double)
FMT_MAKE_VALUE_SAME(double_type, double)
@ -689,26 +732,26 @@ FMT_MAKE_VALUE_SAME(long_double_type, long double)
// Formatting of wide strings into a narrow buffer and multibyte strings
// into a wide buffer is disallowed (https://github.com/fmtlib/fmt/pull/606).
FMT_MAKE_VALUE(cstring_type, typename C::char_type*,
const typename C::char_type*)
FMT_MAKE_VALUE(cstring_type, const typename C::char_type*,
const typename C::char_type*)
FMT_MAKE_VALUE(cstring_type, typename C::char_type *,
const typename C::char_type *)
FMT_MAKE_VALUE(cstring_type, const typename C::char_type *,
const typename C::char_type *)
FMT_MAKE_VALUE(cstring_type, signed char*, const signed char*)
FMT_MAKE_VALUE_SAME(cstring_type, const signed char*)
FMT_MAKE_VALUE(cstring_type, unsigned char*, const unsigned char*)
FMT_MAKE_VALUE_SAME(cstring_type, const unsigned char*)
FMT_MAKE_VALUE(cstring_type, signed char *, const signed char *)
FMT_MAKE_VALUE_SAME(cstring_type, const signed char *)
FMT_MAKE_VALUE(cstring_type, unsigned char *, const unsigned char *)
FMT_MAKE_VALUE_SAME(cstring_type, const unsigned char *)
FMT_MAKE_VALUE_SAME(string_type, basic_string_view<typename C::char_type>)
FMT_MAKE_VALUE(string_type,
typename basic_string_view<typename C::char_type>::type,
basic_string_view<typename C::char_type>)
FMT_MAKE_VALUE(string_type, const std::basic_string<typename C::char_type>&,
FMT_MAKE_VALUE(string_type, const std::basic_string<typename C::char_type> &,
basic_string_view<typename C::char_type>)
FMT_MAKE_VALUE(pointer_type, void*, const void*)
FMT_MAKE_VALUE_SAME(pointer_type, const void*)
FMT_MAKE_VALUE(pointer_type, void *, const void *)
FMT_MAKE_VALUE_SAME(pointer_type, const void *)
#if FMT_USE_NULLPTR
FMT_MAKE_VALUE(pointer_type, std::nullptr_t, const void*)
FMT_MAKE_VALUE(pointer_type, std::nullptr_t, const void *)
#endif
// Formatting of arbitrary pointers is disallowed. If you want to output a
@ -717,22 +760,27 @@ FMT_MAKE_VALUE(pointer_type, std::nullptr_t, const void*)
// iostreams.
template <typename C, typename T>
typename std::enable_if<!std::is_same<T, typename C::char_type>::value>::type
make_value(const T *) {
make_value(const T *) {
static_assert(!sizeof(T), "formatting of non-void pointers is disallowed");
}
template <typename C, typename T>
inline typename std::enable_if<
std::is_enum<T>::value && convert_to_int<T, typename C::char_type>::value,
inline
typename std::enable_if<std::is_enum<T>::value &&
convert_to_int<T, typename C::char_type>::value,
init<C, int, int_type>>::type
make_value(const T &val) { return static_cast<int>(val); }
make_value(const T &val) {
return static_cast<int>(val);
}
template <typename C, typename T, typename Char = typename C::char_type>
inline typename std::enable_if<
is_constructible<basic_string_view<Char>, T>::value &&
!internal::is_string<T>::value,
init<C, basic_string_view<Char>, string_type>>::type
make_value(const T &val) { return basic_string_view<Char>(val); }
make_value(const T &val) {
return basic_string_view<Char>(val);
}
template <typename C, typename T, typename Char = typename C::char_type>
inline typename std::enable_if<
@ -743,24 +791,26 @@ inline typename std::enable_if<
// Implicit conversion to std::string is not handled here because it's
// unsafe: https://github.com/fmtlib/fmt/issues/729
init<C, const T &, custom_type>>::type
make_value(const T &val) { return val; }
make_value(const T &val) {
return val;
}
template <typename C, typename T>
init<C, const void*, named_arg_type>
make_value(const named_arg<T, typename C::char_type> &val) {
init<C, const void *, named_arg_type> make_value(
const named_arg<T, typename C::char_type> &val) {
basic_format_arg<C> arg = make_arg<C>(val.value);
std::memcpy(val.data, &arg, sizeof(arg));
return static_cast<const void*>(&val);
return static_cast<const void *>(&val);
}
template <typename C, typename S>
FMT_CONSTEXPR11 typename std::enable_if<
internal::is_string<S>::value,
init<C, basic_string_view<typename C::char_type>, string_type>>::type
make_value(const S &val) {
make_value(const S &val) {
// Handle adapted strings.
static_assert(std::is_same<
typename C::char_type, typename internal::char_t<S>::type>::value,
static_assert(std::is_same<typename C::char_type,
typename internal::char_t<S>::type>::value,
"mismatch between char-types of context and argument");
return to_string_view(val);
}
@ -782,8 +832,8 @@ class basic_format_arg {
internal::type type_;
template <typename ContextType, typename T>
friend FMT_CONSTEXPR basic_format_arg<ContextType>
internal::make_arg(const T &value);
friend FMT_CONSTEXPR basic_format_arg<ContextType> internal::make_arg(
const T &value);
template <typename Visitor, typename Ctx>
friend FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
@ -797,7 +847,7 @@ class basic_format_arg {
public:
class handle {
public:
explicit handle(internal::custom_value<Context> custom): custom_(custom) {}
explicit handle(internal::custom_value<Context> custom) : custom_(custom) {}
void format(Context &ctx) const { custom_.format(custom_.value, ctx); }
@ -827,8 +877,8 @@ struct monostate {};
\endrst
*/
template <typename Visitor, typename Context>
FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
visit_format_arg(Visitor &&vis, const basic_format_arg<Context> &arg) {
FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type visit_format_arg(
Visitor &&vis, const basic_format_arg<Context> &arg) {
typedef typename Context::char_type char_type;
switch (arg.type_) {
case internal::none_type:
@ -855,8 +905,8 @@ FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
case internal::cstring_type:
return vis(arg.value_.string.value);
case internal::string_type:
return vis(basic_string_view<char_type>(
arg.value_.string.value, arg.value_.string.size));
return vis(basic_string_view<char_type>(arg.value_.string.value,
arg.value_.string.size));
case internal::pointer_type:
return vis(arg.value_.pointer);
case internal::custom_type:
@ -867,8 +917,8 @@ FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
// DEPRECATED!
template <typename Visitor, typename Context>
FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
visit(Visitor &&vis, const basic_format_arg<Context> &arg) {
FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type visit(
Visitor &&vis, const basic_format_arg<Context> &arg) {
return visit_format_arg(std::forward<Visitor>(vis), arg);
}
@ -884,8 +934,8 @@ class basic_parse_context : private ErrorHandler {
typedef Char char_type;
typedef typename basic_string_view<Char>::iterator iterator;
explicit FMT_CONSTEXPR basic_parse_context(
basic_string_view<Char> format_str, ErrorHandler eh = ErrorHandler())
explicit FMT_CONSTEXPR basic_parse_context(basic_string_view<Char> format_str,
ErrorHandler eh = ErrorHandler())
: ErrorHandler(eh), format_str_(format_str), next_arg_id_(0) {}
// Returns an iterator to the beginning of the format string range being
@ -956,13 +1006,12 @@ class arg_map {
public:
arg_map() : map_(FMT_NULL), size_(0) {}
void init(const basic_format_args<Context> &args);
~arg_map() { delete [] map_; }
~arg_map() { delete[] map_; }
basic_format_arg<Context> find(basic_string_view<char_type> name) const {
// The list is unsorted, so just return the first matching name.
for (entry *it = map_, *end = map_ + size_; it != end; ++it) {
if (it->name == name)
return it->arg;
if (it->name == name) return it->arg;
}
return {};
}
@ -1007,16 +1056,15 @@ class context_base {
// Returns the argument with specified index.
format_arg do_get_arg(unsigned arg_id) {
format_arg arg = args_.get(arg_id);
if (!arg)
parse_context_.on_error("argument index out of range");
if (!arg) parse_context_.on_error("argument index out of range");
return arg;
}
// Checks if manual indexing is used and returns the argument with
// specified index.
format_arg get_arg(unsigned arg_id) {
return this->parse_context().check_arg_id(arg_id) ?
this->do_get_arg(arg_id) : format_arg();
return this->parse_context().check_arg_id(arg_id) ? this->do_get_arg(arg_id)
: format_arg();
}
public:
@ -1043,12 +1091,14 @@ class context_base {
template <typename Context, typename T>
struct get_type {
typedef decltype(make_value<Context>(
declval<typename std::decay<T>::type&>())) value_type;
declval<typename std::decay<T>::type &>())) value_type;
static const type value = value_type::type_tag;
};
template <typename Context>
FMT_CONSTEXPR11 unsigned long long get_types() { return 0; }
FMT_CONSTEXPR11 unsigned long long get_types() {
return 0;
}
template <typename Context, typename Arg, typename... Args>
FMT_CONSTEXPR11 unsigned long long get_types() {
@ -1064,22 +1114,22 @@ FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T &value) {
}
template <bool IS_PACKED, typename Context, typename T>
inline typename std::enable_if<IS_PACKED, value<Context>>::type
make_arg(const T &value) {
inline typename std::enable_if<IS_PACKED, value<Context>>::type make_arg(
const T &value) {
return make_value<Context>(value);
}
template <bool IS_PACKED, typename Context, typename T>
inline typename std::enable_if<!IS_PACKED, basic_format_arg<Context>>::type
make_arg(const T &value) {
make_arg(const T &value) {
return make_arg<Context>(value);
}
} // namespace internal
// Formatting context.
template <typename OutputIt, typename Char>
class basic_format_context :
public internal::context_base<
class basic_format_context
: public internal::context_base<
OutputIt, basic_format_context<OutputIt, Char>, Char> {
public:
/** The character type for the output. */
@ -1087,7 +1137,9 @@ class basic_format_context :
// using formatter_type = formatter<T, char_type>;
template <typename T>
struct formatter_type { typedef formatter<T, char_type> type; };
struct formatter_type {
typedef formatter<T, char_type> type;
};
private:
internal::arg_map<basic_format_context> map_;
@ -1124,7 +1176,8 @@ class basic_format_context :
template <typename Char>
struct buffer_context {
typedef basic_format_context<
std::back_insert_iterator<internal::basic_buffer<Char>>, Char> type;
std::back_insert_iterator<internal::basic_buffer<Char>>, Char>
type;
};
typedef buffer_context<char>::type format_context;
typedef buffer_context<wchar_t>::type wformat_context;
@ -1136,7 +1189,7 @@ typedef buffer_context<wchar_t>::type wformat_context;
such as `~fmt::vformat`.
\endrst
*/
template <typename Context, typename ...Args>
template <typename Context, typename... Args>
class format_arg_store {
private:
static const size_t NUM_ARGS = sizeof...(Args);
@ -1144,8 +1197,8 @@ class format_arg_store {
// Packed is a macro on MinGW so use IS_PACKED instead.
static const bool IS_PACKED = NUM_ARGS < internal::max_packed_args;
typedef typename std::conditional<IS_PACKED,
internal::value<Context>, basic_format_arg<Context>>::type value_type;
typedef typename std::conditional<IS_PACKED, internal::value<Context>,
basic_format_arg<Context>>::type value_type;
// If the arguments are not packed, add one more element to mark the end.
static const size_t DATA_SIZE =
@ -1155,9 +1208,8 @@ class format_arg_store {
friend class basic_format_args<Context>;
static FMT_CONSTEXPR11 unsigned long long get_types() {
return IS_PACKED ?
internal::get_types<Context, Args...>() :
internal::is_unpacked_bit | NUM_ARGS;
return IS_PACKED ? internal::get_types<Context, Args...>()
: internal::is_unpacked_bit | NUM_ARGS;
}
public:
@ -1171,8 +1223,8 @@ class format_arg_store {
(FMT_MSC_VER && FMT_MSC_VER <= 1800)
// Workaround array initialization issues in gcc <= 4.5 and MSVC <= 2013.
format_arg_store(const Args &... args) {
value_type init[DATA_SIZE] =
{internal::make_arg<IS_PACKED, Context>(args)...};
value_type init[DATA_SIZE] = {
internal::make_arg<IS_PACKED, Context>(args)...};
std::memcpy(data_, init, sizeof(init));
}
#else
@ -1182,7 +1234,7 @@ class format_arg_store {
};
#if !FMT_USE_CONSTEXPR11
template <typename Context, typename ...Args>
template <typename Context, typename... Args>
const unsigned long long format_arg_store<Context, Args...>::TYPES =
get_types();
#endif
@ -1194,9 +1246,11 @@ const unsigned long long format_arg_store<Context, Args...>::TYPES =
can be omitted in which case it defaults to `~fmt::context`.
\endrst
*/
template <typename Context = format_context, typename ...Args>
inline format_arg_store<Context, Args...>
make_format_args(const Args &... args) { return {args...}; }
template <typename Context = format_context, typename... Args>
inline format_arg_store<Context, Args...> make_format_args(
const Args &... args) {
return {args...};
}
/** Formatting arguments. */
template <typename Context>
@ -1223,8 +1277,8 @@ class basic_format_args {
typename internal::type type(unsigned index) const {
unsigned shift = index * 4;
return static_cast<typename internal::type>(
(types_ & (0xfull << shift)) >> shift);
return static_cast<typename internal::type>((types_ & (0xfull << shift)) >>
shift);
}
friend class internal::arg_map<Context>;
@ -1236,15 +1290,12 @@ class basic_format_args {
format_arg arg;
if (!is_packed()) {
auto num_args = max_size();
if (index < num_args)
arg = args_[index];
if (index < num_args) arg = args_[index];
return arg;
}
if (index > internal::max_packed_args)
return arg;
if (index > internal::max_packed_args) return arg;
arg.type_ = type(index);
if (arg.type_ == internal::none_type)
return arg;
if (arg.type_ == internal::none_type) return arg;
internal::value<Context> &val = arg.value_;
val = values_[index];
return arg;
@ -1292,12 +1343,12 @@ class basic_format_args {
/** An alias to ``basic_format_args<context>``. */
// It is a separate type rather than a typedef to make symbols readable.
struct format_args : basic_format_args<format_context> {
template <typename ...Args>
template <typename... Args>
format_args(Args &&... arg)
: basic_format_args<format_context>(std::forward<Args>(arg)...) {}
};
struct wformat_args : basic_format_args<wformat_context> {
template <typename ...Args>
template <typename... Args>
wformat_args(Args &&... arg)
: basic_format_args<wformat_context>(std::forward<Args>(arg)...) {}
};
@ -1305,18 +1356,18 @@ struct wformat_args : basic_format_args<wformat_context> {
#define FMT_ENABLE_IF_T(B, T) typename std::enable_if<B, T>::type
#ifndef FMT_USE_ALIAS_TEMPLATES
# define FMT_USE_ALIAS_TEMPLATES FMT_HAS_FEATURE(cxx_alias_templates)
#define FMT_USE_ALIAS_TEMPLATES FMT_HAS_FEATURE(cxx_alias_templates)
#endif
#if FMT_USE_ALIAS_TEMPLATES
/** String's character type. */
template <typename S>
using char_t = FMT_ENABLE_IF_T(
internal::is_string<S>::value, typename internal::char_t<S>::type);
using char_t = FMT_ENABLE_IF_T(internal::is_string<S>::value,
typename internal::char_t<S>::type);
#define FMT_CHAR(S) fmt::char_t<S>
#else
template <typename S>
struct char_t : std::enable_if<
internal::is_string<S>::value, typename internal::char_t<S>::type> {};
struct char_t : std::enable_if<internal::is_string<S>::value,
typename internal::char_t<S>::type> {};
#define FMT_CHAR(S) typename char_t<S>::type
#endif
@ -1326,8 +1377,8 @@ struct named_arg_base {
basic_string_view<Char> name;
// Serialized value<context>.
mutable char data[
sizeof(basic_format_arg<typename buffer_context<Char>::type>)];
mutable char
data[sizeof(basic_format_arg<typename buffer_context<Char>::type>)];
named_arg_base(basic_string_view<Char> nm) : name(nm) {}
@ -1349,18 +1400,18 @@ struct named_arg : named_arg_base<Char> {
template <typename... Args, typename S>
inline typename std::enable_if<!is_compile_string<S>::value>::type
check_format_string(const S &) {}
check_format_string(const S &) {}
template <typename... Args, typename S>
typename std::enable_if<is_compile_string<S>::value>::type
check_format_string(S);
typename std::enable_if<is_compile_string<S>::value>::type check_format_string(
S);
template <typename S, typename... Args>
struct checked_args : format_arg_store<
typename buffer_context<FMT_CHAR(S)>::type, Args...> {
struct checked_args
: format_arg_store<typename buffer_context<FMT_CHAR(S)>::type, Args...> {
typedef typename buffer_context<FMT_CHAR(S)>::type context;
checked_args(const S &format_str, const Args &... args):
format_arg_store<context, Args...>(args...) {
checked_args(const S &format_str, const Args &... args)
: format_arg_store<context, Args...>(args...) {
internal::check_format_string<Args...>(format_str);
}
@ -1376,7 +1427,7 @@ template <typename Char>
typename buffer_context<Char>::type::iterator vformat_to(
internal::basic_buffer<Char> &buf, basic_string_view<Char> format_str,
basic_format_args<typename buffer_context<Char>::type> args);
}
} // namespace internal
/**
\rst
@ -1402,21 +1453,19 @@ template <typename S, typename T, typename Char>
void arg(S, internal::named_arg<T, Char>) = delete;
template <typename Container>
struct is_contiguous: std::false_type {};
struct is_contiguous : std::false_type {};
template <typename Char>
struct is_contiguous<std::basic_string<Char> >: std::true_type {};
struct is_contiguous<std::basic_string<Char>> : std::true_type {};
template <typename Char>
struct is_contiguous<internal::basic_buffer<Char> >: std::true_type {};
struct is_contiguous<internal::basic_buffer<Char>> : std::true_type {};
/** Formats a string and writes the output to ``out``. */
template <typename Container, typename S>
typename std::enable_if<
is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type
vformat_to(
std::back_insert_iterator<Container> out,
const S &format_str,
typename std::enable_if<is_contiguous<Container>::value,
std::back_insert_iterator<Container>>::type
vformat_to(std::back_insert_iterator<Container> out, const S &format_str,
basic_format_args<typename buffer_context<FMT_CHAR(S)>::type> args) {
internal::container_buffer<Container> buf(internal::get_container(out));
internal::vformat_to(buf, to_string_view(format_str), args);
@ -1424,10 +1473,10 @@ typename std::enable_if<
}
template <typename Container, typename S, typename... Args>
inline typename std::enable_if<
is_contiguous<Container>::value && internal::is_string<S>::value,
inline typename std::enable_if<is_contiguous<Container>::value &&
internal::is_string<S>::value,
std::back_insert_iterator<Container>>::type
format_to(std::back_insert_iterator<Container> out, const S &format_str,
format_to(std::back_insert_iterator<Container> out, const S &format_str,
const Args &... args) {
internal::checked_args<S, Args...> ca(format_str, args...);
return vformat_to(out, to_string_view(format_str), *ca);
@ -1451,8 +1500,8 @@ inline std::basic_string<Char> vformat(
\endrst
*/
template <typename S, typename... Args>
inline std::basic_string<FMT_CHAR(S)> format(
const S &format_str, const Args &... args) {
inline std::basic_string<FMT_CHAR(S)> format(const S &format_str,
const Args &... args) {
return internal::vformat(
to_string_view(format_str),
*internal::checked_args<S, Args...>(format_str, args...));

329
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_
#define FMT_FORMAT_INL_H_
#include "format.h"
#include <string.h>
#include <cctype>
@ -19,38 +17,40 @@
#include <cstdarg>
#include <cstddef> // for std::ptrdiff_t
#include <cstring> // for std::memmove
#include "format.h"
#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
# include <locale>
#include <locale>
#endif
#if FMT_USE_WINDOWS_H
# if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN)
# define WIN32_LEAN_AND_MEAN
# endif
# if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)
# include <windows.h>
# else
# define NOMINMAX
# include <windows.h>
# undef NOMINMAX
# endif
#if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN)
#define WIN32_LEAN_AND_MEAN
#endif
#if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)
#include <windows.h>
#else
#define NOMINMAX
#include <windows.h>
#undef NOMINMAX
#endif
#endif
#if FMT_EXCEPTIONS
# define FMT_TRY try
# define FMT_CATCH(x) catch (x)
#define FMT_TRY try
#define FMT_CATCH(x) catch (x)
#else
# define FMT_TRY if (true)
# define FMT_CATCH(x) if (false)
#define FMT_TRY if (true)
#define FMT_CATCH(x) if (false)
#endif
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4127) // conditional expression is constant
# pragma warning(disable: 4702) // unreachable code
#pragma warning(push)
#pragma warning(disable : 4127) // conditional expression is constant
#pragma warning(disable : 4702) // unreachable code
// Disable deprecation warning for strerror. The latter is not called but
// MSVC fails to detect it.
# pragma warning(disable: 4996)
#pragma warning(disable : 4996)
#endif
// Dummy implementations of strerror_r and strerror_s called if corresponding
@ -67,7 +67,7 @@ FMT_BEGIN_NAMESPACE
namespace {
#ifndef _MSC_VER
# define FMT_SNPRINTF snprintf
#define FMT_SNPRINTF snprintf
#else // _MSC_VER
inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) {
va_list args;
@ -76,13 +76,13 @@ inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) {
va_end(args);
return result;
}
# define FMT_SNPRINTF fmt_snprintf
#define FMT_SNPRINTF fmt_snprintf
#endif // _MSC_VER
#if defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
# define FMT_SWPRINTF snwprintf
#define FMT_SWPRINTF snwprintf
#else
# define FMT_SWPRINTF swprintf
#define FMT_SWPRINTF swprintf
#endif // defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
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
// other - failure
// Buffer should be at least of size 1.
int safe_strerror(
int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT {
int safe_strerror(int error_code, char *&buffer,
std::size_t buffer_size) FMT_NOEXCEPT {
FMT_ASSERT(buffer != FMT_NULL && buffer_size != 0, "invalid buffer");
class dispatcher {
@ -132,8 +132,8 @@ int safe_strerror(
// Fallback to strerror_s when strerror_r is not available.
int fallback(int result) {
// If the buffer is full then the message is probably truncated.
return result == 0 && strlen(buffer_) == buffer_size_ - 1 ?
ERANGE : result;
return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? ERANGE
: result;
}
#if !FMT_MSC_VER
@ -149,9 +149,7 @@ int safe_strerror(
dispatcher(int err_code, char *&buf, std::size_t buf_size)
: error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
int run() {
return handle(strerror_r(error_code_, buffer_, buffer_size_));
}
int run() { return handle(strerror_r(error_code_, buffer_, buffer_size_)); }
};
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();
size_t num_code_points = 0;
for (size_t i = 0, size = s.size(); i != size; ++i) {
if ((data[i] & 0xc0) != 0x80)
++num_code_points;
if ((data[i] & 0xc0) != 0x80) ++num_code_points;
}
return num_code_points;
}
@ -215,15 +212,15 @@ locale_ref::locale_ref(const Locale &loc) : locale_(&loc) {
template <typename Locale>
Locale locale_ref::get() const {
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>
FMT_FUNC Char thousands_sep_impl(locale_ref loc) {
return std::use_facet<std::numpunct<Char> >(
loc.get<std::locale>()).thousands_sep();
}
return std::use_facet<std::numpunct<Char> >(loc.get<std::locale>())
.thousands_sep();
}
} // namespace internal
#else
template <typename Char>
FMT_FUNC Char internal::thousands_sep_impl(locale_ref) {
@ -231,8 +228,8 @@ FMT_FUNC Char internal::thousands_sep_impl(locale_ref) {
}
#endif
FMT_FUNC void system_error::init(
int err_code, string_view format_str, format_args args) {
FMT_FUNC void system_error::init(int err_code, string_view format_str,
format_args args) {
error_code_ = err_code;
memory_buffer buffer;
format_system_error(buffer, err_code, vformat(format_str, args));
@ -242,20 +239,19 @@ FMT_FUNC void system_error::init(
namespace internal {
template <typename T>
int char_traits<char>::format_float(
char *buf, std::size_t size, const char *format, int precision, T value) {
return precision < 0 ?
FMT_SNPRINTF(buf, size, format, value) :
FMT_SNPRINTF(buf, size, format, precision, value);
int char_traits<char>::format_float(char *buf, std::size_t size,
const char *format, int precision,
T value) {
return precision < 0 ? FMT_SNPRINTF(buf, size, format, value)
: FMT_SNPRINTF(buf, size, format, precision, value);
}
template <typename T>
int char_traits<wchar_t>::format_float(
wchar_t *buf, std::size_t size, const wchar_t *format, int precision,
int char_traits<wchar_t>::format_float(wchar_t *buf, std::size_t size,
const wchar_t *format, int precision,
T value) {
return precision < 0 ?
FMT_SWPRINTF(buf, size, format, value) :
FMT_SWPRINTF(buf, size, format, precision, value);
return precision < 0 ? FMT_SWPRINTF(buf, size, format, value)
: FMT_SWPRINTF(buf, size, format, precision, value);
}
template <typename T>
@ -267,33 +263,21 @@ const char basic_data<T>::DIGITS[] =
"8081828384858687888990919293949596979899";
#define FMT_POWERS_OF_10(factor) \
factor * 10, \
factor * 100, \
factor * 1000, \
factor * 10000, \
factor * 100000, \
factor * 1000000, \
factor * 10000000, \
factor * 100000000, \
factor * 10, factor * 100, factor * 1000, factor * 10000, factor * 100000, \
factor * 1000000, factor * 10000000, factor * 100000000, \
factor * 1000000000
template <typename T>
const uint32_t basic_data<T>::POWERS_OF_10_32[] = {
1, FMT_POWERS_OF_10(1)
};
const uint32_t basic_data<T>::POWERS_OF_10_32[] = {1, FMT_POWERS_OF_10(1)};
template <typename T>
const uint32_t basic_data<T>::ZERO_OR_POWERS_OF_10_32[] = {
0, FMT_POWERS_OF_10(1)
};
const uint32_t basic_data<T>::ZERO_OR_POWERS_OF_10_32[] = {0,
FMT_POWERS_OF_10(1)};
template <typename T>
const uint64_t basic_data<T>::ZERO_OR_POWERS_OF_10_64[] = {
0,
FMT_POWERS_OF_10(1),
FMT_POWERS_OF_10(1000000000ull),
10000000000000000000ull
};
0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ull),
10000000000000000000ull};
// Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
// These are generated by support/compute-powers.py.
@ -341,13 +325,16 @@ const int16_t basic_data<T>::POW10_EXPONENTS[] = {
-50, -24, 3, 30, 56, 83, 109, 136, 162, 189, 216,
242, 269, 295, 322, 348, 375, 402, 428, 455, 481, 508,
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> 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";
template <typename T>
const char basic_data<T>::FOREGROUND_COLOR[] = "\x1b[38;2;";
template <typename T>
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).
class fp {
@ -371,8 +358,8 @@ class fp {
static FMT_CONSTEXPR_DECL const int significand_size =
sizeof(significand_type) * char_size;
fp(): f(0), e(0) {}
fp(uint64_t f_val, int e_val): f(f_val), e(e_val) {}
fp() : f(0), e(0) {}
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
// errors on platforms where double is not IEEE754.
@ -416,8 +403,8 @@ class fp {
// (lower) or successor (upper). The upper boundary is normalized and lower
// has the same exponent but may be not normalized.
void compute_boundaries(fp &lower, fp &upper) const {
lower = f == implicit_bit ?
fp((f << 2) - 1, e - 2) : fp((f << 1) - 1, e - 1);
lower =
f == implicit_bit ? fp((f << 2) - 1, e - 2) : 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.
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
// 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);
// 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) {
const double one_over_log2_10 = 0.30102999566398114; // 1 / log2(10)
int index = static_cast<int>(std::ceil(
(min_exponent + fp::significand_size - 1) * one_over_log2_10));
int index = static_cast<int>(
std::ceil((min_exponent + fp::significand_size - 1) * one_over_log2_10));
// Decimal exponent of the first (smallest) cached power of 10.
const int first_dec_exp = -348;
// Difference between 2 consecutive decimal exponents in cached powers of 10.
@ -463,10 +451,11 @@ FMT_FUNC fp get_cached_power(int min_exponent, int &pow10_exponent) {
return fp(data::POW10_SIGNIFICANDS[index], data::POW10_EXPONENTS[index]);
}
FMT_FUNC bool grisu2_round(
char *buf, int &size, int max_digits, uint64_t delta,
uint64_t remainder, uint64_t exp, uint64_t diff, int &exp10) {
while (remainder < diff && delta - remainder >= exp &&
FMT_FUNC bool grisu2_round(char *buf, int &size, int max_digits, uint64_t delta,
uint64_t remainder, uint64_t exp, uint64_t diff,
int &exp10) {
while (
remainder < diff && delta - remainder >= exp &&
(remainder + exp < diff || diff - remainder > remainder + exp - diff)) {
--buf[size - 1];
remainder += exp;
@ -474,44 +463,72 @@ FMT_FUNC bool grisu2_round(
if (size > max_digits) {
--size;
++exp10;
if (buf[size] >= '5')
return false;
if (buf[size] >= '5') return false;
}
return true;
}
// Generates output using Grisu2 digit-gen algorithm.
FMT_FUNC bool grisu2_gen_digits(
char *buf, int &size, uint32_t hi, uint64_t lo, int &exp,
uint64_t delta, const fp &one, const fp &diff, int max_digits) {
FMT_FUNC bool grisu2_gen_digits(char *buf, int &size, uint32_t hi, uint64_t lo,
int &exp, uint64_t delta, const fp &one,
const fp &diff, int max_digits) {
// Generate digits for the most significant part (hi).
while (exp > 0) {
uint32_t digit = 0;
// This optimization by miloyip reduces the number of integer divisions by
// one per iteration.
switch (exp) {
case 10: digit = hi / 1000000000; hi %= 1000000000; break;
case 9: digit = hi / 100000000; hi %= 100000000; break;
case 8: digit = hi / 10000000; hi %= 10000000; 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;
case 10:
digit = hi / 1000000000;
hi %= 1000000000;
break;
case 9:
digit = hi / 100000000;
hi %= 100000000;
break;
case 8:
digit = hi / 10000000;
hi %= 10000000;
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)
buf[size++] = static_cast<char>('0' + digit);
if (digit != 0 || size != 0) buf[size++] = static_cast<char>('0' + digit);
--exp;
uint64_t remainder = (static_cast<uint64_t>(hi) << -one.e) + lo;
if (remainder <= delta || size > max_digits) {
return grisu2_round(
buf, size, max_digits, delta, remainder,
static_cast<uint64_t>(data::POWERS_OF_10_32[exp]) << -one.e,
diff.f, exp);
static_cast<uint64_t>(data::POWERS_OF_10_32[exp]) << -one.e, diff.f,
exp);
}
}
// Generate digits for the least significant part (lo).
@ -519,8 +536,7 @@ FMT_FUNC bool grisu2_gen_digits(
lo *= 10;
delta *= 10;
char digit = static_cast<char>(lo >> -one.e);
if (digit != 0 || size != 0)
buf[size++] = static_cast<char>('0' + digit);
if (digit != 0 || size != 0) buf[size++] = static_cast<char>('0' + digit);
lo &= one.f - 1;
--exp;
if (lo < delta || size > max_digits) {
@ -531,11 +547,11 @@ FMT_FUNC bool grisu2_gen_digits(
}
#if FMT_CLANG_VERSION
# define FMT_FALLTHROUGH [[clang::fallthrough]];
#define FMT_FALLTHROUGH [[clang::fallthrough]];
#elif FMT_GCC_VERSION >= 700
# define FMT_FALLTHROUGH [[gnu::fallthrough]];
#define FMT_FALLTHROUGH [[gnu::fallthrough]];
#else
# define FMT_FALLTHROUGH
#define FMT_FALLTHROUGH
#endif
struct gen_digits_params {
@ -616,14 +632,13 @@ struct fill {
// The number is given as v = f * pow(10, exp), where f has size digits.
template <typename Handler>
FMT_FUNC void grisu2_prettify(const gen_digits_params &params,
int size, int exp, Handler &&handler) {
FMT_FUNC void grisu2_prettify(const gen_digits_params &params, int size,
int exp, Handler &&handler) {
if (!params.fixed) {
// Insert a decimal point after the first digit and add an exponent.
handler.insert(1, '.');
exp += size - 1;
if (size < params.num_digits)
handler.append(params.num_digits - size, '0');
if (size < params.num_digits) handler.append(params.num_digits - size, '0');
handler.append(params.upper ? 'E' : 'e');
write_exponent(exp, handler);
return;
@ -660,7 +675,9 @@ struct char_counter {
ptrdiff_t size;
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 append(ptrdiff_t n, char) { size += n; }
void append(char) { ++size; }
@ -678,7 +695,8 @@ FMT_FUNC gen_digits_params process_specs(const core_format_specs &specs,
case 'G':
params.upper = true;
FMT_FALLTHROUGH
case '\0': case 'g':
case '\0':
case 'g':
params.trailing_zeros = (specs.flags & HASH_FLAG) != 0;
if (-4 <= exp && exp < num_digits + 1) {
params.fixed = true;
@ -693,8 +711,7 @@ FMT_FUNC gen_digits_params process_specs(const core_format_specs &specs,
params.fixed = true;
params.trailing_zeros = true;
int adjusted_min_digits = num_digits + exp;
if (adjusted_min_digits > 0)
num_digits = adjusted_min_digits;
if (adjusted_min_digits > 0) num_digits = adjusted_min_digits;
break;
}
case 'E':
@ -713,7 +730,7 @@ FMT_FUNC gen_digits_params process_specs(const core_format_specs &specs,
template <typename Double>
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");
if (value == 0) {
gen_digits_params params = process_specs(specs, 1, buf);
@ -767,18 +784,16 @@ void sprintf_format(Double value, internal::buffer &buf,
FMT_ASSERT(buf.capacity() != 0, "empty buffer");
// 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_ptr = format;
*format_ptr++ = '%';
if (spec.has(HASH_FLAG))
*format_ptr++ = '#';
if (spec.has(HASH_FLAG)) *format_ptr++ = '#';
if (spec.precision >= 0) {
*format_ptr++ = '.';
*format_ptr++ = '*';
}
if (std::is_same<Double, long double>::value)
*format_ptr++ = 'L';
if (std::is_same<Double, long double>::value) *format_ptr++ = 'L';
*format_ptr++ = spec.type;
*format_ptr = '\0';
@ -819,15 +834,13 @@ FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) {
return;
}
int length = MultiByteToWideChar(
CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, FMT_NULL, 0);
if (length == 0)
FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
int length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(),
s_size, FMT_NULL, 0);
if (length == 0) FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
buffer_.resize(length + 1);
length = MultiByteToWideChar(
CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length);
if (length == 0)
FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size,
&buffer_[0], length);
if (length == 0) FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
buffer_[length] = 0;
}
@ -839,8 +852,7 @@ FMT_FUNC internal::utf16_to_utf8::utf16_to_utf8(wstring_view s) {
}
FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s) {
if (s.size() > INT_MAX)
return ERROR_INVALID_PARAMETER;
if (s.size() > INT_MAX) return ERROR_INVALID_PARAMETER;
int s_size = static_cast<int>(s.size());
if (s_size == 0) {
// 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;
}
int length = WideCharToMultiByte(
CP_UTF8, 0, s.data(), s_size, FMT_NULL, 0, FMT_NULL, FMT_NULL);
if (length == 0)
return GetLastError();
int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, FMT_NULL, 0,
FMT_NULL, FMT_NULL);
if (length == 0) return GetLastError();
buffer_.resize(length + 1);
length = WideCharToMultiByte(
CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, FMT_NULL, FMT_NULL);
if (length == 0)
return GetLastError();
length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, &buffer_[0],
length, FMT_NULL, FMT_NULL);
if (length == 0) return GetLastError();
buffer_[length] = 0;
return 0;
}
FMT_FUNC void windows_error::init(
int err_code, string_view format_str, format_args args) {
FMT_FUNC void windows_error::init(int err_code, string_view format_str,
format_args args) {
error_code_ = err_code;
memory_buffer buffer;
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));
}
FMT_FUNC void internal::format_windows_error(
internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT {
FMT_FUNC void internal::format_windows_error(internal::buffer &out,
int error_code,
string_view message) FMT_NOEXCEPT {
FMT_TRY {
wmemory_buffer buf;
buf.resize(inline_buffer_size);
for (;;) {
wchar_t *system_message = &buf[0];
int result = FormatMessageW(
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
FMT_NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
system_message, static_cast<uint32_t>(buf.size()), FMT_NULL);
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, FMT_NULL,
error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), system_message,
static_cast<uint32_t>(buf.size()), FMT_NULL);
if (result != 0) {
utf16_to_utf8 utf8_message;
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.
buf.resize(buf.size() * 2);
}
} FMT_CATCH(...) {}
}
FMT_CATCH(...) {}
format_error_code(out, error_code, message);
}
#endif // FMT_USE_WINDOWS_H
FMT_FUNC void format_system_error(
internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT {
FMT_FUNC void format_system_error(internal::buffer &out, int error_code,
string_view message) FMT_NOEXCEPT {
FMT_TRY {
memory_buffer buf;
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.
buf.resize(buf.size() * 2);
}
} FMT_CATCH(...) {}
}
FMT_CATCH(...) {}
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_FUNC void report_system_error(
int error_code, fmt::string_view message) FMT_NOEXCEPT {
FMT_FUNC void report_system_error(int error_code,
fmt::string_view message) FMT_NOEXCEPT {
report_error(format_system_error, error_code, message);
}
#if FMT_USE_WINDOWS_H
FMT_FUNC void report_windows_error(
int error_code, fmt::string_view message) FMT_NOEXCEPT {
FMT_FUNC void report_windows_error(int error_code,
fmt::string_view message) FMT_NOEXCEPT {
report_error(internal::format_windows_error, error_code, message);
}
#endif
@ -966,7 +979,7 @@ FMT_FUNC void vprint(wstring_view format_str, wformat_args args) {
FMT_END_NAMESPACE
#ifdef _MSC_VER
# pragma warning(pop)
#pragma warning(pop)
#endif
#endif // FMT_FORMAT_INL_H_

944
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

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

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

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

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

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

@ -10,7 +10,7 @@
#if defined(__MINGW32__) || defined(__CYGWIN__)
// Workaround MinGW bug https://sourceforge.net/p/mingw/bugs/2024/.
# undef __STRICT_ANSI__
#undef __STRICT_ANSI__
#endif
#include <errno.h>
@ -22,42 +22,42 @@
#include <cstddef>
#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
#include "format.h"
#ifndef FMT_POSIX
# if defined(_WIN32) && !defined(__MINGW32__)
#if defined(_WIN32) && !defined(__MINGW32__)
// Fix warnings about deprecated symbols.
# define FMT_POSIX(call) _##call
# else
# define FMT_POSIX(call) call
# endif
#define FMT_POSIX(call) _##call
#else
#define FMT_POSIX(call) call
#endif
#endif
// Calls to system functions are wrapped in FMT_SYSTEM for testability.
#ifdef FMT_SYSTEM
# define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
#define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
#else
# define FMT_SYSTEM(call) call
# ifdef _WIN32
#define FMT_SYSTEM(call) call
#ifdef _WIN32
// Fix warnings about deprecated symbols.
# define FMT_POSIX_CALL(call) ::_##call
# else
# define FMT_POSIX_CALL(call) ::call
# endif
#define FMT_POSIX_CALL(call) ::_##call
#else
#define FMT_POSIX_CALL(call) ::call
#endif
#endif
// Retries the expression while it evaluates to error_result and errno
// equals to EINTR.
#ifndef _WIN32
# define FMT_RETRY_VAL(result, expression, error_result) \
#define FMT_RETRY_VAL(result, expression, error_result) \
do { \
result = (expression); \
} while (result == error_result && errno == EINTR)
#else
# define FMT_RETRY_VAL(result, expression, error_result) result = (expression)
#define FMT_RETRY_VAL(result, expression, error_result) result = (expression)
#endif
#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
@ -143,13 +143,12 @@ class buffered_file {
buffered_file(const buffered_file &) = delete;
void operator=(const buffered_file &) = delete;
public:
buffered_file(buffered_file &&other) FMT_NOEXCEPT : file_(other.file_) {
other.file_ = FMT_NULL;
}
buffered_file& operator=(buffered_file &&other) {
buffered_file &operator=(buffered_file &&other) {
close();
file_ = other.file_;
other.file_ = FMT_NULL;
@ -167,14 +166,14 @@ class buffered_file {
// We place parentheses around fileno to workaround a bug in some versions
// 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) {
fmt::vprint(file_, format_str, 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...));
}
};
@ -211,11 +210,9 @@ class file {
void operator=(const file &) = delete;
public:
file(file &&other) FMT_NOEXCEPT : fd_(other.fd_) {
other.fd_ = -1;
}
file(file &&other) FMT_NOEXCEPT : fd_(other.fd_) { other.fd_ = -1; }
file& operator=(file &&other) {
file &operator=(file &&other) {
close();
fd_ = other.fd_;
other.fd_ = -1;
@ -268,14 +265,14 @@ long getpagesize();
#if (defined(LC_NUMERIC_MASK) || defined(_MSC_VER)) && \
!defined(__ANDROID__) && !defined(__CYGWIN__) && !defined(__OpenBSD__) && \
!defined(__NEWLIB_H__)
# define FMT_LOCALE
#define FMT_LOCALE
#endif
#ifdef FMT_LOCALE
// A "C" numeric locale.
class Locale {
private:
# ifdef _MSC_VER
#ifdef _MSC_VER
typedef _locale_t locale_t;
enum { LC_NUMERIC_MASK = LC_NUMERIC };
@ -284,14 +281,12 @@ class Locale {
return _create_locale(category_mask, locale);
}
static void freelocale(locale_t locale) {
_free_locale(locale);
}
static void freelocale(locale_t locale) { _free_locale(locale); }
static double strtod_l(const char *nptr, char **endptr, _locale_t locale) {
return _strtod_l(nptr, endptr, locale);
}
# endif
#endif
locale_t locale_;
@ -302,8 +297,7 @@ class Locale {
typedef locale_t Type;
Locale() : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL)) {
if (!locale_)
FMT_THROW(system_error(errno, "cannot create locale"));
if (!locale_) FMT_THROW(system_error(errno, "cannot create locale"));
}
~Locale() { freelocale(locale_); }

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

@ -24,8 +24,8 @@ class null_terminating_iterator {
public:
typedef std::ptrdiff_t difference_type;
typedef Char value_type;
typedef const Char* pointer;
typedef const Char& reference;
typedef const Char *pointer;
typedef const Char &reference;
typedef std::random_access_iterator_tag iterator_category;
null_terminating_iterator() : ptr_(0), end_(0) {}
@ -43,9 +43,7 @@ class null_terminating_iterator {
return *this;
}
FMT_CONSTEXPR Char operator*() const {
return ptr_ != end_ ? *ptr_ : Char();
}
FMT_CONSTEXPR Char operator*() const { return ptr_ != end_ ? *ptr_ : Char(); }
FMT_CONSTEXPR null_terminating_iterator operator++() {
++ptr_;
@ -76,8 +74,8 @@ class null_terminating_iterator {
return *this;
}
FMT_CONSTEXPR difference_type operator-(
null_terminating_iterator other) const {
FMT_CONSTEXPR difference_type
operator-(null_terminating_iterator other) const {
return ptr_ - other.ptr_;
}
@ -101,7 +99,9 @@ class null_terminating_iterator {
};
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>
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;
it = next;
} while ('0' <= *it && *it <= '9');
if (value > max_int)
eh.on_error("number is too big");
if (value > max_int) eh.on_error("number is too big");
return value;
}
@ -162,33 +161,38 @@ struct int_checker<true> {
static bool fits_in_int(int) { return true; }
};
class printf_precision_handler: public function<int> {
class printf_precision_handler : public function<int> {
public:
template <typename T>
typename std::enable_if<std::is_integral<T>::value, int>::type
operator()(T value) {
typename std::enable_if<std::is_integral<T>::value, int>::type operator()(
T value) {
if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
FMT_THROW(format_error("number is too big"));
return static_cast<int>(value);
}
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"));
return 0;
}
};
// 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:
template <typename T>
typename std::enable_if<std::is_integral<T>::value, bool>::type
operator()(T value) { return value == 0; }
typename std::enable_if<std::is_integral<T>::value, bool>::type operator()(
T value) {
return value == 0;
}
template <typename T>
typename std::enable_if<!std::is_integral<T>::value, bool>::type
operator()(T) { return false; }
typename std::enable_if<!std::is_integral<T>::value, bool>::type operator()(
T) {
return false;
}
};
template <typename T>
@ -200,7 +204,7 @@ struct make_unsigned_or_bool<bool> {
};
template <typename T, typename Context>
class arg_converter: public function<void> {
class arg_converter : public function<void> {
private:
typedef typename Context::char_type Char;
@ -212,16 +216,15 @@ class arg_converter: public function<void> {
: arg_(arg), type_(type) {}
void operator()(bool value) {
if (type_ != 's')
operator()<bool>(value);
if (type_ != 's') operator()<bool>(value);
}
template <typename U>
typename std::enable_if<std::is_integral<U>::value>::type
operator()(U value) {
typename std::enable_if<std::is_integral<U>::value>::type operator()(
U value) {
bool is_signed = type_ == 'd' || type_ == 'i';
typedef typename std::conditional<
std::is_same<T, void>::value, U, T>::type TargetType;
typedef typename std::conditional<std::is_same<T, void>::value, U, T>::type
TargetType;
if (const_check(sizeof(TargetType) <= sizeof(int))) {
// Extra casts are used to silence warnings.
if (is_signed) {
@ -262,7 +265,7 @@ void convert_arg(basic_format_arg<Context> &arg, Char type) {
// Converts an integer argument to char for printf.
template <typename Context>
class char_converter: public function<void> {
class char_converter : public function<void> {
private:
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) {}
template <typename T>
typename std::enable_if<std::is_integral<T>::value>::type
operator()(T value) {
typename std::enable_if<std::is_integral<T>::value>::type operator()(
T value) {
typedef typename Context::char_type Char;
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
// left alignment if it is negative.
template <typename Char>
class printf_width_handler: public function<unsigned> {
class printf_width_handler : public function<unsigned> {
private:
typedef basic_format_specs<Char> format_specs;
@ -304,8 +307,7 @@ class printf_width_handler: public function<unsigned> {
width = 0 - width;
}
unsigned int_max = std::numeric_limits<int>::max();
if (width > int_max)
FMT_THROW(format_error("number is too big"));
if (width > int_max) FMT_THROW(format_error("number is too big"));
return static_cast<unsigned>(width);
}
@ -329,10 +331,9 @@ using internal::printf; // For printing into memory_buffer.
template <typename Range>
class printf_arg_formatter;
template <
typename OutputIt, typename Char,
typename ArgFormatter =
printf_arg_formatter<back_insert_range<internal::basic_buffer<Char>>>>
template <typename OutputIt, typename Char,
typename ArgFormatter = printf_arg_formatter<
back_insert_range<internal::basic_buffer<Char>>>>
class basic_printf_context;
/**
@ -341,8 +342,8 @@ class basic_printf_context;
\endrst
*/
template <typename Range>
class printf_arg_formatter:
public internal::function<
class printf_arg_formatter
: public internal::function<
typename internal::arg_formatter_base<Range>::iterator>,
public internal::arg_formatter_base<Range> {
private:
@ -375,8 +376,8 @@ class printf_arg_formatter:
*/
printf_arg_formatter(internal::basic_buffer<char_type> &buffer,
format_specs &spec, context_type &ctx)
: base(back_insert_range<internal::basic_buffer<char_type>>(buffer), &spec,
ctx.locale()),
: base(back_insert_range<internal::basic_buffer<char_type>>(buffer),
&spec, ctx.locale()),
context_(ctx) {}
template <typename T>
@ -386,8 +387,7 @@ class printf_arg_formatter:
// use std::is_same instead.
if (std::is_same<T, bool>::value) {
format_specs &fmt_spec = *this->spec();
if (fmt_spec.type != 's')
return base::operator()(value ? 1 : 0);
if (fmt_spec.type != 's') return base::operator()(value ? 1 : 0);
fmt_spec.type = 0;
this->write(value != 0);
} else if (std::is_same<T, char_type>::value) {
@ -435,14 +435,11 @@ class printf_arg_formatter:
return base::operator()(value);
}
iterator operator()(monostate value) {
return base::operator()(value);
}
iterator operator()(monostate value) { return base::operator()(value); }
/** Formats a pointer. */
iterator operator()(const void *value) {
if (value)
return base::operator()(value);
if (value) return base::operator()(value);
this->spec()->type = 0;
write_null_pointer(char_type());
return this->out();
@ -458,7 +455,9 @@ class printf_arg_formatter:
template <typename T>
struct printf_formatter {
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>
auto format(const T &value, FormatContext &ctx) -> decltype(ctx.out()) {
@ -479,7 +478,9 @@ class basic_printf_context :
typedef Char char_type;
template <typename T>
struct formatter_type { typedef printf_formatter<T> type; };
struct formatter_type {
typedef printf_formatter<T> type;
};
private:
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
// to the maximum unsigned value, the next argument.
format_arg get_arg(
iterator it,
unsigned arg_index = (std::numeric_limits<unsigned>::max)());
iterator it, unsigned arg_index = (std::numeric_limits<unsigned>::max)());
// Parses argument index, flags and width and returns the argument index.
unsigned parse_header(iterator &it, format_specs &spec);
@ -510,17 +510,17 @@ class basic_printf_context :
basic_format_args<basic_printf_context> args)
: base(out, format_str, args) {}
using base::parse_context;
using base::out;
using base::advance_to;
using base::out;
using base::parse_context;
/** Formats stored arguments and writes the output to the range. */
void format();
};
template <typename OutputIt, typename Char, typename AF>
void basic_printf_context<OutputIt, Char, AF>::parse_flags(
format_specs &spec, iterator &it) {
void basic_printf_context<OutputIt, Char, AF>::parse_flags(format_specs &spec,
iterator &it) {
for (;;) {
switch (*it++) {
case '-':
@ -547,8 +547,8 @@ void basic_printf_context<OutputIt, Char, AF>::parse_flags(
template <typename OutputIt, typename Char, typename AF>
typename basic_printf_context<OutputIt, Char, AF>::format_arg
basic_printf_context<OutputIt, Char, AF>::get_arg(
iterator it, unsigned arg_index) {
basic_printf_context<OutputIt, Char, AF>::get_arg(iterator it,
unsigned arg_index) {
(void)it;
if (arg_index == std::numeric_limits<unsigned>::max())
return this->do_get_arg(this->parse_context().next_arg_id());
@ -569,8 +569,7 @@ unsigned basic_printf_context<OutputIt, Char, AF>::parse_header(
++it;
arg_index = value;
} else {
if (c == '0')
spec.fill_ = '0';
if (c == '0') spec.fill_ = '0';
if (value != 0) {
// Nonzero value means that we parsed width and don't need to
// parse it or flags again, so return now.
@ -631,7 +630,8 @@ void basic_printf_context<OutputIt, Char, AF>::format() {
format_arg arg = get_arg(it, arg_index);
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 (arg.is_arithmetic())
spec.align_ = ALIGN_NUMERIC;
@ -673,19 +673,19 @@ void basic_printf_context<OutputIt, Char, AF>::format() {
}
// Parse type.
if (!*it)
FMT_THROW(format_error("invalid format string"));
if (!*it) FMT_THROW(format_error("invalid format string"));
spec.type = static_cast<char>(*it++);
if (arg.is_integral()) {
// Normalize type.
switch (spec.type) {
case 'i': case 'u':
case 'i':
case 'u':
spec.type = 'd';
break;
case 'c':
// TODO: handle wchar_t better?
visit_format_arg(
internal::char_converter<basic_printf_context>(arg), arg);
visit_format_arg(internal::char_converter<basic_printf_context>(arg),
arg);
break;
}
}
@ -700,8 +700,9 @@ void basic_printf_context<OutputIt, Char, AF>::format() {
template <typename Buffer>
struct basic_printf_context_t {
typedef basic_printf_context<
std::back_insert_iterator<Buffer>, typename Buffer::value_type> type;
typedef basic_printf_context<std::back_insert_iterator<Buffer>,
typename Buffer::value_type>
type;
};
typedef basic_printf_context_t<internal::buffer>::type printf_context;
@ -716,9 +717,11 @@ typedef basic_format_args<wprintf_context> wprintf_args;
arguments and can be implicitly converted to `~fmt::printf_args`.
\endrst
*/
template<typename... Args>
inline format_arg_store<printf_context, Args...>
make_printf_args(const Args &... args) { return {args...}; }
template <typename... Args>
inline format_arg_store<printf_context, Args...> make_printf_args(
const Args &... args) {
return {args...};
}
/**
\rst
@ -726,15 +729,18 @@ inline format_arg_store<printf_context, Args...>
arguments and can be implicitly converted to `~fmt::wprintf_args`.
\endrst
*/
template<typename... Args>
inline format_arg_store<wprintf_context, Args...>
make_wprintf_args(const Args &... args) { return {args...}; }
template <typename... Args>
inline format_arg_store<wprintf_context, Args...> make_wprintf_args(
const Args &... args) {
return {args...};
}
template <typename S, typename Char = FMT_CHAR(S)>
inline std::basic_string<Char>
vsprintf(const S &format,
basic_format_args<typename basic_printf_context_t<
internal::basic_buffer<Char>>::type> args) {
inline std::basic_string<Char> vsprintf(
const S &format,
basic_format_args<
typename basic_printf_context_t<internal::basic_buffer<Char>>::type>
args) {
basic_memory_buffer<Char> buffer;
printf(buffer, to_string_view(format), args);
return to_string(buffer);
@ -750,26 +756,28 @@ vsprintf(const S &format,
\endrst
*/
template <typename S, typename... Args>
inline FMT_ENABLE_IF_T(
internal::is_string<S>::value, std::basic_string<FMT_CHAR(S)>)
sprintf(const S &format, const Args & ... args) {
inline FMT_ENABLE_IF_T(internal::is_string<S>::value,
std::basic_string<FMT_CHAR(S)>)
sprintf(const S &format, const Args &... args) {
internal::check_format_string<Args...>(format);
typedef internal::basic_buffer<FMT_CHAR(S)> buffer;
typedef typename basic_printf_context_t<buffer>::type context;
format_arg_store<context, Args...> as{ args... };
return vsprintf(to_string_view(format),
basic_format_args<context>(as));
format_arg_store<context, Args...> as{args...};
return vsprintf(to_string_view(format), basic_format_args<context>(as));
}
template <typename S, typename Char = FMT_CHAR(S)>
inline int vfprintf(std::FILE *f, const S &format,
basic_format_args<typename basic_printf_context_t<
internal::basic_buffer<Char>>::type> args) {
inline int vfprintf(
std::FILE *f, const S &format,
basic_format_args<
typename basic_printf_context_t<internal::basic_buffer<Char>>::type>
args) {
basic_memory_buffer<Char> buffer;
printf(buffer, to_string_view(format), args);
std::size_t size = buffer.size();
return std::fwrite(
buffer.data(), sizeof(Char), size, f) < size ? -1 : static_cast<int>(size);
return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
? -1
: static_cast<int>(size);
}
/**
@ -783,19 +791,20 @@ inline int vfprintf(std::FILE *f, const S &format,
*/
template <typename S, typename... Args>
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);
typedef internal::basic_buffer<FMT_CHAR(S)> buffer;
typedef typename basic_printf_context_t<buffer>::type context;
format_arg_store<context, Args...> as{ args... };
return vfprintf(f, to_string_view(format),
basic_format_args<context>(as));
format_arg_store<context, Args...> as{args...};
return vfprintf(f, to_string_view(format), basic_format_args<context>(as));
}
template <typename S, typename Char = FMT_CHAR(S)>
inline int vprintf(const S &format,
basic_format_args<typename basic_printf_context_t<
internal::basic_buffer<Char>>::type> args) {
inline int vprintf(
const S &format,
basic_format_args<
typename basic_printf_context_t<internal::basic_buffer<Char>>::type>
args) {
return vfprintf(stdout, to_string_view(format), args);
}
@ -810,20 +819,20 @@ inline int vprintf(const S &format,
*/
template <typename S, typename... Args>
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);
typedef internal::basic_buffer<FMT_CHAR(S)> buffer;
typedef typename basic_printf_context_t<buffer>::type context;
format_arg_store<context, Args...> as{ args... };
return vprintf(to_string_view(format_str),
basic_format_args<context>(as));
format_arg_store<context, Args...> as{args...};
return vprintf(to_string_view(format_str), basic_format_args<context>(as));
}
template <typename S, typename Char = FMT_CHAR(S)>
inline int vfprintf(std::basic_ostream<Char> &os,
const S &format,
basic_format_args<typename basic_printf_context_t<
internal::basic_buffer<Char>>::type> args) {
inline int vfprintf(
std::basic_ostream<Char> &os, const S &format,
basic_format_args<
typename basic_printf_context_t<internal::basic_buffer<Char>>::type>
args) {
basic_memory_buffer<Char> buffer;
printf(buffer, to_string_view(format), args);
internal::write(os, buffer);
@ -841,12 +850,12 @@ inline int vfprintf(std::basic_ostream<Char> &os,
*/
template <typename S, typename... Args>
inline FMT_ENABLE_IF_T(internal::is_string<S>::value, int)
fprintf(std::basic_ostream<FMT_CHAR(S)> &os,
const S &format_str, const Args & ... args) {
fprintf(std::basic_ostream<FMT_CHAR(S)> &os, const S &format_str,
const Args &... args) {
internal::check_format_string<Args...>(format_str);
typedef internal::basic_buffer<FMT_CHAR(S)> buffer;
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),
basic_format_args<context>(as));
}

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

@ -12,12 +12,13 @@
#ifndef FMT_RANGES_H_
#define FMT_RANGES_H_
#include "format.h"
#include <type_traits>
#include "format.h"
// output only up to N items from the range.
#ifndef FMT_RANGE_OUTPUT_LENGTH_LIMIT
# define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
#define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
#endif
FMT_BEGIN_NAMESPACE
@ -33,7 +34,8 @@ struct formatting_base {
template <typename Char, typename Enable = void>
struct formatting_range : formatting_base<Char> {
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 delimiter;
Char postfix;
@ -77,8 +79,8 @@ void copy(char ch, OutputIterator out) {
template <typename T>
class is_like_std_string {
template <typename U>
static auto check(U *p) ->
decltype(p->find('a'), p->length(), p->data(), int());
static auto check(U *p)
-> decltype(p->find('a'), p->length(), p->data(), int());
template <typename>
static void check(...);
@ -98,7 +100,8 @@ struct is_range_ : std::false_type {};
#if !FMT_MSC_VER || FMT_MSC_VER > 1800
template <typename T>
struct is_range_<T, typename std::conditional<
struct is_range_<
T, typename std::conditional<
false,
conditional_helper<decltype(internal::declval<T>().begin()),
decltype(internal::declval<T>().end())>,
@ -109,9 +112,10 @@ struct is_range_<T, typename std::conditional<
template <typename T>
class is_tuple_like_ {
template <typename U>
static auto check(U *p) ->
decltype(std::tuple_size<U>::value,
internal::declval<typename std::tuple_element<0, U>::type>(), int());
static auto check(U *p)
-> decltype(std::tuple_size<U>::value,
internal::declval<typename std::tuple_element<0, U>::type>(),
int());
template <typename>
static void check(...);
@ -133,9 +137,7 @@ template <typename T, T... N>
struct integer_sequence {
typedef T value_type;
static FMT_CONSTEXPR std::size_t size() {
return sizeof...(N);
}
static FMT_CONSTEXPR std::size_t size() { return sizeof...(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>
FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value>
get_indexes(T const &) { return {}; }
FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(
T const &) {
return {};
}
template <class Tuple, class F>
void for_each(Tuple &&tup, F &&f) {
@ -168,31 +172,36 @@ void for_each(Tuple &&tup, F &&f) {
for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
}
template<typename Arg>
FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&,
template <typename Arg>
FMT_CONSTEXPR const char *format_str_quoted(
bool add_space, const Arg &,
typename std::enable_if<
!is_like_std_string<typename std::decay<Arg>::type>::value>::type* = nullptr) {
!is_like_std_string<typename std::decay<Arg>::type>::value>::type * =
nullptr) {
return add_space ? " {}" : "{}";
}
template<typename Arg>
FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&,
template <typename Arg>
FMT_CONSTEXPR const char *format_str_quoted(
bool add_space, const Arg &,
typename std::enable_if<
is_like_std_string<typename std::decay<Arg>::type>::value>::type* = nullptr) {
is_like_std_string<typename std::decay<Arg>::type>::value>::type * =
nullptr) {
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 ? " \"{}\"" : "\"{}\"";
}
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"\"{}\"";
}
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 ? " '{}'" : "'{}'";
}
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"'{}'";
}
@ -205,14 +214,15 @@ struct is_tuple_like {
};
template <typename TupleT, typename Char>
struct formatter<TupleT, Char,
struct formatter<
TupleT, Char,
typename std::enable_if<fmt::is_tuple_like<TupleT>::value>::type> {
private:
private:
// C++11 generic lambda for format()
template <typename FormatContext>
struct format_each {
template <typename T>
void operator()(const T& v) {
void operator()(const T &v) {
if (i > 0) {
if (formatting.add_prepostfix_space) {
*out++ = ' ';
@ -226,12 +236,13 @@ private:
++i;
}
formatting_tuple<Char>& formatting;
std::size_t& i;
typename std::add_lvalue_reference<decltype(std::declval<FormatContext>().out())>::type out;
formatting_tuple<Char> &formatting;
std::size_t &i;
typename std::add_lvalue_reference<decltype(
std::declval<FormatContext>().out())>::type out;
};
public:
public:
formatting_tuple<Char> formatting;
template <typename ParseContext>
@ -264,7 +275,6 @@ struct is_range {
template <typename RangeT, typename Char>
struct formatter<RangeT, Char,
typename std::enable_if<fmt::is_range<RangeT>::value>::type> {
formatting_range<Char> formatting;
template <typename ParseContext>
@ -273,8 +283,8 @@ struct formatter<RangeT, Char,
}
template <typename FormatContext>
typename FormatContext::iterator format(
const RangeT &values, FormatContext &ctx) {
typename FormatContext::iterator format(const RangeT &values,
FormatContext &ctx) {
auto out = ctx.out();
internal::copy(formatting.prefix, out);
std::size_t i = 0;
@ -305,4 +315,3 @@ struct formatter<RangeT, Char,
FMT_END_NAMESPACE
#endif // FMT_RANGES_H_

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

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

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

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

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

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

@ -18,23 +18,22 @@
// formatted data,
// and support customize format per each sink.
#include "spdlog/common.h"
#include "spdlog/formatter.h"
#include "spdlog/sinks/sink.h"
#include <memory>
#include <string>
#include <vector>
#include "spdlog/common.h"
#include "spdlog/formatter.h"
#include "spdlog/sinks/sink.h"
namespace spdlog {
class logger
{
public:
class logger {
public:
logger(std::string name, sink_ptr single_sink);
logger(std::string name, sinks_init_list sinks);
template<typename It>
template <typename It>
logger(std::string name, It begin, It end);
virtual ~logger();
@ -42,96 +41,106 @@ public:
logger(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);
template<typename... Args>
void log(source_loc loc, level::level_enum lvl, const char *fmt, const Args &... args);
template <typename... 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(source_loc loc, level::level_enum lvl, const char *msg);
template<typename... Args>
template <typename... Args>
void trace(const char *fmt, const Args &... args);
template<typename... Args>
template <typename... Args>
void debug(const char *fmt, const Args &... args);
template<typename... Args>
template <typename... Args>
void info(const char *fmt, const Args &... args);
template<typename... Args>
template <typename... Args>
void warn(const char *fmt, const Args &... args);
template<typename... Args>
template <typename... Args>
void error(const char *fmt, const Args &... args);
template<typename... Args>
template <typename... Args>
void critical(const char *fmt, const Args &... args);
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
#ifndef _WIN32
#error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows
#else
template<typename... Args>
template <typename... Args>
void log(level::level_enum lvl, const wchar_t *fmt, const Args &... args);
template<typename... Args>
void log(source_loc source, level::level_enum lvl, const wchar_t *fmt, const Args &... args);
template <typename... 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);
template<typename... Args>
template <typename... 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);
template<typename... Args>
template <typename... 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);
template<typename... Args>
template <typename... Args>
void critical(const wchar_t *fmt, const Args &... args);
#endif // _WIN32
#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
// 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<
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
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<
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
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<
!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
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<
!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);
template<typename T>
template <typename T>
void debug(const T &msg);
template<typename T>
template <typename T>
void info(const T &msg);
template<typename T>
template <typename T>
void warn(const T &msg);
template<typename T>
template <typename T>
void error(const T &msg);
template<typename T>
template <typename T>
void critical(const T &msg);
bool should_log(level::level_enum msg_level) const;
@ -144,7 +153,8 @@ public:
// set formatting for the sinks in this logger.
// each sink will get a seperate instance of the formatter object.
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
void flush();
@ -162,7 +172,7 @@ public:
// create new logger with same sinks and configuration.
virtual std::shared_ptr<logger> clone(std::string logger_name);
protected:
protected:
virtual void sink_it_(details::log_msg &msg);
virtual void flush_();
@ -172,14 +182,16 @@ protected:
// print the error to stderr with the max rate of 1 message/minute.
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
// defined(SPDLOG_ENABLE_MESSAGE_COUNTER))
void incr_msg_counter_(details::log_msg &msg);
const std::string name_;
std::vector<sink_ptr> sinks_;
spdlog::level_t level_{spdlog::logger::default_level()};
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_{
[this](const std::string &msg) { this->default_err_handler_(msg); }};
std::atomic<time_t> last_err_time_{0};
std::atomic<size_t> msg_counter_{1};
};

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

@ -9,17 +9,18 @@
#include "spdlog/spdlog.h"
#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 <chrono>
#include <mutex>
#include <string>
#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)
#define SPDLOG_ANDROID_RETRIES 2
#endif
@ -30,27 +31,19 @@ namespace sinks {
/*
* Android sink (logging using __android_log_write)
*/
template<typename Mutex>
class android_sink final : public base_sink<Mutex>
{
public:
template <typename Mutex>
class android_sink final : public base_sink<Mutex> {
public:
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
{
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_)
{
if (use_raw_msg_) {
details::fmt_helper::append_string_view(msg.payload, formatted);
}
else
{
} else {
sink::formatter_->format(msg, formatted);
}
formatted.push_back('\0');
@ -59,26 +52,23 @@ protected:
// 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))
{
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)
{
if (ret < 0) {
throw spdlog_ex("__android_log_write() failed", ret);
}
}
void flush_() override {}
private:
static android_LogPriority convert_to_android_(spdlog::level::level_enum level)
{
switch (level)
{
private:
static android_LogPriority convert_to_android_(
spdlog::level::level_enum level) {
switch (level) {
case spdlog::level::trace:
return ANDROID_LOG_VERBOSE;
case spdlog::level::debug:
@ -106,15 +96,15 @@ using android_sink_st = android_sink<details::null_mutex>;
// Create and register android syslog logger
template<typename Factory = default_factory>
inline std::shared_ptr<logger> android_logger_mt(const std::string &logger_name, const std::string &tag = "spdlog")
{
template <typename Factory = default_factory>
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);
}
template<typename Factory = default_factory>
inline std::shared_ptr<logger> android_logger_st(const std::string &logger_name, const std::string &tag = "spdlog")
{
template <typename Factory = default_factory>
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);
}

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

@ -9,16 +9,16 @@
#include "spdlog/spdlog.h"
#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 <mutex>
#include <string>
#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 sinks {
@ -28,17 +28,17 @@ namespace sinks {
* of the message.
* If no color terminal detected, omit the escape codes.
*/
template<typename TargetStream, class ConsoleMutex>
class ansicolor_sink final : public sink
{
public:
template <typename TargetStream, class ConsoleMutex>
class ansicolor_sink final : public sink {
public:
using mutex_t = typename ConsoleMutex::mutex_t;
ansicolor_sink()
: target_file_(TargetStream::stream())
, mutex_(ConsoleMutex::mutex())
: target_file_(TargetStream::stream()),
mutex_(ConsoleMutex::mutex())
{
should_do_colors_ = details::os::in_terminal(target_file_) && details::os::is_color_terminal();
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;
@ -53,8 +53,7 @@ public:
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)
{
void set_color(level::level_enum color_level, const std::string &color) {
std::lock_guard<mutex_t> lock(mutex_);
colors_[color_level] = color;
}
@ -89,16 +88,14 @@ public:
const std::string on_cyan = "\033[46m";
const std::string on_white = "\033[47m";
void log(const details::log_msg &msg) override
{
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)
{
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
@ -107,39 +104,36 @@ public:
print_ccode_(reset);
// after color range
print_range_(formatted, msg.color_range_end, formatted.size());
}
else // no color
} else // no color
{
print_range_(formatted, 0, formatted.size());
}
fflush(target_file_);
}
void flush() override
{
void flush() override {
std::lock_guard<mutex_t> lock(mutex_);
fflush(target_file_);
}
void set_pattern(const std::string &pattern) final
{
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));
formatter_ =
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_);
formatter_ = std::move(sink_formatter);
}
private:
void print_ccode_(const std::string &color_code)
{
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)
{
void print_range_(const fmt::memory_buffer &formatted, size_t start,
size_t end) {
fwrite(formatted.data() + start, sizeof(char), end - start, target_file_);
}
@ -147,14 +141,19 @@ private:
mutex_t &mutex_;
bool should_do_colors_;
std::unordered_map<level::level_enum, std::string, level::level_hasher> 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_st = ansicolor_sink<details::console_stdout, details::console_nullmutex>;
using ansicolor_stdout_sink_mt =
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_st = ansicolor_sink<details::console_stderr, details::console_nullmutex>;
using ansicolor_stderr_sink_mt =
ansicolor_sink<details::console_stderr, details::console_mutex>;
using ansicolor_stderr_sink_st =
ansicolor_sink<details::console_stderr, details::console_nullmutex>;
} // namespace sinks

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

@ -18,49 +18,43 @@
namespace spdlog {
namespace sinks {
template<typename Mutex>
class base_sink : public sink
{
public:
template <typename Mutex>
class base_sink : public sink {
public:
base_sink() = default;
base_sink(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_);
sink_it_(msg);
}
void flush() final
{
void flush() final {
std::lock_guard<Mutex> lock(mutex_);
flush_();
}
void set_pattern(const std::string &pattern) final
{
void set_pattern(const std::string &pattern) final {
std::lock_guard<Mutex> lock(mutex_);
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_);
set_formatter_(std::move(sink_formatter));
}
protected:
protected:
virtual void sink_it_(const details::log_msg &msg) = 0;
virtual void flush_() = 0;
virtual void set_pattern_(const std::string &pattern)
{
virtual void set_pattern_(const std::string &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);
}
Mutex mutex_;

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

@ -9,41 +9,35 @@
#include "spdlog/spdlog.h"
#endif
#include <mutex>
#include <string>
#include "spdlog/details/file_helper.h"
#include "spdlog/details/null_mutex.h"
#include "spdlog/sinks/base_sink.h"
#include <mutex>
#include <string>
namespace spdlog {
namespace sinks {
/*
* Trivial file sink with single file as target
*/
template<typename Mutex>
class basic_file_sink final : public base_sink<Mutex>
{
public:
explicit basic_file_sink(const filename_t &filename, bool truncate = false)
{
template <typename Mutex>
class basic_file_sink final : public base_sink<Mutex> {
public:
explicit basic_file_sink(const filename_t &filename, bool truncate = false) {
file_helper_.open(filename, truncate);
}
protected:
void sink_it_(const details::log_msg &msg) override
{
protected:
void sink_it_(const details::log_msg &msg) override {
fmt::memory_buffer formatted;
sink::formatter_->format(msg, formatted);
file_helper_.write(formatted);
}
void flush_() override
{
file_helper_.flush();
}
void flush_() override { file_helper_.flush(); }
private:
private:
details::file_helper file_helper_;
};
@ -55,16 +49,20 @@ using basic_file_sink_st = basic_file_sink<details::null_mutex>;
//
// factory functions
//
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)
{
return Factory::template create<sinks::basic_file_sink_mt>(logger_name, filename, truncate);
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) {
return Factory::template create<sinks::basic_file_sink_mt>(
logger_name, filename, truncate);
}
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)
{
return Factory::template create<sinks::basic_file_sink_st>(logger_name, filename, truncate);
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) {
return Factory::template create<sinks::basic_file_sink_st>(
logger_name, filename, truncate);
}
} // namespace spdlog

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

@ -9,33 +9,35 @@
#include "spdlog/spdlog.h"
#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 <cstdio>
#include <ctime>
#include <mutex>
#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 sinks {
/*
* 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
static filename_t calc_filename(const filename_t &filename, const tm &now_tm)
{
static filename_t calc_filename(const filename_t &filename,
const tm &now_tm) {
filename_t basename, ext;
std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
std::conditional<std::is_same<filename_t::value_type, char>::value, fmt::memory_buffer, fmt::wmemory_buffer>::type w;
fmt::format_to(
w, SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}"), basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday, ext);
std::tie(basename, ext) =
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;
fmt::format_to(w, SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}"), basename,
now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday,
ext);
return fmt::to_string(w);
}
};
@ -43,33 +45,32 @@ struct daily_filename_calculator
/*
* Rotating file sink based on date. rotates at midnight
*/
template<typename Mutex, typename FileNameCalc = daily_filename_calculator>
class daily_file_sink final : public base_sink<Mutex>
{
public:
template <typename Mutex, typename FileNameCalc = daily_filename_calculator>
class daily_file_sink final : public base_sink<Mutex> {
public:
// create daily file sink which rotates on given time
daily_file_sink(filename_t base_filename, int rotation_hour, int rotation_minute, bool truncate = false)
: base_filename_(std::move(base_filename))
, rotation_h_(rotation_hour)
, rotation_m_(rotation_minute)
, truncate_(truncate)
{
if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || rotation_minute > 59)
{
daily_file_sink(filename_t base_filename, int rotation_hour,
int rotation_minute, bool truncate = false)
: base_filename_(std::move(base_filename)),
rotation_h_(rotation_hour),
rotation_m_(rotation_minute),
truncate_(truncate) {
if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 ||
rotation_minute > 59) {
throw spdlog_ex("daily_file_sink: Invalid rotation time in ctor");
}
auto now = log_clock::now();
file_helper_.open(FileNameCalc::calc_filename(base_filename_, now_tm(now)), truncate_);
file_helper_.open(FileNameCalc::calc_filename(base_filename_, now_tm(now)),
truncate_);
rotation_tp_ = next_rotation_tp_();
}
protected:
void sink_it_(const details::log_msg &msg) override
{
if (msg.time >= rotation_tp_)
{
file_helper_.open(FileNameCalc::calc_filename(base_filename_, now_tm(msg.time)), truncate_);
protected:
void sink_it_(const details::log_msg &msg) override {
if (msg.time >= rotation_tp_) {
file_helper_.open(
FileNameCalc::calc_filename(base_filename_, now_tm(msg.time)),
truncate_);
rotation_tp_ = next_rotation_tp_();
}
fmt::memory_buffer formatted;
@ -77,28 +78,22 @@ protected:
file_helper_.write(formatted);
}
void flush_() override
{
file_helper_.flush();
}
void flush_() override { file_helper_.flush(); }
private:
tm now_tm(log_clock::time_point tp)
{
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_()
{
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)
{
if (rotation_time > now) {
return rotation_time;
}
return {rotation_time + std::chrono::hours(24)};
@ -120,17 +115,21 @@ using daily_file_sink_st = daily_file_sink<details::null_mutex>;
//
// factory functions
//
template<typename Factory = default_factory>
inline std::shared_ptr<logger> daily_logger_mt(
const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, bool truncate = false)
{
return Factory::template create<sinks::daily_file_sink_mt>(logger_name, filename, hour, minute, truncate);
template <typename Factory = default_factory>
inline std::shared_ptr<logger> daily_logger_mt(const std::string &logger_name,
const filename_t &filename,
int hour = 0, int minute = 0,
bool truncate = false) {
return Factory::template create<sinks::daily_file_sink_mt>(
logger_name, filename, hour, minute, truncate);
}
template<typename Factory = default_factory>
inline std::shared_ptr<logger> daily_logger_st(
const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, bool truncate = false)
{
return Factory::template create<sinks::daily_file_sink_st>(logger_name, filename, hour, minute, truncate);
template <typename Factory = default_factory>
inline std::shared_ptr<logger> daily_logger_st(const std::string &logger_name,
const filename_t &filename,
int hour = 0, int minute = 0,
bool truncate = false) {
return Factory::template create<sinks::daily_file_sink_st>(
logger_name, filename, hour, minute, truncate);
}
} // namespace spdlog

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

@ -9,78 +9,66 @@
#include "spdlog/spdlog.h"
#endif
#include "base_sink.h"
#include "spdlog/details/log_msg.h"
#include "spdlog/details/null_mutex.h"
#include <algorithm>
#include <memory>
#include <mutex>
#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
// is called
namespace spdlog {
namespace sinks {
template<typename Mutex>
class dist_sink : public base_sink<Mutex>
{
public:
template <typename Mutex>
class dist_sink : public base_sink<Mutex> {
public:
dist_sink() = default;
dist_sink(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_);
sinks_.push_back(sink);
}
void remove_sink(std::shared_ptr<sink> 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)
{
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))
{
protected:
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_)
{
void flush_() override {
for (auto &sink : sinks_) {
sink->flush();
}
}
void set_pattern_(const std::string &pattern) override
{
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
{
void set_formatter_(
std::unique_ptr<spdlog::formatter> sink_formatter) override {
base_sink<Mutex>::formatter_ = std::move(sink_formatter);
for (auto &sink : sinks_)
{
for (auto &sink : sinks_) {
sink->set_formatter(base_sink<Mutex>::formatter_->clone());
}
}

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

@ -11,29 +11,26 @@
#if defined(_WIN32)
#include "spdlog/details/null_mutex.h"
#include "spdlog/sinks/base_sink.h"
#include <winbase.h>
#include <mutex>
#include <string>
#include "spdlog/details/null_mutex.h"
#include "spdlog/sinks/base_sink.h"
namespace spdlog {
namespace sinks {
/*
* MSVC sink (logging using OutputDebugStringA)
*/
template<typename Mutex>
class msvc_sink : public base_sink<Mutex>
{
public:
template <typename Mutex>
class msvc_sink : public base_sink<Mutex> {
public:
explicit msvc_sink() {}
protected:
void sink_it_(const details::log_msg &msg) override
{
protected:
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());

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

@ -9,18 +9,17 @@
#include "spdlog/spdlog.h"
#endif
#include <mutex>
#include "spdlog/details/null_mutex.h"
#include "spdlog/sinks/base_sink.h"
#include <mutex>
namespace spdlog {
namespace sinks {
template<typename Mutex>
class null_sink : public base_sink<Mutex>
{
protected:
template <typename Mutex>
class null_sink : public base_sink<Mutex> {
protected:
void sink_it_(const details::log_msg &) override {}
void flush_() override {}
};
@ -30,17 +29,15 @@ using null_sink_st = null_sink<details::null_mutex>;
} // namespace sinks
template<typename Factory = default_factory>
inline std::shared_ptr<logger> null_logger_mt(const std::string &logger_name)
{
template <typename Factory = default_factory>
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);
null_logger->set_level(level::off);
return null_logger;
}
template<typename Factory = default_factory>
inline std::shared_ptr<logger> null_logger_st(const std::string &logger_name)
{
template <typename Factory = default_factory>
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);
null_logger->set_level(level::off);
return null_logger;

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

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

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

@ -9,11 +9,6 @@
#include "spdlog/spdlog.h"
#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 <chrono>
#include <ctime>
@ -21,93 +16,90 @@
#include <string>
#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 sinks {
//
// Rotating file sink based on size
//
template<typename Mutex>
class rotating_file_sink final : public base_sink<Mutex>
{
public:
rotating_file_sink(filename_t base_filename, std::size_t max_size, std::size_t max_files)
: base_filename_(std::move(base_filename))
, max_size_(max_size)
, max_files_(max_files)
{
template <typename Mutex>
class rotating_file_sink final : public base_sink<Mutex> {
public:
rotating_file_sink(filename_t base_filename, std::size_t max_size,
std::size_t max_files)
: base_filename_(std::move(base_filename)),
max_size_(max_size),
max_files_(max_files) {
file_helper_.open(calc_filename(base_filename_, 0));
current_size_ = file_helper_.size(); // expensive. called only once
}
// calc filename according to index and file extension if exists.
// 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)
{
typename std::conditional<std::is_same<filename_t::value_type, char>::value, fmt::memory_buffer, fmt::wmemory_buffer>::type w;
if (index != 0u)
{
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;
if (index != 0u) {
filename_t basename, ext;
std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
std::tie(basename, ext) =
details::file_helper::split_by_extension(filename);
fmt::format_to(w, SPDLOG_FILENAME_T("{}.{}{}"), basename, index, ext);
}
else
{
} else {
fmt::format_to(w, SPDLOG_FILENAME_T("{}"), filename);
}
return fmt::to_string(w);
}
protected:
void sink_it_(const details::log_msg &msg) override
{
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_)
{
if (current_size_ > max_size_) {
rotate_();
current_size_ = formatted.size();
}
file_helper_.write(formatted);
}
void flush_() override
{
file_helper_.flush();
}
void flush_() override { file_helper_.flush(); }
private:
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_()
{
void rotate_() {
using details::os::filename_to_str;
file_helper_.close();
for (auto i = max_files_; i > 0; --i)
{
for (auto i = max_files_; i > 0; --i) {
filename_t src = calc_filename(base_filename_, i - 1);
if (!details::file_helper::file_exists(src))
{
if (!details::file_helper::file_exists(src)) {
continue;
}
filename_t target = calc_filename(base_filename_, i);
if (!rename_file(src, target))
{
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?).
// 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!
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);
throw spdlog_ex("rotating_file_sink: failed renaming " +
filename_to_str(src) + " to " +
filename_to_str(target),
errno);
}
}
}
@ -116,8 +108,8 @@ private:
// 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)
{
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;
@ -139,17 +131,19 @@ using rotating_file_sink_st = rotating_file_sink<details::null_mutex>;
// factory functions
//
template<typename Factory = default_factory>
template <typename Factory = default_factory>
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)
{
return Factory::template create<sinks::rotating_file_sink_mt>(logger_name, filename, max_file_size, 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);
}
template<typename Factory = default_factory>
template <typename Factory = default_factory>
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)
{
return Factory::template create<sinks::rotating_file_sink_st>(logger_name, filename, max_file_size, 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);
}
} // namespace spdlog

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

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

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

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

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

@ -9,34 +9,29 @@
#include "spdlog/spdlog.h"
#endif
#include "spdlog/details/console_globals.h"
#include "spdlog/details/null_mutex.h"
#include <cstdio>
#include <memory>
#include <mutex>
#include "spdlog/details/console_globals.h"
#include "spdlog/details/null_mutex.h"
namespace spdlog {
namespace sinks {
template<typename TargetStream, typename ConsoleMutex>
class stdout_sink final : public sink
{
public:
template <typename TargetStream, typename ConsoleMutex>
class stdout_sink final : public sink {
public:
using mutex_t = typename ConsoleMutex::mutex_t;
stdout_sink()
: mutex_(ConsoleMutex::mutex())
, file_(TargetStream::stream())
{
}
: mutex_(ConsoleMutex::mutex()), file_(TargetStream::stream()) {}
~stdout_sink() override = default;
stdout_sink(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_);
fmt::memory_buffer formatted;
formatter_->format(msg, formatted);
@ -44,59 +39,62 @@ public:
fflush(TargetStream::stream());
}
void flush() override
{
void flush() override {
std::lock_guard<mutex_t> lock(mutex_);
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_);
formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
formatter_ =
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_);
formatter_ = std::move(sink_formatter);
}
private:
private:
mutex_t &mutex_;
FILE *file_;
};
using stdout_sink_mt = stdout_sink<details::console_stdout, details::console_mutex>;
using stdout_sink_st = stdout_sink<details::console_stdout, details::console_nullmutex>;
using stdout_sink_mt =
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_st = stdout_sink<details::console_stderr, details::console_nullmutex>;
using stderr_sink_mt =
stdout_sink<details::console_stderr, details::console_mutex>;
using stderr_sink_st =
stdout_sink<details::console_stderr, details::console_nullmutex>;
} // namespace sinks
// factory methods
template<typename Factory = default_factory>
inline std::shared_ptr<logger> stdout_logger_mt(const std::string &logger_name)
{
template <typename Factory = default_factory>
inline std::shared_ptr<logger> stdout_logger_mt(
const std::string &logger_name) {
return Factory::template create<sinks::stdout_sink_mt>(logger_name);
}
template<typename Factory = default_factory>
inline std::shared_ptr<logger> stdout_logger_st(const std::string &logger_name)
{
template <typename Factory = default_factory>
inline std::shared_ptr<logger> stdout_logger_st(
const std::string &logger_name) {
return Factory::template create<sinks::stdout_sink_st>(logger_name);
}
template<typename Factory = default_factory>
inline std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name)
{
template <typename Factory = default_factory>
inline std::shared_ptr<logger> stderr_logger_mt(
const std::string &logger_name) {
return Factory::template create<sinks::stderr_sink_mt>(logger_name);
}
template<typename Factory = default_factory>
inline std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name)
{
template <typename Factory = default_factory>
inline std::shared_ptr<logger> stderr_logger_st(
const std::string &logger_name) {
return Factory::template create<sinks::stderr_sink_st>(logger_name);
}
} // namespace spdlog

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

@ -9,11 +9,12 @@
#include "spdlog/spdlog.h"
#endif
#include "spdlog/sinks/base_sink.h"
#include <syslog.h>
#include <array>
#include <string>
#include <syslog.h>
#include "spdlog/sinks/base_sink.h"
namespace spdlog {
namespace sinks {
@ -22,14 +23,13 @@ namespace sinks {
*
* Locking is not needed, as `syslog()` itself is thread-safe.
*/
template<typename Mutex>
class syslog_sink : public base_sink<Mutex>
{
public:
template <typename Mutex>
class syslog_sink : public base_sink<Mutex> {
public:
//
explicit syslog_sink(std::string ident = "", int syslog_option = 0, int syslog_facility = LOG_USER)
: ident_(std::move(ident))
{
explicit syslog_sink(std::string ident = "", int syslog_option = 0,
int syslog_facility = LOG_USER)
: ident_(std::move(ident)) {
priorities_[static_cast<size_t>(level::trace)] = LOG_DEBUG;
priorities_[static_cast<size_t>(level::debug)] = LOG_DEBUG;
priorities_[static_cast<size_t>(level::info)] = LOG_INFO;
@ -39,26 +39,24 @@ public:
priorities_[static_cast<size_t>(level::off)] = LOG_INFO;
// 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
{
::closelog();
}
~syslog_sink() override { ::closelog(); }
syslog_sink(const syslog_sink &) = delete;
syslog_sink &operator=(const syslog_sink &) = delete;
protected:
void sink_it_(const details::log_msg &msg) override
{
::syslog(syslog_prio_from_level(msg), "%s", fmt::to_string(msg.payload).c_str());
protected:
void sink_it_(const details::log_msg &msg) override {
::syslog(syslog_prio_from_level(msg), "%s",
fmt::to_string(msg.payload).c_str());
}
void flush_() override {}
private:
private:
std::array<int, 7> priorities_;
// must store the ident because the man says openlog might use the pointer as
// is and not a string copy
@ -67,8 +65,7 @@ private:
//
// 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)];
}
};
@ -78,17 +75,19 @@ using syslog_sink_st = syslog_sink<details::null_mutex>;
} // namespace sinks
// Create and register a syslog logger
template<typename Factory = default_factory>
template <typename Factory = default_factory>
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))
{
return Factory::template create<sinks::syslog_sink_mt>(logger_name, syslog_ident, syslog_option, syslog_facility);
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);
}
template<typename Factory = default_factory>
template <typename Factory = default_factory>
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))
{
return Factory::template create<sinks::syslog_sink_st>(logger_name, syslog_ident, syslog_option, syslog_facility);
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);
}
} // namespace spdlog

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

@ -9,16 +9,17 @@
#include "spdlog/spdlog.h"
#endif
#include "spdlog/common.h"
#include "spdlog/details/console_globals.h"
#include "spdlog/details/null_mutex.h"
#include "spdlog/sinks/sink.h"
#include <wincon.h>
#include <memory>
#include <mutex>
#include <string>
#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 sinks {
@ -26,10 +27,9 @@ namespace sinks {
* Windows color console sink. Uses WriteConsoleA to write to the console with
* colors
*/
template<typename OutHandle, typename ConsoleMutex>
class wincolor_sink : public sink
{
public:
template <typename OutHandle, typename ConsoleMutex>
class wincolor_sink : public sink {
public:
const WORD BOLD = FOREGROUND_INTENSITY;
const WORD RED = FOREGROUND_RED;
const WORD GREEN = FOREGROUND_GREEN;
@ -38,40 +38,33 @@ public:
const WORD YELLOW = FOREGROUND_RED | FOREGROUND_GREEN;
wincolor_sink()
: out_handle_(OutHandle::handle())
, mutex_(ConsoleMutex::mutex())
{
: out_handle_(OutHandle::handle()), 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::critical] =
BACKGROUND_RED | WHITE | BOLD; // white bold on red background
colors_[level::off] = 0;
}
~wincolor_sink() override
{
this->flush();
}
~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)
{
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
{
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)
{
if (msg.color_range_end > msg.color_range_start) {
// before color range
print_range_(formatted, 0, msg.color_range_start);
@ -82,50 +75,49 @@ public:
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
} else // print without colors if color range is invalid
{
print_range_(formatted, 0, formatted.size());
}
}
void flush() final override
{
void flush() final override {
// windows console always flushed?
}
void set_pattern(const std::string &pattern) override final
{
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));
formatter_ =
std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
}
void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override final
{
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:
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)
{
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));
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)
{
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);
::WriteConsoleA(out_handle_, formatted.data() + start, size, nullptr,
nullptr);
}
HANDLE out_handle_;
@ -133,11 +125,15 @@ private:
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_st = wincolor_sink<details::console_stdout, details::console_nullmutex>;
using wincolor_stdout_sink_mt =
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_st = wincolor_sink<details::console_stderr, details::console_nullmutex>;
using wincolor_stderr_sink_mt =
wincolor_sink<details::console_stderr, details::console_mutex>;
using wincolor_stderr_sink_st =
wincolor_sink<details::console_stderr, details::console_nullmutex>;
} // namespace sinks
} // namespace spdlog

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

@ -9,26 +9,26 @@
#define SPDLOG_H
#pragma once
#include "spdlog/common.h"
#include "spdlog/details/registry.h"
#include "spdlog/logger.h"
#include "spdlog/version.h"
#include <chrono>
#include <functional>
#include <memory>
#include <string>
#include "spdlog/common.h"
#include "spdlog/details/registry.h"
#include "spdlog/logger.h"
#include "spdlog/version.h"
namespace spdlog {
// Default logger factory- creates synchronous loggers
struct synchronous_factory
{
template<typename Sink, typename... SinkArgs>
static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&... args)
{
struct synchronous_factory {
template <typename Sink, typename... SinkArgs>
static std::shared_ptr<spdlog::logger> create(std::string logger_name,
SinkArgs &&... args) {
auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
auto new_logger = std::make_shared<logger>(std::move(logger_name), std::move(sink));
auto new_logger =
std::make_shared<logger>(std::move(logger_name), std::move(sink));
details::registry::instance().initialize_logger(new_logger);
return new_logger;
}
@ -40,95 +40,85 @@ using default_factory = synchronous_factory;
// The logger's level, formatter and flush level will be set according the
// global settings.
// Example:
// spdlog::create<daily_file_sink_st>("logger_name", "dailylog_filename", 11, 59);
template<typename Sink, typename... SinkArgs>
inline std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&... sink_args)
{
return default_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
// spdlog::create<daily_file_sink_st>("logger_name", "dailylog_filename", 11,
// 59);
template <typename Sink, typename... SinkArgs>
inline std::shared_ptr<spdlog::logger> create(std::string logger_name,
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
// exist.
// 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);
}
// Set global formatter. Each sink in each logger will get a clone of this object
inline void set_formatter(std::unique_ptr<spdlog::formatter> formatter)
{
// Set global formatter. Each sink in each logger will get a clone of this
// object
inline void set_formatter(std::unique_ptr<spdlog::formatter> formatter) {
details::registry::instance().set_formatter(std::move(formatter));
}
// Set global format string.
// 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)
{
set_formatter(std::unique_ptr<spdlog::formatter>(new pattern_formatter(std::move(pattern), time_type)));
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 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);
}
// 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);
}
// Start/Restart a periodic flusher thread
// 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);
}
// 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));
}
// 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));
}
// Apply a user defined function on all registered loggers
// Example:
// 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);
}
// 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);
}
// Drop all references from the registry
inline void drop_all()
{
details::registry::instance().drop_all();
}
inline void drop_all() { details::registry::instance().drop_all(); }
// stop any running threads started by spdlog and clean registry loggers
inline void shutdown()
{
details::registry::instance().shutdown();
}
inline void shutdown() { details::registry::instance().shutdown(); }
// Automatic registration of loggers when using spdlog::create() or spdlog::create_async
inline void set_automatic_registration(bool automatic_registation)
{
details::registry::instance().set_automatic_registration(automatic_registation);
// Automatic registration of loggers when using spdlog::create() or
// spdlog::create_async
inline void set_automatic_registration(bool automatic_registation) {
details::registry::instance().set_automatic_registration(
automatic_registation);
}
// API for using default logger (stdout_color_mt),
@ -144,153 +134,131 @@ inline void set_automatic_registration(bool automatic_registation)
// IMPORTANT:
// The default API is thread safe (for _mt loggers), but:
// set_default_logger() *should not* be used concurrently with the default API.
// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
// 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();
}
inline spdlog::logger *default_logger_raw()
{
inline spdlog::logger *default_logger_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));
}
template<typename... Args>
inline void log(source_loc source, level::level_enum lvl, const char *fmt, const Args &... args)
{
template <typename... 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...);
}
template<typename... Args>
inline void log(level::level_enum lvl, const char *fmt, const Args &... args)
{
template <typename... Args>
inline void log(level::level_enum lvl, const char *fmt, const Args &... args) {
default_logger_raw()->log(source_loc{}, lvl, fmt, args...);
}
template<typename... Args>
inline void trace(const char *fmt, const Args &... args)
{
template <typename... Args>
inline void trace(const char *fmt, const Args &... args) {
default_logger_raw()->trace(fmt, args...);
}
template<typename... Args>
inline void debug(const char *fmt, const Args &... args)
{
template <typename... Args>
inline void debug(const char *fmt, const Args &... args) {
default_logger_raw()->debug(fmt, args...);
}
template<typename... Args>
inline void info(const char *fmt, const Args &... args)
{
template <typename... Args>
inline void info(const char *fmt, const Args &... args) {
default_logger_raw()->info(fmt, args...);
}
template<typename... Args>
inline void warn(const char *fmt, const Args &... args)
{
template <typename... Args>
inline void warn(const char *fmt, const Args &... args) {
default_logger_raw()->warn(fmt, args...);
}
template<typename... Args>
inline void error(const char *fmt, const Args &... args)
{
template <typename... Args>
inline void error(const char *fmt, const Args &... args) {
default_logger_raw()->error(fmt, args...);
}
template<typename... Args>
inline void critical(const char *fmt, const Args &... args)
{
template <typename... Args>
inline void critical(const char *fmt, const Args &... args) {
default_logger_raw()->critical(fmt, args...);
}
template<typename T>
inline void log(level::level_enum lvl, const T &msg)
{
template <typename T>
inline void log(level::level_enum lvl, const T &msg) {
default_logger_raw()->log(lvl, msg);
}
template<typename T>
inline void trace(const T &msg)
{
template <typename T>
inline void trace(const T &msg) {
default_logger_raw()->trace(msg);
}
template<typename T>
inline void debug(const T &msg)
{
template <typename T>
inline void debug(const T &msg) {
default_logger_raw()->debug(msg);
}
template<typename T>
inline void info(const T &msg)
{
template <typename T>
inline void info(const T &msg) {
default_logger_raw()->info(msg);
}
template<typename T>
inline void warn(const T &msg)
{
template <typename T>
inline void warn(const T &msg) {
default_logger_raw()->warn(msg);
}
template<typename T>
inline void error(const T &msg)
{
template <typename T>
inline void error(const T &msg) {
default_logger_raw()->error(msg);
}
template<typename T>
inline void critical(const T &msg)
{
template <typename T>
inline void critical(const T &msg) {
default_logger_raw()->critical(msg);
}
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
template<typename... Args>
inline void log(level::level_enum lvl, const wchar_t *fmt, const Args &... args)
{
template <typename... Args>
inline void log(level::level_enum lvl, const wchar_t *fmt,
const Args &... args) {
default_logger_raw()->log(lvl, fmt, args...);
}
template<typename... Args>
inline void trace(const wchar_t *fmt, const Args &... args)
{
template <typename... Args>
inline void trace(const wchar_t *fmt, const Args &... args) {
default_logger_raw()->trace(fmt, args...);
}
template<typename... Args>
inline void debug(const wchar_t *fmt, const Args &... args)
{
template <typename... Args>
inline void debug(const wchar_t *fmt, const Args &... args) {
default_logger_raw()->debug(fmt, args...);
}
template<typename... Args>
inline void info(const wchar_t *fmt, const Args &... args)
{
template <typename... Args>
inline void info(const wchar_t *fmt, const Args &... args) {
default_logger_raw()->info(fmt, args...);
}
template<typename... Args>
inline void warn(const wchar_t *fmt, const Args &... args)
{
template <typename... Args>
inline void warn(const wchar_t *fmt, const Args &... args) {
default_logger_raw()->warn(fmt, args...);
}
template<typename... Args>
inline void error(const wchar_t *fmt, const Args &... args)
{
template <typename... Args>
inline void error(const wchar_t *fmt, const Args &... args) {
default_logger_raw()->error(fmt, args...);
}
template<typename... Args>
inline void critical(const wchar_t *fmt, const Args &... args)
{
template <typename... Args>
inline void critical(const wchar_t *fmt, const Args &... args) {
default_logger_raw()->critical(fmt, args...);
}
@ -313,51 +281,65 @@ inline void critical(const wchar_t *fmt, const Args &... args)
#define SPDLOG_LOGGER_CALL(logger, 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
#define SPDLOG_LOGGER_TRACE(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__)
#define SPDLOG_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), __VA_ARGS__)
#define SPDLOG_LOGGER_TRACE(logger, ...) \
SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__)
#define SPDLOG_TRACE(...) \
SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), __VA_ARGS__)
#else
#define SPDLOG_LOGGER_TRACE(logger, ...) (void)0
#define SPDLOG_TRACE(...) (void)0
#endif
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_DEBUG
#define SPDLOG_LOGGER_DEBUG(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__)
#define SPDLOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), __VA_ARGS__)
#define SPDLOG_LOGGER_DEBUG(logger, ...) \
SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__)
#define SPDLOG_DEBUG(...) \
SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), __VA_ARGS__)
#else
#define SPDLOG_LOGGER_DEBUG(logger, ...) (void)0
#define SPDLOG_DEBUG(...) (void)0
#endif
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_INFO
#define SPDLOG_LOGGER_INFO(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__)
#define SPDLOG_INFO(...) SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), __VA_ARGS__)
#define SPDLOG_LOGGER_INFO(logger, ...) \
SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__)
#define SPDLOG_INFO(...) \
SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), __VA_ARGS__)
#else
#define SPDLOG_LOGGER_INFO(logger, ...) (void)0
#define SPDLOG_INFO(...) (void)0
#endif
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_WARN
#define SPDLOG_LOGGER_WARN(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__)
#define SPDLOG_WARN(...) SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), __VA_ARGS__)
#define SPDLOG_LOGGER_WARN(logger, ...) \
SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__)
#define SPDLOG_WARN(...) \
SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), __VA_ARGS__)
#else
#define SPDLOG_LOGGER_WARN(logger, ...) (void)0
#define SPDLOG_WARN(...) (void)0
#endif
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_ERROR
#define SPDLOG_LOGGER_ERROR(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__)
#define SPDLOG_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), __VA_ARGS__)
#define SPDLOG_LOGGER_ERROR(logger, ...) \
SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__)
#define SPDLOG_ERROR(...) \
SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), __VA_ARGS__)
#else
#define SPDLOG_LOGGER_ERROR(logger, ...) (void)0
#define SPDLOG_ERROR(...) (void)0
#endif
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_CRITICAL
#define SPDLOG_LOGGER_CRITICAL(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__)
#define SPDLOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), __VA_ARGS__)
#define SPDLOG_LOGGER_CRITICAL(logger, ...) \
SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__)
#define SPDLOG_CRITICAL(...) \
SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), __VA_ARGS__)
#else
#define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0
#define SPDLOG_CRITICAL(...) (void)0

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

@ -123,14 +123,16 @@
///////////////////////////////////////////////////////////////////////////////
// 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
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// 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
///////////////////////////////////////////////////////////////////////////////

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_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)

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

@ -6,10 +6,11 @@
*/
#pragma once
#include <yoga/YGEnums.h>
#include <cstddef>
#include <limits>
#include <type_traits>
#include <yoga/YGEnums.h>
namespace facebook {
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
template <typename Enum>
constexpr size_t bitWidth() {
static_assert(
enums::count<Enum>() > 0, "Enums must have at least one entries");
static_assert(enums::count<Enum>() > 0,
"Enums must have at least one entries");
return log2ceil(enums::count<Enum>() - 1);
}
@ -75,19 +76,16 @@ struct IndexedType<0, T, Ts...> {
template <typename Storage, typename... Fields>
class Bitfield {
static_assert(
std::is_integral<Storage>::value,
static_assert(std::is_integral<Storage>::value,
"Bitfield needs an integral storage type");
static_assert(
std::is_unsigned<Storage>::value,
static_assert(std::is_unsigned<Storage>::value,
"Bitfield needs an unsigned storage type");
static_assert(sizeof...(Fields) > 0, "Bitfield needs at least one member");
using BitTraits = detail::BitTraits<Storage, Fields...>;
#if !defined(_MSC_VER) || _MSC_VER > 1914
static_assert(
BitTraits::shift(0) + BitTraits::width(0) <=
static_assert(BitTraits::shift(0) + BitTraits::width(0) <=
std::numeric_limits<Storage>::digits,
"Specified storage type is too narrow to hold all types");
#endif
@ -108,7 +106,7 @@ class Bitfield {
Storage storage_ = 0;
public:
public:
template <size_t Idx>
class Ref {
Bitfield& bitfield_;
@ -116,7 +114,8 @@ public:
public:
Ref(Bitfield& bitfield) : bitfield_(bitfield) {}
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));
return *this;
}
@ -130,8 +129,8 @@ public:
template <size_t Idx>
constexpr TypeAt<Idx> at() const {
return static_cast<TypeAt<Idx>>(
(storage_ & BitTraits::mask(Idx)) >> BitTraits::shift(Idx));
return static_cast<TypeAt<Idx>>((storage_ & BitTraits::mask(Idx)) >>
BitTraits::shift(Idx));
}
template <size_t Idx>

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

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

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

@ -8,8 +8,7 @@
using namespace facebook;
YGFlexDirection YGFlexDirectionCross(
const YGFlexDirection flexDirection,
YGFlexDirection YGFlexDirectionCross(const YGFlexDirection flexDirection,
const YGDirection direction) {
return YGFlexDirectionIsColumn(flexDirection)
? YGResolveFlexDirection(YGFlexDirectionRow, direction)

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

@ -5,9 +5,9 @@
* file in the root directory of this source tree.
*/
#pragma once
#include "CompactValue.h"
#include "YGNode.h"
#include "Yoga-internal.h"
#include "CompactValue.h"
// 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.
@ -53,10 +53,9 @@ struct YGCollectFlexItemsRowValues {
};
bool YGValueEqual(const YGValue& a, const YGValue& b);
inline bool YGValueEqual(
facebook::yoga::detail::CompactValue a,
inline bool YGValueEqual(facebook::yoga::detail::CompactValue a,
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
@ -65,8 +64,7 @@ bool YGFloatsEqual(const float a, const float b);
float YGFloatMax(const float a, const float b);
YGFloatOptional YGFloatOptionalMax(
const YGFloatOptional op1,
YGFloatOptional YGFloatOptionalMax(const YGFloatOptional op1,
const YGFloatOptional op2);
float YGFloatMin(const float a, const float b);
@ -75,8 +73,7 @@ float YGFloatMin(const float a, const float b);
// YGFloatsEqual, as the default float comparison operator will not work(Look
// at the comments of YGFloatsEqual function).
template <std::size_t size>
bool YGFloatArrayEqual(
const std::array<float, size>& val1,
bool YGFloatArrayEqual(const std::array<float, size>& val1,
const std::array<float, size>& val2) {
bool areEqual = true;
for (std::size_t i = 0; i < size && areEqual; ++i) {
@ -88,8 +85,7 @@ bool YGFloatArrayEqual(
// This function returns 0 if YGFloatIsUndefined(val) is true and val otherwise
float YGFloatSanitize(const float val);
YGFlexDirection YGFlexDirectionCross(
const YGFlexDirection flexDirection,
YGFlexDirection YGFlexDirectionCross(const YGFlexDirection flexDirection,
const YGDirection direction);
inline bool YGFlexDirectionIsRow(const YGFlexDirection flexDirection) {
@ -97,8 +93,7 @@ inline bool YGFlexDirectionIsRow(const YGFlexDirection flexDirection) {
flexDirection == YGFlexDirectionRowReverse;
}
inline YGFloatOptional YGResolveValue(
const YGValue value,
inline YGFloatOptional YGResolveValue(const YGValue value,
const float ownerSize) {
switch (value.unit) {
case YGUnitPoint:
@ -110,10 +105,9 @@ inline YGFloatOptional YGResolveValue(
}
}
inline YGFloatOptional YGResolveValue(
yoga::detail::CompactValue value,
inline YGFloatOptional YGResolveValue(yoga::detail::CompactValue value,
float ownerSize) {
return YGResolveValue((YGValue) value, ownerSize);
return YGResolveValue((YGValue)value, ownerSize);
}
inline bool YGFlexDirectionIsColumn(const YGFlexDirection flexDirection) {
@ -122,8 +116,7 @@ inline bool YGFlexDirectionIsColumn(const YGFlexDirection flexDirection) {
}
inline YGFlexDirection YGResolveFlexDirection(
const YGFlexDirection flexDirection,
const YGDirection direction) {
const YGFlexDirection flexDirection, const YGDirection direction) {
if (direction == YGDirectionRTL) {
if (flexDirection == YGFlexDirectionRow) {
return YGFlexDirectionRowReverse;
@ -135,8 +128,7 @@ inline YGFlexDirection YGResolveFlexDirection(
return flexDirection;
}
inline YGFloatOptional YGResolveValueMargin(
yoga::detail::CompactValue value,
inline YGFloatOptional YGResolveValueMargin(yoga::detail::CompactValue value,
const float ownerSize) {
return value.isAuto() ? YGFloatOptional{0} : YGResolveValue(value, ownerSize);
}

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

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

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

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

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

@ -53,93 +53,48 @@ constexpr int n() {
YG_EXTERN_C_BEGIN
YG_ENUM_SEQ_DECL(
YGAlign,
YGAlignAuto,
YGAlignFlexStart,
YGAlignCenter,
YGAlignFlexEnd,
YGAlignStretch,
YGAlignBaseline,
YGAlignSpaceBetween,
YGAlignSpaceAround);
YG_ENUM_SEQ_DECL(YGAlign, YGAlignAuto, YGAlignFlexStart, YGAlignCenter,
YGAlignFlexEnd, YGAlignStretch, YGAlignBaseline,
YGAlignSpaceBetween, YGAlignSpaceAround);
YG_ENUM_SEQ_DECL(YGDimension, YGDimensionWidth, YGDimensionHeight)
YG_ENUM_SEQ_DECL(
YGDirection,
YGDirectionInherit,
YGDirectionLTR,
YG_ENUM_SEQ_DECL(YGDirection, YGDirectionInherit, YGDirectionLTR,
YGDirectionRTL)
YG_ENUM_SEQ_DECL(YGDisplay, YGDisplayFlex, YGDisplayNone)
YG_ENUM_SEQ_DECL(
YGEdge,
YGEdgeLeft,
YGEdgeTop,
YGEdgeRight,
YGEdgeBottom,
YGEdgeStart,
YGEdgeEnd,
YGEdgeHorizontal,
YGEdgeVertical,
YG_ENUM_SEQ_DECL(YGEdge, YGEdgeLeft, YGEdgeTop, YGEdgeRight, YGEdgeBottom,
YGEdgeStart, YGEdgeEnd, YGEdgeHorizontal, YGEdgeVertical,
YGEdgeAll)
YG_ENUM_SEQ_DECL(YGExperimentalFeature, YGExperimentalFeatureWebFlexBasis)
YG_ENUM_SEQ_DECL(
YGFlexDirection,
YGFlexDirectionColumn,
YGFlexDirectionColumnReverse,
YGFlexDirectionRow,
YG_ENUM_SEQ_DECL(YGFlexDirection, YGFlexDirectionColumn,
YGFlexDirectionColumnReverse, YGFlexDirectionRow,
YGFlexDirectionRowReverse)
YG_ENUM_SEQ_DECL(
YGJustify,
YGJustifyFlexStart,
YGJustifyCenter,
YGJustifyFlexEnd,
YGJustifySpaceBetween,
YGJustifySpaceAround,
YG_ENUM_SEQ_DECL(YGJustify, YGJustifyFlexStart, YGJustifyCenter,
YGJustifyFlexEnd, YGJustifySpaceBetween, YGJustifySpaceAround,
YGJustifySpaceEvenly)
YG_ENUM_SEQ_DECL(
YGLogLevel,
YGLogLevelError,
YGLogLevelWarn,
YGLogLevelInfo,
YGLogLevelDebug,
YGLogLevelVerbose,
YGLogLevelFatal)
YG_ENUM_SEQ_DECL(YGLogLevel, YGLogLevelError, YGLogLevelWarn, YGLogLevelInfo,
YGLogLevelDebug, YGLogLevelVerbose, YGLogLevelFatal)
YG_ENUM_SEQ_DECL(
YGMeasureMode,
YGMeasureModeUndefined,
YGMeasureModeExactly,
YG_ENUM_SEQ_DECL(YGMeasureMode, YGMeasureModeUndefined, YGMeasureModeExactly,
YGMeasureModeAtMost)
YG_ENUM_SEQ_DECL(YGNodeType, YGNodeTypeDefault, YGNodeTypeText)
YG_ENUM_SEQ_DECL(
YGOverflow,
YGOverflowVisible,
YGOverflowHidden,
YG_ENUM_SEQ_DECL(YGOverflow, YGOverflowVisible, YGOverflowHidden,
YGOverflowScroll)
YG_ENUM_SEQ_DECL(YGPositionType, YGPositionTypeRelative, YGPositionTypeAbsolute)
YG_ENUM_DECL(
YGPrintOptions,
YGPrintOptionsLayout = 1,
YGPrintOptionsStyle = 2,
YG_ENUM_DECL(YGPrintOptions, YGPrintOptionsLayout = 1, YGPrintOptionsStyle = 2,
YGPrintOptionsChildren = 4)
YG_ENUM_SEQ_DECL(
YGUnit,
YGUnitUndefined,
YGUnitPoint,
YGUnitPercent,
YG_ENUM_SEQ_DECL(YGUnit, YGUnitUndefined, YGUnitPoint, YGUnitPercent,
YGUnitAuto)
YG_ENUM_SEQ_DECL(YGWrap, YGWrapNoWrap, YGWrapWrap, YGWrapWrapReverse)

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

@ -8,13 +8,14 @@
#include <cmath>
#include <limits>
#include "Yoga-internal.h"
struct YGFloatOptional {
private:
private:
float value_ = std::numeric_limits<float>::quiet_NaN();
public:
public:
explicit constexpr YGFloatOptional(float value) : value_(value) {}
constexpr YGFloatOptional() = default;
@ -37,16 +38,10 @@ inline bool operator!=(YGFloatOptional lhs, YGFloatOptional rhs) {
inline bool operator==(YGFloatOptional lhs, float rhs) {
return lhs == YGFloatOptional{rhs};
}
inline bool operator!=(YGFloatOptional lhs, float rhs) {
return !(lhs == rhs);
}
inline bool operator!=(YGFloatOptional lhs, float rhs) { return !(lhs == rhs); }
inline bool operator==(float lhs, YGFloatOptional rhs) {
return rhs == lhs;
}
inline bool operator!=(float lhs, YGFloatOptional rhs) {
return !(lhs == rhs);
}
inline bool operator==(float lhs, YGFloatOptional rhs) { return rhs == lhs; }
inline bool operator!=(float lhs, YGFloatOptional rhs) { return !(lhs == rhs); }
inline YGFloatOptional operator+(YGFloatOptional lhs, YGFloatOptional rhs) {
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.
*/
#include "YGLayout.h"
#include "Utils.h"
using namespace facebook;
bool YGLayout::operator==(YGLayout layout) const {
bool isEqual = YGFloatArrayEqual(position, layout.position) &&
bool isEqual =
YGFloatArrayEqual(position, layout.position) &&
YGFloatArrayEqual(dimensions, layout.dimensions) &&
YGFloatArrayEqual(margin, layout.margin) &&
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> padding = {};
private:
private:
static constexpr size_t directionIdx = 0;
static constexpr size_t didUseLegacyFlagIdx = 1;
static constexpr size_t doesLegacyStretchFlagAffectsLayoutIdx = 2;
static constexpr size_t hadOverflowIdx = 3;
facebook::yoga::Bitfield<uint8_t, YGDirection, bool, bool, bool> flags_ =
{YGDirectionInherit, false, false, false};
facebook::yoga::Bitfield<uint8_t, YGDirection, bool, bool, bool> flags_ = {
YGDirectionInherit, false, false, false};
public:
public:
uint32_t computedFlexBasisGeneration = 0;
YGFloatOptional computedFlexBasis = {};
// Instead of recomputing the entire layout every single time, we cache some
// information to break early when nothing changed
uint32_t generationCount = 0;
YGDirection lastOwnerDirection = (YGDirection) -1;
YGDirection lastOwnerDirection = (YGDirection)-1;
uint32_t nextCachedMeasurementsIndex = 0;
std::array<YGCachedMeasurement, YG_MAX_CACHED_RESULT_COUNT>

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

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

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

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

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

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

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

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

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

@ -5,11 +5,13 @@
* file in the root directory of this source tree.
*/
#include "YGStyle.h"
#include "Utils.h"
// Yoga specific properties, not compatible with flexbox specification
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.justifyContent() == rhs.justifyContent() &&
lhs.alignContent() == rhs.alignContent() &&
@ -32,14 +34,16 @@ bool operator==(const YGStyle& lhs, const YGStyle& rhs) {
areNonFloatValuesEqual = areNonFloatValuesEqual && lhs.flex() == rhs.flex();
}
areNonFloatValuesEqual = areNonFloatValuesEqual &&
areNonFloatValuesEqual =
areNonFloatValuesEqual &&
lhs.flexGrow().isUndefined() == rhs.flexGrow().isUndefined();
if (areNonFloatValuesEqual && !lhs.flexGrow().isUndefined()) {
areNonFloatValuesEqual =
areNonFloatValuesEqual && lhs.flexGrow() == rhs.flexGrow();
}
areNonFloatValuesEqual = areNonFloatValuesEqual &&
areNonFloatValuesEqual =
areNonFloatValuesEqual &&
lhs.flexShrink().isUndefined() == rhs.flexShrink().isUndefined();
if (areNonFloatValuesEqual && !rhs.flexShrink().isUndefined()) {
areNonFloatValuesEqual =

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

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

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

@ -7,6 +7,7 @@
#pragma once
#include <math.h>
#include "YGEnums.h"
#include "YGMacros.h"
@ -15,7 +16,7 @@ YG_EXTERN_C_BEGIN
// Not defined in MSVC++
#ifndef NAN
static const uint32_t __nan = 0x7fc00000;
#define NAN (*(const float*) __nan)
#define NAN (*(const float*)__nan)
#endif
#define YGUndefined NAN

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

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

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

File diff suppressed because it is too large Load Diff

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

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

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

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

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

@ -6,10 +6,11 @@
*/
#pragma once
#include <yoga/YGEnums.h>
#include <array>
#include <functional>
#include <vector>
#include <array>
#include <yoga/YGEnums.h>
struct YGConfig;
struct YGNode;
@ -97,7 +98,7 @@ struct Event {
publish<E>(*node, eventData);
}
private:
private:
static void publish(const YGNode&, Type, const Data&);
};

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

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

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

@ -5,6 +5,7 @@
* file in the root directory of this source tree.
*/
#include "experiments.h"
#include "experiments-inl.h"
namespace facebook {

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

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

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

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

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

@ -3,6 +3,6 @@
#include "core/FlexLayout/flexlayout.h"
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);
}

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

@ -1,36 +1,35 @@
#pragma once
#include "core/Events/eventwidget_macro.h"
#include "core/Component/component_macro.h"
#include "core/Events/eventwidget_macro.h"
/*
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
#define QOBJECT_WRAPPED_METHODS_DECLARATION \
\
EVENTWIDGET_WRAPPED_METHODS_DECLARATION \
\
Napi::Value inherits(const Napi::CallbackInfo& info){ \
\
EVENTWIDGET_WRAPPED_METHODS_DECLARATION \
\
Napi::Value inherits(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \
Napi::String className = info[0].As<Napi::String>(); \
bool doesIt = this->instance->inherits(className.Utf8Value().c_str()); \
return Napi::Value::From(env, doesIt); \
} \
\
}
#endif //QOBJECT_WRAPPED_METHODS_DECLARATION
#endif // QOBJECT_WRAPPED_METHODS_DECLARATION
#ifndef QOBJECT_WRAPPED_METHODS_EXPORT_DEFINE
#define QOBJECT_WRAPPED_METHODS_EXPORT_DEFINE(ComponentWrapName) \
\
\
EVENTWIDGET_WRAPPED_METHODS_EXPORT_DEFINE(ComponentWrapName) \
COMPONENT_WRAPPED_METHODS_EXPORT_DEFINE \
\
InstanceMethod("inherits", &ComponentWrapName::inherits),\
\
InstanceMethod("inherits", &ComponentWrapName::inherits),
#endif // QOBJECT_WRAPPED_METHODS_EXPORT_DEFINE

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

@ -1,17 +1,17 @@
#pragma once
#include <napi.h>
#include <QApplication>
class QApplicationWrap : public Napi::ObjectWrap<QApplicationWrap> {
private:
private:
QApplication* instance;
static int argc;
static char** argv;
bool _wasManuallyCreated = false;
public:
public:
static Napi::FunctionReference constructor;
static Napi::Object init(Napi::Env env, Napi::Object exports);
QApplicationWrap(const Napi::CallbackInfo& info);
@ -27,6 +27,6 @@ public:
};
namespace StaticQApplicationWrapMethods {
Napi::Value instance(const Napi::CallbackInfo& info);
Napi::Value clipboard(const Napi::CallbackInfo& info);
}
Napi::Value instance(const Napi::CallbackInfo& info);
Napi::Value clipboard(const Napi::CallbackInfo& info);
} // namespace StaticQApplicationWrapMethods

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

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

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

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

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

@ -2,9 +2,10 @@
#include <napi.h>
#include <stdlib.h>
#include <QKeyEvent>
class QKeyEventWrap : public Napi::ObjectWrap<QKeyEventWrap>{
class QKeyEventWrap : public Napi::ObjectWrap<QKeyEventWrap> {
private:
QKeyEvent* instance;
@ -13,9 +14,9 @@ class QKeyEventWrap : public Napi::ObjectWrap<QKeyEventWrap>{
QKeyEventWrap(const Napi::CallbackInfo& info);
~QKeyEventWrap();
QKeyEvent* getInternalInstance();
//class constructor
// class constructor
static Napi::FunctionReference constructor;
//wrapped methods
// wrapped methods
Napi::Value text(const Napi::CallbackInfo& info);
// Napi::Value setFlexNode(const Napi::CallbackInfo& info);
};

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

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

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

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

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

@ -2,13 +2,16 @@
#include <napi.h>
#include <stdlib.h>
#include <QPixmap>
#include "core/Component/component_macro.h"
class QPixmapWrap : public Napi::ObjectWrap<QPixmapWrap> {
private:
private:
std::unique_ptr<QPixmap> instance;
public:
public:
static Napi::FunctionReference constructor;
static Napi::Object init(Napi::Env env, Napi::Object exports);
QPixmapWrap(const Napi::CallbackInfo& info);
@ -19,4 +22,3 @@ public:
Napi::Value save(const Napi::CallbackInfo& info);
Napi::Value scaled(const Napi::CallbackInfo& info);
};

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

@ -1,43 +1,45 @@
#pragma once
#include "QtWidgets/QWidget/qwidget_wrap.h"
#include "QtWidgets/QWidget/qwidget_macro.h"
#include "QtWidgets/QWidget/qwidget_wrap.h"
#include "deps/spdlog/spdlog.h"
/*
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
#define QABSTRACTSCROLLAREA_WRAPPED_METHODS_DECLARATION \
QWIDGET_WRAPPED_METHODS_DECLARATION \
Napi::Value setViewport(const Napi::CallbackInfo& info) { \
QWIDGET_WRAPPED_METHODS_DECLARATION \
Napi::Value setViewport(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \
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(); \
this->instance->setViewport(viewPort); \
return env.Null(); \
} \
\
Napi::Value viewport(const Napi::CallbackInfo& info) { \
} \
\
Napi::Value viewport(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \
QWidget* viewPort = this->instance->viewport(); \
NWidget* nviewPort = reinterpret_cast<NWidget*>(viewPort); \
auto instance = QWidgetWrap::constructor.New({ Napi::External<NWidget>::New(env, nviewPort) }); \
auto instance = QWidgetWrap::constructor.New( \
{Napi::External<NWidget>::New(env, nviewPort)}); \
return instance; \
} \
\
}
#endif //QABSTRACTSCROLLAREA_WRAPPED_METHODS_DECLARATION
#endif // QABSTRACTSCROLLAREA_WRAPPED_METHODS_DECLARATION
#ifndef QABSTRACTSCROLLAREA_WRAPPED_METHODS_EXPORT_DEFINE
#define QABSTRACTSCROLLAREA_WRAPPED_METHODS_EXPORT_DEFINE(WidgetWrapName) \
QWIDGET_WRAPPED_METHODS_EXPORT_DEFINE(WidgetWrapName) \
InstanceMethod("setViewport", &WidgetWrapName::setViewport), \
InstanceMethod("viewport",&WidgetWrapName::viewport), \
InstanceMethod("viewport", &WidgetWrapName::viewport),
#endif // QABSTRACTSCROLLAREA_WRAPPED_METHODS_EXPORT_DEFINE

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

@ -1,80 +1,81 @@
#pragma once
#include "QtWidgets/QWidget/qwidget_wrap.h"
#include "QtWidgets/QWidget/qwidget_macro.h"
#include "QtWidgets/QWidget/qwidget_wrap.h"
#include "deps/spdlog/spdlog.h"
/*
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
#define QABSTRACTSLIDER_WRAPPED_METHODS_DECLARATION \
QWIDGET_WRAPPED_METHODS_DECLARATION \
Napi::Value setSingleStep(const Napi::CallbackInfo& info) { \
QWIDGET_WRAPPED_METHODS_DECLARATION \
Napi::Value setSingleStep(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \
Napi::Number step = info[0].As<Napi::Number>(); \
this->instance->setSingleStep(step.Int32Value()); \
return env.Null(); \
} \
\
Napi::Value setMaximum(const Napi::CallbackInfo& info) { \
} \
\
Napi::Value setMaximum(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \
Napi::Number maximum = info[0].As<Napi::Number>(); \
this->instance->setMaximum(maximum.Int32Value()); \
return env.Null(); \
} \
\
Napi::Value setMinimum(const Napi::CallbackInfo& info) { \
} \
\
Napi::Value setMinimum(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \
Napi::Number minimum = info[0].As<Napi::Number>(); \
this->instance->setMinimum(minimum.Int32Value()); \
return env.Null(); \
} \
\
Napi::Value setValue(const Napi::CallbackInfo& info) { \
} \
\
Napi::Value setValue(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \
Napi::Number value = info[0].As<Napi::Number>(); \
this->instance->setValue(value.Int32Value()); \
return env.Null(); \
} \
\
Napi::Value setOrientation(const Napi::CallbackInfo& info) { \
} \
\
Napi::Value setOrientation(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \
Napi::Number orientation = info[0].As<Napi::Number>(); \
this->instance->setOrientation(static_cast<Qt::Orientation>(orientation.Int32Value())); \
this->instance->setOrientation( \
static_cast<Qt::Orientation>(orientation.Int32Value())); \
return env.Null(); \
} \
\
Napi::Value maximum(const Napi::CallbackInfo& info) { \
} \
\
Napi::Value maximum(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \
int maximum = this->instance->maximum(); \
return Napi::Number::New(env, maximum); \
} \
\
Napi::Value minimum(const Napi::CallbackInfo& info) { \
} \
\
Napi::Value minimum(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \
int minimum = this->instance->minimum(); \
return Napi::Number::New(env, minimum); \
} \
\
Napi::Value value(const Napi::CallbackInfo& info) { \
} \
\
Napi::Value value(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \
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
#define QABSTRACTSLIDER_WRAPPED_METHODS_EXPORT_DEFINE(WidgetWrapName) \
@ -86,6 +87,6 @@ Napi::Value value(const Napi::CallbackInfo& info) { \
InstanceMethod("setOrientation", &WidgetWrapName::setOrientation), \
InstanceMethod("maximum", &WidgetWrapName::maximum), \
InstanceMethod("minimum", &WidgetWrapName::minimum), \
InstanceMethod("value", &WidgetWrapName::value), \
InstanceMethod("value", &WidgetWrapName::value),
#endif // QABSTRACTSLIDER_WRAPPED_METHODS_EXPORT_DEFINE

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

@ -1,38 +1,38 @@
#pragma once
#include <QAction>
#include "core/NodeWidget/nodewidget.h"
#include "napi.h"
class NAction: public QAction, public EventWidget
{
class NAction : public QAction, public EventWidget {
Q_OBJECT
EVENTWIDGET_IMPLEMENTATIONS(QAction)
public:
using QAction::QAction; //inherit all constructors of QAction
public:
using QAction::QAction; // inherit all constructors of QAction
void connectWidgetSignalsToEventEmitter() {
// Qt Connects: Implement all signal connects here
QObject::connect(this, &QAction::triggered, [=](bool checked) {
Napi::Env env = this->emitOnNode.Env();
Napi::HandleScope scope(env);
this->emitOnNode.Call({ Napi::String::New(env, "triggered"), Napi::Value::From(env, checked) });
this->emitOnNode.Call({Napi::String::New(env, "triggered"),
Napi::Value::From(env, checked)});
});
QObject::connect(this, &QAction::changed, [=]() {
Napi::Env env = this->emitOnNode.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, [=]() {
Napi::Env env = this->emitOnNode.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) {
Napi::Env env = this->emitOnNode.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
#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:
NAction* instance;
public:
static Napi::Object init(Napi::Env env, Napi::Object exports);
QActionWrap(const Napi::CallbackInfo& info);
~QActionWrap();
NAction* getInternalInstance();
//class constructor
// class constructor
static Napi::FunctionReference constructor;
//wrapped methods
// wrapped methods
Napi::Value setText(const Napi::CallbackInfo& info);
Napi::Value setEnabled(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
};

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

@ -1,23 +1,22 @@
#pragma once
#include <QCheckBox>
#include "core/NodeWidget/nodewidget.h"
#include "napi.h"
class NCheckBox: public QCheckBox, public NodeWidget
{
class NCheckBox : public QCheckBox, public NodeWidget {
Q_OBJECT
NODEWIDGET_IMPLEMENTATIONS(QCheckBox)
public:
using QCheckBox::QCheckBox; //inherit all constructors of QCheckBox
public:
using QCheckBox::QCheckBox; // inherit all constructors of QCheckBox
void connectWidgetSignalsToEventEmitter() {
QObject::connect(this, &QCheckBox::toggled, [=](bool checked) {
Napi::Env env = this->emitOnNode.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 <stdlib.h>
#include "ncheckbox.hpp"
#include "QtWidgets/QWidget/qwidget_macro.h"
#include "ncheckbox.hpp"
class QCheckBoxWrap : public Napi::ObjectWrap<QCheckBoxWrap>{
class QCheckBoxWrap : public Napi::ObjectWrap<QCheckBoxWrap> {
private:
std::unique_ptr<NCheckBox> instance;
public:
static Napi::Object init(Napi::Env env, Napi::Object exports);
QCheckBoxWrap(const Napi::CallbackInfo& info);
~QCheckBoxWrap();
NCheckBox* getInternalInstance();
//class constructor
// class constructor
static Napi::FunctionReference constructor;
//wrapped methods
// wrapped methods
Napi::Value setText(const Napi::CallbackInfo& info);
Napi::Value isChecked(const Napi::CallbackInfo& info);
Napi::Value setChecked(const Napi::CallbackInfo& info);
QWIDGET_WRAPPED_METHODS_DECLARATION
};

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

@ -1,43 +1,41 @@
#pragma once
#include <QDial>
#include "core/NodeWidget/nodewidget.h"
class NDial: public QDial, public NodeWidget
{
class NDial : public QDial, public NodeWidget {
Q_OBJECT
NODEWIDGET_IMPLEMENTATIONS(QDial)
public:
using QDial::QDial; //inherit all constructors of QDial
public:
using QDial::QDial; // inherit all constructors of QDial
void connectWidgetSignalsToEventEmitter() {
// Qt Connects: Implement all signal connects here
QObject::connect(this, &QDial::valueChanged, [=]() {
Napi::Env env = this->emitOnNode.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, [=]() {
Napi::Env env = this->emitOnNode.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, [=]() {
Napi::Env env = this->emitOnNode.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, [=]() {
Napi::Env env = this->emitOnNode.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, [=]() {
Napi::Env env = this->emitOnNode.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 <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:
std::unique_ptr<NDial> instance;
public:
static Napi::Object init(Napi::Env env, Napi::Object exports);
QDialWrap(const Napi::CallbackInfo& info);
~QDialWrap();
NDial* getInternalInstance();
//class constructor
// class constructor
static Napi::FunctionReference constructor;
//wrapped methods
// wrapped methods
Napi::Value setNotchesVisible(const Napi::CallbackInfo& info);
Napi::Value setWrapping(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
};

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

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

10
src/cpp/include/nodegui/QtWidgets/QLabel/nlabel.hpp
View File

@ -1,14 +1,12 @@
#pragma once
#include <QLabel>
#include "core/NodeWidget/nodewidget.h"
class NLabel: public QLabel, public NodeWidget
{
class NLabel : public QLabel, public NodeWidget {
Q_OBJECT
NODEWIDGET_IMPLEMENTATIONS(QLabel)
public:
using QLabel::QLabel; //inherit all constructors of QLabel
public:
using QLabel::QLabel; // inherit all constructors of QLabel
};

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