APEX_Generic.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:        APEX_Generic.h (APEX Library, C++)
 *
 * COMMENTS:
 */

#ifndef __APEX_GENERIC_H__
#define __APEX_GENERIC_H__

#include "APEX_API.h"
#include "APEX_Buffer.h"
#include "APEX_Callback.h"
#include "APEX_Include.h"
#include "APEX_Types.h"

#include <UT/UT_Debug.h>
#include <UT/UT_ErrorManager.h>
#include <UT/UT_Options.h>
#include <UT/UT_StringArray.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_Tracing.h>
#include <SYS/SYS_StaticAssert.h>
#include <SYS/SYS_Types.h>

#include <initializer_list>
#include <type_traits>


namespace UT { namespace Format { class ArgValue; } }

namespace apex
{

class APEX_Graph;
class APEX_Program;
class APEX_ProgramCounter;

/// APEX callbacks defined using APEX_GenericFunctionRunData whose RunData inherits from this class
/// will be automatically provided with a UT_ErrorManager for reporting computation errors.
class APEX_API APEX_RunDataErrorBase
{
public:
    /// Extract the error manager from the program.
    /// @internal implemented in .C to avoid depending on APEX_Program.h
    void initializeFromCompileArguments(
            const APEX_Graph *in_graph,
            APEX_NodeID for_node,
            APEX_Program *bind_to);

    /// Add a string error using format()-style arguments
    template <typename... Args>
    void addError(const char *fmt, const Args &...args) const
    {
        addError(fmt, {args...});
    }

    /// Add a string warning using format()-style arguments
    template <typename... Args>
    void addWarning(const char *fmt, const Args &...args) const
    {
        addWarning(fmt, {args...});
    }

    /// Add a string message using format()-style arguments
    template <typename... Args>
    void addMessage(const char *fmt, const Args &...args) const
    {
        addMessage(fmt, {args...});
    }

    /// Accesssors
    /// @{
    const UT_ErrorManager &errorManager() const { return *myErrorManager; }
    const UT_StringHolder &nodePath() const { return myNodePath; }
    /// @}

    /// Steal errors from another error manager
    void stealErrors(UT_ErrorManager &err_mgr)
    {
        myErrorManager->stealErrors(err_mgr);
    }

private:
    void addError(const char *fmt, std::initializer_list<UT::Format::ArgValue> args) const;
    void addWarning(const char *fmt, std::initializer_list<UT::Format::ArgValue> args) const;
    void addMessage(const char *fmt, std::initializer_list<UT::Format::ArgValue> args) const;

private:
    /// Error manager to send errors to.
    UT_ErrorManager *myErrorManager;
    /// Full path to the node that this callback is implementing (useful for prefixing errors)
    UT_StringHolder myNodePath;
    // FIXME: This should also pull out things like the callback name for formatting the errors with
    // some source information.
};

template <typename C, typename... Ts>
class APEX_GenericFunctionRunData : public APEX_FunctionBase
{
public:
    APEX_GenericFunctionRunData()
    {
        if constexpr (!std::is_null_pointer_v<decltype(C::argnames)>)
        {
            static_assert(
                sizeof...(Ts) == std::size(C::argnames),
                "Callback argnames size does not match template argument size");
        }

        myName = C::funcname.c_str();
        mySignature = makeSignature<Ts...>(C::argnames);
        UT_Options defaults;
        defaults.setFromPyDictionary(C::parm_defaults);
        myDefaults->mergeUtOptions(&defaults, false, true, true, &mySignature);
    }

    ~APEX_GenericFunctionRunData() override {}

    const UT_StringHolder &getName() const override { return myName; }

    static constexpr const char *parm_defaults = "";

    struct RunDataT : C::RunData
    {
    };
    const APEX_TypeDefinitionBase *runDataTypeDef() const override
    {
        return findTypeDef<typename C::RunData>();
    }
    void runDataCompileHook(
            APEX_Argument *rundata_instance,
            const APEX_Graph *in_graph,
            APEX_NodeID for_node,
            APEX_Program *bind_to) const override
    {
        if constexpr (std::is_base_of_v<APEX_RunDataErrorBase, typename C::RunData>)
        {
            auto *rd_error_base = static_cast<APEX_RunDataErrorBase *>(
                    castArg<typename C::RunData>(rundata_instance));
            rd_error_base->initializeFromCompileArguments(in_graph, for_node, bind_to);
        }
    }

    // const APEX_Allocator *allocator() const override { return &myAllocator; };

    const APEX_Signature &signature() const override { return mySignature; };

    APEX_CallbackType callbackType() const override { return APEX_CallbackType::NORMAL; }

    const Dict &parmDefaults() const override { return myDefaults; }

    void addSparePort(const UT_StringRef &name="", exint index = -1)
    {
        mySignature.addSparePort(name, index);
    }

    void execute(APEX_ArgPtrs &arg_ptrs) const override
    {
        utZoneScopedN(C::funcname);

        const auto &derived = static_cast<const C &>(*this);
        applyArgs<C, RunDataT, Ts ...>(derived, arg_ptrs);
    }

protected:
    UT_StringHolder myName;

private:
    // APEX_Allocator myAllocator;
    APEX_Signature mySignature;
    Dict myDefaults;
};

struct APEX_Context
{
    APEX_ProgramCounter *myProgramCounter = nullptr;
};

template <typename C, typename... Ts>
class APEX_GenericFunctionContext : public APEX_FunctionBase
{
public:
    APEX_GenericFunctionContext()
    {
        if constexpr (!std::is_null_pointer_v<decltype(C::argnames)>)
        {
            static_assert(
                sizeof...(Ts) == std::size(C::argnames),
                "Callback argnames size does not match template argument size");
        }

        myName = C::funcname.c_str();
        mySignature = makeSignature<Ts...>(C::argnames);
    }

    ~APEX_GenericFunctionContext() override {}

    void addSparePort(const UT_StringRef &name="", exint index = -1)
    {
        mySignature.addSparePort(name, index);
    }

    void addScopePort()
    {
        if (opensScope())
            mySignature.myOutputs.insertAt({scopeConnection(), nullptr}, 0);
        
        if (closesScope())
            mySignature.myInputs.insertAt({scopeConnection(), nullptr}, 0);
    }

    const UT_StringHolder &getName() const override { return myName; }

    struct RunDataT : C::RunData
    {
    };

    const APEX_TypeDefinitionBase *runDataTypeDef() const override
    {
        return findTypeDef<typename C::RunData>();
    }

    void runDataCompileHook(
            APEX_Argument *rundata_instance,
            const APEX_Graph *in_graph,
            APEX_NodeID for_node,
            APEX_Program *bind_to) const override
    {
        SYS_STATIC_ASSERT(std::is_base_of_v<APEX_Context, typename C::RunData>);
    }

    const APEX_Signature &signature() const override { return mySignature; }

    void execute(APEX_ArgPtrs &arg_ptrs) const override
    {
        utZoneScopedN(C::funcname);

        const auto &derived = static_cast<const C &>(*this);
        applyArgs<C, RunDataT, Ts...>(derived, arg_ptrs);
    }

    APEX_CallbackType callbackType() const override = 0;

    static const UT_StringLit funcname;
    static const UT_StringArray argnames;

protected:
    UT_StringHolder myName;

private:
    APEX_Signature mySignature;
};

} // namespace apex

#endif // header guard