colls/slice.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.
 
*/
 
#pragma once
 
#ifndef MTCORE_SLICE_HPP
#define MTCORE_SLICE_HPP
 
#include "../core.hpp"
#include "../traits.hpp"
#include "iter.hpp"
#include "optional.hpp"
#include <string>
#include <vector>
 
namespace mtcore {
  template<class T>
  struct Slice {
    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;
    }

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

    T &operator[](size_t i) noexcept {
      ensure(i < len, "SLICE ACCESS OUT OF BOUNDS");
      ensure(head, "NULL POINTER DEREFERENCE");
      return head[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]] constexpr size_t size() const noexcept { return head != nullptr ? len : 0; }

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

    [[nodiscard]] constexpr Slice sub_rng(size_t start, size_t end) const noexcept {
      if (start >= end || start >= len) {
        Slice res;
        res.init(nullptr, 0);
        return res;
      }
      return sub(start, end - start);
    }

    [[nodiscard]] constexpr Slice sub(size_t start) const noexcept {
      Slice 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 Slice 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;
    }

    std::strong_ordering operator<=>(const Slice<std::remove_const_t<T>> &other) const noexcept {
      return *this <=> other.to_const();
    }

    std::strong_ordering operator<=>(const Slice<std::add_const_t<T>> &other) const noexcept {
      if (empty() && other.empty()) {
        return std::strong_ordering::equal;
      }
 
      if (empty()) {
        return std::strong_ordering::less;
      }
 
      if (other.empty()) {
        return std::strong_ordering::greater;
      }
 
      for (size_t i = 0; i < len && i < other.len; ++i) {
        if (head[i] > other.head[i]) {
          return std::strong_ordering::greater;
        }
        if (head[i] < other.head[i]) {
          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;
      }
    }
 
    bool operator==(const Slice<std::remove_const_t<T>> &o) const noexcept {
      return (*this <=> o) == std::strong_ordering::equal;
    }
 
    bool operator!=(const Slice<std::remove_const_t<T>> &o) const noexcept {
      return (*this <=> o) != std::strong_ordering::equal;
    }
 
    bool operator<(const Slice<std::remove_const_t<T>> &o) const noexcept {
      return (*this <=> o) == std::strong_ordering::less;
    }
 
    bool operator>(const Slice<std::remove_const_t<T>> &o) const noexcept {
      return (*this <=> o) == std::strong_ordering::greater;
    }
 
    bool operator<=(const Slice<std::remove_const_t<T>> &o) const noexcept {
      const auto cmp = *this <=> o;
      return (cmp == std::strong_ordering::less || cmp == std::strong_ordering::equal);
    }
 
    bool operator>=(const Slice<std::remove_const_t<T>> &o) const noexcept {
      const auto cmp = *this <=> o;
      return (cmp == std::strong_ordering::greater || cmp == std::strong_ordering::equal);
    }
 
    bool operator==(const Slice<std::add_const_t<T>> &o) const noexcept {
      return (*this <=> o) == std::strong_ordering::equal;
    }
 
    bool operator!=(const Slice<std::add_const_t<T>> &o) const noexcept {
      return (*this <=> o) != std::strong_ordering::equal;
    }
 
    bool operator<(const Slice<std::add_const_t<T>> &o) const noexcept {
      return (*this <=> o) == std::strong_ordering::less;
    }
 
    bool operator>(const Slice<std::add_const_t<T>> &o) const noexcept {
      return (*this <=> o) == std::strong_ordering::greater;
    }
 
    bool operator<=(const Slice<std::add_const_t<T>> &o) const noexcept {
      const auto cmp = *this <=> o;
      return (cmp == std::strong_ordering::less || cmp == std::strong_ordering::equal);
    }
 
    bool operator>=(const Slice<std::add_const_t<T>> &o) const noexcept {
      const auto cmp = *this <=> o;
      return (cmp == std::strong_ordering::greater || cmp == std::strong_ordering::equal);
    }
  };

  [[nodiscard]] constexpr Slice<char32_t> mut_slice_from(char32_t *cstr, size_t len) {
    return Slice<char32_t>{(cstr), len};
  }

  [[nodiscard]] constexpr Slice<char32_t> mut_slice_from(char32_t *cstr) {
    if (!cstr) {
      return Slice<char32_t>{(cstr), 0};
    }
    size_t len = 0;
    for (; cstr[len]; ++len) {}
    return Slice<char32_t>{(cstr), len};
  }

