PDGT_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 __PDGT_TYPE_REGISTRY_H__
#define __PDGT_TYPE_REGISTRY_H__

#include "PDGT_API.h"

#include "PDGT_BaseType.h"
#include "PDGT_Types.h"
#include "PDGT_Utils.h"

#include <UT/UT_SharedPtr.h>
#include <UT/UT_StringArray.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_StringMap.h>
#include <UT/UT_StringSet.h>
#include <UT/UT_WorkBuffer.h>

#include <SYS/SYS_Time.h>

#include <utility>

/**
 * Base class for a PDGT type system, which consists of a table of EnumType ->
 * PDGT_Registered type. The number of entries in the table is defined by the
 * number of distinct entries in the EnumType enumeration.
 *
 * The type registry is the central place that holds the registered type
 * objects, as well as logic needed to load them from shared libraries or
 * Python definitions.
 */
template <typename EnumType, int EnumSize>
class PDGT_API_TMPL PDGT_TypeRegistry : UT_NonCopyable
{
public:
    /// Self type def
    using Self              = PDGT_TypeRegistry<EnumType, EnumSize>;

protected:
    /// PDGT_BaseType spiicalization for this type registry
    using BaseType          = PDGT_BaseType<EnumType>;

    /// Shared ptr to a registered PDG type
    using pdg_BaseTypePtr   = UT_SharedPtr<BaseType>;

    /// Map of type name to shared ptr
    using TypeMap           = UT_StringMap<pdg_BaseTypePtr>;

protected:

                    /// Construct is protected since only this class and
                    /// subclasses can create instances of itself.
                    PDGT_TypeRegistry(const UT_StringHolder& dso_function,
                                      const UT_StringHolder& module_name)
                        : myDSOFunction(dso_function)
                        , myModuleName(module_name)
                        , myApplicationType(PDGT_ApplicationType::eUnknown)
                        , myInitFlag(false)
                        , myEnableRegistration(true)
                    {
                    }

public:
    virtual         ~PDGT_TypeRegistry() {}

    /// Standard initialization of the types, which loads built in Python
    /// modules first, then user defined Python types, then C++ types. The
    /// reason for this being a method and not part of construction is there
    /// certain use cases that want to have an empty type table, for example
    /// unit testing or users with entirely custom nodes.
    bool            standardInit(UT_WorkBuffer& errors,
                                 PDGT_ApplicationType app_type,
                                 bool skip_python=false)
                        {
                            if (myInitFlag)
                                return true;


                            fpreal start = SYStime();

                            myApplicationType = app_type;
                            bool success = true;
                            if (!skip_python)
                                success &= registerPythonModules(errors);

                            success &= registerDSOTypes();
                            myInitFlag = true;

                            UT_WorkBuffer buffer;
                            buffer.format("Total Time {}s", SYStime()-start);
                            handleLogMessage(
                                PDGT_TypeErrorLevel::eInfo,
                                buffer.buffer(),
                                "LOAD DONE");

                            return success;
                        }

    /// Clears and deletes everything in the type registry
    void            clear()
                        {
                            for (int i = 0; i < EnumSize; i++)
                                myTypes[i].clear();
                        }

    /// Enables or disables custom type registration
    void            setRegistrationEnabled(bool enabled)
                        {
                            myEnableRegistration = enabled;
                        }

    /// Registers a type using a pointer to the type object. Errors are
    /// returned in the error buffer parameter
    template <typename  RegType, typename... Args>
    RegType*        registerType(UT_WorkBuffer& errors,
                                 const UT_StringHolder& name,
                                 Args&&... args)
                        {
                            if (!myEnableRegistration)
                                return nullptr;

                            if (name.isEmpty())
                            {
                                errors.appendFormat("Empty type name");
                                return nullptr;
                            }

                            TypeMap& type_map = myTypes[(int)(RegType::Enum)];
                            BaseType* existing_type =
                                registeredType(RegType::Enum, name);

                            if (existing_type)
                            {
                                errors.appendFormat(
                                    "A type already exists with the name {}",
                                    name);
                                return nullptr;
                            }

                            RegType* new_type = new RegType(
                                name, std::forward<Args>(args)...);
                            type_map[name] = pdg_BaseTypePtr(new_type);
                            if (!new_type->initialize(errors))
                            {
                                if (errors.length() > 0)
                                    errors.append(". ");
                                errors.appendFormat(
                                    "Failed to initialize type {}", name);
                                type_map.erase(name);
                                return nullptr;
                            }

                            handleLogMessage(
                                PDGT_TypeErrorLevel::eSuccess,
                                new_type->displayName(),
                                "ADD");

                            return new_type;
                        }

    /// Registers a type that implements it's construction logic in a function,
    /// rather than a custom class
    template <typename RegType, typename... Args>
    RegType*        registerFuncType(UT_WorkBuffer& errors,
                                     const UT_StringHolder& name,
                                     typename RegType::Function func,
                                     Args&&... args)
                        {
                            RegType* reg_type = registerType<RegType>(
                                errors, name, std::forward<Args>(args)...);

                            if (!reg_type)
                                return nullptr;

                            reg_type->setFunction(func);
                            return reg_type;
                        }

    /// Registers a type that uses the simple built-in function, which creates
    /// and instance of the type using it's constructor and does no additional
    /// logic
    template <typename RegType, typename ClassType, typename... Args>
    RegType*        registerSimpleType(UT_WorkBuffer& errors,
                                       const UT_StringHolder& name,
                                       Args&&... args)
                        {
                            return registerFuncType<RegType>(
                                errors,
                                name,
                                &RegType::template typeInit<ClassType>,
                                std::forward<Args>(args)...);
                        }

