GU_AgentFileCache.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        GU_AgentFileCache.h (GU Library, C++)
 *
 * COMMENTS:
 */

#ifndef __GU_AgentFileCache__
#define __GU_AgentFileCache__

#include "GU_API.h"

#include <FS/FS_Info.h>
#include <UT/UT_ConcurrentHashMap.h>
#include <UT/UT_IntrusivePtr.h>
#include <UT/UT_WorkBuffer.h>

template <typename T>
class GU_AgentFileCache
{
public:
    /// Searches for a cached file with the same key, and returns it if the
    /// timestamp matches the file on disk. Otherwise, the callback is invoked
    /// to load the file, which is then inserted into the cache and returned.
    /// The key should include the filename and any dependencies on other agent
    /// files (e.g. when loading the same clip for slightly different rigs).
    template <typename F>
    UT_IntrusivePtr<T> findCachedFileOrLoad(const UT_StringRef &filename,
                                            const UT_StringRef &key,
                                            F load_new_item);

    /// Removes a cached file with the given key.
    void removeCachedFile(const UT_StringRef &key);

private:
    struct CachedFile
    {
        CachedFile(T *ptr = nullptr, time_t mod_time = 0)
            : myPtr(ptr), myModTime(mod_time)
        {
        }

        /// Since we hold a raw pointer and expect the item's destructor to
        /// remove itself from this cache, there is a small time window where
        /// another thread could access this cache and add a reference after
        /// the count has already gone to 0 and triggered the destructor,
        /// resulting in a dangling pointer being returned.
        /// So, we only allow adding a reference if the ref count is not
        /// already 0 - this is the same idea as a weak_ptr::lock().
        ///
        /// Returns nullptr if a reference could not be added because this item
        /// is pending deletion.
        UT_IntrusivePtr<T> tryGetItem() const
        {
            UT_IntrusivePtr<T> ref(myPtr, /* add_ref */ false);
            if (!ref->conditionalAddRef())
                ref.detach(); // Reset without decrementing, since we never incremented.

            return ref;
        }

        time_t getModTime() const { return myModTime; }

    private:
        T      *myPtr;
        time_t  myModTime;
    };

    using CachedFileMap = UT_ConcurrentHashMap<UT_StringHolder, CachedFile>;
    CachedFileMap myFiles;
};

/// Builds a list of paths to use when attempting to load an external file,
/// ordered by priority.
GU_API extern void GUgetAgentFilePaths(UT_StringArray &paths,
                                       const UT_StringHolder &condensed_path,
                                       const UT_StringHolder &expanded_path);

template <typename T>
template <typename F>
inline UT_IntrusivePtr<T>
GU_AgentFileCache<T>::findCachedFileOrLoad(const UT_StringRef &filename,
                                           const UT_StringRef &key,
                                           F load_new_item)
{
    FS_Info info(filename);
    time_t mod_time = 0;
    if (info.hasAccess())
        mod_time = info.getModTime();

    // First, do a quick check to see if there's a valid entry.
    UT_IntrusivePtr<T> item;
    {
        typename CachedFileMap::const_accessor acc;
        if (myFiles.find(acc, UTmakeUnsafeRef(key)) &&
            acc->second.getModTime() == mod_time &&
            (item = acc->second.tryGetItem()))
        {
            return item;
        }
    }

    typename CachedFileMap::accessor acc;
    if (myFiles.insert(acc, key) || acc->second.getModTime() != mod_time
        || !(item = acc->second.tryGetItem()))
    {
        // If the item was not in the cache or is out of date, load it.
        auto new_item = load_new_item();
        if (new_item)
            acc->second = CachedFile(new_item.get(), mod_time);
        else
        {
            // If the item failed to load, remove the empty entry from the map.
            // Note that this erasure might also happen at the same time from
            // removeCachedFile() but that's ok.
            (void) myFiles.erase(acc);
        }

        return new_item;
    }
    else
    {
        UT_ASSERT_P(item);
        return item;
    }
}

template <typename T>
inline void
GU_AgentFileCache<T>::removeCachedFile(const UT_StringRef &key)
{
    myFiles.erase(key);
}

#endif