VuoCompositionDiff.cc

Go to the documentation of this file.

 
#include "VuoCompositionDiff.hh"
 
#include "VuoRuntimePersistentState.hh"
#include "VuoRuntimeState.hh"
 
VuoCompositionDiff::VuoCompositionDiff(void)
{
    diff = NULL;
}
 
VuoCompositionDiff::~VuoCompositionDiff(void)
{
    free(diff);
}
 
void VuoCompositionDiff::setDiff(char *diff)
{
    free(this->diff);
    this->diff = diff;
}
 
string VuoCompositionDiff::joinPortIdentifier(const string &nodeIdentifier, const string &portName)
{
    return nodeIdentifier + ":" + portName;
}
 
string VuoCompositionDiff::convertIdentifierToPath(const char *compositionIdentifier, const char *nodeIdentifier)
{
    return string(compositionIdentifier) + "/" + nodeIdentifier;
}
 
void VuoCompositionDiff::convertPathToIdentifier(const char *nodePath, string &compositionIdentifier, string &nodeIdentifier)
{
    string nodePathStr = nodePath;
    size_t pos = nodePathStr.rfind("/");
    if (pos == string::npos)
        return;
 
    compositionIdentifier = nodePathStr.substr(0, pos);
    nodeIdentifier = nodePathStr.substr(pos+1);
}
 
VuoCompositionDiff::ChangeType VuoCompositionDiff::findNode(const char *compositionIdentifier, const char *nodeIdentifier,
                                                            json_object **replacementObj)
{
    if (! diff)
        return ChangeStartStop;
 
    json_object *diffJson = json_tokener_parse(diff);
    if (! diffJson)
    {
        VUserLog("Couldn't parse the composition diff: %s", diff);
        return ChangeNone;
    }
 
    string nodePath = convertIdentifierToPath(compositionIdentifier, nodeIdentifier);
 
    set<string> keysFound;
    int numChanges = json_object_array_length(diffJson);
    for (int i = 0; i < numChanges; ++i)
    {
        json_object *change = json_object_array_get_idx(diffJson, i);
        json_object_object_foreach(change, key, val)
        {
            if (! strcmp(nodePath.c_str(), json_object_get_string(val)))
            {
                keysFound.insert(key);
 
                if (! strcmp(key, "replace") || ! strcmp(key, "with") || ! strcmp(key, "move") || ! strcmp(key, "to"))
                {
                    json_object_get(change);
                    *replacementObj = change;
                }
            }
        }
    }
 
    json_object_put(diffJson);
 
    if (keysFound.find("add") != keysFound.end())
        return ChangeAdd;
    else if (keysFound.find("remove") != keysFound.end())
        return ChangeRemove;
    else if (keysFound.find("replace") != keysFound.end() || keysFound.find("with") != keysFound.end())
        return ChangeReplace;
    else if (keysFound.find("move") != keysFound.end() || keysFound.find("to") != keysFound.end())
        return ChangeMove;
 
    return ChangeNone;
}
 
bool VuoCompositionDiff::isNodeBeingRemovedOrReplaced(const char *compositionIdentifier, const char *nodeIdentifier,
                                                      json_object **replacementObj)
{
    enum ChangeType changeType = findNode(compositionIdentifier, nodeIdentifier, replacementObj);
    return changeType == ChangeStartStop || changeType == ChangeRemove || changeType == ChangeReplace;
}
 
bool VuoCompositionDiff::isNodeBeingAddedOrReplaced(const char *compositionIdentifier, const char *nodeIdentifier,
                                                    json_object **replacementObj)
{
    enum ChangeType changeType = findNode(compositionIdentifier, nodeIdentifier, replacementObj);
    return changeType == ChangeStartStop || changeType == ChangeAdd || changeType == ChangeReplace;
}
 
bool VuoCompositionDiff::isPortBeingReplaced(const char *portName, json_object *replacementObj)
{
    json_object *portMappingArray = NULL;
    {
        json_object *o;
        if (json_object_object_get_ex(replacementObj, "ports", &o))
            portMappingArray = o;
    }
    if (! portMappingArray)
        return false;
 
    int numPortMappings = json_object_array_length(portMappingArray);
    for (int i = 0; i < numPortMappings; ++i)
    {
        json_object *portMapping = json_object_array_get_idx(portMappingArray, i);
        json_object *o;
 
        if (json_object_object_get_ex(portMapping, "map", &o) && ! strcmp(json_object_get_string(o), portName))
            return true;
    }
 
    return false;
}
 
