mirrors/spdlog
1
0
Fork 0
mirror of https://github.com/gabime/spdlog.git synced 2024-12-25 10:01:33 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #111 from GreatFruitOmsk/master

Browse Source 
Add support for wchar_t on Windows
This commit is contained in:
Gabi Melman 2015-07-27 01:22:12 +03:00
commit 3632d01983
8 changed files with 85 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
include/spdlog/common.h
View File

@ -36,6 +36,15 @@
#define SPDLOG_NOEXCEPT throw() #define SPDLOG_NOEXCEPT throw()
#endif #endif
#if defined(WIN32) && defined(SPDLOG_USE_WCHAR)
typedef std::wstring tstring;
typedef wchar_t tchar;
#define S(s) L ## s
#else
#define S(s) s
typedef std::string tstring;
typedef char tchar;
#endif
namespace spdlog namespace spdlog
{ {

16
include/spdlog/details/file_helper.h
View File

@ -62,11 +62,11 @@ public:
} }
void open(const std::string& fname, bool truncate=false) void open(const tstring& fname, bool truncate=false)
{ {
close(); close();
const char* mode = truncate ? "wb" : "ab"; const tchar* mode = truncate ? S("wb") : S("ab");
_filename = fname; _filename = fname;
for (int tries = 0; tries < open_tries; ++tries) for (int tries = 0; tries < open_tries; ++tries)
{ {
@ -76,7 +76,7 @@ public:
std::this_thread::sleep_for(std::chrono::milliseconds(open_interval)); std::this_thread::sleep_for(std::chrono::milliseconds(open_interval));
} }
throw spdlog_ex("Failed opening file " + fname + " for writing"); throw spdlog_ex("Failed opening file for writing");
} }
void reopen(bool truncate) void reopen(bool truncate)
@ -106,22 +106,22 @@ public:
size_t size = msg.formatted.size(); size_t size = msg.formatted.size();
auto data = msg.formatted.data(); auto data = msg.formatted.data();
if(std::fwrite(data, 1, size, _fd) != size) if(std::fwrite(data, 1, size, _fd) != size)
throw spdlog_ex("Failed writing to file " + _filename); throw spdlog_ex("Failed writing to file");
if(_force_flush) if(_force_flush)
std::fflush(_fd); std::fflush(_fd);
} }
const std::string& filename() const const tstring& filename() const
{ {
return _filename; return _filename;
} }
static bool file_exists(const std::string& name) static bool file_exists(const tstring& name)
{ {
FILE* file; FILE* file;
if (!os::fopen_s(&file, name.c_str(), "r")) if (!os::fopen_s(&file, name.c_str(), S("r")))
{ {
fclose(file); fclose(file);
return true; return true;
@ -134,7 +134,7 @@ public:
private: private:
FILE* _fd; FILE* _fd;
std::string _filename; tstring _filename;
bool _force_flush; bool _force_flush;

6
include/spdlog/details/format.h
View File

@ -2638,6 +2638,12 @@ public:
typedef BasicMemoryWriter<char> MemoryWriter; typedef BasicMemoryWriter<char> MemoryWriter;
typedef BasicMemoryWriter<wchar_t> WMemoryWriter; typedef BasicMemoryWriter<wchar_t> WMemoryWriter;
#if defined(WIN32) && defined(SPDLOG_USE_WCHAR)
#define TMemoryWriter WMemoryWriter
#else
#define TMemoryWriter MemoryWriter
#endif
/** /**
\rst \rst
This class template provides operations for formatting and writing data This class template provides operations for formatting and writing data

24
include/spdlog/details/os.h
View File

@ -147,17 +147,37 @@ constexpr inline unsigned short eol_size()
#endif #endif
//fopen_s on non windows for writing //fopen_s on non windows for writing
inline int fopen_s(FILE** fp, const std::string& filename, const char* mode) inline int fopen_s(FILE** fp, const tstring& filename, const tchar* mode)
{ {
#ifdef _WIN32 #if defined(WIN32)
#if defined(SPDLOG_USE_WCHAR)
*fp = _wfsopen((filename.c_str()), mode, _SH_DENYWR);
#else
*fp = _fsopen((filename.c_str()), mode, _SH_DENYWR); *fp = _fsopen((filename.c_str()), mode, _SH_DENYWR);
#endif
return *fp == nullptr; return *fp == nullptr;
#else #else
*fp = fopen((filename.c_str()), mode); *fp = fopen((filename.c_str()), mode);
return *fp == nullptr; return *fp == nullptr;
#endif #endif
}
inline int remove(const tchar* filename)
{
#if defined(WIN32) && defined(SPDLOG_USE_WCHAR)
return _wremove(filename);
#else
return std::remove(filename);
#endif
}
inline int rename(const tchar* filename1, const tchar* filename2)
{
#if defined(WIN32) && defined(SPDLOG_USE_WCHAR)
return _wrename(filename1, filename2);
#else
return std::rename(filename1, filename2);
#endif
} }
//Return utc offset in minutes or -1 on failure //Return utc offset in minutes or -1 on failure

16
include/spdlog/details/spdlog_impl.h
View File

@ -48,24 +48,24 @@ inline void spdlog::drop(const std::string &name)
} }
// Create multi/single threaded rotating file logger // Create multi/single threaded rotating file logger
inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_mt(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, bool force_flush) inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_mt(const std::string& logger_name, const tstring& filename, size_t max_file_size, size_t max_files, bool force_flush)
{ {
return create<spdlog::sinks::rotating_file_sink_mt>(logger_name, filename, "txt", max_file_size, max_files, force_flush); return create<spdlog::sinks::rotating_file_sink_mt>(logger_name, filename, S("txt"), max_file_size, max_files, force_flush);
} }
inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_st(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, bool force_flush) inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_st(const std::string& logger_name, const tstring& filename, size_t max_file_size, size_t max_files, bool force_flush)
{ {
return create<spdlog::sinks::rotating_file_sink_st>(logger_name, filename, "txt", max_file_size, max_files, force_flush); return create<spdlog::sinks::rotating_file_sink_st>(logger_name, filename, S("txt"), max_file_size, max_files, force_flush);
} }
// Create file logger which creates new file at midnight): // Create file logger which creates new file at midnight):
inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_mt(const std::string& logger_name, const std::string& filename, int hour, int minute, bool force_flush) inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_mt(const std::string& logger_name, const tstring& filename, int hour, int minute, bool force_flush)
{ {
return create<spdlog::sinks::daily_file_sink_mt>(logger_name, filename, "txt", hour, minute, force_flush); return create<spdlog::sinks::daily_file_sink_mt>(logger_name, filename, S("txt"), hour, minute, force_flush);
} }
inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_st(const std::string& logger_name, const std::string& filename, int hour, int minute, bool force_flush) inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_st(const std::string& logger_name, const tstring& filename, int hour, int minute, bool force_flush)
{ {
return create<spdlog::sinks::daily_file_sink_st>(logger_name, filename, "txt", hour, minute, force_flush); return create<spdlog::sinks::daily_file_sink_st>(logger_name, filename, S("txt"), hour, minute, force_flush);
} }

41
include/spdlog/sinks/file_sinks.h
View File

@ -29,6 +29,7 @@
#include "../details/null_mutex.h" #include "../details/null_mutex.h"
#include "../details/file_helper.h" #include "../details/file_helper.h"
#include "../details/format.h" #include "../details/format.h"
#include "../details/os.h"
namespace spdlog namespace spdlog
{ {
@ -71,7 +72,7 @@ template<class Mutex>
class rotating_file_sink : public base_sink < Mutex > class rotating_file_sink : public base_sink < Mutex >
{ {
public: public:
rotating_file_sink(const std::string &base_filename, const std::string &extension, rotating_file_sink(const tstring &base_filename, const tstring &extension,
std::size_t max_size, std::size_t max_files, std::size_t max_size, std::size_t max_files,
bool force_flush = false) : bool force_flush = false) :
_base_filename(base_filename), _base_filename(base_filename),
@ -102,13 +103,13 @@ protected:
} }
private: private:
static std::string calc_filename(const std::string& filename, std::size_t index, const std::string& extension) static tstring calc_filename(const tstring& filename, std::size_t index, const tstring& extension)
{ {
fmt::MemoryWriter w; fmt::TMemoryWriter w;
if (index) if (index)
w.write("{}.{}.{}", filename, index, extension); w.write(S("{}.{}.{}"), filename, index, extension);
else else
w.write("{}.{}", filename, extension); w.write(S("{}.{}"), filename, extension);
return w.str(); return w.str();
} }
@ -123,25 +124,25 @@ private:
_file_helper.close(); _file_helper.close();
for (auto i = _max_files; i > 0; --i) for (auto i = _max_files; i > 0; --i)
{ {
std::string src = calc_filename(_base_filename, i - 1, _extension); tstring src = calc_filename(_base_filename, i - 1, _extension);
std::string target = calc_filename(_base_filename, i, _extension); tstring target = calc_filename(_base_filename, i, _extension);
if (details::file_helper::file_exists(target)) if (details::file_helper::file_exists(target))
{ {
if (std::remove(target.c_str()) != 0) if (details::os::remove(target.c_str()) != 0)
{ {
throw spdlog_ex("rotating_file_sink: failed removing " + target); throw spdlog_ex("rotating_file_sink: failed removing");
} }
} }
if (details::file_helper::file_exists(src) && std::rename(src.c_str(), target.c_str())) if (details::file_helper::file_exists(src) && details::os::rename(src.c_str(), target.c_str()))
{ {
throw spdlog_ex("rotating_file_sink: failed renaming " + src + " to " + target); throw spdlog_ex("rotating_file_sink: failed renaming");
} }
} }
_file_helper.reopen(true); _file_helper.reopen(true);
} }
std::string _base_filename; tstring _base_filename;
std::string _extension; tstring _extension;
std::size_t _max_size; std::size_t _max_size;
std::size_t _max_files; std::size_t _max_files;
std::size_t _current_size; std::size_t _current_size;
@ -160,8 +161,8 @@ class daily_file_sink :public base_sink < Mutex >
public: public:
//create daily file sink which rotates on given time //create daily file sink which rotates on given time
daily_file_sink( daily_file_sink(
const std::string& base_filename, const tstring& base_filename,
const std::string& extension, const tstring& extension,
int rotation_hour, int rotation_hour,
int rotation_minute, int rotation_minute,
bool force_flush = false) : _base_filename(base_filename), bool force_flush = false) : _base_filename(base_filename),
@ -210,16 +211,16 @@ private:
} }
//Create filename for the form basename.YYYY-MM-DD.extension //Create filename for the form basename.YYYY-MM-DD.extension
static std::string calc_filename(const std::string& basename, const std::string& extension) static tstring calc_filename(const tstring& basename, const tstring& extension)
{ {
std::tm tm = spdlog::details::os::localtime(); std::tm tm = spdlog::details::os::localtime();
fmt::MemoryWriter w; fmt::TMemoryWriter w;
w.write("{}_{:04d}-{:02d}-{:02d}_{:02d}-{:02d}.{}", basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, extension); w.write(S("{}_{:04d}-{:02d}-{:02d}_{:02d}-{:02d}.{}"), basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, extension);
return w.str(); return w.str();
} }
std::string _base_filename; tstring _base_filename;
std::string _extension; tstring _extension;
int _rotation_h; int _rotation_h;
int _rotation_m; int _rotation_m;
std::chrono::system_clock::time_point _rotation_tp; std::chrono::system_clock::time_point _rotation_tp;

8
include/spdlog/spdlog.h
View File

@ -76,14 +76,14 @@ void set_sync_mode();
// //
// Create and register multi/single threaded rotating file logger // Create and register multi/single threaded rotating file logger
// //
std::shared_ptr<logger> rotating_logger_mt(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, bool force_flush = false); std::shared_ptr<logger> rotating_logger_mt(const std::string& logger_name, const tstring& filename, size_t max_file_size, size_t max_files, bool force_flush = false);
std::shared_ptr<logger> rotating_logger_st(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, bool force_flush = false); std::shared_ptr<logger> rotating_logger_st(const std::string& logger_name, const tstring& filename, size_t max_file_size, size_t max_files, bool force_flush = false);
// //
// Create file logger which creates new file on the given time (default in midnight): // Create file logger which creates new file on the given time (default in midnight):
// //
std::shared_ptr<logger> daily_logger_mt(const std::string& logger_name, const std::string& filename, int hour=0, int minute=0, bool force_flush = false); std::shared_ptr<logger> daily_logger_mt(const std::string& logger_name, const tstring& filename, int hour=0, int minute=0, bool force_flush = false);
std::shared_ptr<logger> daily_logger_st(const std::string& logger_name, const std::string& filename, int hour=0, int minute=0, bool force_flush = false); std::shared_ptr<logger> daily_logger_st(const std::string& logger_name, const tstring& filename, int hour=0, int minute=0, bool force_flush = false);
// //

6
include/spdlog/tweakme.h
View File

@ -72,3 +72,9 @@
// Note that upon creating a logger the registry is modified by spdlog.. // Note that upon creating a logger the registry is modified by spdlog..
// #define SPDLOG_NO_REGISTRY_MUTEX // #define SPDLOG_NO_REGISTRY_MUTEX
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Uncomment to enable usage of wchar_t for file names on Windows.
// #define SPDLOG_USE_WCHAR
///////////////////////////////////////////////////////////////////////////////