#ifndef SIMDUTF_IMPLEMENTATION_H

#define SIMDUTF_IMPLEMENTATION_H

#if !defined(SIMDUTF_NO_THREADS)

  #include <atomic>

#endif

#ifdef SIMDUTF_INTERNAL_TESTS

  #include <vector>

#endif

#include "simdutf/common_defs.h"

#include "simdutf/compiler_check.h"

#include "simdutf/encoding_types.h"

#include "simdutf/error.h"

#include "simdutf/internal/isadetection.h"

#include <string_view>

#if SIMDUTF_SPAN

  #include <concepts>

  #include <type_traits>

  #include <span>

  #include <tuple>

  #include <utility> // for std::unreachable

#endif

// The following defines are conditionally enabled/disabled during amalgamation.

// By default all features are enabled, regular code shouldn't check them. Only

// when user code really relies of a selected subset, it's good to verify these

// flags, like:

//

//      #if !SIMDUTF_FEATURE_UTF16

//      #   error("Please amalgamate simdutf with UTF-16 support")

//      #endif

//

#ifndef SIMDUTF_FEATURE_DETECT_ENCODING

  #define SIMDUTF_FEATURE_DETECT_ENCODING 1

#endif

#ifndef SIMDUTF_FEATURE_ASCII

  #define SIMDUTF_FEATURE_ASCII 1

#endif

#ifndef SIMDUTF_FEATURE_LATIN1

  #define SIMDUTF_FEATURE_LATIN1 1

#endif

#ifndef SIMDUTF_FEATURE_UTF8

  #define SIMDUTF_FEATURE_UTF8 1

#endif

#ifndef SIMDUTF_FEATURE_UTF16

  #define SIMDUTF_FEATURE_UTF16 1

#endif

#ifndef SIMDUTF_FEATURE_UTF32

  #define SIMDUTF_FEATURE_UTF32 1

#endif

#ifndef SIMDUTF_FEATURE_BASE64

  #define SIMDUTF_FEATURE_BASE64 1

#endif

#if SIMDUTF_CPLUSPLUS23

  #include <simdutf/constexpr_ptr.h>

#endif

#if SIMDUTF_SPAN

/// helpers placed in namespace detail are not a part of the public API

namespace simdutf {

namespace detail {

/**

 * matches a byte, in the many ways C++ allows. note that these

 * are all distinct types.

 */

template <typename T>

concept byte_like = std::is_same_v<T, std::byte> ||     //

                    std::is_same_v<T, char> ||          //

                    std::is_same_v<T, signed char> ||   //

                    std::is_same_v<T, unsigned char> || //

                    std::is_same_v<T, char8_t>;

template <typename T>

concept is_byte_like = byte_like<std::remove_cvref_t<T>>;

template <typename T>

concept is_pointer = std::is_pointer_v<T>;

/**

 * matches anything that behaves like std::span and points to character-like

 * data such as: std::byte, char, unsigned char, signed char, std::int8_t,

 * std::uint8_t

 */

template <typename T>

concept input_span_of_byte_like = requires(const T &t) {

  { t.size() } noexcept -> std::convertible_to<std::size_t>;

  { t.data() } noexcept -> is_pointer;

  { *t.data() } noexcept -> is_byte_like;

};

template <typename T>

concept is_mutable = !std::is_const_v<std::remove_reference_t<T>>;

/**

 * like span_of_byte_like, but for an output span (intended to be written to)

 */

template <typename T>

concept output_span_of_byte_like = requires(T &t) {

  { t.size() } noexcept -> std::convertible_to<std::size_t>;

  { t.data() } noexcept -> is_pointer;

  { *t.data() } noexcept -> is_byte_like;

  { *t.data() } noexcept -> is_mutable;

};

/**

 * a pointer like object, when indexed, results in a byte like result.

 * valid examples: char*, const char*, std::array<char,10>

 * invalid examples: int*, std::array<int,10>

 */

template <class InputPtr>

concept indexes_into_byte_like = requires(InputPtr p) {

  { std::decay_t<decltype(p[0])>{} } -> simdutf::detail::byte_like;

};

template <class InputPtr>

concept indexes_into_utf16 = requires(InputPtr p) {

  { std::decay_t<decltype(p[0])>{} } -> std::same_as<char16_t>;

};

template <class InputPtr>

concept indexes_into_utf32 = requires(InputPtr p) {

  { std::decay_t<decltype(p[0])>{} } -> std::same_as<char32_t>;

};

template <class InputPtr>

concept index_assignable_from_char = requires(InputPtr p, char s) {

  { p[0] = s };

};

/**

 * a pointer like object that results in a uint32_t when indexed.

 * valid examples: uint32_t*

 */

template <class InputPtr>

concept indexes_into_uint32 = requires(InputPtr p) {

  { std::decay_t<decltype(p[0])>{} } -> std::same_as<std::uint32_t>;

};

} // namespace detail

} // namespace simdutf

