Tap.hpp

// <Tap> -*- C++ -*-
 
#pragma once
 
#include <iostream>
#include <vector>
 
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/log/categories/CategoryManager.hpp"
#include "sparta/utils/StringManager.hpp"
#include "sparta/log/Destination.hpp"
#include "sparta/log/Events.hpp"
#include "sparta/simulation/TreeNodePrivateAttorney.hpp"
namespace sparta
{
    namespace log
    {
 
        class Tap
        {
        public:
 
            Tap(const Tap&) = delete;
 
            Tap& operator=(const Tap&) = delete;
 
            template <typename DestT>
            Tap(TreeNode* node, const std::string* pcategory, DestT& dest) :
                node_(node),
                category_(pcategory)
            {
                Destination* d = DestinationManager::getDestination(dest); // Can instantiate new
                sparta_assert(d != nullptr);
                dest_ = d;
 
                if(nullptr == node){
                    throw SpartaException("Cannot attach a Tap to a null TreeNode");
                }
 
                reset(node);
            }
 
            template <typename DestT>
            Tap(TreeNode* node, const std::string& category, DestT& dest) :
                Tap(node, StringManager::getStringManager().internString(category), dest)
            {
                // Initialization handled in delegated constructor
            }
 
            template <typename DestT>
            Tap(const std::string& category, DestT& dest) :
                node_(nullptr),
                category_(StringManager::getStringManager().internString(category))
            {
                Destination* d = DestinationManager::getDestination(dest); // Can instantiate new
                sparta_assert(d != nullptr);
                dest_ = d;
            }
 
            virtual ~Tap() {
                detach();
            }
 
            void reset(TreeNode* node) {
                detach();
 
                if(nullptr != node){
                    node_wptr_ = node->getWeakPtr();
 
                    // Use the form of the registration command which can ignore the no-notification-source case
                    TreeNodePrivateAttorney::registerForNotification<sparta::log::Message,
                        typename std::remove_reference<decltype(*this)>::type,
                        &std::remove_reference<decltype(*this)>::type::send_>
                        (node_wptr_.lock().get(), this, *category_, false);
                }
            }
 
            void detach() {
                if(!node_wptr_.expired()){
                    auto shared = node_wptr_.lock();
                    if(shared){ // Check if reset
                        TreeNodePrivateAttorney::deregisterForNotification<sparta::log::Message,
                                                                           typename std::remove_reference<decltype(*this)>::type,
                                                                           &std::remove_reference<decltype(*this)>::type::send_>(shared.get(),
                                                                                                                                 this, *category_);
                    }
                }else{
                    // Warn that the target node already expired before this tap was destructed
                    // Note that this is one of the only things that cannot be logged because
                    // it can happen at a time when there is all taps that may observe it are being
                    // destroyed. This it not a real issue, but everyone should be aware that it can
                    // happen.
                    //std::cerr << "Warning: Tap of category \"" << *category_ << "\" and destination "
                    //          << dest_->stringize() << " is detaching from an already-expired node"
                    //          << std::endl;
                }
 
                node_wptr_.reset(); // Clears content
            }
 
            const std::string* getCategoryID() const {
                return category_;
            }
 
            const std::string& getCategoryName() const {
                return *category_;
            }
 
            const Destination* getDestination() const {
                return dest_;
            }
 
            Destination* getDestination() {
                return dest_;
            }
 
            uint64_t getNumMessages() const {
                return num_msgs_;
            }
 
            TreeNode* getObservedNode() const {
                return node_;
            }
 
            bool isObservedNodeExpired() const {
                return node_wptr_.expired();
            }
 
        protected:
 
            void send_(const TreeNode& origin,
                       const TreeNode& obs_pt_DO_NOT_USE,
                       const Message& msg) {
                (void)origin;
                (void)obs_pt_DO_NOT_USE;
 
                sparta_assert(dest_); // Ensure this tap has a valid destination before sending
                dest_->write(msg);
                ++num_msgs_;
            }
 
        private:
 
            TreeNode* node_;
            TreeNode::WeakPtr node_wptr_; 
            const std::string* const category_; 
            Destination* dest_; 
            uint64_t num_msgs_ = 0; 
        };
 
        class TapDescriptor
        {
        public:
 
            TapDescriptor(const std::string& _loc_pattern,
                          const std::string& _category,
                          const std::string& _destination) :
                loc_pattern_(_loc_pattern),
                category_(_category),
                dest_(_destination)
            { }
 
            // Allow copies and assignment (needed for vector)
            TapDescriptor(const TapDescriptor&) = default;
            TapDescriptor& operator=(const TapDescriptor&) = default;
 
            // Pretty print
            std::string stringize() const {
                std::stringstream ss;
                ss << "Tap location_pattern=\"" << loc_pattern_ << "\" (category=\"" << category_
                   << "\") -> file: \"" << dest_ << "\"";
                return ss.str();
            }
 
            // Increments the usage count of this descriptor
            void incrementUsageCount() const { ++num_times_used_; }
 
            // Returns the usage count (incremented by incrementUsageCount)
            uint32_t getUsageCount() const { return num_times_used_; }
 
            // Get the location pattern
            const std::string &getLocation() const { return loc_pattern_; }
 
            // Get the category
            const std::string &getCategory() const { return category_; }
 
            // Get the destination file
            const std::string &getDestination() const { return dest_; }
 
            // Get pattern goodness check
            bool hasBadPattern() const { return has_bad_pattern_; }
 
            // Set the pattern to be bad
            void setBadPattern(bool bad) const { has_bad_pattern_ = bad; }
 
        private:
 
            // Node location string (pattern) on which tap should be placed
            std::string loc_pattern_;
 
            // Tap category
            std::string category_;
 
            // Destination file for this tap
            std::string dest_;
 
            // Number of times this descriptor has been used to
            // construct a tap
            mutable uint32_t num_times_used_ = 0;
 
            // Is the pattern for this tap known to be false. This is usually
            // detected as the tree is being built when searches fail with an
            // exception
            mutable bool has_bad_pattern_ = false;
        };
 
        // Convenient typedef
        typedef std::vector<TapDescriptor> TapDescVec;
 
        inline std::vector<const log::TapDescriptor*> getUnusedTaps(const log::TapDescVec& taps) {
            std::vector<const log::TapDescriptor*> unused_taps;
            for(const TapDescriptor& td : taps){
                if(td.getUsageCount() == 0){
                    unused_taps.push_back(&td);
                }
            }
            return unused_taps;
        }
 
    } // namespace log
} // namespace sparta