    /// Registers an alias for an existing type
    bool            registerTypeAlias(EnumType type, 
                                      const UT_StringHolder& name,
                                      const UT_StringHolder& alias,
                                      bool deprecated=false)
                        {
                            TypeMap& type_map = myTypes[(int)(type)];

                            if (type_map.contains(alias))
                                return false;

                            auto iter = type_map.find(name);
                            if (iter == type_map.end())
                                return false;

                            UT_WorkBuffer message;
                            message.format("{} -> {}", name, alias);
                            handleLogMessage(
                                PDGT_TypeErrorLevel::eSuccess,
                                message,
                                "ALIAS");

                            if (deprecated)
                                deprecateType(type, alias);

                            myTypes[(int)(type)][alias] = iter->second;
                            myAliases[(int)(type)].insert(alias);

                            return true;
                        }

    /// Adds parent types to the type object.
    bool            addParentTypes(BaseType* type,
                                   const UT_StringArray& parent_names,
                                   UT_WorkBuffer& errors)
                        {
                            EnumType reg_type = type->type();
                            for (auto&& parent_name : parent_names)
                            {
                                BaseType* parent = registeredType(
                                    reg_type, parent_name);
                                if (!parent)
                                {
                                    errors.appendFormat(
                                        "{} not a valid type name",
                                        parent_name);
                                    return false;
                                }

                                type->addParent(parent, true);
                            }

                            return true;
                        }

    /// Directly adds a parent type, if it's valid
    bool            addParentType(BaseType* type,
                                  BaseType* parent,
                                  UT_WorkBuffer& errors)
                        {
                            if (!parent)
                            {
                                errors.appendFormat(
                                    "Empty parent type for '{}'",
                                    type->typeName());
                                return false;
                            }

                            if (type->type() != parent->type())
                            {
                                errors.appendFormat(
                                    "Invalid parent type '{}' for '{}",
                                    parent->typeName(),
                                    type->typeName());
                                return false;
                            }

                            type->addParent(parent, true);
                            return true;
                        }

    /// Loads and registers types compiled as a shared library
    bool            registerDSOTypes(const UT_StringHolder& dso_path)
                        {
                            return PDGT_Utils::loadDSO(
                                dso_path, myDSOFunction, (void*)this);
                        }
                            
    /// Loads and registers types that are in DSOs on the PDG shared library
    /// path, e.g. <dso_path>/pdg
    bool            registerDSOTypes()
                        {
                            return PDGT_Utils::loadDSO(
                                myDSOFunction, (void*)this);
                        }

    /// Registers all Python types on the PDG/types search path
    bool            registerPythonModules(UT_WorkBuffer& errors)
                        {
                            return PDGT_Utils::loadPythonModules(
                                myModuleName, errors);
                        }

    /// Registers a Python module by absolute path
    bool            registerPythonPath(const UT_StringHolder& path,
                                       UT_WorkBuffer& errors)
                        {
                            return PDGT_Utils::loadPythonPath(
                                myModuleName, path, errors);
                        }

    /// Reloads a Python module by name
    bool            reloadPythonModule(const UT_StringHolder& path,
                                       bool reregister, 
                                       UT_WorkBuffer& errors)
                        {
                            return PDGT_Utils::reloadPythonModule(
                                myModuleName, path, reregister, errors);
                        }

    /// Returns a generic type object for a given registered type and typename
    BaseType*       registeredType(EnumType type,
                                   const UT_StringHolder& name) const
                        {
                            auto iter = myTypes[(int)(type)].find(name);
                            if (iter == myTypes[(int)(type)].end())
                                return nullptr;

                            if (myDeprecatedTypes[(int)(type)].contains(name))
                            {
                                handleLogMessage(
                                    PDGT_TypeErrorLevel::eInfo,
                                    name,
                                    "DEPRECATED");
                            }

                            return iter->second.get();
                        }

    /// Deprecated a type name, so that accessing it will issue an warning
    void            deprecateType(EnumType type, const UT_StringHolder& name)
                        {
                            myDeprecatedTypes[(int)(type)].insert(name);
                        }

    /// Returns the set of all existing type names for registered type
    UT_StringArray  typeNames(EnumType type, bool include_aliases=false) const
                        {
                            const auto& aliases = myAliases[(int)(type)];

                            UT_StringArray type_names;
                            for (auto&& entry : myTypes[(int)(type)])
                            {
                                if (!include_aliases)
                                {
                                    if (aliases.contains(entry.first))
                                        continue;
                                }

                                type_names.append(entry.first);
                            }

                            return type_names;
                        }

    /// Returns the application type, as determined when the type table
    /// was initialized
    PDGT_ApplicationType
                    applicationType() const
                        { return myApplicationType; }

private:
    /// Handles reporting log messages, implemented by concrete subclass so
    /// they can use their own logging mechanism
    virtual void    handleLogMessage(
                            PDGT_TypeErrorLevel level,
                            const UT_StringHolder& message,
                            const UT_StringHolder& tag) const {}

private:
    TypeMap         myTypes[EnumSize];
    UT_StringSet    myDeprecatedTypes[EnumSize];
    UT_StringSet    myAliases[EnumSize];
    UT_StringHolder myDSOFunction;
    UT_StringHolder myModuleName;

    PDGT_ApplicationType
                    myApplicationType;

    bool            myInitFlag;
    bool            myEnableRegistration;
};

#endif