#endif // SIMDUTF_SPAN

// these includes are needed for constexpr support. they are

// not part of the public api.

#include <simdutf/scalar/swap_bytes.h>

#include <simdutf/scalar/ascii.h>

#include <simdutf/scalar/atomic_util.h>

#include <simdutf/scalar/latin1.h>

#include <simdutf/scalar/latin1_to_utf16/latin1_to_utf16.h>

#include <simdutf/scalar/latin1_to_utf32/latin1_to_utf32.h>

#include <simdutf/scalar/latin1_to_utf8/latin1_to_utf8.h>

#include <simdutf/scalar/utf16.h>

#include <simdutf/scalar/utf16_to_latin1/utf16_to_latin1.h>

#include <simdutf/scalar/utf16_to_latin1/valid_utf16_to_latin1.h>

#include <simdutf/scalar/utf16_to_utf32/utf16_to_utf32.h>

#include <simdutf/scalar/utf16_to_utf32/valid_utf16_to_utf32.h>

#include <simdutf/scalar/utf16_to_utf8/utf16_to_utf8.h>

#include <simdutf/scalar/utf16_to_utf8/valid_utf16_to_utf8.h>

#include <simdutf/scalar/utf32.h>

#include <simdutf/scalar/utf32_to_latin1/utf32_to_latin1.h>

#include <simdutf/scalar/utf32_to_latin1/valid_utf32_to_latin1.h>

#include <simdutf/scalar/utf32_to_utf16/utf32_to_utf16.h>

#include <simdutf/scalar/utf32_to_utf16/valid_utf32_to_utf16.h>

#include <simdutf/scalar/utf32_to_utf8/utf32_to_utf8.h>

#include <simdutf/scalar/utf32_to_utf8/valid_utf32_to_utf8.h>

#include <simdutf/scalar/utf8.h>

#include <simdutf/scalar/utf8_to_latin1/utf8_to_latin1.h>

#include <simdutf/scalar/utf8_to_latin1/valid_utf8_to_latin1.h>

#include <simdutf/scalar/utf8_to_utf16/utf8_to_utf16.h>

#include <simdutf/scalar/utf8_to_utf16/valid_utf8_to_utf16.h>

#include <simdutf/scalar/utf8_to_utf32/utf8_to_utf32.h>

#include <simdutf/scalar/utf8_to_utf32/valid_utf8_to_utf32.h>

namespace simdutf {

constexpr size_t default_line_length =

    76; ///< default line length for base64 encoding with lines

#if SIMDUTF_FEATURE_DETECT_ENCODING

/**

 * Autodetect the encoding of the input, a single encoding is recommended.

 * E.g., the function might return simdutf::encoding_type::UTF8,

 * simdutf::encoding_type::UTF16_LE, simdutf::encoding_type::UTF16_BE, or

 * simdutf::encoding_type::UTF32_LE.

 *

 * @param input the string to analyze.

 * @param length the length of the string in bytes.

 * @return the detected encoding type

 */

simdutf_warn_unused simdutf::encoding_type

autodetect_encoding(const char *input, size_t length) noexcept;

simdutf_really_inline simdutf_warn_unused simdutf::encoding_type

autodetect_encoding(const uint8_t *input, size_t length) noexcept {

  return autodetect_encoding(reinterpret_cast<const char *>(input), length);

}

  #if SIMDUTF_SPAN

/**

 * Autodetect the encoding of the input, a single encoding is recommended.

 * E.g., the function might return simdutf::encoding_type::UTF8,

 * simdutf::encoding_type::UTF16_LE, simdutf::encoding_type::UTF16_BE, or

 * simdutf::encoding_type::UTF32_LE.

 *

 * @param input the string to analyze. can be a anything span-like that has a

 * data() and size() that points to character data: std::string,

 * std::string_view, std::vector<char>, std::span<const std::byte> etc.

 * @return the detected encoding type

 */

simdutf_really_inline simdutf_warn_unused simdutf::encoding_type

autodetect_encoding(

    const detail::input_span_of_byte_like auto &input) noexcept {

  return autodetect_encoding(reinterpret_cast<const char *>(input.data()),

                             input.size());

}

  #endif // SIMDUTF_SPAN

/**

 * Autodetect the possible encodings of the input in one pass.

 * E.g., if the input might be UTF-16LE or UTF-8, this function returns

 * the value (simdutf::encoding_type::UTF8 | simdutf::encoding_type::UTF16_LE).

 *

 * Overridden by each implementation.

 *

 * @param input the string to analyze.

 * @param length the length of the string in bytes.

 * @return the detected encoding type

 */

simdutf_warn_unused int detect_encodings(const char *input,

                                         size_t length) noexcept;

simdutf_really_inline simdutf_warn_unused int

detect_encodings(const uint8_t *input, size_t length) noexcept {

  return detect_encodings(reinterpret_cast<const char *>(input), length);

}

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_warn_unused int

detect_encodings(const detail::input_span_of_byte_like auto &input) noexcept {

  return detect_encodings(reinterpret_cast<const char *>(input.data()),

                          input.size());

}

