✨ windows_code_page encoding type is now live

Author: ThePhD

CMakeLists.txt

@@ -141,12 +141,12 @@ FetchContent_Declare(ztd.idk
 	GIT_TAG        main)
 FetchContent_MakeAvailable(ztd.idk)
 
-# ztd.static_containers
-FetchContent_Declare(ztd.static_containers
-	GIT_REPOSITORY https://github.com/soasis/static_containers.git
+# ztd.inline_containers
+FetchContent_Declare(ztd.inline_containers
+	GIT_REPOSITORY https://github.com/soasis/inline_containers.git
 	GIT_SHALLOW    ON
 	GIT_TAG        main)
-FetchContent_MakeAvailable(ztd.static_containers)
+FetchContent_MakeAvailable(ztd.inline_containers)
 
 # ztd.encoding_tables
 FetchContent_Declare(ztd.encoding_tables
@@ -187,7 +187,7 @@ target_sources(ztd.text INTERFACE ${ztd.text.includes})
 target_link_libraries(ztd.text
 	INTERFACE
 	ztd::idk
-	ztd::static_containers
+	ztd::inline_containers
 	ztd::platform
 	ztd::cuneicode)
 target_compile_definitions(ztd.idk

CMakePresets.json

@@ -116,7 +116,7 @@
 				"ZTD_TEXT_BENCHMARKS_REPETITIONS": "2",
 				"FETCHCONTENT_SOURCE_DIR_ZTD.CMAKE": "${sourceDir}/../cmake",
 				"FETCHCONTENT_SOURCE_DIR_ZTD.IDK": "${sourceDir}/../idk",
-				"FETCHCONTENT_SOURCE_DIR_ZTD.STATIC_CONTAINERS": "${sourceDir}/../static_containers",
+				"FETCHCONTENT_SOURCE_DIR_ZTD.INLINE_CONTAINERS": "${sourceDir}/../inline_containers",
 				"FETCHCONTENT_SOURCE_DIR_ZTD.CUNEICODE": "${sourceDir}/../cuneicode",
 				"FETCHCONTENT_SOURCE_DIR_ZTD.ENCODING_TABLES": "${sourceDir}/../encoding_tables",
 				"FETCHCONTENT_SOURCE_DIR_ZTD.PLATFORM": "${sourceDir}/../platform",

documentation/source/api/encodings/any_encoding.rst

@@ -28,8 +28,8 @@
 ..
 .. =============================================================================>
 
-any_encoding
-============
+``any_encoding`` omni-encoding type
+===================================
 
 ``any_encoding`` is a class type whose sole purpose is to provide a type-generic, byte-based, runtime-deferred way of handling encodings.
 
@@ -40,14 +40,19 @@ Aliases
 
 .. doxygentypedef:: ztd::text::any_encoding
 
+.. doxygentypedef:: ztd::text::any_encoding_of
+
 .. doxygentypedef:: ztd::text::compat_any_encoding
 
 .. doxygentypedef:: ztd::text::ucompat_any_encoding
 
 
 
-Base Template
--------------
+Base
+----
+
+This is based off of :cpp:class:`ztd::text::any_encoding_with`; the only thing special about it is the constructor logic on top of :cpp:class:`ztd::text::any_encoding_with`.
 
 .. doxygenclass:: ztd::text::any_byte_encoding
-	:members:
+	:members: any_byte_encoding, operator=
+	

documentation/source/api/encodings/any_encoding_with.rst

@@ -28,13 +28,11 @@
 ..
 .. =============================================================================>
 
-any_encoding_with
-=================
+``any_encoding_with`` omni-encoding base type
+=============================================
 
 This is the lowest level base template, ``any_encoding_with``, that sits beneath :doc:`any_encoding and any_byte_encoding </api/encodings/any_encoding>`. It is recommended for power users with specific goals for the input and output types of the encode and decode operations, where normal buffer-based I/O is unsuitable. In general, you should be relying on :doc:`any_encoding and any_byte_encoding </api/encodings/any_encoding>`.
 
-
-
 Base Template
 -------------
 

documentation/source/api/encodings/windows_code_page.rst

@@ -0,0 +1,58 @@
+.. =============================================================================
+..
+.. ztd.text
+.. Copyright © JeanHeyd "ThePhD" Meneide and Shepherd's Oasis, LLC
+.. Contact: [email protected]
+..
+.. Commercial License Usage
+.. Licensees holding valid commercial ztd.text licenses may use this file in
+.. accordance with the commercial license agreement provided with the
+.. Software or, alternatively, in accordance with the terms contained in
+.. a written agreement between you and Shepherd's Oasis, LLC.
+.. For licensing terms and conditions see your agreement. For
+.. further information contact [email protected].
+..
+.. Apache License Version 2 Usage
+.. Alternatively, this file may be used under the terms of Apache License
+.. Version 2.0 (the "License") for non-commercial use; you may not use this
+.. file except in compliance with the License. You may obtain a copy of the
+.. License at
+..
+.. https://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.
+..
+.. =============================================================================>
+
+Windows Code Page
+=================
+
+``WideCharToMultiByte`` and ``MultiByteToWideChar`` on Windows platforms has a multitude of encodings with a particular set of quirks. Therefore, on Windows platforms, it may be advantageous to use this over the regular :cpp:class:`execution_encoding_t` type or :cpp:var:`execution_encoding` object. The constructor takes a raw ``int32_t`` whose sole purpose is to be one of the known `Code Page Identifiers`_ that Microsoft supplies on its platforms.
+
+.. warning::
+
+	This type is inefficient due to the poor design of the ``WideCharToMultiByte``/``MultiByteToWideChar`` functions. While this will allow users to achieve parity, if the user knows their encoding ahead of time and can provide either their own encoding object or :doc:`/api//encodings <one of the encoding types provided by this library>`, it is highly preferred over this methodology.
+
+.. warning::
+
+	For certain distributions, specific language packs may need to be installed in order to use certain conversions tied to specific `Code Page Identifiers`_.
+
+Alias
+-----
+
+.. doxygentypedef:: ztd::text::windows_code_page
+
+
+
+Base Templates
+--------------
+
+.. doxygenclass:: ztd::text::basic_windows_code_page
+	:members:
+
+
+.. _Code Page Identifiers: https://learn.microsoft.com/en-us/windows/win32/intl/code-page-identifiers

documentation/source/encodings.rst

@@ -103,6 +103,10 @@ As a general point, we hope to support almost all of the encodings here in one f
 	  - Yes
 	  - Yes
 	  - :doc:`Yes ✅ </api/encodings/cuneicode_registry_encoding>`
+	* - Windows Code Page Encoding
+	  - Yes
+	  - Yes
+	  - :doc:`Yes ✅ </api/encodings/windows_code_page>`
 	* - ARMSCII-8
 	  - ❓ Unresearched
 	  - ❓ Unconfirmed

include/ztd/text/any_encoding_with.hpp

@@ -510,13 +510,13 @@ namespace ztd { namespace text {
 					constexpr ::std::size_t __code_point_max = max_code_points_v<_Encoding>;
 					using _CodeUnit                          = code_unit_t<_Encoding>;
 					using _CodePoint                         = code_point_t<_Encoding>;
-					using _Pivot                             = ::ztd::span<_CodePoint, __code_point_max>;
+					using _Pivot                             = ::ztd::span<_CodePoint>;
 					constexpr bool _AssumeValid              = false;
 
 					_CodePoint __code_point_buf[__code_point_max] {};
 					_CodeUnit __code_unit_buf[__code_unit_max] {};
-					::ztd::span<_CodeUnit, __code_unit_max> __code_unit_view(__code_unit_buf);
-					_Pivot __pivot(__code_point_buf);
+					::ztd::span<_CodeUnit> __code_unit_view(__code_unit_buf, __code_unit_max);
+					_Pivot __pivot(__code_point_buf, __code_point_max);
 					__txt_detail::__progress_handler<_AssumeValid, _Encoding> __pass_handler {};
 					__real_encode_state __encode_state = make_encode_state(__encoding);
 
@@ -558,13 +558,13 @@ namespace ztd { namespace text {
 					constexpr ::std::size_t __code_point_max = max_recode_code_points_v<_Encoding, _Encoding>;
 					using _CodeUnit                          = code_unit_t<_Encoding>;
 					using _CodePoint                         = code_point_t<_Encoding>;
-					using _Pivot                             = ::ztd::span<_CodeUnit, __code_unit_max>;
+					using _Pivot                             = ::ztd::span<_CodeUnit>;
 					constexpr bool _AssumeValid              = false;
 
 					_CodePoint __code_point_buf[__code_point_max] {};
 					_CodeUnit __code_unit_buf[__code_unit_max] {};
-					::ztd::span<_CodePoint, __code_point_max> __code_point_view(__code_point_buf);
-					_Pivot __pivot(__code_unit_buf);
+					::ztd::span<_CodePoint> __code_point_view(__code_point_buf, __code_point_max);
+					_Pivot __pivot(__code_unit_buf, __code_unit_max);
 
 					__txt_detail::__progress_handler<_AssumeValid, _Encoding> __pass_handler {};
 					__real_decode_state __decode_state = make_decode_state(__encoding);
@@ -619,12 +619,12 @@ namespace ztd { namespace text {
 							             __raw_result.error_code, __raw_result.error_count),
 							        __pass_handler._M_code_units_progress(), __pass_handler._M_code_points_progress());
 						::std::size_t __used_size = static_cast<::std::size_t>(
-							::ztd::ranges::distance(__code_point_view.begin(), __err_result.output.begin()));
+							::ztd::ranges::distance(__code_point_view.data(), __err_result.output.data()));
 						return __count_as_decoded_result(__err_result.input, __used_size, __state,
 							__err_result.error_code, __err_result.error_count);
 					}
 					::std::size_t __used_size = static_cast<::std::size_t>(
-						::ztd::ranges::distance(__code_point_view.begin(), __raw_result.output.begin()));
+						::ztd::ranges::distance(__code_point_view.data(), __raw_result.output.data()));
 					return __count_as_decoded_result(::std::move(__raw_result.input), __used_size, __state,
 						__raw_result.error_code, __raw_result.error_count);
 				}
@@ -656,7 +656,7 @@ namespace ztd { namespace text {
 					constexpr bool _AssumeValid             = is_ignorable_error_handler_v<__encode_error_handler>;
 
 					_CodeUnit __code_unit_buf[__code_unit_max] {};
-					::ztd::span<_CodeUnit, __code_unit_max> __code_unit_view(__code_unit_buf);
+					::ztd::span<_CodeUnit> __code_unit_view(__code_unit_buf, __code_unit_max);
 					__txt_detail::__progress_handler<_AssumeValid, _Encoding> __pass_handler {};
 
 					auto __raw_result = encode_one_into_raw(::std::move(__input), __encoding, __code_unit_view,

include/ztd/text/basic_encoding_scheme.hpp

@@ -326,19 +326,18 @@ namespace ztd { namespace text {
 		template <typename _Input, typename _Output, typename _ErrorHandler>
 		constexpr auto decode_one(
 			_Input&& __input, _Output&& __output, _ErrorHandler&& __error_handler, decode_state& __s) const {
-			using _UInputRange    = remove_cvref_t<_Input>;
 			using _UOutputRange   = remove_cvref_t<_Output>;
 			using _CVErrorHandler = ::std::remove_reference_t<_ErrorHandler>;
 			using _SubInput       = ztd::ranges::subrange_for_t<::std::remove_reference_t<_Input>>;
 			using _SubOutput      = ztd::ranges::subrange_for_t<::std::remove_reference_t<_Output>>;
 			using _Result         = decode_result<_SubInput, _SubOutput, decode_state>;
 
-			using _InByteIt  = ranges::word_iterator<_BaseCodeUnit, _UInputRange, _Endian>;
+			using _InByteIt  = ranges::word_iterator<_BaseCodeUnit, _SubInput, _Endian>;
 			using _InByteSen = ranges::word_sentinel;
 			::ztd::ranges::subrange<_InByteIt, _InByteSen> __inbytes(
 				_InByteIt(::std::in_place, ::std::forward<_Input>(__input)), _InByteSen());
-			__txt_detail::__scheme_handler<_Byte, _UInputRange, _UOutputRange, _CVErrorHandler>
-				__intermediate_handler(__error_handler);
+			__txt_detail::__scheme_handler<_Byte, _SubInput, _UOutputRange, _CVErrorHandler> __intermediate_handler(
+				__error_handler);
 			auto __result = this->base().decode_one(
 				::std::move(__inbytes), ::std::forward<_Output>(__output), __intermediate_handler, __s);
 			return _Result(::std::move(__result.input).begin().range(), ::std::move(__result.output), __s,
@@ -365,23 +364,23 @@ namespace ztd { namespace text {
 		template <typename _Input, typename _Output, typename _ErrorHandler>
 		constexpr auto encode_one(
 			_Input&& __input, _Output&& __output, _ErrorHandler&& __error_handler, encode_state& __s) const {
-			using _UInputRange    = remove_cvref_t<_Input>;
-			using _UOutputRange   = remove_cvref_t<_Output>;
-			using _CVErrorHandler = ::std::remove_reference_t<_ErrorHandler>;
-			using _SubInput       = ztd::ranges::subrange_for_t<::std::remove_reference_t<_Input>>;
+			using _SubInput       = ztd::ranges::csubrange_for_t<::std::remove_reference_t<_Input>>;
 			using _SubOutput      = ztd::ranges::subrange_for_t<::std::remove_reference_t<_Output>>;
-			using _Result         = encode_result<_SubInput, _SubOutput, encode_state>;
-			using _OutByteIt      = ranges::word_iterator<_BaseCodeUnit, _UOutputRange, _Endian>;
+			using _OutByteIt      = ranges::word_iterator<_BaseCodeUnit, _SubOutput, _Endian>;
 			using _OutByteSen     = ranges::word_sentinel;
+			using _CVErrorHandler = ::std::remove_reference_t<_ErrorHandler>;
+			using _Result         = encode_result<_SubInput, _SubOutput, encode_state>;
 
+			_SubOutput __outwords_output(::std::forward<_Output>(__output));
 			ranges::subrange<_OutByteIt, _OutByteSen> __outwords(
-				_OutByteIt(::std::forward<_Output>(__output)), _OutByteSen());
-			__txt_detail::__scheme_handler<_Byte, _UInputRange, _UOutputRange, _CVErrorHandler>
-				__intermediate_handler(__error_handler);
+				_OutByteIt(::std::move(__outwords_output)), _OutByteSen());
+			__txt_detail::__scheme_handler<_Byte, _SubInput, _SubOutput, _CVErrorHandler> __intermediate_handler(
+				__error_handler);
 			auto __result
 				= this->base().encode_one(::std::forward<_Input>(__input), __outwords, __intermediate_handler, __s);
-			return _Result(::std::move(__result.input), ::std::move(__result.output).begin().range(), __s,
-				__result.error_code, __result.error_count);
+			_SubOutput __result_output(::std::move(__result.output).begin().range());
+			return _Result(::std::move(__result.input), ::std::move(__result_output), __s, __result.error_code,
+				__result.error_count);
 		}
 	};
 

include/ztd/text/decode_one.hpp

@@ -53,7 +53,7 @@
 #include <ztd/idk/type_traits.hpp>
 #include <ztd/idk/char_traits.hpp>
 #include <ztd/idk/tag.hpp>
-#include <ztd/static_containers.hpp>
+#include <ztd/inline_containers.hpp>
 
 #include <ztd/prologue.hpp>
 
@@ -396,14 +396,14 @@ namespace ztd { namespace text {
 		constexpr ::std::size_t __max_units = max_decode_code_points_v<_UEncoding>;
 		if constexpr (_IsVoidContainer && _IsStringable) {
 			// prevent instantiation errors with basic_string by boxing it inside of an "if constexpr"
-			using _RealOutputContainer = ::ztd::static_basic_string<_OutputCodePoint, __max_units>;
+			using _RealOutputContainer = ::ztd::inline_basic_string<_OutputCodePoint, __max_units>;
 			return __txt_detail::__decode_one_dispatch<false, false, _RealOutputContainer>(
 				::std::forward<_Input>(__input), ::std::forward<_Encoding>(__encoding),
 				::std::forward<_ErrorHandler>(__error_handler), __state);
 		}
 		else {
 			using _RealOutputContainer = ::std::conditional_t<_IsVoidContainer,
-				::ztd::static_vector<_OutputCodePoint, __max_units>, _OutputContainer>;
+				::ztd::inline_vector<_OutputCodePoint, __max_units>, _OutputContainer>;
 			return __txt_detail::__decode_one_dispatch<false, false, _RealOutputContainer>(
 				::std::forward<_Input>(__input), ::std::forward<_Encoding>(__encoding),
 				::std::forward<_ErrorHandler>(__error_handler), __state);
@@ -520,14 +520,14 @@ namespace ztd { namespace text {
 			= (is_char_traitable_v<_OutputCodePoint> || is_unicode_code_point_v<_OutputCodePoint>);
 
 		if constexpr (_IsVoidContainer && _IsStringable) {
-			using _RealOutputContainer = ::ztd::static_basic_string<_OutputCodePoint, __max_units>;
+			using _RealOutputContainer = ::ztd::inline_basic_string<_OutputCodePoint, __max_units>;
 			return __txt_detail::__decode_one_dispatch<true, false, _RealOutputContainer>(
 				::std::forward<_Input>(__input), ::std::forward<_Encoding>(__encoding),
 				::std::forward<_ErrorHandler>(__error_handler), __state);
 		}
 		else {
 			using _RealOutputContainer = ::std::conditional_t<_IsVoidContainer,
-				::ztd::static_vector<_OutputCodePoint, max_code_points_v<_UEncoding>>, _OutputContainer>;
+				::ztd::inline_vector<_OutputCodePoint, max_code_points_v<_UEncoding>>, _OutputContainer>;
 			return __txt_detail::__decode_one_dispatch<true, false, _RealOutputContainer>(
 				::std::forward<_Input>(__input), ::std::forward<_Encoding>(__encoding),
 				::std::forward<_ErrorHandler>(__error_handler), __state);

include/ztd/text/default_handler.hpp

@@ -51,16 +51,9 @@ namespace ztd { namespace text {
 	//////
 	/// @brief The default error handler for the entire library. Can be configured to use different strategies at build
 	/// time. Without configuration, it defaults to the ztd::text::replacement_handler_t.
-	class default_handler_t
-#if ZTD_IS_ON(ZTD_TEXT_DEFAULT_HANDLER_THROWS)
-	: private throw_handler_t {
+	class default_handler_t : private replacement_handler_t {
 	private:
-		using __error_handler_base_t = throw_handler_t;
-#else
-	: private replacement_handler_t {
-	private:
-		using __error_handler_base_t = replacement_handler_t;
-#endif
+		using __error_handler_base_t = __txt_detail::__default_handler_base_t;
 
 	public:
 		//////
@@ -76,6 +69,27 @@ namespace ztd { namespace text {
 	/// @brief An instance of the default_handler_t type for ease of use.
 	inline constexpr default_handler_t default_handler = {};
 
+	//////
+	/// @brief The default error handler for the entire library. Can be configured to use different strategies at build
+	/// time. Without configuration, it defaults to the ztd::text::replacement_handler_t.
+	class unchecked_default_handler_t : private default_handler_t {
+	private:
+		using __error_handler_base_t = default_handler_t;
+
+	public:
+		//////
+		///@brief The underlying error handler type.
+		using error_handler = __error_handler_base_t;
+
+		using __error_handler_base_t::__error_handler_base_t;
+
+		using __error_handler_base_t::operator();
+	};
+
+	//////
+	/// @brief An instance of the default_handler_t type for ease of use.
+	inline constexpr unchecked_default_handler_t unchecked_default_handler = {};
+
 	namespace __txt_detail {
 		template <typename _ErrorHandler>
 		constexpr auto __duplicate_or_be_careless(_ErrorHandler& __original) {