Destination.hpp

// <Destination> -*- C++ -*-
 
#pragma once
 
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <string>
#include <ostream>
#include <fstream>
#include <sstream>
#include <map>
#include <mutex>
#include <functional>
#include <memory>
#include <typeinfo>
#include <utility>
#include <vector>
 
#include "sparta/log/Message.hpp"
#include "sparta/app/SimulationInfo.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/utils/SpartaException.hpp"
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/utils/Utils.hpp"
#include "sparta/log/MessageInfo.hpp"
 
namespace sparta
{
    namespace log
    {
        class Destination
        {
        public:
 
            Destination(const Destination&) = delete;
            Destination& operator=(const Destination&) = delete;
 
            Destination(const Destination&& rhp) :
                num_msgs_received_(rhp.num_msgs_received_),
                num_msgs_written_(rhp.num_msgs_written_),
                num_msg_duplicates_(rhp.num_msg_duplicates_),
                last_seq_map_(rhp.last_seq_map_)
            { }
 
            Destination() :
                num_msgs_received_(0),
                num_msgs_written_(0),
                num_msg_duplicates_(0)
            { }
 
            virtual ~Destination()
            { }
 
            template <std::size_t N>
            bool compare(const char (& arg)[N]) const {
                // Defer to subclass' compareStrings
                return compareStrings(std::string(arg));
            }
 
            bool compare(const char *& arg) const {
                // Defer to subclass' compareStrings
                return compareStrings(std::string(arg));
            }
 
            bool compare(const std::string& arg) const {
                // Defer to subclass' compareStrings
                return compareStrings(arg);
            }
 
            bool compare(const std::ostream& arg) const {
                return compareOstreams(arg);
            }
 
            template <typename T>
            bool compare(const T&) const {
                throw SpartaException("Logging destination does not now how to compare a Destination "
                                    "instance with type: ") << demangle(typeid(T).name());
            }
 
            // Virtual Comparisons for matching destinations
 
            virtual bool compareStrings(const std::string&) const {
                return false;
            }
 
            virtual bool compareOstreams(const std::ostream&) const {
                return false;
            }
 
            virtual std::string stringize(bool pretty=false) const = 0;
 
            void write(const sparta::log::Message& msg) {
                std::lock_guard<std::mutex> lock(write_mutex_);
 
                ++num_msgs_received_;
 
                // Filter by sequence. Get last sequence ID on this message's thread
                seq_num_type last_seq = getLastSequenceNum_(msg.info.thread_id);
                if(msg.info.seq_num <= last_seq){
                    // Duplicate (same msg from a different tap), do not write
                    ++num_msg_duplicates_;
                    return;
                }
 
                ++num_msgs_written_;
                write_(msg);
 
                last_seq_map_[msg.info.thread_id] = msg.info.seq_num; // Update latest sequence
            };
 
            uint64_t getNumMessagesReceived() const { return num_msgs_received_; }
 
            uint64_t getNumMessagesWritten() const { return num_msgs_written_; }
 
            uint64_t getNumMessageDuplicates() const { return num_msg_duplicates_; }
 
        private:
 
            seq_num_type getLastSequenceNum_(thread_id_type tid) const {
 
                auto itr = last_seq_map_.find(tid);
                if(itr != last_seq_map_.end()){
                    return itr->second;
                }
                return -1;
            };
 
            virtual void write_(const sparta::log::Message& msg) = 0;
 
 
            uint64_t num_msgs_received_;  
            uint64_t num_msgs_written_;   
            uint64_t num_msg_duplicates_; 
 
            std::map<thread_id_type, seq_num_type> last_seq_map_; 
 
            std::mutex write_mutex_; 
        };
 
        class Formatter {
        protected:
            std::ostream& stream_;
 
        public:
 
            struct Info {
                const char* const extension;
                const std::string extname;
                std::function<Formatter* (std::ostream&)> factory;
            };
 
            Formatter(std::ostream& stream) :
                stream_(stream)
            { }
 
            virtual ~Formatter() { }
 
            virtual void write(const sparta::log::Message& msg) = 0;
 