  #endif // SIMDUTF_SPAN

#endif   // SIMDUTF_FEATURE_DETECT_ENCODING

#if SIMDUTF_FEATURE_UTF8 || SIMDUTF_FEATURE_DETECT_ENCODING

/**

 * Validate the UTF-8 string. This function may be best when you expect

 * the input to be almost always valid. Otherwise, consider using

 * validate_utf8_with_errors.

 *

 * Overridden by each implementation.

 *

 * @param buf the UTF-8 string to validate.

 * @param len the length of the string in bytes.

 * @return true if and only if the string is valid UTF-8.

 */

simdutf_warn_unused bool validate_utf8(const char *buf, size_t len) noexcept;

  #if SIMDUTF_SPAN

simdutf_constexpr23 simdutf_really_inline simdutf_warn_unused bool

validate_utf8(const detail::input_span_of_byte_like auto &input) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    return scalar::utf8::validate(

        detail::constexpr_cast_ptr<uint8_t>(input.data()), input.size());

  } else

    #endif

  {

    return validate_utf8(reinterpret_cast<const char *>(input.data()),

                         input.size());

  }

}

  #endif // SIMDUTF_SPAN

#endif   // SIMDUTF_FEATURE_UTF8 || SIMDUTF_FEATURE_DETECT_ENCODING

#if SIMDUTF_FEATURE_UTF8

/**

 * Validate the UTF-8 string and stop on error.

 *

 * Overridden by each implementation.

 *

 * @param buf the UTF-8 string to validate.

 * @param len the length of the string in bytes.

 * @return a result pair struct (of type simdutf::result containing the two

 * fields error and count) with an error code and either position of the error

 * (in the input in code units) if any, or the number of code units validated if

 * successful.

 */

simdutf_warn_unused result validate_utf8_with_errors(const char *buf,

                                                     size_t len) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_constexpr23 simdutf_warn_unused result

validate_utf8_with_errors(

    const detail::input_span_of_byte_like auto &input) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    return scalar::utf8::validate_with_errors(

        detail::constexpr_cast_ptr<uint8_t>(input.data()), input.size());

  } else

    #endif

  {

    return validate_utf8_with_errors(

        reinterpret_cast<const char *>(input.data()), input.size());

  }

}

  #endif // SIMDUTF_SPAN

#endif   // SIMDUTF_FEATURE_UTF8

#if SIMDUTF_FEATURE_ASCII

/**

 * Validate the ASCII string.

 *

 * Overridden by each implementation.

 *

 * @param buf the ASCII string to validate.

 * @param len the length of the string in bytes.

 * @return true if and only if the string is valid ASCII.

 */

simdutf_warn_unused bool validate_ascii(const char *buf, size_t len) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 bool

validate_ascii(const detail::input_span_of_byte_like auto &input) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    return scalar::ascii::validate(

        detail::constexpr_cast_ptr<std::uint8_t>(input.data()), input.size());

  } else

    #endif

  {

    return validate_ascii(reinterpret_cast<const char *>(input.data()),

                          input.size());

  }

}

  #endif // SIMDUTF_SPAN

/**

 * Validate the ASCII string and stop on error. It might be faster than

 * validate_utf8 when an error is expected to occur early.

 *

 * Overridden by each implementation.

 *

 * @param buf the ASCII string to validate.

 * @param len the length of the string in bytes.

 * @return a result pair struct (of type simdutf::result containing the two

 * fields error and count) with an error code and either position of the error

 * (in the input in code units) if any, or the number of code units validated if

 * successful.

 */

simdutf_warn_unused result validate_ascii_with_errors(const char *buf,

                                                      size_t len) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 result

validate_ascii_with_errors(

    const detail::input_span_of_byte_like auto &input) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    return scalar::ascii::validate_with_errors(

        detail::constexpr_cast_ptr<std::uint8_t>(input.data()), input.size());

  } else

    #endif

  {

    return validate_ascii_with_errors(

        reinterpret_cast<const char *>(input.data()), input.size());

  }

}

  #endif // SIMDUTF_SPAN

#endif   // SIMDUTF_FEATURE_ASCII

#if SIMDUTF_FEATURE_UTF16 && SIMDUTF_FEATURE_ASCII

/**

 * Validate the ASCII string as a UTF-16 sequence.

 * An UTF-16 sequence is considered an ASCII sequence

 * if it could be converted to an ASCII string losslessly.

 *

 * Overridden by each implementation.

 *

 * @param buf the UTF-16 string to validate.

 * @param len the length of the string in bytes.

 * @return true if and only if the string is valid ASCII.

 */

