Job.h

Go to the documentation of this file.

//-
// ================================================================================================
// Copyright 2025 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_JOB_H
#define BIFROSTGRAPH_EXECUTOR_JOB_H
 
#include <BifrostGraph/Executor/Factory.h>
#include <BifrostGraph/Executor/TypeTranslation.h>
 
#include <BifrostGraph/Executor/internal/ExecutorExport.h>
#include <BifrostGraph/Executor/internal/PropagateConstPtr.h>
 
#include <Amino/Core/Any.h>
#include <Amino/Core/String.h>
 
//-------------------------------------------------------------------------------------------------
// Forward declarations
//-------------------------------------------------------------------------------------------------
 
namespace BifrostGraph {
namespace Executor {
 
class GraphContainer;
class Workspace;
 
namespace Private {
class IJobOwner;
class IRestrictedJobServices;
class JobImpl;
} // namespace Private
 
 
//-------------------------------------------------------------------------------------------------
// CLASS Job
//-------------------------------------------------------------------------------------------------
 
class BIFROSTGRAPH_EXECUTOR_SHARED_DECL Job final {
public:
    struct BIFROSTGRAPH_EXECUTOR_SHARED_DECL Input final {
        Amino::String name;         
        Amino::String typeName;     
        Amino::Any    defaultValue; 
        bool          isJobPort;    
    };
    using Inputs = Amino::Array<Input>;
 
    struct BIFROSTGRAPH_EXECUTOR_SHARED_DECL Output final {
        Amino::String name;       
        Amino::String typeName;   
        bool          isTerminal; 
        bool          isEnabled;  
    };
    using Outputs = Amino::Array<Output>;
 
    struct BIFROSTGRAPH_EXECUTOR_SHARED_DECL TerminalState final {
        Amino::String name;    
        bool          enabled; 
    };
    using TerminalStates = Amino::Array<TerminalState>;
 
private:
    //---------------------------------------------------------------------------------------------
    // Initialization
    //---------------------------------------------------------------------------------------------
 
    explicit Job(Private::IJobOwner& owner) noexcept;
 
    explicit Job(Uninitialized uninitialized) noexcept;
 
    EXECUTOR_DECLARE_MAKE_OWNER_FRIENDSHIP();
 
public:
    ~Job() noexcept;
 
    bool isValid() const noexcept;
 
    static Job& getInvalid() noexcept;
 
    const GraphContainer& getGraphContainer() const noexcept;
    GraphContainer&       getGraphContainer() noexcept;
 
    const Workspace& getWorkspace() const noexcept;
    Workspace&       getWorkspace() noexcept;
 
    void enableRuntimeLogging(bool enable) noexcept;
 
    bool isRuntimeLoggingEnabled() const noexcept;
 
    const Inputs& getInputs() const noexcept;
 
    bool setInputValue(const Input& input, const TypeTranslation::ValueData* valueData) noexcept;
 
    JobExecutionStatus execute(JobExecutionMode mode = JobExecutionMode::kDefault) noexcept;
 
    const Outputs& getOutputs() const noexcept;
 
    bool getOutputValue(const Output& output, TypeTranslation::ValueData* valueData) const noexcept;
 
    bool setTerminalStates(const TerminalStates& terminalStates) noexcept;
 
    //---------------------------------------------------------------------------------------------
    // IRestrictedJobServices
    //---------------------------------------------------------------------------------------------
 
    const Private::IRestrictedJobServices& getRestrictedServices() const noexcept;
    Private::IRestrictedJobServices&       getRestrictedServices() noexcept;
 
private:
    Job(const Job&)            = delete;
    Job(Job&&)                 = delete;
    Job& operator=(const Job&) = delete;
    Job& operator=(Job&&)      = delete;
 
private:
    Internal::PropagateConstPtr<Private::JobImpl, Internal::Owned::kYes> m_impl;
    static Job                                                           g_invalid;
};
 
} // namespace Executor
} // namespace BifrostGraph
 
#endif // BIFROSTGRAPH_EXECUTOR_JOB_H