Fixed header include problems.

This commit is contained in:
Kevin M. Godby 2016-02-24 21:26:18 -06:00
parent 24a1b23e3d
commit 196689f720
26 changed files with 360 additions and 291 deletions

View File

@ -15,12 +15,11 @@
// 3. will throw spdlog_ex upon log exceptions
// Upong destruction, logs all remaining messages in the queue before destructing..
#include <spdlog/common.h>
#include <spdlog/logger.h>
#include <chrono>
#include <functional>
#include "common.h"
#include "logger.h"
#include "spdlog.h"
namespace spdlog
{
@ -69,4 +68,5 @@ private:
}
#include "./details/async_logger_impl.h"
#include <spdlog/details/async_logger_impl.h>

View File

@ -14,17 +14,18 @@
#pragma once
#include <spdlog/common.h>
#include <spdlog/sinks/sink.h>
#include <spdlog/details/mpmc_bounded_q.h>
#include <spdlog/details/log_msg.h>
#include <spdlog/details/format.h>
#include <spdlog/details/os.h>
#include <spdlog/formatter.h>
#include <chrono>
#include <thread>
#include <functional>
#include "../common.h"
#include "../sinks/sink.h"
#include "./mpmc_bounded_q.h"
#include "./log_msg.h"
#include "./format.h"
#include "./os.h"
#include <vector>
namespace spdlog
{

View File

@ -8,7 +8,8 @@
// Async Logger implementation
// Use an async_sink (queue per logger) to perform the logging in a worker thread
#include "./async_log_helper.h"
#include <spdlog/details/async_log_helper.h>
#include <spdlog/async_logger.h>
template<class It>

View File

@ -10,13 +10,12 @@
// Can be set to auto flush on every line
// Throw spdlog_ex exception on errors
#include <spdlog/details/os.h>
#include <spdlog/details/log_msg.h>
#include <string>
#include <thread>
#include <chrono>
#include "os.h"
#include "log_msg.h"
namespace spdlog
{

View File

@ -1,201 +0,0 @@
//
// Copyright(c) 2015 Gabi Melman.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
//
#pragma once
#include <type_traits>
#include "../common.h"
#include "../logger.h"
// Line logger class - aggregates operator<< calls to fast ostream
// and logs upon destruction
namespace spdlog
{
namespace details
{
class line_logger
{
public:
line_logger(logger* callback_logger, level::level_enum msg_level, bool enabled):
_callback_logger(callback_logger),
_log_msg(msg_level),
_enabled(enabled)
{}
// No copy intended. Only move
line_logger(const line_logger& other) = delete;
line_logger& operator=(const line_logger&) = delete;
line_logger& operator=(line_logger&&) = delete;
line_logger(line_logger&& other) :
_callback_logger(other._callback_logger),
_log_msg(std::move(other._log_msg)),
_enabled(other._enabled)
{
other.disable();
}
//Log the log message using the callback logger
~line_logger()
{
if (_enabled)
{
#ifndef SPDLOG_NO_NAME
_log_msg.logger_name = _callback_logger->name();
#endif
#ifndef SPDLOG_NO_DATETIME
_log_msg.time = os::now();
#endif
#ifndef SPDLOG_NO_THREAD_ID
_log_msg.thread_id = os::thread_id();
#endif
_callback_logger->_log_msg(_log_msg);
}
}
//
// Support for format string with variadic args
//
void write(const char* what)
{
if (_enabled)
_log_msg.raw << what;
}
template <typename... Args>
void write(const char* fmt, const Args&... args)
{
if (!_enabled)
return;
try
{
_log_msg.raw.write(fmt, args...);
}
catch (const fmt::FormatError& e)
{
throw spdlog_ex(fmt::format("formatting error while processing format string '{}': {}", fmt, e.what()));
}
}
//
// Support for operator<<
//
line_logger& operator<<(const char* what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
line_logger& operator<<(const std::string& what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
line_logger& operator<<(int what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
line_logger& operator<<(unsigned int what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
line_logger& operator<<(long what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
line_logger& operator<<(unsigned long what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
line_logger& operator<<(long long what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
line_logger& operator<<(unsigned long long what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
line_logger& operator<<(double what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
line_logger& operator<<(long double what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
line_logger& operator<<(float what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
line_logger& operator<<(char what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
//Support user types which implements operator<<
template<typename T>
line_logger& operator<<(const T& what)
{
if (_enabled)
_log_msg.raw.write("{}", what);
return *this;
}
void disable()
{
_enabled = false;
}
bool is_enabled() const
{
return _enabled;
}
private:
logger* _callback_logger;
log_msg _log_msg;
bool _enabled;
};
} //Namespace details
} // Namespace spdlog

View File

@ -0,0 +1,78 @@
//
// Copyright(c) 2015 Gabi Melman.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
//
#pragma once
#include <spdlog/common.h>
#include <spdlog/details/log_msg.h>
#include <string>
// Line logger class - aggregates operator<< calls to fast ostream
// and logs upon destruction
namespace spdlog
{
// Forward declaration
class logger;
namespace details
{
class line_logger
{
public:
line_logger(logger* callback_logger, level::level_enum msg_level, bool enabled);
// No copy intended. Only move
line_logger(const line_logger& other) = delete;
line_logger& operator=(const line_logger&) = delete;
line_logger& operator=(line_logger&&) = delete;
line_logger(line_logger&& other);
//Log the log message using the callback logger
~line_logger();
//
// Support for format string with variadic args
//
void write(const char* what);
template <typename... Args>
void write(const char* fmt, const Args&... args);
//
// Support for operator<<
//
line_logger& operator<<(const char* what);
line_logger& operator<<(const std::string& what);
line_logger& operator<<(int what);
line_logger& operator<<(unsigned int what);
line_logger& operator<<(long what);
line_logger& operator<<(unsigned long what);
line_logger& operator<<(long long what);
line_logger& operator<<(unsigned long long what);
line_logger& operator<<(double what);
line_logger& operator<<(long double what);
line_logger& operator<<(float what);
line_logger& operator<<(char what);
//Support user types which implements operator<<
template<typename T>
line_logger& operator<<(const T& what);
void disable();
bool is_enabled() const;
private:
logger* _callback_logger;
log_msg _log_msg;
bool _enabled;
};
} //Namespace details
} // Namespace spdlog

View File

@ -0,0 +1,182 @@
//
// Copyright(c) 2015 Gabi Melman.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
//
#pragma once
#include <type_traits>
#include <spdlog/details/line_logger_fwd.h>
#include <spdlog/common.h>
#include <spdlog/logger.h>
// Line logger class - aggregates operator<< calls to fast ostream
// and logs upon destruction
inline spdlog::details::line_logger::line_logger(logger* callback_logger, level::level_enum msg_level, bool enabled):
_callback_logger(callback_logger),
_log_msg(msg_level),
_enabled(enabled)
{}
inline spdlog::details::line_logger::line_logger(line_logger&& other) :
_callback_logger(other._callback_logger),
_log_msg(std::move(other._log_msg)),
_enabled(other._enabled)
{
other.disable();
}
//Log the log message using the callback logger
inline spdlog::details::line_logger::~line_logger()
{
if (_enabled)
{
#ifndef SPDLOG_NO_NAME
_log_msg.logger_name = _callback_logger->name();
#endif
#ifndef SPDLOG_NO_DATETIME
_log_msg.time = os::now();
#endif
#ifndef SPDLOG_NO_THREAD_ID
_log_msg.thread_id = os::thread_id();
#endif
_callback_logger->_log_msg(_log_msg);
}
}
//
// Support for format string with variadic args
//
inline void spdlog::details::line_logger::write(const char* what)
{
if (_enabled)
_log_msg.raw << what;
}
template <typename... Args>
inline void spdlog::details::line_logger::write(const char* fmt, const Args&... args)
{
if (!_enabled)
return;
try
{
_log_msg.raw.write(fmt, args...);
}
catch (const fmt::FormatError& e)
{
throw spdlog_ex(fmt::format("formatting error while processing format string '{}': {}", fmt, e.what()));
}
}
//
// Support for operator<<
//
inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(const char* what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(const std::string& what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(int what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(unsigned int what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(long what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(unsigned long what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(long long what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(unsigned long long what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(double what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(long double what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(float what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(char what)
{
if (_enabled)
_log_msg.raw << what;
return *this;
}
//Support user types which implements operator<<
template<typename T>
inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(const T& what)
{
if (_enabled)
_log_msg.raw.write("{}", what);
return *this;
}
inline void spdlog::details::line_logger::disable()
{
_enabled = false;
}
inline bool spdlog::details::line_logger::is_enabled() const
{
return _enabled;
}

View File

@ -5,9 +5,10 @@
#pragma once
#include <spdlog/common.h>
#include <spdlog/details/format.h>
#include <thread>
#include "../common.h"
#include "./format.h"
namespace spdlog
{

View File

@ -5,7 +5,7 @@
#pragma once
#include "./line_logger.h"
#include <spdlog/logger.h>
// create logger with given name, sinks and the default pattern formatter
// all other ctors will call this one

View File

@ -43,8 +43,9 @@ Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#include <spdlog/common.h>
#include <atomic>
#include "../common.h"
namespace spdlog
{

View File

@ -4,6 +4,8 @@
//
#pragma once
#include <spdlog/common.h>
#include <string>
#include <cstdio>
#include <ctime>
@ -26,8 +28,6 @@
#include <thread>
#endif
#include "../common.h"
namespace spdlog
{
namespace details

View File

@ -5,16 +5,16 @@
#pragma once
#include <spdlog/formatter.h>
#include <spdlog/details/log_msg.h>
#include <spdlog/details/os.h>
#include <string>
#include <chrono>
#include <memory>
#include <vector>
#include <thread>
#include "../formatter.h"
#include "./log_msg.h"
#include "./os.h"
#include <mutex>
namespace spdlog
{

View File

@ -10,16 +10,16 @@
// If user requests a non existing logger, nullptr will be returned
// This class is thread safe
#include <spdlog/details/null_mutex.h>
#include <spdlog/logger.h>
#include <spdlog/async_logger.h>
#include <spdlog/common.h>
#include <string>
#include <mutex>
#include <unordered_map>
#include <functional>
#include "./null_mutex.h"
#include "../logger.h"
#include "../async_logger.h"
#include "../common.h"
namespace spdlog
{
namespace details

View File

@ -8,10 +8,11 @@
//
// Global registry functions
//
#include "registry.h"
#include "../sinks/file_sinks.h"
#include "../sinks/stdout_sinks.h"
#include "../sinks/syslog_sink.h"
#include <spdlog/spdlog.h>
#include <spdlog/details/registry.h>
#include <spdlog/sinks/file_sinks.h>
#include <spdlog/sinks/stdout_sinks.h>
#include <spdlog/sinks/syslog_sink.h>
inline void spdlog::register_logger(std::shared_ptr<logger> logger)
{

View File

@ -5,7 +5,10 @@
#pragma once
#include "details/log_msg.h"
#include <spdlog/details/log_msg.h>
#include <vector>
namespace spdlog
{
namespace details
@ -36,5 +39,5 @@ private:
};
}
#include "details/pattern_formatter_impl.h"
#include <spdlog/details/pattern_formatter_impl.h>

View File

@ -12,19 +12,16 @@
// 2. Format the message using the formatter function
// 3. Pass the formatted message to its sinks to performa the actual logging
#include <spdlog/sinks/base_sink.h>
#include <spdlog/common.h>
#include <spdlog/details/line_logger_fwd.h>
#include <vector>
#include <memory>
#include "sinks/base_sink.h"
#include "common.h"
namespace spdlog
{
namespace details
{
class line_logger;
}
class logger
{
public:
@ -110,4 +107,6 @@ protected:
};
}
#include "./details/logger_impl.h"
#include <spdlog/details/logger_impl.h>
#include <spdlog/details/line_logger_impl.h>

View File

@ -7,12 +7,13 @@
#if defined(__ANDROID__)
#include <mutex>
#include "base_sink.h"
#include "../details/null_mutex.h"
#include <spdlog/sinks/base_sink.h>
#include <spdlog/details/null_mutex.h>
#include <android/log.h>
#include <mutex>
namespace spdlog
{
namespace sinks

View File

@ -10,14 +10,14 @@
// all locking is taken care of here so no locking needed by the implementors..
//
#include <spdlog/sinks/sink.h>
#include <spdlog/formatter.h>
#include <spdlog/common.h>
#include <spdlog/details/log_msg.h>
#include <string>
#include <mutex>
#include <atomic>
#include "./sink.h"
#include "../formatter.h"
#include "../common.h"
#include "../details/log_msg.h"
namespace spdlog
{

View File

@ -5,16 +5,16 @@
#pragma once
#include <spdlog/details/log_msg.h>
#include <spdlog/details/null_mutex.h>
#include <spdlog/sinks/base_sink.h>
#include <spdlog/sinks/sink.h>
#include <algorithm>
#include <memory>
#include <mutex>
#include <list>
#include "../details/log_msg.h"
#include "../details/null_mutex.h"
#include "./base_sink.h"
#include "./sink.h"
namespace spdlog
{
namespace sinks

View File

@ -5,11 +5,12 @@
#pragma once
#include <spdlog/sinks/base_sink.h>
#include <spdlog/details/null_mutex.h>
#include <spdlog/details/file_helper.h>
#include <spdlog/details/format.h>
#include <mutex>
#include "base_sink.h"
#include "../details/null_mutex.h"
#include "../details/file_helper.h"
#include "../details/format.h"
namespace spdlog
{

View File

@ -4,10 +4,11 @@
//
#pragma once
#include <mutex>
#include "./base_sink.h"
#include "../details/null_mutex.h"
#include <spdlog/sinks/base_sink.h>
#include <spdlog/details/null_mutex.h>
#include <mutex>
namespace spdlog
{

View File

@ -5,13 +5,13 @@
#pragma once
#include <spdlog/details/null_mutex.h>
#include <spdlog/sinks/base_sink.h>
#include <ostream>
#include <mutex>
#include <memory>
#include "../details/null_mutex.h"
#include "./base_sink.h"
namespace spdlog
{
namespace sinks

View File

@ -6,7 +6,7 @@
#pragma once
#include "../details/log_msg.h"
#include <spdlog/details/log_msg.h>
namespace spdlog
{

View File

@ -5,10 +5,11 @@
#pragma once
#include <spdlog/sinks/ostream_sink.h>
#include <spdlog/details/null_mutex.h>
#include <iostream>
#include <mutex>
#include "./ostream_sink.h"
#include "../details/null_mutex.h"
namespace spdlog
{

View File

@ -7,14 +7,14 @@
#if defined(__linux__) || defined(__APPLE__)
#include <spdlog/sinks/sink.h>
#include <spdlog/common.h>
#include <spdlog/details/log_msg.h>
#include <array>
#include <string>
#include <syslog.h>
#include "./sink.h"
#include "../common.h"
#include "../details/log_msg.h"
namespace spdlog
{

View File

@ -8,9 +8,9 @@
#pragma once
#include "tweakme.h"
#include "common.h"
#include "logger.h"
#include <spdlog/tweakme.h>
#include <spdlog/common.h>
#include <spdlog/logger.h>
namespace spdlog
{
@ -132,4 +132,4 @@ void drop_all();
}
#include "details/spdlog_impl.h"
#include <spdlog/details/spdlog_impl.h>