PDG_TypeRegistry.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.
 *
 * COMMENTS:
 */

#ifndef __PDG_TYPE_REGISTRY_H__
#define __PDG_TYPE_REGISTRY_H__

#include "PDG_API.h"

#include "PDG_CustomHandlers.h"
#include "PDG_DependencyType.h"
#include "PDG_FileUtils.h"
#include "PDG_NodeCallbackType.h"
#include "PDG_SchedulerType.h"
#include "PDG_ServiceType.h"
#include "PDG_Types.h"
#include "PDG_WorkItemDataType.h"

#include <PDGT/PDGT_TypeRegistry.h>

class PDG_NodeInterface;
class PDG_Service;

#ifdef WIN32
/// Explicit instantiate for base type, to avoid linker errors on windows
template class PDG_API PDGT_BaseType<PDG_RegistrationType>;
#endif

/*
 * Specializtion of PDGT_TypeRegistry for the various types that can be
 * registerted and created in PDG
 */
class PDG_API PDG_TypeRegistry : public PDGT_TypeRegistry<PDG_RegistrationType,
                                            (int)PDG_RegistrationType::eCount>
{
protected:
    PDG_TypeRegistry();

public:
    /// Returns the static type registry instance
    static PDG_TypeRegistry* types();

    /// Destructor
    ~PDG_TypeRegistry() override;

    /// Registers a function-based work item type
    template <typename ClassType, typename... Args>
    PDG_WorkItemDataType*   registerCustomWorkItemData(
                                            UT_WorkBuffer& errors,
                                            const UT_StringHolder& name,
                                            Args&&... args)
    {
        return registerSimpleType<PDG_WorkItemDataType, ClassType>(errors, name,
                    std::forward<Args>(args)...);
    }

    /// Registers a function-based node type
    template <typename ClassType, typename... Args>
    PDG_NodeCallbackType*   registerCustomNodeCallback(
                                            UT_WorkBuffer& errors,
                                            const UT_StringHolder& name,
                                            Args&&... args)
    {
        return registerSimpleType<PDG_NodeCallbackType, ClassType>(errors, name,
                    std::forward<Args>(args)...);
    }

    /// Registers a function-based scheduler type
    template <typename ClassType, typename... Args>
    PDG_SchedulerType*      registerCustomScheduler(
                                            UT_WorkBuffer& errors,
                                            const UT_StringHolder& name,
                                            Args&&... args)
    {
        return registerSimpleType<PDG_SchedulerType, ClassType>(errors, name,
                    std::forward<Args>(args)...);
    }

    /// Registers a function-based dependency type
    template <typename ClassType, typename... Args>
    PDG_DependencyType*     registerCustomDependency(
                                            UT_WorkBuffer& errors,
                                            const UT_StringHolder& name,
                                            Args&&... args)
    {
        return registerSimpleType<PDG_DependencyType, ClassType>(errors, name,
                    std::forward<Args>(args)...);
    }

    /// Registers a function-based service type
    template <typename ClassType, typename... Args>
    PDG_ServiceType*        registerCustomService(
                                            UT_WorkBuffer& errors,
                                            const UT_StringHolder& name,
                                            Args&&... args)
    {
        return registerSimpleType<PDG_ServiceType, ClassType>(errors, name,
                    std::forward<Args>(args)...);
    }

    /// Utility method to register a custom C++-based external dependency
    template <typename ClassType>
    PDG_DependencyType*     registerDependency(
                                const UT_StringHolder& name,
                                const UT_StringHolder& label)
    {
        UT_WorkBuffer errors;
        return handleErrors(registerCustomDependency<ClassType>(
            errors, name, label, PDG_BaseType::eCpp), errors);
    }

    /// Utility method to regiser a custom C++-based work item data
    template <typename ClassType>
    PDG_WorkItemDataType*   registerWorkItemData(
                                const UT_StringHolder& name,
                                const UT_StringHolder& label,
                                bool compatible = true,
                                bool make_default = false)
    {
        UT_WorkBuffer errors;
        auto data_type = handleErrors(registerCustomWorkItemData<ClassType>(
            errors, name, label, PDG_BaseType::eCpp), errors);
        if (!data_type)
            return nullptr;

        if (make_default)
            setDefaultWorkItemDataType(data_type);

        if (compatible && myDefaultWorkItemDataType)
            addParentType(data_type, myDefaultWorkItemDataType, errors);

        return data_type;
    }

    /// Utility method to registers a C++-based scheduler node
    template <typename ClassType>
    PDG_SchedulerType*      registerScheduler(
                                const UT_StringHolder& name,
                                const UT_StringHolder& label,
                                const UT_StringHolder& parm_category,
                                const UT_StringHolder& node_category)
    {
        UT_WorkBuffer errors;
        return handleErrors(registerCustomScheduler<ClassType>(
            errors, name, label, parm_category, node_category,
            PDG_BaseType::eCpp), errors);
    }

    /// Utility method to registers a C++-based scheduler node with a
    /// parm interface
    template <typename ClassType>
    PDG_SchedulerType*      registerScheduler(
                                const UT_StringHolder& name,
                                const UT_StringHolder& label,
                                const UT_StringHolder& parm_category,
                                const UT_StringHolder& node_category,
                                const PDG_NodeInterface& interface)
    {
        UT_WorkBuffer errors;
        return handleErrors(registerCustomScheduler<ClassType>(
            errors, name, label, parm_category, node_category,
            PDG_BaseType::eCpp, interface), errors);
    }

    /// Utility method to register a C++-based service using the default
    /// service class
    PDG_ServiceType*        registerService(
                                const UT_StringHolder& name,
                                const UT_StringHolder& label,
                                const UT_StringHolder& commandline,
                                bool internal)
    {
        UT_WorkBuffer errors;
        return handleErrors(registerCustomService<PDG_Service>(
            errors, name, label, PDG_BaseType::eCpp, commandline, internal),
            errors);
    }

    /// Utility method to register a C++-based processor node using defaults
    /// for various standard node callback fields
    template <typename ClassType>
    PDG_NodeCallbackType*   registerProcessor(
                                const UT_StringHolder& name,
                                const UT_StringHolder& label,
                                const UT_StringHolder& category,
                                const PDG_NodeInterface& interface,
                                PDG_NodeSubtype sub = PDG_NodeSubtype::eRegular)
    {
        UT_WorkBuffer errors;
        auto* new_type = registerCustomNodeCallback<ClassType>(
            errors, name, label, category, true, PDG_BaseType::eCpp,
            interface, PDG_NodeType::eProcessor, sub);
        if (new_type)
            new_type->setCallbackBits(PDG_NodeCallback::eProcessorBits);
        return handleErrors(new_type, errors);
    }

    /// Utility method to register a C++-based partitioner node using defaults
    /// for various standard node callback fields
    template <typename ClassType>
    PDG_NodeCallbackType*   registerPartitioner(
                                const UT_StringHolder& name,
                                const UT_StringHolder& label,
                                const UT_StringHolder& category,
                                const PDG_NodeInterface& interface,
                                PDG_NodeSubtype sub = PDG_NodeSubtype::eRegular)
    {
        UT_WorkBuffer errors;
        auto* new_type = registerCustomNodeCallback<ClassType>(
            errors, name, label, category, false, PDG_BaseType::eCpp,
            interface, PDG_NodeType::ePartitioner, sub);
        if (new_type)
            new_type->setCallbackBits(PDG_NodeCallback::ePartitionerBits);
        return handleErrors(new_type, errors);
    }

    /// Utility method to register a C++-based mapper node using defaults
    /// for various standard node callback fields
    template <typename ClassType>
    PDG_NodeCallbackType*   registerMapper(
                                const UT_StringHolder& name,
                                const UT_StringHolder& label,
                                const UT_StringHolder& category,
                                const PDG_NodeInterface& interface)
    {
        UT_WorkBuffer errors;
        auto* new_type = registerCustomNodeCallback<ClassType>(
            errors, name, label, category, false, PDG_BaseType::eCpp,
            interface, PDG_NodeType::eMapper, PDG_NodeSubtype::eRegular);
        if (new_type)
            new_type->setCallbackBits(PDG_NodeCallback::eMapperBits);
        return handleErrors(new_type, errors);
    }

    /// Returns an external dependency type object for a given name
    PDG_DependencyType*     dependencyType(const UT_StringHolder& name) const;

    /// Retruns a node callback type object for a given name
    PDG_NodeCallbackType*   nodeCallbackType(const UT_StringHolder& name) const;

    /// Returns a scheduler type object for a give name
    PDG_SchedulerType*      schedulerType(const UT_StringHolder& name) const;

    /// Returns a service type object for a given name
    PDG_ServiceType*        serviceType(const UT_StringHolder& name) const;

    /// Returns a work item data type object for a given name
    PDG_WorkItemDataType*   workItemDataType(const UT_StringHolder& name) const;

    /// Gets/sets the default work item data type
    PDG_WorkItemDataType*   defaultWorkItemDataType() const
                                { return myDefaultWorkItemDataType; }
    void                    setDefaultWorkItemDataType(PDG_WorkItemDataType* type)
                                { myDefaultWorkItemDataType = type; }

    /// Gets/sets the service scheduler type
    PDG_SchedulerType*      serviceSchedulerType() const
                                { return myServiceSchedulerType; }
    void                    setServiceSchedulerType(PDG_SchedulerType* type)
                                { myServiceSchedulerType = type; }

    /// Gets/sets the in process scheduler type
    PDG_SchedulerType*      inProcessSchedulerType() const
                                { return myInProcessSchedulerType; }
    void                    setInProcessSchedulerType(PDG_SchedulerType* type)
                                { myInProcessSchedulerType = type; }

    /// Returns the name of the local scheduler type
    const UT_StringHolder&  localSchedulerTypeName() const
                                {
                                    static const UT_StringHolder type_name =
                                        "localscheduler";
                                    return type_name;
                                }

    /// Returns the custom handlers table
    PDG_CustomHandlers*     customHandlers()
                                { return &myCustomHandlers;}

    /// Returns the shared file utilities object
    PDG_FileUtils*          fileUtils()
                                { return &myFileUtilities; }

    /// Returns the name of the module used to serialize and deserialize
    /// PyObject attributes
    UT_StringHolder         pySerializationModule() const;

    /// Sets the custom serialization module name
    void                    setPySerializationModule(const UT_StringHolder& mod);

    /// Returns true if the scheduler name is a "local" scheduler, e.g. it does
    /// not use the farm.
    static bool             isSchedulerLocal(const UT_StringHolder& type_name);

private:
    /// Logs a message with the PDG debug logger
    void                    handleLogMessage(
                                PDGT_TypeErrorLevel level,
                                const UT_StringHolder& message,
                                const UT_StringHolder& tag) const override;

    /// Reports errors to stdout, if the type is invalid
    template <typename Type>
    Type*                   handleErrors(
                                    Type* new_type,
                                    const UT_WorkBuffer& errors) const
                                {
                                    if (new_type || errors.isEmpty())
                                        return new_type;

                                    handleLogMessage(
                                        PDGT_TypeErrorLevel::eFailure,
                                        errors.buffer(),
                                        "ERROR");

                                    return nullptr;
                                }

private:
    PDG_WorkItemDataType*   myDefaultWorkItemDataType;
    PDG_SchedulerType*      myServiceSchedulerType;
    PDG_SchedulerType*      myInProcessSchedulerType;

    PDG_CustomHandlers      myCustomHandlers;
    PDG_FileUtils           myFileUtilities;
    UT_StringHolder         myPySerializationModule;
};

extern "C" {
    SYS_VISIBILITY_EXPORT extern void registerPDGTypes(PDG_TypeRegistry*);
};

#endif