VuoComposition.cc

Go to the documentation of this file.

 
#include "VuoComposition.hh"
#include "VuoCable.hh"
#include "VuoCompositionMetadata.hh"
#include "VuoProtocol.hh"
#include "VuoPublishedPort.hh"
#include "VuoStringUtilities.hh"
 
VuoComposition::VuoComposition(void)
    : VuoBase<VuoCompilerComposition,VuoRendererComposition>("VuoComposition")
{
    metadata = new VuoCompositionMetadata();
    ownsMetadata = true;
    directory = "";
}
 
VuoComposition::~VuoComposition(void)
{
    if (ownsMetadata)
        delete metadata;
}
 
void VuoComposition::setMetadata(VuoCompositionMetadata *metadata, bool takeOwnership)
{
    if (ownsMetadata)
        delete this->metadata;
 
    this->metadata = metadata;
    ownsMetadata = takeOwnership;
}
 
VuoCompositionMetadata * VuoComposition::getMetadata(void)
{
    return metadata;
}
 
void VuoComposition::setDirectory(string directory)
{
    this->directory = directory;
}
 
string VuoComposition::getDirectory(void)
{
    return directory;
}
 
void VuoComposition::addNode(VuoNode *node)
{
    nodes.insert(node);
}
 
void VuoComposition::removeNode(VuoNode *node)
{
    nodes.erase(node);
}
 
set<VuoNode *> VuoComposition::getNodes(void)
{
    return nodes;
}
 
void VuoComposition::addCable(VuoCable *cable)
{
    cables.insert(cable);
}
 
void VuoComposition::removeCable(VuoCable *cable)
{
    cable->setFrom(NULL, NULL);
    cable->setTo(NULL, NULL);
 
    cables.erase(cable);
}
 
set<VuoCable *> VuoComposition::getCables(void)
{
    return cables;
}
 
void VuoComposition::addComment(VuoComment *comment)
{
    comments.insert(comment);
}
 
void VuoComposition::removeComment(VuoComment *comment)
{
    comments.erase(comment);
}
 
set<VuoComment *> VuoComposition::getComments(void)
{
    return comments;
}
 
void VuoComposition::addPublishedInputPort(VuoPublishedPort *port, int index)
{
    publishedInputPorts.insert(publishedInputPorts.begin() + index, port);
}
 
void VuoComposition::addPublishedOutputPort(VuoPublishedPort *port, int index)
{
    publishedOutputPorts.insert(publishedOutputPorts.begin() + index, port);
}
 
void VuoComposition::removePublishedInputPort(int index)
{
    publishedInputPorts.erase(publishedInputPorts.begin() + index);
}
 
void VuoComposition::removePublishedOutputPort(int index)
{
    publishedOutputPorts.erase(publishedOutputPorts.begin() + index);
}
 
vector<VuoPublishedPort *> VuoComposition::getPublishedInputPorts(void)
{
    return publishedInputPorts;
}
 
vector<VuoPublishedPort *> VuoComposition::getPublishedOutputPorts(void)
{
    return publishedOutputPorts;
}
 
VuoPublishedPort * VuoComposition::getPublishedInputPortWithName(string name)
{
    return getPublishedPortWithName(name, true);
}
 
VuoPublishedPort * VuoComposition::getPublishedOutputPortWithName(string name)
{
    return getPublishedPortWithName(name, false);
}
 
VuoPublishedPort * VuoComposition::getPublishedPortWithName(string name, bool isInput)
{
    vector<VuoPublishedPort *> publishedPorts = (isInput ? publishedInputPorts : publishedOutputPorts);
    for (vector<VuoPublishedPort *>::iterator i = publishedPorts.begin(); i != publishedPorts.end(); ++i)
    {
        VuoPublishedPort *port = *i;
        if (port->getClass()->getName() == name)
            return port;
    }
    return NULL;
}
 
int VuoComposition::getIndexOfPublishedPort(VuoPublishedPort *port, bool isInput)
{
    vector<VuoPublishedPort *> publishedPorts = (isInput ? getPublishedInputPorts() : getPublishedOutputPorts());
    vector<VuoPublishedPort *>::iterator foundPort = find(publishedPorts.begin(), publishedPorts.end(), port);
    if (foundPort != publishedPorts.end())
        return std::distance(publishedPorts.begin(), foundPort);
    else
        return -1;
}
 
vector<VuoPublishedPort *> VuoComposition::getProtocolAwarePublishedPortOrder(VuoProtocol *protocol, bool publishedInputs)
{
    vector<VuoPublishedPort *> publishedPorts = (publishedInputs? publishedInputPorts : publishedOutputPorts);
    vector<VuoPublishedPort *> sortedPublishedPorts;
 
    // First list published ports that are part of the target protocol.
    if (protocol)
    {
        vector<pair<string, string> > protocolPorts = (publishedInputs?
                                                              protocol->getInputPortNamesAndTypes() :
                                                              protocol->getOutputPortNamesAndTypes());
 
        for (vector<pair<string, string> >::const_iterator i = protocolPorts.begin(); i != protocolPorts.end(); ++i)
        {
            string protocolPortName = i->first;
            VuoPublishedPort *compliantPublishedPort = (publishedInputs?
                                                            getPublishedInputPortWithName(protocolPortName) :
                                                            getPublishedOutputPortWithName(protocolPortName));
            if (compliantPublishedPort)
                sortedPublishedPorts.push_back(compliantPublishedPort);
        }
    }
 
    // Next list published ports that are not part of the target protocol.
    for (vector<VuoPublishedPort *>::const_iterator port = publishedPorts.begin(); port != publishedPorts.end(); ++port)
    {
        if (std::find(sortedPublishedPorts.begin(), sortedPublishedPorts.end(), *port) == sortedPublishedPorts.end())
            sortedPublishedPorts.push_back(*port);
    }
 
    return sortedPublishedPorts;
}