VuoNodeRegistry.cc

Go to the documentation of this file.

 
#include "VuoNodeRegistry.hh"
 
#include <dlfcn.h>
#include <sstream>
#include "VuoCompositionDiff.hh"
#include "VuoException.hh"
#include "VuoRuntimePersistentState.hh"
#include "VuoRuntimeState.hh"
#include "VuoRuntimeUtilities.hh"
 
const unsigned long VuoNodeRegistry::topLevelCompositionIndex = ULONG_MAX;
const unsigned long VuoNodeRegistry::invalidCompositionIndex = ULONG_MAX - 1;
 
VuoNodeRegistry::VuoNodeRegistry(VuoRuntimePersistentState *persistentState)
{
    this->persistentState = persistentState;
    vuoTopLevelCompositionIdentifier = NULL;
}
 
void VuoNodeRegistry::updateCompositionSymbols(void *compositionBinaryHandle)
{
    ostringstream errorMessage;
 
    vuoTopLevelCompositionIdentifierType *vuoTopLevelCompositionIdentifierPtr = (vuoTopLevelCompositionIdentifierType *) dlsym(compositionBinaryHandle, "vuoTopLevelCompositionIdentifier");
    if (! vuoTopLevelCompositionIdentifierPtr)
    {
        errorMessage << "The composition couldn't be started because its vuoTopLevelCompositionIdentifier variable couldn't be found : " << dlerror();
        throw VuoException(errorMessage.str());
    }
    vuoTopLevelCompositionIdentifier = *vuoTopLevelCompositionIdentifierPtr;
}
 
const char * VuoNodeRegistry::defaultToTopLevelCompositionIdentifier(const char *compositionIdentifier)
{
    return (strlen(compositionIdentifier) > 0 ? compositionIdentifier : vuoTopLevelCompositionIdentifier);
}
 
void VuoNodeRegistry::splitCompositionIdentifier(const string &compositionIdentifier, string &parentCompositionIdentifier, string &nodeIdentifier)
{
    size_t pos = compositionIdentifier.rfind("/");
    if (pos != string::npos)
    {
        parentCompositionIdentifier = compositionIdentifier.substr(0, pos);
        nodeIdentifier = compositionIdentifier.substr(pos + strlen("/"));
    }
    else
    {
        parentCompositionIdentifier = compositionIdentifier;
        nodeIdentifier = "";
    }
}
 
string VuoNodeRegistry::buildCompositionIdentifier(const string &parentCompositionIdentifier, const string &nodeIdentifier)
{
    return parentCompositionIdentifier + "/" + nodeIdentifier;
}
 
void VuoNodeRegistry::splitPortIdentifier(const string &portIdentifier, string &nodeIdentifier, string &portName)
{
    size_t pos = portIdentifier.rfind(":");
    if (pos != string::npos)
    {
        nodeIdentifier = portIdentifier.substr(0, pos);
        portName = portIdentifier.substr(pos + strlen(":"));
    }
}
 
void VuoNodeRegistry::addNodeMetadata(const char *compositionIdentifier, const char *nodeIdentifier,
                                      NodeContext *(*compositionCreateContextForNode)(unsigned long),
                                      void (*compositionSetPortValue)(VuoCompositionState *, const char *, const char *, bool, bool, bool, bool, bool),
                                      char * (*compositionGetPortValue)(VuoCompositionState *, const char *, int, bool),
                                      void (*compositionFireTriggerPortEvent)(VuoCompositionState *, const char *),
                                      void (*compositionReleasePortData)(void *, unsigned long))
{
    NodeMetadata nodeMetadata;
    nodeMetadata.identifier = nodeIdentifier;
    nodeMetadata.compositionCreateContextForNode = compositionCreateContextForNode;
    nodeMetadata.compositionSetPortValue = compositionSetPortValue;
    nodeMetadata.compositionGetPortValue = compositionGetPortValue;
    nodeMetadata.compositionFireTriggerPortEvent = compositionFireTriggerPortEvent;
    nodeMetadata.compositionReleasePortData = compositionReleasePortData;
    nodeMetadatas[compositionIdentifier].push_back(nodeMetadata);
}
 
void VuoNodeRegistry::addPortMetadata(const char *compositionIdentifier, const char *portIdentifier, const char *portName,
                     unsigned long typeIndex, const char *initialValue)
{
    PortMetadata portMetadata = { portIdentifier, portName, typeIndex, initialValue };
    nodeMetadatas[compositionIdentifier].back().portMetadatas.push_back(portMetadata);
}
 
string VuoNodeRegistry::getNodeIdentifierForIndex(const char *compositionIdentifier, unsigned long nodeIndex)
{
    if (nodeIndex == topLevelCompositionIndex)
        return "";
 
    map<string, vector<NodeMetadata> >::iterator iter1 = nodeMetadatas.find(compositionIdentifier);
    if (iter1 != nodeMetadatas.end())
        if (nodeIndex < iter1->second.size())
            return iter1->second[nodeIndex].identifier;
 
    VUserLog("Couldn't find identifier for node %s/%lu", compositionIdentifier, nodeIndex);
    return "";
}
 
unsigned long VuoNodeRegistry::getNodeIndexForIdentifier(const string &compositionIdentifier, const string &nodeIdentifier)
{
    if (nodeIdentifier.empty())
        return topLevelCompositionIndex;
 
    map<string, vector<NodeMetadata> >::iterator iter1 = nodeMetadatas.find(compositionIdentifier);
    if (iter1 != nodeMetadatas.end())
        for (unsigned long i = 0; i < iter1->second.size(); ++i)
            if (iter1->second[i].identifier == nodeIdentifier)
                return i;
 
    VUserLog("Couldn't find index for node %s", buildCompositionIdentifier(compositionIdentifier, nodeIdentifier).c_str());
    return invalidCompositionIndex;
}
 
