pluginRegistry.h

//
// 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_IMAGING_HF_PLUGIN_REGISTRY_H
#define PXR_IMAGING_HF_PLUGIN_REGISTRY_H

#include "pxr/pxr.h"
#include "pxr/imaging/hf/api.h"
#include "pxr/imaging/hf/perfLog.h"
#include "pxr/imaging/hf/pluginDesc.h"
#include "pxr/base/tf/type.h"
#include <map>

PXR_NAMESPACE_OPEN_SCOPE


class HfPluginBase;
class Hf_PluginEntry;


class HfPluginRegistry
{

public:
    HF_API
    void GetPluginDescs(HfPluginDescVector *plugins);

    HF_API
    bool GetPluginDesc(const TfToken &pluginId, HfPluginDesc *desc);

    HF_API
    void AddPluginReference(HfPluginBase *plugin);

    HF_API
    void ReleasePlugin(HfPluginBase *plugin);

    HF_API
    bool IsRegisteredPlugin(const TfToken &pluginId);

    HF_API
    TfToken GetPluginId(const HfPluginBase *plugin) const;

protected:
    // Must be derived.

    HF_API
    HfPluginRegistry(const TfType &pluginBaseType);
    HF_API
    virtual ~HfPluginRegistry();

    HF_API
    HfPluginBase *GetPlugin(const TfToken &pluginId);

    template<typename T, typename PluginBaseType, typename... Bases>
    static void Define();

private:
    typedef std::vector<Hf_PluginEntry> _PluginEntryVector;
    typedef std::map<TfToken, size_t> _TokenMap;

    //
    // The purpose of this group of functions is to provide a factory
    // to create the registered plugin with the type system
    // without exposing the internal class _PluginEntry
    typedef std::function<HfPluginBase *()> _FactoryFn;

    template<typename T>
    static HfPluginBase *_CreatePlugin();
    HF_API
    static void _SetFactory(TfType &type, _FactoryFn &func);

    TfType                     _pluginBaseType;

    //
    // Plugins are stored in a ordered list (as a vector).  The token
    // map converts from plugin id into an index in the list.
    //
    _PluginEntryVector         _pluginEntries;
    _TokenMap                  _pluginIndex;

    // Plugin discovery is deferred until first use.
    bool                       _pluginCachePopulated;

    // Use the Plug system to discover plugins from the meta data.
    void _DiscoverPlugins();

    // Find the plugin entry for the given plugin object.
    Hf_PluginEntry *_GetEntryForPlugin(HfPluginBase *plugin);

    HfPluginRegistry()                                    = delete;
    HfPluginRegistry(const HfPluginRegistry &)            = delete;
    HfPluginRegistry &operator=(const HfPluginRegistry &) = delete;
};

template<typename T>
HfPluginBase *
HfPluginRegistry::_CreatePlugin()
{
    HF_MALLOC_TAG_FUNCTION();
    return new T;
}


template<typename T, typename PluginBaseType, typename... Bases>
void
HfPluginRegistry::Define()
{
    TfType type = TfType::Define<T,
                                  TfType::Bases<PluginBaseType, Bases...> >();

    _FactoryFn func = &_CreatePlugin<T>;
    _SetFactory(type, func);
}



PXR_NAMESPACE_CLOSE_SCOPE

#endif //PXR_IMAGING_HF_PLUGIN_REGISTRY_H