            virtual void writeHeader(const SimulationInfo& sim_info) = 0;
 
            static const Info* FORMATTERS;
        };
 
        class VerboseFormatter : public Formatter {
        public:
            VerboseFormatter(std::ostream& stream) :
                Formatter(stream)
            { }
 
            void write(const sparta::log::Message& msg) override {
                // Replace any \n's with nothing
                stream_ << msg.info << copyWithReplace(msg.content, '\n', "") << std::endl;
                stream_.flush();
            }
 
            void writeHeader(const SimulationInfo& sim_info) override {
                sim_info.write(stream_, "#", "\n");
                stream_.flush();
            }
        };
 
        class DefaultFormatter : public Formatter {
        public:
            DefaultFormatter(std::ostream& stream) :
                Formatter(stream)
            { }
 
            void write(const sparta::log::Message& msg) override;
 
            void writeHeader(const SimulationInfo& sim_info) override {
                sim_info.write(stream_, "#", "\n");
                stream_.flush();
            }
        };
 
        class BasicFormatter : public Formatter {
        public:
            BasicFormatter(std::ostream& stream) :
                Formatter(stream)
            { }
 
            void write(const sparta::log::Message& msg) override {
                stream_ << msg.info.origin.getLocation() << ": "
                        << *msg.info.category << ": "
                        << copyWithReplace(msg.content, '\n', "") << std::endl;
                stream_.flush();
            }
 
            void writeHeader(const SimulationInfo& sim_info) override {
                sim_info.write(stream_, "#", "\n");
                stream_.flush();
            }
        };
 
        class RawFormatter : public Formatter {
        public:
            RawFormatter(std::ostream& stream) :
                Formatter(stream)
            { }
 
            void write(const sparta::log::Message& msg) override {
                stream_ << copyWithReplace(msg.content, '\n', "") << std::endl;
                stream_.flush();
            }
 
            void writeHeader(const SimulationInfo& sim_info) override {
                sim_info.write(stream_, "#", "\n");
                stream_.flush();
            }
        };
 
        template <typename DestType>
        class DestinationInstance : public Destination
        {
        };
 
        template <>
        class DestinationInstance<std::ostream> : public Destination
        {
            std::ostream& stream_;
            DefaultFormatter fmt_;
 
        public:
 
            DestinationInstance(std::ostream& stream) :
                stream_(stream),
                fmt_(stream_)
            {
                if(stream.good() == false){
                    throw SpartaException("stream must be a good() ostream");
                }
            }
 
            virtual bool compareOstreams(const std::ostream& o) const override {
                return &o == &stream_;
            }
 
            // From TreeNode
            virtual std::string stringize(bool pretty=false) const override {
                (void) pretty;
                std::stringstream ss;
                ss << "<" << "destination ostream=";
                if(&stream_ == &std::cout){
                    ss << "cout";
                }else if(&stream_ == &std::cerr){
                    ss << "cerr";
                }else{
                    ss << &stream_;
                }
                ss << " rcv="
                   << getNumMessagesReceived() << " wrote=" << getNumMessagesWritten()
                   << " dups=" << getNumMessageDuplicates() << ">";
                return ss.str();
            }
 
        private:
 
            virtual void write_(const sparta::log::Message& msg) override {
                fmt_.write(msg);
            };
        };
 
        template <>
        class DestinationInstance<std::string> : public Destination
        {
            std::ofstream stream_;
            const std::string filename_;
            std::unique_ptr<Formatter> formatter_;
            const Formatter::Info* fmtinfo_;
 
        public:
 
