integrator_decorator.hpp

#pragma once
 
#include "../concepts.hpp"
#include "../abstract_integrator.hpp"
#include <memory>
 
namespace diffeq::core::composable {
 
template<system_state S>
class IntegratorDecorator : public AbstractIntegrator<S> {
public:
    using base_type = AbstractIntegrator<S>;
    using state_type = typename base_type::state_type;
    using time_type = typename base_type::time_type;
    using system_function = typename base_type::system_function;
 
protected:
    std::unique_ptr<base_type> wrapped_integrator_;
 
public:
    explicit IntegratorDecorator(std::unique_ptr<base_type> integrator)
        : base_type(integrator->sys_), wrapped_integrator_(std::move(integrator)) {}
 
    virtual ~IntegratorDecorator() = default;
 
    // Delegate core functionality by default - decorators override as needed
    void step(state_type& state, time_type dt) override {
        wrapped_integrator_->step(state, dt);
    }
 
    void integrate(state_type& state, time_type dt, time_type end_time) override {
        wrapped_integrator_->integrate(state, dt, end_time);
    }
 
    time_type current_time() const override {
        return wrapped_integrator_->current_time();
    }
 
    void set_time(time_type t) override {
        wrapped_integrator_->set_time(t);
        this->current_time_ = t;
    }
 
    void set_system(system_function sys) override {
        wrapped_integrator_->set_system(std::move(sys));
        this->sys_ = wrapped_integrator_->sys_;
    }
 
    base_type& wrapped() { return *wrapped_integrator_; }
    const base_type& wrapped() const { return *wrapped_integrator_; }
 
    bool has_wrapped_integrator() const { return wrapped_integrator_ != nullptr; }
};
 
} // namespace diffeq::core::composable