byte_endian.hpp

Go to the documentation of this file.

/*
 
Copyright 2025 Matthew Tolman
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
   http://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.
 
*/
 
#ifndef MTSTD_ENCODINGS_HPP
#define MTSTD_ENCODINGS_HPP
 
#include "mtcore/byte_order.hpp"
#include "mtcore/colls/slice.hpp"
#include "mtcore/io/writer.hpp"
#include <array>


namespace mtcore {
  constexpr char32_t bom = 0xFEFF;

  constexpr auto is_bom(const char32_t ch) { return ch == bom; }
  constexpr auto is_bom_rev_16_bit(const char16_t ch) { return ch == 0xFFFE; }
  constexpr auto is_bom_rev_32_bit(const char32_t ch) { return ch == 0xFFFE0000; }
 
  template<std::endian target, typename T = char32_t>
  constexpr T endian_bom = target == std::endian::native ? bom : flip_endian<T>(bom);

  inline Optional<std::endian> u16_detect_endian(const char16_t ch) {
    if (is_bom(ch)) {
      return endian::machine;
    }
    else if (is_bom_rev_16_bit(ch)) {
      return endian::opposite;
    }
    else {
      return nullopt;
    }
  }

  inline Optional<std::endian> u32_detect_endian(const char32_t ch) {
    if (is_bom(ch)) {
      return endian::machine;
    }
    else if (is_bom_rev_32_bit(ch)) {
      return endian::opposite;
    }
    else {
      return nullopt;
    }
  }
 
  namespace impl {
    template<typename T, size_t MaxLen>
    struct ShortSeq {
      using Elem = T;
      int len;
      std::array<Elem, MaxLen> elems;
 
      [[nodiscard]] size_t size() const {
        ensure(len < MaxLen);
        return len;
      }
 
      T &operator[](size_t i) {
        ensure(i <= MaxLen, "out of bounds");
        ensure(static_cast<int>(i) < len, "out of bounds");
        return elems[i];
      }
 
      const T &operator[](size_t i) const {
        ensure(i <= MaxLen, "out of bounds");
        ensure(static_cast<int>(i) < len, "out of bounds");
        return elems[i];
      }
 
      [[nodiscard]] T &at(size_t i) noexcept { return (*this)[i]; }
      [[nodiscard]] constexpr const T &at(size_t i) const noexcept { return (*this)[i]; }
 
      [[nodiscard]] decltype(auto) ptr_iter() noexcept { return iter::ptr(*this); }
      [[nodiscard]] decltype(auto) ptr_iter() const noexcept { return iter::const_ptr(*this); }
      [[nodiscard]] decltype(auto) iter() const noexcept { return iter::val(*this); }
    };
  }  // namespace impl
 
  using CharSeq = impl::ShortSeq<char, 4>;
  using U8Seq   = impl::ShortSeq<char8_t, 4>;
  using U16Seq  = impl::ShortSeq<char16_t, 2>;

  constexpr bool is_surrogate(char16_t ch) { return ch >= 0xD800 && ch <= 0xDFFF; }
  constexpr bool is_high_surrogate(char16_t ch) { return ch >= 0xD800 && ch <= 0xDBFF; }
  constexpr bool is_low_surrogate(char16_t ch) { return ch >= 0xDC00 && ch <= 0xDFFF; }

  template<std::endian E = std::endian::native>
  constexpr auto oppositeEndian = E == std::endian::big ? std::endian::little : std::endian::big;

  template<class T, std::endian Endian = std::endian::native>
  struct EndianSlice {
    static_assert(std::is_same_v<T, const char16_t> || std::is_same_v<T, char16_t> ||
                  std::is_same_v<T, const char32_t> || std::is_same_v<T, char32_t>);
    using Elem = T;
 
    T *head    = nullptr;
    size_t len = 0;
 
    [[nodiscard]] decltype(auto) ptr_iter() noexcept { return iter::ptr(*this); }
    [[nodiscard]] decltype(auto) ptr_iter() const noexcept { return iter::const_ptr(*this); }
    [[nodiscard]] decltype(auto) iter() const noexcept { return iter::val(*this); }

    [[nodiscard]] constexpr Slice<std::add_const_t<T>> to_const() const noexcept {
      return {static_cast<std::add_pointer_t<std::add_const_t<T>>>(head), len};
    }

    constexpr void init(T *head, size_t len) {
      this->head = head;
      this->len  = len;
    }

    struct ConstEndianWrapper {
      const EndianSlice &slice;
      size_t i;

      constexpr operator T() const { return as_endian(std::endian::native); }
 
      [[nodiscard]] constexpr auto native() const { return as_endian(std::endian::native); }

      [[nodiscard]] constexpr T as_endian(std::endian viewAs) const {
        ensure(i < slice.size(), "SLICE ACCESS OUT OF BOUNDS");
        ensure(slice.head, "NULL POINTER DEREFERENCE");
        auto v = slice.head[i];
        if (viewAs != Endian) {
          return flip_endian(v);
        }
        return v;
      }
    };

    struct EndianWrapper {
      EndianSlice &slice;
      size_t i;

      constexpr operator T() const { return as_endian(std::endian::native); }

      constexpr EndianWrapper &operator=(T val) { return with_endian(val, std::endian::native); }
 
      [[nodiscard]] constexpr T native() const { return as_endian(std::endian::native); }

      [[nodiscard]] constexpr T as_endian(std::endian viewAs) const {
        ensure(i < slice.size(), "SLICE ACCESS OUT OF BOUNDS");
        ensure(slice.head, "NULL POINTER DEREFERENCE");
        auto v = slice.head[i];
        if (viewAs != Endian) {
          return flip_endian(v);
        }
        return v;
      }

