libcxx/include/__format/buffer.h - rust-lang/llvm-project - Git at Google

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//

 #ifndef _LIBCPP___FORMAT_BUFFER_H
 #define _LIBCPP___FORMAT_BUFFER_H

 #include <__algorithm/copy_n.h>
 #include <__algorithm/max.h>
 #include <__algorithm/min.h>
 #include <__algorithm/unwrap_iter.h>
 #include <__config>
 #include <__format/enable_insertable.h>
 #include <__format/format_to_n_result.h>
 #include <__format/formatter.h> // for __char_type TODO FMT Move the concept?
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/wrap_iter.h>
 #include <__utility/move.h>
 #include <concepts>
 #include <cstddef>
 #include <type_traits>

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

 _LIBCPP_BEGIN_NAMESPACE_STD

 #if _LIBCPP_STD_VER > 17

 namespace __format {

 /// A "buffer" that handles writing to the proper iterator.
 ///
 /// This helper is used together with the @ref back_insert_iterator to offer
 /// type-erasure for the formatting functions. This reduces the number to
 /// template instantiations.
 template <__formatter::__char_type _CharT>
 class _LIBCPP_TEMPLATE_VIS __output_buffer {
 public:
   using value_type = _CharT;

   template <class _Tp>
   _LIBCPP_HIDE_FROM_ABI explicit __output_buffer(_CharT* __ptr,
                                                  size_t __capacity, _Tp* __obj)
       : __ptr_(__ptr), __capacity_(__capacity),
         __flush_([](_CharT* __p, size_t __size, void* __o) {
           static_cast<_Tp*>(__o)->flush(__p, __size);
         }),
         __obj_(__obj) {}

   _LIBCPP_HIDE_FROM_ABI void reset(_CharT* __ptr, size_t __capacity) {
     __ptr_ = __ptr;
     __capacity_ = __capacity;
   }

   _LIBCPP_HIDE_FROM_ABI auto make_output_iterator() {
     return back_insert_iterator{*this};
   }

   // TODO FMT It would be nice to have an overload taking a
   // basic_string_view<_CharT> and append it directly.
   _LIBCPP_HIDE_FROM_ABI void push_back(_CharT __c) {
     __ptr_[__size_++] = __c;

     // Profiling showed flushing after adding is more efficient than flushing
     // when entering the function.
     if (__size_ == __capacity_)
       flush();
   }

   _LIBCPP_HIDE_FROM_ABI void flush() {
     __flush_(__ptr_, __size_, __obj_);
     __size_ = 0;
   }

 private:
   _CharT* __ptr_;
   size_t __capacity_;
   size_t __size_{0};
   void (*__flush_)(_CharT*, size_t, void*);
   void* __obj_;
 };

 /// A storage using an internal buffer.
 ///
 /// This storage is used when writing a single element to the output iterator
 /// is expensive.
 template <__formatter::__char_type _CharT>
 class _LIBCPP_TEMPLATE_VIS __internal_storage {
 public:
   _LIBCPP_HIDE_FROM_ABI _CharT* begin() { return __buffer_; }

   static constexpr size_t __buffer_size = 256 / sizeof(_CharT);

 private:
   _CharT __buffer_[__buffer_size];
 };

 /// A storage writing directly to the storage.
 ///
 /// This requires the storage to be a contiguous buffer of \a _CharT.
 /// Since the output is directly written to the underlying storage this class
 /// is just an empty class.
 template <__formatter::__char_type _CharT>
 class _LIBCPP_TEMPLATE_VIS __direct_storage {};

 template <class _OutIt, class _CharT>
 concept __enable_direct_output = __formatter::__char_type<_CharT> &&
     (same_as<_OutIt, _CharT*>
 #ifndef _LIBCPP_ENABLE_DEBUG_MODE
      || same_as<_OutIt, __wrap_iter<_CharT*>>
 #endif
     );

 /// Write policy for directly writing to the underlying output.
 template <class _OutIt, __formatter::__char_type _CharT>
 class _LIBCPP_TEMPLATE_VIS __writer_direct {
 public:
   _LIBCPP_HIDE_FROM_ABI explicit __writer_direct(_OutIt __out_it)
       : __out_it_(__out_it) {}

   _LIBCPP_HIDE_FROM_ABI auto out() { return __out_it_; }

   _LIBCPP_HIDE_FROM_ABI void flush(_CharT*, size_t __size) {
     // _OutIt can be a __wrap_iter<CharT*>. Therefore the original iterator
     // is adjusted.
     __out_it_ += __size;
   }

 private:
   _OutIt __out_it_;
 };

 /// Write policy for copying the buffer to the output.
 template <class _OutIt, __formatter::__char_type _CharT>
 class _LIBCPP_TEMPLATE_VIS __writer_iterator {
 public:
   _LIBCPP_HIDE_FROM_ABI explicit __writer_iterator(_OutIt __out_it)
       : __out_it_{_VSTD::move(__out_it)} {}

   _LIBCPP_HIDE_FROM_ABI auto out() { return __out_it_; }

   _LIBCPP_HIDE_FROM_ABI void flush(_CharT* __ptr, size_t __size) {
     __out_it_ = _VSTD::copy_n(__ptr, __size, _VSTD::move(__out_it_));
   }

 private:
   _OutIt __out_it_;
 };

 /// Concept to see whether a \a _Container is insertable.
 ///
 /// The concept is used to validate whether multiple calls to a
 /// \ref back_insert_iterator can be replace by a call to \c _Container::insert.
 ///
 /// \note a \a _Container needs to opt-in to the concept by specializing
 /// \ref __enable_insertable.
 template <class _Container>
 concept __insertable =
     __enable_insertable<_Container> && __formatter::__char_type<typename _Container::value_type> &&
     requires(_Container& __t, add_pointer_t<typename _Container::value_type> __first,
              add_pointer_t<typename _Container::value_type> __last) { __t.insert(__t.end(), __first, __last); };

 /// Extract the container type of a \ref back_insert_iterator.
 template <class _It>
 struct _LIBCPP_TEMPLATE_VIS __back_insert_iterator_container {
   using type = void;
 };

 template <__insertable _Container>
 struct _LIBCPP_TEMPLATE_VIS __back_insert_iterator_container<back_insert_iterator<_Container>> {
   using type = _Container;
 };

 /// Write policy for inserting the buffer in a container.
 template <class _Container>
 class _LIBCPP_TEMPLATE_VIS __writer_container {
 public:
   using _CharT = typename _Container::value_type;

   _LIBCPP_HIDE_FROM_ABI explicit __writer_container(back_insert_iterator<_Container> __out_it)
       : __container_{__out_it.__get_container()} {}

   _LIBCPP_HIDE_FROM_ABI auto out() { return back_inserter(*__container_); }

   _LIBCPP_HIDE_FROM_ABI void flush(_CharT* __ptr, size_t __size) {
     __container_->insert(__container_->end(), __ptr, __ptr + __size);
   }

 private:
   _Container* __container_;
 };

 /// Selects the type of the writer used for the output iterator.
 template <class _OutIt, class _CharT>
 class _LIBCPP_TEMPLATE_VIS __writer_selector {
   using _Container = typename __back_insert_iterator_container<_OutIt>::type;

 public:
   using type = conditional_t<!same_as<_Container, void>, __writer_container<_Container>,
                              conditional_t<__enable_direct_output<_OutIt, _CharT>, __writer_direct<_OutIt, _CharT>,
                                            __writer_iterator<_OutIt, _CharT>>>;
 };

 /// The generic formatting buffer.
 template <class _OutIt, __formatter::__char_type _CharT>
 requires(output_iterator<_OutIt, const _CharT&>) class _LIBCPP_TEMPLATE_VIS
     __format_buffer {
   using _Storage =
       conditional_t<__enable_direct_output<_OutIt, _CharT>,
                     __direct_storage<_CharT>, __internal_storage<_CharT>>;

 public:
   _LIBCPP_HIDE_FROM_ABI explicit __format_buffer(_OutIt __out_it)
     requires(same_as<_Storage, __internal_storage<_CharT>>)
   : __output_(__storage_.begin(), __storage_.__buffer_size, this), __writer_(_VSTD::move(__out_it)) {}

   _LIBCPP_HIDE_FROM_ABI explicit __format_buffer(_OutIt __out_it) requires(
       same_as<_Storage, __direct_storage<_CharT>>)
       : __output_(_VSTD::__unwrap_iter(__out_it), size_t(-1), this),
         __writer_(_VSTD::move(__out_it)) {}

   _LIBCPP_HIDE_FROM_ABI auto make_output_iterator() {
     return __output_.make_output_iterator();
   }

   _LIBCPP_HIDE_FROM_ABI void flush(_CharT* __ptr, size_t __size) {
     __writer_.flush(__ptr, __size);
   }

   _LIBCPP_HIDE_FROM_ABI _OutIt out() && {
     __output_.flush();
     return _VSTD::move(__writer_).out();
   }

 private:
   _LIBCPP_NO_UNIQUE_ADDRESS _Storage __storage_;
   __output_buffer<_CharT> __output_;
   typename __writer_selector<_OutIt, _CharT>::type __writer_;
 };

 /// A buffer that counts the number of insertions.
 ///
 /// Since \ref formatted_size only needs to know the size, the output itself is
 /// discarded.
 template <__formatter::__char_type _CharT>
 class _LIBCPP_TEMPLATE_VIS __formatted_size_buffer {
 public:
   _LIBCPP_HIDE_FROM_ABI auto make_output_iterator() { return __output_.make_output_iterator(); }

   _LIBCPP_HIDE_FROM_ABI void flush(const _CharT*, size_t __size) { __size_ += __size; }

   _LIBCPP_HIDE_FROM_ABI size_t result() && {
     __output_.flush();
     return __size_;
   }

 private:
   __internal_storage<_CharT> __storage_;
   __output_buffer<_CharT> __output_{__storage_.begin(), __storage_.__buffer_size, this};
   size_t __size_{0};
 };

 /// The base of a buffer that counts and limits the number of insertions.
 template <class _OutIt, __formatter::__char_type _CharT, bool>
   requires(output_iterator<_OutIt, const _CharT&>)
 struct _LIBCPP_TEMPLATE_VIS __format_to_n_buffer_base {
   using _Size = iter_difference_t<_OutIt>;

 public:
   _LIBCPP_HIDE_FROM_ABI explicit __format_to_n_buffer_base(_OutIt __out_it, _Size __n)
       : __writer_(_VSTD::move(__out_it)), __n_(_VSTD::max(_Size(0), __n)) {}

   _LIBCPP_HIDE_FROM_ABI void flush(_CharT* __ptr, size_t __size) {
     if (_Size(__size_) <= __n_)
       __writer_.flush(__ptr, _VSTD::min(_Size(__size), __n_ - __size_));
     __size_ += __size;
   }

 protected:
   __internal_storage<_CharT> __storage_;
   __output_buffer<_CharT> __output_{__storage_.begin(), __storage_.__buffer_size, this};
   typename __writer_selector<_OutIt, _CharT>::type __writer_;

   _Size __n_;
   _Size __size_{0};
 };

 /// The base of a buffer that counts and limits the number of insertions.
 ///
 /// This version is used when \c __enable_direct_output<_OutIt, _CharT> == true.
 ///
 /// This class limits the size available the the direct writer so it will not
 /// exceed the maximum number of code units.
 template <class _OutIt, __formatter::__char_type _CharT>
   requires(output_iterator<_OutIt, const _CharT&>)
 class _LIBCPP_TEMPLATE_VIS __format_to_n_buffer_base<_OutIt, _CharT, true> {
   using _Size = iter_difference_t<_OutIt>;

 public:
   _LIBCPP_HIDE_FROM_ABI explicit __format_to_n_buffer_base(_OutIt __out_it, _Size __n)
       : __output_(_VSTD::__unwrap_iter(__out_it), __n, this), __writer_(_VSTD::move(__out_it)) {
     if (__n <= 0) [[unlikely]]
       __output_.reset(__storage_.begin(), __storage_.__buffer_size);
   }

   _LIBCPP_HIDE_FROM_ABI void flush(_CharT* __ptr, size_t __size) {
     // A flush to the direct writer happens in two occasions:
     // - The format function has written the maximum number of allowed code
     //   units. At this point it's no longer valid to write to this writer. So
     //   switch to the internal storage. This internal storage doesn't need to
     //   be written anywhere so the flush for that storage writes no output.
     // - The format_to_n function is finished. In this case there's no need to
     //   switch the buffer, but for simplicity the buffers are still switched.
     // When the __n <= 0 the constructor already switched the buffers.
     if (__size_ == 0 && __ptr != __storage_.begin()) {
       __writer_.flush(__ptr, __size);
       __output_.reset(__storage_.begin(), __storage_.__buffer_size);
     }

     __size_ += __size;
   }

 protected:
   __internal_storage<_CharT> __storage_;
   __output_buffer<_CharT> __output_;
   __writer_direct<_OutIt, _CharT> __writer_;

   _Size __size_{0};
 };

 /// The buffer that counts and limits the number of insertions.
 template <class _OutIt, __formatter::__char_type _CharT>
   requires(output_iterator<_OutIt, const _CharT&>)
 struct _LIBCPP_TEMPLATE_VIS __format_to_n_buffer final
     : public __format_to_n_buffer_base< _OutIt, _CharT, __enable_direct_output<_OutIt, _CharT>> {
   using _Base = __format_to_n_buffer_base<_OutIt, _CharT, __enable_direct_output<_OutIt, _CharT>>;
   using _Size = iter_difference_t<_OutIt>;

 public:
   _LIBCPP_HIDE_FROM_ABI explicit __format_to_n_buffer(_OutIt __out_it, _Size __n) : _Base(_VSTD::move(__out_it), __n) {}
   _LIBCPP_HIDE_FROM_ABI auto make_output_iterator() { return this->__output_.make_output_iterator(); }

   _LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt> result() && {
     this->__output_.flush();
     return {_VSTD::move(this->__writer_).out(), this->__size_};
   }
 };
 } // namespace __format

 #endif //_LIBCPP_STD_VER > 17

 _LIBCPP_END_NAMESPACE_STD

 _LIBCPP_POP_MACROS

 #endif // _LIBCPP___FORMAT_BUFFER_H
	// -- C++ --
	//===----------------------------------------------------------------------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP___FORMAT_BUFFER_H
	#define _LIBCPP___FORMAT_BUFFER_H

	#include <__algorithm/copy_n.h>
	#include <__algorithm/max.h>
	#include <__algorithm/min.h>
	#include <__algorithm/unwrap_iter.h>
	#include <__config>
	#include <__format/enable_insertable.h>
	#include <__format/format_to_n_result.h>
	#include <__format/formatter.h> // for __char_type TODO FMT Move the concept?
	#include <__iterator/back_insert_iterator.h>
	#include <__iterator/concepts.h>
	#include <__iterator/incrementable_traits.h>
	#include <__iterator/iterator_traits.h>
	#include <__iterator/wrap_iter.h>
	#include <__utility/move.h>
	#include <concepts>
	#include <cstddef>
	#include <type_traits>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	# pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>

	_LIBCPP_BEGIN_NAMESPACE_STD

	#if _LIBCPP_STD_VER > 17

	namespace __format {

	/// A "buffer" that handles writing to the proper iterator.
	///
	/// This helper is used together with the @ref back_insert_iterator to offer
	/// type-erasure for the formatting functions. This reduces the number to
	/// template instantiations.
	template <__formatter::__char_type _CharT>
	class _LIBCPP_TEMPLATE_VIS __output_buffer {
	public:
	using value_type = _CharT;

	template <class _Tp>
	_LIBCPP_HIDE_FROM_ABI explicit __output_buffer(_CharT* __ptr,
	size_t __capacity, _Tp* __obj)
	: __ptr_(__ptr), __capacity_(__capacity),
	__flush_([](_CharT* __p, size_t __size, void* __o) {
	static_cast<_Tp*>(__o)->flush(__p, __size);
	}),
	__obj_(__obj) {}

	_LIBCPP_HIDE_FROM_ABI void reset(_CharT* __ptr, size_t __capacity) {
	__ptr_ = __ptr;
	__capacity_ = __capacity;
	}

	_LIBCPP_HIDE_FROM_ABI auto make_output_iterator() {
	return back_insert_iterator{*this};
	}

	// TODO FMT It would be nice to have an overload taking a
	// basic_string_view<_CharT> and append it directly.
	_LIBCPP_HIDE_FROM_ABI void push_back(_CharT __c) {
	__ptr_[__size_++] = __c;

	// Profiling showed flushing after adding is more efficient than flushing
	// when entering the function.
	if (__size_ == __capacity_)
	flush();
	}

	_LIBCPP_HIDE_FROM_ABI void flush() {
	__flush_(__ptr_, __size_, __obj_);
	__size_ = 0;
	}

	private:
	_CharT* __ptr_;
	size_t __capacity_;
	size_t __size_{0};
	void (__flush_)(_CharT, size_t, void*);
	void* __obj_;
	};

	/// A storage using an internal buffer.
	///
	/// This storage is used when writing a single element to the output iterator
	/// is expensive.
	template <__formatter::__char_type _CharT>
	class _LIBCPP_TEMPLATE_VIS __internal_storage {
	public:
	_LIBCPP_HIDE_FROM_ABI _CharT* begin() { return __buffer_; }

	static constexpr size_t __buffer_size = 256 / sizeof(_CharT);

	private:
	_CharT __buffer_[__buffer_size];
	};

	/// A storage writing directly to the storage.
	///
	/// This requires the storage to be a contiguous buffer of \a _CharT.
	/// Since the output is directly written to the underlying storage this class
	/// is just an empty class.
	template <__formatter::__char_type _CharT>
	class _LIBCPP_TEMPLATE_VIS __direct_storage {};

	template <class _OutIt, class _CharT>
	concept __enable_direct_output = __formatter::__char_type<_CharT> &&
	(same_as<_OutIt, _CharT*>
	#ifndef _LIBCPP_ENABLE_DEBUG_MODE
	\|\| same_as<_OutIt, __wrap_iter<_CharT*>>
	#endif
	);

	/// Write policy for directly writing to the underlying output.
	template <class _OutIt, __formatter::__char_type _CharT>
	class _LIBCPP_TEMPLATE_VIS __writer_direct {
	public:
	_LIBCPP_HIDE_FROM_ABI explicit __writer_direct(_OutIt __out_it)
	: __out_it_(__out_it) {}

	_LIBCPP_HIDE_FROM_ABI auto out() { return __out_it_; }

	_LIBCPP_HIDE_FROM_ABI void flush(_CharT*, size_t __size) {
	// _OutIt can be a __wrap_iter<CharT*>. Therefore the original iterator
	// is adjusted.
	__out_it_ += __size;
	}

	private:
	_OutIt __out_it_;
	};

	/// Write policy for copying the buffer to the output.
	template <class _OutIt, __formatter::__char_type _CharT>
	class _LIBCPP_TEMPLATE_VIS __writer_iterator {
	public:
	_LIBCPP_HIDE_FROM_ABI explicit __writer_iterator(_OutIt __out_it)
	: __out_it_{_VSTD::move(__out_it)} {}

	_LIBCPP_HIDE_FROM_ABI auto out() { return __out_it_; }

	_LIBCPP_HIDE_FROM_ABI void flush(_CharT* __ptr, size_t __size) {
	__out_it_ = _VSTD::copy_n(__ptr, __size, _VSTD::move(__out_it_));
	}

	private:
	_OutIt __out_it_;
	};

	/// Concept to see whether a \a _Container is insertable.
	///
	/// The concept is used to validate whether multiple calls to a
	/// \ref back_insert_iterator can be replace by a call to \c _Container::insert.
	///
	/// \note a \a _Container needs to opt-in to the concept by specializing
	/// \ref __enable_insertable.
	template <class _Container>
	concept __insertable =
	__enable_insertable<_Container> && __formatter::__char_type<typename _Container::value_type> &&
	requires(_Container& __t, add_pointer_t<typename _Container::value_type> __first,
	add_pointer_t<typename _Container::value_type> __last) { __t.insert(__t.end(), __first, __last); };

	/// Extract the container type of a \ref back_insert_iterator.
	template <class _It>
	struct _LIBCPP_TEMPLATE_VIS __back_insert_iterator_container {
	using type = void;
	};

	template <__insertable _Container>
	struct _LIBCPP_TEMPLATE_VIS __back_insert_iterator_container<back_insert_iterator<_Container>> {
	using type = _Container;
	};

	/// Write policy for inserting the buffer in a container.
	template <class _Container>
	class _LIBCPP_TEMPLATE_VIS __writer_container {
	public:
	using _CharT = typename _Container::value_type;

	_LIBCPP_HIDE_FROM_ABI explicit __writer_container(back_insert_iterator<_Container> __out_it)
	: __container_{__out_it.__get_container()} {}

	_LIBCPP_HIDE_FROM_ABI auto out() { return back_inserter(*__container_); }

	_LIBCPP_HIDE_FROM_ABI void flush(_CharT* __ptr, size_t __size) {
	__container_->insert(__container_->end(), __ptr, __ptr + __size);
	}

	private:
	_Container* __container_;
	};

	/// Selects the type of the writer used for the output iterator.
	template <class _OutIt, class _CharT>
	class _LIBCPP_TEMPLATE_VIS __writer_selector {
	using _Container = typename __back_insert_iterator_container<_OutIt>::type;

	public:
	using type = conditional_t<!same_as<_Container, void>, __writer_container<_Container>,
	conditional_t<__enable_direct_output<_OutIt, _CharT>, __writer_direct<_OutIt, _CharT>,
	__writer_iterator<_OutIt, _CharT>>>;
	};

	/// The generic formatting buffer.
	template <class _OutIt, __formatter::__char_type _CharT>
	requires(output_iterator<_OutIt, const _CharT&>) class _LIBCPP_TEMPLATE_VIS
	__format_buffer {
	using _Storage =
	conditional_t<__enable_direct_output<_OutIt, _CharT>,
	__direct_storage<_CharT>, __internal_storage<_CharT>>;

	public:
	_LIBCPP_HIDE_FROM_ABI explicit __format_buffer(_OutIt __out_it)
	requires(same_as<_Storage, __internal_storage<_CharT>>)
	: __output_(__storage_.begin(), __storage_.__buffer_size, this), __writer_(_VSTD::move(__out_it)) {}

	_LIBCPP_HIDE_FROM_ABI explicit __format_buffer(_OutIt __out_it) requires(
	same_as<_Storage, __direct_storage<_CharT>>)
	: __output_(_VSTD::__unwrap_iter(__out_it), size_t(-1), this),
	__writer_(_VSTD::move(__out_it)) {}

	_LIBCPP_HIDE_FROM_ABI auto make_output_iterator() {
	return __output_.make_output_iterator();
	}

	_LIBCPP_HIDE_FROM_ABI void flush(_CharT* __ptr, size_t __size) {
	__writer_.flush(__ptr, __size);
	}

	_LIBCPP_HIDE_FROM_ABI _OutIt out() && {
	__output_.flush();
	return _VSTD::move(__writer_).out();
	}

	private:
	_LIBCPP_NO_UNIQUE_ADDRESS _Storage __storage_;
	__output_buffer<_CharT> __output_;
	typename __writer_selector<_OutIt, _CharT>::type __writer_;
	};

	/// A buffer that counts the number of insertions.
	///
	/// Since \ref formatted_size only needs to know the size, the output itself is
	/// discarded.
	template <__formatter::__char_type _CharT>
	class _LIBCPP_TEMPLATE_VIS __formatted_size_buffer {
	public:
	_LIBCPP_HIDE_FROM_ABI auto make_output_iterator() { return __output_.make_output_iterator(); }

	_LIBCPP_HIDE_FROM_ABI void flush(const _CharT*, size_t __size) { __size_ += __size; }

	_LIBCPP_HIDE_FROM_ABI size_t result() && {
	__output_.flush();
	return __size_;
	}

	private:
	__internal_storage<_CharT> __storage_;
	__output_buffer<_CharT> __output_{__storage_.begin(), __storage_.__buffer_size, this};
	size_t __size_{0};
	};

	/// The base of a buffer that counts and limits the number of insertions.
	template <class _OutIt, __formatter::__char_type _CharT, bool>
	requires(output_iterator<_OutIt, const _CharT&>)
	struct _LIBCPP_TEMPLATE_VIS __format_to_n_buffer_base {
	using _Size = iter_difference_t<_OutIt>;

	public:
	_LIBCPP_HIDE_FROM_ABI explicit __format_to_n_buffer_base(_OutIt __out_it, _Size __n)
	: __writer_(_VSTD::move(__out_it)), __n_(_VSTD::max(_Size(0), __n)) {}

	_LIBCPP_HIDE_FROM_ABI void flush(_CharT* __ptr, size_t __size) {
	if (_Size(__size_) <= __n_)
	__writer_.flush(__ptr, _VSTD::min(_Size(__size), __n_ - __size_));
	__size_ += __size;
	}

	protected:
	__internal_storage<_CharT> __storage_;
	__output_buffer<_CharT> __output_{__storage_.begin(), __storage_.__buffer_size, this};
	typename __writer_selector<_OutIt, _CharT>::type __writer_;

	_Size __n_;
	_Size __size_{0};
	};

	/// The base of a buffer that counts and limits the number of insertions.
	///
	/// This version is used when \c __enable_direct_output<_OutIt, _CharT> == true.
	///
	/// This class limits the size available the the direct writer so it will not
	/// exceed the maximum number of code units.
	template <class _OutIt, __formatter::__char_type _CharT>
	requires(output_iterator<_OutIt, const _CharT&>)
	class _LIBCPP_TEMPLATE_VIS __format_to_n_buffer_base<_OutIt, _CharT, true> {
	using _Size = iter_difference_t<_OutIt>;

	public:
	_LIBCPP_HIDE_FROM_ABI explicit __format_to_n_buffer_base(_OutIt __out_it, _Size __n)
	: __output_(_VSTD::__unwrap_iter(__out_it), __n, this), __writer_(_VSTD::move(__out_it)) {
	if (__n <= 0) [[unlikely]]
	__output_.reset(__storage_.begin(), __storage_.__buffer_size);
	}

	_LIBCPP_HIDE_FROM_ABI void flush(_CharT* __ptr, size_t __size) {
	// A flush to the direct writer happens in two occasions:
	// - The format function has written the maximum number of allowed code
	// units. At this point it's no longer valid to write to this writer. So
	// switch to the internal storage. This internal storage doesn't need to
	// be written anywhere so the flush for that storage writes no output.
	// - The format_to_n function is finished. In this case there's no need to
	// switch the buffer, but for simplicity the buffers are still switched.
	// When the __n <= 0 the constructor already switched the buffers.
	if (__size_ == 0 && __ptr != __storage_.begin()) {
	__writer_.flush(__ptr, __size);
	__output_.reset(__storage_.begin(), __storage_.__buffer_size);
	}

	__size_ += __size;
	}

	protected:
	__internal_storage<_CharT> __storage_;
	__output_buffer<_CharT> __output_;
	__writer_direct<_OutIt, _CharT> __writer_;

	_Size __size_{0};
	};

	/// The buffer that counts and limits the number of insertions.
	template <class _OutIt, __formatter::__char_type _CharT>
	requires(output_iterator<_OutIt, const _CharT&>)
	struct _LIBCPP_TEMPLATE_VIS __format_to_n_buffer final
	: public __format_to_n_buffer_base< _OutIt, _CharT, __enable_direct_output<_OutIt, _CharT>> {
	using _Base = __format_to_n_buffer_base<_OutIt, _CharT, __enable_direct_output<_OutIt, _CharT>>;
	using _Size = iter_difference_t<_OutIt>;

	public:
	_LIBCPP_HIDE_FROM_ABI explicit __format_to_n_buffer(_OutIt __out_it, _Size __n) : _Base(_VSTD::move(__out_it), __n) {}
	_LIBCPP_HIDE_FROM_ABI auto make_output_iterator() { return this->__output_.make_output_iterator(); }

	_LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt> result() && {
	this->__output_.flush();
	return {_VSTD::move(this->__writer_).out(), this->__size_};
	}
	};
	} // namespace __format

	#endif //_LIBCPP_STD_VER > 17

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP___FORMAT_BUFFER_H