AppleDispatchQueue.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Function.hpp"
 
#include "CeresEngine/Foundation/Threading/DispatchQueue.hpp"
 
#include <dispatch/dispatch.h>
 
namespace CeresEngine {
 
    class AppleDispatchQueue : public DispatchQueue {
    public:
        class Executor;
 
    private:
        dispatch_queue_t mQueue;
 
        DispatchQueueType mType;
 
    public:
        explicit AppleDispatchQueue(const String& name, DispatchQueueType type, AppleDispatchQueue* const queue = nullptr) noexcept;
 
        explicit AppleDispatchQueue(dispatch_queue_t queue, DispatchQueueType type) noexcept;
 
        ~AppleDispatchQueue() noexcept override;
 
    public:
        [[nodiscard]] AnyExecutor getExecutor() noexcept final;
 
        void suspend() final;
 
        void resume() final;
 
        UPtr<DispatchQueue> createSubQueue(DispatchQueueType type, StringView name = "") final;
 
        [[nodiscard]] dispatch_queue_t getDispatchQueue() const noexcept { return mQueue; }
 
    private: // Executor interface
        void onWorkStarted() noexcept;
 
        void onWorkFinished() noexcept;
 
        void schedule(UniqueFunction<void()> function, ExecutorBlocking blockingProperty, ExecutorPriority priority);
 
    public: // ASIO ExecutionContext concept
        using executor_type = Executor;
 
        [[nodiscard]] executor_type get_executor() noexcept;
    };
 
    class AppleDispatchQueue::Executor {
        friend class AppleDispatchQueue;
 
    private:
        AppleDispatchQueue* mExecutionContext;
 
        ExecutorBlocking mBlockingProperty = ExecutorBlocking::never;
 
        ExecutorPriority mPriority = ExecutorPriority::Normal;
 
    private:
        explicit Executor(AppleDispatchQueue& executionContext, ExecutorBlocking blockingProperty = ExecutorBlocking::never,
            ExecutorPriority priority = ExecutorPriority::Normal)
                : mExecutionContext(&executionContext), mBlockingProperty(blockingProperty), mPriority(priority) {}
 
    public:
        Executor(const Executor&) = default;
        Executor& operator=(const Executor&) = default;
        Executor(Executor&&) = default;
        Executor& operator=(Executor&&) = default;
 
    public:
        [[nodiscard]] AppleDispatchQueue& context() const noexcept { return *mExecutionContext; }
 
        void on_work_started() const noexcept {
            CE_ASSERT(mExecutionContext != nullptr);
            mExecutionContext->onWorkStarted();
        }
 
        void on_work_finished() const noexcept {
            CE_ASSERT(mExecutionContext != nullptr);
            mExecutionContext->onWorkFinished();
        }
 
    public:
        [[nodiscard]] friend bool operator==(const Executor& lhs, const Executor& rhs) noexcept {
            return lhs.mExecutionContext == rhs.mExecutionContext && lhs.mBlockingProperty == rhs.mBlockingProperty;
        }
 
        [[nodiscard]] friend bool operator!=(const Executor& lhs, const Executor& rhs) noexcept { return !(lhs == rhs); }
 
    private:
        friend struct asio_query_fn::impl;
        friend struct asio::execution::detail::context_t<0>;
        friend struct asio::execution::detail::mapping_t<0>;
        friend struct asio::execution::detail::blocking_t<0>;
        friend struct asio::execution::detail::relationship_t<0>;
        friend struct asio::execution::detail::outstanding_work_t<0>;
        friend struct asio::execution::detail::bulk_guarantee_t<0>;
        friend struct asio::execution::detail::occupancy_t<0>;
 
        [[nodiscard]] AppleDispatchQueue& query(ExecutorExecutionContext) const noexcept { return context(); }
 
        [[nodiscard]] static constexpr ExecutorMapping query(ExecutorMapping) noexcept { return ExecutorMapping::other; }
 
        [[nodiscard]] ExecutorBlocking query(ExecutorBlocking) const noexcept { return mBlockingProperty; }
 
        [[nodiscard]] ExecutorPriority query(ExecutorPriority) const noexcept { return mPriority; }
 
        [[nodiscard]] static constexpr ExecutorRelationship query(ExecutorRelationship) noexcept { return ExecutorRelationship::continuation; }
 
        [[nodiscard]] static constexpr ExecutorOutstandingWork query(ExecutorOutstandingWork) noexcept { return ExecutorOutstandingWork::tracked; }
 
        [[nodiscard]] static constexpr ExecutorBulkGuarantee query(ExecutorBulkGuarantee) noexcept { return ExecutorBulkGuarantee::sequenced; }
 
        [[nodiscard]] std::size_t query(ExecutorOccupancy) const noexcept {
            CE_ASSERT(mExecutionContext != nullptr);
            switch(mExecutionContext->mType) {
            case DispatchQueueType::Serial: return 1;
            default: return std::thread::hardware_concurrency();
            }
        }
 
        template<typename OtherAllocator> [[nodiscard]] std::allocator<void> query(ExecutorAllocator<OtherAllocator>) const noexcept {
            static std::allocator<void> allocator;
            return allocator;
        }
 
        [[nodiscard]] std::allocator<void> query(ExecutorAllocator<void>) const noexcept {
            static std::allocator<void> allocator;
            return allocator;
        }
 
    private: // Prefer
        friend struct asio_require_fn::impl;
        friend struct asio_prefer_fn::impl;
 
        [[nodiscard]] Executor require(ExecutorBlocking blocking) const { return Executor(*mExecutionContext, blocking, mPriority); }
 
        [[nodiscard]] Executor require(ExecutorPriority newPriority) const { return Executor(*mExecutionContext, mBlockingProperty, newPriority); }
 
    private:
        friend struct asio_execution_execute_fn::impl;
 
        template<typename Function> void execute(ASIO_MOVE_ARG(Function) f) const {
            CE_ASSERT(mExecutionContext != nullptr);
            mExecutionContext->schedule(std::move(f), mBlockingProperty, mPriority);
        }
    };
 
    inline AnyExecutor AppleDispatchQueue::getExecutor() noexcept { return get_executor(); }
    inline AppleDispatchQueue::Executor AppleDispatchQueue::get_executor() noexcept { return Executor(*this); }
 
} // namespace CeresEngine