VuoCompilerIssue.cc

Go to the documentation of this file.

 
#include "VuoCompilerIssue.hh"
 
#include <sstream>
#include "VuoClangIssues.hh"
#include "VuoModule.hh"
#include "VuoShaderIssues.hh"
#include "VuoStringUtilities.hh"
 
static string getLineBreak(bool htmlFormatted, int count = 1)
{
    string lineBreak = (htmlFormatted ? "<br>" : "\n");
    string ret;
    for (int i = 0; i < count; ++i)
        ret += lineBreak;
    return ret;
}
 
VuoCompilerIssue::VuoCompilerIssue(void)
{
    issueType = VuoCompilerIssue::Error;
    module = NULL;
}
 
VuoCompilerIssue::VuoCompilerIssue(IssueType issueType, const string &action, const string &filePath, const string &summary, const string &details)
{
    this->issueType = issueType;
    this->action = action;
    this->filePath = filePath;
    this->summary = summary;
    this->details = details;
    module = NULL;
}
 
string VuoCompilerIssue::getIssueTypeString(void)
{
    string issueTypeStr;
    switch (issueType)
    {
        case Error:
            issueTypeStr = "Error";
            break;
        case Warning:
            issueTypeStr = "Warning";
            break;
    }
 
    return issueTypeStr;
}
 
string VuoCompilerIssue::fillInPlaceholders(const string &s, bool htmlFormatted) const
{
    string ret = s;
 
    {
        string moduleKeyFormatted = moduleKey;
        if (htmlFormatted)
            moduleKeyFormatted = "<code>" + moduleKeyFormatted + "</code>";
        VuoStringUtilities::replaceAll(ret, "%moduleKey", moduleKeyFormatted);
    }
 
    if (module)
    {
        string moduleTitleFormatted = module->getDefaultTitle();
        if (htmlFormatted)
            moduleTitleFormatted = "<code>" + moduleTitleFormatted + "</code>";
        string moduleKeyFormatted = module->getModuleKey();
        if (htmlFormatted)
            moduleKeyFormatted = "<code>" + moduleKeyFormatted + "</code>";
        VuoStringUtilities::replaceAll(ret, "%module", moduleTitleFormatted + " (" + moduleKeyFormatted + ")");
    }
 
    {
        string link = (htmlFormatted ?
                           "<a href=\"" + linkUrl + "\">" + linkText + "</a>" :
                           linkText + " (" + linkUrl + ")");
        VuoStringUtilities::replaceAll(ret, "%link", link);
    }
 
    return ret;
}
 
VuoCompilerIssue::IssueType VuoCompilerIssue::getIssueType(void)
{
    return issueType;
}
 
string VuoCompilerIssue::getSummary(void)
{
    return summary;
}
 
string VuoCompilerIssue::getDetails(bool htmlFormatted) const
{
    return fillInPlaceholders(details, htmlFormatted);
}
 
string VuoCompilerIssue::getShortDescription(bool htmlFormatted) const
{
    string description;
 
    if (! summary.empty())
        description += summary + " — ";
 
    description += getDetails(htmlFormatted);
 
    return description;
}
 
string VuoCompilerIssue::getLongDescription(bool htmlFormatted)
{
    string lineBreak = getLineBreak(htmlFormatted);
 
    string description = getIssueTypeString() + " " + action;
 
    if (! filePath.empty())
    {
        string location = filePath;
 
        if (htmlFormatted)
            location = "<code>" + location + "</code>";
 
        description += " " + location;
    }
 
    description += ":" + lineBreak;
 
    if (! summary.empty())
        description += summary + " — ";
 
    description += getDetails(htmlFormatted);
 
    if (clangIssues && ! clangIssues->isEmpty())
        description += lineBreak + clangIssues->getDescription(lineBreak);
 
    if (shaderIssues && ! shaderIssues->issues().empty())
        description += lineBreak + shaderIssues->getDescription(lineBreak);
 
    return description;
}
 
void VuoCompilerIssue::setHint(const string &hint)
{
    this->hint = hint;
}
 
string VuoCompilerIssue::getHint(bool htmlFormatted)
{
    return fillInPlaceholders(hint, htmlFormatted);
}
 
void VuoCompilerIssue::setHelpPath(const string &path)
{
    this->helpPath = path;
}
 
string VuoCompilerIssue::getHelpPath(void)
{
    return helpPath;
}
 
void VuoCompilerIssue::setFilePath(const string &filePath)
{
    this->filePath = filePath;
}
 
string VuoCompilerIssue::getFilePath(void)
{
    return filePath;
}
 
void VuoCompilerIssue::setModuleKey(const string &moduleKey)
{
    this->moduleKey = moduleKey;
}
 
void VuoCompilerIssue::setLink(const string &url, const string &text)
{
    linkUrl = url;
    linkText = text;
}
 
void VuoCompilerIssue::setModule(VuoModule *module)
{
    this->module = module;
}
 
void VuoCompilerIssue::setNode(VuoNode *node)
{
    nodes.clear();
    nodes.insert(node);
}
 
void VuoCompilerIssue::setNodes(const set<VuoNode *> &nodes)
{
    this->nodes = nodes;
}
 
set<VuoNode *> VuoCompilerIssue::getNodes(void)
{
    return nodes;
}
 
