ExpressionNodeLocationFinder.h

/*
 * GDevelop Core
 * Copyright 2008-present Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#ifndef GDCORE_EXPRESSIONNODELOCATIONFINDER_H
#define GDCORE_EXPRESSIONNODELOCATIONFINDER_H
 
#include <memory>
#include <vector>
 
#include "GDCore/Events/Parsers/ExpressionParser2Node.h"
#include "GDCore/Events/Parsers/ExpressionParser2NodeWorker.h"
namespace gd {
class Expression;
class ObjectsContainer;
class Platform;
class ParameterMetadata;
class ExpressionMetadata;
}  // namespace gd
 
namespace gd {
 
class GD_CORE_API ExpressionNodeLocationFinder
    : public ExpressionParser2NodeWorker {
 public:
  ExpressionNodeLocationFinder(size_t searchedPosition_)
      : searchedPosition(searchedPosition_),
        foundNode(nullptr),
        parentNode(nullptr) {};
  virtual ~ExpressionNodeLocationFinder() {};
 
  static ExpressionNode* GetNodeAtPosition(gd::ExpressionNode& node,
                                           size_t searchedPosition) {
    gd::ExpressionNodeLocationFinder finder(searchedPosition);
    node.Visit(finder);
    return finder.GetNode();
  }
 
  static ExpressionNode* GetParentNodeAtPosition(gd::ExpressionNode& node,
                                                 size_t searchedPosition) {
    gd::ExpressionNodeLocationFinder finder(searchedPosition);
    node.Visit(finder);
    return finder.GetParentNode();
  }
 
  ExpressionNode* GetNode() { return foundNode; };
 
  ExpressionNode* GetParentNode() { return parentNode; };
 
 protected:
  void OnVisitSubExpressionNode(SubExpressionNode& node) override {
    CheckSearchPositionInNode(node);
    node.expression->Visit(*this);
  }
  void OnVisitOperatorNode(OperatorNode& node) override {
    if (CheckSearchPositionInNode(node)) {
      node.leftHandSide->Visit(*this);
      node.rightHandSide->Visit(*this);
    }
  }
  void OnVisitUnaryOperatorNode(UnaryOperatorNode& node) override {
    CheckSearchPositionInNode(node);
    node.factor->Visit(*this);
  }
  void OnVisitNumberNode(NumberNode& node) override {
    CheckSearchPositionInNode(node);
  }
  void OnVisitTextNode(TextNode& node) override {
    CheckSearchPositionInNode(node);
  }
  void OnVisitVariableNode(VariableNode& node) override {
    if (CheckSearchPositionInNode(node)) {
      if (node.child) node.child->Visit(*this);
    }
  }
  void OnVisitVariableAccessorNode(VariableAccessorNode& node) override {
    if (CheckSearchPositionInNode(node)) {
      if (node.child) node.child->Visit(*this);
    }
  }
  void OnVisitVariableBracketAccessorNode(
      VariableBracketAccessorNode& node) override {
    if (CheckSearchPositionInNode(node)) {
      node.expression->Visit(*this);
      if (node.child) node.child->Visit(*this);
    }
  }
  void OnVisitIdentifierNode(IdentifierNode& node) override {
    CheckSearchPositionInNode(node);
  }
  void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) override {
    CheckSearchPositionInNode(node);
  }
  void OnVisitFunctionCallNode(FunctionCallNode& node) override {
    CheckSearchPositionInNode(node);
    for (auto& parameter : node.parameters) {
      parameter->Visit(*this);
    }
  }
  void OnVisitEmptyNode(EmptyNode& node) override {
    CheckSearchPositionInNode(node, /*inclusive=*/true);
  }
 
 private:
  bool CheckSearchPositionInNode(ExpressionNode& node, bool inclusive = false) {
    if (node.location.GetStartPosition() <= searchedPosition &&
        ((!inclusive && searchedPosition < node.location.GetEndPosition()) ||
         (inclusive && searchedPosition <= node.location.GetEndPosition()))) {
      parentNode = foundNode;
      foundNode = &node;
      return true;
    }
 
    return false;
  }
 
  size_t searchedPosition;
  ExpressionNode* foundNode;
  ExpressionNode* parentNode;
};
 
}  // namespace gd
 
#endif  // GDCORE_EXPRESSIONNODELOCATIONFINDER_H