VuoRunningCompositionLibraries.cc

Go to the documentation of this file.

 
#include "VuoRunningCompositionLibraries.hh"
#include "VuoFileUtilities.hh"
 
VuoRunningCompositionLibraries::VuoRunningCompositionLibraries(void)
{
    shouldDeleteResourceLibraries = false;
}
 
VuoRunningCompositionLibraries::~VuoRunningCompositionLibraries(void)
{
    if (shouldDeleteResourceLibraries)
        for (vector<string>::iterator i = resourcePathsLoaded.begin(); i != resourcePathsLoaded.end(); ++i)
            VuoFileUtilities::deleteFile(*i);
 
    for (auto i : cachePathLoadedCallbacks)
        i.second();
}
 
void VuoRunningCompositionLibraries::enqueueResourceLibraryToLoad(const string &path, const set<string> &dependenciesInLibrary,
                                                                  bool isUnloadable)
{
    if (find(resourcePathsLoaded.begin(), resourcePathsLoaded.end(), path) == resourcePathsLoaded.end() ||
            find(resourcePathsToUnload.begin(), resourcePathsToUnload.end(), path) != resourcePathsToUnload.end())
    {
        resourcePathsToLoad.push_back(path);
        canUnloadPathToLoad[path] = isUnloadable;
        dependenciesToLoad[path] = dependenciesInLibrary;
    }
}
 
void VuoRunningCompositionLibraries::enqueueResourceLibraryToUnload(const string &path)
{
    if (find(resourcePathsLoaded.begin(), resourcePathsLoaded.end(), path) != resourcePathsLoaded.end())
    {
        if (! canUnloadPathLoaded[path])
        {
            VUserLog("The resource library %s can't be unloaded.", path.c_str());
            return;
        }
 
        resourcePathsToUnload.insert(path);
    }
}
 
set<string> VuoRunningCompositionLibraries::enqueueAllUnloadableResourceLibrariesToUnload(void)
{
    set<string> dependenciesInLibraries;
 
    for (string path : resourcePathsLoaded)
    {
        if (canUnloadPathLoaded[path])
        {
            resourcePathsToUnload.insert(path);
            dependenciesInLibraries.insert( dependenciesLoaded[path].begin(), dependenciesLoaded[path].end() );
        }
    }
 
    return dependenciesInLibraries;
}
 
void VuoRunningCompositionLibraries::enqueueCacheLibraryToLoad(const string &path, const set<string> &dependenciesInLibrary,
                                                               bool isUnloadable, CallbackType doAfterLoadAttempted)
{
    if (find(cachePathsLoaded.begin(), cachePathsLoaded.end(), path) == cachePathsLoaded.end() ||
            find(cachePathsToUnload.begin(), cachePathsToUnload.end(), path) != cachePathsToUnload.end())
    {
        cachePathsToLoad.push_back(path);
        canUnloadPathToLoad[path] = isUnloadable;
        dependenciesToLoad[path] = dependenciesInLibrary;
        cachePathLoadedCallbacks[path] = doAfterLoadAttempted;
    }
}
 
set<string> VuoRunningCompositionLibraries::enqueueCacheLibraryToUnload(const string &path)
{
    if (find(cachePathsLoaded.begin(), cachePathsLoaded.end(), path) != cachePathsLoaded.end())
    {
        if (! canUnloadPathLoaded[path])
        {
            VUserLog("The cache library %s can't be unloaded.", path.c_str());
            return {};
        }
 
        cachePathsToUnload.insert(path);
    }
    else if (find(cachePathsToUnload.begin(), cachePathsToUnload.end(), path) == cachePathsToUnload.end())
    {
        return {};
    }
 
    return dependenciesLoaded[path];
}
 
void VuoRunningCompositionLibraries::enqueueLibraryContainingDependencyToUnload(const string &dependency)
{
    for (map<string, set<string> >::iterator i = dependenciesLoaded.begin(); i != dependenciesLoaded.end(); ++i)
    {
        if (i->second.find(dependency) != i->second.end())
        {
            string libraryPath = i->first;
 
            if (! canUnloadPathLoaded[libraryPath])
            {
                VUserLog("The library containing %s (%s) can't be unloaded.", dependency.c_str(), libraryPath.c_str());
                break;
            }
 
            if (find(resourcePathsLoaded.begin(), resourcePathsLoaded.end(), libraryPath) != resourcePathsLoaded.end())
                resourcePathsToUnload.insert(libraryPath);
            if (find(cachePathsLoaded.begin(), cachePathsLoaded.end(), libraryPath) != cachePathsLoaded.end())
                cachePathsToUnload.insert(libraryPath);
 
            break;
        }
    }
}
 
