Node.impl.h

// ===========================================================================
// 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.
// ===========================================================================
 
namespace AtomsGraph
{
    Node::port_iterator Node::inputPortBegin()
    {
        return m_vInputPorts.begin();
    }
 
    Node::port_iterator Node::inputPortEnd()
    {
        return m_vInputPorts.end();
    }
 
    Node::const_port_iterator Node::inputPortCBegin() const
    {
        return m_vInputPorts.cbegin();
    }
 
    Node::const_port_iterator Node::inputPortCEnd() const
    {
        return m_vInputPorts.cend();
    }
 
    Node::port_iterator Node::outputPortBegin()
    {
        return m_vOutputPorts.begin();
    }
 
    Node::port_iterator Node::outputPortEnd()
    {
        return m_vOutputPorts.end();
    }
 
    Node::const_port_iterator Node::outputPortCBegin() const
    {
        return m_vOutputPorts.cbegin();
    }
 
    Node::const_port_iterator Node::outputPortCEnd() const
    {
        return m_vOutputPorts.cend();
    }
 
    const std::string& Node::name() const
    {
        return m_sName;
    }
 
    void Node::setName(const std::string& name)
    {
        m_sName = name;
    }
 
    bool Node::isDirty() const
    {
        return m_isDirty;
    }
 
    void Node::setDirtyFlag()
    {
        m_isDirty = true;
    }
 
    size_t Node::numInputPorts() const
    {
        return m_vInputPorts.size();
    }
 
    size_t Node::numOutputPorts() const
    {
        return m_vOutputPorts.size();
    }
 
 
 
    template<class T>
    T*  Node::getInputPort(const std::string& name)
    {
        Port* port = getInputPort(name);
        if (port && (port->typeStr() == T::staticTypeStr()))
            return static_cast<T*>(port);
        return nullptr;
    }
 
    template<class T>
    T*  Node::getOutputPort(const std::string& name)
    {
        Port* port = getOutputPort(name);
        if (port && (port->typeStr() == T::staticTypeStr()))
            return static_cast<T*>(port);
        return nullptr;
    }
 
    void Node::setProfileTime(size_t value)
    {
        m_profileTime = value;
    }
 
    size_t Node::profileTime() const
    {
        return m_profileTime;
    }
}