simdutf_warn_unused bool validate_utf16_as_ascii(const char16_t *buf,

                                                 size_t len) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 bool

validate_utf16_as_ascii(std::span<const char16_t> input) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    return scalar::utf16::validate_as_ascii<endianness::NATIVE>(input.data(),

                                                                input.size());

  } else

    #endif

  {

    return validate_utf16_as_ascii(input.data(), input.size());

  }

}

  #endif // SIMDUTF_SPAN

/**

 * Validate the ASCII string as a UTF-16BE sequence.

 * An UTF-16 sequence is considered an ASCII sequence

 * if it could be converted to an ASCII string losslessly.

 *

 * Overridden by each implementation.

 *

 * @param buf the UTF-16BE string to validate.

 * @param len the length of the string in bytes.

 * @return true if and only if the string is valid ASCII.

 */

simdutf_warn_unused bool validate_utf16be_as_ascii(const char16_t *buf,

                                                   size_t len) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 bool

validate_utf16be_as_ascii(std::span<const char16_t> input) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    return scalar::utf16::validate_as_ascii<endianness::BIG>(input.data(),

                                                             input.size());

  } else

    #endif

  {

    return validate_utf16be_as_ascii(input.data(), input.size());

  }

}

  #endif // SIMDUTF_SPAN

/**

 * Validate the ASCII string as a UTF-16LE sequence.

 * An UTF-16 sequence is considered an ASCII sequence

 * if it could be converted to an ASCII string losslessly.

 *

 * Overridden by each implementation.

 *

 * @param buf the UTF-16LE string to validate.

 * @param len the length of the string in bytes.

 * @return true if and only if the string is valid ASCII.

 */

simdutf_warn_unused bool validate_utf16le_as_ascii(const char16_t *buf,

                                                   size_t len) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 bool

validate_utf16le_as_ascii(std::span<const char16_t> input) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    return scalar::utf16::validate_as_ascii<endianness::LITTLE>(input.data(),

                                                                input.size());

  } else

    #endif

  {

    return validate_utf16le_as_ascii(input.data(), input.size());

  }

}

  #endif // SIMDUTF_SPAN

#endif   // SIMDUTF_FEATURE_UTF16 && SIMDUTF_FEATURE_ASCII

#if SIMDUTF_FEATURE_UTF16

/**

 * Using native endianness; Validate the UTF-16 string.

 * This function may be best when you expect the input to be almost always

 * valid. Otherwise, consider using validate_utf16_with_errors.

 *

 * Overridden by each implementation.

 *

 * This function is not BOM-aware.

 *

 * @param buf the UTF-16 string to validate.

 * @param len the length of the string in number of 2-byte code units

 * (char16_t).

 * @return true if and only if the string is valid UTF-16.

 */

simdutf_warn_unused bool validate_utf16(const char16_t *buf,

                                        size_t len) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 bool

validate_utf16(std::span<const char16_t> input) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    return scalar::utf16::validate<endianness::NATIVE>(input.data(),

                                                       input.size());

  } else

    #endif

  {

    return validate_utf16(input.data(), input.size());

  }

}

  #endif // SIMDUTF_SPAN

#endif   // SIMDUTF_FEATURE_UTF16

#if SIMDUTF_FEATURE_UTF16 || SIMDUTF_FEATURE_DETECT_ENCODING

/**

 * Validate the UTF-16LE string. This function may be best when you expect

 * the input to be almost always valid. Otherwise, consider using

 * validate_utf16le_with_errors.

 *

 * Overridden by each implementation.

 *

 * This function is not BOM-aware.

 *

 * @param buf the UTF-16LE string to validate.

 * @param len the length of the string in number of 2-byte code units

 * (char16_t).

 * @return true if and only if the string is valid UTF-16LE.

 */

simdutf_warn_unused bool validate_utf16le(const char16_t *buf,

                                          size_t len) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_constexpr23 simdutf_warn_unused bool

validate_utf16le(std::span<const char16_t> input) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    return scalar::utf16::validate<endianness::LITTLE>(input.data(),

                                                       input.size());

  } else

    #endif

  {

    return validate_utf16le(input.data(), input.size());

  }

}

  #endif // SIMDUTF_SPAN

#endif   // SIMDUTF_FEATURE_UTF16 || SIMDUTF_FEATURE_DETECT_ENCODING

#if SIMDUTF_FEATURE_UTF16

/**

 * Validate the UTF-16BE string. This function may be best when you expect

 * the input to be almost always valid. Otherwise, consider using

 * validate_utf16be_with_errors.

 *

 * Overridden by each implementation.

 *

 * This function is not BOM-aware.

 *

 * @param buf the UTF-16BE string to validate.

 * @param len the length of the string in number of 2-byte code units

 * (char16_t).

 * @return true if and only if the string is valid UTF-16BE.

 */

