EditorTransactionConsumer.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "editor/EditCommand.h"
#include "editor/EditorAuthority.h"
#include "transaction/Transaction.h"
 
#include <cstddef>
#include <memory>
#include <optional>
#include <span>
#include <string>
#include <vector>
 
namespace eve::editor {
 
struct EditorTransactionRecord {
    transaction::TransactionReceipt                coordinator;
    TransactionSpec                                specification;
    std::optional<eve::editor::TransactionReceipt> authorityReceipt;
    std::size_t                                    commandCount   = 0;
    std::size_t                                    operationCount = 0;
};
 
struct EditorDryRunReport {
    TransactionSpec              specification;
    std::size_t                  commandCount   = 0;
    std::size_t                  operationCount = 0;
    std::optional<AuthorityPlan> authorityPlan;
};
 
enum class EditorCommitState {
    Pending,
    FailedRetryable,
    Committed,
    Discarded,
};
 
class EVENGINE_API_ORCHESTRATION EditorTransactionConsumer {
public:
    explicit EditorTransactionConsumer(IEditAuthority* authority = nullptr);
    ~EditorTransactionConsumer();
 
    EditorTransactionConsumer(const EditorTransactionConsumer&)            = delete;
    EditorTransactionConsumer& operator=(const EditorTransactionConsumer&) = delete;
 
    [[nodiscard]] eve::Result<void> setAuthority(IEditAuthority* authority);
    [[nodiscard]] eve::Result<TransactionId> begin(TransactionSpec specification);
    [[nodiscard]] eve::Result<TransactionId> beginLegacy(std::string label);
 
    [[nodiscard]] eve::Result<void> append(std::unique_ptr<IEditCommand> command);
    [[nodiscard]] eve::Result<void> appendPreview(std::unique_ptr<IEditCommand> command);
    [[nodiscard]] eve::Result<void> append(DomainOperation operation);
 
    [[nodiscard]] eve::Result<EditorDryRunReport> dryRun() const;
    [[nodiscard]] eve::Result<EditorTransactionRecord> commit();
    [[nodiscard]] eve::Result<EditorTransactionRecord> commit(
        std::span<transaction::ITransactionParticipant*> additional);
    [[nodiscard]] eve::Result<EditorTransactionRecord> retry(
        std::span<transaction::ITransactionParticipant*> additional = {});
    [[nodiscard]] eve::Result<void> discard();
    [[nodiscard]] eve::Result<void> rollback();
    [[nodiscard]] eve::Result<EditorTransactionRecord> undo();
    [[nodiscard]] eve::Result<EditorTransactionRecord> redo();
 
    [[nodiscard]] bool active() const noexcept;
    [[nodiscard]] bool canUndo() const noexcept;
    [[nodiscard]] bool canRedo() const noexcept;
    [[nodiscard]] std::size_t undoCount() const noexcept;
    [[nodiscard]] std::size_t redoCount() const noexcept;
    [[nodiscard]] EditorCommitState state() const noexcept;
    [[nodiscard]] const std::vector<eve::Diagnostic>& diagnostics() const noexcept;
    void clear();
 
private:
    [[nodiscard]] eve::Result<EditorTransactionRecord> commitAttempt(
        std::span<transaction::ITransactionParticipant*> additional, bool retryAttempt);
 
    struct Impl;
    std::unique_ptr<Impl> impl_;
};
 
}  // namespace eve::editor