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

#ifndef __UT_SUBSYSTEM_H__
#define __UT_SUBSYSTEM_H__

#include "UT_API.h"

#define UT_ENABLE_SUBSYSTEMS

#include "UT_NonCopyable.h"
#include "UT_UniquePtr.h"

#include <SYS/SYS_StaticInit.h>
#include <SYS/SYS_TypeTraits.h>

#include <type_traits>

class UT_ThreadIOPool;
class UT_PrivateThreadIOPool;

/// All subsystems should derive from this interface. Each subsystem then
/// defines how to initialize and shutdown its components.
/// All components of a subsystem should be lazy initialized.
///
/// To add a new subsystem:
///   1. Add a new entry to the @ref Type enum below.
///   2. In a header, declare a class deriving from @c UT_ISubSystem, use
///      @c UT_SUBSYSTEM_CLASS(your_type) inside it.
///   3. Override @c initialize_() / @c shutdown_(). 
///   4. End the header with @c UT_SUBSYSTEM_DECLARE(your_api, YourSubSystem).
///   5. In the matching .C file, add @c UT_SUBSYSTEM_IMPL(YourSubSystem).
///   6. Access the singleton anywhere via @c UTgetSubSystem<YourSubSystem>().
///
class UT_API UT_ISubSystem
{
public:
    enum Type
    {
        UT_SUBSYSTEM,
        NET_SUBSYSTEM,
        LM_SUBSYSTEM,
        UNI_SUBSYSTEM,
        COP_SUBSYSTEM,
        MAX_SUBSYSTEMS
    };

    UT_NON_COPYABLE(UT_ISubSystem);

    virtual ~UT_ISubSystem() = default;

    /// The type of the subsystem.
    virtual Type type() const = 0;

    template <typename SubSystemT>
    static bool registerSubSystem(SubSystemT& subsys)
    {
        static_assert(
                std::is_base_of_v<UT_ISubSystem, SubSystemT>
                && std::is_default_constructible_v<SubSystemT>);
        return registerSubSystem_(SYSaddressof(subsys));
    }

protected:
    UT_ISubSystem() = default;

    /// Initialize this subsystem
    virtual void initialize_() = 0;
    /// Shutdown this subsystem
    virtual void shutdown_() = 0;
private:
    friend class ut_SubSystemRegistry;

    static bool registerSubSystem_(UT_ISubSystem* subsys);
};

#define UT_SUBSYSTEM_CLASS(sub_type)                                          \
public:                                                                        \
    static constexpr Type subsystem_type = UT_ISubSystem::Type::sub_type;      \
    Type type() const override                                                 \
    {                                                                          \
        return subsystem_type;                                                 \
    }                                                                          \
                                                                               \
private:                                                                       \
    static bool theIsRegistered;

#define UT_SUBSYSTEM_IMPL_INNER(cls)                                           \
    static SYS_StaticInit<cls> theSubSystem;                                   \
    static void cls##Init()                                                    \
    {                                                                          \
        UT_ISubSystem::registerSubSystem<cls>(*theSubSystem);                  \
    }                                                                          \
    static void cls##CleanUp()                                                 \
    {                                                                          \
    }

#define UT_SUBSYSTEM_IMPL(cls)                                                 \
    namespace cls_Namespace                                                    \
    {                                                                          \
    UT_SUBSYSTEM_IMPL_INNER(cls)                                               \
    SYSimplementStaticInit(cls);                                               \
    }

#define UT_SUBSYSTEM_DECLARE(api, cls)                                         \
    namespace cls_Namespace                                                    \
    {                                                                          \
    SYSdeclareStaticInit(api, cls)                                             \
    }

/// The subsystem to initialize and cleanup UT.
class UT_API UT_SubSystem final : public UT_ISubSystem
{
    UT_SUBSYSTEM_CLASS(UT_SUBSYSTEM);
public:
    UT_SubSystem();
    ~UT_SubSystem() override;

protected:

    void initialize_() override;
    void shutdown_() override;

private:
    friend class ut_SubSystemAccessor;

    class Impl;
    UT_UniquePtr<Impl> myImpl;
};

/// The general purpose thread pool. Any work can be done on this pool. The
/// exception to this is licensing work. We must not do any licensing work on
/// this thread as license checks will end up blocking the thread causing a hang
/// waiting for licensing work to be processed.
UT_API UT_ThreadIOPool& UThoudiniIOPool();

/// Initialize all subsystems
UT_API void UTsubSystemInitialize();
/// Shutdown all subsystems. initialize() must be called prior to this
/// function.
UT_API void UTsubSystemShutdown();

namespace UT_SubSystemImpl
{
SYSdeclareStaticObject(UT_API, theRegistry);

UT_API UT_ISubSystem* utGetSubSystem(UT_SubSystem::Type t);
} // namespace UT_SubSystemImpl

template <typename T>
T*
UTgetSubSystem()
{
   static_assert(std::is_base_of_v<UT_ISubSystem, T>);
   return static_cast<T*>(UT_SubSystemImpl::utGetSubSystem(T::subsystem_type));
}

UT_SUBSYSTEM_DECLARE(UT_API, UT_SubSystem);

#endif // __UT_SUBSYSTEM_H__