VuoCompilerCable.cc

Go to the documentation of this file.

 
#include <sstream>
 
#include "VuoCable.hh"
#include "VuoCompilerCable.hh"
#include "VuoCompilerInputEventPort.hh"
#include "VuoCompilerNode.hh"
#include "VuoCompilerPortClass.hh"
#include "VuoCompilerType.hh"
#include "VuoNode.hh"
#include "VuoNodeClass.hh"
#include "VuoPort.hh"
 
VuoCompilerCable::VuoCompilerCable(VuoCompilerNode * fromNode, VuoCompilerPort * fromPort, VuoCompilerNode * toNode, VuoCompilerPort * toPort, bool addCableToPorts)
    : VuoBaseDetail<VuoCable>("VuoCompilerCable",
                                new VuoCable(   fromNode? fromNode->getBase() : NULL,
                                                fromPort? fromPort->getBase() : NULL,
                                                toNode? toNode->getBase() : NULL,
                                                toPort? toPort->getBase() : NULL,
                                                addCableToPorts))
{
    getBase()->setCompiler(this);
    isAlwaysEventOnly = false;
    isHidden = false;
}
 
void VuoCompilerCable::setAlwaysEventOnly(bool isEventOnly)
{
    this->isAlwaysEventOnly = isEventOnly;
}
 
bool VuoCompilerCable::getAlwaysEventOnly()
{
    return this->isAlwaysEventOnly;
}
 
void VuoCompilerCable::setHidden(bool hidden)
{
    this->isHidden = hidden;
}
 
bool VuoCompilerCable::getHidden()
{
    return this->isHidden;
}
 
bool VuoCompilerCable::portHasData(VuoPort *port)
{
    return (port &&
            (port->getClass()->getPortType() == VuoPortClass::dataAndEventPort ||
             (port->getClass()->hasCompiler() && static_cast<VuoCompilerPortClass *>(port->getClass()->getCompiler())->getDataVuoType())));
}
 
string VuoCompilerCable::getGraphvizDeclaration(void)
{
    ostringstream declaration;
 
    VuoNode *fromNode = getBase()->getFromNode();
    VuoPort *fromPort = getBase()->getFromPort();
    VuoNode *toNode = getBase()->getToNode();
    VuoPort *toPort = getBase()->getToPort();
 
    if ((fromNode || getBase()->isPublishedInputCable())
            && (toNode || getBase()->isPublishedOutputCable())
            && fromPort && toPort)
    {
        string fromNodeIdentifier = (getBase()->isPublishedInputCable() ?
                                         VuoNodeClass::publishedInputNodeIdentifier :
                                         (fromNode->hasCompiler() ?
                                              fromNode->getCompiler()->getGraphvizIdentifier() :
                                              fromNode->getRawGraphvizIdentifier()));
        string toNodeIdentifier = (getBase()->isPublishedOutputCable() ?
                                       VuoNodeClass::publishedOutputNodeIdentifier :
                                       (toNode->hasCompiler() ?
                                            toNode->getCompiler()->getGraphvizIdentifier() :
                                            toNode->getRawGraphvizIdentifier()));
 
        declaration << fromNodeIdentifier << ":" << fromPort->getClass()->getName() << " -> "
                    << toNodeIdentifier << ":" << toPort->getClass()->getName();
 
        // Cable attributes
        bool isExplicitlyEventOnly = (isAlwaysEventOnly && portHasData( getBase()->getFromPort() ) && portHasData( getBase()->getToPort() ));
        if (isExplicitlyEventOnly || isHidden)
        {
            declaration << " [";
 
            if (isExplicitlyEventOnly)
                declaration << "event=true";
 
            if (isExplicitlyEventOnly && isHidden)
                declaration << " ";
 
            if (isHidden)
                declaration << "style=invis";
 
            declaration << "]";
        }
 
        declaration << ";";
    }
 
    return declaration.str();
}
 
bool VuoCompilerCable::carriesData(void)
{
    if (isAlwaysEventOnly)
        return false;
 
    VuoPort *fromPort = getBase()->getFromPort();
    VuoPort *toPort = getBase()->getToPort();
 
    bool fromPortHasData = portHasData(fromPort);
    bool toPortHasData = portHasData(toPort);
 
    // If not currently connected to a 'From' port, decide on the basis of the 'To' port alone.
    if (! fromPort)
        return toPortHasData;
 
    // If not currently connected to a 'To' port, decide on the basis of the 'From' port alone.
    else if (! toPort)
        return fromPortHasData;
 
    // If connected at both ends, the cable carries data if and only if each of its connected ports contain data.
    else
        return (fromPortHasData && toPortHasData);
}
 
void VuoCompilerCable::generateTransmission(Module *module, BasicBlock *block, Value *toNodeContextValue, Value *toPortContextValue,
                                            Value *outputDataPointer, bool shouldTransmitEvent)
{
    VuoCompilerInputEventPort *inputEventPort = static_cast<VuoCompilerInputEventPort *>(getBase()->getToPort()->getCompiler());
 
    if (outputDataPointer)
    {
        outputDataPointer = inputEventPort->getDataType()->convertToPortData(block, outputDataPointer);
        inputEventPort->generateReplaceData(module, block, toNodeContextValue, outputDataPointer, toPortContextValue);
    }
 
    if (shouldTransmitEvent)
        inputEventPort->generateStoreEvent(module, block, toNodeContextValue, true, toPortContextValue);
}