include/sequence.hpp - main - Ant010ff/ffpp

include/sequence.hpp
118 строк4 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_SEQUENCE_HPP
#define FFPP_SEQUENCE_HPP

namespace FFPP::Concepts {

	template<typename Type>
	concept SequencePolicy =
		ResourcePolicy<typename Type::ResourcePolicyT> 
		&& ConstexprInvocableStrict<Type::SequenceGranularity, size_t>
	;

}//FFPP::Concepts

namespace FFPP {

	////SequencePolicy////////////////////////////////////////////////////////////////////////////////////////////////////////////

	struct SequencePolicy { 
		using ResourcePolicyT = DefaultResourcePolicy;
		static constexpr size_t SequenceGranularity() { return 2; }
	};

	////Sequence//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	template<std::movable TValue, Concepts::SequencePolicy TPolicy = SequencePolicy>
	class Sequence {
	public:
		using ValueT = TValue;
		using PolicyT = TPolicy;
		using ResourcePolicyT = TPolicy::ResourcePolicyT;
		template<typename Type> 
		using AllocatorT = ResourcePolicyT::template AllocatorT<Type>;
		
		Sequence() { vData_.reserve(c_nPreallocation_); }

		Sequence(Sequence const&) = delete;
		
		Sequence(Sequence&& that) 
		: vData_(std::move(that.vData_))
		{ }

		Sequence& operator = (Sequence const&) = delete;
		
		Sequence& operator = (Sequence&& that) {
			vData_ = std::move(that.vData_);
			return *this;
		}

		bool Append(ValueT&& vAppend) {
			size_t const nCapacity = vData_.capacity(), nSize = vData_.size();
			if(nCapacity < nSize + c_nGranularity_) vData_.reserve(nCapacity + c_nGranularity_);
			vData_.push_back(std::move(vAppend));
			return true;
		}

		bool Prepend(ValueT&& vPrepend) {
			size_t const nCapacity = vData_.capacity(), nSize = vData_.size();
			if(nCapacity < nSize + c_nGranularity_) vData_.reserve(nCapacity + c_nGranularity_);
			vData_.insert(vData_.begin(), std::move(vPrepend));
			return true;
		}

		template<bool t_bCheckBounds = false>
		auto Visit(size_t i, auto&& onVisit, auto&&... args) 
		requires std::invocable<decltype(onVisit), ValueT&, decltype(args)...>
		{
			if constexpr(t_bCheckBounds) return onVisit(vData_.at(i), std::forward<decltype(args)>(args)...);
			else return onVisit(vData_[i], std::forward<decltype(args)>(args)...);
		}

		template<bool t_bAscend = true>
		void Visit(auto&& onVisit, auto&&... args)
		requires std::invocable<decltype(onVisit), ValueT&, decltype(args)...>
		{
			constexpr bool c_bBreakable = std::is_same_v<std::invoke_result_t<decltype(onVisit), ValueT&, decltype(args)...>, bool>;
			if constexpr(t_bAscend) {
				for(size_t i = 0; i < vData_.size(); ++i) {
					if constexpr(c_bBreakable) { if(!onVisit(vData_[i], std::forward<decltype(args)>(args)...)) break; }
					else { onVisit(vData_[i], std::forward<decltype(args)>(args)...); }
				}
			}
			else {
				for(size_t i = vData_.size(); i-- > 0;) {
					if constexpr(c_bBreakable) { if(!onVisit(vData_[i], std::forward<decltype(args)>(args)...)) break; }
					else { onVisit(vData_[i], std::forward<decltype(args)>(args)...); }
				}
			}
		}

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

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

	private:        
		static constexpr size_t
			c_nGranularity_ = std::max(
				PolicyT::SequenceGranularity(), 
				std::max(ResourcePolicyT::InterferenceSize() / sizeof(ValueT), size_t(1))
			),
			c_nPreallocation_ = c_nGranularity_;

		using VectorT = std::vector<ValueT, AllocatorT<ValueT>>;
		VectorT vData_;
	};//Sequence

}//FFPP

#endif//FFPP_SEQUENCE_HPP