            DestinationInstance(const std::string& filename) :
                stream_(filename, std::ofstream::out), // write mode
                filename_(filename)
            {
                if(stream_.good() == false){
                    throw SpartaException("Failed to open logging destination file for append \"")
                        << filename << "\"";
                }
 
                // Throw on write errors
                stream_.exceptions(std::ostream::eofbit | std::ostream::badbit | std::ostream::failbit | std::ostream::goodbit);
 
                fmtinfo_ = Formatter::FORMATTERS;
                while(true){
                    if(nullptr == fmtinfo_->extension){
                        break; // End of the list. Use this formatter
                    }
                    std::string ext = fmtinfo_->extension;
                    size_t pos = filename.find(ext);
                    if(pos != std::string::npos && pos == filename.size() - ext.size()){
                        break; // Use this fmtinfo_->factory to construct
                    }
                    ++fmtinfo_;
                }
                if(nullptr == fmtinfo_){
                    throw SpartaException("No formatters defined in FORMATTERS ")
                        << "list for file-based destination instance. "
                        << "Cannot open file \"" << filename << "\"";
                }
                formatter_.reset(fmtinfo_->factory(stream_));
                sparta_assert(formatter_ != nullptr);
 
                formatter_->writeHeader(SimulationInfo::getInstance());
            }
 
            virtual bool compareStrings(const std::string& filename) const override {
                return filename == filename_;
            }
 
            // From TreeNode
            virtual std::string stringize(bool pretty=false) const override {
                (void) pretty;
                std::stringstream ss;
                ss << "<" << "destination file=\"" << filename_ << "\" format=\""
                   << fmtinfo_->extname << "\" ext=\"";
                if(nullptr == fmtinfo_->extension){
                    ss << "(default)";
                }else{
                    ss << fmtinfo_->extension;
                }
                ss << "\" ostream="
                   << &stream_ << " rcv=" << getNumMessagesReceived()
                   << " wrote=" << getNumMessagesWritten()
                   << " dups=" << getNumMessageDuplicates() << ">";
                return ss.str();
            }
 
        private:
 
            virtual void write_(const sparta::log::Message& msg) override {
                formatter_->write(msg);
            };
        };
 
 
        class DestinationManager
        {
        public:
 
            typedef std::vector<std::unique_ptr<Destination>> DestinationVector;
 
            template <class DestT>
            static Destination* getDestination(DestT& arg) {
                for(std::unique_ptr<Destination>& d : dests_){
                    // Overload for Destination::compare(DestT&) must exist. c-string type is typically const char[N]
                    if(d->compare(arg)){
                        return d.get();
                    }
                }
 
                dests_.emplace_back(createDestination(arg));
                return dests_.back().get();
            }
 
            template <std::size_t N>
            static Destination* createDestination(const char (&arg)[N]) {
                return new DestinationInstance<std::string>(arg);
            }
 
            static Destination* createDestination(const char *& arg) {
                return new DestinationInstance<std::string>(arg);
            }
 
            template <class DestT>
            static Destination* createDestination(const DestT& arg) {
                return new DestinationInstance<DestT>(arg);
            }
 
            template <class DestT>
            static Destination* createDestination(DestT& arg) {
                return new DestinationInstance<DestT>(arg);
            }
 
            static const DestinationVector& getDestinations() {
                return dests_;
            }
 
            static uint32_t getNumDestinations() {
                return dests_.size();
            }
 
            static std::ostream& dumpDestinations(std::ostream& o, bool pretty=false) {
                (void) pretty;
                for(auto& d : dests_){
                    o << "  " << d->stringize() << std::endl;
                }
 
                return o;
            }
 
            static std::ostream& dumpFileExtensions(std::ostream& o, bool pretty=false) {
                (void) pretty;
                const Formatter::Info* finf = Formatter::FORMATTERS;
                while(true){
                    if(nullptr == finf->extension){
                        o << "  " << "(default) -> " << finf->extname << std::endl;
                        break; // End of the list
                    }
                    o << "  \"" << finf->extension << "\" -> " << finf->extname << std::endl;
                    ++finf;
                }
 
                return o;
            }
 
        private:
 
            static DestinationVector dests_;
        };
 
    } // namespace log
} // namespace sparta
 
inline std::ostream& operator<< (std::ostream& out, sparta::log::Destination const & d){
    out << d.stringize();
    return out;
}
 
inline std::ostream& operator<< (std::ostream& out, sparta::log::Destination const * d){
    if(d == 0){
        out << "null";
    }else{
        out << d->stringize();
    }
    return out;
}