task_count.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 XCENA Inc.
 
#pragma once
 
#include <cstdint>
#include <utility>
 
namespace pxl
{
namespace detail
{
 
template <typename Builder>
class [[nodiscard]] TaskCountConfigured : public Builder
{
public:
    explicit TaskCountConfigured(Builder&& builder)
        : Builder(std::move(builder))
    {
    }
 
    TaskCountConfigured(TaskCountConfigured&&) noexcept = default;
    TaskCountConfigured& operator=(TaskCountConfigured&&) noexcept = default;
    TaskCountConfigured(const TaskCountConfigured&) = delete;
    TaskCountConfigured& operator=(const TaskCountConfigured&) = delete;
 
// Keep every setting's lvalue/rvalue behavior identical. No storage or exported
// symbols are added to the underlying builders.
#define PXL_CONFIGURED_SETTING(method)                \
    template <typename... Args>                       \
    TaskCountConfigured& method(Args&&... args)&      \
    {                                                 \
        Builder::method(std::forward<Args>(args)...); \
        return *this;                                 \
    }                                                 \
    template <typename... Args>                       \
    TaskCountConfigured&& method(Args&&... args)&&    \
    {                                                 \
        Builder::method(std::forward<Args>(args)...); \
        return std::move(*this);                      \
    }
 
    PXL_CONFIGURED_SETTING(tasks)
    PXL_CONFIGURED_SETTING(reserve)
    PXL_CONFIGURED_SETTING(batchSize)
    PXL_CONFIGURED_SETTING(clusterBitmap)
    PXL_CONFIGURED_SETTING(locality)
    PXL_CONFIGURED_SETTING(onComplete)
    PXL_CONFIGURED_SETTING(onMessage)
    PXL_CONFIGURED_SETTING(onError)
    PXL_CONFIGURED_SETTING(stream)
    PXL_CONFIGURED_SETTING(enableProfile)
 
#undef PXL_CONFIGURED_SETTING
 
    template <auto Func, typename... Args, typename B = Builder>
    auto stage(Args&&... args) & -> decltype(std::declval<B&>().template stage<Func>(std::forward<Args>(args)...))
    {
        return Builder::template stage<Func>(std::forward<Args>(args)...);
    }
 
    template <auto Func, typename... Args, typename B = Builder>
    auto stage(Args&&... args) && -> decltype(std::declval<B&&>().template stage<Func>(std::forward<Args>(args)...))
    {
        return std::move(static_cast<Builder&>(*this)).template stage<Func>(std::forward<Args>(args)...);
    }
 
    template <typename B = Builder>
    auto stage() & -> decltype(std::declval<B&>().stage())
    {
        return Builder::stage();
    }
 
    // A group returned from a temporary chain must own that chain. Borrowing
    // it would leave a stored group pointing at a destroyed parent.
    template <typename B = Builder>
    auto stage() && -> decltype(std::declval<B&&>().takeStageGroup())
    {
        return std::move(static_cast<Builder&>(*this)).takeStageGroup();
    }
};
 
template <typename Builder>
class [[nodiscard]] TaskCountRequired
{
public:
    explicit TaskCountRequired(Builder&& builder)
        : builder_(std::move(builder))
    {
    }
 
    TaskCountRequired(TaskCountRequired&&) noexcept = default;
    TaskCountRequired& operator=(TaskCountRequired&&) noexcept = default;
    TaskCountRequired(const TaskCountRequired&) = delete;
    TaskCountRequired& operator=(const TaskCountRequired&) = delete;
 
    TaskCountConfigured<Builder> tasks(uint32_t taskCount)
    {
        builder_.tasks(taskCount);
        return TaskCountConfigured<Builder>(std::move(builder_));
    }
 
    template <typename... Args>
    TaskCountRequired& reserve(Args&&... args)
    {
        builder_.reserve(std::forward<Args>(args)...);
        return *this;
    }
 
    template <typename... Args>
    TaskCountRequired& batchSize(Args&&... args)
    {
        builder_.batchSize(std::forward<Args>(args)...);
        return *this;
    }
 
    template <typename... Args>
    TaskCountRequired& clusterBitmap(Args&&... args)
    {
        builder_.clusterBitmap(std::forward<Args>(args)...);
        return *this;
    }
 
    template <typename... Args>
    TaskCountRequired& locality(Args&&... args)
    {
        builder_.locality(std::forward<Args>(args)...);
        return *this;
    }
 
    template <typename... Args>
    TaskCountRequired& onComplete(Args&&... args)
    {
        builder_.onComplete(std::forward<Args>(args)...);
        return *this;
    }
 
    template <typename... Args>
    TaskCountRequired& onMessage(Args&&... args)
    {
        builder_.onMessage(std::forward<Args>(args)...);
        return *this;
    }
 
    template <typename... Args>
    TaskCountRequired& onError(Args&&... args)
    {
        builder_.onError(std::forward<Args>(args)...);
        return *this;
    }
 
    template <typename... Args>
    TaskCountRequired& stream(Args&&... args)
    {
        builder_.stream(std::forward<Args>(args)...);
        return *this;
    }
 
    template <typename... Args>
    TaskCountRequired& enableProfile(Args&&... args)
    {
        builder_.enableProfile(std::forward<Args>(args)...);
        return *this;
    }
 
private:
    Builder builder_;
};
 
}  // namespace detail
}  // namespace pxl