      constexpr EndianWrapper &with_endian(T newVal, std::endian setAs) {
        ensure(i < slice.size(), "SLICE ACCESS OUT OF BOUNDS");
        ensure(slice.head, "NULL POINTER DEREFERENCE");
        if (setAs != Endian) {
          newVal = flip_endian(newVal);
        }
        slice.head[i] = newVal;
        return *this;
      }
    };

    [[nodiscard]] constexpr ConstEndianWrapper operator[](size_t i) const noexcept {
      ensure(i < len, "SLICE ACCESS OUT OF BOUNDS");
      ensure(head, "NULL POINTER DEREFERENCE");
      return ConstEndianWrapper{*this, i};
    }

    EndianWrapper operator[](size_t i) noexcept {
      ensure(i < len, "SLICE ACCESS OUT OF BOUNDS");
      ensure(head, "NULL POINTER DEREFERENCE");
      return EndianWrapper{*this, i};
    }

    EndianWrapper at(size_t i) noexcept { return (*this)[i]; }

    [[nodiscard]] constexpr ConstEndianWrapper at(size_t i) const noexcept { return (*this)[i]; }

    [[nodiscard]] constexpr size_t size() const noexcept { return head != nullptr ? len : 0; }

    [[nodiscard]] constexpr bool empty() const noexcept { return head == nullptr || len == 0; }

    [[nodiscard]] constexpr EndianSlice sub(size_t start) const noexcept {
      EndianSlice res;
      if (start >= len) {
        res.init(nullptr, 0);
        return res;
      }
 
      res.init(head + start, len - start);
      ensure(res.len + start == len, "BAD LENGTH MATH");
      ensure(head + len == res.head + res.len, "BAD END POINTER");
      return res;
    }

    [[nodiscard]] constexpr EndianSlice sub(size_t start, size_t len) const noexcept {
      auto res = sub(start);
      res.len  = res.len > len ? len : res.len;
      ensure(res.len <= len, "BAD LENGTH");
      return res;
    }

    template<std::endian E>
    std::strong_ordering operator<=>(const EndianSlice<std::remove_const_t<T>, E> &other) const noexcept {
      return *this <=> other.to_const();
    }

    template<std::endian E>
    std::strong_ordering operator<=>(const EndianSlice<std::add_const_t<T>, E> &other) const noexcept {
      if (!head) {
        if (other.head) {
          return std::strong_ordering::less;
        }
        return std::strong_ordering::equal;
      }
 
      for (size_t i = 0; i < len && i < other.len; ++i) {
        auto tv = (*this)[i].native();
        auto ov = other[i].native();
        if (tv > ov) {
          return std::strong_ordering::greater;
        }
        else if (tv < ov) {
          return std::strong_ordering::less;
        }
      }
 
      if (len == other.len) {
        return std::strong_ordering::equal;
      }
      else if (len < other.len) {
        return std::strong_ordering::less;
      }
      else {
        return std::strong_ordering::greater;
      }
    }
 
    template<std::endian E>
    bool operator==(const EndianSlice<std::remove_const_t<T>, E> &o) const noexcept {
      return (*this <=> o) == std::strong_ordering::equal;
    }
 
    template<std::endian E>
    bool operator!=(const EndianSlice<std::remove_const_t<T>, E> &o) const noexcept {
      return (*this <=> o) != std::strong_ordering::equal;
    }
 
    template<std::endian E>
    bool operator<(const EndianSlice<std::remove_const_t<T>, E> &o) const noexcept {
      return (*this <=> o) == std::strong_ordering::less;
    }
 
    template<std::endian E>
    bool operator>(const EndianSlice<std::remove_const_t<T>, E> &o) const noexcept {
      return (*this <=> o) == std::strong_ordering::greater;
    }
 
    template<std::endian E>
    bool operator<=(const EndianSlice<std::remove_const_t<T>, E> &o) const noexcept {
      const auto cmp = *this <=> o;
      return (cmp == std::strong_ordering::less || cmp == std::strong_ordering::equal);
    }
 
    template<std::endian E>
    bool operator>=(const EndianSlice<std::remove_const_t<T>, E> &o) const noexcept {
      const auto cmp = *this <=> o;
      return (cmp == std::strong_ordering::greater || cmp == std::strong_ordering::equal);
    }
 
    template<std::endian E>
    bool operator==(const EndianSlice<std::add_const_t<T>, E> &o) const noexcept {
      return (*this <=> o) == std::strong_ordering::equal;
    }
 
    template<std::endian E>
    bool operator!=(const EndianSlice<std::add_const_t<T>, E> &o) const noexcept {
      return (*this <=> o) != std::strong_ordering::equal;
    }
 
    template<std::endian E>
    bool operator<(const EndianSlice<std::add_const_t<T>, E> &o) const noexcept {
      return (*this <=> o) == std::strong_ordering::less;
    }
 
    template<std::endian E>
    bool operator>(const EndianSlice<std::add_const_t<T>, E> &o) const noexcept {
      return (*this <=> o) == std::strong_ordering::greater;
    }
 
    template<std::endian E>
    bool operator<=(const EndianSlice<std::add_const_t<T>, E> &o) const noexcept {
      const auto cmp = *this <=> o;
      return (cmp == std::strong_ordering::less || cmp == std::strong_ordering::equal);
    }
 
    template<std::endian E>
    bool operator>=(const EndianSlice<std::add_const_t<T>, E> &o) const noexcept {
      const auto cmp = *this <=> o;
      return (cmp == std::strong_ordering::greater || cmp == std::strong_ordering::equal);
    }
  };
 
  namespace impl {
    template<typename T, std::endian E>
    struct EndianSliceWriterImpl {
      static_assert(!std::is_const_v<T>, "Cannot write to const pointer!");
      EndianSlice<T, E> out;
      size_t curWriteIndex = 0;
 
      using WriteElem = T;
      using ErrType   = io::SliceWriteError;
 