const VuoNodeRegistry::NodeMetadata * VuoNodeRegistry::getNodeMetadataForPort(const string &compositionIdentifier, const string &portIdentifier)
{
    string nodeIdentifier, portName;
    splitPortIdentifier(portIdentifier, nodeIdentifier, portName);
 
    map<string, vector<NodeMetadata> >::iterator iter1 = nodeMetadatas.find(compositionIdentifier);
    if (iter1 != nodeMetadatas.end())
        for (unsigned long i = 0; i < iter1->second.size(); ++i)
            if (iter1->second[i].identifier == nodeIdentifier)
                return &(iter1->second[i]);
 
    VUserLog("Couldn't find node metadata for port %s", buildCompositionIdentifier(compositionIdentifier, portIdentifier).c_str());
    return NULL;
}
 
string VuoNodeRegistry::getCompositionIdentifierForHash(unsigned long compositionIdentifierHash)
{
    map<unsigned long, string>::iterator iter1 = compositionIdentifierForHash.find(compositionIdentifierHash);
    if (iter1 != compositionIdentifierForHash.end())
        return iter1->second;
 
    VUserLog("Couldn't find composition identifier for hash %lu", compositionIdentifierHash);
    return "";
}
 
void VuoNodeRegistry::addNodeContext(const char *compositionIdentifier, unsigned long nodeIndex, NodeContext *nodeContext)
{
    unsigned long compositionIdentifierHash = VuoRuntimeUtilities::hash(compositionIdentifier);
 
    map<unsigned long, map<unsigned long, NodeContext *> >::iterator iter1 = nodeContextForIndex.find(compositionIdentifierHash);
    if (iter1 != nodeContextForIndex.end())
    {
        map<unsigned long, NodeContext *>::iterator iter2 = iter1->second.find(nodeIndex);
        if (iter2 != iter1->second.end())
            VUserLog("Context overwritten for node %s", buildCompositionIdentifier(compositionIdentifier, getNodeIdentifierForIndex(compositionIdentifier, nodeIndex)).c_str());
    }
 
    nodeContextForIndex[compositionIdentifierHash][nodeIndex] = nodeContext;
 
    compositionIdentifierForHash[ VuoRuntimeUtilities::hash(compositionIdentifier) ] = compositionIdentifier;
}
 
void VuoNodeRegistry::removeNodeContext(const char *compositionIdentifier, unsigned long nodeIndex)
{
    unsigned long compositionIdentifierHash = VuoRuntimeUtilities::hash(compositionIdentifier);
 
    map<unsigned long, map<unsigned long, NodeContext *> >::iterator iter1 = nodeContextForIndex.find(compositionIdentifierHash);
    if (iter1 != nodeContextForIndex.end())
    {
        map<unsigned long, NodeContext *>::iterator iter2 = iter1->second.find(nodeIndex);
        if (iter2 != iter1->second.end())
        {
            iter1->second.erase(iter2);
            if (iter1->second.empty())
                nodeContextForIndex.erase(iter1);
 
            string nodeIdentifier = getNodeIdentifierForIndex(compositionIdentifier, nodeIndex);
            string subcompositionIdentifier = buildCompositionIdentifier(compositionIdentifier, nodeIdentifier);
            unsigned long subcompositionIdentifierHash = VuoRuntimeUtilities::hash(subcompositionIdentifier.c_str());
            map<unsigned long, string>::iterator ciIter = compositionIdentifierForHash.find(subcompositionIdentifierHash);
            if (ciIter != compositionIdentifierForHash.end())
                compositionIdentifierForHash.erase(ciIter);
 
            return;
        }
    }
 
    VUserLog("Couldn't find context for node %s", buildCompositionIdentifier(compositionIdentifier, getNodeIdentifierForIndex(compositionIdentifier, nodeIndex)).c_str());
}
 
void VuoNodeRegistry::relocateNodeContext(const char *compositionIdentifier, unsigned long nodeIndex)
{
    unsigned long compositionIdentifierHash = VuoRuntimeUtilities::hash(compositionIdentifier);
 
    map<unsigned long, map<unsigned long, NodeContext *> >::iterator iter1 = nodeContextForIndex.find(compositionIdentifierHash);
    if (iter1 != nodeContextForIndex.end())
    {
        map<unsigned long, NodeContext *>::iterator iter2 = iter1->second.find(nodeIndex);
        if (iter2 != iter1->second.end())
        {
            string nodeIdentifier = getNodeIdentifierForIndex(compositionIdentifier, nodeIndex);
            carriedOverNodeContextForIdentifier[compositionIdentifier][nodeIdentifier] = iter2->second;
            iter1->second.erase(iter2);
 
            if (iter1->second.empty())
                nodeContextForIndex.erase(iter1);
 
            return;
        }
    }
 
    VUserLog("Couldn't find context for node %s", buildCompositionIdentifier(compositionIdentifier, getNodeIdentifierForIndex(compositionIdentifier, nodeIndex)).c_str());
}
 
NodeContext * VuoNodeRegistry::carryOverNodeContext(const char *oldCompositionIdentifier, const char *newCompositionIdentifier,
                                                    unsigned long nodeIndex)
{
    NodeContext *nodeContext = NULL;
    string nodeIdentifier = getNodeIdentifierForIndex(newCompositionIdentifier, nodeIndex);
 
    {
        bool found = false;
        map<string, map<string, NodeContext *> >::iterator coIter1 = carriedOverNodeContextForIdentifier.find(oldCompositionIdentifier);
        if (coIter1 != carriedOverNodeContextForIdentifier.end())
        {
            map<string, NodeContext *>::iterator coIter2 = coIter1->second.find(nodeIdentifier);
            if (coIter2 != coIter1->second.end())
            {
                nodeContext = coIter2->second;
                coIter1->second.erase(coIter2);
                addNodeContext(newCompositionIdentifier, nodeIndex, nodeContext);
                found = true;
 
                if (coIter1->second.empty())
                    carriedOverNodeContextForIdentifier.erase(coIter1);
            }
        }
 
        if (! found)
            VUserLog("Couldn't find context for node %s", buildCompositionIdentifier(oldCompositionIdentifier, nodeIdentifier).c_str());
    }
 
    return nodeContext;
}
 
