Workspace.h

Go to the documentation of this file.

//-
// ================================================================================================
// Copyright 2024 Autodesk, Inc.  All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license agreement provided
// at the time of installation or download, or which otherwise accompanies this software in
// either electronic or hard copy form.
// ================================================================================================
//+
 
 
#ifndef BIFROSTGRAPH_EXECUTOR_WORKSPACE_H
#define BIFROSTGRAPH_EXECUTOR_WORKSPACE_H
 
#include <BifrostGraph/Executor/internal/ExecutorExport.h>
#include <BifrostGraph/Executor/internal/PropagateConstPtr.h>
 
#include <BifrostGraph/Executor/Factory.h>
#include <BifrostGraph/Executor/GraphContainer.h>
#include <BifrostGraph/Executor/Owner.h>
#include <BifrostGraph/Executor/TypeTranslation.h>
#include <BifrostGraph/Executor/Types.h>
 
#include <Amino/Core/String.h>
 
#include <utility>
 
//-------------------------------------------------------------------------------------------------
// Forward declarations
//-------------------------------------------------------------------------------------------------
 
namespace Amino {
class TypeId;
} // namespace Amino
 
namespace BifrostGraph {
namespace Executor {
 
class Library;
class Watchpoint;
class WatchpointLayoutFactory;
 
namespace Private {
class IGraphContainerOwner;
class IRestrictedWorkspaceServices;
class WorkspaceImpl;
} // namespace Private
 
//-------------------------------------------------------------------------------------------------
// CLASS Workspace
//-------------------------------------------------------------------------------------------------
class BIFROSTGRAPH_EXECUTOR_SHARED_DECL Workspace {
protected:
    //---------------------------------------------------------------------------------------------
    // Initialization
    //---------------------------------------------------------------------------------------------
 
    explicit Workspace(const Amino::String& name) noexcept;
 
    explicit Workspace(Uninitialized uninitialized) noexcept;
 
    EXECUTOR_DECLARE_MAKE_OWNER_FRIENDSHIP();
 
public:
    virtual ~Workspace() noexcept;
 
    virtual bool isValid() const noexcept;
 
    static Workspace& getInvalid() noexcept;
 
    //---------------------------------------------------------------------------------------------
    // Library
    //---------------------------------------------------------------------------------------------
 
    const Library& getLibrary() const noexcept;
    Library&       getLibrary() noexcept;
 
    //---------------------------------------------------------------------------------------------
    // Configuration Files
    //---------------------------------------------------------------------------------------------
 
    bool loadConfigFiles(const StringArray& configFiles,
                         const StringArray& disabledPacks = StringArray()) noexcept;
 
    //---------------------------------------------------------------------------------------------
    // Resources Services
    //---------------------------------------------------------------------------------------------
 
    bool registerTypeTranslationsPlugins(TypeTranslation::PluginHostData* hostData) const noexcept;
 
    bool unregisterTypeTranslationsPlugins(
        TypeTranslation::PluginHostData* hostData) const noexcept;
 
    //---------------------------------------------------------------------------------------------
    // GraphContainer Management
    //---------------------------------------------------------------------------------------------
 
    template <typename Functor>
    GraphContainer& addGraphContainerT(Functor&& func) noexcept {
        if (isValid()) {
            // Make a new GraphContainer (potentially a class derived from GraphContainer).
            Owner<GraphContainer> owner;
            try {
                owner = std::forward<Functor&&>(func)(getGraphContainerOwnerServices());
            } catch (...) {
            }
            // Validate then add the new GraphContainer.
            // Upon failure, validateAndAddGraphContainer will destroy the GraphContainer (if any).
            GraphContainer* container = validateAndAddGraphContainer(std::move(owner));
            if (container) {
                return *container;
            }
        }
        // Upon any failure, return an invalid GraphContainer:
        return GraphContainer::getInvalid();
    }
 
    template <typename T>
    using DeleterFunc = void (*)(T* p);
 
    GraphContainer& addGraphContainer() noexcept;
    GraphContainer& addGraphContainer(DeleterFunc<GraphContainer> deleter) noexcept;
 
    bool deleteGraphContainer(GraphContainer& graphContainer) noexcept;
 
    const Watchpoint* getWatchpoint(const Amino::TypeId& typeId) const noexcept;
 
    WatchpointLayoutFactory const& getWatchpointLayoutFactory() const noexcept;
    WatchpointLayoutFactory&       getWatchpointLayoutFactory() noexcept;
 
protected:
    void reportMessage(MessageCategory category, const Amino::String& message) const noexcept;
 
private:
    virtual void onReportedMessage(MessageSource        source,
                                   MessageCategory      category,
                                   const Amino::String& message) const noexcept;
 
    Private::IGraphContainerOwner& getGraphContainerOwnerServices() noexcept;
 
    GraphContainer* validateAndAddGraphContainer(Owner<GraphContainer>&& owner) noexcept;
 
public:
    //---------------------------------------------------------------------------------------------
    // IRestrictedWorkspaceServices
    //---------------------------------------------------------------------------------------------
 
    const Private::IRestrictedWorkspaceServices& getRestrictedServices() const noexcept;
    Private::IRestrictedWorkspaceServices&       getRestrictedServices() noexcept;
 
private:
    Workspace(const Workspace&)            = delete;
    Workspace(Workspace&&)                 = delete;
    Workspace& operator=(const Workspace&) = delete;
    Workspace& operator=(Workspace&&)      = delete;
 
private:
    friend class Private::WorkspaceImpl;
    Internal::PropagateConstPtr<Private::WorkspaceImpl, Internal::Owned::kYes> m_impl;
    static Workspace                                                           s_invalid;
};
} // namespace Executor
} // namespace BifrostGraph
 
#endif // BIFROSTGRAPH_EXECUTOR_WORKSPACE_H