      Result<size_t, ErrType> write(Slice<std::add_const_t<T>> bytes) {
        size_t i = 0;
        for (; i < bytes.size() && curWriteIndex < out.size(); ++i, ++curWriteIndex) {
          out[curWriteIndex] = bytes[i];
        }
        return success(i);
      }
 
      template<std::endian E2>
      Result<size_t, ErrType> write(EndianSlice<std::add_const_t<T>, E2> bytes) {
        size_t i = 0;
        for (; i < bytes.size() && curWriteIndex < out.size(); ++i, ++curWriteIndex) {
          out[curWriteIndex] = bytes[i].native();
        }
        return success(i);
      }
    };
  }  // namespace impl

  using SliceU16Native = EndianSlice<char16_t, std::endian::native>;
  using SliceU16Le = EndianSlice<char16_t, std::endian::little>;
  using SliceU16Be = EndianSlice<char16_t, std::endian::big>;
  using SliceConstU16Native = EndianSlice<const char16_t, std::endian::native>;
  using SliceConstU16Le = EndianSlice<const char16_t, std::endian::little>;
  using SliceConstU16Be = EndianSlice<const char16_t, std::endian::big>;

  using SliceU32Native = EndianSlice<char32_t, std::endian::native>;
  using SliceU32Le = EndianSlice<char32_t, std::endian::little>;
  using SliceU32Be = EndianSlice<char32_t, std::endian::big>;
  using SliceConstU32Native = EndianSlice<const char32_t, std::endian::native>;
  using SliceConstU32Le = EndianSlice<const char32_t, std::endian::little>;
  using SliceConstU32Be = EndianSlice<const char32_t, std::endian::big>;

  inline SliceU16Native endian_from_native_slice(Slice<char16_t> s) { return {.head = s.head, .len = s.len}; }
  inline SliceU32Native endian_from_native_slice(Slice<char32_t> s) { return {.head = s.head, .len = s.len}; }

  inline SliceU16Le endian_from_le_slice(Slice<char16_t> s) { return {.head = s.head, .len = s.len}; }
  inline SliceU32Le endian_from_le_slice(Slice<char32_t> s) { return {.head = s.head, .len = s.len}; }

  inline SliceU16Be endian_from_be_slice(Slice<char16_t> s) { return {.head = s.head, .len = s.len}; }
  inline SliceU32Be endian_from_be_slice(Slice<char32_t> s) { return {.head = s.head, .len = s.len}; }

  inline SliceConstU16Native endian_from_native_slice(Slice<const char16_t> s) {
    return {.head = s.head, .len = s.len};
  }
  /*
   * Gets a const UTF-32 endian slice from a slice which is assumed ot be native endian
   * @ingroup unicode_enc
   */
  inline SliceConstU32Native endian_from_native_slice(Slice<const char32_t> s) {
    return {.head = s.head, .len = s.len};
  }

  inline SliceConstU16Le endian_from_le_slice(Slice<const char16_t> s) { return {.head = s.head, .len = s.len}; }
  inline SliceConstU32Le endian_from_le_slice(Slice<const char32_t> s) { return {.head = s.head, .len = s.len}; }

  inline SliceConstU16Be endian_from_be_slice(Slice<const char16_t> s) { return {.head = s.head, .len = s.len}; }
  inline SliceConstU32Be endian_from_be_slice(Slice<const char32_t> s) { return {.head = s.head, .len = s.len}; }

  inline std::variant<SliceU16Le, SliceU16Be> endian_from_slice(Slice<char16_t> s) {
    if (s.size() > 0) {
      if (auto detect = u16_detect_endian(s[0]); detect.has_value()) {
        auto subbed = s.sub(1);
        if (detect.value() == std::endian::little) {
          return SliceU16Le{.head = subbed.head, .len = subbed.len};
        }
        else {
          return SliceU16Be{.head = subbed.head, .len = subbed.len};
        }
      }
    }
    return SliceU16Native{.head = s.head, .len = s.len};
  }

  inline std::variant<SliceU32Le, SliceU32Be> endian_from_slice(Slice<char32_t> s) {
    if (s.size() > 0) {
      if (auto detect = u16_detect_endian(s[0]); detect.has_value()) {
        auto subbed = s.sub(1);
        if (detect.value() == std::endian::little) {
          return SliceU32Le{.head = subbed.head, .len = subbed.len};
        }
        else {
          return SliceU32Be{.head = subbed.head, .len = subbed.len};
        }
      }
    }
    return SliceU32Native{.head = s.head, .len = s.len};
  }

  inline std::variant<SliceConstU16Le, SliceConstU16Be> endian_from_slice(Slice<const char16_t> s) {
    if (s.size() > 0) {
      if (auto detect = u16_detect_endian(s[0]); detect.has_value()) {
        auto subbed = s.sub(1);
        if (detect.value() == std::endian::little) {
          return SliceConstU16Le{.head = subbed.head, .len = subbed.len};
        }
        else {
          return SliceConstU16Be{.head = subbed.head, .len = subbed.len};
        }
      }
    }
    return SliceConstU16Native{.head = s.head, .len = s.len};
  }

  inline std::variant<SliceConstU32Le, SliceConstU32Be> endian_from_slice(Slice<const char32_t> s) {
    if (s.size() > 0) {
      if (auto detect = u16_detect_endian(s[0]); detect.has_value()) {
        auto subbed = s.sub(1);
        if (detect.value() == std::endian::little) {
          return SliceConstU32Le{.head = subbed.head, .len = subbed.len};
        }
        else {
          return SliceConstU32Be{.head = subbed.head, .len = subbed.len};
        }
      }
    }
    return SliceConstU32Native{.head = s.head, .len = s.len};
  }

  inline Slice<char16_t> slice_from_native_endian(SliceU16Native s) { return {.head = s.head, .len = s.len}; }
  inline Slice<const char16_t> slice_from_native_endian(SliceConstU16Native s) {
    return {.head = s.head, .len = s.len};
  }

