CE_SnippetCache.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: CE_SnippetCach.h ( CE Library, C++)
 *
 * COMMENTS: Proivdes a way to create caches for snippet -> code
 */

#ifndef __CE_SnippetCache__
#define __CE_SnippetCache__

#include "CE_API.h"
#include "CE_Precision.h"
#include "CE_Snippet.h"

#include <UT/UT_String.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_Vector4.h>
#include <UT/UT_Array.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_StringMap.h>
#include <UT/UT_Ramp.h>
#include <UT/UT_Error.h>
#include <UT/UT_Lock.h>

class UT_ErrorManager;
class UT_Options;

class CE_API CE_SnippetCacheEntry
{
public:
    struct SnippetParms
    {
        UT_StringHolder myKernelName, myWritebackName;
        CE_Snippet::RunOver    myRunOver = CE_Snippet::RunOver::INVALID;
        bool            myImportPrequel = false;
        bool            myAlign = false;
        bool            myVDBTiles = false;
        bool            myTimeInc = false;
        bool            myTime = false;
        bool            mySimFrame = false;
        bool            myIteration = false;
        bool            myXNoise = false;
        bool operator==(const SnippetParms &a) const
        {
            if (myWritebackName != a.myWritebackName) return false;
            if (myKernelName != a.myKernelName) return false;
            if (myRunOver != a.myRunOver) return false;
            if (myImportPrequel != a.myImportPrequel) return false;
            if (myAlign != a.myAlign) return false;
            if (myVDBTiles != a.myVDBTiles) return false;
            if (myTimeInc != a.myTimeInc) return false;
            if (myTime != a.myTime) return false;
            if (mySimFrame != a.mySimFrame) return false;
            if (myIteration != a.myIteration) return false;
            if (myXNoise != a.myXNoise) return false;
            return true;
        }
        bool operator!=(const SnippetParms &a) const
        {
            return !(*this == a);
        }
    };
    cl::Program lookupCode(UT_StringRef attriboption) const;
    void        stashCode(UT_StringRef attriboption, cl::Program prog);
    bool        validate(const UT_Array<CE_Snippet::Binding> &bindings,
                         SnippetParms parms) const;

    UT_StringHolder     expandedCode() const { return myExpandedCode; }
    CE_Snippet::RunOver runover() const { return myFinalRunOver; }
    const UT_Array<CE_Snippet::Binding> &overlayBindings() const { return myOverlayBindings; }

protected:
    UT_StringHolder               myExpandedCode;

    // Initial values
    SnippetParms                  myInitialParms;
    UT_Array<CE_Snippet::Binding> myInitialBindings;

    CE_Snippet::RunOver           myFinalRunOver;
    UT_Array<CE_Snippet::Binding> myOverlayBindings;

    // We have a separate program per attribute option.
    mutable UT_Lock               myProgLock;
    UT_StringMap<cl::Program>     myProgs;
    friend class CE_SnippetCache;
};

using CE_SnippetCacheEntrySPtr = UT_SharedPtr<CE_SnippetCacheEntry>;

class CE_API CE_SnippetCache
{
public:
    CE_SnippetCacheEntrySPtr    findSnippet(UT_StringRef code) const;
    void                        purgeSnippet(UT_StringRef code);

    CE_SnippetCacheEntrySPtr    cacheSnippet(
            const UT_StringHolder &code,
            const UT_StringHolder &expandedcode,
            CE_Snippet::RunOver finalrunover,
            const UT_Array<CE_Snippet::Binding> &overlaybindings,
            const UT_Array<CE_Snippet::Binding> &initialbindings,
            CE_SnippetCacheEntry::SnippetParms parms);

protected:
    mutable UT_Lock                             myLock;
    UT_StringMap<CE_SnippetCacheEntrySPtr>      myCache;
};

#endif