void VuoCompilerIssue::setCables(const set<VuoCable *> &cables)
{
    this->cables = cables;
}
 
set<VuoCable *> VuoCompilerIssue::getCables(void)
{
    return cables;
}
 
void VuoCompilerIssue::setClangIssues(shared_ptr<VuoClangIssues> clangIssues)
{
    this->clangIssues = clangIssues;
}
 
void VuoCompilerIssue::setShaderIssues(shared_ptr<VuoShaderIssues> shaderIssues)
{
    this->shaderIssues = shaderIssues;
}
 
shared_ptr<VuoShaderIssues> VuoCompilerIssue::getShaderIssues(void)
{
    return shaderIssues;
}
 
long VuoCompilerIssue::getHash(void)
{
    ostringstream s;
 
    s << getLongDescription(false);
 
    vector<string> nodeStrings;
    for (set<VuoNode *>::iterator i = nodes.begin(); i != nodes.end(); ++i)
    {
        ostringstream ss;
        ss << *i;
        nodeStrings.push_back(ss.str());
    }
    sort(nodeStrings.begin(), nodeStrings.end());
    s << "[" << VuoStringUtilities::join(nodeStrings, ',') << "]";
 
    vector<string> cableStrings;
    for (set<VuoCable *>::iterator i = cables.begin(); i != cables.end(); ++i)
    {
        ostringstream ss;
        ss << *i;
        cableStrings.push_back(ss.str());
    }
    s << "[" << VuoStringUtilities::join(cableStrings, ',') << "]";
 
    return VuoStringUtilities::hash(s.str());
}
 
 
VuoCompilerIssues::VuoCompilerIssues(void)
{
}
 
VuoCompilerIssues::VuoCompilerIssues(const VuoCompilerIssue &issue)
{
    issues.push_back(issue);
}
 
string VuoCompilerIssues::getShortDescription(bool htmlFormatted)
{
    vector<string> uniqueDescriptions;
    for (vector<VuoCompilerIssue>::iterator i = issues.begin(); i != issues.end(); ++i)
    {
        string description = (*i).getShortDescription(htmlFormatted);
        if (find(uniqueDescriptions.begin(), uniqueDescriptions.end(), description) == uniqueDescriptions.end())
            uniqueDescriptions.push_back(description);
    }
 
    return VuoStringUtilities::join(uniqueDescriptions, getLineBreak(htmlFormatted, 2));
}
 
string VuoCompilerIssues::getLongDescription(bool htmlFormatted)
{
    vector<string> uniqueDescriptions;
    for (vector<VuoCompilerIssue>::iterator i = issues.begin(); i != issues.end(); ++i)
    {
        string description = (*i).getLongDescription(htmlFormatted);
        if (find(uniqueDescriptions.begin(), uniqueDescriptions.end(), description) == uniqueDescriptions.end())
            uniqueDescriptions.push_back(description);
    }
 
    return VuoStringUtilities::join(uniqueDescriptions, getLineBreak(htmlFormatted, 2));
}
 
string VuoCompilerIssues::getHint(bool htmlFormatted)
{
    vector<string> uniqueHints;
    for (vector<VuoCompilerIssue>::iterator i = issues.begin(); i != issues.end(); ++i)
    {
        string hint = (*i).getHint(htmlFormatted);
        if (! hint.empty() && find(uniqueHints.begin(), uniqueHints.end(), hint) == uniqueHints.end())
            uniqueHints.push_back(hint);
    }
 
    return VuoStringUtilities::join(uniqueHints, getLineBreak(htmlFormatted, 2));
}
 
void VuoCompilerIssues::setFilePathIfEmpty(const string &filePath)
{
    for (VuoCompilerIssue &issue : issues)
        if (issue.getFilePath().empty())
            issue.setFilePath(filePath);
}
 
void VuoCompilerIssues::setFilePath(const string &filePath)
{
    for (VuoCompilerIssue &issue : issues)
        issue.setFilePath(filePath);
}
 
void VuoCompilerIssues::setFilePath(std::function<string(const string &)> generateFilePath)
{
    for (VuoCompilerIssue &issue : issues)
        issue.setFilePath( generateFilePath(issue.getFilePath()) );
}
 
void VuoCompilerIssues::append(const VuoCompilerIssue &issue)
{
    issues.push_back(issue);
}
 
void VuoCompilerIssues::append(VuoCompilerIssues *otherIssues)
{
    issues.insert(issues.end(), otherIssues->issues.begin(), otherIssues->issues.end());
}
 
bool VuoCompilerIssues::isEmpty(void)
{
    return issues.empty();
}
 
vector<VuoCompilerIssue> VuoCompilerIssues::getList(void)
{
    return issues;
}
 
VuoCompilerIssues * VuoCompilerIssues::getErrors(void)
{
    VuoCompilerIssues *errors = new VuoCompilerIssues();
    for (vector<VuoCompilerIssue>::iterator i = issues.begin(); i != issues.end(); ++i)
        if ((*i).getIssueType() == VuoCompilerIssue::Error)
            errors->append(*i);
 
    return errors;
}
 
bool VuoCompilerIssues::hasErrors(void)
{
    auto isError = [](VuoCompilerIssue issue)
    {
        return issue.getIssueType() == VuoCompilerIssue::Error;
    };
 
    return std::find_if(issues.begin(), issues.end(), isError) != issues.end();
}