vector<string> VuoRunningCompositionLibraries::dequeueLibrariesToLoad(vector<CallbackType> &doAfterLoadAttempted)
{
    vector<string> libraryPathsToLoad;
 
    for (vector<string>::iterator i = cachePathsLoaded.begin(); i != cachePathsLoaded.end(); ++i)
        if (canUnloadPathLoaded[*i])
            libraryPathsToLoad.push_back(*i);
 
    libraryPathsToLoad.insert(libraryPathsToLoad.end(), cachePathsToLoad.begin(), cachePathsToLoad.end());
 
    for (const string &cachePath : cachePathsToLoad)
    {
        auto callbackIter = cachePathLoadedCallbacks.find(cachePath);
        if (callbackIter != cachePathLoadedCallbacks.end())
        {
            doAfterLoadAttempted.push_back(callbackIter->second);
            cachePathLoadedCallbacks.erase(callbackIter);
        }
    }
 
    for (vector<string>::iterator i = resourcePathsLoaded.begin(); i != resourcePathsLoaded.end(); ++i)
        if (canUnloadPathLoaded[*i])
            libraryPathsToLoad.push_back(*i);
 
    libraryPathsToLoad.insert(libraryPathsToLoad.end(), resourcePathsToLoad.begin(), resourcePathsToLoad.end());
 
    resourcePathsLoaded.insert(resourcePathsLoaded.end(), resourcePathsToLoad.begin(), resourcePathsToLoad.end());
    resourcePathsToLoad.clear();
 
    cachePathsLoaded.insert(cachePathsLoaded.end(), cachePathsToLoad.begin(), cachePathsToLoad.end());
    cachePathsToLoad.clear();
 
    dependenciesLoaded.insert(dependenciesToLoad.begin(), dependenciesToLoad.end());
    dependenciesToLoad.clear();
 
    canUnloadPathLoaded.insert(canUnloadPathToLoad.begin(), canUnloadPathToLoad.end());
    canUnloadPathToLoad.clear();
 
    return libraryPathsToLoad;
}
 
vector<string> VuoRunningCompositionLibraries::dequeueLibrariesToUnload(void)
{
    for (set<string>::iterator i = resourcePathsToUnload.begin(); i != resourcePathsToUnload.end(); ++i)
    {
        dependenciesLoaded.erase(*i);
        canUnloadPathLoaded.erase(*i);
 
        if (shouldDeleteResourceLibraries)
            VuoFileUtilities::deleteFile(*i);
    }
 
    for (set<string>::iterator i = cachePathsToUnload.begin(); i != cachePathsToUnload.end(); ++i)
    {
        dependenciesLoaded.erase(*i);
        canUnloadPathLoaded.erase(*i);
    }
 
    for (int i = resourcePathsLoaded.size()-1; i >= 0; --i)
        if (find(resourcePathsToUnload.begin(), resourcePathsToUnload.end(), resourcePathsLoaded[i]) != resourcePathsToUnload.end())
            resourcePathsLoaded.erase(resourcePathsLoaded.begin() + i);
 
    for (int i = cachePathsLoaded.size()-1; i >= 0; --i)
        if (find(cachePathsToUnload.begin(), cachePathsToUnload.end(), cachePathsLoaded[i]) != cachePathsToUnload.end())
            cachePathsLoaded.erase(cachePathsLoaded.begin() + i);
 
    vector<string> libraryPathsToUnload;
 
    libraryPathsToUnload.insert(libraryPathsToUnload.end(), resourcePathsToUnload.rbegin(), resourcePathsToUnload.rend());
 
    for (vector<string>::reverse_iterator i = resourcePathsLoaded.rbegin(); i != resourcePathsLoaded.rend(); ++i)
        if (canUnloadPathLoaded[*i])
            libraryPathsToUnload.push_back(*i);
 
    libraryPathsToUnload.insert(libraryPathsToUnload.end(), cachePathsToUnload.rbegin(), cachePathsToUnload.rend());
 
    for (vector<string>::reverse_iterator i = cachePathsLoaded.rbegin(); i != cachePathsLoaded.rend(); ++i)
        if (canUnloadPathLoaded[*i])
            libraryPathsToUnload.push_back(*i);
 
    resourcePathsToUnload.clear();
    cachePathsToUnload.clear();
 
    return libraryPathsToUnload;
}
 