  inline Slice<char32_t> slice_from_native_endian(SliceU32Native s) { return {.head = s.head, .len = s.len}; }
  inline Slice<const char32_t> slice_from_native_endian(SliceConstU32Native s) {
    return {.head = s.head, .len = s.len};
  }

  inline Slice<char16_t> slice_from_le_endian(SliceU16Native s) { return {.head = s.head, .len = s.len}; }
  inline Slice<const char16_t> slice_from_le_endian(SliceConstU16Native s) { return {.head = s.head, .len = s.len}; }
  inline Slice<char32_t> slice_from_le_endian(SliceU32Native s) { return {.head = s.head, .len = s.len}; }
  inline Slice<const char32_t> slice_from_le_endian(SliceConstU32Native s) { return {.head = s.head, .len = s.len}; }

  inline Slice<char16_t> slice_from_be_endian(SliceU16Native s) { return {.head = s.head, .len = s.len}; }
  inline Slice<const char16_t> slice_from_be_endian(SliceConstU16Native s) { return {.head = s.head, .len = s.len}; }
  inline Slice<char32_t> slice_from_be_endian(SliceU32Native s) { return {.head = s.head, .len = s.len}; }
  inline Slice<const char32_t> slice_from_be_endian(SliceConstU32Native s) { return {.head = s.head, .len = s.len}; }
 
  using Rune = char32_t;

  CharSeq rune_to_str(Rune rune);
  U8Seq rune_to_utf8(Rune rune);
  U16Seq rune_to_utf16(Rune rune);

  enum class RuneConversionError {
    NoInput,
    InvalidChars,
  };
 
  namespace impl::unicode {
    constexpr char16_t utf16HighOffset = 0xD800;
    constexpr char16_t utf16LowOffset  = 0xDC00;
    constexpr char32_t utf16Sub        = 0x10000;
 
    constexpr uint8_t continueFlag = 0b10000000;
 
    constexpr auto runeMasks = std::array{
      static_cast<u32>(0b111110000000000000000),
      static_cast<u32>(0b000001111100000000000),
      static_cast<u32>(0b000000000011110000000),
    };
 
    constexpr auto utf8StartFlags = std::array<std::tuple<uint8_t, int, uint8_t>, 5>{
      std::make_tuple(0b11110000, 4, 0b00000111), std::make_tuple(0b11100000, 3, 0b00001111),
      std::make_tuple(0b11000000, 2, 0b00011111), std::make_tuple(continueFlag, -1, 0b00111111),
      std::make_tuple(0b00000000, 1, 0b01111111),
    };
 
    constexpr auto num_bytes(char8_t byte) -> int {
      for (const auto &[flagSet, bytes, _flag_removal]: utf8StartFlags) {
        if (byte >= flagSet) {
          return bytes;
        }
      }
      return -1;
    }
 
    constexpr auto without_flag(char8_t byte) -> uint8_t {
      for (const auto &[flagSet, _bytes, removeFlag]: utf8StartFlags) {
        if (byte >= flagSet) {
          return byte & removeFlag;
        }
      }
      return byte;
    }
 
    constexpr auto get_flag(char8_t byte) -> uint8_t {
      for (const auto &[flagSet, _bytes, _removeFlag]: utf8StartFlags) {
        if (byte >= flagSet) {
          return flagSet;
        }
      }
      return 0;
    }
  }  // namespace impl::unicode

  Result<Rune, RuneConversionError> utf8_to_rune(const Slice<const char8_t> &rune);
  Result<Rune, RuneConversionError> str_to_rune(const Slice<const char> &rune);

  Result<Rune, RuneConversionError> utf16_to_rune(const Slice<const char16_t> &rune);
  Result<Rune, RuneConversionError> utf16_to_rune(const SliceConstU16Native &rune);

  template<typename T>
  struct RuneIterator {
    using IterElem = Rune;
    Slice<const T> data;
    size_t strIndex = 0;

    Optional<Rune> next() {
      if (strIndex >= data.size()) {
        return nullopt;
      }
      auto curIndex        = strIndex;
      char32_t currentRune = 0;
      auto numBytes        = impl::unicode::num_bytes(data[curIndex]);
 
      if (numBytes < 0) {
        ++strIndex;
      }
      else if (curIndex + numBytes - 1 >= data.size()) {
        strIndex = data.size();
      }
      else {
        strIndex = curIndex + numBytes;
        for (size_t index = curIndex; index < strIndex; ++index) {
          auto flag = impl::unicode::get_flag(data[index]);
          if (index > curIndex && flag != impl::unicode::continueFlag) {
            strIndex    = curIndex + index - 1;
            currentRune = 0;
            break;
          }
          auto noFlag = impl::unicode::without_flag(data[index]);
          currentRune <<= 6;
          currentRune |= noFlag;
        }
      }
      return currentRune;
    }
  };

  template<>
  struct RuneIterator<char32_t> {
    using IterElem = char32_t;
    Slice<const char32_t> data;
    size_t strIndex = 0;
    bool reverseBom = false;
 
    Optional<char32_t> next() {
      if (strIndex >= data.len) {
        return nullopt;
      }
      const auto res = data[strIndex++];
      if (reverseBom) {
        return flip_endian_ch32(res);
      }
      return res;
    }
  };

  template<>
  struct RuneIterator<char16_t> {
    using IterElem = char32_t;
    Slice<const char16_t> data;
    size_t strIndex = 0;
    bool reverseBom = false;
 
