filter_expression.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2025 Povl Filip Sonne-Frederiksen
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
 
#include <reusex/types.hpp>
#include <memory>
#include <string>
#include <unordered_set>
#include <vector>
 
namespace reusex {
// Forward declaration
class ProjectDB;
} // namespace reusex
 
namespace reusex::core {

class FilterNode {
public:
  virtual ~FilterNode() = default;

  virtual auto evaluate(int32_t label_value) const -> bool = 0;
};

class CloudReferenceNode {
  std::string cloud_name_;
  CloudLConstPtr label_cloud_;
 
public:
  CloudReferenceNode(std::string name, CloudLConstPtr labels)
      : cloud_name_(std::move(name)), label_cloud_(std::move(labels)) {}
 
  auto labels() const -> const CloudLConstPtr & { return label_cloud_; }
  auto name() const -> const std::string & { return cloud_name_; }
  auto size() const -> size_t { return label_cloud_->size(); }
};

class EqualNode : public FilterNode {
  int32_t value_;
 
public:
  explicit EqualNode(int32_t value) : value_(value) {}
  auto evaluate(int32_t label) const -> bool override {
    return label == value_;
  }
};

class NotEqualNode : public FilterNode {
  int32_t value_;
 
public:
  explicit NotEqualNode(int32_t value) : value_(value) {}
  auto evaluate(int32_t label) const -> bool override {
    return label != value_;
  }
};

class InNode : public FilterNode {
  std::unordered_set<int32_t> values_;
 
public:
  explicit InNode(std::vector<int32_t> values)
      : values_(values.begin(), values.end()) {}
  auto evaluate(int32_t label) const -> bool override {
    return values_.count(label) > 0;
  }
};

class CompareNode : public FilterNode {
public:
  enum class Op { GT, GE, LT, LE };
 
private:
  Op op_;
  int32_t value_;
 
public:
  CompareNode(Op op, int32_t value) : op_(op), value_(value) {}
  auto evaluate(int32_t label) const -> bool override {
    switch (op_) {
    case Op::GT:
      return label > value_;
    case Op::GE:
      return label >= value_;
    case Op::LT:
      return label < value_;
    case Op::LE:
      return label <= value_;
    }
    return false;
  }
};

class AndNode : public FilterNode {
  std::unique_ptr<FilterNode> left_;
  std::unique_ptr<FilterNode> right_;
 
public:
  AndNode(std::unique_ptr<FilterNode> left, std::unique_ptr<FilterNode> right)
      : left_(std::move(left)), right_(std::move(right)) {}
  auto evaluate(int32_t label) const -> bool override {
    return left_->evaluate(label) && right_->evaluate(label);
  }
};

class OrNode : public FilterNode {
  std::unique_ptr<FilterNode> left_;
  std::unique_ptr<FilterNode> right_;
 
public:
  OrNode(std::unique_ptr<FilterNode> left, std::unique_ptr<FilterNode> right)
      : left_(std::move(left)), right_(std::move(right)) {}
  auto evaluate(int32_t label) const -> bool override {
    return left_->evaluate(label) || right_->evaluate(label);
  }
};

struct FilterExpression {
  std::unique_ptr<FilterNode> root; 
  std::vector<CloudReferenceNode> clouds; 

  auto evaluate_point(size_t idx) const -> bool;
};

auto parse_filter_expression(const std::string &expression, ProjectDB &db)
    -> std::unique_ptr<FilterExpression>;

auto evaluate_filter(const FilterExpression &expr, size_t cloud_size)
    -> IndicesPtr;
 
} // namespace reusex::core