VuoCompilerPublishedNodeClass.cc

Go to the documentation of this file.

 
#include <sstream>
 
#include "VuoCompiler.hh"
#include "VuoCompilerPortClass.hh"
#include "VuoCompilerPublishedPort.hh"
#include "VuoCompilerPublishedNodeClass.hh"
#include "VuoCompilerPublishedInputNodeClass.hh"
#include "VuoCompilerPublishedOutputNodeClass.hh"
#include "VuoCompilerType.hh"
#include "VuoGenericType.hh"
#include "VuoMakeDependencies.hh"
#include "VuoNode.hh"
#include "VuoNodeClass.hh"
#include "VuoPublishedPort.hh"
#include "VuoStringUtilities.hh"
#include "VuoType.hh"
 
VuoCompilerPublishedNodeClass::VuoCompilerPublishedNodeClass(string nodeClassName, Module *module) :
    VuoCompilerSpecializedNodeClass(nodeClassName, module)
{
}
 
VuoCompilerPublishedNodeClass::VuoCompilerPublishedNodeClass(VuoCompilerPublishedNodeClass *compilerNodeClass) :
    VuoCompilerSpecializedNodeClass(compilerNodeClass)
{
}
 
VuoCompilerPublishedNodeClass::VuoCompilerPublishedNodeClass(VuoNodeClass *baseNodeClass) :
    VuoCompilerSpecializedNodeClass(baseNodeClass)
{
}
 
VuoNodeClass * VuoCompilerPublishedNodeClass::newNodeClass(const string &nodeClassName, VuoCompiler *compiler, dispatch_queue_t llvmQueue, VuoCompilerPublishedNodeClass *singleton)
{
    vector<string> portNames;
    vector<string> typeNames;
    bool parsedOk = singleton->parseNodeClassName(nodeClassName, portNames, typeNames);
    if (! parsedOk)
        return NULL;
 
    vector<VuoType *> types;
    for (string typeName : typeNames)
    {
        VuoCompilerType *type = (typeName == "event" ? nullptr : compiler->getType(typeName));
        types.push_back(type ? type->getBase() : nullptr);
    }
 
    return newNodeClass(portNames, types, llvmQueue, singleton);
}
 
VuoNodeClass * VuoCompilerPublishedNodeClass::newNodeClass(const vector<VuoPublishedPort *> &publishedPorts, dispatch_queue_t llvmQueue, VuoCompilerPublishedNodeClass *singleton)
{
    vector<string> portNames = singleton->formUniquePortNames(publishedPorts);
 
    vector<VuoType *> types;
    for (VuoPublishedPort *publishedPort : publishedPorts)
    {
        VuoType *type = static_cast<VuoCompilerPort *>(publishedPort->getCompiler())->getDataVuoType();
        types.push_back(type);
    }
 
    return newNodeClass(portNames, types, llvmQueue, singleton);
}
 
VuoNodeClass * VuoCompilerPublishedNodeClass::newNodeClass(const vector<string> &portNames, const vector<VuoType *> &types, dispatch_queue_t llvmQueue, VuoCompilerPublishedNodeClass *singleton)
{
    string nodeClassName = singleton->buildNodeClassName(portNames, types);
 
    bool isFullySpecialized = true;
    for (VuoType *type : types)
    {
        if (dynamic_cast<VuoGenericType *>(type))
        {
            isFullySpecialized = false;
            break;
        }
    }
 
    __block VuoNodeClass *nodeClass;
    if (isFullySpecialized && llvmQueue)
    {
        dispatch_sync(llvmQueue, ^{
                          nodeClass = singleton->newNodeClassWithImplementation(nodeClassName, portNames, types);
                      });
 
        vector<string> typeDependencies;
        for (VuoType *type : types)
        {
            if (type && type->hasCompiler())
            {
                string typeDependency = type->getCompiler()->getDependencyPath();
                if (! typeDependency.empty())
                    typeDependencies.push_back(typeDependency);
            }
        }
 
        std::sort(typeDependencies.begin(), typeDependencies.end());
        auto endOfUnique = std::unique(typeDependencies.begin(), typeDependencies.end());
        typeDependencies.erase(endOfUnique, typeDependencies.end());
 
        VuoCompilerPublishedNodeClass *publishedNodeClass = static_cast<VuoCompilerPublishedNodeClass *>(nodeClass->getCompiler());
        publishedNodeClass->makeDependencies = VuoMakeDependencies::createFromComponents(VuoMakeDependencies::getPlaceholderCompiledFilePath(), typeDependencies);
    }
    else
    {
        nodeClass = singleton->newNodeClassWithoutImplementation(nodeClassName, portNames, types);
    }
 
    return nodeClass;
}
 
