{

std::string outfile = infile + GZ_SUFFIX;

gzFile out = gzopen(outfile.c_str(), "wb6f");

if (!out)

return false;

typedef typename std::remove_pointer<gzFile>::type gzFileType;

std::unique_ptr<gzFileType, decltype(&gzclose)> gz_closer(out, &gzclose);

FILE* in = fopen(infile.c_str(), "rb");

if (!in)

return false;

std::unique_ptr<FILE, decltype(&fclose)> FILE_closer(in, &fclose);

char buf[BUFLEN];

int len;

for (;;) {

len = (int)fread(buf, 1, sizeof(buf), in);

if (ferror(in))

return false;

if (len == 0)

break;

int total = 0;

int ret;

while (total < len) {

ret = gzwrite(out, buf + total, (unsigned)len - total);

if (ret <= 0) {

return false; // detail error information see gzerror(out, &ret);

}

total += ret;

}

}

return true;

{

#if defined(WIN32) || defined(_WIN32)

thread_local int64_t system_start_time = 0;

thread_local int64_t system_current_time = 0;

thread_local uint32_t last_time = 0;

auto tmp = timeGetTime();

if (system_start_time == 0) {

LOGGING_FT nt_time;

GetSystemTimeAsFileTime(&(nt_time.ft_struct));

int64_t tim = (__int64)((nt_time.ft_scalar - aux::epoch) / (__int64)10000);

system_start_time = tim - tmp;

}

system_current_time += (tmp - last_time);

last_time = tmp;

return system_start_time + system_current_time;

#elif defined(__linux__) || defined(__APPLE__)

struct timeval tv;

gettimeofday(&tv, NULL);

return ((int64_t)tv.tv_sec * 1000000 + tv.tv_usec) / 1000;

#endif

{

static constexpr uint8_t utf8d[] = {

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 00..1f

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 20..3f

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 40..5f

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 60..7f

1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, // 80..9f

7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, // a0..bf

8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, // c0..df

0xa,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x4,0x3,0x3, // e0..ef

0xb,0x6,0x6,0x6,0x5,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8, // f0..ff

0x0,0x1,0x2,0x3,0x5,0x8,0x7,0x1,0x1,0x1,0x4,0x6,0x1,0x1,0x1,0x1, // s0..s0

1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,0,1,1,1,1,1,1, // s1..s2

1,2,1,1,1,1,1,2,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1, // s3..s4

1,2,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,3,1,1,1,1,1,1, // s5..s6

1,3,1,1,1,1,1,3,1,3,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // s7..s8

};

uint32_t type = utf8d[byte];

*codep = (*state != 0) ?

(byte & 0x3fu) | (*codep << 6) :

(0xff >> type) & (byte);

*state = utf8d[256 + *state * 16 + type];

return *state;

{

uint32_t codepoint;

uint32_t state = 0;

size_t count = 0;

uint8_t* s = (uint8_t*)str.c_str();

for (count = 0; *s; ++s)

if (!decode(&state, &codepoint, *s))

count += 1;

return state == 0;

{

int c, i, ix, n, j;

for (i = 0, ix = static_cast<int>(str.size()); i < ix; i++)

{

c = (unsigned char)str[i];

//if (c==0x09 || c==0x0a || c==0x0d || (0x20 <= c && c <= 0x7e) ) n = 0; // is_printable_ascii

if (0x00 <= c && c <= 0x7f) n = 0; // 0bbbbbbb

else if ((c & 0xE0) == 0xC0) n = 1; // 110bbbbb

else if (c == 0xed && i < (ix - 1) && ((unsigned char)str[i + 1] & 0xa0) == 0xa0)

return false; // U+d800 to U+dfff

else if ((c & 0xF0) == 0xE0) n = 2; // 1110bbbb

else if ((c & 0xF8) == 0xF0) n = 3; // 11110bbb

//else if (($c & 0xFC) == 0xF8) n=4; // 111110bb //byte 5, unnecessary in 4 byte UTF-8

//else if (($c & 0xFE) == 0xFC) n=5; // 1111110b //byte 6, unnecessary in 4 byte UTF-8

else return false;

for (j = 0; j < n && i < ix; j++) // n bytes matching 10bbbbbb follow ?

{

if ((++i == ix) || (((unsigned char)str[i] & 0xC0) != 0x80))

return false;

}

}

return true;

{

std::locale sys_locale("");

const wchar_t* data_from = src.c_str();

const wchar_t* data_from_end = src.c_str() + src.size();

const wchar_t* data_from_next = 0;

int wchar_size = 4;

std::unique_ptr<char> buffer(new char[(src.size() + 1) * wchar_size]);

char* data_to = buffer.get();

char* data_to_end = data_to + (src.size() + 1) * wchar_size;

char* data_to_next = 0;

memset(data_to, 0, (src.size() + 1) * wchar_size);

typedef std::codecvt<wchar_t, char, mbstate_t> convert_facet;

mbstate_t out_state;

auto result = std::use_facet<convert_facet>(sys_locale).out(

out_state, data_from, data_from_end, data_from_next,

data_to, data_to_end, data_to_next);

if (result == convert_facet::ok)

{

str = data_to;

return true;

}

return false;

{

std::locale sys_locale("");

const char* data_from = src.c_str();

const char* data_from_end = src.c_str() + src.size();

const char* data_from_next = 0;

std::unique_ptr<wchar_t> buffer(new wchar_t[src.size() + 1]);

wchar_t* data_to = buffer.get();

wchar_t* data_to_end = data_to + src.size() + 1;

wchar_t* data_to_next = 0;

wmemset(data_to, 0, src.size() + 1);

typedef std::codecvt<wchar_t, char, mbstate_t> convert_facet;

mbstate_t in_state;

auto result = std::use_facet<convert_facet>(sys_locale).in(

in_state, data_from, data_from_end, data_from_next,

data_to, data_to_end, data_to_next);

if (result == convert_facet::ok)

{

wstr = data_to;

return true;

}

return false;

{

if (!aux::utf8_check_is_valid(str))

{

std::wstring wres;

if (aux::string_wide(str, wres))

return boost::nowide::narrow(wres);

}

return str;

{

std::string ret;

std::time_t rawtime = time / 1000;

struct tm* ptm = std::localtime(&rawtime);

if (!ptm)

return { ret, ptm };

char buffer[1024];

std::sprintf(buffer, "%04d-%02d-%02d %02d:%02d:%02d.%03d",

ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday,

ptm->tm_hour, ptm->tm_min, ptm->tm_sec, (int)(time % 1000));

ret = buffer;

return { ret, ptm };

auto_logger_file()

{

m_log_path = m_log_path / (LOG_APPNAME + std::string(".log"));

boost::system::error_code ignore_ec;

if (!boost::filesystem::exists(m_log_path, ignore_ec))

boost::filesystem::create_directories(boost::filesystem::path(m_log_path).branch_path(), ignore_ec);

}

~auto_logger_file()

{

}

typedef boost::shared_ptr<std::ofstream> ofstream_ptr;

void open(const char* path)

{

m_log_path = path;

boost::system::error_code ignore_ec;

if (!boost::filesystem::exists(m_log_path, ignore_ec))

boost::filesystem::create_directories(boost::filesystem::path(m_log_path).branch_path(), ignore_ec);

}

std::string log_path() const

{

return m_log_path.string();

}

void write(int64_t time, const char* str, std::streamsize size)

{

boost::ignore_unused(time);

#ifdef LOGGING_COMPRESS_LOGS

bool condition = false;

auto hours = time / 1000 / 3600;

auto last_hours = m_last_time / 1000 / 3600;

if (LOG_MAXFILE_SIZE > 0)

condition = true;

if (last_hours != hours && LOG_MAXFILE_SIZE < 0)

condition = true;

while (condition) {

if (m_last_time == -1) {

m_last_time = time;

break;

}

auto [ts, ptm] = aux::time_to_string(m_last_time);

boost::ignore_unused(ts);

m_ofstream->close();

m_ofstream.reset();

auto logpath = boost::filesystem::path(m_log_path).branch_path();

boost::filesystem::path filename;

if (LOG_MAXFILE_SIZE <= 0) {

auto logfile = fmt::format("{:04d}{:02d}{:02d}-{:02d}.log",

ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour);

filename = logpath / logfile;

} else {

auto utc_time = std::mktime(ptm);

auto logfile = fmt::format("{:04d}{:02d}{:02d}-{}.log",

ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday, utc_time);

filename = logpath / logfile;

}

m_last_time = time;

boost::system::error_code ec;

if (!boost::filesystem::copy_file(m_log_path, filename, ec))

break;

boost::filesystem::resize_file(m_log_path, 0, ec);

m_log_size = 0;

auto fn = filename.string();

boost::async(boost::launch::async, [this, fn]() {

std::string file = fn;

boost::system::error_code ignore_ec;

boost::mutex& m = compress::compress_lock();

boost::lock_guard<boost::mutex> lock(m);

if (!compress::do_compress_gz(fn)) {

file = fn + compress::GZ_SUFFIX;

boost::filesystem::remove(file, ignore_ec);

if (ignore_ec)

std::cout << "delete log failed: " << file

<< ", error code: " << ignore_ec.message() << std::endl;

}

else {

boost::filesystem::remove(fn, ignore_ec);

}

});

break;

}

#endif

if (!m_ofstream) {

m_ofstream.reset(new std::ofstream);

m_ofstream->open(m_log_path.string().c_str(), std::ios_base::out | std::ios_base::app);

m_ofstream->sync_with_stdio(false);

}

if (m_ofstream->is_open()) {

m_log_size += size;

m_ofstream->write(str, size);

m_ofstream->flush();

}

}

boost::filesystem::path m_log_path{"./logs"};

ofstream_ptr m_ofstream;

int64_t m_last_time{-1};

std::size_t m_log_size{0};

{

#ifdef WIN32

HANDLE handle_stdout = GetStdHandle(STD_OUTPUT_HANDLE);

CONSOLE_SCREEN_BUFFER_INFO csbi;

GetConsoleScreenBufferInfo(handle_stdout, &csbi);

if (level == LOGGER_INFO_STR)

SetConsoleTextAttribute(handle_stdout, FOREGROUND_GREEN);

else if (level == LOGGER_DEBUG_STR)

SetConsoleTextAttribute(handle_stdout, FOREGROUND_GREEN | FOREGROUND_INTENSITY);

else if (level == LOGGER_WARN_STR)

SetConsoleTextAttribute(handle_stdout, FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY);

else if (level == LOGGER_ERR_STR)

SetConsoleTextAttribute(handle_stdout, FOREGROUND_RED | FOREGROUND_INTENSITY);

std::wstring wstr = boost::nowide::widen(prefix);

WriteConsoleW(handle_stdout, wstr.data(), (DWORD)wstr.size(), nullptr, nullptr);

SetConsoleTextAttribute(handle_stdout, FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE);

wstr = boost::nowide::widen(message);

WriteConsoleW(handle_stdout, wstr.data(), (DWORD)wstr.size(), nullptr, nullptr);

SetConsoleTextAttribute(handle_stdout, csbi.wAttributes);

#else

fmt::memory_buffer out;

if (level == LOGGER_INFO_STR)

fmt::format_to(out, "\033[32m{}\033[0m{}", prefix, message);

else if (level == LOGGER_DEBUG_STR)

fmt::format_to(out, "\033[1;32m{}\033[0m{}", prefix, message);

else if (level == LOGGER_WARN_STR)

fmt::format_to(out, "\033[1;33m{}\033[0m{}", prefix, message);

else if (level == LOGGER_ERR_STR)

fmt::format_to(out, "\033[1;31m{}\033[0m{}", prefix, message);

std::cout << fmt::to_string(out);

std::cout.flush();

#endif

{

if (level == LOGGER_INFO_STR)

sd_journal_print(LOG_INFO, "%s", message.c_str());

else if (level == LOGGER_DEBUG_STR)

sd_journal_print(LOG_DEBUG, "%s", message.c_str());

else if (level == LOGGER_WARN_STR)

sd_journal_print(LOG_WARNING, "%s", message.c_str());

else if (level == LOGGER_ERR_STR)

sd_journal_print(LOG_ERR, "%s", message.c_str());

std::string message, bool disable_cout = false)

{

(void)disable_cout;

LOGGER_LOCKS_();

auto [ts, ptm] = aux::time_to_string(time);

boost::ignore_unused(ptm);

std::string prefix = ts + std::string(" [") + level + std::string("]: ");

std::string tmp = message + "\n";

std::string whole = prefix + tmp;

#ifdef __ANDROID__

if (level == LOGGER_INFO_STR)

__android_log_print(ANDROID_LOG_INFO, "LOGGING", "%s", whole.c_str());

else if (level == LOGGER_DEBUG_STR)

__android_log_print(ANDROID_LOG_DEBUG, "LOGGING", "%s", whole.c_str());

else if (level == LOGGER_WARN_STR)

__android_log_print(ANDROID_LOG_WARN, "LOGGING", "%s", whole.c_str());

else if (level == LOGGER_ERR_STR)

__android_log_print(ANDROID_LOG_ERROR, "LOGGING", "%s", whole.c_str());

else

__android_log_print(ANDROID_LOG_DEFAULT, "LOGGING", "%s", whole.c_str());

return;

#endif

#ifndef DISABLE_WRITE_LOGGING

util::aux::writer_single<util::auto_logger_file>().write(time, whole.c_str(), whole.size());

#endif // !DISABLE_WRITE_LOGGING

LOGGER_DBG_VIEW_(whole);

#ifndef DISABLE_LOGGER_TO_CONSOLE

if (!disable_cout)

output_console(level, prefix, tmp);

#endif

#ifdef USE_SYSTEMD_LOGGING

output_systemd(level, message);

#endif // USE_SYSTEMD_LOGGING

public:

logger_internal()

{

}

~logger_internal()

{

if (m_main_thread.joinable()) {

if (!m_io_context.stopped())

m_io_context.stop();

m_main_thread.join();

}

}

public:

void start()

{

m_main_thread = boost::thread(boost::bind(&logger_internal::main_thread, this));

}

void stop()

{

if (!m_io_context.stopped())

m_io_context.stop();

}

void post_log(std::string level,

std::string message, bool disable_cout = false)

{

m_io_context.post(boost::bind(&logger_writer, aux::gettime(),

level, message, disable_cout));

}

private:

void main_thread()

{

boost::asio::io_context::work work(m_io_context);

try {

m_io_context.run();

} catch (std::exception&) {}

}

private:

boost::asio::io_context m_io_context;

boost::thread m_main_thread;

{

auto_logger_file& file = aux::writer_single<util::auto_logger_file>();

if (!path.empty())

file.open(path.c_str());

auto& log_obj = fetch_log_obj();

if (use_async && !log_obj) {

log_obj.reset(new aux::logger_internal());

log_obj->start();

}

{

auto_logger_file& file = aux::writer_single<util::auto_logger_file>();

return file.log_path();

{

auto& log_obj = fetch_log_obj();

if (log_obj) {

log_obj->stop();

log_obj.reset();

}

logger(std::string& level, bool disable_cout = false)

: level_(level)

, m_disable_cout(disable_cout)

{

if (!logging_flag())

return;

}

~logger()

{

if (!logging_flag())

return;

std::string message = aux::string_utf8(fmt::to_string(out_));

if (fetch_log_obj())

fetch_log_obj()->post_log(level_, message, m_disable_cout);

else

logger_writer(aux::gettime(), level_, message, m_disable_cout);

}

template <class T>

inline logger& strcat_impl(T const& v)

{

if (!logging_flag())

return *this;

fmt::format_to(out_, "{}", v);

return *this;

}

inline logger& operator<<(bool v)

{

return strcat_impl(v);

}

inline logger& operator<<(short v)

{

return strcat_impl(v);

}

inline logger& operator<<(unsigned short v)

{

return strcat_impl(v);

}

inline logger& operator<<(int v)

{

return strcat_impl(v);

}

inline logger& operator<<(unsigned int v)

{

return strcat_impl(v);

}

inline logger& operator<<(unsigned long long v)

{

return strcat_impl(v);

}

inline logger& operator<<(long v)

{

return strcat_impl(v);

}

inline logger& operator<<(long long v)

{

return strcat_impl(v);

}

inline logger& operator<<(float v)

{

return strcat_impl(v);

}

inline logger& operator<<(double v)

{

return strcat_impl(v);

}

inline logger& operator<<(long double v)

{

return strcat_impl(v);

}

inline logger& operator<<(unsigned long int v)

{

return strcat_impl(v);

}

inline logger& operator<<(const std::string& v)

{

return strcat_impl(v);

}

inline logger& operator<<(const char* v)

{

return strcat_impl(v);

}

inline logger& operator<<(const void *v)

{

if (!logging_flag())

return *this;

fmt::format_to(out_, "{:#010x}", (std::size_t)v);

return *this;

}

inline logger& operator<<(const boost::posix_time::ptime& p)

{

if (!logging_flag())

return *this;

if (!p.is_not_a_date_time())

{

auto date = p.date().year_month_day();

auto time = p.time_of_day();

fmt::format_to(out_, "{:04}", date.year);

fmt::format_to(out_, "-{:02}", date.month.as_number());

fmt::format_to(out_, "-{:02}", date.day.as_number());

fmt::format_to(out_, " {:02}", time.hours());

fmt::format_to(out_, ":{:02}", time.minutes());

fmt::format_to(out_, ":{:02}", time.seconds());

auto ms = time.total_milliseconds() % 1000; // milliseconds.

if (ms != 0)

fmt::format_to(out_, ".{:03}", ms);

}

else

{

fmt::format_to(out_, "NOT A DATE TIME");

}

return *this;

}

fmt::memory_buffer out_;

std::string& level_;

bool m_disable_cout;

template <class T>

empty_logger& operator<<(T const&/*v*/)

{

return *this;

}