TreeEditor.hpp

#pragma once
 
#include "MorphologicalTree.hpp"
 
#include <stdexcept>
 
namespace mmcfilters {
 
class TreeEditor {
    friend class MorphologicalTree;
 
private:
    MorphologicalTree* tree_ = nullptr;
    bool active_ = false;
 
    class EditSessionPause {
    private:
        MorphologicalTree& tree_;
        bool wasEditing_ = false;
 
    public:
        explicit EditSessionPause(MorphologicalTree& tree) noexcept
            : tree_(tree), wasEditing_(tree.editSessionOpen_) {
            tree_.editSessionOpen_ = false;
        }
 
        ~EditSessionPause() noexcept {
            tree_.editSessionOpen_ = wasEditing_;
        }
    };
 
    explicit TreeEditor(MorphologicalTree& tree) : tree_(&tree), active_(true) {
        tree_->beginEditSession();
    }
 
    MorphologicalTree& tree() const {
        if (!active_ || tree_ == nullptr) {
            throw std::logic_error("TreeEditor operation requires an active edit session.");
        }
        return *tree_;
    }
 
public:
    TreeEditor(const TreeEditor&) = delete;
    TreeEditor& operator=(const TreeEditor&) = delete;
 
    TreeEditor(TreeEditor&& other) noexcept
        : tree_(other.tree_), active_(other.active_) {
        other.tree_ = nullptr;
        other.active_ = false;
    }
 
    TreeEditor& operator=(TreeEditor&&) = delete;
 
    ~TreeEditor() = default;
 
    [[nodiscard("Discarding a detached node id makes the staged edit impossible to complete safely")]] NodeId createDetachedNode() {
        MorphologicalTree& t = tree();
        return t.createDetachedNode();
    }
 
    void detach(NodeId nodeId) {
        MorphologicalTree& t = tree();
        if (!t.isAlive(nodeId)) {
            throw std::invalid_argument("TreeEditor::detach requires a live node.");
        }
        if (t.isRoot(nodeId)) {
            throw std::invalid_argument("TreeEditor::detach cannot detach the connected root.");
        }
        t.detachNode(nodeId);
    }
 
    void reparent(NodeId nodeId, NodeId newParentId) {
        MorphologicalTree& t = tree();
        if (!t.isAlive(nodeId) || !t.isAlive(newParentId)) {
            throw std::invalid_argument("TreeEditor::reparent requires live node ids.");
        }
        if (t.isRoot(nodeId)) {
            throw std::invalid_argument("TreeEditor::reparent cannot move the connected root.");
        }
        if (nodeId == newParentId) {
            throw std::invalid_argument("TreeEditor::reparent requires distinct node ids.");
        }
        t.moveNode(nodeId, newParentId);
    }
 
    void attach(NodeId parentId, NodeId detachedNodeId) {
        MorphologicalTree& t = tree();
        if (!t.isAlive(parentId) || !t.isAlive(detachedNodeId)) {
            throw std::invalid_argument("TreeEditor::attach requires live node ids.");
        }
        if (parentId == detachedNodeId) {
            throw std::invalid_argument("TreeEditor::attach requires distinct node ids.");
        }
        if (t.getNodeParent(detachedNodeId) != detachedNodeId) {
            throw std::invalid_argument("TreeEditor::attach expects a detached self-parented node.");
        }
        t.attachNode(parentId, detachedNodeId);
    }
 
    void moveChildren(NodeId parentId, NodeId sourceId) {
        MorphologicalTree& t = tree();
        if (!t.isAlive(parentId) || !t.isAlive(sourceId)) {
            throw std::invalid_argument("TreeEditor::moveChildren requires live node ids.");
        }
        if (parentId == sourceId) {
            throw std::invalid_argument("TreeEditor::moveChildren requires distinct node ids.");
        }
        t.moveChildren(parentId, sourceId);
    }
 
