TeaSpeak/spdlog
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

wchar filenames support - minor improvements

Browse Source
This commit is contained in:
gabime 2016-04-10 00:02:19 +03:00
parent 23200b08bb
commit 19dae96985
7 changed files with 62 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
include/spdlog/common.h
View File

@ -11,7 +11,7 @@
#include <memory> #include <memory>
#include <exception> #include <exception>
#if defined(_WIN32) && defined(SPDLOG_USE_WCHAR) #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
#include <codecvt> #include <codecvt>
#include <locale> #include <locale>
#endif #endif
@ -100,22 +100,22 @@ private:
}; };
#if defined(_WIN32) && defined(SPDLOG_USE_WCHAR) //
// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
//
#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
#define SPDLOG_FILENAME_T(s) L ## s #define SPDLOG_FILENAME_T(s) L ## s
typedef std::wstring filename_str_t; using filename_t = std::wstring;
typedef wchar_t filename_char_t; inline std::string filename_to_str(const filename_t& filename)
inline std::string filename_to_bytes(const filename_str_t& filename)
{ {
std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> c; std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> c;
return c.to_bytes(filename); return c.to_bytes(filename);
} }
#else #else
#define SPDLOG_FILENAME_T(s) s #define SPDLOG_FILENAME_T(s) s
typedef std::string filename_str_t; using filename_t = std::string;
typedef char filename_char_t;
inline std::string filename_to_bytes(const filename_str_t& filename) inline std::string filename_to_str(const filename_t& filename)
{ {
return filename; return filename;
} }

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