bool VuoCompilerPublishedNodeClass::isPublishedNodeClassName(const string &nodeClassName)
{
    return nodeClassName == VuoNodeClass::publishedInputNodeClassName ||
            nodeClassName == VuoNodeClass::publishedOutputNodeClassName ||
            VuoStringUtilities::beginsWith(nodeClassName, VuoNodeClass::publishedInputNodeClassName + ".") ||
            VuoStringUtilities::beginsWith(nodeClassName, VuoNodeClass::publishedOutputNodeClassName + ".");
}
 
bool VuoCompilerPublishedNodeClass::parseNodeClassName(string nodeClassName, vector<string> &portNames, vector<string> &typeNames)
{
    string countAndNamesAndTypesStr = VuoStringUtilities::substrAfter(nodeClassName, getNodeClassNamePrefix() + ".");
    if (countAndNamesAndTypesStr.empty())
        return false;
 
    vector<string> countAndNamesAndTypes = VuoStringUtilities::split(countAndNamesAndTypesStr, '.');
    if (countAndNamesAndTypes.empty())
        return false;
 
    string countStr = countAndNamesAndTypes[0];
    int count = atoi(countStr.c_str());
    if (count != (countAndNamesAndTypes.size() - 1) / 2)
        return false;
 
    for (int i = 0; i < count; ++i)
    {
        string portName = countAndNamesAndTypes.at(1 + i);
        portNames.push_back(portName);
 
        string typeName = countAndNamesAndTypes.at(1 + count + i);
        typeNames.push_back(typeName);
    }
 
    return true;
}
 
string VuoCompilerPublishedNodeClass::buildNodeClassName(const vector<string> &portNames, const vector<VuoType *> &types)
{
    vector<string> typeNames;
    for (VuoType *type : types)
        typeNames.push_back(type ? type->getModuleKey() : "event");
 
    return buildNodeClassName(portNames, typeNames);
}
 
string VuoCompilerPublishedNodeClass::buildNodeClassName(const vector<string> &portNames, const vector<string> &typeNames)
{
    vector<string> nodeClassNameParts;
    nodeClassNameParts.push_back(getNodeClassNamePrefix());
 
    ostringstream oss;
    oss << portNames.size();
    nodeClassNameParts.push_back(oss.str());
 
    for (string portName : portNames)
        nodeClassNameParts.push_back(portName);
 
    for (string typeName : typeNames)
        nodeClassNameParts.push_back(typeName);
 
    return VuoStringUtilities::join(nodeClassNameParts, '.');
}
 
string VuoCompilerPublishedNodeClass::buildNodeClassNameFromPorts(const vector<VuoPublishedPort *> &publishedPorts)
{
    vector<string> portNames = formUniquePortNames(publishedPorts);
 
    vector<VuoType *> types;
    for (VuoPublishedPort *publishedPort : publishedPorts)
    {
        VuoType *type = static_cast<VuoCompilerPort *>(publishedPort->getCompiler())->getDataVuoType();
        types.push_back(type);
    }
 
    return buildNodeClassName(portNames, types);
}
 
