lidavidm commented on a change in pull request #11084: URL: https://github.com/apache/arrow/pull/11084#discussion_r702892278
########## File path: cpp/src/arrow/util/async_util.h ########## @@ -0,0 +1,132 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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 +// +// http://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 "arrow/result.h" +#include "arrow/status.h" +#include "arrow/util/future.h" +#include "arrow/util/mutex.h" + +namespace arrow { +namespace util { + +/// Custom deleter for AsyncDestroyable objects +template <typename T> +struct DestroyingDeleter { + void operator()(T* p) { p->Destroy(); } +}; + +/// An object which should be asynchronously closed before it is destroyed +/// +/// Classes can extend this to ensure that the close method is called and completed +/// before the instance is deleted. This provides smart_ptr / delete semantics for +/// objects with an asynchronous destructor. +/// +/// Classes which extend this must be constructed using MakeSharedAsync or MakeUniqueAsync +class ARROW_EXPORT AsyncDestroyable { + public: + AsyncDestroyable(); + virtual ~AsyncDestroyable(); + + /// A future which will complete when the AsyncDestroyable has finished and is ready + /// to be deleted. + /// + /// This can be used to ensure all work done by this object has been completed before + /// proceeding. + Future<> on_closed() { return on_closed_; } + + protected: + /// Subclasses should override this and perform any cleanup. Once the future returned + /// by this method finishes then this object is eligible for destruction and any + /// reference to `this` will be invalid + virtual Future<> DoDestroy() = 0; + + private: + void Destroy(); + + Future<> on_closed_; +#ifndef NDEBUG + bool constructed_correctly_ = false; +#endif + + template <typename T> + friend struct DestroyingDeleter; + template <typename T, typename... Args> + friend std::shared_ptr<T> MakeSharedAsync(Args&&... args); + template <typename T, typename... Args> + friend std::unique_ptr<T, DestroyingDeleter<T>> MakeUniqueAsync(Args&&... args); +}; + +template <typename T, typename... Args> +std::shared_ptr<T> MakeSharedAsync(Args&&... args) { + static_assert(std::is_base_of<AsyncDestroyable, T>::value, + "Nursery::MakeSharedCloseable only works with AsyncDestroyable types"); + std::shared_ptr<T> ptr(new T(std::forward<Args&&>(args)...), DestroyingDeleter<T>()); +#ifndef NDEBUG + ptr->constructed_correctly_ = true; +#endif + return ptr; +} + +template <typename T, typename... Args> +std::unique_ptr<T, DestroyingDeleter<T>> MakeUniqueAsync(Args&&... args) { + static_assert(std::is_base_of<AsyncDestroyable, T>::value, + "Nursery::MakeUniqueCloseable only works with AsyncDestroyable types"); + std::unique_ptr<T, DestroyingDeleter<T>> ptr(new T(std::forward<Args>(args)...), + DestroyingDeleter<T>()); +#ifndef NDEBUG + ptr->constructed_correctly_ = true; +#endif + return ptr; +} + +/// A utility which keeps track of a collection of asynchronous tasks +/// +/// This can be used to provide structured concurrency for asynchronous development. +/// A task group created at a high level can be distributed amongst low level components +/// which register work to be completed. The high level job can then wait for all work +/// to be completed before cleaning up. +class AsyncTaskGroup { Review comment: Ah, MSVC isn't happy since this needs ARROW_EXPORT too. -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected]
