Port.h

#pragma once
// ===========================================================================
// Copyright (c) 2015 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
 
#include <AtomsGraph/Globals.h>
 
#include <string>
#include <vector>
#include <set>
 
namespace AtomsGraph
{
 
    class Node;
    
    /*
    This is the base class of all the ports type
    */
    class ATOMSGRAPH_EXPORT Port
    {
    public:
 
        typedef std::vector<Port*>::iterator port_iterator;
 
        typedef std::vector<Port*>::const_iterator const_port_iterator;
 
 
        virtual std::string typeStr() const;
 
 
        explicit Port(const std::string& name);
 
        /*
        BasePort destructor
        */
        virtual ~Port();
 
        /*
        \return return the name as a std string
        */
        inline std::string name() const;
 
        /*
        The life of the port is handled by the node. A port should always be parented to a node.
        \param node pointer to the baseNode that has this port
        */
        inline void setNode(Node* node);
 
        /*
        \return BaseNode* parent node
        */
        inline Node* node();
 
        /*
        Connect this port to another port.
        The only connections allowed are from a input port to an output port. The ports must not be on the same node.
        \param port BasePort* to connect to
        */
        bool connectTo(Port* port);
 
        /*
        \param BasePort* port to break the connection to
        */
        bool disconnectFrom(Port* port);
 
        /*
        \param ports vector used to return the list of connections
        */
        inline const std::vector<Port*>& getConnections() const;
        inline std::vector<Port*>& getConnections();
 
        /*
        If the port is an int port, so only one incoming connection is allowed,
        so this is return the port connected to the input side of the connection
        \return BasePort* port on the input side of the connection
        */
        inline Port* input() const;
 
        /*
        \return size_t number of connected ports
        */
        inline size_t numConnections() const;
 
        /*
        \return bool true if it's an input port
        */
        inline bool isInput() const;
 
        /*
        \return bool true if it's an output port
        */
        inline bool isOutput() const;
 
        inline port_iterator    begin();
 
        inline port_iterator    end();
 
        inline const_port_iterator cbegin() const;
 
        inline const_port_iterator cend() const;
 
        virtual void copyValue(Port *other);
 
        virtual void reset();
 
    protected:
 
        friend class Node;
 
        inline void setAsInput(bool value);
 
    private:
 
        /*
        Copy constructor not implemented
        */
        Port(const Port& other);
 
        /*
        Assign operator not implemented
        */
        Port& operator=(const Port& other);
 
    private:
 
        std::vector<Port*> m_vConnections;
 
        std::string m_sName;
 
        Node* m_node;
 
        bool m_bIsInput;
 
    };
 
}
 
#include "Port.impl.h"