EditorCommandService.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "editor/EditorCommandTypes.h"
#include "editor/EditorHostProfile.h"
#include "editor/EditorProtocol.h"
#include "editor/EditorResult.h"
#include "editor/EditorValue.h"
 
#include <functional>
#include <string>
#include <vector>
 
namespace eve::editor {
 
class EditorSession;
 
struct CommandContext {
    EditorSession*     session = nullptr;
    const HostProfile* profile = nullptr;
    TargetId           target;
    uint64_t           targetRevision = 0;
    CommandSource      source         = CommandSource::Api;
};
 
struct CommandDescriptor {
    CommandId   id;
    std::string ownerModule;
    std::string displayName;
    std::string category;
    HostFeature requiredFeatures   = HostFeature::None;
    bool        createsTransaction = true;
    bool        automationAllowed  = true;
};
 
using EditorCommandHandler = std::function<Result<EditorValue>(const CommandContext&, const EditorValue&)>;
using EditorCommandPlanner = std::function<Result<CommandPlan>(const CommandRequest&)>;
using EditorCommandPlanExecutor =
    std::function<Result<TransactionReceipt>(const CommandRequest&, const CommandPlan&)>;
 
class EVENGINE_API_ORCHESTRATION EditorCommandService {
public:
    Result<EditorValue> registerCommand(CommandDescriptor descriptor, EditorCommandHandler handler,
                                              bool replace = false);
    Result<EditorValue> registerPlannedCommand(CommandDescriptor descriptor, EditorCommandPlanner planner,
                                                     EditorCommandPlanExecutor executor, bool replace = false);
    bool unregisterCommand(const CommandId& id, const std::string& ownerModule = {});
    size_t unregisterOwner(const std::string& ownerModule);
    void clear();
 
    const CommandDescriptor* find(const CommandId& id) const;
    [[nodiscard]] bool supportsPlanning(const CommandId& id) const;
    std::vector<CommandDescriptor> commands(const HostProfile& profile) const;
    uint64_t revision() const { return revision_; }
 
    Result<EditorValue> execute(const CommandId& id, const CommandContext& context,
                                      const EditorValue& payload) const;
    Result<CommandPlan> plan(const CommandRequest& request, const HostProfile& profile) const;
    Result<TransactionReceipt> executePlan(const CommandRequest& request, const CommandPlan& plan,
                                                 const HostProfile& profile) const;
 
private:
    struct Registration {
        CommandDescriptor         descriptor;
        EditorCommandHandler      handler;
        EditorCommandPlanner      planner;
        EditorCommandPlanExecutor planExecutor;
        uint64_t                  generation = 0;
    };
 
    static Result<EditorValue> error(EditorStatus status, const char* rule, std::string message);
    [[nodiscard]] Result<void> checkExecutionPolicy(const CommandDescriptor& descriptor, const CommandId& id,
                                                            CommandSource source, const EditorValue& payload,
                                                            const HostProfile& profile) const;
    std::vector<Registration>        commands_;
    uint64_t                         revision_     = 0;
    uint64_t                         nextRegistrationGeneration_ = 1;
    mutable uint64_t                 planSequence_ = 0;
};
 
}  // namespace eve::editor