@ -43,11 +43,11 @@ public:
} }
void open(const filename_str_t& fname, bool truncate = false) void open(const filename_t& fname, bool truncate = false)
{ {
close(); close();
const filename_char_t* mode = truncate ? SPDLOG_FILENAME_T("wb") : SPDLOG_FILENAME_T("ab"); auto *mode = truncate ? SPDLOG_FILENAME_T("wb") : SPDLOG_FILENAME_T("ab");
_filename = fname; _filename = fname;
for (int tries = 0; tries < open_tries; ++tries) for (int tries = 0; tries < open_tries; ++tries)
{ {
@ -57,7 +57,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 " + filename_to_bytes(_filename) + " for writing"); throw spdlog_ex("Failed opening file " + filename_to_str(_filename) + " for writing");
} }
void reopen(bool truncate) void reopen(bool truncate)
@ -88,7 +88,7 @@ public:
size_t msg_size = msg.formatted.size(); size_t msg_size = msg.formatted.size();
auto data = msg.formatted.data(); auto data = msg.formatted.data();
if (std::fwrite(data, 1, msg_size, _fd) != msg_size) if (std::fwrite(data, 1, msg_size, _fd) != msg_size)
throw spdlog_ex("Failed writing to file " + filename_to_bytes(_filename)); throw spdlog_ex("Failed writing to file " + filename_to_str(_filename));
if (_force_flush) if (_force_flush)
std::fflush(_fd); std::fflush(_fd);
@ -98,19 +98,19 @@ public:
long size() long size()
{ {
if (!_fd) if (!_fd)
throw spdlog_ex("Cannot use size() on closed file " + filename_to_bytes(_filename)); throw spdlog_ex("Cannot use size() on closed file " + filename_to_str(_filename));
auto pos = ftell(_fd); auto pos = ftell(_fd);
if (fseek(_fd, 0, SEEK_END) != 0) if (fseek(_fd, 0, SEEK_END) != 0)
throw spdlog_ex("fseek failed on file " + filename_to_bytes(_filename)); throw spdlog_ex("fseek failed on file " + filename_to_str(_filename));
auto file_size = ftell(_fd); auto file_size = ftell(_fd);
if(fseek(_fd, pos, SEEK_SET) !=0) if(fseek(_fd, pos, SEEK_SET) !=0)
throw spdlog_ex("fseek failed on file " + filename_to_bytes(_filename)); throw spdlog_ex("fseek failed on file " + filename_to_str(_filename));
if (file_size == -1) if (file_size == -1)
throw spdlog_ex("ftell failed on file " + filename_to_bytes(_filename)); throw spdlog_ex("ftell failed on file " + filename_to_str(_filename));
return file_size; return file_size;
@ -118,12 +118,12 @@ public:
} }
const filename_str_t& filename() const const filename_t& filename() const
{ {
return _filename; return _filename;
} }
static bool file_exists(const filename_str_t& name) static bool file_exists(const filename_t& name)
{ {
return os::file_exists(name); return os::file_exists(name);
@ -133,7 +133,7 @@ public:
private: private:
FILE* _fd; FILE* _fd;
filename_str_t _filename; filename_t _filename;
bool _force_flush; bool _force_flush;

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

@ -137,45 +137,45 @@ 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 filename_str_t& filename, const filename_char_t* mode) inline int fopen_s(FILE** fp, const filename_t& filename, const filename_t& mode)
{ {
#ifdef _WIN32 #ifdef _WIN32
#ifdef SPDLOG_USE_WCHAR #ifdef SPDLOG_WCHAR_FILENAMES
*fp = _wfsopen((filename.c_str()), mode, _SH_DENYWR); *fp = _wfsopen((filename.c_str()), mode.c_str(), _SH_DENYWR);
#else #else
*fp = _fsopen((filename.c_str()), mode, _SH_DENYWR); *fp = _fsopen((filename.c_str()), mode.c_str(), _SH_DENYWR);
#endif #endif
return *fp == nullptr; return *fp == nullptr;
#else #else
*fp = fopen((filename.c_str()), mode); *fp = fopen((filename.c_str()), mode.c_str());
return *fp == nullptr; return *fp == nullptr;
#endif #endif
} }
inline int remove(const filename_char_t* filename) inline int remove(const filename_t &filename)
{ {
#if defined(_WIN32) && defined(SPDLOG_USE_WCHAR) #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
return _wremove(filename); return _wremove(filename.c_str());
#else #else
return std::remove(filename); return std::remove(filename.c_str());
#endif #endif
} }
inline int rename(const filename_char_t* filename1, const filename_char_t* filename2) inline int rename(const filename_t& filename1, const filename_t& filename2)
{ {
#if defined(_WIN32) && defined(SPDLOG_USE_WCHAR) #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
return _wrename(filename1, filename2); return _wrename(filename1.c_str(), filename2.c_str());
#else #else
return std::rename(filename1, filename2); return std::rename(filename1.c_str(), filename2.c_str());
#endif #endif
} }
//Return if file exists //Return if file exists
inline bool file_exists(const filename_str_t& filename) inline bool file_exists(const filename_t& filename)
{ {
#ifdef _WIN32 #ifdef _WIN32
#ifdef SPDLOG_USE_WCHAR #ifdef SPDLOG_WCHAR_FILENAMES
auto attribs = GetFileAttributesW(filename.c_str()); auto attribs = GetFileAttributesW(filename.c_str());
#else #else
auto attribs = GetFileAttributesA(filename.c_str()); auto attribs = GetFileAttributesA(filename.c_str());

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

@ -36,23 +36,23 @@ 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 filename_str_t& 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 filename_t& filename, size_t max_file_size, size_t max_files, bool force_flush)
{ {
return create<spdlog::sinks::rotating_file_sink_mt>(logger_name, filename, SPDLOG_FILENAME_T("txt"), max_file_size, max_files, force_flush); return create<spdlog::sinks::rotating_file_sink_mt>(logger_name, filename, SPDLOG_FILENAME_T("txt"), max_file_size, max_files, force_flush);
} }
inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_st(const std::string& logger_name, const filename_str_t& 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 filename_t& filename, size_t max_file_size, size_t max_files, bool force_flush)
{ {
return create<spdlog::sinks::rotating_file_sink_st>(logger_name, filename, SPDLOG_FILENAME_T("txt"), max_file_size, max_files, force_flush); return create<spdlog::sinks::rotating_file_sink_st>(logger_name, filename, SPDLOG_FILENAME_T("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 filename_str_t& filename, int hour, int minute, bool force_flush) inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_mt(const std::string& logger_name, const filename_t& filename, int hour, int minute, bool force_flush)
{ {
return create<spdlog::sinks::daily_file_sink_mt>(logger_name, filename, SPDLOG_FILENAME_T("txt"), hour, minute, force_flush); return create<spdlog::sinks::daily_file_sink_mt>(logger_name, filename, SPDLOG_FILENAME_T("txt"), hour, minute, force_flush);
} }
inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_st(const std::string& logger_name, const filename_str_t& filename, int hour, int minute, bool force_flush) inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_st(const std::string& logger_name, const filename_t& filename, int hour, int minute, bool force_flush)
{ {
return create<spdlog::sinks::daily_file_sink_st>(logger_name, filename, SPDLOG_FILENAME_T("txt"), hour, minute, force_flush); return create<spdlog::sinks::daily_file_sink_st>(logger_name, filename, SPDLOG_FILENAME_T("txt"), hour, minute, force_flush);
} }

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

@ -28,7 +28,7 @@ template<class Mutex>
class simple_file_sink : public base_sink < Mutex > class simple_file_sink : public base_sink < Mutex >
{ {
public: public:
explicit simple_file_sink(const filename_str_t &filename, explicit simple_file_sink(const filename_t &filename,
bool force_flush = false) : bool force_flush = false) :
_file_helper(force_flush) _file_helper(force_flush)
{ {
@ -58,7 +58,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 filename_str_t &base_filename, const filename_str_t &extension, rotating_file_sink(const filename_t &base_filename, const filename_t &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),
@ -90,9 +90,9 @@ protected:
} }
private: private:
static filename_str_t calc_filename(const filename_str_t& filename, std::size_t index, const filename_str_t& extension) static filename_t calc_filename(const filename_t& filename, std::size_t index, const filename_t& extension)
{ {
std::conditional<std::is_same<filename_char_t, char>::value, fmt::MemoryWriter, fmt::WMemoryWriter>::type w; std::conditional<std::is_same<filename_t::value_type, char>::value, fmt::MemoryWriter, fmt::WMemoryWriter>::type w;
if (index) if (index)
w.write(SPDLOG_FILENAME_T("{}.{}.{}"), filename, index, extension); w.write(SPDLOG_FILENAME_T("{}.{}.{}"), filename, index, extension);
else else
@ -111,25 +111,25 @@ private:
_file_helper.close(); _file_helper.close();
for (auto i = _max_files; i > 0; --i) for (auto i = _max_files; i > 0; --i)
{ {
filename_str_t src = calc_filename(_base_filename, i - 1, _extension); filename_t src = calc_filename(_base_filename, i - 1, _extension);
filename_str_t target = calc_filename(_base_filename, i, _extension); filename_t target = calc_filename(_base_filename, i, _extension);
if (details::file_helper::file_exists(target)) if (details::file_helper::file_exists(target))
{ {
if (details::os::remove(target.c_str()) != 0) if (details::os::remove(target) != 0)
{ {
throw spdlog_ex("rotating_file_sink: failed removing " + filename_to_bytes(target)); throw spdlog_ex("rotating_file_sink: failed removing " + filename_to_str(target));
} }
} }
if (details::file_helper::file_exists(src) && details::os::rename(src.c_str(), target.c_str())) if (details::file_helper::file_exists(src) && details::os::rename(src, target))
{ {
throw spdlog_ex("rotating_file_sink: failed renaming " + filename_to_bytes(src) + " to " + filename_to_bytes(target)); throw spdlog_ex("rotating_file_sink: failed renaming " + filename_to_str(src) + " to " + filename_to_str(target));
} }
} }
_file_helper.reopen(true); _file_helper.reopen(true);
} }
filename_str_t _base_filename; filename_t _base_filename;
filename_str_t _extension; filename_t _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;
@ -148,8 +148,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 filename_str_t& base_filename, const filename_t& base_filename,
const filename_str_t& extension, const filename_t& 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),
@ -198,16 +198,16 @@ private:
} }
//Create filename for the form basename.YYYY-MM-DD.extension //Create filename for the form basename.YYYY-MM-DD.extension
static filename_str_t calc_filename(const filename_str_t& basename, const filename_str_t& extension) static filename_t calc_filename(const filename_t& basename, const filename_t& extension)
{ {
std::tm tm = spdlog::details::os::localtime(); std::tm tm = spdlog::details::os::localtime();
std::conditional<std::is_same<filename_char_t, char>::value, fmt::MemoryWriter, fmt::WMemoryWriter>::type w; std::conditional<std::is_same<filename_t::value_type, char>::value, fmt::MemoryWriter, fmt::WMemoryWriter>::type w;
w.write(SPDLOG_FILENAME_T("{}_{: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(SPDLOG_FILENAME_T("{}_{: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();
} }
filename_str_t _base_filename; filename_t _base_filename;
filename_str_t _extension; filename_t _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

@ -61,14 +61,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 filename_str_t& 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 filename_t& 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 filename_str_t& 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 filename_t& 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 filename_str_t& filename, int hour=0, int minute=0, bool force_flush = false); std::shared_ptr<logger> daily_logger_mt(const std::string& logger_name, const filename_t& filename, int hour=0, int minute=0, bool force_flush = false);
std::shared_ptr<logger> daily_logger_st(const std::string& logger_name, const filename_str_t& filename, int hour=0, int minute=0, bool force_flush = false); std::shared_ptr<logger> daily_logger_st(const std::string& logger_name, const filename_t& filename, int hour=0, int minute=0, bool force_flush = false);
// //
// Create and register stdout/stderr loggers // Create and register stdout/stderr loggers

2
include/spdlog/tweakme.h
View File

@ -55,5 +55,5 @@
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// Uncomment to enable usage of wchar_t for file names on Windows. // Uncomment to enable usage of wchar_t for file names on Windows.
// #define SPDLOG_USE_WCHAR // #define SPDLOG_WCHAR_FILENAMES
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////