vector<string> VuoRunningCompositionLibraries::getNonUnloadableLibrariesLoaded(void)
{
    vector<string> libraryPathsLoaded;
 
    for (vector<string>::iterator i = cachePathsLoaded.begin(); i != cachePathsLoaded.end(); ++i)
        if (! canUnloadPathLoaded[*i])
            libraryPathsLoaded.push_back(*i);
 
    for (vector<string>::iterator i = resourcePathsLoaded.begin(); i != resourcePathsLoaded.end(); ++i)
        if (! canUnloadPathLoaded[*i])
            libraryPathsLoaded.push_back(*i);
 
    return libraryPathsLoaded;
}
 
vector<string> VuoRunningCompositionLibraries::getUnloadableLibrariesLoaded(void)
{
    vector<string> libraryPathsLoaded;
 
    for (vector<string>::iterator i = cachePathsLoaded.begin(); i != cachePathsLoaded.end(); ++i)
        if (canUnloadPathLoaded[*i] && cachePathsToUnload.find(*i) == cachePathsToUnload.end())
            libraryPathsLoaded.push_back(*i);
 
    for (vector<string>::iterator i = resourcePathsLoaded.begin(); i != resourcePathsLoaded.end(); ++i)
        if (canUnloadPathLoaded[*i] && resourcePathsToUnload.find(*i) == resourcePathsToUnload.end())
            libraryPathsLoaded.push_back(*i);
 
    return libraryPathsLoaded;
}
 
vector<string> VuoRunningCompositionLibraries::getUnloadableResourceLibrariesLoaded(void)
{
    vector<string> unloadableResourcePathsLoaded;
 
    for (vector<string>::iterator i = resourcePathsLoaded.begin(); i != resourcePathsLoaded.end(); ++i)
        if (canUnloadPathLoaded[*i] && resourcePathsToUnload.find(*i) == resourcePathsToUnload.end())
            unloadableResourcePathsLoaded.push_back(*i);
 
    return unloadableResourcePathsLoaded;
}
 
vector<string> VuoRunningCompositionLibraries::getUnloadableCacheLibrariesLoaded(void)
{
    vector<string> unloadableCachePathsLoaded;
 
    for (vector<string>::iterator i = cachePathsLoaded.begin(); i != cachePathsLoaded.end(); ++i)
        if (canUnloadPathLoaded[*i] && cachePathsToUnload.find(*i) == cachePathsToUnload.end())
            unloadableCachePathsLoaded.push_back(*i);
 
    return unloadableCachePathsLoaded;
}
 
map<string, set<string>> VuoRunningCompositionLibraries::getCacheLibrariesEnqueuedToUnload(void)
{
    map<string, set<string>> cachePathsAndDependenciesToUnload;
 
    for (const string &path : cachePathsToUnload)
        cachePathsAndDependenciesToUnload[path] = dependenciesLoaded[path];
 
    return cachePathsAndDependenciesToUnload;
}
 
set<string> VuoRunningCompositionLibraries::getDependenciesLoaded(void)
{
    set<string> dependenciesLoadedSet;
 
    set<string> libraryPathsLoaded;
    vector<string> nonUnloadable = getNonUnloadableLibrariesLoaded();
    vector<string> unloadable = getUnloadableLibrariesLoaded();
    libraryPathsLoaded.insert(nonUnloadable.begin(), nonUnloadable.end());
    libraryPathsLoaded.insert(unloadable.begin(), unloadable.end());
 
    for (set<string>::iterator i = libraryPathsLoaded.begin(); i != libraryPathsLoaded.end(); ++i)
    {
        map<string, set<string> >::iterator j = dependenciesLoaded.find(*i);
        if (j != dependenciesLoaded.end())
            dependenciesLoadedSet.insert(j->second.begin(), j->second.end());
    }
 
    return dependenciesLoadedSet;
}
 
void VuoRunningCompositionLibraries::addExternalLibraries(const set<string> &paths)
{
    externalLibraries.insert(paths.begin(), paths.end());
}
 
void VuoRunningCompositionLibraries::addExternalFrameworks(const set<string> &paths)
{
    externalFrameworks.insert(paths.begin(), paths.end());
}
 
set<string> VuoRunningCompositionLibraries::getExternalLibraries(void)
{
    return externalLibraries;
}
 
set<string> VuoRunningCompositionLibraries::getExternalFrameworks(void)
{
    return externalFrameworks;
}
 
void VuoRunningCompositionLibraries::setDeleteResourceLibraries(bool shouldDeleteResourceLibraries)
{
    this->shouldDeleteResourceLibraries = shouldDeleteResourceLibraries;
}