NodeContext * VuoNodeRegistry::getNodeContext(const char *compositionIdentifier, unsigned long nodeIndex)
{
    unsigned long compositionIdentifierHash = VuoRuntimeUtilities::hash(compositionIdentifier);
 
    map<unsigned long, map<unsigned long, NodeContext *> >::iterator iter1 = nodeContextForIndex.find(compositionIdentifierHash);
    if (iter1 != nodeContextForIndex.end())
    {
        map<unsigned long, NodeContext *>::iterator iter2 = iter1->second.find(nodeIndex);
        if (iter2 != iter1->second.end())
            return iter2->second;
    }
 
    VUserLog("Couldn't find context for node %s", buildCompositionIdentifier(compositionIdentifier, getNodeIdentifierForIndex(compositionIdentifier, nodeIndex)).c_str());
    return NULL;
}
 
NodeContext * VuoNodeRegistry::getCompositionContext(const char *compositionIdentifier)
{
    string parentCompositionIdentifier, subcompositionNodeIdentifier;
    splitCompositionIdentifier(compositionIdentifier, parentCompositionIdentifier, subcompositionNodeIdentifier);
    unsigned long subcompositionNodeIndex = getNodeIndexForIdentifier(parentCompositionIdentifier, subcompositionNodeIdentifier);
    return getNodeContext(parentCompositionIdentifier.c_str(), subcompositionNodeIndex);
}
 
template<typename T>
bool VuoNodeRegistry::findCachedInfoForPort(const map<string, map<string, T> > &cachedInfoForPort, const string &compositionIdentifier,
                                            const string &portIdentifier, typename map<string, T>::const_iterator &foundIter)
{
    typename map<string, map<string, T> >::const_iterator compIter = cachedInfoForPort.find(compositionIdentifier);
    if (compIter != cachedInfoForPort.end())
    {
        foundIter = compIter->second.find(portIdentifier);
        if (foundIter != compIter->second.end())
            return true;
    }
 
    return false;
}
 
void * VuoNodeRegistry::getDataForPort(const char *compositionIdentifier, const char *portIdentifier)
{
    map<string, void *>::const_iterator foundIter;
    bool found = findCachedInfoForPort<void *>(dataForPort, compositionIdentifier, portIdentifier, foundIter);
    if (found)
        return foundIter->second;
 
    VUserLog("Couldn't find data for port %s", buildCompositionIdentifier(compositionIdentifier, portIdentifier).c_str());
    return NULL;
}
 
dispatch_semaphore_t VuoNodeRegistry::getNodeSemaphoreForPort(const char *compositionIdentifier, const char *portIdentifier)
{
    map<string, dispatch_semaphore_t>::const_iterator foundIter;
    bool found = findCachedInfoForPort<dispatch_semaphore_t>(nodeSemaphoreForPort, compositionIdentifier, portIdentifier, foundIter);
    if (found)
        return foundIter->second;
 
    VUserLog("Couldn't find node semaphore for port %s", buildCompositionIdentifier(compositionIdentifier, portIdentifier).c_str());
    return NULL;
}
 
unsigned long VuoNodeRegistry::getNodeIndexForPort(const char *compositionIdentifier, const char *portIdentifier)
{
    map<string, unsigned long>::const_iterator foundIter;
    bool found = findCachedInfoForPort<unsigned long>(nodeIndexForPort, compositionIdentifier, portIdentifier, foundIter);
    if (found)
        return foundIter->second;
 
    VUserLog("Couldn't find node index for port %s", buildCompositionIdentifier(compositionIdentifier, portIdentifier).c_str());
    return 0;
}
 
unsigned long VuoNodeRegistry::getTypeIndexForPort(const char *compositionIdentifier, const char *portIdentifier)
{
    map<string, unsigned long>::const_iterator foundIter;
    bool found = findCachedInfoForPort<unsigned long>(typeIndexForPort, compositionIdentifier, portIdentifier, foundIter);
    if (found)
        return foundIter->second;
 
    VUserLog("Couldn't find type index for port %s", buildCompositionIdentifier(compositionIdentifier, portIdentifier).c_str());
    return 0;
}
 
void VuoNodeRegistry::addPortIdentifier(const char *compositionIdentifier, const string &portIdentifier,
                                        void *data, dispatch_semaphore_t nodeSemaphore, unsigned long nodeIndex, unsigned long typeIndex)
{
    map<string, void *>::const_iterator foundIter;
    bool found = findCachedInfoForPort<void *>(dataForPort, compositionIdentifier, portIdentifier, foundIter);
    if (found)
        VUserLog("Cache overwritten for port %s", buildCompositionIdentifier(compositionIdentifier, portIdentifier).c_str());
 
    dataForPort[compositionIdentifier][portIdentifier] = data;
    nodeSemaphoreForPort[compositionIdentifier][portIdentifier] = nodeSemaphore;
    nodeIndexForPort[compositionIdentifier][portIdentifier] = nodeIndex;
    typeIndexForPort[compositionIdentifier][portIdentifier] = typeIndex;
}
 
