VuoCompilerPublishedOutputNodeClass.cc

Go to the documentation of this file.

 
#include "VuoCompilerPublishedOutputNodeClass.hh"
#include "VuoCompiler.hh"
#include "VuoCompilerCodeGenUtilities.hh"
#include "VuoCompilerConstantsCache.hh"
#include "VuoCompilerInputDataClass.hh"
#include "VuoCompilerInputEventPortClass.hh"
#include "VuoCompilerPublishedPort.hh"
#include "VuoCompilerPublishedPortClass.hh"
#include "VuoCompilerType.hh"
#include "VuoGenericType.hh"
#include "VuoNode.hh"
#include "VuoNodeClass.hh"
#include "VuoPublishedPort.hh"
#include "VuoStringUtilities.hh"
 
 
VuoCompilerPublishedOutputNodeClass * VuoCompilerPublishedOutputNodeClass::singleton = nullptr;
 
VuoCompilerPublishedOutputNodeClass * VuoCompilerPublishedOutputNodeClass::getSingleton(void)
{
    if (! singleton)
        singleton = new VuoCompilerPublishedOutputNodeClass(new VuoNodeClass(VuoNodeClass::publishedOutputNodeClassName, vector<string>(), vector<string>()));
 
    return singleton;
}
 
VuoCompilerPublishedOutputNodeClass::VuoCompilerPublishedOutputNodeClass(string nodeClassName, Module *module) :
    VuoCompilerPublishedNodeClass(nodeClassName, module)
{
}
 
VuoCompilerPublishedOutputNodeClass::VuoCompilerPublishedOutputNodeClass(VuoCompilerPublishedOutputNodeClass *compilerNodeClass) :
    VuoCompilerPublishedNodeClass(compilerNodeClass)
{
}
 
VuoCompilerPublishedOutputNodeClass::VuoCompilerPublishedOutputNodeClass(VuoNodeClass *baseNodeClass) :
    VuoCompilerPublishedNodeClass(baseNodeClass)
{
}
 
VuoNodeClass * VuoCompilerPublishedOutputNodeClass::newNodeClass(string nodeClassName, VuoCompiler *compiler, dispatch_queue_t llvmQueue)
{
    return VuoCompilerPublishedNodeClass::newNodeClass(nodeClassName, compiler, llvmQueue, getSingleton());
}
 
VuoNodeClass * VuoCompilerPublishedOutputNodeClass::newNodeClass(vector<VuoPublishedPort *> publishedOutputPorts, dispatch_queue_t llvmQueue)
{
    return VuoCompilerPublishedNodeClass::newNodeClass(publishedOutputPorts, llvmQueue, getSingleton());
}
 
VuoNodeClass * VuoCompilerPublishedOutputNodeClass::newNodeClassWithImplementation(const string &nodeClassName,
                                                                                   const vector<string> &portNames, const vector<VuoType *> &types)
{
    Module *module = new Module(nodeClassName, *VuoCompiler::globalLLVMContext);
 
    // VuoModuleMetadata({});
    VuoCompilerCodeGenUtilities::generateModuleMetadata(module, "{}", "");
 
    // For published ports a (data+event) and b (event):
    //
    // void nodeEvent
    // (
    //   VuoInputData(<data type>) a,
    //   VuoInputEvent() b,
    //   VuoInputEvent() gather
    // )
    // {
    // }
 
 
    vector<VuoPort *> modelInputPorts;
    for (size_t i = 0; i < portNames.size(); ++i)
    {
        VuoCompilerPublishedPort *modelPort = VuoCompilerPublishedPort::newPort(portNames.at(i), types.at(i));
        modelInputPorts.push_back(modelPort->getBase());
    }
 
    VuoCompilerInputEventPortClass *gatherPortClass = new VuoCompilerInputEventPortClass("gather");
    VuoCompilerPort *gatherPort = gatherPortClass->newPort();
    modelInputPorts.push_back(gatherPort->getBase());
 
    map<VuoPort *, size_t> indexOfDataParameter;
    map<VuoPort *, size_t> indexOfEventParameter;
    VuoCompilerConstantsCache constantsCache(module);
 
    Function *eventFunction = VuoCompilerCodeGenUtilities::getNodeEventFunction(module, "", false, false,
                                                                                nullptr, modelInputPorts, vector<VuoPort *>(),
                                                                                map<VuoPort *, json_object *>(), map<VuoPort *, string>(),
                                                                                map<VuoPort *, string>(), map<VuoPort *, VuoPortClass::EventBlocking>(),
                                                                                indexOfDataParameter, indexOfEventParameter, &constantsCache);
 
    BasicBlock *block = &(eventFunction->getEntryBlock());
    ReturnInst::Create(module->getContext(), block);
 
 
    VuoCompilerPublishedOutputNodeClass *dummyNodeClass = new VuoCompilerPublishedOutputNodeClass(nodeClassName, module);
    VuoCompilerNodeClass *nodeClass = new VuoCompilerPublishedOutputNodeClass(dummyNodeClass);
    delete dummyNodeClass;
 
    nodeClass->getBase()->setDefaultTitle(VuoNodeClass::publishedOutputNodeIdentifier);
    nodeClass->getBase()->setVersion("1.0.0");
 
    return nodeClass->getBase();
}
 