simdutf_warn_unused bool validate_utf16be(const char16_t *buf,

                                          size_t len) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 bool

validate_utf16be(std::span<const char16_t> input) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    return scalar::utf16::validate<endianness::BIG>(input.data(), input.size());

  } else

    #endif

  {

    return validate_utf16be(input.data(), input.size());

  }

}

  #endif // SIMDUTF_SPAN

/**

 * Using native endianness; Validate the UTF-16 string and stop on error.

 * It might be faster than validate_utf16 when an error is expected to occur

 * early.

 *

 * Overridden by each implementation.

 *

 * This function is not BOM-aware.

 *

 * @param buf the UTF-16 string to validate.

 * @param len the length of the string in number of 2-byte code units

 * (char16_t).

 * @return a result pair struct (of type simdutf::result containing the two

 * fields error and count) with an error code and either position of the error

 * (in the input in code units) if any, or the number of code units validated if

 * successful.

 */

simdutf_warn_unused result validate_utf16_with_errors(const char16_t *buf,

                                                      size_t len) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 result

validate_utf16_with_errors(std::span<const char16_t> input) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    return scalar::utf16::validate_with_errors<endianness::NATIVE>(

        input.data(), input.size());

  } else

    #endif

  {

    return validate_utf16_with_errors(input.data(), input.size());

  }

}

  #endif // SIMDUTF_SPAN

/**

 * Validate the UTF-16LE string and stop on error. It might be faster than

 * validate_utf16le when an error is expected to occur early.

 *

 * Overridden by each implementation.

 *

 * This function is not BOM-aware.

 *

 * @param buf the UTF-16LE string to validate.

 * @param len the length of the string in number of 2-byte code units

 * (char16_t).

 * @return a result pair struct (of type simdutf::result containing the two

 * fields error and count) with an error code and either position of the error

 * (in the input in code units) if any, or the number of code units validated if

 * successful.

 */

simdutf_warn_unused result validate_utf16le_with_errors(const char16_t *buf,

                                                        size_t len) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 result

validate_utf16le_with_errors(std::span<const char16_t> input) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    return scalar::utf16::validate_with_errors<endianness::LITTLE>(

        input.data(), input.size());

  } else

    #endif

  {

    return validate_utf16le_with_errors(input.data(), input.size());

  }

}

  #endif // SIMDUTF_SPAN

/**

 * Validate the UTF-16BE string and stop on error. It might be faster than

 * validate_utf16be when an error is expected to occur early.

 *

 * Overridden by each implementation.

 *

 * This function is not BOM-aware.

 *

 * @param buf the UTF-16BE string to validate.

 * @param len the length of the string in number of 2-byte code units

 * (char16_t).

 * @return a result pair struct (of type simdutf::result containing the two

 * fields error and count) with an error code and either position of the error

 * (in the input in code units) if any, or the number of code units validated if

 * successful.

 */

simdutf_warn_unused result validate_utf16be_with_errors(const char16_t *buf,

                                                        size_t len) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 result

validate_utf16be_with_errors(std::span<const char16_t> input) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    return scalar::utf16::validate_with_errors<endianness::BIG>(input.data(),

                                                                input.size());

  } else

    #endif

  {

    return validate_utf16be_with_errors(input.data(), input.size());

  }

}

  #endif // SIMDUTF_SPAN

/**

 * Fixes an ill-formed UTF-16LE string by replacing mismatched surrogates with

 * the Unicode replacement character U+FFFD. If input and output points to

 * different memory areas, the procedure copies string, and it's expected that

 * output memory is at least as big as the input. It's also possible to set

 * input equal output, that makes replacements an in-place operation.

 *

 * @param input the UTF-16LE string to correct.

 * @param len the length of the string in number of 2-byte code units

 * (char16_t).

 * @param output the output buffer.

 */

void to_well_formed_utf16le(const char16_t *input, size_t len,

                            char16_t *output) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_constexpr23 void

to_well_formed_utf16le(std::span<const char16_t> input,

                       std::span<char16_t> output) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    scalar::utf16::to_well_formed_utf16<endianness::LITTLE>(

        input.data(), input.size(), output.data());

  } else

    #endif

  {

    to_well_formed_utf16le(input.data(), input.size(), output.data());

  }

}

  #endif // SIMDUTF_SPAN

/**

 * Fixes an ill-formed UTF-16BE string by replacing mismatched surrogates with

 * the Unicode replacement character U+FFFD. If input and output points to

 * different memory areas, the procedure copies string, and it's expected that

 * output memory is at least as big as the input. It's also possible to set

 * input equal output, that makes replacements an in-place operation.

 *

 * @param input the UTF-16BE string to correct.

 * @param len the length of the string in number of 2-byte code units

 * (char16_t).

 * @param output the output buffer.

 */