void VuoNodeRegistry::removePortIdentifier(const char *compositionIdentifier, const string &portIdentifier)
{
    {
        map<string, void *>::const_iterator foundIter;
        bool found = findCachedInfoForPort<void *>(dataForPort, compositionIdentifier, portIdentifier, foundIter);
        if (found)
        {
            dataForPort[compositionIdentifier].erase(portIdentifier);
 
            if (dataForPort[compositionIdentifier].empty())
                dataForPort.erase(compositionIdentifier);
        }
        else
            VUserLog("Couldn't find data for port %s", buildCompositionIdentifier(compositionIdentifier, portIdentifier).c_str());
    }
    {
        map<string, dispatch_semaphore_t>::const_iterator foundIter;
        bool found = findCachedInfoForPort<dispatch_semaphore_t>(nodeSemaphoreForPort, compositionIdentifier, portIdentifier, foundIter);
        if (found)
        {
            nodeSemaphoreForPort[compositionIdentifier].erase(portIdentifier);
 
            if (nodeSemaphoreForPort[compositionIdentifier].empty())
                nodeSemaphoreForPort.erase(compositionIdentifier);
        }
        else
            VUserLog("Couldn't find node semaphore for port %s", buildCompositionIdentifier(compositionIdentifier, portIdentifier).c_str());
    }
    {
        map<string, unsigned long>::const_iterator foundIter;
        bool found = findCachedInfoForPort<unsigned long>(nodeIndexForPort, compositionIdentifier, portIdentifier, foundIter);
        if (found)
        {
            nodeIndexForPort[compositionIdentifier].erase(portIdentifier);
 
            if (nodeIndexForPort[compositionIdentifier].empty())
                nodeIndexForPort.erase(compositionIdentifier);
        }
        else
            VUserLog("Couldn't find node index for port %s", buildCompositionIdentifier(compositionIdentifier, portIdentifier).c_str());
    }
    {
        map<string, unsigned long>::const_iterator foundIter;
        bool found = findCachedInfoForPort<unsigned long>(typeIndexForPort, compositionIdentifier, portIdentifier, foundIter);
        if (found)
        {
            typeIndexForPort[compositionIdentifier].erase(portIdentifier);
 
            if (typeIndexForPort[compositionIdentifier].empty())
                typeIndexForPort.erase(compositionIdentifier);
        }
        else
            VUserLog("Couldn't find type index for port %s", buildCompositionIdentifier(compositionIdentifier, portIdentifier).c_str());
    }
}
 
void VuoNodeRegistry::relocatePortIdentifier(const char *compositionIdentifier, const string &portIdentifier)
{
    {
        map<string, void *>::const_iterator foundIter;
        bool found = findCachedInfoForPort<void *>(dataForPort, compositionIdentifier, portIdentifier, foundIter);
        if (found)
            carriedOverDataForPort[compositionIdentifier][portIdentifier] = foundIter->second;
        else
            VUserLog("Couldn't find data for port %s", buildCompositionIdentifier(compositionIdentifier, portIdentifier).c_str());
    }
    {
        map<string, dispatch_semaphore_t>::const_iterator foundIter;
        bool found = findCachedInfoForPort<dispatch_semaphore_t>(nodeSemaphoreForPort, compositionIdentifier, portIdentifier, foundIter);
        if (found)
            carriedOverNodeSemaphoreForPort[compositionIdentifier][portIdentifier] = foundIter->second;
        else
            VUserLog("Couldn't find node semaphore for port %s", buildCompositionIdentifier(compositionIdentifier, portIdentifier).c_str());
    }
    {
        map<string, unsigned long>::const_iterator foundIter;
        bool found = findCachedInfoForPort<unsigned long>(nodeIndexForPort, compositionIdentifier, portIdentifier, foundIter);
        if (found)
            carriedOverNodeIndexForPort[compositionIdentifier][portIdentifier] = foundIter->second;
        else
            VUserLog("Couldn't find node index for port %s", buildCompositionIdentifier(compositionIdentifier, portIdentifier).c_str());
    }
    {
        map<string, unsigned long>::const_iterator foundIter;
        bool found = findCachedInfoForPort<unsigned long>(typeIndexForPort, compositionIdentifier, portIdentifier, foundIter);
        if (found)
            carriedOverTypeIndexForPort[compositionIdentifier][portIdentifier] = foundIter->second;
        else
            VUserLog("Couldn't find type index for port %s", buildCompositionIdentifier(compositionIdentifier, portIdentifier).c_str());
    }
 
    removePortIdentifier(compositionIdentifier, portIdentifier);
}
 
void VuoNodeRegistry::carryOverPortIdentifier(const char *oldCompositionIdentifier, const char *newCompositionIdentifier,
                                              const string &portIdentifier, unsigned long nodeIndex, unsigned long typeIndex)
{
    map<string, void *>::const_iterator foundIter;
    bool found = findCachedInfoForPort<void *>(carriedOverDataForPort, oldCompositionIdentifier, portIdentifier, foundIter);
    if (! found)
    {
        VUserLog("Couldn't find cache for port %s", buildCompositionIdentifier(oldCompositionIdentifier, portIdentifier).c_str());
        return;
    }
 
    dataForPort[newCompositionIdentifier][portIdentifier] = carriedOverDataForPort[oldCompositionIdentifier][portIdentifier];
    nodeSemaphoreForPort[newCompositionIdentifier][portIdentifier] = carriedOverNodeSemaphoreForPort[oldCompositionIdentifier][portIdentifier];
    nodeIndexForPort[newCompositionIdentifier][portIdentifier] = nodeIndex;
    typeIndexForPort[newCompositionIdentifier][portIdentifier] = typeIndex;
 
    removeCarriedOverPortIdentifier(oldCompositionIdentifier, portIdentifier);
}
 
void VuoNodeRegistry::carryOverPortIdentifiersForNode(const char *oldCompositionIdentifier, const char *newCompositionIdentifier,
                                                      const string &nodeIdentifier, unsigned long nodeIndex,
                                                      const vector<string> &portIdentifiers, const vector<unsigned long> typeIndexes)
{
    for (size_t j = 0; j < portIdentifiers.size(); ++j)
        carryOverPortIdentifier(oldCompositionIdentifier, newCompositionIdentifier, portIdentifiers[j], nodeIndex, typeIndexes[j]);
}
 
