COP_SlapcompDispatcher.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 "COP_SlapcompProgramManager.h"

/// This class is a polymorphic slapcomp manager that can be used to interface
/// with different types of slapcomps. To this end, a factory must be registered
/// with the static installFactory() method, with a checker and an allocator.
/// When a manager gets enabled with a specific node, the first factory (i.e.
/// one registered earliest) whose check the node passes will be used to run it.
class COP_API COP_SlapcompDispatcher : public COP_SlapcompManager
{
public:
    using Callbacks = COP_SlapcompManager::Callbacks;

    /// Should return true for nodes that are supported by the slapcomp type.
    using CheckFunction = bool (*)(const OP_Node*);
    /// Should dynamically allocate a new slapcomp manager for the slapcomp
    /// type.
    using AllocationFunction = COP_SlapcompManager* (*)();
    /// Call this function to register a slapcomp factory.
    /// The checker function should return true for a node if that slapcomp
    /// manager should be used for it.
    static void installFactory(CheckFunction checker,
                               AllocationFunction allocator);

private:
    /// List of available options for slapcomp.
    struct Factory
    {
        CheckFunction           myCheck;
        AllocationFunction      myAlloc;
    };
    static UT_Array<Factory>            theFactories;

    /// Given a node, returns index of the factory that is appropriate for it.
    /// Will return -1
    static int getFactoryIndex(int target_node_id);

public:
    COP_SlapcompDispatcher() {}
    COP_SlapcompDispatcher(const COP_SlapcompDispatcher&) = delete;
    COP_SlapcompDispatcher(COP_SlapcompDispatcher&&);
    COP_SlapcompDispatcher& operator=(const COP_SlapcompDispatcher&) = delete;
    COP_SlapcompDispatcher& operator=(COP_SlapcompDispatcher&&);

    /// Makes this object a copy of other, including the enable state.
    void copyFrom(const COP_SlapcompDispatcher& other,
                  const OP_Context& context);

    void enable(int target_node_id, const OP_Context&) override;
    void enable(OP_Node *const node, const OP_Context &ctx)
               { enable(node->getUniqueId(), ctx); }
    void disable() override;
    bool isEnabled() const override;
    bool hasErrors() const override;
    int  getTargetNode() const override;
    
    void setErrorCallback(void (*cb)(void*, const char*), void* data) override;
    void setWarningCallback(void (*cb)(void*, const char*), void* data)
        override;
    void setRunCallback(void (*cb)(void*), void* data) override;
    void setUpdateCallback(void (*cb)(void*), void* data) override;

    bool isSlapcompAOV(const UT_StringHolder& name) const override;

    bool buildForInputs(const COP_CableStructure& inputs,
                        const OP_Context& context) override;
    void runSlapcompImpl(COP_SlapcompInputFetcher& input_fetcher,
                         const OP_Context& context) override;

    COP_CableStructure getOutputStructure() const override;
    IMX_LayerPtr getOutputLayer(const UT_StringHolder& name) const override;

    int getVersion() const override
    {
        return myVersion;
    }
    bool hasStateChanged() const override
    {
        return myStateChanged;
    }

public:
    void setVersion(int version) override
    {
        myVersion = version;
    }

protected:
    void reportError(const char* message) override;
    void reportWarning(const char* message) override;

protected:
    Callbacks                           myCallbacks;
    UT_UniquePtr<COP_SlapcompManager>   myManager;
    int                                 myCurrentType = -1;

    int                                 myVersion = 0;
    bool                                myStateChanged = false;
};