void to_well_formed_utf16be(const char16_t *input, size_t len,

                            char16_t *output) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_constexpr23 void

to_well_formed_utf16be(std::span<const char16_t> input,

                       std::span<char16_t> output) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    scalar::utf16::to_well_formed_utf16<endianness::BIG>(

        input.data(), input.size(), output.data());

  } else

    #endif

  {

    to_well_formed_utf16be(input.data(), input.size(), output.data());

  }

}

  #endif // SIMDUTF_SPAN

/**

 * Fixes an ill-formed UTF-16 string by replacing mismatched surrogates with the

 * Unicode replacement character U+FFFD. If input and output points to different

 * memory areas, the procedure copies string, and it's expected that output

 * memory is at least as big as the input. It's also possible to set input equal

 * output, that makes replacements an in-place operation.

 *

 * @param input the UTF-16 string to correct.

 * @param len the length of the string in number of 2-byte code units

 * (char16_t).

 * @param output the output buffer.

 */

void to_well_formed_utf16(const char16_t *input, size_t len,

                          char16_t *output) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_constexpr23 void

to_well_formed_utf16(std::span<const char16_t> input,

                     std::span<char16_t> output) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    scalar::utf16::to_well_formed_utf16<endianness::NATIVE>(

        input.data(), input.size(), output.data());

  } else

    #endif

  {

    to_well_formed_utf16(input.data(), input.size(), output.data());

  }

}

  #endif // SIMDUTF_SPAN

#endif // SIMDUTF_FEATURE_UTF16

#if SIMDUTF_FEATURE_UTF32 || SIMDUTF_FEATURE_DETECT_ENCODING

/**

 * Validate the UTF-32 string. This function may be best when you expect

 * the input to be almost always valid. Otherwise, consider using

 * validate_utf32_with_errors.

 *

 * Overridden by each implementation.

 *

 * This function is not BOM-aware.

 *

 * @param buf the UTF-32 string to validate.

 * @param len the length of the string in number of 4-byte code units

 * (char32_t).

 * @return true if and only if the string is valid UTF-32.

 */

simdutf_warn_unused bool validate_utf32(const char32_t *buf,

                                        size_t len) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 bool

validate_utf32(std::span<const char32_t> input) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    return scalar::utf32::validate(

        detail::constexpr_cast_ptr<std::uint32_t>(input.data()), input.size());

  } else

    #endif

  {

    return validate_utf32(input.data(), input.size());

  }

}

  #endif // SIMDUTF_SPAN

#endif   // SIMDUTF_FEATURE_UTF32 || SIMDUTF_FEATURE_DETECT_ENCODING

#if SIMDUTF_FEATURE_UTF32

/**

 * Validate the UTF-32 string and stop on error. It might be faster than

 * validate_utf32 when an error is expected to occur early.

 *

 * Overridden by each implementation.

 *

 * This function is not BOM-aware.

 *

 * @param buf the UTF-32 string to validate.

 * @param len the length of the string in number of 4-byte code units

 * (char32_t).

 * @return a result pair struct (of type simdutf::result containing the two

 * fields error and count) with an error code and either position of the error

 * (in the input in code units) if any, or the number of code units validated if

 * successful.

 */

simdutf_warn_unused result validate_utf32_with_errors(const char32_t *buf,

                                                      size_t len) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 result

validate_utf32_with_errors(std::span<const char32_t> input) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    return scalar::utf32::validate_with_errors(

        detail::constexpr_cast_ptr<std::uint32_t>(input.data()), input.size());

  } else

    #endif

  {

    return validate_utf32_with_errors(input.data(), input.size());

  }

}

  #endif // SIMDUTF_SPAN

#endif   // SIMDUTF_FEATURE_UTF32

#if SIMDUTF_FEATURE_UTF8 && SIMDUTF_FEATURE_LATIN1

/**

 * Convert Latin1 string into UTF-8 string.

 *

 * This function is suitable to work with inputs from untrusted sources.

 *

 * @param input         the Latin1 string to convert

 * @param length        the length of the string in bytes

 * @param utf8_output   the pointer to buffer that can hold conversion result

 * @return the number of written char; 0 if conversion is not possible

 */

simdutf_warn_unused size_t convert_latin1_to_utf8(const char *input,

                                                  size_t length,

                                                  char *utf8_output) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 size_t

convert_latin1_to_utf8(

    const detail::input_span_of_byte_like auto &latin1_input,

    detail::output_span_of_byte_like auto &&utf8_output) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    return scalar::latin1_to_utf8::convert(

        detail::constexpr_cast_ptr<char>(latin1_input.data()),

        latin1_input.size(),

        detail::constexpr_cast_writeptr<char>(utf8_output.data()));

  } else

    #endif

  {

    return convert_latin1_to_utf8(

        reinterpret_cast<const char *>(latin1_input.data()),

        latin1_input.size(), reinterpret_cast<char *>(utf8_output.data()));

  }

}

  #endif // SIMDUTF_SPAN

