VuoModuleInfo.cc

Go to the documentation of this file.

 
#include "VuoModuleInfo.hh"
#include "VuoCompiler.hh"
#include "VuoCompilerEnvironment.hh"
#include "VuoCompilerGraphvizParser.hh"
#include "VuoCompilerModule.hh"
#include <sys/time.h>
 
VuoModuleInfo::VuoModuleInfo(VuoCompilerEnvironment *environment, const string &searchPath, const string &relativePath,
                             bool isSourceFile, bool isSubcomposition)
{
    VuoFileUtilities::File *file = new VuoFileUtilities::File(searchPath, relativePath);
    initialize(environment, searchPath, file, isSourceFile, isSubcomposition);
}
 
VuoModuleInfo::VuoModuleInfo(VuoCompilerEnvironment *environment, const string &searchPath, VuoFileUtilities::File *file,
                             bool isSourceFile, bool isSubcomposition)
{
    initialize(environment, searchPath, file, isSourceFile, isSubcomposition);
}
 
void VuoModuleInfo::initialize(VuoCompilerEnvironment *environment, const string &searchPath, VuoFileUtilities::File *file,
                               bool isSourceFile, bool isSubcomposition)
{
    this->environment = environment;
    this->searchPath = searchPath;
    this->file = file;
    moduleKey = VuoCompiler::getModuleKeyForPath(file->getRelativePath());
    moduleKeyMangled = VuoCompilerModule::isModuleKeyMangledInFileName(file->getRelativePath());
    sourceCodeOverridden = false;
    lastModified = VuoFileUtilities::getFileLastModifiedInSeconds(file->isInArchive() ? file->getArchivePath() : file->path());
    longestDownstreamPath = 0;
    attempted = false;
    loading = nullptr;
 
#if VUO_PRO
    init_Pro();
#endif
 
    if (isSourceFile)
    {
        loading = dispatch_group_create();
        sourceCode = file->getContentsAsString();
 
        if (isSubcomposition)
        {
            try
            {
                containedNodeClasses = VuoCompilerGraphvizParser::getNodeClassNamesFromCompositionFile(file->path());
            }
            catch (...)
            {
                // Issues parsing the composition will be caught later when compiling it.
            }
        }
    }
}
 
VuoModuleInfo::~VuoModuleInfo(void)
{
#if VUO_PRO
    fini_Pro();
#endif
 
    delete file;
 
    if (loading)
        dispatch_release(loading);
}
 
VuoCompilerEnvironment * VuoModuleInfo::getEnvironment(void) const
{
    return environment;
}
 
string VuoModuleInfo::getSearchPath(void) const
{
    return searchPath;
}
 
string VuoModuleInfo::getModuleKey(void) const
{
    return moduleKey;
}
 
bool VuoModuleInfo::isModuleKeyMangled(void) const
{
    return moduleKeyMangled;
}
 
void VuoModuleInfo::setUnmangledModuleKey(const string &moduleKey)
{
    this->moduleKey = moduleKey;
    moduleKeyMangled = false;
}
 
VuoFileUtilities::File * VuoModuleInfo::getFile(void) const
{
    return file;
}
 
string VuoModuleInfo::getSourceCode(void) const
{
    return sourceCode;
}
 
void VuoModuleInfo::setSourceCode(const string &sourceCode)
{
    this->sourceCode = sourceCode;
}
 
void VuoModuleInfo::revertSourceCode(void)
{
    sourceCode = file->getContentsAsString();
}
 
bool VuoModuleInfo::isSourceCodeOverridden(void) const
{
    return sourceCodeOverridden;
}
 
void VuoModuleInfo::setSourceCodeOverridden(bool overridden)
{
    sourceCodeOverridden = overridden;
}
 
bool VuoModuleInfo::isNewerThan(VuoModuleInfo *other) const
{
    return lastModified > other->lastModified;
}
 
bool VuoModuleInfo::isNewerThan(double ageInSeconds) const
{
    return lastModified > ageInSeconds;
}
 
bool VuoModuleInfo::isOlderThan(double ageInSeconds) const
{
    return lastModified < ageInSeconds;
}
 
void VuoModuleInfo::setLastModifiedToNow(void)
{
    struct timeval t;
    gettimeofday(&t, NULL);
    lastModified = t.tv_sec + t.tv_usec/1000000.0;
}
 
set<string> VuoModuleInfo::getContainedNodeClasses(void) const
{
    return containedNodeClasses;
}
 
int VuoModuleInfo::getLongestDownstreamPath(void) const
{
    return longestDownstreamPath;
}
 
void VuoModuleInfo::setLongestDownstreamPath(int pathLength)
{
    longestDownstreamPath = pathLength;
}
 
bool VuoModuleInfo::getAttempted(void) const
{
    return attempted;
}
 
void VuoModuleInfo::setAttempted(bool attempted)
{
    this->attempted = attempted;
}
 
dispatch_group_t VuoModuleInfo::getLoadingGroup(void) const
{
    return loading;
}
 
void VuoModuleInfo::dump() const
{
    fprintf(stderr, "module %s:\n"
                    "\tloadingGroup=%p\n"
                    "\tsearchPath=%s\n"
                    "\tattempted=%d\n"
                    "\tenvironment=%s\n"
                    "\tfile=%s%s%s\n"
                    "\tsourceCodeOverridden=%d\n"
                    "\tsourceCode=%s\n"
                    "\tcontainedNodeClasses:\n",
            moduleKey.c_str(),
            loading,
            searchPath.c_str(),
            attempted,
            environment->getCompiledModuleCachePath().c_str(),
            file->isInArchive() ? file->getArchivePath().c_str() : "",
            file->isInArchive() ? "::" : "",
            file->isInArchive() ? file->getRelativePath().c_str() : file->path().c_str(),
            sourceCodeOverridden,
            sourceCode.c_str());
    for (auto i: containedNodeClasses)
        fprintf(stderr, "\t\t%s\n", i.c_str());
}