From 61c6ad332d1a60afe549a07e0d4077df438abe6b Mon Sep 17 00:00:00 2001 From: ivan Date: Sun, 9 Jul 2017 18:08:16 +0300 Subject: [PATCH] =?UTF-8?q?add=20fmtlib=20support=20=09=D0=B8=D0=B7=D0=BC?= =?UTF-8?q?=D0=B5=D0=BD=D0=B5=D0=BD=D0=BE:=20=20=20=20=20=20include/FirstS?= =?UTF-8?q?tageSubEngine.h=20=09=D0=B8=D0=B7=D0=BC=D0=B5=D0=BD=D0=B5=D0=BD?= =?UTF-8?q?=D0=BE:=20=20=20=20=20=20include/GameEngine.h=20=09=D0=B8=D0=B7?= =?UTF-8?q?=D0=BC=D0=B5=D0=BD=D0=B5=D0=BD=D0=BE:=20=20=20=20=20=20include/?= =?UTF-8?q?PreparationEngine.h=20=09=D0=B8=D0=B7=D0=BC=D0=B5=D0=BD=D0=B5?= =?UTF-8?q?=D0=BD=D0=BE:=20=20=20=20=20=20include/SecondStageSubEngine.h?= =?UTF-8?q?=20=09=D0=B8=D0=B7=D0=BC=D0=B5=D0=BD=D0=B5=D0=BD=D0=BE:=20=20?= =?UTF-8?q?=20=20=20=20include/ThirdStageSubEngine.h=20=09=D0=BD=D0=BE?= =?UTF-8?q?=D0=B2=D1=8B=D0=B9=20=D1=84=D0=B0=D0=B9=D0=BB:=20=20=20=20inclu?= =?UTF-8?q?de/format.h=20=09=D0=B8=D0=B7=D0=BC=D0=B5=D0=BD=D0=B5=D0=BD?= =?UTF-8?q?=D0=BE:=20=20=20=20=20=20src/Field.cpp=20=09=D0=B8=D0=B7=D0=BC?= =?UTF-8?q?=D0=B5=D0=BD=D0=B5=D0=BD=D0=BE:=20=20=20=20=20=20src/FirstStage?= =?UTF-8?q?SubEngine.cpp=20=09=D0=B8=D0=B7=D0=BC=D0=B5=D0=BD=D0=B5=D0=BD?= =?UTF-8?q?=D0=BE:=20=20=20=20=20=20src/GameEngine.cpp=20=09=D0=B8=D0=B7?= =?UTF-8?q?=D0=BC=D0=B5=D0=BD=D0=B5=D0=BD=D0=BE:=20=20=20=20=20=20src/Hex.?= =?UTF-8?q?cpp=20=09=D0=B8=D0=B7=D0=BC=D0=B5=D0=BD=D0=B5=D0=BD=D0=BE:=20?= =?UTF-8?q?=20=20=20=20=20src/Player.cpp=20=09=D0=B8=D0=B7=D0=BC=D0=B5?= =?UTF-8?q?=D0=BD=D0=B5=D0=BD=D0=BE:=20=20=20=20=20=20src/PreparationEngin?= =?UTF-8?q?e.cpp=20=09=D0=B8=D0=B7=D0=BC=D0=B5=D0=BD=D0=B5=D0=BD=D0=BE:=20?= =?UTF-8?q?=20=20=20=20=20src/ResourcesHolder.cpp=20=09=D0=B8=D0=B7=D0=BC?= =?UTF-8?q?=D0=B5=D0=BD=D0=B5=D0=BD=D0=BE:=20=20=20=20=20=20src/SecondStag?= =?UTF-8?q?eSubEngine.cpp=20=09=D0=B8=D0=B7=D0=BC=D0=B5=D0=BD=D0=B5=D0=BD?= =?UTF-8?q?=D0=BE:=20=20=20=20=20=20src/ThirdStageSubEngine.cpp=20=09?= =?UTF-8?q?=D0=BD=D0=BE=D0=B2=D1=8B=D0=B9=20=D1=84=D0=B0=D0=B9=D0=BB:=20?= =?UTF-8?q?=20=20=20src/format.cc=20=09=D0=B8=D0=B7=D0=BC=D0=B5=D0=BD?= =?UTF-8?q?=D0=B5=D0=BD=D0=BE:=20=20=20=20=20=20src/main.cpp?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- include/FirstStageSubEngine.h | 3 +- include/GameEngine.h | 54 +- include/PreparationEngine.h | 5 +- include/SecondStageSubEngine.h | 3 +- include/ThirdStageSubEngine.h | 3 +- include/format.h | 4015 ++++++++++++++++++++++++++++++++ src/Field.cpp | 39 +- src/FirstStageSubEngine.cpp | 44 +- src/GameEngine.cpp | 210 +- src/Hex.cpp | 20 +- src/Player.cpp | 17 +- src/PreparationEngine.cpp | 111 +- src/ResourcesHolder.cpp | 32 +- src/SecondStageSubEngine.cpp | 28 +- src/ThirdStageSubEngine.cpp | 44 +- src/format.cc | 535 +++++ src/main.cpp | 125 +- 17 files changed, 4893 insertions(+), 395 deletions(-) create mode 100644 include/format.h create mode 100644 src/format.cc diff --git a/include/FirstStageSubEngine.h b/include/FirstStageSubEngine.h index 6a1b99a..fbb95c8 100644 --- a/include/FirstStageSubEngine.h +++ b/include/FirstStageSubEngine.h @@ -2,8 +2,7 @@ #define FIRSTSTAGESUBENGINE_H #include -#include -#include +#include #include class FirstStageSubEngine diff --git a/include/GameEngine.h b/include/GameEngine.h index ec21c2c..4ae0f42 100644 --- a/include/GameEngine.h +++ b/include/GameEngine.h @@ -1,30 +1,32 @@ #ifndef GAMEENGINE_H -#define GAMEENGINE_H - -#include -#include +#define GAMEENGINE_H + +#include +#include #include #include #include #include -#include -class GameEngine -{ - GameEngine(const GameEngine &) = delete; - GameEngine &operator= (const GameEngine &) = delete; - +//#include "format.h" +//#include "format.cc" + +class GameEngine +{ + GameEngine(const GameEngine &) = delete; + GameEngine &operator= (const GameEngine &) = delete; + public: enum {VICTORY_POINTS = 10}; enum {POINTS_PER_TOWN = 1, POINTS_PER_CITY = 2}; - - GameEngine() {Logger::init_logger();} - ~GameEngine(); - - //PREPARATION STAGE - void join_player(const std::string &); - void unjoin_player(const std::string &); - + + GameEngine() = default; + ~GameEngine(); + + //PREPARATION STAGE + void join_player(const std::string &); + void unjoin_player(const std::string &); + void start_game(); void register_road(const std::string &player, const std::string &name); @@ -81,18 +83,18 @@ class GameEngine int score(const std::string &player); GameStage stage() const noexcept {return _game_stage;} - const Player &winner() const; - -private: - GameStage _game_stage = GameStage::PLAYERS_REGISTRATION; + const Player &winner() const; + +private: + GameStage _game_stage = GameStage::PLAYERS_REGISTRATION; Game *_game = new Game(); - size_t _current_player = 0; - + size_t _current_player = 0; + PreparationEngine *_preparation_stage = new PreparationEngine(*_game); FirstStageSubEngine *_first_stage = nullptr; SecondStageSubEngine *_second_stage = nullptr; - ThirdStageSubEngine *_third_stage = nullptr; + ThirdStageSubEngine *_third_stage = nullptr; }; #endif // GAMEENGINE_H - + diff --git a/include/PreparationEngine.h b/include/PreparationEngine.h index 50d2f4c..8630eb1 100644 --- a/include/PreparationEngine.h +++ b/include/PreparationEngine.h @@ -2,12 +2,9 @@ #define PREPARATIONENGINE_H #include -#include - +#include #include #include -#include - using std::string; class PreparationEngine diff --git a/include/SecondStageSubEngine.h b/include/SecondStageSubEngine.h index e467015..e06f71a 100644 --- a/include/SecondStageSubEngine.h +++ b/include/SecondStageSubEngine.h @@ -3,8 +3,7 @@ #include #include -#include -#include +#include class SecondStageSubEngine { diff --git a/include/ThirdStageSubEngine.h b/include/ThirdStageSubEngine.h index c0ce5cf..dcda300 100644 --- a/include/ThirdStageSubEngine.h +++ b/include/ThirdStageSubEngine.h @@ -2,8 +2,7 @@ #define THIRDSTAGESUBENGINE_H #include -#include -#include +#include #include class ThirdStageSubEngine diff --git a/include/format.h b/include/format.h new file mode 100644 index 0000000..349a059 --- /dev/null +++ b/include/format.h @@ -0,0 +1,4015 @@ +/* + Formatting library for C++ + + Copyright (c) 2012 - 2016, Victor Zverovich + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef FMT_FORMAT_H_ +#define FMT_FORMAT_H_ + +#include +//#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // for std::pair + +// The fmt library version in the form major * 10000 + minor * 100 + patch. +#define FMT_VERSION 40000 + +#ifdef _SECURE_SCL +# define FMT_SECURE_SCL _SECURE_SCL +#else +# define FMT_SECURE_SCL 0 +#endif + +#if FMT_SECURE_SCL +# include +#endif + +#ifdef _MSC_VER +# define FMT_MSC_VER _MSC_VER +#else +# define FMT_MSC_VER 0 +#endif + +#if FMT_MSC_VER && FMT_MSC_VER <= 1500 +typedef unsigned __int32 uint32_t; +typedef unsigned __int64 uint64_t; +typedef __int64 intmax_t; +#else +#include +#endif + +#if !defined(FMT_HEADER_ONLY) && defined(_WIN32) +# ifdef FMT_EXPORT +# define FMT_API __declspec(dllexport) +# elif defined(FMT_SHARED) +# define FMT_API __declspec(dllimport) +# endif +#endif +#ifndef FMT_API +# define FMT_API +#endif + +#ifdef __GNUC__ +# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) +# define FMT_GCC_EXTENSION __extension__ +# if FMT_GCC_VERSION >= 406 +# pragma GCC diagnostic push +// Disable the warning about "long long" which is sometimes reported even +// when using __extension__. +# pragma GCC diagnostic ignored "-Wlong-long" +// Disable the warning about declaration shadowing because it affects too +// many valid cases. +# pragma GCC diagnostic ignored "-Wshadow" +// Disable the warning about implicit conversions that may change the sign of +// an integer; silencing it otherwise would require many explicit casts. +# pragma GCC diagnostic ignored "-Wsign-conversion" +# endif +# if __cplusplus >= 201103L || defined __GXX_EXPERIMENTAL_CXX0X__ +# define FMT_HAS_GXX_CXX11 1 +# endif +#else +# define FMT_GCC_EXTENSION +#endif + +#if defined(__INTEL_COMPILER) +# define FMT_ICC_VERSION __INTEL_COMPILER +#elif defined(__ICL) +# define FMT_ICC_VERSION __ICL +#endif + +#if defined(__clang__) && !defined(FMT_ICC_VERSION) +# define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wdocumentation-unknown-command" +# pragma clang diagnostic ignored "-Wpadded" +#endif + +#ifdef __GNUC_LIBSTD__ +# define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__) +#endif + +#ifdef __has_feature +# define FMT_HAS_FEATURE(x) __has_feature(x) +#else +# define FMT_HAS_FEATURE(x) 0 +#endif + +#ifdef __has_builtin +# define FMT_HAS_BUILTIN(x) __has_builtin(x) +#else +# define FMT_HAS_BUILTIN(x) 0 +#endif + +#ifdef __has_cpp_attribute +# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) +#else +# define FMT_HAS_CPP_ATTRIBUTE(x) 0 +#endif + +#ifndef FMT_USE_VARIADIC_TEMPLATES +// Variadic templates are available in GCC since version 4.4 +// (http://gcc.gnu.org/projects/cxx0x.html) and in Visual C++ +// since version 2013. +# define FMT_USE_VARIADIC_TEMPLATES \ + (FMT_HAS_FEATURE(cxx_variadic_templates) || \ + (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1800) +#endif + +#ifndef FMT_USE_RVALUE_REFERENCES +// Don't use rvalue references when compiling with clang and an old libstdc++ +// as the latter doesn't provide std::move. +# if defined(FMT_GNUC_LIBSTD_VERSION) && FMT_GNUC_LIBSTD_VERSION <= 402 +# define FMT_USE_RVALUE_REFERENCES 0 +# else +# define FMT_USE_RVALUE_REFERENCES \ + (FMT_HAS_FEATURE(cxx_rvalue_references) || \ + (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1600) +# endif +#endif + +// Check if exceptions are disabled. +#if defined(__GNUC__) && !defined(__EXCEPTIONS) +# define FMT_EXCEPTIONS 0 +#endif +#if FMT_MSC_VER && !_HAS_EXCEPTIONS +# define FMT_EXCEPTIONS 0 +#endif +#ifndef FMT_EXCEPTIONS +# define FMT_EXCEPTIONS 1 +#endif + +#ifndef FMT_THROW +# if FMT_EXCEPTIONS +# define FMT_THROW(x) throw x +# else +# define FMT_THROW(x) assert(false) +# endif +#endif + +// Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature). +#ifndef FMT_USE_NOEXCEPT +# 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 +#else +# define FMT_DETECTED_NOEXCEPT throw() +#endif + +#ifndef FMT_NOEXCEPT +# if FMT_EXCEPTIONS +# define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT +# else +# define FMT_NOEXCEPT +# endif +#endif + +// This is needed because GCC still uses throw() in its headers when exceptions +// are disabled. +#if FMT_GCC_VERSION +# define FMT_DTOR_NOEXCEPT FMT_DETECTED_NOEXCEPT +#else +# define FMT_DTOR_NOEXCEPT FMT_NOEXCEPT +#endif + +#ifndef FMT_OVERRIDE +# if (defined(FMT_USE_OVERRIDE) && FMT_USE_OVERRIDE) || 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 +#endif + +#ifndef FMT_NULL +# if FMT_HAS_FEATURE(cxx_nullptr) || \ + (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \ + FMT_MSC_VER >= 1600 +# define FMT_NULL nullptr +# else +# define FMT_NULL NULL +# endif +#endif + +// A macro to disallow the copy constructor and operator= functions +// This should be used in the private: declarations for a class +#ifndef FMT_USE_DELETED_FUNCTIONS +# define FMT_USE_DELETED_FUNCTIONS 0 +#endif + +#if FMT_USE_DELETED_FUNCTIONS || FMT_HAS_FEATURE(cxx_deleted_functions) || \ + (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1800 +# define FMT_DELETED_OR_UNDEFINED = delete +# define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \ + TypeName(const TypeName&) = delete; \ + TypeName& operator=(const TypeName&) = delete +#else +# define FMT_DELETED_OR_UNDEFINED +# define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \ + TypeName(const TypeName&); \ + TypeName& operator=(const TypeName&) +#endif + +#ifndef FMT_USE_DEFAULTED_FUNCTIONS +# define FMT_USE_DEFAULTED_FUNCTIONS 0 +#endif + +#ifndef FMT_DEFAULTED_COPY_CTOR +# if FMT_USE_DEFAULTED_FUNCTIONS || FMT_HAS_FEATURE(cxx_defaulted_functions) || \ + (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1800 +# define FMT_DEFAULTED_COPY_CTOR(TypeName) \ + TypeName(const TypeName&) = default; +# else +# define FMT_DEFAULTED_COPY_CTOR(TypeName) +# endif +#endif + +#ifndef FMT_USE_USER_DEFINED_LITERALS +// All compilers which support UDLs also support variadic templates. This +// makes the fmt::literals implementation easier. However, an explicit check +// for variadic templates is added here just in case. +// For Intel's compiler both it and the system gcc/msc must support UDLs. +# define FMT_USE_USER_DEFINED_LITERALS \ + FMT_USE_VARIADIC_TEMPLATES && FMT_USE_RVALUE_REFERENCES && \ + (FMT_HAS_FEATURE(cxx_user_literals) || \ + (FMT_GCC_VERSION >= 407 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900) && \ + (!defined(FMT_ICC_VERSION) || FMT_ICC_VERSION >= 1500) +#endif + +#ifndef FMT_USE_EXTERN_TEMPLATES +# define FMT_USE_EXTERN_TEMPLATES \ + (FMT_CLANG_VERSION >= 209 || (FMT_GCC_VERSION >= 303 && FMT_HAS_GXX_CXX11)) +#endif + +#ifdef FMT_HEADER_ONLY +// If header only do not use extern templates. +# undef FMT_USE_EXTERN_TEMPLATES +# define FMT_USE_EXTERN_TEMPLATES 0 +#endif + +#ifndef FMT_ASSERT +# define FMT_ASSERT(condition, message) assert((condition) && message) +#endif + +// __builtin_clz is broken in clang with Microsoft CodeGen: +// https://github.com/fmtlib/fmt/issues/519 +#ifndef _MSC_VER +# if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clz) +# define FMT_BUILTIN_CLZ(n) __builtin_clz(n) +# endif + +# if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clzll) +# define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n) +# endif +#endif + +// Some compilers masquerade as both MSVC and GCC-likes or +// otherwise support __builtin_clz and __builtin_clzll, so +// only define FMT_BUILTIN_CLZ using the MSVC intrinsics +// if the clz and clzll builtins are not available. +#if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL) && !defined(_MANAGED) +# include // _BitScanReverse, _BitScanReverse64 + +namespace fmt { +namespace internal { +# pragma intrinsic(_BitScanReverse) +inline uint32_t clz(uint32_t x) { + unsigned long r = 0; + _BitScanReverse(&r, x); + + assert(x != 0); + // Static analysis complains about using uninitialized data + // "r", but the only way that can happen is if "x" is 0, + // which the callers guarantee to not happen. +# pragma warning(suppress: 6102) + return 31 - r; +} +# define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n) + +# ifdef _WIN64 +# pragma intrinsic(_BitScanReverse64) +# endif + +inline uint32_t clzll(uint64_t x) { + unsigned long r = 0; +# ifdef _WIN64 + _BitScanReverse64(&r, x); +# else + // Scan the high 32 bits. + if (_BitScanReverse(&r, static_cast(x >> 32))) + return 63 - (r + 32); + + // Scan the low 32 bits. + _BitScanReverse(&r, static_cast(x)); +# endif + + assert(x != 0); + // Static analysis complains about using uninitialized data + // "r", but the only way that can happen is if "x" is 0, + // which the callers guarantee to not happen. +# pragma warning(suppress: 6102) + return 63 - r; +} +# define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n) +} +} +#endif + +namespace fmt { +namespace internal { +struct DummyInt { + int data[2]; + operator int() const { return 0; } +}; +typedef std::numeric_limits FPUtil; + +// Dummy implementations of system functions such as signbit and ecvt called +// if the latter are not available. +inline DummyInt signbit(...) { return DummyInt(); } +inline DummyInt _ecvt_s(...) { return DummyInt(); } +inline DummyInt isinf(...) { return DummyInt(); } +inline DummyInt _finite(...) { return DummyInt(); } +inline DummyInt isnan(...) { return DummyInt(); } +inline DummyInt _isnan(...) { return DummyInt(); } + +// A helper function to suppress bogus "conditional expression is constant" +// warnings. +template +inline T const_check(T value) { return value; } +} +} // namespace fmt + +namespace std { +// Standard permits specialization of std::numeric_limits. This specialization +// is used to resolve ambiguity between isinf and std::isinf in glibc: +// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=48891 +// and the same for isnan and signbit. +template <> +class numeric_limits : + public std::numeric_limits { + public: + // Portable version of isinf. + template + static bool isinfinity(T x) { + using namespace fmt::internal; + // The resolution "priority" is: + // isinf macro > std::isinf > ::isinf > fmt::internal::isinf + if (const_check(sizeof(isinf(x)) == sizeof(bool) || + sizeof(isinf(x)) == sizeof(int))) { + return isinf(x) != 0; + } + return !_finite(static_cast(x)); + } + + // Portable version of isnan. + template + static bool isnotanumber(T x) { + using namespace fmt::internal; + if (const_check(sizeof(isnan(x)) == sizeof(bool) || + sizeof(isnan(x)) == sizeof(int))) { + return isnan(x) != 0; + } + return _isnan(static_cast(x)) != 0; + } + + // Portable version of signbit. + static bool isnegative(double x) { + using namespace fmt::internal; + if (const_check(sizeof(signbit(x)) == sizeof(bool) || + sizeof(signbit(x)) == sizeof(int))) { + return signbit(x) != 0; + } + if (x < 0) return true; + if (!isnotanumber(x)) return false; + int dec = 0, sign = 0; + char buffer[2]; // The buffer size must be >= 2 or _ecvt_s will fail. + _ecvt_s(buffer, sizeof(buffer), x, 0, &dec, &sign); + return sign != 0; + } +}; +} // namespace std + +namespace fmt { + +// Fix the warning about long long on older versions of GCC +// that don't support the diagnostic pragma. +FMT_GCC_EXTENSION typedef long long LongLong; +FMT_GCC_EXTENSION typedef unsigned long long ULongLong; + +#if FMT_USE_RVALUE_REFERENCES +using std::move; +#endif + +template +class BasicWriter; + +typedef BasicWriter Writer; +typedef BasicWriter WWriter; + +template +class ArgFormatter; + +struct FormatSpec; + +template +class BasicPrintfArgFormatter; + +template > +class BasicFormatter; + +/** + \rst + A string reference. It can be constructed from a C string or + ``std::basic_string``. + + You can use one of the following typedefs for common character types: + + +------------+-------------------------+ + | Type | Definition | + +============+=========================+ + | StringRef | BasicStringRef | + +------------+-------------------------+ + | WStringRef | BasicStringRef | + +------------+-------------------------+ + + This class is most useful as a parameter type to allow passing + different types of strings to a function, for example:: + + template + std::string format(StringRef format_str, const Args & ... args); + + format("{}", 42); + format(std::string("{}"), 42); + \endrst + */ +template +class BasicStringRef { + private: + const Char *data_; + std::size_t size_; + + public: + /** Constructs a string reference object from a C string and a size. */ + BasicStringRef(const Char *s, std::size_t size) : data_(s), size_(size) {} + + /** + \rst + Constructs a string reference object from a C string computing + the size with ``std::char_traits::length``. + \endrst + */ + BasicStringRef(const Char *s) + : data_(s), size_(std::char_traits::length(s)) {} + + /** + \rst + Constructs a string reference from a ``std::basic_string`` object. + \endrst + */ + template + BasicStringRef( + const std::basic_string, Allocator> &s) + : data_(s.c_str()), size_(s.size()) {} + + /** + \rst + Converts a string reference to an ``std::string`` object. + \endrst + */ + std::basic_string to_string() const { + return std::basic_string(data_, size_); + } + + /** Returns a pointer to the string data. */ + const Char *data() const { return data_; } + + /** Returns the string size. */ + std::size_t size() const { return size_; } + + // Lexicographically compare this string reference to other. + int compare(BasicStringRef other) const { + std::size_t size = size_ < other.size_ ? size_ : other.size_; + int result = std::char_traits::compare(data_, other.data_, size); + if (result == 0) + result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1); + return result; + } + + friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) { + return lhs.compare(rhs) == 0; + } + friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) { + return lhs.compare(rhs) != 0; + } + friend bool operator<(BasicStringRef lhs, BasicStringRef rhs) { + return lhs.compare(rhs) < 0; + } + friend bool operator<=(BasicStringRef lhs, BasicStringRef rhs) { + return lhs.compare(rhs) <= 0; + } + friend bool operator>(BasicStringRef lhs, BasicStringRef rhs) { + return lhs.compare(rhs) > 0; + } + friend bool operator>=(BasicStringRef lhs, BasicStringRef rhs) { + return lhs.compare(rhs) >= 0; + } +}; + +typedef BasicStringRef StringRef; +typedef BasicStringRef WStringRef; + +/** + \rst + A reference to a null terminated string. It can be constructed from a C + string or ``std::basic_string``. + + You can use one of the following typedefs for common character types: + + +-------------+--------------------------+ + | Type | Definition | + +=============+==========================+ + | CStringRef | BasicCStringRef | + +-------------+--------------------------+ + | WCStringRef | BasicCStringRef | + +-------------+--------------------------+ + + This class is most useful as a parameter type to allow passing + different types of strings to a function, for example:: + + template + std::string format(CStringRef format_str, const Args & ... args); + + format("{}", 42); + format(std::string("{}"), 42); + \endrst + */ +template +class BasicCStringRef { + private: + const Char *data_; + + public: + /** Constructs a string reference object from a C string. */ + BasicCStringRef(const Char *s) : data_(s) {} + + /** + \rst + Constructs a string reference from a ``std::basic_string`` object. + \endrst + */ + template + BasicCStringRef( + const std::basic_string, Allocator> &s) + : data_(s.c_str()) {} + + /** Returns the pointer to a C string. */ + const Char *c_str() const { return data_; } +}; + +typedef BasicCStringRef CStringRef; +typedef BasicCStringRef WCStringRef; + +/** A formatting error such as invalid format string. */ +class FormatError : public std::runtime_error { + public: + explicit FormatError(CStringRef message) + : std::runtime_error(message.c_str()) {} + FormatError(const FormatError &ferr) : std::runtime_error(ferr) {} + FMT_API ~FormatError() FMT_DTOR_NOEXCEPT; +}; + +namespace internal { + +// MakeUnsigned::Type gives an unsigned type corresponding to integer type T. +template +struct MakeUnsigned { typedef T Type; }; + +#define FMT_SPECIALIZE_MAKE_UNSIGNED(T, U) \ + template <> \ + struct MakeUnsigned { typedef U Type; } + +FMT_SPECIALIZE_MAKE_UNSIGNED(char, unsigned char); +FMT_SPECIALIZE_MAKE_UNSIGNED(signed char, unsigned char); +FMT_SPECIALIZE_MAKE_UNSIGNED(short, unsigned short); +FMT_SPECIALIZE_MAKE_UNSIGNED(int, unsigned); +FMT_SPECIALIZE_MAKE_UNSIGNED(long, unsigned long); +FMT_SPECIALIZE_MAKE_UNSIGNED(LongLong, ULongLong); + +// Casts nonnegative integer to unsigned. +template +inline typename MakeUnsigned::Type to_unsigned(Int value) { + FMT_ASSERT(value >= 0, "negative value"); + return static_cast::Type>(value); +} + +// The number of characters to store in the MemoryBuffer object itself +// to avoid dynamic memory allocation. +enum { INLINE_BUFFER_SIZE = 500 }; + +#if FMT_SECURE_SCL +// Use checked iterator to avoid warnings on MSVC. +template +inline stdext::checked_array_iterator make_ptr(T *ptr, std::size_t size) { + return stdext::checked_array_iterator(ptr, size); +} +#else +template +inline T *make_ptr(T *ptr, std::size_t) { return ptr; } +#endif +} // namespace internal + +/** + \rst + A buffer supporting a subset of ``std::vector``'s operations. + \endrst + */ +template +class Buffer { + private: + FMT_DISALLOW_COPY_AND_ASSIGN(Buffer); + + protected: + T *ptr_; + std::size_t size_; + std::size_t capacity_; + + Buffer(T *ptr = FMT_NULL, std::size_t capacity = 0) + : ptr_(ptr), size_(0), capacity_(capacity) {} + + /** + \rst + Increases the buffer capacity to hold at least *size* elements updating + ``ptr_`` and ``capacity_``. + \endrst + */ + virtual void grow(std::size_t size) = 0; + + public: + virtual ~Buffer() {} + + /** Returns the size of this buffer. */ + std::size_t size() const { return size_; } + + /** Returns the capacity of this buffer. */ + std::size_t capacity() const { return capacity_; } + + /** + Resizes the buffer. If T is a POD type new elements may not be initialized. + */ + void resize(std::size_t new_size) { + if (new_size > capacity_) + grow(new_size); + size_ = new_size; + } + + /** + \rst + Reserves space to store at least *capacity* elements. + \endrst + */ + void reserve(std::size_t capacity) { + if (capacity > capacity_) + grow(capacity); + } + + void clear() FMT_NOEXCEPT { size_ = 0; } + + void push_back(const T &value) { + if (size_ == capacity_) + grow(size_ + 1); + ptr_[size_++] = value; + } + + /** Appends data to the end of the buffer. */ + template + void append(const U *begin, const U *end); + + T &operator[](std::size_t index) { return ptr_[index]; } + const T &operator[](std::size_t index) const { return ptr_[index]; } +}; + +template +template +void Buffer::append(const U *begin, const U *end) { + FMT_ASSERT(end >= begin, "negative value"); + std::size_t new_size = size_ + (end - begin); + if (new_size > capacity_) + grow(new_size); + std::uninitialized_copy(begin, end, + internal::make_ptr(ptr_, capacity_) + size_); + size_ = new_size; +} + +namespace internal { + +// A memory buffer for trivially copyable/constructible types with the first +// SIZE elements stored in the object itself. +template > +class MemoryBuffer : private Allocator, public Buffer { + private: + T data_[SIZE]; + + // Deallocate memory allocated by the buffer. + void deallocate() { + if (this->ptr_ != data_) Allocator::deallocate(this->ptr_, this->capacity_); + } + + protected: + void grow(std::size_t size) FMT_OVERRIDE; + + public: + explicit MemoryBuffer(const Allocator &alloc = Allocator()) + : Allocator(alloc), Buffer(data_, SIZE) {} + ~MemoryBuffer() { deallocate(); } + +#if FMT_USE_RVALUE_REFERENCES + private: + // Move data from other to this buffer. + void move(MemoryBuffer &other) { + Allocator &this_alloc = *this, &other_alloc = other; + this_alloc = std::move(other_alloc); + this->size_ = other.size_; + this->capacity_ = other.capacity_; + if (other.ptr_ == other.data_) { + this->ptr_ = data_; + std::uninitialized_copy(other.data_, other.data_ + this->size_, + make_ptr(data_, this->capacity_)); + } else { + this->ptr_ = other.ptr_; + // Set pointer to the inline array so that delete is not called + // when deallocating. + other.ptr_ = other.data_; + } + } + + public: + MemoryBuffer(MemoryBuffer &&other) { + move(other); + } + + MemoryBuffer &operator=(MemoryBuffer &&other) { + assert(this != &other); + deallocate(); + move(other); + return *this; + } +#endif + + // Returns a copy of the allocator associated with this buffer. + Allocator get_allocator() const { return *this; } +}; + +template +void MemoryBuffer::grow(std::size_t size) { + std::size_t new_capacity = this->capacity_ + this->capacity_ / 2; + if (size > new_capacity) + new_capacity = size; + T *new_ptr = this->allocate(new_capacity, FMT_NULL); + // The following code doesn't throw, so the raw pointer above doesn't leak. + std::uninitialized_copy(this->ptr_, this->ptr_ + this->size_, + make_ptr(new_ptr, new_capacity)); + std::size_t old_capacity = this->capacity_; + T *old_ptr = this->ptr_; + this->capacity_ = new_capacity; + this->ptr_ = new_ptr; + // deallocate may throw (at least in principle), but it doesn't matter since + // the buffer already uses the new storage and will deallocate it in case + // of exception. + if (old_ptr != data_) + Allocator::deallocate(old_ptr, old_capacity); +} + +// A fixed-size buffer. +template +class FixedBuffer : public fmt::Buffer { + public: + FixedBuffer(Char *array, std::size_t size) : fmt::Buffer(array, size) {} + + protected: + FMT_API void grow(std::size_t size) FMT_OVERRIDE; +}; + +template +class BasicCharTraits { + public: +#if FMT_SECURE_SCL + typedef stdext::checked_array_iterator CharPtr; +#else + typedef Char *CharPtr; +#endif + static Char cast(int value) { return static_cast(value); } +}; + +template +class CharTraits; + +template <> +class CharTraits : public BasicCharTraits { + private: + // Conversion from wchar_t to char is not allowed. + static char convert(wchar_t); + + public: + static char convert(char value) { return value; } + + // Formats a floating-point number. + template + FMT_API static int format_float(char *buffer, std::size_t size, + const char *format, unsigned width, int precision, T value); +}; + +#if FMT_USE_EXTERN_TEMPLATES +extern template int CharTraits::format_float + (char *buffer, std::size_t size, + const char* format, unsigned width, int precision, double value); +extern template int CharTraits::format_float + (char *buffer, std::size_t size, + const char* format, unsigned width, int precision, long double value); +#endif + +template <> +class CharTraits : public BasicCharTraits { + public: + static wchar_t convert(char value) { return value; } + static wchar_t convert(wchar_t value) { return value; } + + template + FMT_API static int format_float(wchar_t *buffer, std::size_t size, + const wchar_t *format, unsigned width, int precision, T value); +}; + +#if FMT_USE_EXTERN_TEMPLATES +extern template int CharTraits::format_float + (wchar_t *buffer, std::size_t size, + const wchar_t* format, unsigned width, int precision, double value); +extern template int CharTraits::format_float + (wchar_t *buffer, std::size_t size, + const wchar_t* format, unsigned width, int precision, long double value); +#endif + +// Checks if a number is negative - used to avoid warnings. +template +struct SignChecker { + template + static bool is_negative(T value) { return value < 0; } +}; + +template <> +struct SignChecker { + template + static bool is_negative(T) { return false; } +}; + +// Returns true if value is negative, false otherwise. +// Same as (value < 0) but doesn't produce warnings if T is an unsigned type. +template +inline bool is_negative(T value) { + return SignChecker::is_signed>::is_negative(value); +} + +// Selects uint32_t if FitsIn32Bits is true, uint64_t otherwise. +template +struct TypeSelector { typedef uint32_t Type; }; + +template <> +struct TypeSelector { typedef uint64_t Type; }; + +template +struct IntTraits { + // Smallest of uint32_t and uint64_t that is large enough to represent + // all values of T. + typedef typename + TypeSelector::digits <= 32>::Type MainType; +}; + +FMT_API void report_unknown_type(char code, const char *type); + +// Static data is placed in this class template to allow header-only +// configuration. +template +struct FMT_API BasicData { + static const uint32_t POWERS_OF_10_32[]; + static const uint64_t POWERS_OF_10_64[]; + static const char DIGITS[]; +}; + +#if FMT_USE_EXTERN_TEMPLATES +extern template struct BasicData; +#endif + +typedef BasicData<> Data; + +#ifdef FMT_BUILTIN_CLZLL +// Returns the number of decimal digits in n. Leading zeros are not counted +// except for n == 0 in which case count_digits returns 1. +inline unsigned count_digits(uint64_t n) { + // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10 + // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits. + int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12; + return to_unsigned(t) - (n < Data::POWERS_OF_10_64[t]) + 1; +} +#else +// Fallback version of count_digits used when __builtin_clz is not available. +inline unsigned count_digits(uint64_t n) { + unsigned count = 1; + for (;;) { + // Integer division is slow so do it for a group of four digits instead + // of for every digit. The idea comes from the talk by Alexandrescu + // "Three Optimization Tips for C++". See speed-test for a comparison. + if (n < 10) return count; + if (n < 100) return count + 1; + if (n < 1000) return count + 2; + if (n < 10000) return count + 3; + n /= 10000u; + count += 4; + } +} +#endif + +#ifdef FMT_BUILTIN_CLZ +// Optional version of count_digits for better performance on 32-bit platforms. +inline unsigned count_digits(uint32_t n) { + int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12; + return to_unsigned(t) - (n < Data::POWERS_OF_10_32[t]) + 1; +} +#endif + +// A functor that doesn't add a thousands separator. +struct NoThousandsSep { + template + void operator()(Char *) {} +}; + +// A functor that adds a thousands separator. +class ThousandsSep { + private: + fmt::StringRef sep_; + + // Index of a decimal digit with the least significant digit having index 0. + unsigned digit_index_; + + public: + explicit ThousandsSep(fmt::StringRef sep) : sep_(sep), digit_index_(0) {} + + template + void operator()(Char *&buffer) { + if (++digit_index_ % 3 != 0) + return; + buffer -= sep_.size(); + std::uninitialized_copy(sep_.data(), sep_.data() + sep_.size(), + internal::make_ptr(buffer, sep_.size())); + } +}; + +// Formats a decimal unsigned integer value writing into buffer. +// thousands_sep is a functor that is called after writing each char to +// add a thousands separator if necessary. +template +inline void format_decimal(Char *buffer, UInt value, unsigned num_digits, + ThousandsSep thousands_sep) { + buffer += num_digits; + while (value >= 100) { + // Integer division is slow so do it for a group of two digits instead + // of for every digit. The idea comes from the talk by Alexandrescu + // "Three Optimization Tips for C++". See speed-test for a comparison. + unsigned index = static_cast((value % 100) * 2); + value /= 100; + *--buffer = Data::DIGITS[index + 1]; + thousands_sep(buffer); + *--buffer = Data::DIGITS[index]; + thousands_sep(buffer); + } + if (value < 10) { + *--buffer = static_cast('0' + value); + return; + } + unsigned index = static_cast(value * 2); + *--buffer = Data::DIGITS[index + 1]; + thousands_sep(buffer); + *--buffer = Data::DIGITS[index]; +} + +template +inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) { + format_decimal(buffer, value, num_digits, NoThousandsSep()); + return; +} + +#ifndef _WIN32 +# define FMT_USE_WINDOWS_H 0 +#elif !defined(FMT_USE_WINDOWS_H) +# define FMT_USE_WINDOWS_H 1 +#endif + +// Define FMT_USE_WINDOWS_H to 0 to disable use of windows.h. +// All the functionality that relies on it will be disabled too. +#if FMT_USE_WINDOWS_H +// A converter from UTF-8 to UTF-16. +// It is only provided for Windows since other systems support UTF-8 natively. +class UTF8ToUTF16 { + private: + MemoryBuffer buffer_; + + public: + FMT_API explicit UTF8ToUTF16(StringRef s); + operator WStringRef() const { return WStringRef(&buffer_[0], size()); } + size_t size() const { return buffer_.size() - 1; } + const wchar_t *c_str() const { return &buffer_[0]; } + std::wstring str() const { return std::wstring(&buffer_[0], size()); } +}; + +// A converter from UTF-16 to UTF-8. +// It is only provided for Windows since other systems support UTF-8 natively. +class UTF16ToUTF8 { + private: + MemoryBuffer buffer_; + + public: + UTF16ToUTF8() {} + FMT_API explicit UTF16ToUTF8(WStringRef s); + operator StringRef() const { return StringRef(&buffer_[0], size()); } + size_t size() const { return buffer_.size() - 1; } + const char *c_str() const { return &buffer_[0]; } + std::string str() const { return std::string(&buffer_[0], size()); } + + // Performs conversion returning a system error code instead of + // throwing exception on conversion error. This method may still throw + // in case of memory allocation error. + FMT_API int convert(WStringRef s); +}; + +FMT_API void format_windows_error(fmt::Writer &out, int error_code, + fmt::StringRef message) FMT_NOEXCEPT; +#endif + +// A formatting argument value. +struct Value { + template + struct StringValue { + const Char *value; + std::size_t size; + }; + + typedef void (*FormatFunc)( + void *formatter, const void *arg, void *format_str_ptr); + + struct CustomValue { + const void *value; + FormatFunc format; + }; + + union { + int int_value; + unsigned uint_value; + LongLong long_long_value; + ULongLong ulong_long_value; + double double_value; + long double long_double_value; + const void *pointer; + StringValue string; + StringValue sstring; + StringValue ustring; + StringValue wstring; + CustomValue custom; + }; + + enum Type { + NONE, NAMED_ARG, + // Integer types should go first, + INT, UINT, LONG_LONG, ULONG_LONG, BOOL, CHAR, LAST_INTEGER_TYPE = CHAR, + // followed by floating-point types. + DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE, + CSTRING, STRING, WSTRING, POINTER, CUSTOM + }; +}; + +// A formatting argument. It is a trivially copyable/constructible type to +// allow storage in internal::MemoryBuffer. +struct Arg : Value { + Type type; +}; + +template +struct NamedArg; +template +struct NamedArgWithType; + +template +struct Null {}; + +// A helper class template to enable or disable overloads taking wide +// characters and strings in MakeValue. +template +struct WCharHelper { + typedef Null Supported; + typedef T Unsupported; +}; + +template +struct WCharHelper { + typedef T Supported; + typedef Null Unsupported; +}; + +typedef char Yes[1]; +typedef char No[2]; + +template +T &get(); + +// These are non-members to workaround an overload resolution bug in bcc32. +Yes &convert(fmt::ULongLong); +No &convert(...); + +template +struct ConvertToIntImpl { + enum { value = ENABLE_CONVERSION }; +}; + +template +struct ConvertToIntImpl2 { + enum { value = false }; +}; + +template +struct ConvertToIntImpl2 { + enum { + // Don't convert numeric types. + value = ConvertToIntImpl::is_specialized>::value + }; +}; + +template +struct ConvertToInt { + enum { + enable_conversion = sizeof(fmt::internal::convert(get())) == sizeof(Yes) + }; + enum { value = ConvertToIntImpl2::value }; +}; + +#define FMT_DISABLE_CONVERSION_TO_INT(Type) \ + template <> \ + struct ConvertToInt { enum { value = 0 }; } + +// Silence warnings about convering float to int. +FMT_DISABLE_CONVERSION_TO_INT(float); +FMT_DISABLE_CONVERSION_TO_INT(double); +FMT_DISABLE_CONVERSION_TO_INT(long double); + +template +struct EnableIf {}; + +template +struct EnableIf { typedef T type; }; + +template +struct Conditional { typedef T type; }; + +template +struct Conditional { typedef F type; }; + +// For bcc32 which doesn't understand ! in template arguments. +template +struct Not { enum { value = 0 }; }; + +template <> +struct Not { enum { value = 1 }; }; + +template +struct FalseType { enum { value = 0 }; }; + +template struct LConvCheck { + LConvCheck(int) {} +}; + +// Returns the thousands separator for the current locale. +// We check if ``lconv`` contains ``thousands_sep`` because on Android +// ``lconv`` is stubbed as an empty struct. +template +inline StringRef thousands_sep( + LConv *lc, LConvCheck = 0) { + return lc->thousands_sep; +} + +inline fmt::StringRef thousands_sep(...) { return ""; } + +#define FMT_CONCAT(a, b) a##b + +#if FMT_GCC_VERSION >= 303 +# define FMT_UNUSED __attribute__((unused)) +#else +# define FMT_UNUSED +#endif + +#ifndef FMT_USE_STATIC_ASSERT +# define FMT_USE_STATIC_ASSERT 0 +#endif + +#if FMT_USE_STATIC_ASSERT || FMT_HAS_FEATURE(cxx_static_assert) || \ + (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1600 +# define FMT_STATIC_ASSERT(cond, message) static_assert(cond, message) +#else +# define FMT_CONCAT_(a, b) FMT_CONCAT(a, b) +# define FMT_STATIC_ASSERT(cond, message) \ + typedef int FMT_CONCAT_(Assert, __LINE__)[(cond) ? 1 : -1] FMT_UNUSED +#endif + +template +void format_arg(Formatter &, const Char *, const T &) { + FMT_STATIC_ASSERT(FalseType::value, + "Cannot format argument. To enable the use of ostream " + "operator<< include fmt/ostream.h. Otherwise provide " + "an overload of format_arg."); +} + +// Makes an Arg object from any type. +template +class MakeValue : public Arg { + public: + typedef typename Formatter::Char Char; + + private: + // The following two methods are private to disallow formatting of + // arbitrary pointers. If you want to output a pointer cast it to + // "void *" or "const void *". In particular, this forbids formatting + // of "[const] volatile char *" which is printed as bool by iostreams. + // Do not implement! + template + MakeValue(const T *value); + template + MakeValue(T *value); + + // The following methods are private to disallow formatting of wide + // characters and strings into narrow strings as in + // fmt::format("{}", L"test"); + // To fix this, use a wide format string: fmt::format(L"{}", L"test"). +#if !FMT_MSC_VER || defined(_NATIVE_WCHAR_T_DEFINED) + MakeValue(typename WCharHelper::Unsupported); +#endif + MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); + + void set_string(StringRef str) { + string.value = str.data(); + string.size = str.size(); + } + + void set_string(WStringRef str) { + wstring.value = str.data(); + wstring.size = str.size(); + } + + // Formats an argument of a custom type, such as a user-defined class. + template + static void format_custom_arg( + void *formatter, const void *arg, void *format_str_ptr) { + format_arg(*static_cast(formatter), + *static_cast(format_str_ptr), + *static_cast(arg)); + } + + public: + MakeValue() {} + +#define FMT_MAKE_VALUE_(Type, field, TYPE, rhs) \ + MakeValue(Type value) { field = rhs; } \ + static uint64_t type(Type) { return Arg::TYPE; } + +#define FMT_MAKE_VALUE(Type, field, TYPE) \ + FMT_MAKE_VALUE_(Type, field, TYPE, value) + + FMT_MAKE_VALUE(bool, int_value, BOOL) + FMT_MAKE_VALUE(short, int_value, INT) + FMT_MAKE_VALUE(unsigned short, uint_value, UINT) + FMT_MAKE_VALUE(int, int_value, INT) + FMT_MAKE_VALUE(unsigned, uint_value, UINT) + + MakeValue(long value) { + // To minimize the number of types we need to deal with, long is + // translated either to int or to long long depending on its size. + if (const_check(sizeof(long) == sizeof(int))) + int_value = static_cast(value); + else + long_long_value = value; + } + static uint64_t type(long) { + return sizeof(long) == sizeof(int) ? Arg::INT : Arg::LONG_LONG; + } + + MakeValue(unsigned long value) { + if (const_check(sizeof(unsigned long) == sizeof(unsigned))) + uint_value = static_cast(value); + else + ulong_long_value = value; + } + static uint64_t type(unsigned long) { + return sizeof(unsigned long) == sizeof(unsigned) ? + Arg::UINT : Arg::ULONG_LONG; + } + + FMT_MAKE_VALUE(LongLong, long_long_value, LONG_LONG) + FMT_MAKE_VALUE(ULongLong, ulong_long_value, ULONG_LONG) + FMT_MAKE_VALUE(float, double_value, DOUBLE) + FMT_MAKE_VALUE(double, double_value, DOUBLE) + FMT_MAKE_VALUE(long double, long_double_value, LONG_DOUBLE) + FMT_MAKE_VALUE(signed char, int_value, INT) + FMT_MAKE_VALUE(unsigned char, uint_value, UINT) + FMT_MAKE_VALUE(char, int_value, CHAR) + +#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) + MakeValue(typename WCharHelper::Supported value) { + int_value = value; + } + static uint64_t type(wchar_t) { return Arg::CHAR; } +#endif + +#define FMT_MAKE_STR_VALUE(Type, TYPE) \ + MakeValue(Type value) { set_string(value); } \ + static uint64_t type(Type) { return Arg::TYPE; } + + FMT_MAKE_VALUE(char *, string.value, CSTRING) + FMT_MAKE_VALUE(const char *, string.value, CSTRING) + FMT_MAKE_VALUE(signed char *, sstring.value, CSTRING) + FMT_MAKE_VALUE(const signed char *, sstring.value, CSTRING) + FMT_MAKE_VALUE(unsigned char *, ustring.value, CSTRING) + FMT_MAKE_VALUE(const unsigned char *, ustring.value, CSTRING) + FMT_MAKE_STR_VALUE(const std::string &, STRING) + FMT_MAKE_STR_VALUE(StringRef, STRING) + FMT_MAKE_VALUE_(CStringRef, string.value, CSTRING, value.c_str()) + +#define FMT_MAKE_WSTR_VALUE(Type, TYPE) \ + MakeValue(typename WCharHelper::Supported value) { \ + set_string(value); \ + } \ + static uint64_t type(Type) { return Arg::TYPE; } + + FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING) + FMT_MAKE_WSTR_VALUE(const wchar_t *, WSTRING) + FMT_MAKE_WSTR_VALUE(const std::wstring &, WSTRING) + FMT_MAKE_WSTR_VALUE(WStringRef, WSTRING) + + FMT_MAKE_VALUE(void *, pointer, POINTER) + FMT_MAKE_VALUE(const void *, pointer, POINTER) + + template + MakeValue(const T &value, + typename EnableIf::value>::value, int>::type = 0) { + custom.value = &value; + custom.format = &format_custom_arg; + } + + template + static typename EnableIf::value>::value, uint64_t>::type + type(const T &) { + return Arg::CUSTOM; + } + + // Additional template param `Char_` is needed here because make_type always + // uses char. + template + MakeValue(const NamedArg &value) { pointer = &value; } + template + MakeValue(const NamedArgWithType &value) { pointer = &value; } + + template + static uint64_t type(const NamedArg &) { return Arg::NAMED_ARG; } + template + static uint64_t type(const NamedArgWithType &) { return Arg::NAMED_ARG; } +}; + +template +class MakeArg : public Arg { +public: + MakeArg() { + type = Arg::NONE; + } + + template + MakeArg(const T &value) + : Arg(MakeValue(value)) { + type = static_cast(MakeValue::type(value)); + } +}; + +template +struct NamedArg : Arg { + BasicStringRef name; + + template + NamedArg(BasicStringRef argname, const T &value) + : Arg(MakeArg< BasicFormatter >(value)), name(argname) {} +}; + +template +struct NamedArgWithType : NamedArg { + NamedArgWithType(BasicStringRef argname, const T &value) + : NamedArg(argname, value) {} +}; + +class RuntimeError : public std::runtime_error { + protected: + RuntimeError() : std::runtime_error("") {} + RuntimeError(const RuntimeError &rerr) : std::runtime_error(rerr) {} + FMT_API ~RuntimeError() FMT_DTOR_NOEXCEPT; +}; + +template +class ArgMap; +} // namespace internal + +/** An argument list. */ +class ArgList { + private: + // To reduce compiled code size per formatting function call, types of first + // MAX_PACKED_ARGS arguments are passed in the types_ field. + uint64_t types_; + union { + // If the number of arguments is less than MAX_PACKED_ARGS, the argument + // values are stored in values_, otherwise they are stored in args_. + // This is done to reduce compiled code size as storing larger objects + // may require more code (at least on x86-64) even if the same amount of + // data is actually copied to stack. It saves ~10% on the bloat test. + const internal::Value *values_; + const internal::Arg *args_; + }; + + internal::Arg::Type type(unsigned index) const { + return type(types_, index); + } + + template + friend class internal::ArgMap; + + public: + // Maximum number of arguments with packed types. + enum { MAX_PACKED_ARGS = 16 }; + + ArgList() : types_(0) {} + + ArgList(ULongLong types, const internal::Value *values) + : types_(types), values_(values) {} + ArgList(ULongLong types, const internal::Arg *args) + : types_(types), args_(args) {} + + uint64_t types() const { return types_; } + + /** Returns the argument at specified index. */ + internal::Arg operator[](unsigned index) const { + using internal::Arg; + Arg arg; + bool use_values = type(MAX_PACKED_ARGS - 1) == Arg::NONE; + if (index < MAX_PACKED_ARGS) { + Arg::Type arg_type = type(index); + internal::Value &val = arg; + if (arg_type != Arg::NONE) + val = use_values ? values_[index] : args_[index]; + arg.type = arg_type; + return arg; + } + if (use_values) { + // The index is greater than the number of arguments that can be stored + // in values, so return a "none" argument. + arg.type = Arg::NONE; + return arg; + } + for (unsigned i = MAX_PACKED_ARGS; i <= index; ++i) { + if (args_[i].type == Arg::NONE) + return args_[i]; + } + return args_[index]; + } + + static internal::Arg::Type type(uint64_t types, unsigned index) { + unsigned shift = index * 4; + uint64_t mask = 0xf; + return static_cast( + (types & (mask << shift)) >> shift); + } +}; + +#define FMT_DISPATCH(call) static_cast(this)->call + +/** + \rst + An argument visitor based on the `curiously recurring template pattern + `_. + + To use `~fmt::ArgVisitor` define a subclass that implements some or all of the + visit methods with the same signatures as the methods in `~fmt::ArgVisitor`, + for example, `~fmt::ArgVisitor::visit_int()`. + Pass the subclass as the *Impl* template parameter. Then calling + `~fmt::ArgVisitor::visit` for some argument will dispatch to a visit method + specific to the argument type. For example, if the argument type is + ``double`` then the `~fmt::ArgVisitor::visit_double()` method of a subclass + will be called. If the subclass doesn't contain a method with this signature, + then a corresponding method of `~fmt::ArgVisitor` will be called. + + **Example**:: + + class MyArgVisitor : public fmt::ArgVisitor { + public: + void visit_int(int value) { fmt::print("{}", value); } + void visit_double(double value) { fmt::print("{}", value ); } + }; + \endrst + */ +template +class ArgVisitor { + private: + typedef internal::Arg Arg; + + public: + void report_unhandled_arg() {} + + Result visit_unhandled_arg() { + FMT_DISPATCH(report_unhandled_arg()); + return Result(); + } + + /** Visits an ``int`` argument. **/ + Result visit_int(int value) { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits a ``long long`` argument. **/ + Result visit_long_long(LongLong value) { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits an ``unsigned`` argument. **/ + Result visit_uint(unsigned value) { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits an ``unsigned long long`` argument. **/ + Result visit_ulong_long(ULongLong value) { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits a ``bool`` argument. **/ + Result visit_bool(bool value) { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits a ``char`` or ``wchar_t`` argument. **/ + Result visit_char(int value) { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits an argument of any integral type. **/ + template + Result visit_any_int(T) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits a ``double`` argument. **/ + Result visit_double(double value) { + return FMT_DISPATCH(visit_any_double(value)); + } + + /** Visits a ``long double`` argument. **/ + Result visit_long_double(long double value) { + return FMT_DISPATCH(visit_any_double(value)); + } + + /** Visits a ``double`` or ``long double`` argument. **/ + template + Result visit_any_double(T) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits a null-terminated C string (``const char *``) argument. **/ + Result visit_cstring(const char *) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits a string argument. **/ + Result visit_string(Arg::StringValue) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits a wide string argument. **/ + Result visit_wstring(Arg::StringValue) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits a pointer argument. **/ + Result visit_pointer(const void *) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits an argument of a custom (user-defined) type. **/ + Result visit_custom(Arg::CustomValue) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** + \rst + Visits an argument dispatching to the appropriate visit method based on + the argument type. For example, if the argument type is ``double`` then + the `~fmt::ArgVisitor::visit_double()` method of the *Impl* class will be + called. + \endrst + */ + Result visit(const Arg &arg) { + switch (arg.type) { + case Arg::NONE: + case Arg::NAMED_ARG: + FMT_ASSERT(false, "invalid argument type"); + break; + case Arg::INT: + return FMT_DISPATCH(visit_int(arg.int_value)); + case Arg::UINT: + return FMT_DISPATCH(visit_uint(arg.uint_value)); + case Arg::LONG_LONG: + return FMT_DISPATCH(visit_long_long(arg.long_long_value)); + case Arg::ULONG_LONG: + return FMT_DISPATCH(visit_ulong_long(arg.ulong_long_value)); + case Arg::BOOL: + return FMT_DISPATCH(visit_bool(arg.int_value != 0)); + case Arg::CHAR: + return FMT_DISPATCH(visit_char(arg.int_value)); + case Arg::DOUBLE: + return FMT_DISPATCH(visit_double(arg.double_value)); + case Arg::LONG_DOUBLE: + return FMT_DISPATCH(visit_long_double(arg.long_double_value)); + case Arg::CSTRING: + return FMT_DISPATCH(visit_cstring(arg.string.value)); + case Arg::STRING: + return FMT_DISPATCH(visit_string(arg.string)); + case Arg::WSTRING: + return FMT_DISPATCH(visit_wstring(arg.wstring)); + case Arg::POINTER: + return FMT_DISPATCH(visit_pointer(arg.pointer)); + case Arg::CUSTOM: + return FMT_DISPATCH(visit_custom(arg.custom)); + default: + break; + } + return Result(); + } +}; + +enum Alignment { + ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC +}; + +// Flags. +enum { + SIGN_FLAG = 1, PLUS_FLAG = 2, MINUS_FLAG = 4, HASH_FLAG = 8, + CHAR_FLAG = 0x10 // Argument has char type - used in error reporting. +}; + +// An empty format specifier. +struct EmptySpec {}; + +// A type specifier. +template +struct TypeSpec : EmptySpec { + Alignment align() const { return ALIGN_DEFAULT; } + unsigned width() const { return 0; } + int precision() const { return -1; } + bool flag(unsigned) const { return false; } + char type() const { return TYPE; } + char type_prefix() const { return TYPE; } + char fill() const { return ' '; } +}; + +// A width specifier. +struct WidthSpec { + unsigned width_; + // Fill is always wchar_t and cast to char if necessary to avoid having + // two specialization of WidthSpec and its subclasses. + wchar_t fill_; + + WidthSpec(unsigned width, wchar_t fill) : width_(width), fill_(fill) {} + + unsigned width() const { return width_; } + wchar_t fill() const { return fill_; } +}; + +// An alignment specifier. +struct AlignSpec : WidthSpec { + Alignment align_; + + AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT) + : WidthSpec(width, fill), align_(align) {} + + Alignment align() const { return align_; } + + int precision() const { return -1; } +}; + +// An alignment and type specifier. +template +struct AlignTypeSpec : AlignSpec { + AlignTypeSpec(unsigned width, wchar_t fill) : AlignSpec(width, fill) {} + + bool flag(unsigned) const { return false; } + char type() const { return TYPE; } + char type_prefix() const { return TYPE; } +}; + +// A full format specifier. +struct FormatSpec : AlignSpec { + unsigned flags_; + int precision_; + char type_; + + FormatSpec( + unsigned width = 0, char type = 0, wchar_t fill = ' ') + : AlignSpec(width, fill), flags_(0), precision_(-1), type_(type) {} + + bool flag(unsigned f) const { return (flags_ & f) != 0; } + int precision() const { return precision_; } + char type() const { return type_; } + char type_prefix() const { return type_; } +}; + +// An integer format specifier. +template , typename Char = char> +class IntFormatSpec : public SpecT { + private: + T value_; + + public: + IntFormatSpec(T val, const SpecT &spec = SpecT()) + : SpecT(spec), value_(val) {} + + T value() const { return value_; } +}; + +// A string format specifier. +template +class StrFormatSpec : public AlignSpec { + private: + const Char *str_; + + public: + template + StrFormatSpec(const Char *str, unsigned width, FillChar fill) + : AlignSpec(width, fill), str_(str) { + internal::CharTraits::convert(FillChar()); + } + + const Char *str() const { return str_; } +}; + +/** + Returns an integer format specifier to format the value in base 2. + */ +IntFormatSpec > bin(int value); + +/** + Returns an integer format specifier to format the value in base 8. + */ +IntFormatSpec > oct(int value); + +/** + Returns an integer format specifier to format the value in base 16 using + lower-case letters for the digits above 9. + */ +IntFormatSpec > hex(int value); + +/** + Returns an integer formatter format specifier to format in base 16 using + upper-case letters for the digits above 9. + */ +IntFormatSpec > hexu(int value); + +/** + \rst + Returns an integer format specifier to pad the formatted argument with the + fill character to the specified width using the default (right) numeric + alignment. + + **Example**:: + + MemoryWriter out; + out << pad(hex(0xcafe), 8, '0'); + // out.str() == "0000cafe" + + \endrst + */ +template +IntFormatSpec, Char> pad( + int value, unsigned width, Char fill = ' '); + +#define FMT_DEFINE_INT_FORMATTERS(TYPE) \ +inline IntFormatSpec > bin(TYPE value) { \ + return IntFormatSpec >(value, TypeSpec<'b'>()); \ +} \ + \ +inline IntFormatSpec > oct(TYPE value) { \ + return IntFormatSpec >(value, TypeSpec<'o'>()); \ +} \ + \ +inline IntFormatSpec > hex(TYPE value) { \ + return IntFormatSpec >(value, TypeSpec<'x'>()); \ +} \ + \ +inline IntFormatSpec > hexu(TYPE value) { \ + return IntFormatSpec >(value, TypeSpec<'X'>()); \ +} \ + \ +template \ +inline IntFormatSpec > pad( \ + IntFormatSpec > f, unsigned width) { \ + return IntFormatSpec >( \ + f.value(), AlignTypeSpec(width, ' ')); \ +} \ + \ +/* For compatibility with older compilers we provide two overloads for pad, */ \ +/* one that takes a fill character and one that doesn't. In the future this */ \ +/* can be replaced with one overload making the template argument Char */ \ +/* default to char (C++11). */ \ +template \ +inline IntFormatSpec, Char> pad( \ + IntFormatSpec, Char> f, \ + unsigned width, Char fill) { \ + return IntFormatSpec, Char>( \ + f.value(), AlignTypeSpec(width, fill)); \ +} \ + \ +inline IntFormatSpec > pad( \ + TYPE value, unsigned width) { \ + return IntFormatSpec >( \ + value, AlignTypeSpec<0>(width, ' ')); \ +} \ + \ +template \ +inline IntFormatSpec, Char> pad( \ + TYPE value, unsigned width, Char fill) { \ + return IntFormatSpec, Char>( \ + value, AlignTypeSpec<0>(width, fill)); \ +} + +FMT_DEFINE_INT_FORMATTERS(int) +FMT_DEFINE_INT_FORMATTERS(long) +FMT_DEFINE_INT_FORMATTERS(unsigned) +FMT_DEFINE_INT_FORMATTERS(unsigned long) +FMT_DEFINE_INT_FORMATTERS(LongLong) +FMT_DEFINE_INT_FORMATTERS(ULongLong) + +/** + \rst + Returns a string formatter that pads the formatted argument with the fill + character to the specified width using the default (left) string alignment. + + **Example**:: + + std::string s = str(MemoryWriter() << pad("abc", 8)); + // s == "abc " + + \endrst + */ +template +inline StrFormatSpec pad( + const Char *str, unsigned width, Char fill = ' ') { + return StrFormatSpec(str, width, fill); +} + +inline StrFormatSpec pad( + const wchar_t *str, unsigned width, char fill = ' ') { + return StrFormatSpec(str, width, fill); +} + +namespace internal { + +template +class ArgMap { + private: + typedef std::vector< + std::pair, internal::Arg> > MapType; + typedef typename MapType::value_type Pair; + + MapType map_; + + public: + FMT_API void init(const ArgList &args); + + const internal::Arg *find(const fmt::BasicStringRef &name) const { + // The list is unsorted, so just return the first matching name. + for (typename MapType::const_iterator it = map_.begin(), end = map_.end(); + it != end; ++it) { + if (it->first == name) + return &it->second; + } + return FMT_NULL; + } +}; + +template +class ArgFormatterBase : public ArgVisitor { + private: + BasicWriter &writer_; + Spec &spec_; + + FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatterBase); + + void write_pointer(const void *p) { + spec_.flags_ = HASH_FLAG; + spec_.type_ = 'x'; + writer_.write_int(reinterpret_cast(p), spec_); + } + + // workaround MSVC two-phase lookup issue + typedef internal::Arg Arg; + + protected: + BasicWriter &writer() { return writer_; } + Spec &spec() { return spec_; } + + void write(bool value) { + const char *str_value = value ? "true" : "false"; + Arg::StringValue str = { str_value, std::strlen(str_value) }; + writer_.write_str(str, spec_); + } + + void write(const char *value) { + Arg::StringValue str = {value, value ? std::strlen(value) : 0}; + writer_.write_str(str, spec_); + } + + public: + typedef Spec SpecType; + + ArgFormatterBase(BasicWriter &w, Spec &s) + : writer_(w), spec_(s) {} + + template + void visit_any_int(T value) { writer_.write_int(value, spec_); } + + template + void visit_any_double(T value) { writer_.write_double(value, spec_); } + + void visit_bool(bool value) { + if (spec_.type_) { + visit_any_int(value); + return; + } + write(value); + } + + void visit_char(int value) { + if (spec_.type_ && spec_.type_ != 'c') { + spec_.flags_ |= CHAR_FLAG; + writer_.write_int(value, spec_); + return; + } + if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0) + FMT_THROW(FormatError("invalid format specifier for char")); + typedef typename BasicWriter::CharPtr CharPtr; + Char fill = internal::CharTraits::cast(spec_.fill()); + CharPtr out = CharPtr(); + const unsigned CHAR_SIZE = 1; + if (spec_.width_ > CHAR_SIZE) { + out = writer_.grow_buffer(spec_.width_); + if (spec_.align_ == ALIGN_RIGHT) { + std::uninitialized_fill_n(out, spec_.width_ - CHAR_SIZE, fill); + out += spec_.width_ - CHAR_SIZE; + } else if (spec_.align_ == ALIGN_CENTER) { + out = writer_.fill_padding(out, spec_.width_, + internal::const_check(CHAR_SIZE), fill); + } else { + std::uninitialized_fill_n(out + CHAR_SIZE, + spec_.width_ - CHAR_SIZE, fill); + } + } else { + out = writer_.grow_buffer(CHAR_SIZE); + } + *out = internal::CharTraits::cast(value); + } + + void visit_cstring(const char *value) { + if (spec_.type_ == 'p') + return write_pointer(value); + write(value); + } + + // Qualification with "internal" here and below is a workaround for nvcc. + void visit_string(internal::Arg::StringValue value) { + writer_.write_str(value, spec_); + } + + using ArgVisitor::visit_wstring; + + void visit_wstring(internal::Arg::StringValue value) { + writer_.write_str(value, spec_); + } + + void visit_pointer(const void *value) { + if (spec_.type_ && spec_.type_ != 'p') + report_unknown_type(spec_.type_, "pointer"); + write_pointer(value); + } +}; + +class FormatterBase { + private: + ArgList args_; + int next_arg_index_; + + // Returns the argument with specified index. + FMT_API Arg do_get_arg(unsigned arg_index, const char *&error); + + protected: + const ArgList &args() const { return args_; } + + explicit FormatterBase(const ArgList &args) { + args_ = args; + next_arg_index_ = 0; + } + + // Returns the next argument. + Arg next_arg(const char *&error) { + if (next_arg_index_ >= 0) + return do_get_arg(internal::to_unsigned(next_arg_index_++), error); + error = "cannot switch from manual to automatic argument indexing"; + return Arg(); + } + + // Checks if manual indexing is used and returns the argument with + // specified index. + Arg get_arg(unsigned arg_index, const char *&error) { + return check_no_auto_index(error) ? do_get_arg(arg_index, error) : Arg(); + } + + bool check_no_auto_index(const char *&error) { + if (next_arg_index_ > 0) { + error = "cannot switch from automatic to manual argument indexing"; + return false; + } + next_arg_index_ = -1; + return true; + } + + template + void write(BasicWriter &w, const Char *start, const Char *end) { + if (start != end) + w << BasicStringRef(start, internal::to_unsigned(end - start)); + } +}; +} // namespace internal + +/** + \rst + An argument formatter based on the `curiously recurring template pattern + `_. + + To use `~fmt::BasicArgFormatter` define a subclass that implements some or + all of the visit methods with the same signatures as the methods in + `~fmt::ArgVisitor`, for example, `~fmt::ArgVisitor::visit_int()`. + Pass the subclass as the *Impl* template parameter. When a formatting + function processes an argument, it will dispatch to a visit method + specific to the argument type. For example, if the argument type is + ``double`` then the `~fmt::ArgVisitor::visit_double()` method of a subclass + will be called. If the subclass doesn't contain a method with this signature, + then a corresponding method of `~fmt::BasicArgFormatter` or its superclass + will be called. + \endrst + */ +template +class BasicArgFormatter : public internal::ArgFormatterBase { + private: + BasicFormatter &formatter_; + const Char *format_; + + public: + /** + \rst + Constructs an argument formatter object. + *formatter* is a reference to the main formatter object, *spec* contains + format specifier information for standard argument types, and *fmt* points + to the part of the format string being parsed for custom argument types. + \endrst + */ + BasicArgFormatter(BasicFormatter &formatter, + Spec &spec, const Char *fmt) + : internal::ArgFormatterBase(formatter.writer(), spec), + formatter_(formatter), format_(fmt) {} + + /** Formats an argument of a custom (user-defined) type. */ + void visit_custom(internal::Arg::CustomValue c) { + c.format(&formatter_, c.value, &format_); + } +}; + +/** The default argument formatter. */ +template +class ArgFormatter : + public BasicArgFormatter, Char, FormatSpec> { + public: + /** Constructs an argument formatter object. */ + ArgFormatter(BasicFormatter &formatter, + FormatSpec &spec, const Char *fmt) + : BasicArgFormatter, + Char, FormatSpec>(formatter, spec, fmt) {} +}; + +/** This template formats data and writes the output to a writer. */ +template +class BasicFormatter : private internal::FormatterBase { + public: + /** The character type for the output. */ + typedef CharType Char; + + private: + BasicWriter &writer_; + internal::ArgMap map_; + + FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter); + + using internal::FormatterBase::get_arg; + + // Checks if manual indexing is used and returns the argument with + // specified name. + internal::Arg get_arg(BasicStringRef arg_name, const char *&error); + + // Parses argument index and returns corresponding argument. + internal::Arg parse_arg_index(const Char *&s); + + // Parses argument name and returns corresponding argument. + internal::Arg parse_arg_name(const Char *&s); + + public: + /** + \rst + Constructs a ``BasicFormatter`` object. References to the arguments and + the writer are stored in the formatter object so make sure they have + appropriate lifetimes. + \endrst + */ + BasicFormatter(const ArgList &args, BasicWriter &w) + : internal::FormatterBase(args), writer_(w) {} + + /** Returns a reference to the writer associated with this formatter. */ + BasicWriter &writer() { return writer_; } + + /** Formats stored arguments and writes the output to the writer. */ + void format(BasicCStringRef format_str); + + // Formats a single argument and advances format_str, a format string pointer. + const Char *format(const Char *&format_str, const internal::Arg &arg); +}; + +// Generates a comma-separated list with results of applying f to +// numbers 0..n-1. +# define FMT_GEN(n, f) FMT_GEN##n(f) +# define FMT_GEN1(f) f(0) +# define FMT_GEN2(f) FMT_GEN1(f), f(1) +# define FMT_GEN3(f) FMT_GEN2(f), f(2) +# define FMT_GEN4(f) FMT_GEN3(f), f(3) +# define FMT_GEN5(f) FMT_GEN4(f), f(4) +# define FMT_GEN6(f) FMT_GEN5(f), f(5) +# define FMT_GEN7(f) FMT_GEN6(f), f(6) +# define FMT_GEN8(f) FMT_GEN7(f), f(7) +# define FMT_GEN9(f) FMT_GEN8(f), f(8) +# define FMT_GEN10(f) FMT_GEN9(f), f(9) +# define FMT_GEN11(f) FMT_GEN10(f), f(10) +# define FMT_GEN12(f) FMT_GEN11(f), f(11) +# define FMT_GEN13(f) FMT_GEN12(f), f(12) +# define FMT_GEN14(f) FMT_GEN13(f), f(13) +# define FMT_GEN15(f) FMT_GEN14(f), f(14) + +namespace internal { +inline uint64_t make_type() { return 0; } + +template +inline uint64_t make_type(const T &arg) { + return MakeValue< BasicFormatter >::type(arg); +} + +template +struct ArgArray; + +template +struct ArgArray { + typedef Value Type[N > 0 ? N : 1]; + + template + static Value make(const T &value) { +#ifdef __clang__ + Value result = MakeValue(value); + // Workaround a bug in Apple LLVM version 4.2 (clang-425.0.28) of clang: + // https://github.com/fmtlib/fmt/issues/276 + (void)result.custom.format; + return result; +#else + return MakeValue(value); +#endif + } +}; + +template +struct ArgArray { + typedef Arg Type[N + 1]; // +1 for the list end Arg::NONE + + template + static Arg make(const T &value) { return MakeArg(value); } +}; + +#if FMT_USE_VARIADIC_TEMPLATES +template +inline uint64_t make_type(const Arg &first, const Args & ... tail) { + return make_type(first) | (make_type(tail...) << 4); +} + +#else + +struct ArgType { + uint64_t type; + + ArgType() : type(0) {} + + template + ArgType(const T &arg) : type(make_type(arg)) {} +}; + +# define FMT_ARG_TYPE_DEFAULT(n) ArgType t##n = ArgType() + +inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) { + return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) | + (t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) | + (t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) | + (t12.type << 48) | (t13.type << 52) | (t14.type << 56); +} +#endif +} // namespace internal + +# define FMT_MAKE_TEMPLATE_ARG(n) typename T##n +# define FMT_MAKE_ARG_TYPE(n) T##n +# define FMT_MAKE_ARG(n) const T##n &v##n +# define FMT_ASSIGN_char(n) \ + arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter >(v##n) +# define FMT_ASSIGN_wchar_t(n) \ + arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter >(v##n) + +#if FMT_USE_VARIADIC_TEMPLATES +// Defines a variadic function returning void. +# define FMT_VARIADIC_VOID(func, arg_type) \ + template \ + void func(arg_type arg0, const Args & ... args) { \ + typedef fmt::internal::ArgArray ArgArray; \ + typename ArgArray::Type array{ \ + ArgArray::template make >(args)...}; \ + func(arg0, fmt::ArgList(fmt::internal::make_type(args...), array)); \ + } + +// Defines a variadic constructor. +# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \ + template \ + ctor(arg0_type arg0, arg1_type arg1, const Args & ... args) { \ + typedef fmt::internal::ArgArray ArgArray; \ + typename ArgArray::Type array{ \ + ArgArray::template make >(args)...}; \ + func(arg0, arg1, fmt::ArgList(fmt::internal::make_type(args...), array)); \ + } + +#else + +# define FMT_MAKE_REF(n) \ + fmt::internal::MakeValue< fmt::BasicFormatter >(v##n) +# define FMT_MAKE_REF2(n) v##n + +// Defines a wrapper for a function taking one argument of type arg_type +// and n additional arguments of arbitrary types. +# define FMT_WRAP1(func, arg_type, n) \ + template \ + inline void func(arg_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \ + const fmt::internal::ArgArray::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \ + func(arg1, fmt::ArgList( \ + fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \ + } + +// Emulates a variadic function returning void on a pre-C++11 compiler. +# define FMT_VARIADIC_VOID(func, arg_type) \ + inline void func(arg_type arg) { func(arg, fmt::ArgList()); } \ + FMT_WRAP1(func, arg_type, 1) FMT_WRAP1(func, arg_type, 2) \ + FMT_WRAP1(func, arg_type, 3) FMT_WRAP1(func, arg_type, 4) \ + FMT_WRAP1(func, arg_type, 5) FMT_WRAP1(func, arg_type, 6) \ + FMT_WRAP1(func, arg_type, 7) FMT_WRAP1(func, arg_type, 8) \ + FMT_WRAP1(func, arg_type, 9) FMT_WRAP1(func, arg_type, 10) + +# define FMT_CTOR(ctor, func, arg0_type, arg1_type, n) \ + template \ + ctor(arg0_type arg0, arg1_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \ + const fmt::internal::ArgArray::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \ + func(arg0, arg1, fmt::ArgList( \ + fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \ + } + +// Emulates a variadic constructor on a pre-C++11 compiler. +# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \ + FMT_CTOR(ctor, func, arg0_type, arg1_type, 1) \ + FMT_CTOR(ctor, func, arg0_type, arg1_type, 2) \ + FMT_CTOR(ctor, func, arg0_type, arg1_type, 3) \ + FMT_CTOR(ctor, func, arg0_type, arg1_type, 4) \ + FMT_CTOR(ctor, func, arg0_type, arg1_type, 5) \ + FMT_CTOR(ctor, func, arg0_type, arg1_type, 6) \ + FMT_CTOR(ctor, func, arg0_type, arg1_type, 7) \ + FMT_CTOR(ctor, func, arg0_type, arg1_type, 8) \ + FMT_CTOR(ctor, func, arg0_type, arg1_type, 9) \ + FMT_CTOR(ctor, func, arg0_type, arg1_type, 10) +#endif + +// Generates a comma-separated list with results of applying f to pairs +// (argument, index). +#define FMT_FOR_EACH1(f, x0) f(x0, 0) +#define FMT_FOR_EACH2(f, x0, x1) \ + FMT_FOR_EACH1(f, x0), f(x1, 1) +#define FMT_FOR_EACH3(f, x0, x1, x2) \ + FMT_FOR_EACH2(f, x0 ,x1), f(x2, 2) +#define FMT_FOR_EACH4(f, x0, x1, x2, x3) \ + FMT_FOR_EACH3(f, x0, x1, x2), f(x3, 3) +#define FMT_FOR_EACH5(f, x0, x1, x2, x3, x4) \ + FMT_FOR_EACH4(f, x0, x1, x2, x3), f(x4, 4) +#define FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5) \ + FMT_FOR_EACH5(f, x0, x1, x2, x3, x4), f(x5, 5) +#define FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6) \ + FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5), f(x6, 6) +#define FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7) \ + FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6), f(x7, 7) +#define FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8) \ + FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7), f(x8, 8) +#define FMT_FOR_EACH10(f, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) \ + FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8), f(x9, 9) + +/** + An error returned by an operating system or a language runtime, + for example a file opening error. +*/ +class SystemError : public internal::RuntimeError { + private: + FMT_API void init(int err_code, CStringRef format_str, ArgList args); + + protected: + int error_code_; + + typedef char Char; // For FMT_VARIADIC_CTOR. + + SystemError() {} + + public: + /** + \rst + Constructs a :class:`fmt::SystemError` object with a description + formatted with `fmt::format_system_error`. *message* and additional + arguments passed into the constructor are formatted similarly to + `fmt::format`. + + **Example**:: + + // This throws a SystemError with the description + // cannot open file 'madeup': No such file or directory + // or similar (system message may vary). + const char *filename = "madeup"; + std::FILE *file = std::fopen(filename, "r"); + if (!file) + throw fmt::SystemError(errno, "cannot open file '{}'", filename); + \endrst + */ + SystemError(int error_code, CStringRef message) { + init(error_code, message, ArgList()); + } + FMT_DEFAULTED_COPY_CTOR(SystemError) + FMT_VARIADIC_CTOR(SystemError, init, int, CStringRef) + + FMT_API ~SystemError() FMT_DTOR_NOEXCEPT; + + int error_code() const { return error_code_; } +}; + +/** + \rst + Formats an error returned by an operating system or a language runtime, + for example a file opening error, and writes it to *out* in the following + form: + + .. parsed-literal:: + **: ** + + where ** is the passed message and ** is + the system message corresponding to the error code. + *error_code* is a system error code as given by ``errno``. + If *error_code* is not a valid error code such as -1, the system message + may look like "Unknown error -1" and is platform-dependent. + \endrst + */ +FMT_API void format_system_error(fmt::Writer &out, int error_code, + fmt::StringRef message) FMT_NOEXCEPT; + +/** + \rst + This template provides operations for formatting and writing data into + a character stream. The output is stored in a buffer provided by a subclass + such as :class:`fmt::BasicMemoryWriter`. + + You can use one of the following typedefs for common character types: + + +---------+----------------------+ + | Type | Definition | + +=========+======================+ + | Writer | BasicWriter | + +---------+----------------------+ + | WWriter | BasicWriter | + +---------+----------------------+ + + \endrst + */ +template +class BasicWriter { + private: + // Output buffer. + Buffer &buffer_; + + FMT_DISALLOW_COPY_AND_ASSIGN(BasicWriter); + + typedef typename internal::CharTraits::CharPtr CharPtr; + +#if FMT_SECURE_SCL + // Returns pointer value. + static Char *get(CharPtr p) { return p.base(); } +#else + static Char *get(Char *p) { return p; } +#endif + + // Fills the padding around the content and returns the pointer to the + // content area. + static CharPtr fill_padding(CharPtr buffer, + unsigned total_size, std::size_t content_size, wchar_t fill); + + // Grows the buffer by n characters and returns a pointer to the newly + // allocated area. + CharPtr grow_buffer(std::size_t n) { + std::size_t size = buffer_.size(); + buffer_.resize(size + n); + return internal::make_ptr(&buffer_[size], n); + } + + // Writes an unsigned decimal integer. + template + Char *write_unsigned_decimal(UInt value, unsigned prefix_size = 0) { + unsigned num_digits = internal::count_digits(value); + Char *ptr = get(grow_buffer(prefix_size + num_digits)); + internal::format_decimal(ptr + prefix_size, value, num_digits); + return ptr; + } + + // Writes a decimal integer. + template + void write_decimal(Int value) { + typedef typename internal::IntTraits::MainType MainType; + MainType abs_value = static_cast(value); + if (internal::is_negative(value)) { + abs_value = 0 - abs_value; + *write_unsigned_decimal(abs_value, 1) = '-'; + } else { + write_unsigned_decimal(abs_value, 0); + } + } + + // Prepare a buffer for integer formatting. + CharPtr prepare_int_buffer(unsigned num_digits, + const EmptySpec &, const char *prefix, unsigned prefix_size) { + unsigned size = prefix_size + num_digits; + CharPtr p = grow_buffer(size); + std::uninitialized_copy(prefix, prefix + prefix_size, p); + return p + size - 1; + } + + template + CharPtr prepare_int_buffer(unsigned num_digits, + const Spec &spec, const char *prefix, unsigned prefix_size); + + // Formats an integer. + template + void write_int(T value, Spec spec); + + // Formats a floating-point number (double or long double). + template + void write_double(T value, const Spec &spec); + + // Writes a formatted string. + template + CharPtr write_str(const StrChar *s, std::size_t size, const AlignSpec &spec); + + template + void write_str(const internal::Arg::StringValue &str, + const Spec &spec); + + // This following methods are private to disallow writing wide characters + // and strings to a char stream. If you want to print a wide string as a + // pointer as std::ostream does, cast it to const void*. + // Do not implement! + void operator<<(typename internal::WCharHelper::Unsupported); + void operator<<( + typename internal::WCharHelper::Unsupported); + + // Appends floating-point length specifier to the format string. + // The second argument is only used for overload resolution. + void append_float_length(Char *&format_ptr, long double) { + *format_ptr++ = 'L'; + } + + template + void append_float_length(Char *&, T) {} + + template + friend class internal::ArgFormatterBase; + + template + friend class BasicPrintfArgFormatter; + + protected: + /** + Constructs a ``BasicWriter`` object. + */ + explicit BasicWriter(Buffer &b) : buffer_(b) {} + + public: + /** + \rst + Destroys a ``BasicWriter`` object. + \endrst + */ + virtual ~BasicWriter() {} + + /** + Returns the total number of characters written. + */ + std::size_t size() const { return buffer_.size(); } + + /** + Returns a pointer to the output buffer content. No terminating null + character is appended. + */ + const Char *data() const FMT_NOEXCEPT { return &buffer_[0]; } + + /** + Returns a pointer to the output buffer content with terminating null + character appended. + */ + const Char *c_str() const { + std::size_t size = buffer_.size(); + buffer_.reserve(size + 1); + buffer_[size] = '\0'; + return &buffer_[0]; + } + + /** + \rst + Returns the content of the output buffer as an `std::string`. + \endrst + */ + std::basic_string str() const { + return std::basic_string(&buffer_[0], buffer_.size()); + } + + /** + \rst + Writes formatted data. + + *args* is an argument list representing arbitrary arguments. + + **Example**:: + + MemoryWriter out; + out.write("Current point:\n"); + out.write("({:+f}, {:+f})", -3.14, 3.14); + + This will write the following output to the ``out`` object: + + .. code-block:: none + + Current point: + (-3.140000, +3.140000) + + The output can be accessed using :func:`data()`, :func:`c_str` or + :func:`str` methods. + + See also :ref:`syntax`. + \endrst + */ + void write(BasicCStringRef format, ArgList args) { + BasicFormatter(args, *this).format(format); + } + FMT_VARIADIC_VOID(write, BasicCStringRef) + + BasicWriter &operator<<(int value) { + write_decimal(value); + return *this; + } + BasicWriter &operator<<(unsigned value) { + return *this << IntFormatSpec(value); + } + BasicWriter &operator<<(long value) { + write_decimal(value); + return *this; + } + BasicWriter &operator<<(unsigned long value) { + return *this << IntFormatSpec(value); + } + BasicWriter &operator<<(LongLong value) { + write_decimal(value); + return *this; + } + + /** + \rst + Formats *value* and writes it to the stream. + \endrst + */ + BasicWriter &operator<<(ULongLong value) { + return *this << IntFormatSpec(value); + } + + BasicWriter &operator<<(double value) { + write_double(value, FormatSpec()); + return *this; + } + + /** + \rst + Formats *value* using the general format for floating-point numbers + (``'g'``) and writes it to the stream. + \endrst + */ + BasicWriter &operator<<(long double value) { + write_double(value, FormatSpec()); + return *this; + } + + /** + Writes a character to the stream. + */ + BasicWriter &operator<<(char value) { + buffer_.push_back(value); + return *this; + } + + BasicWriter &operator<<( + typename internal::WCharHelper::Supported value) { + buffer_.push_back(value); + return *this; + } + + /** + \rst + Writes *value* to the stream. + \endrst + */ + BasicWriter &operator<<(fmt::BasicStringRef value) { + const Char *str = value.data(); + buffer_.append(str, str + value.size()); + return *this; + } + + BasicWriter &operator<<( + typename internal::WCharHelper::Supported value) { + const char *str = value.data(); + buffer_.append(str, str + value.size()); + return *this; + } + + template + BasicWriter &operator<<(IntFormatSpec spec) { + internal::CharTraits::convert(FillChar()); + write_int(spec.value(), spec); + return *this; + } + + template + BasicWriter &operator<<(const StrFormatSpec &spec) { + const StrChar *s = spec.str(); + write_str(s, std::char_traits::length(s), spec); + return *this; + } + + void clear() FMT_NOEXCEPT { buffer_.clear(); } + + Buffer &buffer() FMT_NOEXCEPT { return buffer_; } +}; + +template +template +typename BasicWriter::CharPtr BasicWriter::write_str( + const StrChar *s, std::size_t size, const AlignSpec &spec) { + CharPtr out = CharPtr(); + if (spec.width() > size) { + out = grow_buffer(spec.width()); + Char fill = internal::CharTraits::cast(spec.fill()); + if (spec.align() == ALIGN_RIGHT) { + std::uninitialized_fill_n(out, spec.width() - size, fill); + out += spec.width() - size; + } else if (spec.align() == ALIGN_CENTER) { + out = fill_padding(out, spec.width(), size, fill); + } else { + std::uninitialized_fill_n(out + size, spec.width() - size, fill); + } + } else { + out = grow_buffer(size); + } + std::uninitialized_copy(s, s + size, out); + return out; +} + +template +template +void BasicWriter::write_str( + const internal::Arg::StringValue &s, const Spec &spec) { + // Check if StrChar is convertible to Char. + internal::CharTraits::convert(StrChar()); + if (spec.type_ && spec.type_ != 's') + internal::report_unknown_type(spec.type_, "string"); + const StrChar *str_value = s.value; + std::size_t str_size = s.size; + if (str_size == 0) { + if (!str_value) { + FMT_THROW(FormatError("string pointer is null")); + } + } + std::size_t precision = static_cast(spec.precision_); + if (spec.precision_ >= 0 && precision < str_size) + str_size = precision; + write_str(str_value, str_size, spec); +} + +template +typename BasicWriter::CharPtr + BasicWriter::fill_padding( + CharPtr buffer, unsigned total_size, + std::size_t content_size, wchar_t fill) { + std::size_t padding = total_size - content_size; + std::size_t left_padding = padding / 2; + Char fill_char = internal::CharTraits::cast(fill); + std::uninitialized_fill_n(buffer, left_padding, fill_char); + buffer += left_padding; + CharPtr content = buffer; + std::uninitialized_fill_n(buffer + content_size, + padding - left_padding, fill_char); + return content; +} + +template +template +typename BasicWriter::CharPtr + BasicWriter::prepare_int_buffer( + unsigned num_digits, const Spec &spec, + const char *prefix, unsigned prefix_size) { + unsigned width = spec.width(); + Alignment align = spec.align(); + Char fill = internal::CharTraits::cast(spec.fill()); + if (spec.precision() > static_cast(num_digits)) { + // Octal prefix '0' is counted as a digit, so ignore it if precision + // is specified. + if (prefix_size > 0 && prefix[prefix_size - 1] == '0') + --prefix_size; + unsigned number_size = + prefix_size + internal::to_unsigned(spec.precision()); + AlignSpec subspec(number_size, '0', ALIGN_NUMERIC); + if (number_size >= width) + return prepare_int_buffer(num_digits, subspec, prefix, prefix_size); + buffer_.reserve(width); + unsigned fill_size = width - number_size; + if (align != ALIGN_LEFT) { + CharPtr p = grow_buffer(fill_size); + std::uninitialized_fill(p, p + fill_size, fill); + } + CharPtr result = prepare_int_buffer( + num_digits, subspec, prefix, prefix_size); + if (align == ALIGN_LEFT) { + CharPtr p = grow_buffer(fill_size); + std::uninitialized_fill(p, p + fill_size, fill); + } + return result; + } + unsigned size = prefix_size + num_digits; + if (width <= size) { + CharPtr p = grow_buffer(size); + std::uninitialized_copy(prefix, prefix + prefix_size, p); + return p + size - 1; + } + CharPtr p = grow_buffer(width); + CharPtr end = p + width; + if (align == ALIGN_LEFT) { + std::uninitialized_copy(prefix, prefix + prefix_size, p); + p += size; + std::uninitialized_fill(p, end, fill); + } else if (align == ALIGN_CENTER) { + p = fill_padding(p, width, size, fill); + std::uninitialized_copy(prefix, prefix + prefix_size, p); + p += size; + } else { + if (align == ALIGN_NUMERIC) { + if (prefix_size != 0) { + p = std::uninitialized_copy(prefix, prefix + prefix_size, p); + size -= prefix_size; + } + } else { + std::uninitialized_copy(prefix, prefix + prefix_size, end - size); + } + std::uninitialized_fill(p, end - size, fill); + p = end; + } + return p - 1; +} + +template +template +void BasicWriter::write_int(T value, Spec spec) { + unsigned prefix_size = 0; + typedef typename internal::IntTraits::MainType UnsignedType; + UnsignedType abs_value = static_cast(value); + char prefix[4] = ""; + if (internal::is_negative(value)) { + prefix[0] = '-'; + ++prefix_size; + abs_value = 0 - abs_value; + } else if (spec.flag(SIGN_FLAG)) { + prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' '; + ++prefix_size; + } + switch (spec.type()) { + case 0: case 'd': { + unsigned num_digits = internal::count_digits(abs_value); + CharPtr p = prepare_int_buffer(num_digits, spec, prefix, prefix_size) + 1; + internal::format_decimal(get(p), abs_value, 0); + break; + } + case 'x': case 'X': { + UnsignedType n = abs_value; + if (spec.flag(HASH_FLAG)) { + prefix[prefix_size++] = '0'; + prefix[prefix_size++] = spec.type_prefix(); + } + unsigned num_digits = 0; + do { + ++num_digits; + } while ((n >>= 4) != 0); + Char *p = get(prepare_int_buffer( + num_digits, spec, prefix, prefix_size)); + n = abs_value; + const char *digits = spec.type() == 'x' ? + "0123456789abcdef" : "0123456789ABCDEF"; + do { + *p-- = digits[n & 0xf]; + } while ((n >>= 4) != 0); + break; + } + case 'b': case 'B': { + UnsignedType n = abs_value; + if (spec.flag(HASH_FLAG)) { + prefix[prefix_size++] = '0'; + prefix[prefix_size++] = spec.type_prefix(); + } + unsigned num_digits = 0; + do { + ++num_digits; + } while ((n >>= 1) != 0); + Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size)); + n = abs_value; + do { + *p-- = static_cast('0' + (n & 1)); + } while ((n >>= 1) != 0); + break; + } + case 'o': { + UnsignedType n = abs_value; + if (spec.flag(HASH_FLAG)) + prefix[prefix_size++] = '0'; + unsigned num_digits = 0; + do { + ++num_digits; + } while ((n >>= 3) != 0); + Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size)); + n = abs_value; + do { + *p-- = static_cast('0' + (n & 7)); + } while ((n >>= 3) != 0); + break; + } + case 'n': { + unsigned num_digits = internal::count_digits(abs_value); + fmt::StringRef sep = ""; +#if !(defined(ANDROID) || defined(__ANDROID__)) + sep = internal::thousands_sep(std::localeconv()); +#endif + unsigned size = static_cast( + num_digits + sep.size() * ((num_digits - 1) / 3)); + CharPtr p = prepare_int_buffer(size, spec, prefix, prefix_size) + 1; + internal::format_decimal(get(p), abs_value, 0, internal::ThousandsSep(sep)); + break; + } + default: + internal::report_unknown_type( + spec.type(), spec.flag(CHAR_FLAG) ? "char" : "integer"); + break; + } +} + +template +template +void BasicWriter::write_double(T value, const Spec &spec) { + // Check type. + char type = spec.type(); + bool upper = false; + switch (type) { + case 0: + type = 'g'; + break; + case 'e': case 'f': case 'g': case 'a': + break; + case 'F': +#if FMT_MSC_VER + // MSVC's printf doesn't support 'F'. + type = 'f'; +#endif + // Fall through. + case 'E': case 'G': case 'A': + upper = true; + break; + default: + internal::report_unknown_type(type, "double"); + break; + } + + char sign = 0; + // Use isnegative instead of value < 0 because the latter is always + // false for NaN. + if (internal::FPUtil::isnegative(static_cast(value))) { + sign = '-'; + value = -value; + } else if (spec.flag(SIGN_FLAG)) { + sign = spec.flag(PLUS_FLAG) ? '+' : ' '; + } + + if (internal::FPUtil::isnotanumber(value)) { + // Format NaN ourselves because sprintf's output is not consistent + // across platforms. + std::size_t nan_size = 4; + const char *nan = upper ? " NAN" : " nan"; + if (!sign) { + --nan_size; + ++nan; + } + CharPtr out = write_str(nan, nan_size, spec); + if (sign) + *out = sign; + return; + } + + if (internal::FPUtil::isinfinity(value)) { + // Format infinity ourselves because sprintf's output is not consistent + // across platforms. + std::size_t inf_size = 4; + const char *inf = upper ? " INF" : " inf"; + if (!sign) { + --inf_size; + ++inf; + } + CharPtr out = write_str(inf, inf_size, spec); + if (sign) + *out = sign; + return; + } + + std::size_t offset = buffer_.size(); + unsigned width = spec.width(); + if (sign) { + buffer_.reserve(buffer_.size() + (width > 1u ? width : 1u)); + if (width > 0) + --width; + ++offset; + } + + // Build format string. + enum { MAX_FORMAT_SIZE = 10}; // longest format: %#-*.*Lg + Char format[MAX_FORMAT_SIZE]; + Char *format_ptr = format; + *format_ptr++ = '%'; + unsigned width_for_sprintf = width; + if (spec.flag(HASH_FLAG)) + *format_ptr++ = '#'; + if (spec.align() == ALIGN_CENTER) { + width_for_sprintf = 0; + } else { + if (spec.align() == ALIGN_LEFT) + *format_ptr++ = '-'; + if (width != 0) + *format_ptr++ = '*'; + } + if (spec.precision() >= 0) { + *format_ptr++ = '.'; + *format_ptr++ = '*'; + } + + append_float_length(format_ptr, value); + *format_ptr++ = type; + *format_ptr = '\0'; + + // Format using snprintf. + Char fill = internal::CharTraits::cast(spec.fill()); + unsigned n = 0; + Char *start = FMT_NULL; + for (;;) { + std::size_t buffer_size = buffer_.capacity() - offset; +#if FMT_MSC_VER + // MSVC's vsnprintf_s doesn't work with zero size, so reserve + // space for at least one extra character to make the size non-zero. + // Note that the buffer's capacity will increase by more than 1. + if (buffer_size == 0) { + buffer_.reserve(offset + 1); + buffer_size = buffer_.capacity() - offset; + } +#endif + start = &buffer_[offset]; + int result = internal::CharTraits::format_float( + start, buffer_size, format, width_for_sprintf, spec.precision(), value); + if (result >= 0) { + n = internal::to_unsigned(result); + if (offset + n < buffer_.capacity()) + break; // The buffer is large enough - continue with formatting. + buffer_.reserve(offset + n + 1); + } else { + // If result is negative we ask to increase the capacity by at least 1, + // but as std::vector, the buffer grows exponentially. + buffer_.reserve(buffer_.capacity() + 1); + } + } + if (sign) { + if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) || + *start != ' ') { + *(start - 1) = sign; + sign = 0; + } else { + *(start - 1) = fill; + } + ++n; + } + if (spec.align() == ALIGN_CENTER && spec.width() > n) { + width = spec.width(); + CharPtr p = grow_buffer(width); + std::memmove(get(p) + (width - n) / 2, get(p), n * sizeof(Char)); + fill_padding(p, spec.width(), n, fill); + return; + } + if (spec.fill() != ' ' || sign) { + while (*start == ' ') + *start++ = fill; + if (sign) + *(start - 1) = sign; + } + grow_buffer(n); +} + +/** + \rst + This class template provides operations for formatting and writing data + into a character stream. The output is stored in a memory buffer that grows + dynamically. + + You can use one of the following typedefs for common character types + and the standard allocator: + + +---------------+-----------------------------------------------------+ + | Type | Definition | + +===============+=====================================================+ + | MemoryWriter | BasicMemoryWriter> | + +---------------+-----------------------------------------------------+ + | WMemoryWriter | BasicMemoryWriter> | + +---------------+-----------------------------------------------------+ + + **Example**:: + + MemoryWriter out; + out << "The answer is " << 42 << "\n"; + out.write("({:+f}, {:+f})", -3.14, 3.14); + + This will write the following output to the ``out`` object: + + .. code-block:: none + + The answer is 42 + (-3.140000, +3.140000) + + The output can be converted to an ``std::string`` with ``out.str()`` or + accessed as a C string with ``out.c_str()``. + \endrst + */ +template > +class BasicMemoryWriter : public BasicWriter { + private: + internal::MemoryBuffer buffer_; + + public: + explicit BasicMemoryWriter(const Allocator& alloc = Allocator()) + : BasicWriter(buffer_), buffer_(alloc) {} + +#if FMT_USE_RVALUE_REFERENCES + /** + \rst + Constructs a :class:`fmt::BasicMemoryWriter` object moving the content + of the other object to it. + \endrst + */ + BasicMemoryWriter(BasicMemoryWriter &&other) + : BasicWriter(buffer_), buffer_(std::move(other.buffer_)) { + } + + /** + \rst + Moves the content of the other ``BasicMemoryWriter`` object to this one. + \endrst + */ + BasicMemoryWriter &operator=(BasicMemoryWriter &&other) { + buffer_ = std::move(other.buffer_); + return *this; + } +#endif +}; + +typedef BasicMemoryWriter MemoryWriter; +typedef BasicMemoryWriter WMemoryWriter; + +/** + \rst + This class template provides operations for formatting and writing data + into a fixed-size array. For writing into a dynamically growing buffer + use :class:`fmt::BasicMemoryWriter`. + + Any write method will throw ``std::runtime_error`` if the output doesn't fit + into the array. + + You can use one of the following typedefs for common character types: + + +--------------+---------------------------+ + | Type | Definition | + +==============+===========================+ + | ArrayWriter | BasicArrayWriter | + +--------------+---------------------------+ + | WArrayWriter | BasicArrayWriter | + +--------------+---------------------------+ + \endrst + */ +template +class BasicArrayWriter : public BasicWriter { + private: + internal::FixedBuffer buffer_; + + public: + /** + \rst + Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the + given size. + \endrst + */ + BasicArrayWriter(Char *array, std::size_t size) + : BasicWriter(buffer_), buffer_(array, size) {} + + /** + \rst + Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the + size known at compile time. + \endrst + */ + template + explicit BasicArrayWriter(Char (&array)[SIZE]) + : BasicWriter(buffer_), buffer_(array, SIZE) {} +}; + +typedef BasicArrayWriter ArrayWriter; +typedef BasicArrayWriter WArrayWriter; + +// Reports a system error without throwing an exception. +// Can be used to report errors from destructors. +FMT_API void report_system_error(int error_code, + StringRef message) FMT_NOEXCEPT; + +#if FMT_USE_WINDOWS_H + +/** A Windows error. */ +class WindowsError : public SystemError { + private: + FMT_API void init(int error_code, CStringRef format_str, ArgList args); + + public: + /** + \rst + Constructs a :class:`fmt::WindowsError` object with the description + of the form + + .. parsed-literal:: + **: ** + + where ** is the formatted message and ** is the + system message corresponding to the error code. + *error_code* is a Windows error code as given by ``GetLastError``. + If *error_code* is not a valid error code such as -1, the system message + will look like "error -1". + + **Example**:: + + // This throws a WindowsError with the description + // cannot open file 'madeup': The system cannot find the file specified. + // or similar (system message may vary). + const char *filename = "madeup"; + LPOFSTRUCT of = LPOFSTRUCT(); + HFILE file = OpenFile(filename, &of, OF_READ); + if (file == HFILE_ERROR) { + throw fmt::WindowsError(GetLastError(), + "cannot open file '{}'", filename); + } + \endrst + */ + WindowsError(int error_code, CStringRef message) { + init(error_code, message, ArgList()); + } + FMT_VARIADIC_CTOR(WindowsError, init, int, CStringRef) +}; + +// Reports a Windows error without throwing an exception. +// Can be used to report errors from destructors. +FMT_API void report_windows_error(int error_code, + StringRef message) FMT_NOEXCEPT; + +#endif + +enum Color { BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE }; + +/** + Formats a string and prints it to stdout using ANSI escape sequences + to specify color (experimental). + Example: + print_colored(fmt::RED, "Elapsed time: {0:.2f} seconds", 1.23); + */ +FMT_API void print_colored(Color c, CStringRef format, ArgList args); + +/** + \rst + Formats arguments and returns the result as a string. + + **Example**:: + + std::string message = format("The answer is {}", 42); + \endrst +*/ +inline std::string format(CStringRef format_str, ArgList args) { + MemoryWriter w; + w.write(format_str, args); + return w.str(); +} + +inline std::wstring format(WCStringRef format_str, ArgList args) { + WMemoryWriter w; + w.write(format_str, args); + return w.str(); +} + +/** + \rst + Prints formatted data to the file *f*. + + **Example**:: + + print(stderr, "Don't {}!", "panic"); + \endrst + */ +FMT_API void print(std::FILE *f, CStringRef format_str, ArgList args); + +/** + \rst + Prints formatted data to ``stdout``. + + **Example**:: + + print("Elapsed time: {0:.2f} seconds", 1.23); + \endrst + */ +FMT_API void print(CStringRef format_str, ArgList args); + +/** + Fast integer formatter. + */ +class FormatInt { + private: + // Buffer should be large enough to hold all digits (digits10 + 1), + // a sign and a null character. + enum {BUFFER_SIZE = std::numeric_limits::digits10 + 3}; + mutable char buffer_[BUFFER_SIZE]; + char *str_; + + // Formats value in reverse and returns the number of digits. + char *format_decimal(ULongLong value) { + char *buffer_end = buffer_ + BUFFER_SIZE - 1; + while (value >= 100) { + // Integer division is slow so do it for a group of two digits instead + // of for every digit. The idea comes from the talk by Alexandrescu + // "Three Optimization Tips for C++". See speed-test for a comparison. + unsigned index = static_cast((value % 100) * 2); + value /= 100; + *--buffer_end = internal::Data::DIGITS[index + 1]; + *--buffer_end = internal::Data::DIGITS[index]; + } + if (value < 10) { + *--buffer_end = static_cast('0' + value); + return buffer_end; + } + unsigned index = static_cast(value * 2); + *--buffer_end = internal::Data::DIGITS[index + 1]; + *--buffer_end = internal::Data::DIGITS[index]; + return buffer_end; + } + + void FormatSigned(LongLong value) { + ULongLong abs_value = static_cast(value); + bool negative = value < 0; + if (negative) + abs_value = 0 - abs_value; + str_ = format_decimal(abs_value); + if (negative) + *--str_ = '-'; + } + + public: + explicit FormatInt(int value) { FormatSigned(value); } + explicit FormatInt(long value) { FormatSigned(value); } + explicit FormatInt(LongLong value) { FormatSigned(value); } + explicit FormatInt(unsigned value) : str_(format_decimal(value)) {} + explicit FormatInt(unsigned long value) : str_(format_decimal(value)) {} + explicit FormatInt(ULongLong value) : str_(format_decimal(value)) {} + + /** Returns the number of characters written to the output buffer. */ + std::size_t size() const { + return internal::to_unsigned(buffer_ - str_ + BUFFER_SIZE - 1); + } + + /** + Returns a pointer to the output buffer content. No terminating null + character is appended. + */ + const char *data() const { return str_; } + + /** + Returns a pointer to the output buffer content with terminating null + character appended. + */ + const char *c_str() const { + buffer_[BUFFER_SIZE - 1] = '\0'; + return str_; + } + + /** + \rst + Returns the content of the output buffer as an ``std::string``. + \endrst + */ + std::string str() const { return std::string(str_, size()); } +}; + +// Formats a decimal integer value writing into buffer and returns +// a pointer to the end of the formatted string. This function doesn't +// write a terminating null character. +template +inline void format_decimal(char *&buffer, T value) { + typedef typename internal::IntTraits::MainType MainType; + MainType abs_value = static_cast(value); + if (internal::is_negative(value)) { + *buffer++ = '-'; + abs_value = 0 - abs_value; + } + if (abs_value < 100) { + if (abs_value < 10) { + *buffer++ = static_cast('0' + abs_value); + return; + } + unsigned index = static_cast(abs_value * 2); + *buffer++ = internal::Data::DIGITS[index]; + *buffer++ = internal::Data::DIGITS[index + 1]; + return; + } + unsigned num_digits = internal::count_digits(abs_value); + internal::format_decimal(buffer, abs_value, num_digits); + buffer += num_digits; +} + +/** + \rst + Returns a named argument for formatting functions. + + **Example**:: + + print("Elapsed time: {s:.2f} seconds", arg("s", 1.23)); + + \endrst + */ +template +inline internal::NamedArgWithType arg(StringRef name, const T &arg) { + return internal::NamedArgWithType(name, arg); +} + +template +inline internal::NamedArgWithType arg(WStringRef name, const T &arg) { + return internal::NamedArgWithType(name, arg); +} + +// The following two functions are deleted intentionally to disable +// nested named arguments as in ``format("{}", arg("a", arg("b", 42)))``. +template +void arg(StringRef, const internal::NamedArg&) FMT_DELETED_OR_UNDEFINED; +template +void arg(WStringRef, const internal::NamedArg&) FMT_DELETED_OR_UNDEFINED; +} + +#if FMT_GCC_VERSION +// Use the system_header pragma to suppress warnings about variadic macros +// because suppressing -Wvariadic-macros with the diagnostic pragma doesn't +// work. It is used at the end because we want to suppress as little warnings +// as possible. +# pragma GCC system_header +#endif + +// This is used to work around VC++ bugs in handling variadic macros. +#define FMT_EXPAND(args) args + +// Returns the number of arguments. +// Based on https://groups.google.com/forum/#!topic/comp.std.c/d-6Mj5Lko_s. +#define FMT_NARG(...) FMT_NARG_(__VA_ARGS__, FMT_RSEQ_N()) +#define FMT_NARG_(...) FMT_EXPAND(FMT_ARG_N(__VA_ARGS__)) +#define FMT_ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N +#define FMT_RSEQ_N() 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 + +#define FMT_FOR_EACH_(N, f, ...) \ + FMT_EXPAND(FMT_CONCAT(FMT_FOR_EACH, N)(f, __VA_ARGS__)) +#define FMT_FOR_EACH(f, ...) \ + FMT_EXPAND(FMT_FOR_EACH_(FMT_NARG(__VA_ARGS__), f, __VA_ARGS__)) + +#define FMT_ADD_ARG_NAME(type, index) type arg##index +#define FMT_GET_ARG_NAME(type, index) arg##index + +#if FMT_USE_VARIADIC_TEMPLATES +# define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \ + template \ + ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \ + const Args & ... args) { \ + typedef fmt::internal::ArgArray ArgArray; \ + typename ArgArray::Type array{ \ + ArgArray::template make >(args)...}; \ + call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), \ + fmt::ArgList(fmt::internal::make_type(args...), array)); \ + } +#else +// Defines a wrapper for a function taking __VA_ARGS__ arguments +// and n additional arguments of arbitrary types. +# define FMT_WRAP(Char, ReturnType, func, call, n, ...) \ + template \ + inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \ + FMT_GEN(n, FMT_MAKE_ARG)) { \ + fmt::internal::ArgArray::Type arr; \ + FMT_GEN(n, FMT_ASSIGN_##Char); \ + call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList( \ + fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), arr)); \ + } + +# define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \ + inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__)) { \ + call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList()); \ + } \ + FMT_WRAP(Char, ReturnType, func, call, 1, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 2, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 3, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 4, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 5, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 6, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 7, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 8, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 9, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 10, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 11, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 12, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 13, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 14, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 15, __VA_ARGS__) +#endif // FMT_USE_VARIADIC_TEMPLATES + +/** + \rst + Defines a variadic function with the specified return type, function name + and argument types passed as variable arguments to this macro. + + **Example**:: + + void print_error(const char *file, int line, const char *format, + fmt::ArgList args) { + fmt::print("{}: {}: ", file, line); + fmt::print(format, args); + } + FMT_VARIADIC(void, print_error, const char *, int, const char *) + + ``FMT_VARIADIC`` is used for compatibility with legacy C++ compilers that + don't implement variadic templates. You don't have to use this macro if + you don't need legacy compiler support and can use variadic templates + directly:: + + template + void print_error(const char *file, int line, const char *format, + const Args & ... args) { + fmt::print("{}: {}: ", file, line); + fmt::print(format, args...); + } + \endrst + */ +#define FMT_VARIADIC(ReturnType, func, ...) \ + FMT_VARIADIC_(char, ReturnType, func, return func, __VA_ARGS__) + +#define FMT_VARIADIC_W(ReturnType, func, ...) \ + FMT_VARIADIC_(wchar_t, ReturnType, func, return func, __VA_ARGS__) + +#define FMT_CAPTURE_ARG_(id, index) ::fmt::arg(#id, id) + +#define FMT_CAPTURE_ARG_W_(id, index) ::fmt::arg(L###id, id) + +/** + \rst + Convenient macro to capture the arguments' names and values into several + ``fmt::arg(name, value)``. + + **Example**:: + + int x = 1, y = 2; + print("point: ({x}, {y})", FMT_CAPTURE(x, y)); + // same as: + // print("point: ({x}, {y})", arg("x", x), arg("y", y)); + + \endrst + */ +#define FMT_CAPTURE(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_, __VA_ARGS__) + +#define FMT_CAPTURE_W(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_W_, __VA_ARGS__) + +namespace fmt { +FMT_VARIADIC(std::string, format, CStringRef) +FMT_VARIADIC_W(std::wstring, format, WCStringRef) +FMT_VARIADIC(void, print, CStringRef) +FMT_VARIADIC(void, print, std::FILE *, CStringRef) +FMT_VARIADIC(void, print_colored, Color, CStringRef) + +namespace internal { +template +inline bool is_name_start(Char c) { + return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c; +} + +// Parses an unsigned integer advancing s to the end of the parsed input. +// This function assumes that the first character of s is a digit. +template +unsigned parse_nonnegative_int(const Char *&s) { + assert('0' <= *s && *s <= '9'); + unsigned value = 0; + do { + unsigned new_value = value * 10 + (*s++ - '0'); + // Check if value wrapped around. + if (new_value < value) { + value = (std::numeric_limits::max)(); + break; + } + value = new_value; + } while ('0' <= *s && *s <= '9'); + // Convert to unsigned to prevent a warning. + unsigned max_int = (std::numeric_limits::max)(); + if (value > max_int) + FMT_THROW(FormatError("number is too big")); + return value; +} + +inline void require_numeric_argument(const Arg &arg, char spec) { + if (arg.type > Arg::LAST_NUMERIC_TYPE) { + std::string message = + fmt::format("format specifier '{}' requires numeric argument", spec); + FMT_THROW(fmt::FormatError(message)); + } +} + +template +void check_sign(const Char *&s, const Arg &arg) { + char sign = static_cast(*s); + require_numeric_argument(arg, sign); + if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG) { + FMT_THROW(FormatError(fmt::format( + "format specifier '{}' requires signed argument", sign))); + } + ++s; +} +} // namespace internal + +template +inline internal::Arg BasicFormatter::get_arg( + BasicStringRef arg_name, const char *&error) { + if (check_no_auto_index(error)) { + map_.init(args()); + const internal::Arg *arg = map_.find(arg_name); + if (arg) + return *arg; + error = "argument not found"; + } + return internal::Arg(); +} + +template +inline internal::Arg BasicFormatter::parse_arg_index(const Char *&s) { + const char *error = FMT_NULL; + internal::Arg arg = *s < '0' || *s > '9' ? + next_arg(error) : get_arg(internal::parse_nonnegative_int(s), error); + if (error) { + FMT_THROW(FormatError( + *s != '}' && *s != ':' ? "invalid format string" : error)); + } + return arg; +} + +template +inline internal::Arg BasicFormatter::parse_arg_name(const Char *&s) { + assert(internal::is_name_start(*s)); + const Char *start = s; + Char c; + do { + c = *++s; + } while (internal::is_name_start(c) || ('0' <= c && c <= '9')); + const char *error = FMT_NULL; + internal::Arg arg = get_arg(BasicStringRef(start, s - start), error); + if (error) + FMT_THROW(FormatError(error)); + return arg; +} + +template +const Char *BasicFormatter::format( + const Char *&format_str, const internal::Arg &arg) { + using internal::Arg; + const Char *s = format_str; + typename ArgFormatter::SpecType spec; + if (*s == ':') { + if (arg.type == Arg::CUSTOM) { + arg.custom.format(this, arg.custom.value, &s); + return s; + } + ++s; + // Parse fill and alignment. + if (Char c = *s) { + const Char *p = s + 1; + spec.align_ = ALIGN_DEFAULT; + do { + switch (*p) { + case '<': + spec.align_ = ALIGN_LEFT; + break; + case '>': + spec.align_ = ALIGN_RIGHT; + break; + case '=': + spec.align_ = ALIGN_NUMERIC; + break; + case '^': + spec.align_ = ALIGN_CENTER; + break; + } + if (spec.align_ != ALIGN_DEFAULT) { + if (p != s) { + if (c == '}') break; + if (c == '{') + FMT_THROW(FormatError("invalid fill character '{'")); + s += 2; + spec.fill_ = c; + } else ++s; + if (spec.align_ == ALIGN_NUMERIC) + require_numeric_argument(arg, '='); + break; + } + } while (--p >= s); + } + + // Parse sign. + switch (*s) { + case '+': + check_sign(s, arg); + spec.flags_ |= SIGN_FLAG | PLUS_FLAG; + break; + case '-': + check_sign(s, arg); + spec.flags_ |= MINUS_FLAG; + break; + case ' ': + check_sign(s, arg); + spec.flags_ |= SIGN_FLAG; + break; + } + + if (*s == '#') { + require_numeric_argument(arg, '#'); + spec.flags_ |= HASH_FLAG; + ++s; + } + + // Parse zero flag. + if (*s == '0') { + require_numeric_argument(arg, '0'); + spec.align_ = ALIGN_NUMERIC; + spec.fill_ = '0'; + ++s; + } + + // Parse width. + if ('0' <= *s && *s <= '9') { + spec.width_ = internal::parse_nonnegative_int(s); + } else if (*s == '{') { + ++s; + Arg width_arg = internal::is_name_start(*s) ? + parse_arg_name(s) : parse_arg_index(s); + if (*s++ != '}') + FMT_THROW(FormatError("invalid format string")); + ULongLong value = 0; + switch (width_arg.type) { + case Arg::INT: + if (width_arg.int_value < 0) + FMT_THROW(FormatError("negative width")); + value = width_arg.int_value; + break; + case Arg::UINT: + value = width_arg.uint_value; + break; + case Arg::LONG_LONG: + if (width_arg.long_long_value < 0) + FMT_THROW(FormatError("negative width")); + value = width_arg.long_long_value; + break; + case Arg::ULONG_LONG: + value = width_arg.ulong_long_value; + break; + default: + FMT_THROW(FormatError("width is not integer")); + } + if (value > (std::numeric_limits::max)()) + FMT_THROW(FormatError("number is too big")); + spec.width_ = static_cast(value); + } + + // Parse precision. + if (*s == '.') { + ++s; + spec.precision_ = 0; + if ('0' <= *s && *s <= '9') { + spec.precision_ = internal::parse_nonnegative_int(s); + } else if (*s == '{') { + ++s; + Arg precision_arg = internal::is_name_start(*s) ? + parse_arg_name(s) : parse_arg_index(s); + if (*s++ != '}') + FMT_THROW(FormatError("invalid format string")); + ULongLong value = 0; + switch (precision_arg.type) { + case Arg::INT: + if (precision_arg.int_value < 0) + FMT_THROW(FormatError("negative precision")); + value = precision_arg.int_value; + break; + case Arg::UINT: + value = precision_arg.uint_value; + break; + case Arg::LONG_LONG: + if (precision_arg.long_long_value < 0) + FMT_THROW(FormatError("negative precision")); + value = precision_arg.long_long_value; + break; + case Arg::ULONG_LONG: + value = precision_arg.ulong_long_value; + break; + default: + FMT_THROW(FormatError("precision is not integer")); + } + if (value > (std::numeric_limits::max)()) + FMT_THROW(FormatError("number is too big")); + spec.precision_ = static_cast(value); + } else { + FMT_THROW(FormatError("missing precision specifier")); + } + if (arg.type <= Arg::LAST_INTEGER_TYPE || arg.type == Arg::POINTER) { + FMT_THROW(FormatError( + fmt::format("precision not allowed in {} format specifier", + arg.type == Arg::POINTER ? "pointer" : "integer"))); + } + } + + // Parse type. + if (*s != '}' && *s) + spec.type_ = static_cast(*s++); + } + + if (*s++ != '}') + FMT_THROW(FormatError("missing '}' in format string")); + + // Format argument. + ArgFormatter(*this, spec, s - 1).visit(arg); + return s; +} + +template +void BasicFormatter::format(BasicCStringRef format_str) { + const Char *s = format_str.c_str(); + const Char *start = s; + while (*s) { + Char c = *s++; + if (c != '{' && c != '}') continue; + if (*s == c) { + write(writer_, start, s); + start = ++s; + continue; + } + if (c == '}') + FMT_THROW(FormatError("unmatched '}' in format string")); + write(writer_, start, s - 1); + internal::Arg arg = internal::is_name_start(*s) ? + parse_arg_name(s) : parse_arg_index(s); + start = s = format(s, arg); + } + write(writer_, start, s); +} + +template +struct ArgJoin { + It first; + It last; + BasicCStringRef sep; + + ArgJoin(It first, It last, const BasicCStringRef& sep) : + first(first), + last(last), + sep(sep) {} +}; + +template +ArgJoin join(It first, It last, const BasicCStringRef& sep) { + return ArgJoin(first, last, sep); +} + +template +ArgJoin join(It first, It last, const BasicCStringRef& sep) { + return ArgJoin(first, last, sep); +} + +#if FMT_HAS_GXX_CXX11 +template +auto join(const Range& range, const BasicCStringRef& sep) + -> ArgJoin { + return join(std::begin(range), std::end(range), sep); +} + +template +auto join(const Range& range, const BasicCStringRef& sep) + -> ArgJoin { + return join(std::begin(range), std::end(range), sep); +} +#endif + +template +void format_arg(fmt::BasicFormatter &f, + const Char *&format_str, const ArgJoin& e) { + const Char* end = format_str; + if (*end == ':') + ++end; + while (*end && *end != '}') + ++end; + if (*end != '}') + FMT_THROW(FormatError("missing '}' in format string")); + + It it = e.first; + if (it != e.last) { + const Char* save = format_str; + f.format(format_str, internal::MakeArg >(*it++)); + while (it != e.last) { + f.writer().write(e.sep); + format_str = save; + f.format(format_str, internal::MakeArg >(*it++)); + } + } + format_str = end + 1; +} +} // namespace fmt + +#if FMT_USE_USER_DEFINED_LITERALS +namespace fmt { +namespace internal { + +template +struct UdlFormat { + const Char *str; + + template + auto operator()(Args && ... args) const + -> decltype(format(str, std::forward(args)...)) { + return format(str, std::forward(args)...); + } +}; + +template +struct UdlArg { + const Char *str; + + template + NamedArgWithType operator=(T &&value) const { + return {str, std::forward(value)}; + } +}; + +} // namespace internal + +inline namespace literals { + +/** + \rst + C++11 literal equivalent of :func:`fmt::format`. + + **Example**:: + + using namespace fmt::literals; + std::string message = "The answer is {}"_format(42); + \endrst + */ +inline internal::UdlFormat +operator"" _format(const char *s, std::size_t) { return {s}; } +inline internal::UdlFormat +operator"" _format(const wchar_t *s, std::size_t) { return {s}; } + +/** + \rst + C++11 literal equivalent of :func:`fmt::arg`. + + **Example**:: + + using namespace fmt::literals; + print("Elapsed time: {s:.2f} seconds", "s"_a=1.23); + \endrst + */ +inline internal::UdlArg +operator"" _a(const char *s, std::size_t) { return {s}; } +inline internal::UdlArg +operator"" _a(const wchar_t *s, std::size_t) { return {s}; } + +} // inline namespace literals +} // namespace fmt +#endif // FMT_USE_USER_DEFINED_LITERALS + +// Restore warnings. +#if FMT_GCC_VERSION >= 406 +# pragma GCC diagnostic pop +#endif + +#if defined(__clang__) && !defined(FMT_ICC_VERSION) +# pragma clang diagnostic pop +#endif + +#ifdef FMT_HEADER_ONLY +# define FMT_FUNC inline +# include "format.cc" +#else +# define FMT_FUNC +#endif + +#endif // FMT_FORMAT_H_ diff --git a/src/Field.cpp b/src/Field.cpp index cc2f358..ce321f5 100644 --- a/src/Field.cpp +++ b/src/Field.cpp @@ -1,4 +1,5 @@ #include "Field.h" +#include "format.h" using std::logic_error; using std::out_of_range; @@ -15,7 +16,7 @@ Field::~Field() Hex &Field::put_hex(Coord xy) { if (has_hex(xy)) { - throw logic_error("cannot put hex at " + xy.str() + " : spot is occupied"); + throw logic_error(fmt::format("cannot put hex at {} : spot is occupied", xy.str())); } Hex *p = new Hex(); _hex_map.insert( {xy, p} ); @@ -26,7 +27,7 @@ void Field::remove_hex(Coord xy) { auto hex_it = _hex_map.find(xy); if (hex_it == _hex_map.end()) { - throw logic_error("cannot remove hex from " + xy.str() + " : there is no hex"); + throw logic_error(fmt::format("cannot remove hex from {}: there is no hex", xy.str())); } delete hex_it->second; _hex_map.erase(hex_it); @@ -35,7 +36,7 @@ void Field::remove_hex(Coord xy) Hex &Field::hex(Coord xy) const { if (!has_hex(xy)) { - throw logic_error("cannot return hex at " + xy.str() + " : there is no hex"); + throw logic_error(fmt::format("cannot return hex at {}: there is no hex", xy.str())); } return *_hex_map.find(xy)->second; } @@ -66,12 +67,10 @@ void Field::link_road(Road &r, Coord xy, RoadSide rdsd) { if (linked(r)) { auto road_coord = coord(r); - throw logic_error("cannot link road " + r.name() + " : road is already linked to " + - road_coord.first.str() + " " + EnumInfo::road_side_str(road_coord.second)); + throw logic_error(fmt::format("cannot link road {0} : road is already linked to {1} {2}", r.name(), road_coord.first.str(), EnumInfo::road_side_str(road_coord.second))); } if (has_road(xy, rdsd)) { - throw logic_error("cannot link road " + r.name() + " to " + xy.str() + " " + EnumInfo::road_side_str(rdsd) + - " : spot is occupied"); + throw logic_error(fmt::format("cannot link road {0} to {1} {2}: spot is occupied", r.name(), xy.str(), EnumInfo::road_side_str(rdsd))); } _road_map.insert( {{xy, rdsd}, &r} ); } @@ -79,8 +78,7 @@ void Field::link_road(Road &r, Coord xy, RoadSide rdsd) void Field::unlink_road(Coord xy, RoadSide rdsd) { if (!has_road(xy, rdsd)) { - throw logic_error("cannot unlink road from " + xy.str() + " " + EnumInfo::road_side_str(rdsd) + - " : there is no road"); + throw logic_error(fmt::format("cannot unlink road from {0} {1} : there is no road", xy.str(), EnumInfo::road_side_str(rdsd))); } _road_map.erase( {xy, rdsd} ); } @@ -93,14 +91,13 @@ void Field::unlink_road(Road &r) return; } } - throw logic_error("cannot unlink road " + r.name() + " : no such road on the map"); + throw logic_error(fmt::format("cannot unlink road {} : no such road on the map", r.name())); } Road &Field::road(Coord xy, RoadSide rdsd) const { if (!has_road(xy, rdsd)) { - throw logic_error("cannot return road at " + xy.str() + " " + EnumInfo::road_side_str(rdsd) + - " : there is no road"); + throw logic_error(fmt::format("cannot return road at {0} {1} : there is no road", xy.str(), EnumInfo::road_side_str(rdsd))); } return *_road_map.find( {xy, rdsd} )->second; } @@ -112,19 +109,17 @@ pair Field::coord(Road &r) const return i->first; } } - throw logic_error("cannot find road " + r.name() + " on the map"); + throw logic_error(fmt::format("cannot find road {} on the map", r.name())); } void Field::link_locality(Locality &loc, Coord xy, CrossCorner cr_corn) { if (linked(loc)) { auto loc_coord = coord(loc); - throw logic_error("cannot link locality " + loc.name() + " : locality is already linked to " + - loc_coord.first.str() + " " + EnumInfo::cross_corner_str(loc_coord.second)); + throw logic_error(fmt::format("cannot link locality {0} : locality is already linked to {1} {2}", loc.name(), loc_coord.first.str(), EnumInfo::cross_corner_str(loc_coord.second))); } if (has_locality(xy, cr_corn)) { - throw logic_error("cannot link locality " + loc.name() + " to " + xy.str() + " " + EnumInfo::cross_corner_str(cr_corn) + - " : spot is occupied"); + throw logic_error(fmt::format("cannot link locality {0} to {1} {2} : spot is occupied", loc.name(), xy.str(), EnumInfo::cross_corner_str(cr_corn))); } _locality_map.insert( {{xy, cr_corn}, &loc} ); } @@ -132,8 +127,7 @@ void Field::link_locality(Locality &loc, Coord xy, CrossCorner cr_corn) void Field::unlink_locality(Coord xy, CrossCorner cr_corn) { if (!has_locality(xy, cr_corn)) { - throw logic_error("cannot unlink locality from " + xy.str() + " " + EnumInfo::cross_corner_str(cr_corn) + - " : there is no locality"); + throw logic_error(fmt::format("cannot unlink locality from {0} {1} : there is no locality", xy.str(), EnumInfo::cross_corner_str(cr_corn))); } _locality_map.erase( {xy, cr_corn} ); } @@ -146,14 +140,13 @@ void Field::unlink_locality(Locality &loc) return; } } - throw logic_error("cannot unlink locality " + loc.name() + " : no such locality on the map"); + throw logic_error(fmt::format("cannot unlink locality {} : no such locality on the map", loc.name())); } Locality &Field::locality(Coord xy, CrossCorner cr_corn) const { if (!has_locality(xy, cr_corn)) { - throw logic_error("cannot return locality at " + xy.str() + " " + EnumInfo::cross_corner_str(cr_corn) + - " : there is no locality"); + throw logic_error(fmt::format("cannot return locality at {0} {1} : there is no locality", xy.str(), EnumInfo::cross_corner_str(cr_corn))); } return *_locality_map.find( {xy, cr_corn} )->second; } @@ -165,7 +158,7 @@ pair Field::coord(Locality &loc) const return i->first; } } - throw logic_error("cannot find locality " + loc.name() + " on the map"); + throw logic_error(fmt::format("cannot find locality {} on the map", loc.name())); } bool Field::linked(const Infrastructure &inf) const noexcept diff --git a/src/FirstStageSubEngine.cpp b/src/FirstStageSubEngine.cpp index 83104e8..39d74c8 100644 --- a/src/FirstStageSubEngine.cpp +++ b/src/FirstStageSubEngine.cpp @@ -2,24 +2,22 @@ #include #include #include -#include - -using Logger::log; +#include + +#include "format.h" +#include "format.cc" + using std::invalid_argument; GameStage FirstStageSubEngine::make_dice(size_t dice) { if ((dice < DICE_LOWER_BOUND) || (dice > DICE_HIGHER_BOUND)) { - std::stringstream ss; - ss << "cannot make dice: possible from " << DICE_LOWER_BOUND << " up to " << DICE_HIGHER_BOUND; - ss << " your dice is " << dice; - throw invalid_argument(ss.str()); - } else if (dice == ROBBERS_MOVE) { - log("robbers dice: starting robbing procedure"); + throw invalid_argument(fmt::format("cannot make dice: possible from {0} up to {1}", DICE_LOWER_BOUND, DICE_HIGHER_BOUND)); + + } else if (dice == ROBBERS_MOVE) { init_drop_list(); return _drop_list.empty() ? GameStage::STAGE1_MOVE_ROBBER : GameStage::STAGE1_DROP_RESOURCES; - } else { - log("regular dice: dealing resources"); + } else { deal_resources(dice); return GameStage::STAGE2; } @@ -28,20 +26,16 @@ GameStage FirstStageSubEngine::make_dice(size_t dice) GameStage FirstStageSubEngine::drop_resource(const Player &player, Resource res) { if (player.bank().resources(res) < SINGLE_DROP) { - throw invalid_argument("cannot drop resource: player " + player.name() + " hasn't enough " + - EnumInfo::resource_str(res) + " to drop"); + throw invalid_argument(fmt::format("cannot drop resource: player {0} hasn't enough {1} to drop", player.name(), EnumInfo::resource_str(res))); } else if (_drop_list.count(&player) == 0) { - throw invalid_argument("cannot drop resource: player " + player.name() + " doesn't have to drop resource"); + throw invalid_argument(fmt::format("cannot drop resource: player {0} doesn't have to drop resource", player.name())); } else if (_drop_list.find(&player)->second == 0) { - throw invalid_argument("cannot drop resource: player " + player.name() + - " already dropped required resources count"); + throw invalid_argument(fmt::format("cannot drop resource: player {0} already dropped required resources count", player.name())); } player.bank().remove(res, SINGLE_DROP); _drop_list[&player] -= SINGLE_DROP; - _game.field().bank().add(res, SINGLE_DROP); - - log("player " + player.name() + " performed a single drop"); + _game.field().bank().add(res, SINGLE_DROP); for (auto it = _drop_list.cbegin(); it != _drop_list.cend(); it++) { if (it->second != 0) { @@ -56,12 +50,10 @@ GameStage FirstStageSubEngine::move_robber(Coord xy) const if (_game.field().has_robber() && (_game.field().robber() == xy)) { throw invalid_argument("cannot move robber: robber has to be moved to other place"); } else if (!_game.field().has_hex(xy)) { - throw invalid_argument("cannot move robber: spot " + xy.str() + " is out of field"); + throw invalid_argument(fmt::format("cannot move robber: spot {} is out of field", xy.str())); } - _game.field().set_robber(xy); - - log("moving robber to " + xy.str()); + _game.field().set_robber(xy); auto hex_corners = this->hex_corners(_game.field().robber()); for (auto i: hex_corners) { @@ -88,7 +80,7 @@ GameStage FirstStageSubEngine::rob(const Player &player, const Player &victim) c } if (!has_locality_near_robber) { - throw invalid_argument("cannot rob: victim player " + victim.name() + " hasn't any locality near robber"); + throw invalid_argument(fmt::format("cannot rob: victim player {} hasn't any locality near robber", victim.name())); } else if (victim.bank().resources() != 0) { std::vector res = {Resource::CLAY, Resource::GRAIN, Resource::ORE, Resource::WOOD, Resource::WOOL}; Resource rob_res; @@ -99,9 +91,7 @@ GameStage FirstStageSubEngine::rob(const Player &player, const Player &victim) c } while (victim.bank().resources(rob_res) == 0); player.bank().add(rob_res, SINGLE_ROBBERY); - victim.bank().remove(rob_res, SINGLE_ROBBERY); - - log(player.name() + " robbed " + victim.name()); + victim.bank().remove(rob_res, SINGLE_ROBBERY); } return GameStage::STAGE2; } diff --git a/src/GameEngine.cpp b/src/GameEngine.cpp index d81f8a6..c810544 100644 --- a/src/GameEngine.cpp +++ b/src/GameEngine.cpp @@ -1,66 +1,60 @@ #include -#include "GameEngine.h" - -using Logger::log; -using std::invalid_argument; - -GameEngine::~GameEngine() -{ +#include "GameEngine.h" +#include "format.h" +using std::invalid_argument; + +GameEngine::~GameEngine() +{ delete _preparation_stage; delete _first_stage; delete _second_stage; delete _third_stage; - delete _game; + delete _game; } //--------------------------------------------------------------------- //------------------------ PREPARATION -------------------------------- -//--------------------------------------------------------------------- - -void GameEngine::join_player(const std::string &player) -{ - if (_game_stage != GameStage::PLAYERS_REGISTRATION) { - throw invalid_argument("cannot join player \"" + player + "\": game is on " + - EnumInfo::game_stage_str(_game_stage)); - } - _preparation_stage->join_player(player); -} - -void GameEngine::unjoin_player(const std::string &player) -{ - if (_game_stage != GameStage::PLAYERS_REGISTRATION) { - throw invalid_argument("cannot unjoin player \"" + player + "\": game is on " + - EnumInfo::game_stage_str(_game_stage)); - } - _preparation_stage->unjoin_player(player); -} +//--------------------------------------------------------------------- + +void GameEngine::join_player(const std::string &player) +{ + if (_game_stage != GameStage::PLAYERS_REGISTRATION) { + throw invalid_argument(fmt::format("cannot join player \"{0}\" : game is on {1}", player, EnumInfo::game_stage_str(_game_stage))); + } + _preparation_stage->join_player(player); +} + +void GameEngine::unjoin_player(const std::string &player) +{ + if (_game_stage != GameStage::PLAYERS_REGISTRATION) { + throw invalid_argument(fmt::format("cannot unjoin player \"{0}\" : game is on {1}", player, EnumInfo::game_stage_str(_game_stage))); + } + _preparation_stage->unjoin_player(player); +} void GameEngine::start_game() { if (_game_stage != GameStage::PLAYERS_REGISTRATION) { - throw invalid_argument("cannot start game: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot start game: game is on {}", EnumInfo::game_stage_str(_game_stage))); } _preparation_stage->fix_players(); _preparation_stage->init_bank(); _preparation_stage->init_classical_field(); - _game_stage = GameStage::INFRASTRUCTURES_REGISTRATION; - - log("starting game"); + _game_stage = GameStage::INFRASTRUCTURES_REGISTRATION; } void GameEngine::register_road(const std::string &player, const std::string &name) { if (_game_stage != GameStage::INFRASTRUCTURES_REGISTRATION) { - throw invalid_argument("cannot register " + player + "'s road \"" + name + - "\": game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot register {0}'s road \"{1}\": game is on {2}", player, name, EnumInfo::game_stage_str(_game_stage))); } Player *player_ptr = nullptr; try { player_ptr = &_game->player(player_number(player)); } catch (invalid_argument &except) { - throw invalid_argument("cannot register " + player + "'s road \"" + name + "\" player doesn't exist"); + throw invalid_argument(fmt::format("cannot register {0}'s road \"{1}\" player doesn't exist", player, name)); } _game_stage = _preparation_stage->register_road(*player_ptr, name); @@ -69,14 +63,13 @@ void GameEngine::register_road(const std::string &player, const std::string &nam void GameEngine::register_town(const std::string &player, const std::string &name) { if (_game_stage != GameStage::INFRASTRUCTURES_REGISTRATION) { - throw invalid_argument("cannot register " + player + "'s town \"" + name + - "\": game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot register {0}'s town \"{1}\": game is on {2}", player, name, EnumInfo::game_stage_str(_game_stage))); } Player *player_ptr = nullptr; try { player_ptr = &_game->player(player_number(player)); } catch (invalid_argument &except) { - throw invalid_argument("cannot register " + player + "'s town \"" + name + "\" player doesn't exist"); + throw invalid_argument(fmt::format("cannot register {0}'s town \"{1}\" player doesn't exist", player, name)); } _game_stage = _preparation_stage->register_town(*player_ptr, name); @@ -85,14 +78,13 @@ void GameEngine::register_town(const std::string &player, const std::string &nam void GameEngine::register_city(const std::string &player, const std::string &name) { if (_game_stage != GameStage::INFRASTRUCTURES_REGISTRATION) { - throw invalid_argument("cannot register " + player + "'s city \"" + name + - "\": game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot register {0}'s city \"{1}\": game is on {2}", player, name, EnumInfo::game_stage_str(_game_stage))); } Player *player_ptr = nullptr; try { player_ptr = &_game->player(player_number(player)); } catch (invalid_argument &except) { - throw invalid_argument("cannot register " + player + "'s city \"" + name + "\" player doesn't exist"); + throw invalid_argument(fmt::format("cannot register {0}'s city \"{1}\" player doesn't exist", player, name)); } _game_stage = _preparation_stage->register_city(*player_ptr, name); @@ -103,15 +95,14 @@ void GameEngine::put_initial_infrastructure(const std::string &player, const std::string &road, Coord road_coord, RoadSide road_side) { if (_game_stage != GameStage::PUT_INITIAL_INFRASTRUCTURES) { - throw invalid_argument("cannot put initial infrastructure: game is on " + - EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot put initial infrastructure: game is on {}", EnumInfo::game_stage_str(_game_stage))); } Player *player_ptr = nullptr; try { player_ptr = &_game->player(player_number(player)); } catch (invalid_argument &except) { - throw invalid_argument("cannot put initial infrastructure: " + string(except.what())); + throw invalid_argument(fmt::format("cannot put initial infrastructure: {}", string(except.what()))); } _game_stage = _preparation_stage->put_initial_infrastructure(*player_ptr, town, town_coord, town_corner, @@ -120,23 +111,21 @@ void GameEngine::put_initial_infrastructure(const std::string &player, if (_game_stage == GameStage::STAGE1_DICE) { _first_stage = new FirstStageSubEngine(*_game); delete _preparation_stage; - _preparation_stage = nullptr; - log("moving onto stage 1"); + _preparation_stage = nullptr; } } //--------------------------------------------------------------------- //------------------------ STAGE 1 ------------------------------------ -//--------------------------------------------------------------------- +//--------------------------------------------------------------------- void GameEngine::make_dice(const std::string &player, size_t dice) { if (_game_stage != GameStage::STAGE1_DICE) { - throw invalid_argument("cannot make dice: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot make dice: game is on {}", EnumInfo::game_stage_str(_game_stage))); } else if (current_player().name() != player) { - throw invalid_argument("cannot make dice: it is " + - current_player().name() + "'s move, not " + player + "'s"); + throw invalid_argument(fmt::format("cannot make dice: it is {0}'s move, not {1}'s", current_player().name(), player)); } _game_stage = _first_stage->make_dice(dice); @@ -144,22 +133,21 @@ void GameEngine::make_dice(const std::string &player, size_t dice) if (_game_stage == GameStage::STAGE2) { _second_stage = new SecondStageSubEngine(_game->field().bank(), current_player()); delete _first_stage; - _first_stage = nullptr; - log("moving onto stage 2"); + _first_stage = nullptr; } } void GameEngine::drop_resource(const std::string &player, Resource res) { if (_game_stage != GameStage::STAGE1_DROP_RESOURCES) { - throw invalid_argument("cannot drop resource: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot drop resource: game is on {}", EnumInfo::game_stage_str(_game_stage))); } size_t num; try { num = player_number(player); } catch (invalid_argument &except) { - throw invalid_argument("cannot drop resource: " + string(except.what())); + throw invalid_argument(fmt::format("cannot drop resource: {}", string(except.what()))); } _game_stage = _first_stage->drop_resource(_game->player(num), res); @@ -168,54 +156,51 @@ void GameEngine::drop_resource(const std::string &player, Resource res) void GameEngine::move_robber(const std::string &player, Coord xy) { if (_game_stage != GameStage::STAGE1_MOVE_ROBBER) { - throw invalid_argument("cannot move robber: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot move robber: game is on {}", EnumInfo::game_stage_str(_game_stage))); } else if (current_player().name() != player) { - throw invalid_argument("cannot move robber: player " + player + " isn't current"); + throw invalid_argument(fmt::format("cannot move robber: player {} isn't current")); } _game_stage = _first_stage->move_robber(xy); if (_game_stage == GameStage::STAGE2) { _second_stage = new SecondStageSubEngine(_game->field().bank(), current_player()); delete _first_stage; - _first_stage = nullptr; - log("moving onto stage 2"); + _first_stage = nullptr; } } void GameEngine::rob(const std::string &player, const std::string &victim) { if (_game_stage != GameStage::STAGE1_ROBBING) { - throw invalid_argument("cannot rob: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot rob: game is on {}", EnumInfo::game_stage_str(_game_stage))); } else if (current_player().name() != player) { - throw invalid_argument("cannot rob: it is " + current_player().name() + "'s move, not " + player + "'s"); + throw invalid_argument(fmt::format("cannot rob: it is {0}'s move, not {1}'s", current_player().name(), player)); } size_t num_victim; try { num_victim = player_number(victim); } catch (invalid_argument &except) { - throw invalid_argument("cannot rob: " + string(except.what())); + throw invalid_argument(fmt::format("cannot rob: {}", string(except.what()))); } _game_stage = _first_stage->rob(current_player(), _game->player(num_victim)); _second_stage = new SecondStageSubEngine(_game->field().bank(), current_player()); delete _first_stage; - _first_stage = nullptr; - log("moving onto stage 2"); + _first_stage = nullptr; } //--------------------------------------------------------------------- //------------------------ STAGE 2 ------------------------------------ -//--------------------------------------------------------------------- +//--------------------------------------------------------------------- void GameEngine::exchange_with_field(const std::string &player, Resource src, Resource target) { if (_game_stage != GameStage::STAGE2) { - throw invalid_argument("cannot exchange with field: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot exchange with field: game is on {}", EnumInfo::game_stage_str(_game_stage))); } else if (current_player().name() != player) { - throw invalid_argument("cannot exchange with field: it is " + - current_player().name() + "'s move, not " + player + "'s"); + throw invalid_argument(fmt::format("cannot exchange with field: it is {0}'s move, not {1}'s", current_player().name(), player)); } _second_stage->exchange_with_field(src, target); @@ -225,16 +210,15 @@ int GameEngine::exchange_players_request(const std::string &player, const std::s const std::multiset &src, const std::multiset &target) { if (_game_stage != GameStage::STAGE2) { - throw invalid_argument("cannot register exchange: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot register exchange: game is on {}", EnumInfo::game_stage_str(_game_stage))); } else if (current_player().name() != player) { - throw invalid_argument("cannot register exchange: it is " + current_player().name() + - "'s move, not " + player + "'s"); + throw invalid_argument(fmt::format("cannot register exchange: it is {0}'s move, not {1}'s", current_player().name(), player)); } Player *other_player_ptr = nullptr; try { other_player_ptr = &_game->player(player_number(other_player)); } catch (invalid_argument &except) { - throw invalid_argument("cannot register exchange: " + string(except.what())); + throw invalid_argument(fmt::format("cannot register exchange: {}", string(except.what()))); } if (current_player().name() == other_player_ptr->name()) { throw invalid_argument("cannot register exchange: self-exchanges are forbidden"); @@ -246,16 +230,16 @@ int GameEngine::exchange_players_request(const std::string &player, const std::s void GameEngine::exchange_players_accept(const std::string &player, int request) { if (_game_stage != GameStage::STAGE2) { - throw invalid_argument("cannot accept exchange: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot accept exchange: game is on {}", EnumInfo::game_stage_str(_game_stage))); } Player *player_ptr = nullptr; try { player_ptr = &_game->player(player_number(player)); } catch (invalid_argument &except) { - throw invalid_argument("cannot accept exchange: " + string(except.what())); + throw invalid_argument(fmt::format("cannot accept exchange: {}", string(except.what()))); } if (current_player().name() == player_ptr->name()) { - throw invalid_argument("cannot accept exchange: wrong player \"" + player + "\""); + throw invalid_argument(fmt::format("cannot accept exchange: wrong player \"{}\"", player)); } _second_stage->exchange_players_accept(*player_ptr, request); @@ -264,7 +248,7 @@ void GameEngine::exchange_players_accept(const std::string &player, int request) std::set GameEngine::requests() const { if (_game_stage != GameStage::STAGE2) { - throw invalid_argument("cannot get exchange requests: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot get exchange requests: game is on {}", EnumInfo::game_stage_str(_game_stage))); } return _second_stage->requests(); } @@ -272,7 +256,7 @@ std::set GameEngine::requests() const std::set GameEngine::exchanges() const { if (_game_stage != GameStage::STAGE2) { - throw invalid_argument("cannot get exchanges: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot get exchanges: game is on {}", EnumInfo::game_stage_str(_game_stage))); } return _second_stage->exchanges(); } @@ -280,7 +264,7 @@ std::set GameEngine::exchanges() const const Player &GameEngine::initiator(int request) const { if (_game_stage != GameStage::STAGE2) { - throw invalid_argument("cannot get exchange initiator: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot get exchange initiator: game is on {}", EnumInfo::game_stage_str(_game_stage))); } return _second_stage->initiator(request); } @@ -288,7 +272,7 @@ const Player &GameEngine::initiator(int request) const const Player &GameEngine::other(int request) const { if (_game_stage != GameStage::STAGE2) { - throw invalid_argument("cannot get exchange other player: game is on "+EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot get exchange other player: game is on {}", EnumInfo::game_stage_str(_game_stage))); } return _second_stage->other(request); } @@ -296,7 +280,7 @@ const Player &GameEngine::other(int request) const const std::multiset &GameEngine::src(int request) const { if (_game_stage != GameStage::STAGE2) { - throw invalid_argument("cannot get exchange src set: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot get exchange src set: game is on {}", EnumInfo::game_stage_str(_game_stage))); } return _second_stage->src(request); } @@ -304,7 +288,7 @@ const std::multiset &GameEngine::src(int request) const const std::multiset &GameEngine::target(int request) const { if (_game_stage != GameStage::STAGE2) { - throw invalid_argument("cannot get exchange target set: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot get exchange target set: game is on {}", EnumInfo::game_stage_str(_game_stage))); } return _second_stage->target(request); } @@ -312,7 +296,7 @@ const std::multiset &GameEngine::target(int request) const bool GameEngine::requested(int number) const { if (_game_stage != GameStage::STAGE2) { - throw invalid_argument("cannot identify request: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot identify request: game is on {}", EnumInfo::game_stage_str(_game_stage))); } return _second_stage->requested(number); } @@ -320,7 +304,7 @@ bool GameEngine::requested(int number) const bool GameEngine::performed(int request) const { if (_game_stage != GameStage::STAGE2) { - throw invalid_argument("cannot identify request: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot identify request: game is on {}", EnumInfo::game_stage_str(_game_stage))); } return _second_stage->performed(request); } @@ -328,17 +312,15 @@ bool GameEngine::performed(int request) const void GameEngine::end_exchanges(const std::string &player) { if (_game_stage != GameStage::STAGE2) { - throw invalid_argument("cannot end exchanges: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot end exchanges: game is on {}", EnumInfo::game_stage_str(_game_stage))); } else if (current_player().name() != player) { - throw invalid_argument("cannot end exchanges: it is " + current_player().name() + - "'s move, not " + player + "'s"); + throw invalid_argument(fmt::format("cannot end exchanges: it is {0}'s move, not {1}'s", current_player().name(), player)); } _third_stage = new ThirdStageSubEngine(_game->field(), current_player()); _game_stage = GameStage::STAGE3; delete _second_stage; - _second_stage = nullptr; - log("moving onto stage 3"); + _second_stage = nullptr; } //--------------------------------------------------------------------- @@ -348,10 +330,9 @@ void GameEngine::end_exchanges(const std::string &player) void GameEngine::build_road(const std::string &player, const std::string &road, Coord xy, RoadSide road_side) { if (_game_stage != GameStage::STAGE3) { - throw invalid_argument("cannot build: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot build: game is on {}", EnumInfo::game_stage_str(_game_stage))); } else if (current_player().name() != player) { - throw invalid_argument("cannot build: it is " + current_player().name() + - "'s move, not " + player + "'s"); + throw invalid_argument(fmt::format("cannot build: it is {0}'s move, not {1}'s", current_player().name(), player)); } _third_stage->build_road(_third_stage->road(road), xy, road_side); @@ -360,10 +341,9 @@ void GameEngine::build_road(const std::string &player, const std::string &road, void GameEngine::build_town(const std::string &player, const std::string &town, Coord xy, CrossCorner cross_corner) { if (_game_stage != GameStage::STAGE3) { - throw invalid_argument("cannot build: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot build: game is on {}", EnumInfo::game_stage_str(_game_stage))); } else if (current_player().name() != player) { - throw invalid_argument("cannot build: it is " + current_player().name() + - "'s move, not " + player + "'s"); + throw invalid_argument(fmt::format("cannot build: it is {0}'s move, not {1}'s", current_player().name(), player)); } _third_stage->build_town(_third_stage->town(town), xy, cross_corner); @@ -371,18 +351,16 @@ void GameEngine::build_town(const std::string &player, const std::string &town, if (score(player) >= VICTORY_POINTS) { delete _third_stage; _third_stage = nullptr; - _game_stage = GameStage::FINAL_STAGE; - log("game over"); + _game_stage = GameStage::FINAL_STAGE; } } void GameEngine::build_city(const std::string &player, const std::string &city, Coord xy, CrossCorner cross_corner) { if (_game_stage != GameStage::STAGE3) { - throw invalid_argument("cannot build: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot build: game is on {}", EnumInfo::game_stage_str(_game_stage))); } else if (current_player().name() != player) { - throw invalid_argument("cannot build: it is " + current_player().name() + - "'s move, not " + player + "'s"); + throw invalid_argument(fmt::format("cannot build: it is {0}'s move, not {1}'s", current_player().name(), player)); } _third_stage->build_city(_third_stage->city(city), xy, cross_corner); @@ -390,18 +368,16 @@ void GameEngine::build_city(const std::string &player, const std::string &city, if (score(player) >= VICTORY_POINTS) { delete _third_stage; _third_stage = nullptr; - _game_stage = GameStage::FINAL_STAGE; - log("game over"); + _game_stage = GameStage::FINAL_STAGE; } } const std::set< std::pair > &GameEngine::valid_road_spots(const string &player) const { if (_game_stage != GameStage::STAGE3) { - throw invalid_argument("cannot get valid road spots: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot get valid road spots: game is on {}", EnumInfo::game_stage_str(_game_stage))); } else if (current_player().name() != player) { - throw invalid_argument("cannot get valid road spots: it is " + current_player().name() + - "'s move, not " + player + "'s"); + throw invalid_argument(fmt::format("cannot get valid road spots: it is {0}'s move, not {1}'s", current_player().name(), player)); } return _third_stage->valid_road_spots(); } @@ -409,10 +385,9 @@ const std::set< std::pair > &GameEngine::valid_road_spots(const const std::set< std::pair > &GameEngine::valid_town_spots(const string &player) const { if (_game_stage != GameStage::STAGE3) { - throw invalid_argument("cannot get valid town spots: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot get valid town spots: game is on {}", EnumInfo::game_stage_str(_game_stage))); } else if (current_player().name() != player) { - throw invalid_argument("cannot get valid town spots: it is " + current_player().name() + - "'s move, not " + player + "'s"); + throw invalid_argument(fmt::format("cannot get valid town spots: it is {0}'s move, not {1}'s", current_player().name(), player)); } return _third_stage->valid_town_spots(); } @@ -420,10 +395,9 @@ const std::set< std::pair > &GameEngine::valid_town_spots(co const std::set< std::pair > &GameEngine::valid_city_spots(const string &player) const { if (_game_stage != GameStage::STAGE3) { - throw invalid_argument("cannot get valid city spots: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot get valid city spots: game is on {}", EnumInfo::game_stage_str(_game_stage))); } else if (current_player().name() != player) { - throw invalid_argument("cannot get valid city spots: it is " + current_player().name() + - "'s move, not " + player + "'s"); + throw invalid_argument(fmt::format("cannot get valid city spots: it is {0}'s move, not {1}'s", current_player().name(), player)); } return _third_stage->valid_city_spots(); } @@ -431,10 +405,9 @@ const std::set< std::pair > &GameEngine::valid_city_spots(co void GameEngine::next_player(const std::string &player) { if (_game_stage != GameStage::STAGE3) { - throw invalid_argument("cannot switch player: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot switch player: game is on {}", EnumInfo::game_stage_str(_game_stage))); } else if (current_player().name() != player) { - throw invalid_argument("cannot switch player: it is " + current_player().name() + - "'s move, not " + player + "'s"); + throw invalid_argument(fmt::format("cannot switch player: it is {0}'s move, not {1}'s", current_player().name(), player)); } _first_stage = new FirstStageSubEngine(game()); @@ -443,8 +416,7 @@ void GameEngine::next_player(const std::string &player) _game_stage = GameStage::STAGE1_DICE; - _current_player = (_current_player + 1) % game().num_players(); - log("switching to the next player: " + current_player().name()); + _current_player = (_current_player + 1) % game().num_players(); } //--------------------------------------------------------------------- @@ -453,7 +425,7 @@ void GameEngine::next_player(const std::string &player) const Player &GameEngine::current_player() const { if ((_game_stage == GameStage::PLAYERS_REGISTRATION) || (_game_stage == GameStage::FINAL_STAGE)) { - throw invalid_argument("cannot get current player: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot get current player: game is on {}", EnumInfo::game_stage_str(_game_stage))); } return _game->player(_current_player); } @@ -461,7 +433,7 @@ const Player &GameEngine::current_player() const size_t GameEngine::player_number(const string &player_name) const { if (_game_stage == GameStage::PLAYERS_REGISTRATION) { - throw invalid_argument("cannot get players number: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot get players number: game is on {}", EnumInfo::game_stage_str(_game_stage))); } for (size_t i = 0; i < _game->num_players(); i++) { @@ -469,19 +441,19 @@ size_t GameEngine::player_number(const string &player_name) const return i; } } - throw invalid_argument("player \"" + player_name + "\" doesn't exist"); + throw invalid_argument(fmt::format("player \"{}\" doesn't exist", player_name)); } int GameEngine::score(const std::string &player) { if (_game_stage == GameStage::PLAYERS_REGISTRATION) { - throw invalid_argument("cannot get score: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot get score: game is on {}", EnumInfo::game_stage_str(_game_stage))); } Player *player_ptr = nullptr; try { player_ptr = &_game->player(player_number(player)); } catch (invalid_argument &except) { - throw invalid_argument("cannot get score: " + string(except.what())); + throw invalid_argument(fmt::format("cannot get score: {}", string(except.what()))); } int points = 0; @@ -502,7 +474,7 @@ int GameEngine::score(const std::string &player) const Player &GameEngine::winner() const { if (_game_stage != GameStage::FINAL_STAGE) { - throw invalid_argument("cannot get winner: game is on " + EnumInfo::game_stage_str(_game_stage)); + throw invalid_argument(fmt::format("cannot get winner: game is on {}", EnumInfo::game_stage_str(_game_stage))); } return _game->player(_current_player); diff --git a/src/Hex.cpp b/src/Hex.cpp index a271a1f..1f7edf4 100644 --- a/src/Hex.cpp +++ b/src/Hex.cpp @@ -1,20 +1,18 @@ #include "Hex.h" #include +#include "format.h" using std::logic_error; void Hex::set_number(size_t n) { if (_has_number) { - std::stringstream err_msg; - err_msg << "cannot set number " << n; - err_msg << ": the number on hex is " << _number; - throw logic_error(err_msg.str()); - } + throw logic_error(fmt::format("cannot set number {0} : the number on hex is {1}", n, _number)); + } _has_number = true; _number = n; } - + void Hex::unset_number() { if (!_has_number) { @@ -29,19 +27,17 @@ size_t Hex::number() const throw logic_error("cannot return number: there is no number on hex"); } return _number; -} - +} + void Hex::set_resource(Resource res) { if (_has_resource) { - std::string err_msg = "cannot set resource " + EnumInfo::resource_str(res) + - " : the resource on hex is " + EnumInfo::resource_str(_resource); - throw logic_error(err_msg); + throw logic_error(fmt::format("cannot set resource {0} : the resource on hex is {1}", EnumInfo::resource_str(res), EnumInfo::resource_str(_resource))); } _has_resource = true; _resource = res; } - + void Hex::unset_resource() { if (!_has_resource) { diff --git a/src/Player.cpp b/src/Player.cpp index 196b678..375b96e 100644 --- a/src/Player.cpp +++ b/src/Player.cpp @@ -1,4 +1,5 @@ #include "Player.h" +#include "format.h" using std::logic_error; using std::out_of_range; @@ -14,7 +15,7 @@ Player::~Player () for (auto &i: _cities) { delete i; } - delete _bank; + delete _bank; } Infrastructure &Player::infrastructure(size_t i) const @@ -26,29 +27,29 @@ Infrastructure &Player::infrastructure(size_t i) const } else if ((i -= _cities.size()) < _towns.size()) { return *_towns[i]; } - throw out_of_range(name() + "/Infrastructure &Player::infrastructure() OUT OF RANGE"); + throw out_of_range(fmt::format("{}/Infrastructure &Player::infrastructure() OUT OF RANGE", name())); } Road &Player::road(size_t i) const { if (i >= _roads.size()) { - throw out_of_range(name() + "/Road &Player::road() OUT OF RANGE"); + throw out_of_range(fmt::format("{}/Road &Player::road() OUT OF RANGE", name())); } return *_roads[i]; } - + Town &Player::town(size_t i) const { if (i >= _towns.size()) { - throw out_of_range(name() + "/Town &Player::town() OUT OF RANGE"); + throw out_of_range(fmt::format("{}/Town &Player::town() OUT OF RANGE", name())); } return *_towns[i]; -} - +} + City &Player::city(size_t i) const { if (i >= _cities.size()) { - throw out_of_range(name() + "/City &Player::city() OUT OF RANGE"); + throw out_of_range(fmt::format("{}/City &Player::city() OUT OF RANGE", name())); } return *_cities[i]; } diff --git a/src/PreparationEngine.cpp b/src/PreparationEngine.cpp index 7968e90..204dbe7 100644 --- a/src/PreparationEngine.cpp +++ b/src/PreparationEngine.cpp @@ -1,37 +1,27 @@ -#include "PreparationEngine.h" - -#include - -using Logger::log; -using Logger::warnif; -using std::invalid_argument; +#include "PreparationEngine.h" +#include +#include "format.h" +using std::invalid_argument; bool PreparationEngine::player_is_waiting(const string &name) const noexcept { return std::count(_waiting_queue.begin(), _waiting_queue.end(), name); } - -void PreparationEngine::join_player(const string &player) -{ - if (player_is_waiting(player)) { - throw invalid_argument("cannot join player \"" + player + - "\": player with this name is already waiting for a game"); - } - _waiting_queue.push_back(player); - - log("player " + player + " joined the game"); - warnif(_waiting_queue.size() > NUM_PLAYERS_HIGHER_BOUND, "number of players exceeds game limit"); -} - -void PreparationEngine::unjoin_player(const string &player) -{ - if (!player_is_waiting(player)) { - throw invalid_argument("cannot unjoin player \"" + player + - "\": player with this name doesn't exist"); - } - _waiting_queue.remove(player); - - log("player " + player + " left the game"); + +void PreparationEngine::join_player(const string &player) +{ + if (player_is_waiting(player)) { + throw invalid_argument(fmt::format("cannot join player \"{}\": player with this name is already waiting for a game", player)); + } + _waiting_queue.push_back(player); +} + +void PreparationEngine::unjoin_player(const string &player) +{ + if (!player_is_waiting(player)) { + throw invalid_argument(fmt::format("cannot unjoin player \"{}\": player with this name doesn't exist", player)); + } + _waiting_queue.remove(player); } bool PreparationEngine::has_road(const Player &player, const string &name) const noexcept @@ -67,45 +57,36 @@ bool PreparationEngine::has_city(const Player &player, const string &name) const GameStage PreparationEngine::register_road(Player &player, const string &name) { if (has_road(player, name)) { - throw invalid_argument("cannot register " + player.name() + "'s road \"" + name + - "\": player already has such road"); + throw invalid_argument(fmt::format("cannot register {0}'s road \"{1}\": player already has such road", player.name(), name)); } else if (player.num_roads() >= MAX_ROADS) { - throw invalid_argument("cannot register " + player.name() + "'s road \"" + name + - "\": player already has all possible roads"); + throw invalid_argument(fmt::format("cannot register {0}'s road \"{1}\": player already has all possible roads", player.name(), name)); } - player.add_road(name); - log(player.name() + " registered road " + name); + player.add_road(name); return registration_is_over() ? GameStage::PUT_INITIAL_INFRASTRUCTURES : GameStage::INFRASTRUCTURES_REGISTRATION; } GameStage PreparationEngine::register_town(Player &player, const string &name) { if (has_town(player, name)) { - throw invalid_argument("cannot register " + player.name() + "'s town \"" + name + - "\": player already has such town"); + throw invalid_argument(fmt::format("cannot register {0}'s town \"{1}\": player already has such town", player.name(), name)); } else if (player.num_towns() >= MAX_TOWNS) { - throw invalid_argument("cannot register " + player.name() + "'s town \"" + name + - "\": player already has all possible towns"); + throw invalid_argument(fmt::format("cannot register {0}'s town \"{1}\": player already has all possible towns", player.name(), name)); } - player.add_town(name); - log(player.name() + " registered town " + name); + player.add_town(name); return registration_is_over() ? GameStage::PUT_INITIAL_INFRASTRUCTURES : GameStage::INFRASTRUCTURES_REGISTRATION; } GameStage PreparationEngine::register_city(Player &player, const string &name) { if (has_city(player, name)) { - throw invalid_argument("cannot register " + player.name() + "'s city \"" + name + - "\": player already has such city"); + throw invalid_argument(fmt::format("cannot register {0}'s city \"{1}\": player already has such city", player.name(), name)); } else if (player.num_cities() >= MAX_CITIES) { - throw invalid_argument("cannot register " + player.name() + "'s city \"" + name + - "\": player already has all possible cities"); + throw invalid_argument(fmt::format("cannot register {0}'s city \"{1}\": player already has all possible cities", player.name(), name)); } - player.add_city(name); - log(player.name() + " registered city " + name); + player.add_city(name); return registration_is_over() ? GameStage::PUT_INITIAL_INFRASTRUCTURES : GameStage::INFRASTRUCTURES_REGISTRATION; } @@ -118,11 +99,9 @@ void PreparationEngine::fix_players() for (auto &i: _waiting_queue) { _game.add_player(i); } - _waiting_queue.clear(); - - log("registration is over"); + _waiting_queue.clear(); } - + void PreparationEngine::init_bank() const { ResourcesHolder &bank = _game.field().bank(); @@ -131,9 +110,7 @@ void PreparationEngine::init_bank() const bank.add(Resource::GRAIN, RESOURCES_INITIAL_COUNT); bank.add(Resource::ORE, RESOURCES_INITIAL_COUNT); bank.add(Resource::WOOD, RESOURCES_INITIAL_COUNT); - bank.add(Resource::WOOL, RESOURCES_INITIAL_COUNT); - - log("game bank initialized"); + bank.add(Resource::WOOL, RESOURCES_INITIAL_COUNT); } void PreparationEngine::init_classical_field() const @@ -211,9 +188,7 @@ void PreparationEngine::init_classical_field() const field.hex(Coord(2, -2)).set_number(11); field.hex(Coord(2, -2)).set_resource(Resource::ORE); - field.set_robber(Coord(0, 0)); - - log("classical field initialized"); + field.set_robber(Coord(0, 0)); } bool PreparationEngine::registration_is_over() const noexcept @@ -240,8 +215,7 @@ GameStage PreparationEngine::put_initial_infrastructure(const Player &player, } } if (road_ptr == nullptr) { - throw invalid_argument("cannot put initial infrastructure: player " + player.name() + - " hasn't road \"" + road + "\""); + throw invalid_argument(fmt::format("cannot put initial infrastructure: player {0} hasn't road \"{1}\"", player.name(), road)); } for (size_t i = 0; i < player.num_towns(); i++) { if (player.town(i).name() == town) { @@ -250,8 +224,7 @@ GameStage PreparationEngine::put_initial_infrastructure(const Player &player, } } if (town_ptr == nullptr) { - throw invalid_argument("cannot put initial infrastructure: player " + player.name() + - " hasn't town \"" + town + "\""); + throw invalid_argument(fmt::format("cannot put initial infrastructure: player {0} hasn't town \"{1}\"", player.name(), town)); } Field &field = _game.field(); @@ -266,8 +239,7 @@ GameStage PreparationEngine::put_initial_infrastructure(const Player &player, { throw invalid_argument("cannot put initial infrastructure: initial infrastructures aren't adjacent"); } else if (_game.player(_current_player).name() != player.name()) { - throw invalid_argument("cannot put initial infrastructure: it is " + _game.player(_current_player).name() + - "'s move, not " + player.name() + "'s"); + throw invalid_argument(fmt::format("cannot put initial infrastructure: it is {0}'s move, not {1}'s", _game.player(_current_player).name(), player.name())); } else if (((town_corner == CrossCorner::BOTTOM) && (field.has_locality(town_coord.south_east(), CrossCorner::TOP) || field.has_locality(town_coord.south_west(), CrossCorner::TOP) @@ -299,13 +271,10 @@ GameStage PreparationEngine::put_initial_infrastructure(const Player &player, } field.link_locality(*town_ptr, town_coord, town_corner); - field.link_road(*road_ptr, road_coord, road_side); - - log("player " + player.name() + " successfully put road " + road + " and town " + town); + field.link_road(*road_ptr, road_coord, road_side); if (!_reverse && (_current_player == _game.num_players() - 1)) { - _reverse = true; - log("straight arrangement is over, starting reverse"); + _reverse = true; } else if (_reverse) { std::vector hex_with_resource; if (field.has_hex(town_coord) && field.hex(town_coord).has_resource()) { @@ -329,8 +298,7 @@ GameStage PreparationEngine::put_initial_infrastructure(const Player &player, for (auto i: hex_with_resource) { Resource rec = field.hex(i).resource(); player.bank().add(rec, RESOURCES_PORTION); - field.bank().remove(rec, RESOURCES_PORTION); - log(player.name() + " receives resources from initial infrastructure"); + field.bank().remove(rec, RESOURCES_PORTION); } if (_current_player == 0) { @@ -340,7 +308,6 @@ GameStage PreparationEngine::put_initial_infrastructure(const Player &player, } } else { _current_player++; - } - + } return GameStage::PUT_INITIAL_INFRASTRUCTURES; } diff --git a/src/ResourcesHolder.cpp b/src/ResourcesHolder.cpp index 1f586f7..193367e 100644 --- a/src/ResourcesHolder.cpp +++ b/src/ResourcesHolder.cpp @@ -2,17 +2,15 @@ #include #include +#include "format.h" using std::logic_error; - + void ResourcesHolder::remove(Resource r, size_t n) -{ - if (_resources[r] < n) { - std::stringstream err_msg; - err_msg << "cannot remove " << n << ' ' << EnumInfo::resource_str(r); - err_msg << ": there is only "<< _resources[r]; - throw logic_error(err_msg.str()); - } - _resources[r] -= n; +{ + if (_resources[r] < n) { + throw logic_error(fmt::format("cannot remove {0} {1} : there is only {2}", n, EnumInfo::resource_str(r), _resources[r])); + } + _resources[r] -= n; } size_t ResourcesHolder::resources(Resource r) const noexcept @@ -24,12 +22,12 @@ size_t ResourcesHolder::resources(Resource r) const noexcept return rec_it->second; } } - + size_t ResourcesHolder::resources() const noexcept -{ - size_t sum = 0; - for (auto i: _resources) { - sum += i.second; - } - return sum; -} +{ + size_t sum = 0; + for (auto i: _resources) { + sum += i.second; + } + return sum; +} diff --git a/src/SecondStageSubEngine.cpp b/src/SecondStageSubEngine.cpp index c43361a..251349c 100644 --- a/src/SecondStageSubEngine.cpp +++ b/src/SecondStageSubEngine.cpp @@ -1,26 +1,22 @@ #include "SecondStageSubEngine.h" #include -#include - -using Logger::log; +#include +#include "format.h" using std::invalid_argument; void SecondStageSubEngine::exchange_with_field(Resource src, Resource target) { if (_player.bank().resources(src) < FIELD_EXCHANGE_SRC) { - throw invalid_argument("cannot exchange with field: player " + _player.name() + - " hasn't enough " + EnumInfo::resource_str(src)); + throw invalid_argument(fmt::format("cannot exchange with field: player {0} hasn't enough {1}", _player.name(), EnumInfo::resource_str(src))); } else if (_game_bank.resources(target) < FIELD_EXCHANGE_TARGET) { - throw invalid_argument("cannot exchange with field: game bank hasn't enough " + EnumInfo::resource_str(target)); + throw invalid_argument(fmt::format("cannot exchange with field: game bank hasn't enough {}", EnumInfo::resource_str(target))); } _player.bank().remove(src, FIELD_EXCHANGE_SRC); _game_bank.remove(target, FIELD_EXCHANGE_TARGET); _game_bank.add(src, FIELD_EXCHANGE_SRC); - _player.bank().add(target, FIELD_EXCHANGE_TARGET); - - log(_player.name() + " successfully performed exchange with field"); + _player.bank().add(target, FIELD_EXCHANGE_TARGET); } int SecondStageSubEngine::exchange_players_request(const Player &other_player, @@ -41,11 +37,10 @@ int SecondStageSubEngine::exchange_players_request(const Player &other_player, count_res(src, Resource::WOOD) > _player.bank().resources(Resource::WOOD) || count_res(src, Resource::WOOL) > _player.bank().resources(Resource::WOOL) ) { - throw invalid_argument("cannot register exchange: player " + _player.name() + " hasn't enough resources"); + throw invalid_argument(fmt::format("cannot register exchange: player {} hasn't enough resources", _player.name())); } - _exchange_list.push_back(Exchange(_player, other_player, src, target)); - log(_player.name() + " requested exchange with " + other_player.name()); + _exchange_list.push_back(Exchange(_player, other_player, src, target)); return _exchange_list.size() - 1; } @@ -56,8 +51,7 @@ void SecondStageSubEngine::exchange_players_accept(const Player &player, int req } else if (performed(request)) { throw invalid_argument("cannot accept exchange: this exchange already performed"); } else if (other(request).name() != player.name()) { - throw invalid_argument("cannot accept exchange: request applies to " + _exchange_list[request].other.name() + - ", not to " + player.name()); + throw invalid_argument(fmt::format("cannot accept exchange: request applies to {0}, not to {1}", _exchange_list[request].other.name(), player.name())); } else if (count_res(target(request), Resource::CLAY) > player.bank().resources(Resource::CLAY) || count_res(target(request), Resource::GRAIN) > player.bank().resources(Resource::GRAIN) || count_res(target(request), Resource::ORE) > player.bank().resources(Resource::ORE) || @@ -70,8 +64,7 @@ void SecondStageSubEngine::exchange_players_accept(const Player &player, int req count_res(src(request), Resource::WOOD) > initiator(request).bank().resources(Resource::WOOD) || count_res(src(request), Resource::WOOL) > initiator(request).bank().resources(Resource::WOOL)) { - throw invalid_argument("cannot accept exchange: " + initiator(request).name() + " or " - + player.name() + " hasn't enough resources"); + throw invalid_argument(fmt::format("cannot accept exchange: {0} or {1} hasn't enough resources", initiator(request).name(), player.name())); } for (Resource i: _exchange_list[request].src) { @@ -82,8 +75,7 @@ void SecondStageSubEngine::exchange_players_accept(const Player &player, int req initiator(request).bank().add(i, 1); player.bank().remove(i, 1); } - _exchange_list[request].performed = true; - log(player.name() + " accepted " + _player.name() + "'s request"); + _exchange_list[request].performed = true; } std::set SecondStageSubEngine::requests() const noexcept diff --git a/src/ThirdStageSubEngine.cpp b/src/ThirdStageSubEngine.cpp index 22fabca..a59df20 100644 --- a/src/ThirdStageSubEngine.cpp +++ b/src/ThirdStageSubEngine.cpp @@ -1,7 +1,6 @@ #include "ThirdStageSubEngine.h" -#include - -using Logger::log; +#include +#include "format.h" using std::invalid_argument; const std::map @@ -44,19 +43,17 @@ ThirdStageSubEngine::ThirdStageSubEngine(Field &field, const Player &player) } catch (std::logic_error) { } - } - log("successfully created data structure with valid infrastructure spots"); + } } void ThirdStageSubEngine::build_road(Road &road, Coord xy, RoadSide road_side) { if (_field.linked(road)) { - throw invalid_argument("cannot build road: " + _player.name() + "'s road " + road.name() + " is already built"); + throw invalid_argument(fmt::format("cannot build road: {0}'s road {1} is already built", _player.name(), road.name())); } else if (_road_spots.count( {xy, road_side} ) == 0) { - throw invalid_argument("cannot build road: spot " + xy.str() + - " " + EnumInfo::road_side_str(road_side) + " is incorrect"); + throw invalid_argument(fmt::format("cannot build road: spot {0} {1} is incorrect", xy.str(), EnumInfo::road_side_str(road_side))); } else if (! enough_resources(resources_per_road)) { - throw invalid_argument("cannot build road: player " + _player.name() + " hasn't enough resources"); + throw invalid_argument(fmt::format("cannot build road: player {} hasn't enough resources", _player.name())); } _field.link_road(road, xy, road_side); @@ -67,19 +64,17 @@ void ThirdStageSubEngine::build_road(Road &road, Coord xy, RoadSide road_side) for (auto &i: resources_per_road) { _player.bank().remove(i.first, i.second); _field.bank().add(i.first, i.second); - } - log(_player.name() + " successfully built road " + road.name()); + } } void ThirdStageSubEngine::build_town(Town &town, Coord xy, CrossCorner cross_corner) { if (_field.linked(town)) { - throw invalid_argument("cannot build town: " + _player.name() + "'s town " + town.name() + " is already built"); + throw invalid_argument(fmt::format("cannot build town: {0}'s town {1} is already built", _player.name(), town.name())); } else if (_town_spots.count( {xy, cross_corner} ) == 0) { - throw invalid_argument("cannot build town: spot " + xy.str() + - " " + EnumInfo::cross_corner_str(cross_corner) + " is incorrect"); + throw invalid_argument(fmt::format("cannot build town: spot {0} {1} is incorrect", xy.str(), EnumInfo::cross_corner_str(cross_corner))); } else if (! enough_resources(resources_per_town)) { - throw invalid_argument("cannot build town: player " + _player.name() + " hasn't enough resources"); + throw invalid_argument(fmt::format("cannot build town: player {} hasn't enough resources", _player.name())); } _field.link_locality(town, xy, cross_corner); @@ -90,19 +85,17 @@ void ThirdStageSubEngine::build_town(Town &town, Coord xy, CrossCorner cross_cor for (auto &i: resources_per_town) { _player.bank().remove(i.first, i.second); _field.bank().add(i.first, i.second); - } - log(_player.name() + " successfully built town " + town.name()); + } } void ThirdStageSubEngine::build_city(City &city, Coord xy, CrossCorner cross_corner) { if (_field.linked(city)) { - throw invalid_argument("cannot build city: " + _player.name() + "'s city " + city.name() + " is already built"); + throw invalid_argument(fmt::format("cannot build city: {0}'s city {1} is already built", _player.name(), city.name())); } else if (_city_spots.count( {xy, cross_corner} ) == 0) { - throw invalid_argument("cannot build city: spot " + xy.str() + - " " + EnumInfo::cross_corner_str(cross_corner) + " is incorrect"); + throw invalid_argument(fmt::format("cannot build city: spot {0} {1} is incorrect", xy.str(), EnumInfo::cross_corner_str(cross_corner))); } else if (! enough_resources(resources_per_city)) { - throw invalid_argument("cannot build city: player " + _player.name() + " hasn't enough resources"); + throw invalid_argument(fmt::format("cannot build city: player {} hasn't enough resources", _player.name())); } _field.unlink_locality(xy, cross_corner); @@ -113,8 +106,7 @@ void ThirdStageSubEngine::build_city(City &city, Coord xy, CrossCorner cross_cor for (auto &i: resources_per_city) { _player.bank().remove(i.first, i.second); _field.bank().add(i.first, i.second); - } - log(_player.name() + " successfully built city " + city.name()); + } } bool ThirdStageSubEngine::enough_resources(const std::map &resources_per_infrastructure) @@ -213,7 +205,7 @@ Road &ThirdStageSubEngine::road(const std::string &name) const return _player.road(i); } } - throw invalid_argument("cannot build: player " + _player.name() + " hasn't road \"" + name + '\"'); + throw invalid_argument(fmt::format("cannot build: player {0} hasn't road \"{1}\"", _player.name(), name)); } Town &ThirdStageSubEngine::town(const std::string &name) const @@ -223,7 +215,7 @@ Town &ThirdStageSubEngine::town(const std::string &name) const return _player.town(i); } } - throw invalid_argument("cannot build: player " + _player.name() + " hasn't town \"" + name + '\"'); + throw invalid_argument(fmt::format("cannot build: player {0} hasn't town \"{1}\"", _player.name(), name)); } City &ThirdStageSubEngine::city(const std::string &name) const @@ -233,7 +225,7 @@ City &ThirdStageSubEngine::city(const std::string &name) const return _player.city(i); } } - throw invalid_argument("cannot build: player " + _player.name() + " hasn't city \"" + name + '\"'); + throw invalid_argument(fmt::format("cannot build: player {0} hasn't city \"{1}\"", _player.name(), name)); } void ThirdStageSubEngine::_modify_road_spots(Coord used_spot_coord, RoadSide used_spot_road_side) { diff --git a/src/format.cc b/src/format.cc new file mode 100644 index 0000000..09d2ea9 --- /dev/null +++ b/src/format.cc @@ -0,0 +1,535 @@ +/* + Formatting library for C++ + + Copyright (c) 2012 - 2016, Victor Zverovich + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "format.h" + +#include + +#include +#include +#include +#include +#include +#include // for std::ptrdiff_t + +#if defined(_WIN32) && defined(__MINGW32__) +# include +#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 +# else +# define NOMINMAX +# include +# undef NOMINMAX +# endif +#endif + +#if FMT_EXCEPTIONS +# define FMT_TRY try +# define FMT_CATCH(x) catch (x) +#else +# define FMT_TRY if (true) +# define FMT_CATCH(x) if (false) +#endif + +#ifdef _MSC_VER +# 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) +#endif + +// Dummy implementations of strerror_r and strerror_s called if corresponding +// system functions are not available. +static inline fmt::internal::Null<> strerror_r(int, char *, ...) { + return fmt::internal::Null<>(); +} +static inline fmt::internal::Null<> strerror_s(char *, std::size_t, ...) { + return fmt::internal::Null<>(); +} + +namespace fmt { + +FMT_FUNC internal::RuntimeError::~RuntimeError() FMT_DTOR_NOEXCEPT {} +FMT_FUNC FormatError::~FormatError() FMT_DTOR_NOEXCEPT {} +FMT_FUNC SystemError::~SystemError() FMT_DTOR_NOEXCEPT {} + +namespace { + +#ifndef _MSC_VER +# define FMT_SNPRINTF snprintf +#else // _MSC_VER +inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) { + va_list args; + va_start(args, format); + int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args); + va_end(args); + return result; +} +# define FMT_SNPRINTF fmt_snprintf +#endif // _MSC_VER + +#if defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT) +# define FMT_SWPRINTF snwprintf +#else +# define FMT_SWPRINTF swprintf +#endif // defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT) + +const char RESET_COLOR[] = "\x1b[0m"; + +typedef void (*FormatFunc)(Writer &, int, StringRef); + +// Portable thread-safe version of strerror. +// Sets buffer to point to a string describing the error code. +// This can be either a pointer to a string stored in buffer, +// or a pointer to some static immutable string. +// Returns one of the following values: +// 0 - success +// 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 { + FMT_ASSERT(buffer != 0 && buffer_size != 0, "invalid buffer"); + + class StrError { + private: + int error_code_; + char *&buffer_; + std::size_t buffer_size_; + + // A noop assignment operator to avoid bogus warnings. + void operator=(const StrError &) {} + + // Handle the result of XSI-compliant version of strerror_r. + int handle(int result) { + // glibc versions before 2.13 return result in errno. + return result == -1 ? errno : result; + } + + // Handle the result of GNU-specific version of strerror_r. + int handle(char *message) { + // If the buffer is full then the message is probably truncated. + if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1) + return ERANGE; + buffer_ = message; + return 0; + } + + // Handle the case when strerror_r is not available. + int handle(internal::Null<>) { + return fallback(strerror_s(buffer_, buffer_size_, error_code_)); + } + + // Fallback to strerror_s when strerror_r is not available. + int fallback(int result) { + // If the buffer is full then the message is probably truncated. + return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? + ERANGE : result; + } + + // Fallback to strerror if strerror_r and strerror_s are not available. + int fallback(internal::Null<>) { + errno = 0; + buffer_ = strerror(error_code_); + return errno; + } + + public: + StrError(int err_code, char *&buf, std::size_t buf_size) + : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {} + + int run() { + // Suppress a warning about unused strerror_r. + strerror_r(0, FMT_NULL, ""); + return handle(strerror_r(error_code_, buffer_, buffer_size_)); + } + }; + return StrError(error_code, buffer, buffer_size).run(); +} + +void format_error_code(Writer &out, int error_code, + StringRef message) FMT_NOEXCEPT { + // Report error code making sure that the output fits into + // INLINE_BUFFER_SIZE to avoid dynamic memory allocation and potential + // bad_alloc. + out.clear(); + static const char SEP[] = ": "; + static const char ERROR_STR[] = "error "; + // Subtract 2 to account for terminating null characters in SEP and ERROR_STR. + std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2; + typedef internal::IntTraits::MainType MainType; + MainType abs_value = static_cast(error_code); + if (internal::is_negative(error_code)) { + abs_value = 0 - abs_value; + ++error_code_size; + } + error_code_size += internal::count_digits(abs_value); + if (message.size() <= internal::INLINE_BUFFER_SIZE - error_code_size) + out << message << SEP; + out << ERROR_STR << error_code; + assert(out.size() <= internal::INLINE_BUFFER_SIZE); +} + +void report_error(FormatFunc func, int error_code, + StringRef message) FMT_NOEXCEPT { + MemoryWriter full_message; + func(full_message, error_code, message); + // Use Writer::data instead of Writer::c_str to avoid potential memory + // allocation. + std::fwrite(full_message.data(), full_message.size(), 1, stderr); + std::fputc('\n', stderr); +} +} // namespace + +FMT_FUNC void SystemError::init( + int err_code, CStringRef format_str, ArgList args) { + error_code_ = err_code; + MemoryWriter w; + format_system_error(w, err_code, format(format_str, args)); + std::runtime_error &base = *this; + base = std::runtime_error(w.str()); +} + +template +int internal::CharTraits::format_float( + char *buffer, std::size_t size, const char *format, + unsigned width, int precision, T value) { + if (width == 0) { + return precision < 0 ? + FMT_SNPRINTF(buffer, size, format, value) : + FMT_SNPRINTF(buffer, size, format, precision, value); + } + return precision < 0 ? + FMT_SNPRINTF(buffer, size, format, width, value) : + FMT_SNPRINTF(buffer, size, format, width, precision, value); +} + +template +int internal::CharTraits::format_float( + wchar_t *buffer, std::size_t size, const wchar_t *format, + unsigned width, int precision, T value) { + if (width == 0) { + return precision < 0 ? + FMT_SWPRINTF(buffer, size, format, value) : + FMT_SWPRINTF(buffer, size, format, precision, value); + } + return precision < 0 ? + FMT_SWPRINTF(buffer, size, format, width, value) : + FMT_SWPRINTF(buffer, size, format, width, precision, value); +} + +template +const char internal::BasicData::DIGITS[] = + "0001020304050607080910111213141516171819" + "2021222324252627282930313233343536373839" + "4041424344454647484950515253545556575859" + "6061626364656667686970717273747576777879" + "8081828384858687888990919293949596979899"; + +#define FMT_POWERS_OF_10(factor) \ + factor * 10, \ + factor * 100, \ + factor * 1000, \ + factor * 10000, \ + factor * 100000, \ + factor * 1000000, \ + factor * 10000000, \ + factor * 100000000, \ + factor * 1000000000 + +template +const uint32_t internal::BasicData::POWERS_OF_10_32[] = { + 0, FMT_POWERS_OF_10(1) +}; + +template +const uint64_t internal::BasicData::POWERS_OF_10_64[] = { + 0, + FMT_POWERS_OF_10(1), + FMT_POWERS_OF_10(ULongLong(1000000000)), + // Multiply several constants instead of using a single long long constant + // to avoid warnings about C++98 not supporting long long. + ULongLong(1000000000) * ULongLong(1000000000) * 10 +}; + +FMT_FUNC void internal::report_unknown_type(char code, const char *type) { + (void)type; + if (std::isprint(static_cast(code))) { + FMT_THROW(FormatError( + format("unknown format code '{}' for {}", code, type))); + } + FMT_THROW(FormatError( + format("unknown format code '\\x{:02x}' for {}", + static_cast(code), type))); +} + +#if FMT_USE_WINDOWS_H + +FMT_FUNC internal::UTF8ToUTF16::UTF8ToUTF16(StringRef s) { + static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16"; + if (s.size() > INT_MAX) + FMT_THROW(WindowsError(ERROR_INVALID_PARAMETER, ERROR_MSG)); + int s_size = static_cast(s.size()); + int length = MultiByteToWideChar( + CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, FMT_NULL, 0); + if (length == 0) + FMT_THROW(WindowsError(GetLastError(), ERROR_MSG)); + buffer_.resize(length + 1); + length = MultiByteToWideChar( + CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length); + if (length == 0) + FMT_THROW(WindowsError(GetLastError(), ERROR_MSG)); + buffer_[length] = 0; +} + +FMT_FUNC internal::UTF16ToUTF8::UTF16ToUTF8(WStringRef s) { + if (int error_code = convert(s)) { + FMT_THROW(WindowsError(error_code, + "cannot convert string from UTF-16 to UTF-8")); + } +} + +FMT_FUNC int internal::UTF16ToUTF8::convert(WStringRef s) { + if (s.size() > INT_MAX) + return ERROR_INVALID_PARAMETER; + int s_size = static_cast(s.size()); + 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(); + buffer_[length] = 0; + return 0; +} + +FMT_FUNC void WindowsError::init( + int err_code, CStringRef format_str, ArgList args) { + error_code_ = err_code; + MemoryWriter w; + internal::format_windows_error(w, err_code, format(format_str, args)); + std::runtime_error &base = *this; + base = std::runtime_error(w.str()); +} + +FMT_FUNC void internal::format_windows_error( + Writer &out, int error_code, StringRef message) FMT_NOEXCEPT { + FMT_TRY { + MemoryBuffer buffer; + buffer.resize(INLINE_BUFFER_SIZE); + for (;;) { + wchar_t *system_message = &buffer[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(buffer.size()), FMT_NULL); + if (result != 0) { + UTF16ToUTF8 utf8_message; + if (utf8_message.convert(system_message) == ERROR_SUCCESS) { + out << message << ": " << utf8_message; + return; + } + break; + } + if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) + break; // Can't get error message, report error code instead. + buffer.resize(buffer.size() * 2); + } + } FMT_CATCH(...) {} + fmt::format_error_code(out, error_code, message); // 'fmt::' is for bcc32. +} + +#endif // FMT_USE_WINDOWS_H + +FMT_FUNC void format_system_error( + Writer &out, int error_code, StringRef message) FMT_NOEXCEPT { + FMT_TRY { + internal::MemoryBuffer buffer; + buffer.resize(internal::INLINE_BUFFER_SIZE); + for (;;) { + char *system_message = &buffer[0]; + int result = safe_strerror(error_code, system_message, buffer.size()); + if (result == 0) { + out << message << ": " << system_message; + return; + } + if (result != ERANGE) + break; // Can't get error message, report error code instead. + buffer.resize(buffer.size() * 2); + } + } FMT_CATCH(...) {} + fmt::format_error_code(out, error_code, message); // 'fmt::' is for bcc32. +} + +template +void internal::ArgMap::init(const ArgList &args) { + if (!map_.empty()) + return; + typedef internal::NamedArg NamedArg; + const NamedArg *named_arg = FMT_NULL; + bool use_values = + args.type(ArgList::MAX_PACKED_ARGS - 1) == internal::Arg::NONE; + if (use_values) { + for (unsigned i = 0;/*nothing*/; ++i) { + internal::Arg::Type arg_type = args.type(i); + switch (arg_type) { + case internal::Arg::NONE: + return; + case internal::Arg::NAMED_ARG: + named_arg = static_cast(args.values_[i].pointer); + map_.push_back(Pair(named_arg->name, *named_arg)); + break; + default: + /*nothing*/; + } + } + return; + } + for (unsigned i = 0; i != ArgList::MAX_PACKED_ARGS; ++i) { + internal::Arg::Type arg_type = args.type(i); + if (arg_type == internal::Arg::NAMED_ARG) { + named_arg = static_cast(args.args_[i].pointer); + map_.push_back(Pair(named_arg->name, *named_arg)); + } + } + for (unsigned i = ArgList::MAX_PACKED_ARGS;/*nothing*/; ++i) { + switch (args.args_[i].type) { + case internal::Arg::NONE: + return; + case internal::Arg::NAMED_ARG: + named_arg = static_cast(args.args_[i].pointer); + map_.push_back(Pair(named_arg->name, *named_arg)); + break; + default: + /*nothing*/; + } + } +} + +template +void internal::FixedBuffer::grow(std::size_t) { + FMT_THROW(std::runtime_error("buffer overflow")); +} + +FMT_FUNC internal::Arg internal::FormatterBase::do_get_arg( + unsigned arg_index, const char *&error) { + internal::Arg arg = args_[arg_index]; + switch (arg.type) { + case internal::Arg::NONE: + error = "argument index out of range"; + break; + case internal::Arg::NAMED_ARG: + arg = *static_cast(arg.pointer); + break; + default: + /*nothing*/; + } + return arg; +} + +FMT_FUNC void report_system_error( + int error_code, fmt::StringRef message) FMT_NOEXCEPT { + // 'fmt::' is for bcc32. + report_error(format_system_error, error_code, message); +} + +#if FMT_USE_WINDOWS_H +FMT_FUNC void report_windows_error( + int error_code, fmt::StringRef message) FMT_NOEXCEPT { + // 'fmt::' is for bcc32. + report_error(internal::format_windows_error, error_code, message); +} +#endif + +FMT_FUNC void print(std::FILE *f, CStringRef format_str, ArgList args) { + MemoryWriter w; + w.write(format_str, args); + std::fwrite(w.data(), 1, w.size(), f); +} + +FMT_FUNC void print(CStringRef format_str, ArgList args) { + print(stdout, format_str, args); +} + +FMT_FUNC void print_colored(Color c, CStringRef format, ArgList args) { + char escape[] = "\x1b[30m"; + escape[3] = static_cast('0' + c); + std::fputs(escape, stdout); + print(format, args); + std::fputs(RESET_COLOR, stdout); +} + +#ifndef FMT_HEADER_ONLY + +template struct internal::BasicData; + +// Explicit instantiations for char. + +template void internal::FixedBuffer::grow(std::size_t); + +template void internal::ArgMap::init(const ArgList &args); + +template FMT_API int internal::CharTraits::format_float( + char *buffer, std::size_t size, const char *format, + unsigned width, int precision, double value); + +template FMT_API int internal::CharTraits::format_float( + char *buffer, std::size_t size, const char *format, + unsigned width, int precision, long double value); + +// Explicit instantiations for wchar_t. + +template void internal::FixedBuffer::grow(std::size_t); + +template void internal::ArgMap::init(const ArgList &args); + +template FMT_API int internal::CharTraits::format_float( + wchar_t *buffer, std::size_t size, const wchar_t *format, + unsigned width, int precision, double value); + +template FMT_API int internal::CharTraits::format_float( + wchar_t *buffer, std::size_t size, const wchar_t *format, + unsigned width, int precision, long double value); + +#endif // FMT_HEADER_ONLY + +} // namespace fmt + +#ifdef _MSC_VER +# pragma warning(pop) +#endif diff --git a/src/main.cpp b/src/main.cpp index a08c0ee..d5227d6 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1,31 +1,78 @@ -// SIMPLE TEST - #include +#include #include -using namespace std; +#include "format.h" +//#include "format.cc" -void infinity_res_cheat(const Player &p) { - p.bank().add(Resource::CLAY, (size_t)-90); - p.bank().add(Resource::GRAIN, (size_t)-90); - p.bank().add(Resource::ORE, (size_t)-90); - p.bank().add(Resource::WOOD, (size_t)-90); - p.bank().add(Resource::WOOL, (size_t)-90); -} +using namespace std; + +void show_res_num(const Game &g, size_t num_player) { + fmt::print("bank res = {}\n", g.field().bank().resources()); + fmt::print("player res = {}\n", g.player(num_player).bank().resources()); +} + +void show_res_full(const string &name, const ResourcesHolder &bank) { + fmt::print("{}'s resources = ", name); + fmt::print("{0} ({1})", EnumInfo::resource_str(Resource::CLAY), bank.resources(Resource::CLAY)); + fmt::print("{0} ({1})", EnumInfo::resource_str(Resource::GRAIN), bank.resources(Resource::GRAIN)); + fmt::print("{0} ({1})", EnumInfo::resource_str(Resource::ORE), bank.resources(Resource::ORE)); + fmt::print("{0} ({1})", EnumInfo::resource_str(Resource::WOOD), bank.resources(Resource::WOOD)); + fmt::print("{0} ({1})\n", EnumInfo::resource_str(Resource::WOOL), bank.resources(Resource::WOOL)); +} + +void show_res_all(const Game &g) { + for (size_t i = 0; i < g.num_players(); i++) { + show_res_full(g.player(i).name(), g.player(i).bank()); + } + show_res_full("bank", g.field().bank()); +} + +void list_inf(const Game &g) { + for (size_t i = 0; i < g.num_players(); i++) { + for (size_t j = 0; j < g.player(i).num_roads(); j++) { + fmt::print("player {0} road {1}\n", g.player(i).name(), g.player(i).road(j).name()); + } + cout << endl; + for (size_t j = 0; j < g.player(i).num_towns(); j++) { + fmt::print("player {0} town {1}\n", g.player(i).name(), g.player(i).town(j).name()); + } + cout << endl; + for (size_t j = 0; j < g.player(i).num_cities(); j++) { + fmt::print("player {0} city {1}\n", g.player(i).name(), g.player(i).city(j).name()); + } + cout << endl; + } +} + +void spots(ThirdStageSubEngine &ts) { + auto r = ts.valid_road_spots(); + auto t = ts.valid_town_spots(); + auto c = ts.valid_city_spots(); + fmt::print("road spots:\n"); + for (auto &i: r) { + cout << i.first.str() << ' ' << EnumInfo::road_side_str(i.second) << endl; + } + fmt::print("town spots:\n"); + for (auto &i: t) { + cout << i.first.str() << ' ' << EnumInfo::cross_corner_str(i.second) << endl; + } + + fmt::print("city spots:\n"); + for (auto &i: c) { + cout << i.first.str() << ' ' << EnumInfo::cross_corner_str(i.second) << endl; + } +} int main() { try { GameEngine g; - - g.join_player("excess"); - g.join_player("ya tut mimo"); + g.join_player("a"); g.join_player("b"); - g.join_player("c"); - g.unjoin_player("ya tut mimo"); - g.unjoin_player("excess"); + g.join_player("c"); g.start_game(); @@ -50,6 +97,8 @@ int main() } } + //g.put_initial_infrastructure("a", "ata", Coord(0,-2), CrossCorner::BOTTOM, "ara", Coord(0,-3), RoadSide::RIGHT); + //g.put_initial_infrastructure("b", "bta", Coord(0,0), CrossCorner::TOP, "bra", Coord(0,0), RoadSide::UP); for (char c = 'a', i =-1,j=-1; c < 'd'; c++,i++,j++) { string player = "0", road = "0ra", town = "0ta"; road[0] = town[0] = c; @@ -64,16 +113,22 @@ int main() } g.make_dice("a", 11); - g.end_exchanges("a"); - - for(uint i = 0; i < g.game().num_players(); ++i) - infinity_res_cheat(g.game().player(i)); + g.end_exchanges("a"); + + + g.game().player(0).bank().add(Resource::CLAY, 90); + g.game().player(0).bank().add(Resource::GRAIN, 90); + g.game().player(0).bank().add(Resource::ORE, 90); + g.game().player(0).bank().add(Resource::WOOD, 90); + g.game().player(0).bank().add(Resource::WOOL, 90); g.build_road("a", "ard", Coord(-2,0), RoadSide::UP); g.build_road("a", "arc", Coord(-3,1), RoadSide::DOWN); g.build_road("a", "are", Coord(-3,0), RoadSide::RIGHT); g.build_road("a", "arf", Coord(-2,-1), RoadSide::UP); + show_res_num(g.game(),0); g.build_road("a", "arg", Coord(-2,0), RoadSide::DOWN); + show_res_num(g.game(),0); g.build_road("a", "arh", Coord(-2,1), RoadSide::DOWN); g.build_road("a", "ark", Coord(-1,0), RoadSide::UP); @@ -91,25 +146,21 @@ int main() g.build_city("a", "acd", Coord(0,0), CrossCorner::BOTTOM); g.build_town("a", "ata", Coord(-1,-2), CrossCorner::TOP); - g.build_town("a", "atb", Coord(-3,2), CrossCorner::BOTTOM); - - g.next_player("a"); - - g.make_dice("b", 2); - g.exchange_players_request("b", "c", {Resource::CLAY}, {Resource::GRAIN}); - g.exchange_players_accept("c", 0); - g.end_exchanges("b"); - g.next_player("b"); - - g.make_dice("c", 3); - g.end_exchanges("c"); - g.next_player("c"); - - g.make_dice("a", 10); - g.end_exchanges("a"); + g.build_town("a", "atb", Coord(-3,2), CrossCorner::BOTTOM); + g.build_city("a", "aca", Coord(-3,2),CrossCorner::BOTTOM); + //spots(g.ts()); + + fmt::print("score = {}", g.score("a")); + + fmt::print("\n{}\n", EnumInfo::game_stage_str(g.stage())); + fmt::print("OK!!!\n"); } catch (exception &e) { - cout << "EXCEPTION WAAAT: " << e.what() << endl; + fmt::print("EXCEPTION WAAAT: {}", e.what()); + } catch (size_t i) { + fmt::print("EXCEPTION INT = {}", i); } + + fmt::print("SUCCESS!!!\n"); }