    void moveProperPart(NodeId targetNodeId, NodeId sourceNodeId, NodeId properPartId) {
        MorphologicalTree& t = tree();
        if (!t.isAlive(targetNodeId) || !t.isAlive(sourceNodeId)) {
            throw std::invalid_argument("TreeEditor::moveProperPart requires live node ids.");
        }
        if (targetNodeId == sourceNodeId) {
            throw std::invalid_argument("TreeEditor::moveProperPart requires distinct source and target nodes.");
        }
        if (!t.isProperPart(properPartId)) {
            throw std::invalid_argument("TreeEditor::moveProperPart requires a valid proper-part id.");
        }
        t.moveProperPart(targetNodeId, sourceNodeId, properPartId);
    }
 
    void moveProperParts(NodeId targetNodeId, NodeId sourceNodeId) {
        MorphologicalTree& t = tree();
        if (!t.isAlive(targetNodeId) || !t.isAlive(sourceNodeId)) {
            throw std::invalid_argument("TreeEditor::moveProperParts requires live node ids.");
        }
        if (targetNodeId == sourceNodeId) {
            throw std::invalid_argument("TreeEditor::moveProperParts requires distinct source and target nodes.");
        }
        t.moveProperParts(targetNodeId, sourceNodeId);
    }
 
    void removeChild(NodeId parentNodeId, NodeId childId, bool releaseNodeFlag) {
        MorphologicalTree& t = tree();
        if (!t.isAlive(parentNodeId) || !t.isAlive(childId)) {
            throw std::invalid_argument("TreeEditor::removeChild requires live node ids.");
        }
        if (!t.hasChild(parentNodeId, childId)) {
            throw std::invalid_argument("TreeEditor::removeChild requires a direct parent-child relation.");
        }
        t.removeChild(parentNodeId, childId, releaseNodeFlag);
    }
 
    void releaseNode(NodeId nodeId) {
        MorphologicalTree& t = tree();
        if (!t.isAlive(nodeId)) {
            throw std::invalid_argument("TreeEditor::releaseNode requires a live node.");
        }
        if (t.isRoot(nodeId)) {
            throw std::invalid_argument("TreeEditor::releaseNode cannot release the connected root.");
        }
        if (t.getNodeParent(nodeId) != nodeId) {
            throw std::invalid_argument("TreeEditor::releaseNode expects a detached self-parented node.");
        }
        t.releaseNode(nodeId);
    }
 
    void setRoot(NodeId nodeId) {
        MorphologicalTree& t = tree();
        if (!t.isAlive(nodeId)) {
            throw std::invalid_argument("TreeEditor::setRoot requires a live node.");
        }
        t.setRoot(nodeId);
    }
 
    void pruneNode(NodeId nodeId) {
        MorphologicalTree& t = tree();
        EditSessionPause pause(t);
        t.pruneNode(nodeId);
    }
 
    void mergeNodeIntoParent(NodeId nodeId) {
        MorphologicalTree& t = tree();
        EditSessionPause pause(t);
        t.mergeNodeIntoParent(nodeId);
    }
 
    [[nodiscard]] bool hasDetachedAliveNodes() const noexcept {
        return active_ && tree_ != nullptr && tree_->hasDetachedAliveNodes();
    }
 
    [[nodiscard]] TreeValidationResult validate() const noexcept {
        if (!active_ || tree_ == nullptr) {
            return {false, "TreeEditor validation requires an active edit session."};
        }
        return tree_->validateConnectedRootedTreeResult();
    }
 
    [[nodiscard("Inspect the validation result or use commit() for exception-based failure handling")]] TreeValidationResult validateAndCommit() noexcept {
        TreeValidationResult result = validate();
        if (!result.ok) {
            return result;
        }
        tree_->endEditSession();
        active_ = false;
        return result;
    }
 
    void commit() {
        TreeValidationResult result = validateAndCommit();
        if (!result.ok) {
            throw std::runtime_error(result.message);
        }
    }
 
    void commitUnchecked() noexcept {
        if (active_ && tree_ != nullptr) {
#if defined(MMCFILTERS_ENABLE_ASSERTS)
            const TreeValidationResult result = validate();
            assert(result.ok && "TreeEditor::commitUnchecked requires a valid tree when MMCFILTERS_ENABLE_ASSERTS is enabled.");
#endif
            tree_->endEditSession();
            active_ = false;
        }
    }
};
 
inline TreeEditor MorphologicalTree::edit() {
    return TreeEditor(*this);
}
 
} // namespace mmcfilters