  [[nodiscard]] constexpr Slice<const char32_t> slice_from(char32_t *cstr) {
    if (!cstr) {
      return Slice<const char32_t>{static_cast<const char32_t *>(cstr), 0};
    }
    size_t len = 0;
    for (; cstr[len]; ++len) {}
    return Slice<const char32_t>{static_cast<const char32_t *>(cstr), len};
  }

  [[nodiscard]] constexpr Slice<const char32_t> slice_from(char32_t *cstr, size_t len) {
    return Slice<const char32_t>{static_cast<const char32_t *>(cstr), len};
  }

  [[nodiscard]] constexpr Slice<const char32_t> slice_from(const char32_t *cstr, size_t len) {
    return Slice<const char32_t>{cstr, len};
  }

  [[nodiscard]] constexpr Slice<const char32_t> slice_from(const char32_t *cstr) {
    if (!cstr) {
      return Slice<const char32_t>{cstr, 0};
    }
    size_t len = 0;
    for (; cstr[len]; ++len) {}
    return Slice<const char32_t>{cstr, len};
  }

  [[nodiscard]] constexpr Slice<char16_t> mut_slice_from(char16_t *cstr, size_t len) {
    return Slice<char16_t>{cstr, len};
  }

  [[nodiscard]] constexpr Slice<const char16_t> slice_from(char16_t *cstr, size_t len) {
    return Slice<const char16_t>{static_cast<const char16_t *>(cstr), len};
  }

  [[nodiscard]] constexpr Slice<const char16_t> slice_from(const char16_t *cstr, size_t len) {
    return Slice<const char16_t>{cstr, len};
  }

  [[nodiscard]] constexpr Slice<char8_t> mut_slice_from(char8_t *cstr, size_t len) { return Slice<char8_t>{cstr, len}; }

  [[nodiscard]] constexpr Slice<const char8_t> slice_from(char8_t *cstr, size_t len) {
    return Slice<const char8_t>{static_cast<const char8_t *>(cstr), len};
  }

  [[nodiscard]] constexpr Slice<const char8_t> slice_from(const char8_t *cstr, size_t len) {
    return Slice<const char8_t>{cstr, len};
  }

  [[nodiscard]] constexpr Slice<char16_t> mut_slice_from(char16_t *cstr) {
    if (!cstr) {
      return Slice<char16_t>{(cstr), 0};
    }
    size_t len = 0;
    for (; cstr[len]; ++len) {}
    return Slice<char16_t>{(cstr), len};
  }

  [[nodiscard]] constexpr Slice<const char16_t> slice_from(char16_t *cstr) {
    if (!cstr) {
      return Slice<const char16_t>{static_cast<const char16_t *>(cstr), 0};
    }
    size_t len = 0;
    for (; cstr[len]; ++len) {}
    return Slice<const char16_t>{static_cast<const char16_t *>(cstr), len};
  }

  [[nodiscard]] constexpr Slice<const char16_t> slice_from(const char16_t *cstr) {
    if (!cstr) {
      return Slice<const char16_t>{cstr, 0};
    }
    size_t len = 0;
    for (; cstr[len]; ++len) {}
    return Slice<const char16_t>{cstr, len};
  }

  [[nodiscard]] constexpr Slice<char8_t> mut_slice_from(char8_t *cstr) {
    if (!cstr) {
      return Slice<char8_t>{(cstr), 0};
    }
    size_t len = 0;
    for (; cstr[len]; ++len) {}
    return Slice<char8_t>{(cstr), len};
  }

  [[nodiscard]] constexpr Slice<const char8_t> slice_from(char8_t *cstr) {
    if (!cstr) {
      return Slice<const char8_t>{static_cast<const char8_t *>(cstr), 0};
    }
    size_t len = 0;
    for (; cstr[len]; ++len) {}
    return Slice<const char8_t>{static_cast<const char8_t *>(cstr), len};
  }

  [[nodiscard]] constexpr Slice<const char8_t> slice_from(const char8_t *cstr) {
    if (!cstr) {
      return Slice<const char8_t>{cstr, 0};
    }
    size_t len = 0;
    for (; cstr[len]; ++len) {}
    return Slice<const char8_t>{cstr, len};
  }

