COP_MicroNode.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.
 *
 */

#pragma once

#include "COP_API.h"

#include <OP/OP_Context.h>

/// If this is defined, COPs will track and check context option dependencies.
#define USE_CONTEXT_OPTIONS_MICRONODE

#ifdef USE_CONTEXT_OPTIONS_MICRONODE

#include <CH/CH_EvalContextFwd.h>
#include <CH/CH_Manager.h>
#include <OP/OP_ContextOptionsMicroNode.h>

/// Base type of a micronode in COPs.
typedef OP_ContextOptionsMicroNode COP_BaseMicroNode;

/// Returns whether the micronode requires updating given the context.
SYS_FORCE_INLINE bool
COPmicroNodeRequiresUpdate(const COP_BaseMicroNode& dep,
                           const OP_Context& context)
{
    return dep.requiresUpdateTimeOrOptions(context);
}
/// Returns whether the micronode requires updating in the current evaluation
/// context.
SYS_FORCE_INLINE bool
COPmicroNodeRequiresUpdate(const COP_BaseMicroNode& dep)
{
    CH_Manager* chman = CHgetManager();
    const CH_EvalContext& context = chman->evalContext(SYSgetSTID());
    DEP_ContextOptionsReadHandle options = context.contextOptions();
    if (options.isNull())
        options = chman->getDefaultContextOptions();
    return dep.requiresUpdate(context.time()) ||
           dep.requiresUpdateOptions(options, context.contextOptionsStack());
}

/// Marks the micronode clean with respect to the given context.
SYS_FORCE_INLINE void
COPupdateMicroNode(COP_BaseMicroNode& dep, const OP_Context& context)
{
    dep.inheritTimeDependentFromExplicitInputs();
    dep.inheritContextOptionDepsFromExplicitInputs({});
    dep.updateOptions(context);
    dep.update(context.getTime());
}
/// Marks the micronode clean with respect to the current evaluation context.
SYS_FORCE_INLINE void
COPupdateMicroNode(COP_BaseMicroNode& dep)
{
    CH_Manager* chman = CHgetManager();
    const CH_EvalContext& context = chman->evalContext(SYSgetSTID());
    DEP_ContextOptionsReadHandle options = context.contextOptions();
    if (options.isNull())
        options = chman->getDefaultContextOptions();
    dep.inheritTimeDependentFromExplicitInputs();
    dep.inheritContextOptionDepsFromExplicitInputs({});
    dep.updateOptions(options, context.contextOptionsStack());
    dep.update(context.time());
}

#else           // USE_CONTEXT_OPTIONS_MICRONODE

#include <DEP/DEP_TimedMicroNode.h>

/// Base type of a micronode in COPs.
typedef DEP_TimedMicroNode COP_BaseMicroNode;

/// Returns whether the micronode requires updating given the context.
SYS_FORCE_INLINE bool
COPmicroNodeRequiresUpdate(const COP_BaseMicroNode& dep,
                           const OP_Context& context)
{
    return dep.requiresUpdate(context.getTime());
}
/// Returns whether the micronode requires updating in the current evaluation
/// context.
SYS_FORCE_INLINE bool
COPmicroNodeRequiresUpdate(const COP_BaseMicroNode& dep)
{
    const CH_EvalContext& context = CHgetManager()->evalContext(SYSgetSTID());
    return dep.requiresUpdate(context.time());
}

/// Marks the micronode clean with respect to the given context.
SYS_FORCE_INLINE void
COPupdateMicroNode(COP_BaseMicroNode& dep, const OP_Context& context)
{
    dep.inheritTimeDependentFromExplicitInputs();
    dep.update(context.getTime());
}
/// Marks the micronode clean with respect to the current evaluation context.
SYS_FORCE_INLINE void
COPupdateMicroNode(COP_BaseMicroNode& dep)
{
    const CH_EvalContext& context = CHgetManager()->evalContext(SYSgetSTID());
    dep.inheritTimeDependentFromExplicitInputs();
    dep.update(context.time());
}

#endif          // USE_CONTEXT_OPTIONS_MICRONODE

/// This micronode can invoke a callback when it becomes dirty. It's used by
/// COP_ApexProgram's callback registration, to make sure a function runs when
/// the program's results are changed.
class COP_API COP_MicroNodeWithCallback : public COP_BaseMicroNode
{
public:
    COP_MicroNodeWithCallback() :
        COP_BaseMicroNode(), myCallback(nullptr), myEnabled(false)
    {
    }

    /// Controls whether or not the callback runs when the micronode is dirtied.
    void enableCallback(bool enable)
    {
        myEnabled = enable;
    }

    /// Returns true if the callback is enabled (even if not set).
    bool callbackEnabled() const
    {
        return myEnabled;
    }

    /// Set the callback to run when the micronode is dirtied. The callback will
    /// only be invoked if enableCallback(true) was previously called. The data
    /// pointer is passed to the callback function when it's executed.
    void setCallback(void (*callback)(void*), void* data)
    {
        myCallback = callback;
        myData = data;
    }

    void becameDirty(DEP_MicroNode& src, const DEP_PropagateData& propdata)
        override;

private:
    void                          (*myCallback)(void*);
    void*                           myData;
    bool                            myEnabled;
};