void VuoNodeRegistry::removeCarriedOverPortIdentifier(const char *compositionIdentifier, const string &oldPortIdentifier)
{
    map<string, void *>::const_iterator foundIter;
    bool found = findCachedInfoForPort<void *>(carriedOverDataForPort, compositionIdentifier, oldPortIdentifier, foundIter);
    if (! found)
    {
        VUserLog("Couldn't find cache for port %s", buildCompositionIdentifier(compositionIdentifier, oldPortIdentifier).c_str());
        return;
    }
 
    carriedOverDataForPort[compositionIdentifier].erase(oldPortIdentifier);
    carriedOverNodeSemaphoreForPort[compositionIdentifier].erase(oldPortIdentifier);
    carriedOverNodeIndexForPort[compositionIdentifier].erase(oldPortIdentifier);
    carriedOverTypeIndexForPort[compositionIdentifier].erase(oldPortIdentifier);
 
    if (carriedOverDataForPort[compositionIdentifier].empty())
        carriedOverDataForPort.erase(compositionIdentifier);
    if (carriedOverNodeSemaphoreForPort[compositionIdentifier].empty())
        carriedOverNodeSemaphoreForPort.erase(compositionIdentifier);
    if (carriedOverNodeIndexForPort[compositionIdentifier].empty())
        carriedOverNodeIndexForPort.erase(compositionIdentifier);
    if (carriedOverTypeIndexForPort[compositionIdentifier].empty())
        carriedOverTypeIndexForPort.erase(compositionIdentifier);
}
 
void VuoNodeRegistry::carryOverPortData(const char *oldCompositionIdentifier, const char *newCompositionIdentifier,
                                        const string &oldPortIdentifier, const string &newPortIdentifier, PortContext *newPortContext)
{
    void *carriedOverData;
    {
        map<string, void *>::const_iterator foundIter;
        bool found = findCachedInfoForPort<void *>(carriedOverDataForPort, oldCompositionIdentifier, oldPortIdentifier, foundIter);
        if (! found)
        {
            VUserLog("Couldn't find data for carried-over port %s", buildCompositionIdentifier(oldCompositionIdentifier, oldPortIdentifier).c_str());
            return;
        }
 
        carriedOverData = foundIter->second;
    }
 
    vuoSetPortContextData(newPortContext, carriedOverData);
 
    {
        map<string, void *>::const_iterator foundIter;
        bool found = findCachedInfoForPort<void *>(dataForPort, newCompositionIdentifier, newPortIdentifier, foundIter);
        if (! found)
        {
            VUserLog("Couldn't find data for port %s", buildCompositionIdentifier(newCompositionIdentifier, newPortIdentifier).c_str());
            return;
        }
 
        dataForPort[newCompositionIdentifier][newPortIdentifier] = carriedOverData;
    }
}
 
void VuoNodeRegistry::initContextForTopLevelComposition(VuoCompositionState *compositionState, bool hasInstanceData,
                                                        unsigned long publishedOutputPortCount)
{
    const char *compositionIdentifier = compositionState->compositionIdentifier;
 
    if (persistentState->compositionDiff->isCompositionStartingOrStopping())
    {
        // Create and register a node context for the top-level composition.
        NodeContext *compositionContext = vuoCreateNodeContext(hasInstanceData, true, publishedOutputPortCount);
        addNodeContext(compositionIdentifier, topLevelCompositionIndex, compositionContext);
    }
    else
    {
        carryOverNodeContext(compositionIdentifier, compositionIdentifier, topLevelCompositionIndex);
    }
 
    initContextsForCompositionContents(compositionState);
}
 
