AppleRunLoop.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/IO/RunLoop.hpp"
 
#include <CoreFoundation/CoreFoundation.h>
 
#include <asio/execution.hpp>
 
namespace CeresEngine {
 
    class AppleRunLoop : public RunLoop {
    public:
        class Executor {
            friend class AppleRunLoop;
 
        private:
            AppleRunLoop* mExecutionContext;
 
            ExecutorBlocking mBlockingProperty = ExecutorBlocking::never;
 
        private:
            explicit Executor(AppleRunLoop* const executionContext, ExecutorBlocking blockingProperty = ExecutorBlocking::never)
                    : mExecutionContext(executionContext), mBlockingProperty(blockingProperty) {}
 
        public:
            Executor(const Executor&) = default;
            Executor& operator=(const Executor&) = default;
            Executor(Executor&&) = default;
            Executor& operator=(Executor&&) = default;
 
        public:
            [[nodiscard]] AppleRunLoop& 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&, const Executor&) noexcept { return true; }
 
            [[nodiscard]] friend bool operator!=(const Executor&, const Executor&) noexcept { return false; }
 
        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]] AppleRunLoop& query(ExecutorExecutionContext) const noexcept { return *mExecutionContext; }
 
            [[nodiscard]] static constexpr ExecutorMapping query(ExecutorMapping) noexcept { return ExecutorMapping::other; }
 
            [[nodiscard]] ExecutorBlocking query(ExecutorBlocking) const noexcept { return mBlockingProperty; }
 
            [[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 { return 1; }
 
            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); }
 
        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);
            }
        };
 
    private:
        CFRunLoopRef mRunLoop;
 
        CFRunLoopObserverRef mRunLoopObserver;
 
        Scope mScope;
 
    public:
        explicit AppleRunLoop() noexcept;
 
        explicit AppleRunLoop(CFRunLoopRef runLoop) noexcept;
 
        ~AppleRunLoop() noexcept override;
 
    public:
        [[nodiscard]] AnyExecutor getExecutor() noexcept final;
 
        void stop() final;
 
        void run() final;
 
        [[nodiscard]] CFRunLoopRef getRunLoop() const noexcept { return mRunLoop; }
 
    private: // Executor interface
        void onWorkStarted() noexcept;
 
        void onWorkFinished() noexcept;
 
        void schedule(UniqueFunction<void()> function, ExecutorBlocking blockingProperty);
 
    public: // ASIO ExecutionContext concept
        using executor_type = Executor;
 
        [[nodiscard]] executor_type get_executor() noexcept { return Executor(this); }
    };
 
} // namespace CeresEngine