/**

 * Convert Latin1 string into UTF-8 string with output limit.

 *

 * This function is suitable to work with inputs from untrusted sources.

 *

 * We write as many characters as possible.

 *

 * @param input         the Latin1 string to convert

 * @param length        the length of the string in bytes

 * @param utf8_output   the pointer to buffer that can hold conversion result

 * @param utf8_len      the maximum output length

 * @return the number of written char; 0 if conversion is not possible

 */

simdutf_warn_unused size_t

convert_latin1_to_utf8_safe(const char *input, size_t length, char *utf8_output,

                            size_t utf8_len) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 size_t

convert_latin1_to_utf8_safe(

    const detail::input_span_of_byte_like auto &input,

    detail::output_span_of_byte_like auto &&utf8_output) noexcept {

      // implementation note: outputspan is a forwarding ref to avoid copying

      // and allow both lvalues and rvalues. std::span can be copied without

      // problems, but std::vector should not, and this function should accept

      // both. it will allow using an owning rvalue ref (example: passing a

      // temporary std::string) as output, but the user will quickly find out

      // that he has no way of getting the data out of the object in that case.

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    return scalar::latin1_to_utf8::convert_safe_constexpr(

        input.data(), input.size(), utf8_output.data(), utf8_output.size());

  } else

    #endif

  {

    return convert_latin1_to_utf8_safe(

        reinterpret_cast<const char *>(input.data()), input.size(),

        reinterpret_cast<char *>(utf8_output.data()), utf8_output.size());

  }

}

  #endif // SIMDUTF_SPAN

#endif   // SIMDUTF_FEATURE_UTF8 && SIMDUTF_FEATURE_LATIN1

#if SIMDUTF_FEATURE_UTF16 && SIMDUTF_FEATURE_LATIN1

/**

 * Convert possibly Latin1 string into UTF-16LE string.

 *

 * This function is suitable to work with inputs from untrusted sources.

 *

 * @param input         the Latin1 string to convert

 * @param length        the length of the string in bytes

 * @param utf16_output  the pointer to buffer that can hold conversion result

 * @return the number of written char16_t; 0 if conversion is not possible

 */

simdutf_warn_unused size_t convert_latin1_to_utf16le(

    const char *input, size_t length, char16_t *utf16_output) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 size_t

convert_latin1_to_utf16le(

    const detail::input_span_of_byte_like auto &latin1_input,

    std::span<char16_t> utf16_output) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    return scalar::latin1_to_utf16::convert<endianness::LITTLE>(

        latin1_input.data(), latin1_input.size(), utf16_output.data());

  } else

    #endif

  {

    return convert_latin1_to_utf16le(

        reinterpret_cast<const char *>(latin1_input.data()),

        latin1_input.size(), utf16_output.data());

  }

}

  #endif // SIMDUTF_SPAN

/**

 * Convert Latin1 string into UTF-16BE string.

 *

 * This function is suitable to work with inputs from untrusted sources.

 *

 * @param input         the Latin1 string to convert

 * @param length        the length of the string in bytes

 * @param utf16_output  the pointer to buffer that can hold conversion result

 * @return the number of written char16_t; 0 if conversion is not possible

 */

simdutf_warn_unused size_t convert_latin1_to_utf16be(

    const char *input, size_t length, char16_t *utf16_output) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 size_t

convert_latin1_to_utf16be(const detail::input_span_of_byte_like auto &input,

                          std::span<char16_t> output) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    return scalar::latin1_to_utf16::convert<endianness::BIG>(

        input.data(), input.size(), output.data());

  } else

    #endif

  {

    return convert_latin1_to_utf16be(

        reinterpret_cast<const char *>(input.data()), input.size(),

        output.data());

  }

}

  #endif // SIMDUTF_SPAN

/**

 * Compute the number of bytes that this UTF-16 string would require in Latin1

 * format.

 *

 * @param length        the length of the string in Latin1 code units (char)

 * @return the length of the string in Latin1 code units (char) required to

 * encode the UTF-16 string as Latin1

 */

simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 size_t

latin1_length_from_utf16(size_t length) noexcept {

  return length;

}

/**

 * Compute the number of code units that this Latin1 string would require in

 * UTF-16 format.

 *

 * @param length        the length of the string in Latin1 code units (char)

 * @return the length of the string in 2-byte code units (char16_t) required to

 * encode the Latin1 string as UTF-16

 */

simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 size_t

utf16_length_from_latin1(size_t length) noexcept {

  return length;

}

#endif // SIMDUTF_FEATURE_UTF16 && SIMDUTF_FEATURE_LATIN1

#if SIMDUTF_FEATURE_UTF32 && SIMDUTF_FEATURE_LATIN1