vector<string> VuoCompilerPublishedNodeClass::formUniquePortNames(const vector<VuoPublishedPort *> &publishedPorts)
{
    set<string> takenPortNames = getReservedPortNames();
 
    vector<string> portNames;
    for (VuoPublishedPort *publishedPort : publishedPorts)
    {
        string uniquePortName = VuoStringUtilities::formUniqueIdentifier(takenPortNames, publishedPort->getClass()->getName());
        portNames.push_back(uniquePortName);
    }
 
    return portNames;
}
 
json_object * VuoCompilerPublishedNodeClass::buildSpecializedModuleDetails(const vector<VuoType *> &types)
{
    map<string, string> specializedForGenericTypeName;
    for (unsigned int i = 0; i < types.size(); ++i)
        if (types[i])
            specializedForGenericTypeName[VuoGenericType::createGenericTypeName(i)] = types[i]->getModuleKey();
 
    return VuoCompilerSpecializedNodeClass::buildSpecializedModuleDetails(specializedForGenericTypeName);
}
 
string VuoCompilerPublishedNodeClass::getFileName(void)
{
    ostringstream hash;
    hash << VuoStringUtilities::hash(getBase()->getModuleKey());
 
    return getNodeClassNamePrefix() + "." + hash.str() + ".vuonode";
}
 
string VuoCompilerPublishedNodeClass::getFileNameForModuleKey(const string &moduleKey)
{
    string prefix = VuoStringUtilities::beginsWith(moduleKey, VuoNodeClass::publishedInputNodeClassName) ?
                        VuoNodeClass::publishedInputNodeClassName :
                        VuoNodeClass::publishedOutputNodeClassName;
 
    ostringstream hash;
    hash << VuoStringUtilities::hash(moduleKey);
 
    return prefix + "." + hash.str() + ".vuonode";
}
 
bool VuoCompilerPublishedNodeClass::isModuleKeyMangledInFileName(const string &fileName)
{
    return true;
}
 
VuoCompilerNode * VuoCompilerPublishedNodeClass::createReplacementBackingNode(VuoNode *nodeToBack, string backingNodeClassName, VuoCompiler *compiler)
{
    vector<string> portNames;
    vector<string> typeNames;
    bool ok = parseNodeClassName(backingNodeClassName, portNames, typeNames);
    if (! ok)
        return NULL;
 
    vector<VuoPublishedPort *> publishedPorts;
    for (int i = 0; i < portNames.size(); ++i)
    {
        string portName = portNames[i];
        string typeName = typeNames[i];
        VuoType *type = (typeName == "event" ? NULL : compiler->getType(typeName)->getBase());
        VuoCompilerPublishedPort *publishedPort = VuoCompilerPublishedPort::newPort(portName, type);
        publishedPorts.push_back( static_cast<VuoPublishedPort *>(publishedPort->getBase()) );
    }
 
    return (dynamic_cast<VuoCompilerPublishedInputNodeClass *>(this) ?
                compiler->createPublishedInputNode(publishedPorts)->getCompiler() :
                compiler->createPublishedOutputNode(publishedPorts)->getCompiler());
}
 
VuoType * VuoCompilerPublishedNodeClass::getOriginalPortType(VuoPortClass *portClass)
{
    return NULL;
}
 
string VuoCompilerPublishedNodeClass::getOriginalGenericNodeClassName(void)
{
    return getNodeClassNamePrefix();
}
 
string VuoCompilerPublishedNodeClass::getOriginalGenericNodeClassDescription(void)
{
    return "";
}
 
VuoNodeSet * VuoCompilerPublishedNodeClass::getOriginalGenericNodeSet(void)
{
    return NULL;
}
 
string VuoCompilerPublishedNodeClass::createUnspecializedNodeClassName(set<VuoPortClass *> portClassesToUnspecialize)
{
    return "";
}
 
string VuoCompilerPublishedNodeClass::createSpecializedNodeClassNameWithReplacement(string genericTypeName, string specializedTypeName)
{
    return "";
}