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 <tuple>
#include <type_traits>


namespace UT { namespace Format { class ArgValue; } }

namespace apex
{

class APEX_Graph;
class APEX_Program;

/// 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()
    {
        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);
        auto cast_args = castArgs<RunDataT, std::remove_const_t<Ts>...>(arg_ptrs);
        auto ref_args = makerefs(cast_args);

        const auto &derived = static_cast<const C &>(*this);

        std::apply(derived, ref_args);
    }

protected:
    UT_StringHolder myName;

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

struct APEX_Context
{
    APEX_Context() {}
    ~APEX_Context() {}

    APEX_Program *myProgram;
};

template <typename C, typename... Ts>
class APEX_GenericFunctionContext : public APEX_FunctionBase
{
public:
    APEX_GenericFunctionContext()
    {
        myName = C::funcname.c_str();
        mySignature = makeSignature<Ts...>(C::argnames);
    };

    ~APEX_GenericFunctionContext() override {}

    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>);

        static_cast<APEX_Context *>(castArg<typename C::RunData>(rundata_instance))
                ->myProgram = bind_to;
    }

    const APEX_Signature &signature() const override
    {
        myFullSignature = mySignature;

        if (opensScope())
            myFullSignature.myOutputs.insertAt({scopeConnection(), nullptr}, 0);
        else if (closesScope())
            myFullSignature.myInputs.insertAt({scopeConnection(), nullptr}, 0);
        if (!scopeConnection().isEmpty())
        {
            myFullSignature.myInputs.append({theSparePortName.asRef(), nullptr});
            myFullSignature.myOutputs.append({theSparePortName.asRef(), nullptr});
        }

        return myFullSignature;
    };

    void execute(APEX_ArgPtrs &arg_ptrs) const override
    {
        utZoneScopedN(C::funcname);
        auto cast_args = castArgs<RunDataT, std::remove_const_t<Ts>...>(arg_ptrs);
        auto ref_args = makerefs(cast_args);

        const auto &derived = static_cast<const C &>(*this);

        std::apply(derived, ref_args);
    }

    APEX_CallbackType callbackType() const override = 0;

    static const UT_StringLit funcname;
    static const UT_StringArray argnames;

protected:
    UT_StringHolder myName;

private:
    APEX_Signature mySignature;
    mutable APEX_Signature myFullSignature;
};

} // namespace apex

#endif // header guard