Fixed header include problems.

include/spdlog/async_logger.h

@@ -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>
+

include/spdlog/details/async_log_helper.h

@@ -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 <vector>
-#include "../common.h"
-#include "../sinks/sink.h"
-#include "./mpmc_bounded_q.h"
-#include "./log_msg.h"
-#include "./format.h"
-#include "./os.h"
-
 
 namespace spdlog
 {

include/spdlog/details/async_logger_impl.h

@@ -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>

include/spdlog/details/file_helper.h

@@ -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
 {

include/spdlog/details/line_logger.h

@@ -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

include/spdlog/details/line_logger_fwd.h

@@ -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
+

include/spdlog/details/line_logger_impl.h

@@ -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;
+}
+

include/spdlog/details/log_msg.h

@@ -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
 {

include/spdlog/details/logger_impl.h

@@ -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

include/spdlog/details/mpmc_bounded_q.h

@@ -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
 {

include/spdlog/details/os.h

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

include/spdlog/details/pattern_formatter_impl.h

@@ -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 <mutex>
-
-#include "../formatter.h"
-#include "./log_msg.h"
-#include "./os.h"
 
 namespace spdlog
 {

include/spdlog/details/registry.h

@@ -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

include/spdlog/details/spdlog_impl.h

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

include/spdlog/formatter.h

@@ -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>
 

include/spdlog/logger.h

@@ -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<vector>
+#include <spdlog/sinks/base_sink.h>
-#include<memory>
+#include <spdlog/common.h>
-#include "sinks/base_sink.h"
+#include <spdlog/details/line_logger_fwd.h>
-#include "common.h"
+
+#include <vector>
+#include <memory>
 
 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>
+

include/spdlog/sinks/android_sink.h

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

include/spdlog/sinks/base_sink.h

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

include/spdlog/sinks/dist_sink.h

@@ -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

include/spdlog/sinks/file_sinks.h

@@ -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
 {

include/spdlog/sinks/null_sink.h

@@ -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
 {

include/spdlog/sinks/ostream_sink.h

@@ -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

include/spdlog/sinks/sink.h

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

include/spdlog/sinks/stdout_sinks.h

@@ -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
 {

include/spdlog/sinks/syslog_sink.h

@@ -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
 {

include/spdlog/spdlog.h

@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include "tweakme.h"
+#include <spdlog/tweakme.h>
-#include "common.h"
+#include <spdlog/common.h>
-#include "logger.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>