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

astyle

Browse Source
This commit is contained in:
gabime 2014-03-31 02:31:26 +03:00
parent 4696132cd5
commit bde2d24abb
6 changed files with 83 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
example/example.cpp
View File

@ -21,24 +21,24 @@ int main(int argc, char* argv[])
const unsigned int howmany = argc <= 1 ? 1000000:atoi(argv[1]); const unsigned int howmany = argc <= 1 ? 1000000:atoi(argv[1]);
logger cout_logger ("", sinks::stdout_sink()); logger cout_logger ("", sinks::stdout_sink());
cout_logger.set_min_level(c11log::level::TRACE); cout_logger.set_min_level(c11log::level::TRACE);
cout_logger.info() << "Hello " << "man" << 123; cout_logger.info() << "Hello " << "man" << 123;
cout_logger.trace("This is very nice! ") << "Yes gabi.." << ":)"; cout_logger.trace("This is very nice! ") << "Yes gabi.." << ":)";
auto fsink = std::make_shared<sinks::rotating_file_sink>("log", "txt", 1024*1024*50 , 5, 0); auto fsink = std::make_shared<sinks::rotating_file_sink>("log", "txt", 1024*1024*50 , 5, 0);
auto nullsink = sinks::null_sink::get(); auto nullsink = sinks::null_sink::get();
//auto as = std::make_shared<sinks::async_sink>(1000); //auto as = std::make_shared<sinks::async_sink>(1000);
//as->add_sink(sinks::null_sink::get()); //as->add_sink(sinks::null_sink::get());
logger my_logger ("my_logger", nullsink); logger my_logger ("my_logger", nullsink);
auto start = system_clock::now(); auto start = system_clock::now();
for(unsigned int i = 1; i <= howmany ; ++i) for(unsigned int i = 1; i <= howmany ; ++i)
my_logger.info("Hello logger: "); my_logger.info("Hello logger: ");
//auto s = howmany - as->q().size(); //auto s = howmany - as->q().size();
auto s = howmany; auto s = howmany;
auto delta = system_clock::now() - start; auto delta = system_clock::now() - start;
auto delta_d = duration_cast<duration<double>> (delta).count(); auto delta_d = duration_cast<duration<double>> (delta).count();

2
include/c11log/common_types.h
View File