bool VuoCompositionDiff::isPortReplacingAnother(const char *portName, json_object *replacementObj,
                                                string &oldNodeIdentifier, string &oldPortIdentifier)
{
    json_object *portMappingArray = NULL;
    {
        json_object *o;
 
        if (json_object_object_get_ex(replacementObj, "replace", &o))
        {
            const char *oldNodePath = json_object_get_string(o);
            string oldCompositionIdentifier;
            convertPathToIdentifier(oldNodePath, oldCompositionIdentifier, oldNodeIdentifier);
        }
 
        if (json_object_object_get_ex(replacementObj, "ports", &o))
            portMappingArray = o;
    }
    if (! portMappingArray)
        return false;
 
    string oldPortName;
    bool foundPort = false;
    int numPortMappings = json_object_array_length(portMappingArray);
    for (int i = 0; i < numPortMappings; ++i)
    {
        json_object *portMapping = json_object_array_get_idx(portMappingArray, i);
        json_object *o;
 
        if (json_object_object_get_ex(portMapping, "to", &o) && ! strcmp(json_object_get_string(o), portName))
        {
            if (json_object_object_get_ex(portMapping, "map", &o))
                oldPortName = json_object_get_string(o);
 
            foundPort = true;
            break;
        }
    }
    if (! foundPort)
        return false;
 
    oldPortIdentifier = joinPortIdentifier(oldNodeIdentifier, oldPortName);
    return true;
}
 
bool VuoCompositionDiff::isNodeBeingMovedToHere(const char *newCompositionIdentifier, const char *nodeIdentifier, json_object *replacementObj,
                                                string &oldCompositionIdentifier)
{
    string moveFrom;
    string moveTo;
 
    json_object *o;
    if (json_object_object_get_ex(replacementObj, "move", &o))
        moveFrom = json_object_get_string(o);
 
    if (json_object_object_get_ex(replacementObj, "to", &o))
        moveTo = json_object_get_string(o);
 
    if (moveTo == convertIdentifierToPath(newCompositionIdentifier, nodeIdentifier))
    {
        string unused;
        convertPathToIdentifier(moveFrom.c_str(), oldCompositionIdentifier, unused);
        return true;
    }
 
    return false;
}
 
bool VuoCompositionDiff::isPortBeingCopied(const char *portName, json_object *replacementObj,
                                           string &destinationCompositionIdentifier, string &destinationPortIdentifier)
{
    json_object *portMappingArray = NULL;
    {
        json_object *o;
        if (json_object_object_get_ex(replacementObj, "ports", &o))
            portMappingArray = o;
    }
    if (! portMappingArray)
        return false;
 
    int numPortMappings = json_object_array_length(portMappingArray);
    for (int i = 0; i < numPortMappings; ++i)
    {
        json_object *portMapping = json_object_array_get_idx(portMappingArray, i);
        json_object *o;
 
        if (json_object_object_get_ex(portMapping, "copy", &o) && ! strcmp(json_object_get_string(o), portName))
        {
            if (json_object_object_get_ex(portMapping, "to", &o))
            {
                const char *destinationPortPath = json_object_get_string(o);
                convertPathToIdentifier(destinationPortPath, destinationCompositionIdentifier, destinationPortIdentifier);
            }
 
            return true;
        }
    }
 
    return false;
}
 
bool VuoCompositionDiff::isCompositionStartingOrStopping(void)
{
    return ! diff;
}
 
extern "C"
{
void vuoSetCompositionDiff(VuoCompositionState *compositionState, char *diff)
{
    VuoRuntimeState *runtimeState = (VuoRuntimeState *)compositionState->runtimeState;
    runtimeState->persistentState->compositionDiff->setDiff(diff);
}
 
bool vuoIsNodeBeingRemovedOrReplaced(VuoCompositionState *compositionState, const char *nodeIdentifier, json_object **replacementObj)
{
    VuoRuntimeState *runtimeState = (VuoRuntimeState *)compositionState->runtimeState;
    return runtimeState->persistentState->compositionDiff->isNodeBeingRemovedOrReplaced(compositionState->compositionIdentifier,
                                                                                        nodeIdentifier, replacementObj);
}
 
bool vuoIsNodeBeingAddedOrReplaced(VuoCompositionState *compositionState, const char *nodeIdentifier, json_object **replacementObj)
{
    VuoRuntimeState *runtimeState = (VuoRuntimeState *)compositionState->runtimeState;
    return runtimeState->persistentState->compositionDiff->isNodeBeingAddedOrReplaced(compositionState->compositionIdentifier,
                                                                                      nodeIdentifier, replacementObj);
}
 
}