void VuoNodeRegistry::initContextsForCompositionContents(VuoCompositionState *compositionState)
{
    const char *compositionIdentifier = compositionState->compositionIdentifier;
 
    for (size_t nodeIndex = 0; nodeIndex < nodeMetadatas[compositionIdentifier].size(); ++nodeIndex)
    {
        NodeMetadata nodeMetadata = nodeMetadatas[compositionIdentifier][nodeIndex];
        NodeContext *nodeContext = NULL;
 
        json_object *replacementObj = NULL;
        VuoCompositionDiff::ChangeType changeType = persistentState->compositionDiff->findNode(compositionIdentifier,
                                                                                               nodeMetadata.identifier.c_str(),
                                                                                               &replacementObj);
        if (changeType == VuoCompositionDiff::ChangeStartStop ||
                changeType == VuoCompositionDiff::ChangeAdd || changeType == VuoCompositionDiff::ChangeReplace)
        {
            // Create and register a node context for the added node and a port context for each of its ports.
            NodeContext *nodeContext = nodeMetadata.compositionCreateContextForNode(nodeIndex);
            addNodeContext(compositionIdentifier, nodeIndex, nodeContext);
 
            // Add the added node's ports to the port cache.
            dispatch_semaphore_t nodeSemaphore = vuoGetNodeContextSemaphore(nodeContext);
            for (size_t portIndex = 0; portIndex < nodeMetadata.portMetadatas.size(); ++portIndex)
            {
                PortMetadata portMetadata = nodeMetadata.portMetadatas[portIndex];
                PortContext *portContext = vuoGetNodeContextPortContext(nodeContext, portIndex);
                void *portData = vuoGetPortContextData(portContext);
 
                addPortIdentifier(compositionIdentifier, portMetadata.identifier, portData, nodeSemaphore, nodeIndex, portMetadata.typeIndex);
            }
 
            for (size_t portIndex = 0; portIndex < nodeMetadata.portMetadatas.size(); ++portIndex)
            {
                PortMetadata portMetadata = nodeMetadata.portMetadatas[portIndex];
                PortContext *portContext = vuoGetNodeContextPortContext(nodeContext, portIndex);
                void *portData = vuoGetPortContextData(portContext);
 
                if (portData)
                {
                    string oldNodeIdentifier;
                    string oldPortIdentifier;
                    if (changeType == VuoCompositionDiff::ChangeReplace &&
                            persistentState->compositionDiff->isPortReplacingAnother(portMetadata.name.c_str(), replacementObj, oldNodeIdentifier, oldPortIdentifier))
                    {
                        // Set the replacement port's data from the port it replaces.
                        carryOverPortData(compositionIdentifier, compositionIdentifier, oldPortIdentifier, portMetadata.identifier, portContext);
 
                        // Remove the port from the carried-over port info.
                        removeCarriedOverPortIdentifier(compositionIdentifier, oldPortIdentifier);
                    }
                    else
                    {
                        // Set the added port's data to its initial value.
                        nodeMetadata.compositionSetPortValue(compositionState, portMetadata.identifier.c_str(), portMetadata.initialValue.c_str(),
                                                             false, false, false, false, true);
                    }
                }
            }
        }
        else
        {
            string oldCompositionIdentifier = compositionIdentifier;
            if (changeType == VuoCompositionDiff::ChangeMove &&
                    (! persistentState->compositionDiff->isNodeBeingMovedToHere(compositionIdentifier, nodeMetadata.identifier.c_str(), replacementObj, oldCompositionIdentifier)))
                continue;
 
            // Restore the kept node's context.
            nodeContext = carryOverNodeContext(oldCompositionIdentifier.c_str(), compositionIdentifier, nodeIndex);
 
            // Restore the kept node's ports to the port cache.
            vector<string> portIdentifiers;
            vector<unsigned long> typeIndexes;
            for (size_t portIndex = 0; portIndex < nodeMetadata.portMetadatas.size(); ++portIndex)
            {
                PortMetadata portMetadata = nodeMetadata.portMetadatas[portIndex];
                portIdentifiers.push_back(portMetadata.identifier);
                typeIndexes.push_back(portMetadata.typeIndex);
            }
            carryOverPortIdentifiersForNode(oldCompositionIdentifier.c_str(), compositionIdentifier, nodeMetadata.identifier, nodeIndex, portIdentifiers, typeIndexes);
 
            // If the node has been packaged into a subcomposition, copy the port values with connected published input cables
            // from here (the node inside the subcomposition) to the new subcomposition node in the parent composition.
            if (changeType == VuoCompositionDiff::ChangeMove)
            {
                for (size_t portIndex = 0; portIndex < nodeMetadata.portMetadatas.size(); ++portIndex)
                {
                    PortMetadata portMetadata = nodeMetadata.portMetadatas[portIndex];
 
                    string destinationCompositionIdentifier;
                    string destinationPortIdentifier;
                    if (persistentState->compositionDiff->isPortBeingCopied(portMetadata.name.c_str(), replacementObj,
                                                                            destinationCompositionIdentifier, destinationPortIdentifier))
                    {
                        char *portValue = getPortValue(compositionState, portMetadata.identifier.c_str(), false);
 
                        const NodeMetadata *destinationPortMetadata = getNodeMetadataForPort(destinationCompositionIdentifier.c_str(), destinationPortIdentifier.c_str());
                        VuoCompositionState *destinationCompositionState = vuoCreateCompositionState(compositionState->runtimeState, destinationCompositionIdentifier.c_str());
                        destinationPortMetadata->compositionSetPortValue(destinationCompositionState, destinationPortIdentifier.c_str(), portValue, false, false, false, true, true);
                    }
                }
            }
        }
 
        json_object_put(replacementObj);
 
        // If the node is a subcomposition, initialize the node and port contexts within it.
        string subcompositionIdentifier = buildCompositionIdentifier(compositionIdentifier, nodeMetadata.identifier);
        if (nodeMetadatas.find(subcompositionIdentifier) != nodeMetadatas.end())
        {
            VuoCompositionState *subcompositionState = vuoCreateCompositionState(compositionState->runtimeState, subcompositionIdentifier.c_str());
            initContextsForCompositionContents(subcompositionState);
            vuoFreeCompositionState(subcompositionState);
        }
    }
}
 
void VuoNodeRegistry::finiContextForTopLevelComposition(VuoCompositionState *compositionState)
{
    const char *compositionIdentifier = compositionState->compositionIdentifier;
 
    if (persistentState->compositionDiff->isCompositionStartingOrStopping())
    {
        // Unregister and destroy the node context for the top-level composition.
        NodeContext *compositionContext = getNodeContext(compositionIdentifier, topLevelCompositionIndex);
        removeNodeContext(compositionIdentifier, topLevelCompositionIndex);
        vuoFreeNodeContext(compositionContext);
    }
    else
    {
        relocateNodeContext(compositionIdentifier, topLevelCompositionIndex);
    }
 
    finiContextsForCompositionContents(compositionState);
 
    nodeMetadatas.clear();
}
 
