Class TypedConfigurations

include/thundersvm/util/log.h:1958–2084

@brief Configurations with data types. @detail el::Configurations have string based values. This is whats used internally in order to read correct configurations. This is to perform faster while writing logs using correct configurations. This is thread safe and final class containing non-virtual destructor (means nothing should inherit this class)

///
/// This is thread safe and final class containing non-virtual destructor (means nothing should inherit this class)
        class TypedConfigurations : public base::threading::ThreadSafe {
        public:
            /// @brief Constructor to initialize (construct) the object off el::Configurations
            /// @param configurations Configurations pointer/reference to base this typed configurations off.
            /// @param logStreamsReference Use ELPP->registeredLoggers()->logStreamsReference()
            TypedConfigurations(Configurations* configurations, base::LogStreamsReferenceMap* logStreamsReference);

            TypedConfigurations(const TypedConfigurations& other);

            virtual ~TypedConfigurations(void) {
            }

            const Configurations* configurations(void) const {
                return m_configurations;
            }

            bool enabled(Level level);
            bool toFile(Level level);
            const std::string& filename(Level level);
            bool toStandardOutput(Level level);
            const base::LogFormat& logFormat(Level level);
            const base::SubsecondPrecision& subsecondPrecision(Level level = Level::Global);
            const base::MillisecondsWidth& millisecondsWidth(Level level = Level::Global);
            bool performanceTracking(Level level = Level::Global);
            base::type::fstream_t* fileStream(Level level);
            std::size_t maxLogFileSize(Level level);
            std::size_t logFlushThreshold(Level level);

        private:
            Configurations* m_configurations;
            std::map<Level, bool> m_enabledMap;
            std::map<Level, bool> m_toFileMap;
            std::map<Level, std::string> m_filenameMap;
            std::map<Level, bool> m_toStandardOutputMap;
            std::map<Level, base::LogFormat> m_logFormatMap;
            std::map<Level, base::SubsecondPrecision> m_subsecondPrecisionMap;
            std::map<Level, bool> m_performanceTrackingMap;
            std::map<Level, base::FileStreamPtr> m_fileStreamMap;
            std::map<Level, std::size_t> m_maxLogFileSizeMap;
            std::map<Level, std::size_t> m_logFlushThresholdMap;
            base::LogStreamsReferenceMap* m_logStreamsReference;

            friend class el::Helpers;
            friend class el::base::MessageBuilder;
            friend class el::base::Writer;
            friend class el::base::DefaultLogDispatchCallback;
            friend class el::base::LogDispatcher;

            template <typename Conf_T>
            inline Conf_T getConfigByVal(Level level, const std::map<Level, Conf_T>* confMap, const char* confName) {
                base::threading::ScopedLock scopedLock(lock());
                return unsafeGetConfigByVal(level, confMap, confName);  // This is not unsafe anymore - mutex locked in scope
            }

            template <typename Conf_T>
            inline Conf_T& getConfigByRef(Level level, std::map<Level, Conf_T>* confMap, const char* confName) {
                base::threading::ScopedLock scopedLock(lock());
                return unsafeGetConfigByRef(level, confMap, confName);  // This is not unsafe anymore - mutex locked in scope