  [[nodiscard]] constexpr Slice<const char> slice_from(char *cstr) {
    if (!cstr) {
      return Slice<const char>{static_cast<const char *>(cstr), 0};
    }
    size_t len = 0;
    for (; cstr[len]; ++len) {}
    return Slice<const char>{static_cast<const char *>(cstr), len};
  }

  [[nodiscard]] constexpr Slice<const char> slice_from(const char *cstr) {
    if (!cstr) {
      return Slice<const char>{cstr, 0};
    }
    size_t len = 0;
    for (; cstr[len]; ++len) {}
    return Slice<const char>{cstr, len};
  }

  [[nodiscard]] constexpr Slice<const char> slice_from(char *cstr, const size_t len) {
    return Slice<const char>{static_cast<const char *>(cstr), len};
  }

  [[nodiscard]] constexpr Slice<char> mut_slice_from(char *cstr, const size_t len) { return Slice<char>{cstr, len}; }

  [[nodiscard]] constexpr Slice<const char> slice_from(const char *cstr, const size_t len) {
    return Slice<const char>{cstr, len};
  }

  [[nodiscard]] inline Slice<const char> slice_from(const std::string &str) {
    return Slice<const char>{str.c_str(), str.size()};
  }

  [[nodiscard]] constexpr Slice<const char> slice_from(const std::string_view &sv) {
    return Slice<const char>{&sv[0], sv.size()};
  }

  template<typename T>
  [[nodiscard]] Slice<std::add_const_t<T>> slice_from(const std::vector<T> &arr) {
    return Slice<std::add_const<T>>{static_cast<std::add_pointer_t<std::add_const_t<T>>>(arr.data()), arr.size()};
  }

  template<typename T>
  [[nodiscard]] Slice<T> mut_slice_from(std::vector<T> &arr) {
    return Slice<T>{arr.data(), arr.size()};
  }

  template<typename T, size_t N>
  [[nodiscard]] constexpr Slice<std::add_const_t<T>> slice_from(const std::array<T, N> &arr) {
    return Slice<std::add_const_t<T>>{static_cast<std::add_pointer_t<std::add_const_t<T>>>(arr.data()), arr.size()};
  }

  template<typename T, size_t N>
  [[nodiscard]] constexpr Slice<T> mut_slice_from(std::array<T, N> &arr) {
    return Slice<T>{arr.data(), arr.size()};
  }

  [[nodiscard]] inline Slice<char> mut_slice_from(char *cstr) {
    if (!cstr) {
      return Slice<char>{cstr, 0};
    }
    size_t len = 0;
    for (; cstr[len]; ++len) {}
    return Slice<char>{cstr, len};
  }

  [[nodiscard]] inline Slice<char> mut_slice_from(std::string &str) { return Slice<char>{str.data(), str.size()}; }

  template<typename Left, typename Right>
  std::strong_ordering str_compare(const Left &left, const Right &right) {
    using L = std::decay_t<std::remove_cv_t<Left>>;
    using R = std::decay_t<std::remove_cv_t<Right>>;
    static_assert(std::same_as<Slice<char>, L> || std::same_as<Slice<const char>, L> || std::same_as<std::string, L> ||
                  std::same_as<std::string_view, L> || std::same_as<char *, L> || std::same_as<const char *, L>);
    static_assert(std::same_as<Slice<char>, R> || std::same_as<Slice<const char>, R> || std::same_as<std::string, R> ||
                  std::same_as<std::string_view, R> || std::same_as<char *, R> || std::same_as<const char *, R>);
 
    Slice<const char> leftSlice;
    if constexpr (std::is_same_v<Slice<const char>, L>) {
      leftSlice = left;
    }
    else if constexpr (std::is_same_v<Slice<char>, L>) {
      leftSlice = left.to_const();
    }
    else {
      leftSlice = slice_from(left);
    }
 
    Slice<const char> rightSlice;
    if constexpr (std::is_same_v<Slice<const char>, R>) {
      rightSlice = right;
    }
    else if constexpr (std::is_same_v<Slice<char>, R>) {
      rightSlice = right.to_const();
    }
    else {
      rightSlice = slice_from(right);
    }
 
    return leftSlice <=> rightSlice;
  }

  template<typename L, typename R>
  bool str_equal(const L &left, const R &right) {
    return str_compare(left, right) == std::strong_ordering::equal;
  }
}  // namespace mtcore
 
#endif  // MTCORE_SLICE_HPP