void VuoNodeRegistry::finiContextsForCompositionContents(VuoCompositionState *compositionState)
{
    const char *compositionIdentifier = compositionState->compositionIdentifier;
 
    for (size_t nodeIndex = 0; nodeIndex < nodeMetadatas[compositionIdentifier].size(); ++nodeIndex)
    {
        NodeMetadata nodeMetadata = nodeMetadatas[compositionIdentifier][nodeIndex];
 
        json_object *replacementObj = NULL;
        VuoCompositionDiff::ChangeType changeType = persistentState->compositionDiff->findNode(compositionIdentifier,
                                                                                               nodeMetadata.identifier.c_str(),
                                                                                               &replacementObj);
        if (changeType == VuoCompositionDiff::ChangeStartStop ||
                changeType == VuoCompositionDiff::ChangeRemove || changeType == VuoCompositionDiff::ChangeReplace)
        {
            NodeContext *nodeContext = getNodeContext(compositionIdentifier, nodeIndex);
 
            for (size_t portIndex = 0; portIndex < nodeMetadata.portMetadatas.size(); ++portIndex)
            {
                PortMetadata portMetadata = nodeMetadata.portMetadatas[portIndex];
                PortContext *portContext = vuoGetNodeContextPortContext(nodeContext, portIndex);
                void *portData = vuoGetPortContextData(portContext);
 
                bool relocated = false;
                if (portData)
                {
                    if (changeType == VuoCompositionDiff::ChangeReplace &&
                            persistentState->compositionDiff->isPortBeingReplaced(portMetadata.name.c_str(), replacementObj))
                    {
                        // Retain the being-replaced port's data for after the live-coding reload.
                        vuoRetainPortContextData(portContext);
 
                        // Carry over the port's data
                        relocatePortIdentifier(compositionIdentifier, portMetadata.identifier);
                        relocated = true;
                    }
                    else
                    {
                        // Release the port's data.
                        nodeMetadata.compositionReleasePortData(portData, portMetadata.typeIndex);
                    }
                }
 
                if (! relocated)
                {
                    // Remove the port from the (non-carried-over) port cache.
                    removePortIdentifier(compositionIdentifier, portMetadata.identifier);
                }
            }
 
            // Unregister and destroy the node's context.
            removeNodeContext(compositionIdentifier, nodeIndex);
            vuoFreeNodeContext(nodeContext);
        }
        else
        {
            for (size_t portIndex = 0; portIndex < nodeMetadata.portMetadatas.size(); ++portIndex)
            {
                // Carry over the port's data
                PortMetadata portMetadata = nodeMetadata.portMetadatas[portIndex];
                relocatePortIdentifier(compositionIdentifier, portMetadata.identifier);
            }
 
            // Carry over the node's context
            relocateNodeContext(compositionIdentifier, nodeIndex);
        }
 
        json_object_put(replacementObj);
 
        string subcompositionIdentifier = buildCompositionIdentifier(compositionIdentifier, nodeMetadata.identifier);
        if (nodeMetadatas.find(subcompositionIdentifier) != nodeMetadatas.end())
        {
            // Recursive call for subcomposition.
            VuoCompositionState *subcompositionState = vuoCreateCompositionState(compositionState->runtimeState, subcompositionIdentifier.c_str());
            finiContextsForCompositionContents(subcompositionState);
            vuoFreeCompositionState(subcompositionState);
        }
    }
}
 
void VuoNodeRegistry::setPortValue(VuoCompositionState *compositionState, const char *portIdentifier, const char *valueAsString)
{
    const NodeMetadata *nm = getNodeMetadataForPort(compositionState->compositionIdentifier, portIdentifier);
    if (!nm)
        return;
 
    nm->compositionSetPortValue(compositionState, portIdentifier, valueAsString, true, true, true, true, true);
}
 
char * VuoNodeRegistry::getPortValue(VuoCompositionState *compositionState, const char *portIdentifier, bool shouldUseInterprocessSerialization)
{
    const NodeMetadata *nm = getNodeMetadataForPort(compositionState->compositionIdentifier, portIdentifier);
    if (!nm)
        return nullptr;
 
    return nm->compositionGetPortValue(compositionState, portIdentifier, shouldUseInterprocessSerialization ? 2 : 1, true);
}
 
char * VuoNodeRegistry::getPortSummary(VuoCompositionState *compositionState, const char *portIdentifier)
{
    const NodeMetadata *nm = getNodeMetadataForPort(compositionState->compositionIdentifier, portIdentifier);
    if (!nm)
        return nullptr;
 
    return nm->compositionGetPortValue(compositionState, portIdentifier, 0, true);
}
 
void VuoNodeRegistry::fireTriggerPortEvent(VuoCompositionState *compositionState, const char *portIdentifier)
{
    const NodeMetadata *nm = getNodeMetadataForPort(compositionState->compositionIdentifier, portIdentifier);
    if (!nm)
        return;
 
    nm->compositionFireTriggerPortEvent(compositionState, portIdentifier);
}
 
void VuoNodeRegistry::print(void)
{
    const char *indent = "  ";
 
    printf("=== node metadatas ===\n\n");
    for (map<string, vector<NodeMetadata> >::iterator i = nodeMetadatas.begin(); i != nodeMetadatas.end(); ++i)
    {
        printf("%s%s\n", indent, i->first.c_str());
        for (size_t j = 0; j < i->second.size(); ++j)
            printf("%s%s%lu %s, %lu ports\n", indent, indent, j, i->second[j].identifier.c_str(), i->second[j].portMetadatas.size());
    }
    printf("\n");
 
    printf("=== node contexts ===\n\n");
    for (map<unsigned long, map<unsigned long, NodeContext *> >::iterator i = nodeContextForIndex.begin(); i != nodeContextForIndex.end(); ++i)
    {
        string compositionIdentifier = getCompositionIdentifierForHash(i->first);
        printf("%s%s\n", indent, compositionIdentifier.c_str());
        for (map<unsigned long, NodeContext *>::iterator j = i->second.begin(); j != i->second.end(); ++j)
            printf("%s%s%s %p\n", indent, indent, getNodeIdentifierForIndex(compositionIdentifier.c_str(), j->first).c_str(), j->second);
    }
    printf("\n");
 
    printf("=== carried-over node contexts ===\n\n");
    for (map<string, map<string, NodeContext *> >::iterator i = carriedOverNodeContextForIdentifier.begin(); i != carriedOverNodeContextForIdentifier.end(); ++i)
    {
        printf("%s%s\n", indent, i->first.c_str());
        for (map<string, NodeContext *>::iterator j = i->second.begin(); j != i->second.end(); ++j)
            printf("%s%s%s %p\n", indent, indent, j->first.c_str(), j->second);
    }
    printf("\n");
 
    printf("=== cached ports ===\n\n");
    for (map<string, map<string, void *> >::iterator i = dataForPort.begin(); i != dataForPort.end(); ++i)
    {
        printf("%s%s\n", indent, i->first.c_str());
        for (map<string, void *>::iterator j = i->second.begin(); j != i->second.end(); ++j)
            printf("%s%s%s %p\n", indent, indent, j->first.c_str(), j->second);
    }
    printf("\n");
 
    printf("=== carried-over cached ports ===\n\n");
    for (map<string, map<string, void *> >::iterator i = carriedOverDataForPort.begin(); i != carriedOverDataForPort.end(); ++i)
    {
        printf("%s%s\n", indent, i->first.c_str());
        for (map<string, void *>::iterator j = i->second.begin(); j != i->second.end(); ++j)
            printf("%s%s%s %p\n", indent, indent, j->first.c_str(), j->second);
    }
    printf("\n");
}
 
