NetworkManager.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 <AtomsGraph/Node.h>
#include <AtomsGraph/Port.h>
#include <AtomsGraph/PortTemplate.h>
 
#include <unordered_map>
#include <map>
#include <string>
 
namespace AtomsGraph
{
 
    /*
    This class defines a dependency graph
    */
    class ATOMSGRAPH_EXPORT NetworkManager
    {
    public:
 
        NetworkManager();
 
        ~NetworkManager();
 
        NetworkManager(const NetworkManager& other);
 
        NetworkManager& operator=(const NetworkManager& other);
 
 
        Node* createNode(const std::string& typeName, const std::string& name);
 
 
        bool renameNode(const std::string& name, const std::string& newName);
 
 
        void addNode(Node* node, const std::string& name);
 
 
        void deleteNode(const std::string& name);
 
        /*
        \param sourceNode Source node name
        \param sourceAttribute Source node port
        \param destinationNode Destination node name
        \param destinationAttribute Destination node port name
        */
        bool connectAttr(const std::string& sourceNode, const std::string& sourceAttribute,
            const std::string& destinationNode, const std::string& destinationAttribute);
 
        /*
        \param sourceNode Source node name
        \param sourceAttribute Source node port
        \param destinationNode Destination node name
        \param destinationAttribute Destination node port name
        */
        bool disconnectAttr(const std::string& sourceNode, const std::string& sourceAttribute,
            const std::string& destinationNode, const std::string& destinationAttribute);
 
 
        Node* getNode(const std::string& name);
 
 
        template<class T>
        T*  getNode(const std::string& name);
 
 
        Node * getNodeByType(const unsigned int id);
 
        std::vector<Node*> getAllNodes();
 
        std::vector<std::string> getNodeNames();
 
 
        void computeNode(
            const std::string& nodeName, 
            const AtomsGraph::ComputeData* computeData, 
            bool multithread=false, 
            bool useNetworkCache=false
        );
 
        NetworkManager clone() const;
 
        void cleanNetwork();
 
 
        void cacheNodeNetwork(const std::string& nodeName);
 
        /*
        \param nodeName Node name
        */
        void clearNodeNetworkCache(const std::string& nodeName);
 
        void clearNodeNetworkCaches();
 
        void reset();
 
        void clearNodeCache();
 
        void setAllNodeDirty();
 
    protected:
 
        std::string getUniqueName(const std::string& name);
 
    private:
 
        std::map<std::string, Node*> m_nodes;
 
        std::map<std::string, std::vector<Node*>> m_networkCache;
 
 
        std::map<std::string, std::pair<bool, Node*>> m_nodesCached;
    };
}
 
#include "NetworkManager.impl.h"