ExportedPort.hpp

Go to the documentation of this file.

// <ExportedPort.hpp> -*- C++ -*-
 
#pragma once
 
#include <string>
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/ports/Port.hpp"
#include "sparta/utils/Utils.hpp"
 
namespace sparta
{
    class ExportedPort : public Port
    {
    public:
 
        ExportedPort(sparta::TreeNode  * portset,
                     const std::string & exported_port_name,
                     sparta::TreeNode  * internal_port_search_path,
                     const std::string & internal_port_name) :
            Port(portset, Port::Direction::UNKNOWN, exported_port_name),
            internal_port_search_path_(internal_port_search_path),
            internal_port_name_(internal_port_name)
        {}
 
        ExportedPort(sparta::TreeNode  * portset,
                     const std::string & exported_port_name,
                     sparta::Port      * internal_port) :
            Port(portset, sparta::notNull(internal_port)->getDirection(), exported_port_name),
            internal_port_(internal_port),
            internal_port_name_(internal_port->getName())
        {}
 
        void bind(Port * port) override final;
 
        bool isBound() const override final
        {
            // If the internal_port is nullptr, it has not been bound
            // yet (searched for)
            if(nullptr != internal_port_) {
                return internal_port_->isBound();
            }
            return false;
        }
 
        Direction getDirection() const override {
            if(nullptr == internal_port_) {
                return Port::Direction::UNKNOWN;
            }
             return internal_port_->getDirection();
        }
 
        void participateInAutoPrecedence(bool) override final {
            sparta_assert(false, "You cannot set auto precedence on an ExportedPort");
        }
 
        bool doesParticipateInAutoPrecedence() const override final {
            if(internal_port_) {
                return internal_port_->doesParticipateInAutoPrecedence();
            }
            return false;
        }
 
        sparta::Port * getInternalPort() { return internal_port_; }
 
        const sparta::Port * getInternalPort() const { return internal_port_; }
 
        std::string stringize(bool pretty=false) const override {
            sparta_assert(internal_port_ != this);
            std::stringstream ss;
            ss << "[exported port <" << getLocation() << "> ";
            if(internal_port_) {
                ss << internal_port_->stringize(pretty);
            }
            else {
                ss << "undefined";
            }
            ss << "]";
            return ss.str();
        }
 
 
    private:
        // The interal port -- to either be found or provided
        sparta::Port * internal_port_ = nullptr;
 
        // Non-const as the Port TreeNode contained in the path will
        // be modified during binding.  If this variable were const,
        // the code could not find the to-be-modified internal_port_
        sparta::TreeNode * internal_port_search_path_ = nullptr;
        const std::string  internal_port_name_;
 
        // Resolve the internal port
        void resolvePort_();
    };
}