extern "C"
{
 
void vuoAddNodeMetadata(VuoCompositionState *compositionState, const char *nodeIdentifier,
                        NodeContext *(*compositionCreateContextForNode)(unsigned long),
                        void (*compositionSetPortValue)(VuoCompositionState *, const char *, const char *, bool, bool, bool, bool, bool),
                        char * (*compositionGetPortValue)(VuoCompositionState *, const char *, int, bool),
                        void (*compositionFireTriggerPortEvent)(VuoCompositionState *, const char *),
                        void (*compositionReleasePortData)(void *, unsigned long))
{
    VuoRuntimeState *runtimeState = (VuoRuntimeState *)compositionState->runtimeState;
    const char *compositionIdentifier = compositionState->compositionIdentifier;
    runtimeState->persistentState->nodeRegistry->addNodeMetadata(compositionIdentifier, nodeIdentifier,
                                                                 compositionCreateContextForNode, compositionSetPortValue,
                                                                 compositionGetPortValue, compositionFireTriggerPortEvent,
                                                                 compositionReleasePortData);
}
 
void vuoAddPortMetadata(VuoCompositionState *compositionState, const char *portIdentifier, const char *portName,
                        unsigned long typeIndex, const char *initialValue)
{
    VuoRuntimeState *runtimeState = (VuoRuntimeState *)compositionState->runtimeState;
    const char *compositionIdentifier = compositionState->compositionIdentifier;
    runtimeState->persistentState->nodeRegistry->addPortMetadata(compositionIdentifier, portIdentifier, portName, typeIndex, initialValue);
}
 
NodeContext * vuoGetNodeContext(VuoCompositionState *compositionState, unsigned long nodeIndex)
{
    VuoRuntimeState *runtimeState = (VuoRuntimeState *)compositionState->runtimeState;
    const char *compositionIdentifier = compositionState->compositionIdentifier;
    return runtimeState->persistentState->nodeRegistry->getNodeContext(compositionIdentifier, nodeIndex);
}
 
NodeContext * vuoGetCompositionContext(VuoCompositionState *compositionState)
{
    VuoRuntimeState *runtimeState = (VuoRuntimeState *)compositionState->runtimeState;
    const char *compositionIdentifier = compositionState->compositionIdentifier;
    return runtimeState->persistentState->nodeRegistry->getCompositionContext(compositionIdentifier);
}
 
void * vuoGetDataForPort(VuoCompositionState *compositionState, const char *portIdentifier)
{
    VuoRuntimeState *runtimeState = (VuoRuntimeState *)compositionState->runtimeState;
    const char *compositionIdentifier = compositionState->compositionIdentifier;
    return runtimeState->persistentState->nodeRegistry->getDataForPort(compositionIdentifier, portIdentifier);
}
 
dispatch_semaphore_t vuoGetNodeSemaphoreForPort(VuoCompositionState *compositionState, const char *portIdentifier)
{
    VuoRuntimeState *runtimeState = (VuoRuntimeState *)compositionState->runtimeState;
    const char *compositionIdentifier = compositionState->compositionIdentifier;
    return runtimeState->persistentState->nodeRegistry->getNodeSemaphoreForPort(compositionIdentifier, portIdentifier);
}
 
unsigned long vuoGetNodeIndexForPort(VuoCompositionState *compositionState, const char *portIdentifier)
{
    VuoRuntimeState *runtimeState = (VuoRuntimeState *)compositionState->runtimeState;
    const char *compositionIdentifier = compositionState->compositionIdentifier;
    return runtimeState->persistentState->nodeRegistry->getNodeIndexForPort(compositionIdentifier, portIdentifier);
}
 
unsigned long vuoGetTypeIndexForPort(VuoCompositionState *compositionState, const char *portIdentifier)
{
    VuoRuntimeState *runtimeState = (VuoRuntimeState *)compositionState->runtimeState;
    const char *compositionIdentifier = compositionState->compositionIdentifier;
    return runtimeState->persistentState->nodeRegistry->getTypeIndexForPort(compositionIdentifier, portIdentifier);
}
 
void vuoInitContextForTopLevelComposition(VuoCompositionState *compositionState, bool hasInstanceData, unsigned long publishedOutputPortCount)
{
    VuoRuntimeState *runtimeState = (VuoRuntimeState *)compositionState->runtimeState;
    return runtimeState->persistentState->nodeRegistry->initContextForTopLevelComposition(compositionState, hasInstanceData, publishedOutputPortCount);
}
 
void vuoFiniContextForTopLevelComposition(VuoCompositionState *compositionState)
{
    VuoRuntimeState *runtimeState = (VuoRuntimeState *)compositionState->runtimeState;
    return runtimeState->persistentState->nodeRegistry->finiContextForTopLevelComposition(compositionState);
}
 
}