scriptModuleLoader.h

//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_BASE_TF_SCRIPT_MODULE_LOADER_H
#define PXR_BASE_TF_SCRIPT_MODULE_LOADER_H
 
#include "pxr/pxr.h"
 
#include "pxr/base/tf/api.h"
#include "pxr/base/tf/hash.h"
#include "pxr/base/tf/singleton.h"
#include "pxr/base/tf/token.h"
#include "pxr/base/tf/weakBase.h"
 
// XXX: This include is a hack to avoid build errors due to
// incompatible macro definitions in pyport.h on macOS.
#include <locale>
#include <boost/python/dict.hpp>
 
#include <deque>
#include "pxr/base/tf/hashmap.h"
#include "pxr/base/tf/hashset.h"
#include <string>
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class TfScriptModuleLoader : public TfWeakBase {
 
  public:
 
    typedef TfScriptModuleLoader This;
 
    TF_API static This &GetInstance() {
        return TfSingleton<This>::GetInstance();
    } 
 
    TF_API
    void RegisterLibrary(TfToken const &name, TfToken const &moduleName,
                         std::vector<TfToken> const &predecessors);
 
    TF_API
    void LoadModules();
 
    TF_API
    void LoadModulesForLibrary(TfToken const &name);
 
    TF_API
    std::vector<std::string> GetModuleNames() const;
 
    TF_API
    boost::python::dict GetModulesDict() const;
    
    TF_API
    void WriteDotFile(std::string const &file) const;
    
  private:
 
    struct _LibInfo {
        _LibInfo() {}
        std::vector<TfToken> predecessors, successors;
    };
 
    typedef TfHashMap<TfToken, _LibInfo, TfToken::HashFunctor>
    _TokenToInfoMap;
 
    typedef TfHashMap<TfToken, TfToken, TfToken::HashFunctor>
    _TokenToTokenMap;
    
    typedef TfHashSet<TfToken, TfToken::HashFunctor>
    _TokenSet;
    
    TfScriptModuleLoader();
    virtual ~TfScriptModuleLoader();
    friend class TfSingleton<This>;
    
    void _AddSuccessor(TfToken const &lib, TfToken const &successor);
    void _LoadModulesFor(TfToken const &name);
    void _LoadUpTo(TfToken const &name);
    void _GetOrderedDependenciesRecursive(TfToken const &lib,
                                          TfToken::HashSet *seenLibs,
                                          std::vector<TfToken> *result) const;
    void _GetOrderedDependencies(std::vector<TfToken> const &input,
                                 std::vector<TfToken> *result) const;
    void _TopologicalSort(std::vector<TfToken> *result) const;
 
    bool _HasTransitiveSuccessor(TfToken const &predecessor,
                                 TfToken const &successor) const;
 
    _TokenToInfoMap _libInfo;
    _TokenToTokenMap _libsToModules;
    _TokenSet _loadedSet;
 
    // This is only used to handle reentrant loading requests.
    std::deque<TfToken> _remainingLoadWork;
};
 
TF_API_TEMPLATE_CLASS(TfSingleton<TfScriptModuleLoader>);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_BASE_TF_SCRIPT_MODULE_LOADER_H