/**

 * Convert Latin1 string into UTF-32 string.

 *

 * This function is suitable to work with inputs from untrusted sources.

 *

 * @param input         the Latin1 string to convert

 * @param length        the length of the string in bytes

 * @param utf32_buffer  the pointer to buffer that can hold conversion result

 * @return the number of written char32_t; 0 if conversion is not possible

 */

simdutf_warn_unused size_t convert_latin1_to_utf32(

    const char *input, size_t length, char32_t *utf32_buffer) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 size_t

convert_latin1_to_utf32(

    const detail::input_span_of_byte_like auto &latin1_input,

    std::span<char32_t> utf32_output) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    return scalar::latin1_to_utf32::convert(

        latin1_input.data(), latin1_input.size(), utf32_output.data());

  } else

    #endif

  {

    return convert_latin1_to_utf32(

        reinterpret_cast<const char *>(latin1_input.data()),

        latin1_input.size(), utf32_output.data());

  }

}

  #endif // SIMDUTF_SPAN

#endif   // SIMDUTF_FEATURE_UTF32 && SIMDUTF_FEATURE_LATIN1

#if SIMDUTF_FEATURE_UTF8 && SIMDUTF_FEATURE_LATIN1

/**

 * Convert possibly broken UTF-8 string into latin1 string.

 *

 * During the conversion also validation of the input string is done.

 * This function is suitable to work with inputs from untrusted sources.

 *

 * @param input         the UTF-8 string to convert

 * @param length        the length of the string in bytes

 * @param latin1_output  the pointer to buffer that can hold conversion result

 * @return the number of written char; 0 if the input was not valid UTF-8 string

 * or if it cannot be represented as Latin1

 */

simdutf_warn_unused size_t convert_utf8_to_latin1(const char *input,

                                                  size_t length,

                                                  char *latin1_output) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 size_t

convert_utf8_to_latin1(

    const detail::input_span_of_byte_like auto &input,

    detail::output_span_of_byte_like auto &&output) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    return scalar::utf8_to_latin1::convert(input.data(), input.size(),

                                           output.data());

  } else

    #endif

  {

    return convert_utf8_to_latin1(reinterpret_cast<const char *>(input.data()),

                                  input.size(),

                                  reinterpret_cast<char *>(output.data()));

  }

}

  #endif // SIMDUTF_SPAN

#endif   // SIMDUTF_FEATURE_UTF8 && SIMDUTF_FEATURE_LATIN1

#if SIMDUTF_FEATURE_UTF8 && SIMDUTF_FEATURE_UTF16

/**

 * Using native endianness, convert possibly broken UTF-8 string into a UTF-16

 * string.

 *

 * During the conversion also validation of the input string is done.

 * This function is suitable to work with inputs from untrusted sources.

 *

 * @param input         the UTF-8 string to convert

 * @param length        the length of the string in bytes

 * @param utf16_output  the pointer to buffer that can hold conversion result

 * @return the number of written char16_t; 0 if the input was not valid UTF-8

 * string

 */

simdutf_warn_unused size_t convert_utf8_to_utf16(

    const char *input, size_t length, char16_t *utf16_output) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 size_t

convert_utf8_to_utf16(const detail::input_span_of_byte_like auto &input,

                      std::span<char16_t> output) noexcept {

    #if SIMDUTF_CPLUSPLUS23

  if consteval {

    return scalar::utf8_to_utf16::convert<endianness::NATIVE>(

        input.data(), input.size(), output.data());

  } else

    #endif

  {

    return convert_utf8_to_utf16(reinterpret_cast<const char *>(input.data()),

                                 input.size(), output.data());

  }

}

  #endif // SIMDUTF_SPAN

/**

 * Compute the number of bytes that this UTF-16LE string would require in UTF-8

 * format even when the UTF-16LE content contains mismatched surrogates

 * that have to be replaced by the replacement character (0xFFFD).

 *

 * @param input         the UTF-16LE string to convert

 * @param length        the length of the string in 2-byte code units (char16_t)

 * @return a result pair struct (of type simdutf::result containing the two

 * fields error and count) where the count is the number of bytes required to

 * encode the UTF-16LE string as UTF-8, and the error code is either SUCCESS or

 * SURROGATE. The count is correct regardless of the error field.

 * When SURROGATE is returned, it does not indicate an error in the case of this

 * function: it indicates that at least one surrogate has been encountered: the

 * surrogates may be matched or not (thus this function does not validate). If

 * the returned error code is SUCCESS, then the input contains no surrogate, is

 * in the Basic Multilingual Plane, and is necessarily valid.

 */

simdutf_warn_unused result utf8_length_from_utf16le_with_replacement(

    const char16_t *input, size_t length) noexcept;

  #if SIMDUTF_SPAN

simdutf_really_inline simdutf_constexpr23 simdutf_warn_unused result

utf8_length_from_utf16le_with_replacement(