include/finalizer.hpp - main - Ant010ff/ffpp

include/finalizer.hpp
223 строки6 KB
Ant010ff
Version 2.11.3.
08 авг 2026, 16:44
08 авг 2026, 16:44fd187d3
/*
This header is part of a Functional Flow Processing Primitives (FFPP) library, version 2.11.3.

Official repository: https://gitlab.com/ant010ff/ffpp

Licensed under the MIT License <http://opensource.org/licenses/MIT>.
SPDX-License-Identifier: MIT
Copyright (c) 2021 - 2026 Anton Nasonov <ant010fff @ gmail . com>.
*/

#ifndef FFPP_FINALIZER_HPP
#define FFPP_FINALIZER_HPP

namespace FFPP::Concepts {

	template<typename Type>
	concept Finalizer = 
		requires { typename Type::ResourcePolicyT; } && Concepts::ResourcePolicy<typename Type::ResourcePolicyT>
		&& requires { typename Type::FunctionalT; } && std::invocable<typename Type::FunctionalT>
		&& requires(Type& t) {
			t.Finalize();
			t.Clear();
			{ t.Empty() } -> std::same_as<bool>;
			{ t.Size() } -> std::same_as<size_t>;
			{ t = Type { } } -> std::same_as<Type&>;
			{ t += typename Type::FunctionalT { } } -> std::same_as<Type&>;
			{ t |= typename Type::FunctionalT { } } -> std::same_as<Type&>;
			{ t += Type { } } -> std::same_as<Type&>;
			{ t |= Type { } } -> std::same_as<Type&>;
			bool(t);
		}
	;

}//FFPP::Concepts

namespace FFPP {

	template<bool t_bExclusive = false, bool t_bNoExcept = true, Concepts::ResourcePolicy TPolicy = DefaultResourcePolicy>
	class Finalizer {
	public:
		using ResourcePolicyT = TPolicy;
		using FunctionalT = ResourcePolicyT::template FunctionT<void(), false>;

		Finalizer() { }

		template<std::convertible_to<FunctionalT>... TFunctions>
		Finalizer(TFunctions&&... fnFinalizers) 
		: dqFinalizers_({ std::forward<TFunctions>(fnFinalizers)... })
		{ }

		Finalizer(Finalizer&& that) 
		: dqFinalizers_(std::move(that.dqFinalizers_))
		{ }
		
		Finalizer(Finalizer const&) = delete;

		~Finalizer() noexcept(t_bNoExcept) { Finalize(); }

		void Finalize() noexcept(t_bNoExcept) {
			if(!dqFinalizers_.empty()) {
				auto dqFinalizers = std::move(dqFinalizers_);
				for(auto& fnFinalizer : dqFinalizers) std::invoke(std::move(fnFinalizer));
			}
		}

		void Clear() { dqFinalizers_.clear(); }

		bool Empty() const { return dqFinalizers_.empty(); }

		size_t Size() const { return dqFinalizers_.size(); }

		Finalizer& operator = (Finalizer const&) = delete;

		Finalizer& operator = (Finalizer&& that) {
			Finalize();
			dqFinalizers_ = std::move(that.dqFinalizers_);			
			return *this;
		}

		Finalizer& operator += (Finalizer&& that) {
			dqFinalizers_.insert(
				dqFinalizers_.begin(), 
				std::make_move_iterator(that.dqFinalizers_.begin()), 
				std::make_move_iterator(that.dqFinalizers_.end())
			);
			that.dqFinalizers_.clear();			
			return *this;
		}

		Finalizer& operator |= (Finalizer&& that) {
			dqFinalizers_.insert(
				dqFinalizers_.end(), 
				std::make_move_iterator(that.dqFinalizers_.begin()), 
				std::make_move_iterator(that.dqFinalizers_.end())
			);
			that.dqFinalizers_.clear();			
			return *this;
		}

		template<std::convertible_to<FunctionalT> TFunction>
		Finalizer& operator += (TFunction&& fnFinalizer) {
			dqFinalizers_.emplace_front(std::forward<TFunction>(fnFinalizer));
			return *this;
		}

