BinaryLogger.hpp

Go to the documentation of this file.

 
#pragma once
 
#ifndef NUMCPP_NO_USE_BOOST
 
#include <algorithm>
#include <filesystem>
#include <fstream>
#include <stdexcept>
#include <string>
#include <string_view>
#include <type_traits>
#include <typeinfo>
 
#include "boost/algorithm/string.hpp"
#include "boost/core/demangle.hpp"
 
namespace nc::logger
{
    namespace detail
    {
        namespace type_traits
        {
            template<typename DataType>
            using serialize_t = decltype(std::declval<DataType>().serialize());
 
            template<typename DataType, typename = std::void_t<>>
            class has_serialize : std::false_type
            {
            public:
                static constexpr bool value = false;
            };
 
            template<typename DataType>
            class has_serialize<DataType,
                                std::void_t<std::enable_if_t<std::is_same_v<serialize_t<DataType>, std::string>, int>>>
            {
            public:
                static constexpr bool value = true;
            };
 
            template<typename DataType>
            inline constexpr bool has_serialize_v = has_serialize<DataType>::value;
        } // namespace type_traits
 
        template<typename DataType>
        class BinaryDataLogger
        {
        public:
            using value_type      = DataType;
            using const_pointer   = const DataType* const;
            using const_reference = const DataType&;
 
            // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays, hicpp-avoid-c-arrays, modernize-avoid-c-arrays)
            static constexpr char LOG_EXT[]                      = ".log";
            static constexpr auto DATA_ELEMENT_SIZE              = sizeof(value_type);
            static constexpr auto DATE_TYPE_HAS_SERIALIZE_METHOD = type_traits::has_serialize_v<value_type>;
 
            BinaryDataLogger() { }
 
            explicit BinaryDataLogger(std::filesystem::path outputDir)
            {
                setOutputDir(outputDir);
            }
 
            explicit BinaryDataLogger(std::string_view outputDir) :
                BinaryDataLogger(std::filesystem::path(outputDir))
            {
            }
 
            ~BinaryDataLogger()
            {
                ofile_.close();
            }
 
            // explicitly delete
            BinaryDataLogger(const BinaryDataLogger&)            = delete;
            BinaryDataLogger(BinaryDataLogger&&)                 = delete;
            BinaryDataLogger& operator=(const BinaryDataLogger&) = delete;
            BinaryDataLogger& operator=(BinaryDataLogger&&)      = delete;
 
            const std::filesystem::path& filepath() const noexcept
            {
                return filepath_;
            }
 
            void setOutputDir(std::filesystem::path outputDir)
            {
                if (std::filesystem::is_directory(outputDir))
                {
                    auto dataTypeName = boost::core::demangle(typeid(DataType).name());
                    boost::algorithm::replace_all(dataTypeName, "::", "_");
                    boost::algorithm::replace_all(dataTypeName, "<", "_");
                    boost::algorithm::replace_all(dataTypeName, ">", "_");
                    const auto filename = std::filesystem::path(dataTypeName).replace_extension(LOG_EXT);
                    filepath_           = std::filesystem::canonical(outputDir) / filename;
 
                    ofile_ = std::ofstream(filepath_.c_str(), std::ios::out | std::ios::binary);
                    if (!ofile_.good())
                    {
                        throw std::runtime_error("Unable to open the log file:\n\t" + filepath_.string());
                    }
                }
                else
                {
                    throw std::runtime_error("The provided output log directory is not valid:\n\t" +
                                             outputDir.string());
                }
            }
 
            void setOutputDir(std::string_view outputDir)
            {
                setOutputDir(std::filesystem::path(outputDir));
            }
 
            void enable() noexcept
            {
                enabled_ = true;
            }
 
            void disable() noexcept
            {
                enabled_ = false;
            }
 
            bool isEnabled() noexcept
            {
                return enabled_;
            }
 
            void flush()
            {
                ofile_.flush();
            }
 
            void log(const_reference dataElement)
            {
                if (!enabled_)
                {
                    return;
                }
 
                if (filepath_.empty())
                {
                    throw std::runtime_error("The output log directory does not exist");
                }
 
                if constexpr (DATE_TYPE_HAS_SERIALIZE_METHOD)
                {
                    const auto serializedData = dataElement.serialize();
                    ofile_.write(serializedData.data(), serializedData.size());
                }
                else
                {
                    ofile_.write(reinterpret_cast<const char*>(&dataElement), DATA_ELEMENT_SIZE);
                }
            }
 
            void log(const_pointer dataElements, std::size_t numElements)
            {
                if (!enabled_)
                {
                    return;
                }
 
                if (filepath_.empty())
                {
                    throw std::runtime_error("The output log directory does not exist");
                }
 
                std::for_each(dataElements,
                              dataElements + numElements,
                              [this](const_reference dataElement) { log(dataElement); });
            }
 
        private:
            std::filesystem::path filepath_{};
            std::ofstream         ofile_;
            bool                  enabled_{ true };
        };
    } // namespace detail
 
    class BinaryLogger
    {
    public:
        // explicitly delete
        BinaryLogger(const BinaryLogger&)            = delete;
        BinaryLogger(BinaryLogger&&)                 = delete;
        BinaryLogger& operator=(const BinaryLogger&) = delete;
        BinaryLogger& operator=(BinaryLogger&&)      = delete;
 
        static BinaryLogger& getInstance() noexcept
        {
            static BinaryLogger binaryLogger;
            return binaryLogger;
        }
 
        void setOutputDir(const std::filesystem::path& outputDir)
        {
            if (!std::filesystem::is_directory(outputDir))
            {
                throw std::runtime_error("outputDir does not exist");
            }
 
            outputDir_ = outputDir;
        }
 
        void setOutputDir(std::string_view outputDir)
        {
            setOutputDir(std::filesystem::path(outputDir));
        }
 
        template<typename DataType>
        detail::BinaryDataLogger<DataType>& getTypeLogger()
        {
            static detail::BinaryDataLogger<DataType> typeLogger(outputDir_);
            return typeLogger;
        }
 
    private:
        std::filesystem::path outputDir_{ "." };
 
        BinaryLogger() = default;
    };
} // namespace nc::logger
 
#endif // #ifndef NUMCPP_NO_USE_BOOST