future_task.h

// Copyright 2026 The Pigweed Authors
//
// 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
//
//     https://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 "pw_async2/future.h"
#include "pw_async2/poll.h"
#include "pw_async2/task.h"
 
namespace pw::async2 {
 
 
template <typename T>
class FutureTask final : public Task {
 public:
  using future_type = std::remove_reference_t<T>;
 
  using value_type = typename future_type::value_type;
 
  template <typename Arg, typename... Args>
  explicit constexpr FutureTask(Arg&& arg, Args&&... args)
      : Task(PW_ASYNC_TASK_NAME("FutureTask")),
        future_(std::forward<Arg>(arg), std::forward<Args>(args)...),
        output_(Pending()) {}
 
  ~FutureTask() override { Deregister(); }
 
  Poll<value_type> TakePoll() { return std::move(output_); }
 
  FutureValue<future_type>& value() & { return output_.value(); }
  const FutureValue<future_type>& value() const& { return output_.value(); }
  FutureValue<future_type>&& value() && { return std::move(output_).value(); }
  const FutureValue<future_type>&& value() const&& {
    return std::move(output_).value();
  }
 
  FutureValue<future_type>& Wait() {
    Task::Join();
    return *output_;
  }
 
 private:
  static_assert(Future<future_type>);
 
  Poll<> DoPend(Context& cx) override {
    output_ = future_.Pend(cx);
    return output_.Readiness();
  }
 
  T future_;
  Poll<value_type> output_;
};
 
template <typename T>
FutureTask(T&& value) -> FutureTask<T>;
 
 
}  // namespace pw::async2