@ -12,7 +12,7 @@ namespace level
{ {
typedef enum typedef enum
{ {
TRACE, TRACE,
DEBUG, DEBUG,
INFO, INFO,
WARNING, WARNING,

2
include/c11log/details/blocking_queue.h
View File

@ -20,7 +20,7 @@ class blocking_queue
{ {
public: public:
using queue_type = std::queue<T>; using queue_type = std::queue<T>;
using item_type = T; using item_type = T;
using size_type = typename queue_type::size_type; using size_type = typename queue_type::size_type;
using clock = std::chrono::system_clock; using clock = std::chrono::system_clock;

14
include/c11log/details/line_logger.h
View File

@ -21,7 +21,7 @@ public:
_log_msg(msg_level), _log_msg(msg_level),
_oss(), _oss(),
_enabled(enabled), _enabled(enabled),
_empty(true) _empty(true)
{ {
if(enabled) if(enabled)
{ {
@ -49,7 +49,7 @@ public:
~line_logger() ~line_logger()
{ {
//only if enabled and not empty //only if enabled and not empty
if (!_empty) if (!_empty)
{ {
_oss << os::eol(); _oss << os::eol();
@ -58,14 +58,14 @@ public:
} }
} }
template<typename T> template<typename T>
void write(const T& what) void write(const T& what)
{ {
if (_enabled) if (_enabled)
{ {
_oss << what; _oss << what;
_empty = false; _empty = false;
} }
} }
template<typename T> template<typename T>
@ -82,7 +82,7 @@ private:
log_msg _log_msg; log_msg _log_msg;
details::stack_oss _oss; details::stack_oss _oss;
bool _enabled; bool _enabled;
bool _empty; bool _empty;
}; };
} //Namespace details } //Namespace details
} // Namespace c11log } // Namespace c11log

78
include/c11log/logger.h
View File

@ -23,7 +23,6 @@ class line_logger;
template<std::size_t> class fast_buf; template<std::size_t> class fast_buf;
} }
class logger class logger
{ {
public: public:
@ -50,22 +49,21 @@ public:
const std::string& get_name() const; const std::string& get_name() const;
bool should_log(c11log::level::level_enum) const; bool should_log(c11log::level::level_enum) const;
template<typename T> details::line_logger trace(const T&); template<typename T> details::line_logger trace(const T&);
template<typename T> details::line_logger debug(const T&); template<typename T> details::line_logger debug(const T&);
template<typename T> details::line_logger info(const T&); template<typename T> details::line_logger info(const T&);
template<typename T> details::line_logger warn(const T&); template<typename T> details::line_logger warn(const T&);
template<typename T> details::line_logger error(const T&); template<typename T> details::line_logger error(const T&);
template<typename T> details::line_logger critical(const T&); template<typename T> details::line_logger critical(const T&);
template<typename T> details::line_logger fatal(const T&); template<typename T> details::line_logger fatal(const T&);
details::line_logger trace();
details::line_logger trace(); details::line_logger debug();
details::line_logger debug(); details::line_logger info();
details::line_logger info(); details::line_logger warn();
details::line_logger warn(); details::line_logger error();
details::line_logger error(); details::line_logger critical();
details::line_logger critical(); details::line_logger fatal();
details::line_logger fatal();
private: private:
@ -112,80 +110,80 @@ inline c11log::logger::logger(const std::string& name, sink_ptr sink, formatter_
template<typename T> template<typename T>
inline c11log::details::line_logger c11log::logger::trace(const T& msg) inline c11log::details::line_logger c11log::logger::trace(const T& msg)
{ {
details::line_logger l(this, level::TRACE, should_log(level::TRACE)); details::line_logger l(this, level::TRACE, should_log(level::TRACE));
l.write(msg); l.write(msg);
return l; return l;
} }
template<typename T> template<typename T>
inline c11log::details::line_logger c11log::logger::debug(const T& msg) inline c11log::details::line_logger c11log::logger::debug(const T& msg)
{ {
details::line_logger l(this, level::DEBUG, should_log(level::DEBUG)); details::line_logger l(this, level::DEBUG, should_log(level::DEBUG));
l.write(msg); l.write(msg);
return l; return l;
} }
template<typename T> template<typename T>
inline c11log::details::line_logger c11log::logger::info(const T& msg) inline c11log::details::line_logger c11log::logger::info(const T& msg)
{ {
details::line_logger l(this, level::INFO, should_log(level::INFO)); details::line_logger l(this, level::INFO, should_log(level::INFO));
l.write(msg); l.write(msg);
return l; return l;
} }
template<typename T> template<typename T>
inline c11log::details::line_logger c11log::logger::warn(const T& msg) inline c11log::details::line_logger c11log::logger::warn(const T& msg)
{ {
details::line_logger l(this, level::WARNING, should_log(level::WARNING)); details::line_logger l(this, level::WARNING, should_log(level::WARNING));
l.write(msg); l.write(msg);
return l; return l;
} }
template<typename T> template<typename T>
inline c11log::details::line_logger c11log::logger::critical(const T& msg) inline c11log::details::line_logger c11log::logger::critical(const T& msg)
{ {
details::line_logger l(this, level::CRITICAL, should_log(level::CRITICAL)); details::line_logger l(this, level::CRITICAL, should_log(level::CRITICAL));
l.write(msg); l.write(msg);
return l; return l;
} }
template<typename T> template<typename T>
inline c11log::details::line_logger c11log::logger::fatal(const T& msg) inline c11log::details::line_logger c11log::logger::fatal(const T& msg)
{ {
details::line_logger l(this, level::FATAL, should_log(level::FATAL)); details::line_logger l(this, level::FATAL, should_log(level::FATAL));
l.write(msg); l.write(msg);
return l; return l;
} }
inline c11log::details::line_logger c11log::logger::trace() inline c11log::details::line_logger c11log::logger::trace()
{ {
return details::line_logger(this, level::TRACE, should_log(level::TRACE)); return details::line_logger(this, level::TRACE, should_log(level::TRACE));
} }
inline c11log::details::line_logger c11log::logger::debug() inline c11log::details::line_logger c11log::logger::debug()
{ {
return details::line_logger(this, level::DEBUG, should_log(level::DEBUG)); return details::line_logger(this, level::DEBUG, should_log(level::DEBUG));
} }
inline c11log::details::line_logger c11log::logger::info() inline c11log::details::line_logger c11log::logger::info()
{ {
return details::line_logger(this, level::INFO, should_log(level::INFO)); return details::line_logger(this, level::INFO, should_log(level::INFO));
} }
inline c11log::details::line_logger c11log::logger::warn() inline c11log::details::line_logger c11log::logger::warn()
{ {
return details::line_logger(this, level::WARNING, should_log(level::WARNING)); return details::line_logger(this, level::WARNING, should_log(level::WARNING));
} }
inline c11log::details::line_logger c11log::logger::critical() inline c11log::details::line_logger c11log::logger::critical()
{ {
return details::line_logger(this, level::CRITICAL, should_log(level::CRITICAL)); return details::line_logger(this, level::CRITICAL, should_log(level::CRITICAL));
} }
inline c11log::details::line_logger c11log::logger::fatal() inline c11log::details::line_logger c11log::logger::fatal()
{ {
return details::line_logger(this, level::FATAL, should_log(level::FATAL)); return details::line_logger(this, level::FATAL, should_log(level::FATAL));
} }

54
include/c11log/sinks/async_sink.h
View File

@ -20,8 +20,8 @@ namespace sinks
static void msg_deleter(details::log_msg* msg_to_delete) static void msg_deleter(details::log_msg* msg_to_delete)
{ {
delete []msg_to_delete->msg_buf.first; delete []msg_to_delete->msg_buf.first;
delete msg_to_delete; delete msg_to_delete;
} }
class async_sink : public base_sink class async_sink : public base_sink
@ -33,12 +33,12 @@ public:
explicit async_sink(const queue_type::size_type max_queue_size); explicit async_sink(const queue_type::size_type max_queue_size);
//Stop logging and join the back thread //Stop logging and join the back thread
// TODO: limit with timeout of the join and kill it afterwards? // TODO: limit with timeout of the join and kill it afterwards?
~async_sink(); ~async_sink();
void add_sink(logger::sink_ptr sink); void add_sink(logger::sink_ptr sink);
void remove_sink(logger::sink_ptr sink_ptr); void remove_sink(logger::sink_ptr sink_ptr);
queue_type& q(); queue_type& q();
//Wait to remaining items (if any) in the queue to be written and shutdown //Wait to remaining items (if any) in the queue to be written and shutdown
void shutdown(const std::chrono::milliseconds& timeout); void shutdown(const std::chrono::milliseconds& timeout);
@ -54,7 +54,7 @@ private:
std::thread _back_thread; std::thread _back_thread;
//Clear all remaining messages(if any), stop the _back_thread and join it //Clear all remaining messages(if any), stop the _back_thread and join it
void _shutdown(); void _shutdown();
std::mutex _shutdown_mutex; std::mutex _shutdown_mutex;
}; };
} }
} }
@ -78,17 +78,17 @@ inline c11log::sinks::async_sink::~async_sink()
inline void c11log::sinks::async_sink::_sink_it(const details::log_msg& msg) inline void c11log::sinks::async_sink::_sink_it(const details::log_msg& msg)
{ {
auto msg_size = msg.msg_buf.second; auto msg_size = msg.msg_buf.second;
if(!_active || !msg_size) if(!_active || !msg_size)
return; return;
//re allocate on the heap the (stack based) message //re allocate on the heap the (stack based) message
auto new_msg = new details::log_msg(msg); auto new_msg = new details::log_msg(msg);
char *buf = new char[msg_size]; char *buf = new char[msg_size];
std::memcpy(buf, msg.msg_buf.first, msg_size); std::memcpy(buf, msg.msg_buf.first, msg_size);
new_msg->msg_buf = bufpair_t(buf, msg_size); new_msg->msg_buf = bufpair_t(buf, msg_size);
// Create unique_ptr with custom deleter and push it // Create unique_ptr with custom deleter and push it
queue_type::item_type new_shared_msg(new_msg, msg_deleter); queue_type::item_type new_shared_msg(new_msg, msg_deleter);
_q.push(std::move(new_shared_msg)); _q.push(std::move(new_shared_msg));
} }
@ -103,8 +103,8 @@ inline void c11log::sinks::async_sink::_thread_loop()
for (auto &sink : _sinks) for (auto &sink : _sinks)
{ {
sink->log(*msg); sink->log(*msg);
if(!_active) if(!_active)
break; break;
} }
} }
} }
@ -122,31 +122,31 @@ inline void c11log::sinks::async_sink::remove_sink(logger::sink_ptr sink_ptr)
inline c11log::sinks::async_sink::queue_type& c11log::sinks::async_sink::q() inline c11log::sinks::async_sink::queue_type& c11log::sinks::async_sink::q()
{ {
return _q; return _q;
} }
inline void c11log::sinks::async_sink::shutdown(const std::chrono::milliseconds& timeout) inline void c11log::sinks::async_sink::shutdown(const std::chrono::milliseconds& timeout)
{ {
if(timeout > std::chrono::milliseconds::zero()) if(timeout > std::chrono::milliseconds::zero())
{ {
auto until = log_clock::now() + timeout; auto until = log_clock::now() + timeout;
while (_q.size() > 0 && log_clock::now() < until) while (_q.size() > 0 && log_clock::now() < until)
{ {
std::this_thread::sleep_for(std::chrono::milliseconds(2)); std::this_thread::sleep_for(std::chrono::milliseconds(2));
} }
} }
_shutdown(); _shutdown();
} }
inline void c11log::sinks::async_sink::_shutdown() inline void c11log::sinks::async_sink::_shutdown()
{ {
std::lock_guard<std::mutex> guard(_shutdown_mutex); std::lock_guard<std::mutex> guard(_shutdown_mutex);
if(_active) if(_active)
{ {
_active = false; _active = false;
if (_back_thread.joinable()) if (_back_thread.joinable())
_back_thread.join(); _back_thread.join();
} }
} }