VuoNodeClass * VuoCompilerPublishedOutputNodeClass::newNodeClassWithoutImplementation(const string &nodeClassName,
                                                                                      const vector<string> &portNames, const vector<VuoType *> &types)
{
    vector<VuoPortClass *> inputPortClasses;
    vector<VuoPortClass *> outputPortClasses;
 
    VuoPortClass *refreshPortClass = (new VuoCompilerInputEventPortClass("refresh"))->getBase();
    inputPortClasses.push_back(refreshPortClass);
 
    for (size_t i = 0; i < portNames.size(); ++i)
    {
        VuoCompilerInputEventPortClass *inputPortClass = new VuoCompilerInputEventPortClass(portNames.at(i));
        if (types.at(i))
        {
            VuoCompilerInputDataClass *inputDataClass = new VuoCompilerInputDataClass("");
            inputPortClass->setDataClass(inputDataClass);
            inputPortClass->setDataVuoType(types.at(i));
        }
 
        inputPortClasses.push_back(inputPortClass->getBase());
    }
 
    VuoPortClass *gatherPortClass = (new VuoCompilerInputEventPortClass("gather"))->getBase();
    inputPortClasses.push_back(gatherPortClass);
 
    VuoNodeClass *baseNodeClass = new VuoNodeClass(nodeClassName, refreshPortClass, inputPortClasses, outputPortClasses);
    VuoCompilerNodeClass *nodeClass = new VuoCompilerPublishedOutputNodeClass(baseNodeClass);
 
    nodeClass->getBase()->setDefaultTitle(VuoNodeClass::publishedOutputNodeIdentifier);
 
    return nodeClass->getBase();
}
 
size_t VuoCompilerPublishedOutputNodeClass::getInputPortIndexForPublishedOutputPort(size_t publishedOutputPortIndex)
{
    return VuoNodeClass::unreservedInputPortStartIndex + publishedOutputPortIndex;
}
 
size_t VuoCompilerPublishedOutputNodeClass::getGatherInputPortIndex(void)
{
    return getBase()->getInputPortClasses().size() - 1;
}
 
string VuoCompilerPublishedOutputNodeClass::buildNodeClassName(const vector<VuoPublishedPort *> &publishedOutputPorts)
{
    return getSingleton()->buildNodeClassNameFromPorts(publishedOutputPorts);
}
 
string VuoCompilerPublishedOutputNodeClass::getNodeClassNamePrefix(void)
{
    return VuoNodeClass::publishedOutputNodeClassName;
}
 
set<string> VuoCompilerPublishedOutputNodeClass::getReservedPortNames(void)
{
    set<string> names;
    names.insert("refresh");
    names.insert("gather");
    return names;
}