    Optional<char32_t> next() {
      if (strIndex >= data.size()) {
        return nullopt;
      }
      size_t curIndex      = strIndex;
      char32_t currentRune = 0;
 
      auto ch = data[curIndex];
      if (reverseBom) {
        ch = flip_endian_ch16(ch);
      }
 
      if (is_high_surrogate(ch)) {
        if (curIndex + 1 >= data.size()) {
          strIndex = data.size();
          return currentRune;
        }
        else {
          auto chNext = data[curIndex + 1];
          if (reverseBom) {
            chNext = flip_endian_ch16(chNext);
          }
 
          const auto high = (ch - impl::unicode::utf16HighOffset) * 0x400;
          const auto low  = chNext - impl::unicode::utf16LowOffset;
          currentRune     = high + low + impl::unicode::utf16Sub;
          strIndex        = curIndex + 2;
        }
      }
      else {
        if (!is_low_surrogate(ch)) {
          currentRune = static_cast<char32_t>(ch);
          if (reverseBom) {
            flip_endian_ch16(currentRune);
          }
        }
        ++strIndex;
      }
      return currentRune;
    }
  };

  inline RuneIterator<char> str_rune_iterator(const Slice<const char> &s) { return {.data = s, .strIndex = 0}; }

  inline RuneIterator<char8_t> utf8_rune_iterator(const Slice<const char8_t> &s) { return {.data = s, .strIndex = 0}; }

  inline RuneIterator<char16_t> utf16_rune_iterator(const Slice<const char16_t> &s) {
    if (s.size()) {
      if (const auto encoding = u16_detect_endian(s[0]); encoding.has_value()) {
        return {.data = s.sub(1), .strIndex = 0, .reverseBom = encoding == endian::opposite};
      }
    }
    return {.data = s, .strIndex = 0};
  }

  inline RuneIterator<char16_t> utf16_rune_iterator(const SliceConstU16Le &s) {
    return {
      .data = {.head = s.head, .len = s.len}, .strIndex = 0, .reverseBom = std::endian::native != std::endian::little};
  }

  inline RuneIterator<char16_t> utf16_rune_iterator(const SliceConstU16Be &s) {
    return {
      .data = {.head = s.head, .len = s.len}, .strIndex = 0, .reverseBom = std::endian::native != std::endian::big};
  }

  inline RuneIterator<char16_t> utf16_rune_iterator(const SliceU16Le &s) {
    return {
      .data = {.head = s.head, .len = s.len}, .strIndex = 0, .reverseBom = std::endian::native != std::endian::little};
  }

  inline RuneIterator<char16_t> utf16_rune_iterator(const SliceU16Be &s) {
    return {
      .data = {.head = s.head, .len = s.len}, .strIndex = 0, .reverseBom = std::endian::native != std::endian::big};
  }

  inline RuneIterator<char32_t> utf32_rune_iterator(const Slice<const char32_t> &s) {
    if (s.size()) {
      if (const auto encoding = u32_detect_endian(s[0]); encoding.has_value()) {
        return {.data = s.sub(1), .strIndex = 0, .reverseBom = encoding == endian::opposite};
      }
    }
    return {.data = s, .strIndex = 0};
  }

  inline RuneIterator<char32_t> utf32_rune_iterator(const SliceConstU32Le &s) {
    return {
      .data = {.head = s.head, .len = s.len}, .strIndex = 0, .reverseBom = std::endian::native != std::endian::little};
  }

  inline RuneIterator<char32_t> utf32_rune_iterator(const SliceConstU32Be &s) {
    return {
      .data = {.head = s.head, .len = s.len}, .strIndex = 0, .reverseBom = std::endian::native != std::endian::big};
  }

  inline RuneIterator<char32_t> utf32_rune_iterator(const SliceU32Le &s) {
    return {
      .data = {.head = s.head, .len = s.len}, .strIndex = 0, .reverseBom = std::endian::native != std::endian::little};
  }

  inline RuneIterator<char32_t> utf32_rune_iterator(const SliceU32Be &s) {
    return {
      .data = {.head = s.head, .len = s.len}, .strIndex = 0, .reverseBom = std::endian::native != std::endian::big};
  }

