VuoNodeAndPortIdentifierCache.cc

Go to the documentation of this file.

 
#include "VuoNodeAndPortIdentifierCache.hh"
#include "VuoEditorComposition.hh"
#include "VuoComposition.hh"
#include "VuoCompilerNode.hh"
 
void VuoNodeAndPortIdentifierCache::addCompositionComponentsToCache(VuoComposition *composition)
{
    std::lock_guard<std::mutex> lock(mapMutex);
 
    for (VuoNode *node : composition->getNodes())
        addNodeToCache_internal(node);
 
    for (VuoPublishedPort *publishedPort : composition->getPublishedInputPorts())
        addPortToCache_internal(publishedPort);
 
    for (VuoPublishedPort *publishedPort : composition->getPublishedOutputPorts())
        addPortToCache_internal(publishedPort);
}
 
void VuoNodeAndPortIdentifierCache::addNodeToCache(VuoNode *node)
{
    std::lock_guard<std::mutex> lock(mapMutex);
 
    addNodeToCache_internal(node);
}
 
void VuoNodeAndPortIdentifierCache::addNodeToCache_internal(VuoNode *node)
{
    if (node && node->hasCompiler())
        nodeWithGraphvizIdentifier[node->getCompiler()->getGraphvizIdentifier()] = node;
 
    for (VuoPort *port : node->getInputPorts())
        addPortToCache_internal(port, node);
 
    for (VuoPort *port : node->getOutputPorts())
        addPortToCache_internal(port, node);
}
 
void VuoNodeAndPortIdentifierCache::addPublishedPortToCache(VuoPublishedPort *publishedPort)
{
    std::lock_guard<std::mutex> lock(mapMutex);
 
    addPortToCache_internal(publishedPort);
}
 
void VuoNodeAndPortIdentifierCache::addPortToCache_internal(VuoPort *port, VuoNode *node)
{
    string staticPortIdentifier = VuoEditorComposition::getIdentifierForStaticPort(port, node);
    portWithStaticIdentifier[staticPortIdentifier] = port;
    staticIdentifierForPort[port] = staticPortIdentifier;
}
 
void VuoNodeAndPortIdentifierCache::clearCache(void)
{
    std::lock_guard<std::mutex> lock(mapMutex);
 
    nodeWithGraphvizIdentifier.clear();
    portWithStaticIdentifier.clear();
    staticIdentifierForPort.clear();
}
 
bool VuoNodeAndPortIdentifierCache::doForNodeWithIdentifier(const string &identifier, std::function<void(VuoNode *)> callback)
{
    std::lock_guard<std::mutex> lock(mapMutex);
 
    auto foundIter = nodeWithGraphvizIdentifier.find(identifier);
    if (foundIter != nodeWithGraphvizIdentifier.end())
    {
        callback(foundIter->second);
        return true;
    }
 
    return false;
}
 
bool VuoNodeAndPortIdentifierCache::doForPortWithIdentifier(const string &identifier, std::function<void(VuoPort *)> callback)
{
    std::lock_guard<std::mutex> lock(mapMutex);
 
    auto foundIter = portWithStaticIdentifier.find(identifier);
    if (foundIter != portWithStaticIdentifier.end())
    {
        callback(foundIter->second);
        return true;
    }
 
    return false;
}
 
string VuoNodeAndPortIdentifierCache::getIdentifierForPort(VuoPort *port)
{
    std::lock_guard<std::mutex> lock(mapMutex);
 
    auto foundIter = staticIdentifierForPort.find(port);
    if (foundIter != staticIdentifierForPort.end())
        return foundIter->second;
 
    return "";
}