MessageSource.hpp

// <MessageSource> -*- C++ -*-
 
#pragma once
 
#include <cstdint>
#include <iostream>
#include <string>
#include <sstream>
#include <utility>
 
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/log/NotificationSource.hpp"
#include "sparta/log/Message.hpp"
#include "sparta/log/Tap.hpp"
#include "sparta/log/Events.hpp"
#include "sparta/log/categories/CategoryManager.hpp"
#include "sparta/utils/StringManager.hpp"
#include "sparta/utils/Utils.hpp"
#include "sparta/log/MessageInfo.hpp"
 
namespace sparta
{
    namespace log
    {
        class MessageSource : public NotificationSource<sparta::log::Message>
        {
        public:
 
            static const constexpr char* GROUP_NAME_MSG_SOURCE = "_sparta_log_msg_source_";
 
        public:
 
            MessageSource(const MessageSource&) = delete;
            MessageSource& operator=(const MessageSource&) = delete;
            MessageSource& operator=(const MessageSource&&) = delete;
 
            MessageSource(TreeNode* parent,
                          const std::string& category,
                          const std::string& desc) :
                MessageSource(parent, StringManager::getStringManager().internString(category), desc)
            { }
 
            // MessageSource with category_id interned in StringManager
            MessageSource(TreeNode* parent,
                          const std::string* category_id,
                          const std::string& desc) :
                NotificationSource(parent,
                                   GROUP_NAME_MSG_SOURCE,
                                   notNull(parent)->getGroupIndexMax(GROUP_NAME_MSG_SOURCE) + 1,
                                   desc,
                                   category_id)
            { }
 
            virtual ~MessageSource() {
            }
 
            uint64_t getNumEmitted() const {
                return getNumPosts();
            }
 
            const std::string* getCategoryID() const {
                return getNotificationID();
            }
 
            const std::string& getCategoryName() const {
                return getNotificationName();
            }
 
            operator bool() const noexcept {
                return observed();
            }
 
            static MessageSource& getGlobalWarn();
 
            static MessageSource& getGlobalDebug();
 
            static MessageSource& getGlobalParameterTraceSource();
 
 
 
            class LogObject
            {
                const sparta::log::MessageSource* src_;
 
                std::ostringstream s_;
 
            public:
 
                LogObject() = delete;
 
                LogObject(LogObject&& rhp) :
                    src_(rhp.src_),
                    s_(rhp.s_.str()) // May unfortunately involve a copy
                { }
 
                LogObject(const LogObject& rhp) = delete;
 
                LogObject(const MessageSource& src) :
                    src_(&src)
                { }
 
                template <class T>
                LogObject(const MessageSource& src, const T& init) :
                    src_(&src)
                {
                    s_ << init;
                }
 
                LogObject(const MessageSource& src, std::ostream& (*f)(std::ostream&)) :
                    src_(&src)
                {
                    f(s_);
                }
 
                ~LogObject() {
                    if(src_){
                        src_->emit_(s_.str());
                    }
                }
 
                void cancel() {
                    src_ = nullptr;
                }
 
                template <class T>
                LogObject& operator<<(const T& t) {
                    s_ << t;
                    return *this;
                }
 
                LogObject& operator<<(std::ostream& (*f)(std::ostream&)) {
                    f(s_);
                    return *this;
                }
            };
 
            template <class T>
            LogObject operator<<(const T& t) const {
                return LogObject(*this, t);
            }
 
            LogObject operator<<(std::ostream& (*f)(std::ostream&)) const {
                return LogObject(*this, f);
            }
 
            LogObject emit(const std::string& msg) const {
                return LogObject(*this, msg);
            }
 
            LogObject emit(std::string&& msg) const {
                return LogObject(*this, msg);
            }
 
 
 
            // Override from TreeNode
            virtual std::string stringize(bool pretty=false) const override {
                (void) pretty;
                std::stringstream ss;
                ss << '<' << getParent()->getLocation() << ":log_msg_src cat:\""
                   << getCategoryName() << "\" observed:" << std::boolalpha << observed()
                   << " msgs:" << getNumEmitted() << '>';
                return ss.str();
            }
 
        private:
 
            void emit_(const std::string& content) const;
 
            static seq_num_type seq_num_;
        };
 
    } // namespace log
} // namespace sparta