  template<WriterImpl WI>
  auto utf32_to_utf16(io::Writer<WI> &writer, const SliceConstU32Be &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    char32_t cur;
    auto iter      = utf32_rune_iterator(str);
    size_t written = 0;
 
    if (writeBom) {
      if (auto res = writer.write(bom); res.is_error()) {
        return res.error();
      }
      ++written;
    }
 
    while (iter.next().copy_if_present(cur)) {
      auto seq = rune_to_utf16(cur);
      char16_t curCh;
      auto iter2 = seq.iter();
      while (iter2.next().copy_if_present(curCh)) {
        if (auto writeRes = writer.write(curCh); writeRes.is_error()) {
          return writeRes.error();
        }
        ++written;
      }
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf32_to_utf16(io::Writer<WI> &writer, const SliceConstU32Le &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    char32_t cur;
    auto iter      = utf32_rune_iterator(str);
    size_t written = 0;
 
    if (writeBom) {
      if (auto res = writer.write(bom); res.is_error()) {
        return res.error();
      }
      ++written;
    }
 
    while (iter.next().copy_if_present(cur)) {
      auto seq = rune_to_utf16(cur);
      char16_t curCh;
      auto iter2 = seq.iter();
      while (iter2.next().copy_if_present(curCh)) {
        if (auto writeRes = writer.write(curCh); writeRes.is_error()) {
          return writeRes.error();
        }
        ++written;
      }
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf32_to_utf16(io::Writer<WI> &writer, const Slice<const char32_t> &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    return utf32_to_utf16(writer, endian_from_native_slice(str), writeBom);
  }

  template<WriterImpl WI>
  auto utf32_to_utf8(io::Writer<WI> &writer, const SliceConstU32Be &str) -> Result<size_t, typename io::Writer<WI>::ErrType> {
    char32_t cur;
    auto iter      = utf32_rune_iterator(str);
    size_t written = 0;
    while (iter.next().copy_if_present(cur)) {
      auto seq = rune_to_utf8(cur);
      char8_t curCh;
      auto iter2 = seq.iter();
      while (iter2.next().copy_if_present(curCh)) {
        if (auto writeRes = writer.write(curCh); writeRes.is_error()) {
          return writeRes.error();
        }
        ++written;
      }
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf32_to_utf8(io::Writer<WI> &writer, const SliceConstU32Le &str) -> Result<size_t, typename io::Writer<WI>::ErrType> {
    char32_t cur;
    auto iter      = utf32_rune_iterator(str);
    size_t written = 0;
    while (iter.next().copy_if_present(cur)) {
      auto seq = rune_to_utf8(cur);
      char8_t curCh;
      auto iter2 = seq.iter();
      while (iter2.next().copy_if_present(curCh)) {
        if (auto writeRes = writer.write(curCh); writeRes.is_error()) {
          return writeRes.error();
        }
        ++written;
      }
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf32_to_utf8(io::Writer<WI> &writer, const Slice<const char32_t> &str)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    return utf32_to_utf8(writer, endian_from_native_slice(str));
  }

  template<WriterImpl WI>
  auto utf32_to_str(io::Writer<WI> &writer, const SliceConstU32Be &str) -> Result<size_t, typename io::Writer<WI>::ErrType> {
    char32_t cur;
    auto iter      = utf32_rune_iterator(str);
    size_t written = 0;
    while (iter.next().copy_if_present(cur)) {
      auto seq = rune_to_str(cur);
      char curCh;
      auto iter2 = seq.iter();
      while (iter2.next().copy_if_present(curCh)) {
        if (auto writeRes = writer.write(curCh); writeRes.is_error()) {
          return writeRes.error();
        }
        ++written;
      }
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf32_to_str(io::Writer<WI> &writer, const SliceConstU32Le &str) -> Result<size_t, typename io::Writer<WI>::ErrType> {
    char32_t cur;
    auto iter      = utf32_rune_iterator(str);
    size_t written = 0;
    while (iter.next().copy_if_present(cur)) {
      auto seq = rune_to_str(cur);
      char curCh;
      auto iter2 = seq.iter();
      while (iter2.next().copy_if_present(curCh)) {
        if (auto writeRes = writer.write(curCh); writeRes.is_error()) {
          return writeRes.error();
        }
        ++written;
      }
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf32_to_str(io::Writer<WI> &writer, const Slice<const char32_t> &str)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    return utf32_to_str(writer, endian_from_native_slice(str));
  }

  template<WriterImpl WI>
  auto utf8_to_utf32(io::Writer<WI> &writer, const Slice<const char8_t> &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = utf8_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
 
    if (writeBom) {
      if (auto res = writer.write(bom); res.is_error()) {
        return res.error();
      }
      ++written;
    }
 
    while (runeIter.next().copy_if_present(rune)) {
      if (auto writeRes = writer.write(rune); writeRes.is_error()) {
        return writeRes.error();
      }
      ++written;
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto str_to_utf32(io::Writer<WI> &writer, const Slice<const char> &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = str_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
 
    if (writeBom) {
      if (auto res = writer.write(bom); res.is_error()) {
        return res.error();
      }
      ++written;
    }
 
    while (runeIter.next().copy_if_present(rune)) {
      if (auto writeRes = writer.write(rune); writeRes.is_error()) {
        return writeRes.error();
      }
      ++written;
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf16_to_utf8(io::Writer<WI> &writer, const SliceConstU16Be &str) -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = utf16_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
    while (runeIter.next().copy_if_present(rune)) {
      auto seq = rune_to_utf8(rune);
      char8_t curCh;
      auto charIter = seq.iter();
      while (charIter.next().copy_if_present(curCh)) {
        if (auto writeRes = writer.write(curCh); writeRes.is_error()) {
          return writeRes.error();
        }
        ++written;
      }
    }
    return success(written);
  }
 

  template<WriterImpl WI>
  auto utf16_to_utf32(io::Writer<WI> &writer, const SliceConstU16Le &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = utf16_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
 
    if (writeBom) {
      if (auto res = writer.write(bom); res.is_error()) {
        return res.error();
      }
      ++written;
    }
 
    while (runeIter.next().copy_if_present(rune)) {
      if (auto writeres = writer.write(rune); writeres.is_error()) {
        return writeres.error();
      }
      ++written;
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf16_to_utf32(io::Writer<WI> &writer, const SliceConstU16Be &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = utf16_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
 
    if (writeBom) {
      if (auto res = writer.write(bom); res.is_error()) {
        return res.error();
      }
      ++written;
    }
 
    while (runeIter.next().copy_if_present(rune)) {
      if (auto writeres = writer.write(rune); writeres.is_error()) {
        return writeres.error();
      }
      ++written;
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf16_to_utf32(io::Writer<WI> &writer, const Slice<const char16_t> &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    return utf16_to_utf32(writer, endian_from_native_slice(str), writeBom);
  }

  template<WriterImpl WI>
  auto utf16_to_utf8(io::Writer<WI> &writer, const SliceConstU16Le &str) -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = utf16_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
    while (runeIter.next().copy_if_present(rune)) {
      auto seq = rune_to_utf8(rune);
      char8_t curCh;
      auto charIter = seq.iter();
      while (charIter.next().copy_if_present(curCh)) {
        if (auto writeRes = writer.write(curCh); writeRes.is_error()) {
          return writeRes.error();
        }
        ++written;
      }
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf16_to_str(io::Writer<WI> &writer, const SliceConstU16Be &str) -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = utf16_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
    while (runeIter.next().copy_if_present(rune)) {
      auto seq = rune_to_str(rune);
      char curCh;
      auto charIter = seq.iter();
      while (charIter.next().copy_if_present(curCh)) {
        if (auto writeRes = writer.write(curCh); writeRes.is_error()) {
          return writeRes.error();
        }
        ++written;
      }
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf16_to_str(io::Writer<WI> &writer, const SliceConstU16Le &str) -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = utf16_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
    while (runeIter.next().copy_if_present(rune)) {
      auto seq = rune_to_str(rune);
      char curCh;
      auto charIter = seq.iter();
      while (charIter.next().copy_if_present(curCh)) {
        if (auto writeRes = writer.write(curCh); writeRes.is_error()) {
          return writeRes.error();
        }
        ++written;
      }
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf16_to_utf8(io::Writer<WI> &writer, const Slice<const char16_t> &str)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    return utf16_to_utf8(writer, endian_from_native_slice(str));
  }

  template<WriterImpl WI>
  auto utf16_to_str(io::Writer<WI> &writer, const Slice<const char16_t> &str)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    return utf16_to_str(writer, endian_from_native_slice(str));
  }

  template<WriterImpl WI>
  auto utf8_to_utf16(io::Writer<WI> &writer, const Slice<const char8_t> &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = utf8_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
 
    if (writeBom) {
      if (auto res = writer.write(bom); res.is_error()) {
        return res.error();
      }
      ++written;
    }
 
    while (runeIter.next().copy_if_present(rune)) {
      auto seq = rune_to_utf16(rune);
      char16_t curCh;
      auto charIter = seq.iter();
      while (charIter.next().copy_if_present(curCh)) {
        if (auto writeRes = writer.write(curCh); writeRes.is_error()) {
          return writeRes.error();
        }
        ++written;
      }
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto str_to_utf16(io::Writer<WI> &writer, const Slice<const char> &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = str_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
 
    if (writeBom) {
      if (auto res = writer.write(bom); res.is_error()) {
        return res.error();
      }
      ++written;
    }
 
    while (runeIter.next().copy_if_present(rune)) {
      auto seq = rune_to_utf16(rune);
      char16_t curCh;
      auto charIter = seq.iter();
      while (charIter.next().copy_if_present(curCh)) {
        if (auto writeRes = writer.write(curCh); writeRes.is_error()) {
          return writeRes.error();
        }
        ++written;
      }
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf8_to_str(io::Writer<WI> &writer, const Slice<const char8_t> &str)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = utf8_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
    while (runeIter.next().copy_if_present(rune)) {
      auto seq = rune_to_str(rune);
      char curCh;
      auto charIter = seq.iter();
      while (charIter.next().copy_if_present(curCh)) {
        if (auto writeRes = writer.write(curCh); writeRes.is_error()) {
          return writeRes.error();
        }
        ++written;
      }
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto str_to_utf8(io::Writer<WI> &writer, const Slice<const char> &str) -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = str_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
    while (runeIter.next().copy_if_present(rune)) {
      auto seq = rune_to_utf8(rune);
      char8_t curCh;
      auto charIter = seq.iter();
      while (charIter.next().copy_if_present(curCh)) {
        if (auto writeRes = writer.write(curCh); writeRes.is_error()) {
          return writeRes.error();
        }
        ++written;
      }
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf16_to_utf16le(io::Writer<WI> &writer, const SliceConstU16Native &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = utf16_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
 
    if (writeBom) {
      if (auto res = writer.write(endian_bom<std::endian::little, char16_t>); res.is_error()) {
        return res.error();
      }
      ++written;
    }
 
    while (runeIter.next().copy_if_present(rune)) {
      auto seq = rune_to_utf16(rune);
      char16_t cur;
      auto seqIter = seq.iter();
      while (seqIter.next().copy_if_present(cur)) {
        if constexpr (std::endian::native != std::endian::little) {
          cur = flip_endian(cur);
        }
        if (auto writeRes = writer.write(cur); writeRes.is_error()) {
          return writeRes.error();
        }
        ++written;
      }
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf16_to_utf16le(io::Writer<WI> &writer, const Slice<const char16_t> &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    return utf16_to_utf16le(writer, endian_from_native_slice(str), writeBom);
  }

  template<WriterImpl WI>
  auto utf16_to_utf16be(io::Writer<WI> &writer, const SliceConstU16Native &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = utf16_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
 
    if (writeBom) {
      if (auto res = writer.write(endian_bom<std::endian::big, char16_t>); res.is_error()) {
        return res.error();
      }
      ++written;
    }
 
    while (runeIter.next().copy_if_present(rune)) {
      auto seq = rune_to_utf16(rune);
      char16_t cur;
      auto seqIter = seq.iter();
      while (seqIter.next().copy_if_present(cur)) {
        if constexpr (std::endian::native != std::endian::big) {
          cur = flip_endian(cur);
        }
        if (auto writeRes = writer.write(cur); writeRes.is_error()) {
          return writeRes.error();
        }
        ++written;
      }
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf16_to_utf16be(io::Writer<WI> &writer, const Slice<const char16_t> &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    return utf16_to_utf16be(writer, endian_from_native_slice(str), writeBom);
  }

  template<WriterImpl WI>
  auto utf16le_to_utf16be(io::Writer<WI> &writer, const SliceConstU16Le &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = utf16_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
 
    if (writeBom) {
      if (auto res = writer.write(endian_bom<std::endian::big, char16_t>); res.is_error()) {
        return res.error();
      }
      ++written;
    }
 
    while (runeIter.next().copy_if_present(rune)) {
      auto seq = rune_to_utf16(rune);
      char16_t cur;
      auto seqIter = seq.iter();
      while (seqIter.next().copy_if_present(cur)) {
        if constexpr (std::endian::native != std::endian::big) {
          cur = flip_endian(cur);
        }
        if (auto writeRes = writer.write(cur); writeRes.is_error()) {
          return writeRes.error();
        }
        ++written;
      }
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf16be_to_utf16le(io::Writer<WI> &writer, const SliceConstU16Be &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = utf16_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
 
    if (writeBom) {
      if (auto res = writer.write(endian_bom<std::endian::little, char16_t>); res.is_error()) {
        return res.error();
      }
      ++written;
    }
 
    while (runeIter.next().copy_if_present(rune)) {
      auto seq = rune_to_utf16(rune);
      char16_t cur;
      auto seqIter = seq.iter();
      while (seqIter.next().copy_if_present(cur)) {
        if constexpr (std::endian::native != std::endian::little) {
          cur = flip_endian(cur);
        }
        if (auto writeRes = writer.write(cur); writeRes.is_error()) {
          return writeRes.error();
        }
        ++written;
      }
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf16le_to_utf16(io::Writer<WI> &writer, const SliceConstU16Le &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = utf16_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
 
    if (writeBom) {
      if (auto res = writer.write(endian_bom<std::endian::native, char16_t>); res.is_error()) {
        return res.error();
      }
      ++written;
    }
 
    while (runeIter.next().copy_if_present(rune)) {
      auto seq = rune_to_utf16(rune);
      char16_t cur;
      auto seqIter = seq.iter();
      while (seqIter.next().copy_if_present(cur)) {
        if (auto writeRes = writer.write(cur); writeRes.is_error()) {
          return writeRes.error();
        }
        ++written;
      }
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf16be_to_utf16(io::Writer<WI> &writer, const SliceConstU16Be &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = utf16_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
 
    if (writeBom) {
      if (auto res = writer.write(endian_bom<std::endian::native, char16_t>); res.is_error()) {
        return res.error();
      }
      ++written;
    }
 
    while (runeIter.next().copy_if_present(rune)) {
      auto seq = rune_to_utf16(rune);
      char16_t cur;
      auto seqIter = seq.iter();
      while (seqIter.next().copy_if_present(cur)) {
        if (auto writeRes = writer.write(cur); writeRes.is_error()) {
          return writeRes.error();
        }
        ++written;
      }
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf32_to_utf32le(io::Writer<WI> &writer, const SliceConstU32Native &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = utf32_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
 
    if (writeBom) {
      if (auto res = writer.write(endian_bom<std::endian::little, char32_t>); res.is_error()) {
        return res.error();
      }
      ++written;
    }
 
    while (runeIter.next().copy_if_present(rune)) {
      if constexpr (std::endian::native != std::endian::little) {
        rune = flip_endian(rune);
      }
      if (auto writeRes = writer.write(rune); writeRes.is_error()) {
        return writeRes.error();
      }
      ++written;
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf32_to_utf32le(io::Writer<WI> &writer, const Slice<const char32_t> &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    return utf32_to_utf32le(writer, endian_from_native_slice(str), writeBom);
  }

  template<WriterImpl WI>
  auto utf32_to_utf32be(io::Writer<WI> &writer, const SliceConstU32Native &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = utf32_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
 
    if (writeBom) {
      if (auto res = writer.write(endian_bom<std::endian::big, char32_t>); res.is_error()) {
        return res.error();
      }
      ++written;
    }
 
    while (runeIter.next().copy_if_present(rune)) {
      if constexpr (std::endian::native != std::endian::big) {
        rune = flip_endian(rune);
      }
      if (auto writeRes = writer.write(rune); writeRes.is_error()) {
        return writeRes.error();
      }
      ++written;
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf32_to_utf32be(io::Writer<WI> &writer, const Slice<const char32_t> &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    return utf32_to_utf32be(writer, endian_from_native_slice(str), writeBom);
  }

  template<WriterImpl WI>
  auto utf32le_to_utf32be(io::Writer<WI> &writer, const SliceConstU32Le &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = utf32_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
 
    if (writeBom) {
      if (auto res = writer.write(endian_bom<std::endian::big, char32_t>); res.is_error()) {
        return res.error();
      }
      ++written;
    }
 
    while (runeIter.next().copy_if_present(rune)) {
      if constexpr (std::endian::native != std::endian::big) {
        rune = flip_endian(rune);
      }
      if (auto writeRes = writer.write(rune); writeRes.is_error()) {
        return writeRes.error();
      }
      ++written;
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf32be_to_utf32le(io::Writer<WI> &writer, const SliceConstU32Be &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = utf32_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
 
    if (writeBom) {
      if (auto res = writer.write(endian_bom<std::endian::little, char32_t>); res.is_error()) {
        return res.error();
      }
      ++written;
    }
 
    while (runeIter.next().copy_if_present(rune)) {
      if constexpr (std::endian::native != std::endian::little) {
        rune = flip_endian(rune);
      }
      if (auto writeRes = writer.write(rune); writeRes.is_error()) {
        return writeRes.error();
      }
      ++written;
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf32le_to_utf32(io::Writer<WI> &writer, const SliceConstU32Le &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = utf32_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
 
    if (writeBom) {
      if (auto res = writer.write(endian_bom<std::endian::native, char32_t>); res.is_error()) {
        return res.error();
      }
      ++written;
    }
 
    while (runeIter.next().copy_if_present(rune)) {
      if (auto writeRes = writer.write(rune); writeRes.is_error()) {
        return writeRes.error();
      }
      ++written;
    }
    return success(written);
  }

  template<WriterImpl WI>
  auto utf32be_to_utf32(io::Writer<WI> &writer, const SliceConstU32Be &str, bool writeBom = false)
    -> Result<size_t, typename io::Writer<WI>::ErrType> {
    auto runeIter = utf32_rune_iterator(str);
    char32_t rune;
    size_t written = 0;
 
    if (writeBom) {
      if (auto res = writer.write(endian_bom<std::endian::native, char32_t>); res.is_error()) {
        return res.error();
      }
      ++written;
    }
 
    while (runeIter.next().copy_if_present(rune)) {
      if (auto writeRes = writer.write(rune); writeRes.is_error()) {
        return writeRes.error();
      }
      ++written;
    }
    return success(written);
  }
 
}  // namespace mtcore
 
#endif  // MTSTD_ENCODINGS_HPP