expression_memory_pool.h

Go to the documentation of this file.

/*
 * Copyright 2026 MusicScience37 (Kenta Kabashima)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once
 
#include <memory_resource>
#include <type_traits>
#include <utility>
#include <variant>
 
#include "func_sketch/expressions/expression.h"
 
namespace func_sketch::expressions {

class ExpressionMemoryPool {
public:
    ExpressionMemoryPool()
        : memory_resource_(), allocator_(&memory_resource_) {}

    template <typename T, typename... Args>
    [[nodiscard]] Expression* create(Args&&... args) {
        return allocator_.new_object<Expression>(
            T(std::forward<Args>(args)...));
    }

    void destroy(Expression* expression) noexcept {  // NOLINT(*-exception-*)
        if (expression == nullptr) {
            return;
        }
 
        // Remove child expressions.
        std::visit(
            [this](auto& expr) noexcept {
                using ExpressionType = std::decay_t<decltype(expr)>;
                if constexpr (std::is_same_v<ExpressionType, UnaryExpression>) {
                    destroy(expr.target);
                } else if constexpr (std::is_same_v<ExpressionType,
                                         BinaryExpression>) {
                    destroy(expr.left);
                    destroy(expr.right);
                } else if constexpr (std::is_same_v<ExpressionType,
                                         FunctionCallExpression>) {
                    for (auto& arg : expr.arguments) {
                        destroy(arg);
                    }
                }
            },
            expression->as_variant());
 
        allocator_.delete_object(expression);
    }
 
private:
    std::pmr::monotonic_buffer_resource memory_resource_;

    std::pmr::polymorphic_allocator<Expression> allocator_;
};
 
}  // namespace func_sketch::expressions