		template<std::convertible_to<FunctionalT> TFunction>
		Finalizer& operator |= (TFunction&& fnFinalizer) {
			dqFinalizers_.emplace_back(std::forward<TFunction>(fnFinalizer));
			return *this;
		}

		operator bool () const { return !Empty(); }

	private:		
		using FinalizersDequeT = std::deque<FunctionalT, typename ResourcePolicyT::template AllocatorT<FunctionalT>>;
		FinalizersDequeT dqFinalizers_;
	};//Finalizer<>

	template<bool t_bNoExcept, Concepts::ResourcePolicy TPolicy>
	class Finalizer<true, t_bNoExcept, TPolicy> {
	public:
		using ResourcePolicyT = TPolicy;
		using FunctionalT = ResourcePolicyT::template FunctionT<void(), false>;

		Finalizer() { }

		template<std::convertible_to<FunctionalT>... TFunctions>
		Finalizer(TFunctions&&... fnFinalizers) 
		: dqFinalizers_({ std::forward<TFunctions>(fnFinalizers)... })
		{ }

		Finalizer(Finalizer&& that) 
		: dqFinalizers_(std::move(that.dqFinalizers_))
		{ }
		
		Finalizer(Finalizer const&) = delete;

		~Finalizer() noexcept(t_bNoExcept) { Finalize(); }

		void Finalize() noexcept(t_bNoExcept) {
			std::unique_lock ul(mtx_);
			if(!dqFinalizers_.empty()) {
				auto dqFinalizers = std::move(dqFinalizers_);
				ul.unlock();
				for(auto& fnFinalizer : dqFinalizers) std::invoke(std::move(fnFinalizer));
			}
		}

		void Clear() { 
			std::lock_guard lg(mtx_);
			dqFinalizers_.clear(); 
		}

		bool Empty() const { 
			std::lock_guard lg(mtx_);
			return dqFinalizers_.empty(); 
		}

		size_t Size() const { 
			std::lock_guard lg(mtx_);
			return dqFinalizers_.size(); 
		}

		Finalizer& operator = (Finalizer const&) = delete;

		Finalizer& operator = (Finalizer&& that) {
			FinalizersDequeT dqFinalizers;
			{
				std::scoped_lock sl(mtx_, that.mtx_);
				if(!dqFinalizers_.empty()) dqFinalizers = std::move(dqFinalizers_);
				dqFinalizers_ = std::move(that.dqFinalizers_);			
			}
			for(auto& fnFinalizer : dqFinalizers) std::invoke(std::move(fnFinalizer));
			return *this;
		}

		Finalizer& operator += (Finalizer&& that) {
			std::scoped_lock sl(mtx_, that.mtx_);
			dqFinalizers_.insert(
				dqFinalizers_.begin(), 
				std::make_move_iterator(that.dqFinalizers_.begin()), 
				std::make_move_iterator(that.dqFinalizers_.end())
			);
			that.dqFinalizers_.clear();			
			return *this;
		}

		Finalizer& operator |= (Finalizer&& that) {
			std::scoped_lock sl(mtx_, that.mtx_);
			dqFinalizers_.insert(
				dqFinalizers_.end(), 
				std::make_move_iterator(that.dqFinalizers_.begin()), 
				std::make_move_iterator(that.dqFinalizers_.end())
			);
			that.dqFinalizers_.clear();			
			return *this;
		}

		template<std::convertible_to<FunctionalT> TFunction>
		Finalizer& operator += (TFunction&& fnFinalizer) {
			std::lock_guard lg(mtx_);
			dqFinalizers_.emplace_front(std::forward<TFunction>(fnFinalizer));
			return *this;
		}

		template<std::convertible_to<FunctionalT> TFunction>
		Finalizer& operator |= (TFunction&& fnFinalizer) {
			std::lock_guard lg(mtx_);
			dqFinalizers_.emplace_back(std::forward<TFunction>(fnFinalizer));
			return *this;
		}

		operator bool () const { return !Empty(); }

	private:
		using FinalizersDequeT = std::deque<FunctionalT, typename ResourcePolicyT::template AllocatorT<FunctionalT>>;
		std::mutex mutable mtx_;		
		FinalizersDequeT dqFinalizers_;
	};//Finalizer<true>

}//FFPP

#endif//FFPP_FINALIZER_HPP