registryManager.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#ifndef PXR_BASE_TF_REGISTRY_MANAGER_H
#define PXR_BASE_TF_REGISTRY_MANAGER_H


#include "pxr/pxr.h"

#include "pxr/base/arch/attributes.h"
#include "pxr/base/tf/preprocessorUtilsLite.h"
#include "pxr/base/tf/api.h"

#include <functional>
#include <typeinfo>

PXR_NAMESPACE_OPEN_SCOPE

class TfRegistryManager {
    TfRegistryManager(const TfRegistryManager&) = delete;
    TfRegistryManager& operator=(const TfRegistryManager&) = delete;

public:
    // The type of a registration function.  The arguments are not used.
    typedef void (*RegistrationFunctionType)(void*, void*);
    typedef std::function<void ()> UnloadFunctionType;

    TF_API static TfRegistryManager& GetInstance();

    template <class T>
    void SubscribeTo() {
        _SubscribeTo(typeid(T));
    }

    template <class T>
    void UnsubscribeFrom() {
        _UnsubscribeFrom(typeid(T));
    }

    TF_API bool AddFunctionForUnload(const UnloadFunctionType&);

    TF_API static void RunUnloadersAtExit();

private:
    TF_API TfRegistryManager();
    TF_API ~TfRegistryManager();

    TF_API void _SubscribeTo(const std::type_info&);
    TF_API void _UnsubscribeFrom(const std::type_info&);
};

TF_API void Tf_RegistryInitCtor(char const *name);
TF_API void Tf_RegistryInitDtor(char const *name);

namespace {
struct Tf_RegistryStaticInit {
    Tf_RegistryStaticInit() {
        Tf_RegistryInitCtor(TF_PP_STRINGIZE(MFB_ALT_PACKAGE_NAME));
    }
    ~Tf_RegistryStaticInit() {
        Tf_RegistryInitDtor(TF_PP_STRINGIZE(MFB_ALT_PACKAGE_NAME));
    }
};
}

// Private class used to indicate the library has finished registering
// functions, to indicate that the library is being unloaded and to
// add functions to the registry.
class Tf_RegistryInit {
public:
    TF_API static void Add(const char* libName,
                    TfRegistryManager::RegistrationFunctionType func,
                    const char* typeName);
    template <class T, class U>
    static void Add(const char* libName,
                    void (*func)(T*, U*),
                    const char* typeName)
    {
        Add(libName,(TfRegistryManager::RegistrationFunctionType)func,typeName);
    }
};

// The ARCH_CONSTRUCTOR priority for registering registry functions.
#define TF_REGISTRY_PRIORITY 100

//
// Macros for adding registry functions outside class templates.
//

// Define a registry function outside of a template.  Follow the macro with
// the body of the function inside braces.  KEY_TYPE and TAG must be types.
#define TF_REGISTRY_DEFINE_WITH_TYPE(KEY_TYPE, TAG)                            \
    static void _Tf_RegistryFunction(KEY_TYPE*, TAG*);                         \
    ARCH_CONSTRUCTOR(TF_PP_CAT(_Tf_RegistryAdd, __LINE__),                     \
                     TF_REGISTRY_PRIORITY, KEY_TYPE*, TAG*)                    \
    {                                                                          \
        Tf_RegistryInit::Add(TF_PP_STRINGIZE(MFB_ALT_PACKAGE_NAME),            \
                             (void(*)(KEY_TYPE*, TAG*))_Tf_RegistryFunction,   \
                             TF_PP_STRINGIZE(KEY_TYPE));                       \
    }                                                                          \
    _ARCH_ENSURE_PER_LIB_INIT(Tf_RegistryStaticInit, _tfRegistryInit);         \
    static void _Tf_RegistryFunction(KEY_TYPE*, TAG*)
    
// Define a registry function outside of a template.  Follow the macro with
// the body of the function inside braces.  KEY_TYPE must be a type and NAME
// must be a valid C++ name.
#define TF_REGISTRY_DEFINE(KEY_TYPE, NAME)                                     \
    static void TF_PP_CAT(_Tf_RegistryFunction, NAME)(KEY_TYPE*, void*);       \
    ARCH_CONSTRUCTOR(TF_PP_CAT(_Tf_RegistryAdd, NAME),                         \
                     TF_REGISTRY_PRIORITY, KEY_TYPE*)                          \
    {                                                                          \
        Tf_RegistryInit::Add(TF_PP_STRINGIZE(MFB_ALT_PACKAGE_NAME),            \
                             (void(*)(KEY_TYPE*, void*))                       \
                             TF_PP_CAT(_Tf_RegistryFunction, NAME),            \
                             TF_PP_STRINGIZE(KEY_TYPE));                       \
    }                                                                          \
    _ARCH_ENSURE_PER_LIB_INIT(Tf_RegistryStaticInit, _tfRegistryInit);         \
    static void TF_PP_CAT(_Tf_RegistryFunction, NAME)(KEY_TYPE*, void*)


#define TF_REGISTRY_FUNCTION(KEY_TYPE) \
    TF_REGISTRY_DEFINE(KEY_TYPE, __LINE__)

#define TF_REGISTRY_FUNCTION_WITH_TAG(KEY_TYPE, TAG) \
    TF_REGISTRY_DEFINE(KEY_TYPE, TF_PP_CAT(TAG, __LINE__))

PXR_NAMESPACE_CLOSE_SCOPE

#endif // PXR_BASE_TF_REGISTRY_MANAGER_H