PortSet.hpp

Go to the documentation of this file.

// <Port> -*- C++ -*-
 
 
#pragma once
#include <set>
#include <list>
#include <unordered_map>
 
#include "sparta/ports/Port.hpp"
 
namespace sparta
{
 
    class PortSet : public TreeNode
    {
    public:
 
        typedef std::unordered_map<std::string, Port *> RegisteredPortMap;
 
        PortSet(TreeNode * parent, const std::string & desc = "Port Set") :
            TreeNode(parent, "ports", desc)
        {}
 
        Port * getPort(const std::string & named_port) const {
            for(uint32_t i = 0; i < Port::Direction::N_DIRECTIONS; ++i) {
                auto found_port = registered_ports_[i].find(named_port);
                if(found_port != registered_ports_[i].end()) {
                    return found_port->second;
                }
            }
            //Throw an exception if we could not find the port.
            throw SpartaException("The port with the name : " + named_port + " could not be found");
            return nullptr;
        }
 
        // Port * getDataInPort(const std::string & named_port) {
        //     auto found_port = registered_ports_[Port::IN].find(named_port);
        //     if(found_port != registered_ports_[Port::IN].end()) {
        //         // Right name, wrong direction
        //         return found_port->second;
        //     }
        //     //Throw an exception if we could not find the port.
        //     throw SpartaException("The port with the name : " + named_port + " could not be found");
        //     return nullptr;
        // }
 
        // /**
        //  * \brief Get a DataOutPort by the given name (convenience function)
        //  * \param named_port The named DataOutPort to retrieve
        //  * \return Pointer to the port or nullptr if not found
        //  */
        // Port * getDataOutPort(const std::string & named_port) {
        //     auto found_port = registered_ports_[Port::OUT].find(named_port);
        //     if(found_port != registered_ports_[Port::OUT].end()) {
        //         // Right name, wrong direction
        //         return found_port->second;
        //     }
        //     //Throw an exception if we could not find the port.
        //     throw SpartaException("The port with the name : " + named_port + " could not be found");
        //     return nullptr;
        // }
 
 
        PortSet(const PortSet &) = delete;
 
        PortSet & operator=(const PortSet &) = delete;
 
        RegisteredPortMap & getPorts(Port::Direction direction) {
            return registered_ports_[direction];
        }
 
    private:
        RegisteredPortMap registered_ports_[static_cast<uint32_t>(Port::Direction::N_DIRECTIONS)];
 
        virtual void onAddingChild_(TreeNode* child) override {
            if(isFinalized()){
                throw SpartaException("Cannot add a child Port once a PortSet is finalized. "
                                    "Error with: ")
                    << getLocation();
            }
 
            Port* port = dynamic_cast<Port*>(child);
            if(nullptr != port){
                sparta_assert(registered_ports_[port->getDirection()].count(port->getName()) == 0,
                                  "ERROR: Port '" << port->getName() << "' already registered");
                registered_ports_[port->getDirection()][port->getName()] = port;
                return;
            }
 
            throw SpartaException("Cannot add TreeNode child ")
                << child->getName() << " to PortSet " << getLocation()
                << " because the child is not a Port or derivative";
        }
 
    };
}