ah-cpp-compat.H

Go to the documentation of this file.

 
/*
                          Aleph_w
 
  Data structures & Algorithms
  version 5.1.0
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
#ifndef ALEPH_CPP_COMPAT_H
#define ALEPH_CPP_COMPAT_H
 
#include <exception>
#include <functional>
#include <memory>
#include <new>
#include <type_traits>
#include <utility>
 
#if __has_include(<version>)
#  include <version>  // library feature-test macros (__cpp_lib_*)
#endif
 
// ---------------------------------------------------------------------------
// Feature detection for selected C++23 library facilities.
// ---------------------------------------------------------------------------
 
#if defined(__cpp_lib_expected) && __cpp_lib_expected >= 202211L
#  define ALEPH_HAS_STD_EXPECTED 1
#else
#  define ALEPH_HAS_STD_EXPECTED 0
#endif
 
#if defined(__cpp_lib_generator) && __cpp_lib_generator >= 202207L
#  define ALEPH_HAS_STD_GENERATOR 1
#else
#  define ALEPH_HAS_STD_GENERATOR 0
#endif
 
#if defined(__cpp_lib_flat_map) && __cpp_lib_flat_map >= 202207L
#  define ALEPH_HAS_STD_FLAT_MAP 1
#else
#  define ALEPH_HAS_STD_FLAT_MAP 0
#endif
 
#if defined(__cpp_lib_mdspan) && __cpp_lib_mdspan >= 202207L
#  define ALEPH_HAS_STD_MDSPAN 1
#else
#  define ALEPH_HAS_STD_MDSPAN 0
#endif
 
// ---------------------------------------------------------------------------
// Aleph::expected
// ---------------------------------------------------------------------------
 
#if ALEPH_HAS_STD_EXPECTED
 
#include <expected>
 
namespace Aleph {
template <class T, class E> using expected = std::expected<T, E>;
template <class E> using unexpected = std::unexpected<E>;
template <class E> using bad_expected_access = std::bad_expected_access<E>;
using std::unexpect;
using std::unexpect_t;
}  // namespace Aleph
 
#else  // ----- C++20 / C++17 polyfill ---------------------------------------
 
namespace Aleph {
 
namespace cpp_compat_detail {
template <class U>
using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<U>>;
}  // namespace cpp_compat_detail
 
struct unexpect_t
{
  explicit unexpect_t() = default;
};
 
inline constexpr unexpect_t unexpect{};
 
template <class E>
class unexpected
{
  E err_;
 
public:
  template <class Err = E>
    requires (not std::is_same_v<std::remove_cvref_t<Err>, unexpected> and
              std::is_constructible_v<E, Err>)
  constexpr explicit unexpected(Err &&e)
    noexcept(std::is_nothrow_constructible_v<E, Err>)
    : err_(std::forward<Err>(e)) {}
 
  constexpr const E &error() const & noexcept { return err_; }
 
  constexpr E &error() & noexcept { return err_; }
 
  constexpr E &&error() && noexcept { return std::move(err_); }
};
 
template <class E>
unexpected(E) -> unexpected<E>;
 
template <class E>
class bad_expected_access : public std::exception
{
  E err_;
 
public:
  explicit bad_expected_access(E e) : err_(std::move(e)) {}
 
  [[nodiscard]] const char *what() const noexcept override
  {
    return "Aleph::bad_expected_access: expected holds an error, not a value";
  }
 
  [[nodiscard]] const E &error() const & noexcept { return err_; }
 
  [[nodiscard]] E &error() & noexcept { return err_; }
};
 
template <class T, class E>
class expected
{
  static_assert(not std::is_same_v<std::remove_cv_t<T>, unexpect_t>,
                "T must not be unexpect_t");
 
  union
  {
    T val_;
    E err_;
  };
  bool has_;
 
  void destroy() noexcept
  {
    if (has_)
      val_.~T();
    else
      err_.~E();
  }
 
public:
  using value_type = T;
  using error_type = E;
  using unexpected_type = unexpected<E>;
 
  constexpr expected() : val_(), has_(true) {}
 
  template <class U = T,
            class = std::enable_if_t<
                std::is_constructible_v<T, U &&> and
                not std::is_same_v<cpp_compat_detail::remove_cvref_t<U>, expected> and
                not std::is_same_v<cpp_compat_detail::remove_cvref_t<U>, unexpect_t>>>
  constexpr expected(U &&v) : val_(std::forward<U>(v)), has_(true)
  {
  }
 
  template <class G>
  constexpr expected(const unexpected<G> &u) : err_(u.error()), has_(false)
  {
  }
 
  template <class G>
  constexpr expected(unexpected<G> &&u)
    : err_(std::move(u).error()), has_(false)
  {
  }
 
  template <class... Args>
  constexpr explicit expected(unexpect_t, Args &&...args)
    : err_(std::forward<Args>(args)...), has_(false)
  {
  }
 
  expected(const expected &o) : has_(o.has_)
  {
    if (has_)
      ::new (static_cast<void *>(std::addressof(val_))) T(o.val_);
    else
      ::new (static_cast<void *>(std::addressof(err_))) E(o.err_);
  }
 
  expected(expected &&o) noexcept(std::is_nothrow_move_constructible_v<T> and
                                  std::is_nothrow_move_constructible_v<E>)
    : has_(o.has_)
  {
    if (has_)
      ::new (static_cast<void *>(std::addressof(val_))) T(std::move(o.val_));
    else
      ::new (static_cast<void *>(std::addressof(err_))) E(std::move(o.err_));
  }
 
  expected &operator=(const expected &o)
  {
    if (this != std::addressof(o))
      {
        expected tmp(o);
        destroy();
        has_ = tmp.has_;
        if (has_)
          ::new (static_cast<void *>(std::addressof(val_))) T(std::move(tmp.val_));
        else
          ::new (static_cast<void *>(std::addressof(err_))) E(std::move(tmp.err_));
      }
    return *this;
  }
 
  expected &operator=(expected &&o) noexcept(
      std::is_nothrow_move_constructible_v<T> and
      std::is_nothrow_move_constructible_v<E>)
  {
    if (this != std::addressof(o))
      {
        expected tmp(std::move(o));
        destroy();
        has_ = tmp.has_;
        if (has_)
          ::new (static_cast<void *>(std::addressof(val_))) T(std::move(tmp.val_));
        else
          ::new (static_cast<void *>(std::addressof(err_))) E(std::move(tmp.err_));
      }
    return *this;
  }
 
  ~expected() { destroy(); }
 
  // -- observers ----------------------------------------------------------
 
  [[nodiscard]] constexpr bool has_value() const noexcept { return has_; }
 
  [[nodiscard]] constexpr explicit operator bool() const noexcept { return has_; }
 
  [[nodiscard]] constexpr const T &operator*() const & noexcept { return val_; }
 
  [[nodiscard]] constexpr T &operator*() & noexcept { return val_; }
 
  [[nodiscard]] constexpr const T *operator->() const noexcept
  {
    return std::addressof(val_);
  }
 
  [[nodiscard]] constexpr T *operator->() noexcept
  {
    return std::addressof(val_);
  }
 
  [[nodiscard]] constexpr const T &value() const &
  {
    if (not has_)
      throw bad_expected_access<E>(err_);
    return val_;
  }
 
  [[nodiscard]] constexpr T &value() &
  {
    if (not has_)
      throw bad_expected_access<E>(err_);
    return val_;
  }
 
  [[nodiscard]] constexpr const E &error() const & noexcept { return err_; }
 
  [[nodiscard]] constexpr E &error() & noexcept { return err_; }
 
  template <class U>
  [[nodiscard]] constexpr T value_or(U &&default_value) const &
  {
    return has_ ? val_ : static_cast<T>(std::forward<U>(default_value));
  }
 
  // -- monadic operations -------------------------------------------------
 
  template <class F>
  [[nodiscard]] auto and_then(F &&f) const &
  {
    using R = cpp_compat_detail::remove_cvref_t<std::invoke_result_t<F, const T &>>;
    if (has_)
      return std::invoke(std::forward<F>(f), val_);
    return R(unexpected<E>(err_));
  }
 
  template <class F>
  [[nodiscard]] auto transform(F &&f) const &
  {
    using U = cpp_compat_detail::remove_cvref_t<std::invoke_result_t<F, const T &>>;
    using R = expected<U, E>;
    if (has_)
      return R(std::invoke(std::forward<F>(f), val_));
    return R(unexpected<E>(err_));
  }
 
  template <class F>
  [[nodiscard]] auto or_else(F &&f) const &
  {
    using R = cpp_compat_detail::remove_cvref_t<std::invoke_result_t<F, const E &>>;
    if (has_)
      return R(val_);
    return std::invoke(std::forward<F>(f), err_);
  }
};
 
template <class E>
class expected<void, E>
{
  union
  {
    E err_;
  };
  bool has_;
 
  void destroy() noexcept
  {
    if (not has_)
      err_.~E();
  }
 
public:
  using value_type = void;
  using error_type = E;
  using unexpected_type = unexpected<E>;
 
  constexpr expected() noexcept : has_(true) {}
 
  template <class G>
  constexpr expected(const unexpected<G> &u) : err_(u.error()), has_(false)
  {
  }
 
  template <class G>
  constexpr expected(unexpected<G> &&u)
    : err_(std::move(u).error()), has_(false)
  {
  }
 
  template <class... Args>
  constexpr explicit expected(unexpect_t, Args &&...args)
    : err_(std::forward<Args>(args)...), has_(false)
  {
  }
 
  expected(const expected &o) : has_(o.has_)
  {
    if (not has_)
      ::new (static_cast<void *>(std::addressof(err_))) E(o.err_);
  }
 
  expected(expected &&o) noexcept(std::is_nothrow_move_constructible_v<E>)
    : has_(o.has_)
  {
    if (not has_)
      ::new (static_cast<void *>(std::addressof(err_))) E(std::move(o.err_));
  }
 
  expected &operator=(const expected &o)
  {
    if (this != std::addressof(o))
      {
        expected tmp(o);
        destroy();
        has_ = tmp.has_;
        if (not has_)
          ::new (static_cast<void *>(std::addressof(err_))) E(std::move(tmp.err_));
      }
    return *this;
  }
 
  expected &operator=(expected &&o) noexcept(
      std::is_nothrow_move_constructible_v<E>)
  {
    if (this != std::addressof(o))
      {
        expected tmp(std::move(o));
        destroy();
        has_ = tmp.has_;
        if (not has_)
          ::new (static_cast<void *>(std::addressof(err_))) E(std::move(tmp.err_));
      }
    return *this;
  }
 
  ~expected() { destroy(); }
 
  [[nodiscard]] constexpr bool has_value() const noexcept { return has_; }
  [[nodiscard]] constexpr explicit operator bool() const noexcept { return has_; }
 
  constexpr void value() const
  {
    if (not has_)
      throw bad_expected_access<E>(err_);
  }
 
  [[nodiscard]] constexpr const E &error() const & noexcept { return err_; }
  [[nodiscard]] constexpr E &error() & noexcept { return err_; }
 
  template <class F>
  [[nodiscard]] auto and_then(F &&f) const
  {
    using R = cpp_compat_detail::remove_cvref_t<std::invoke_result_t<F>>;
    if (has_)
      return std::invoke(std::forward<F>(f));
    return R(unexpected<E>(err_));
  }
 
  template <class F>
  [[nodiscard]] auto or_else(F &&f) const
  {
    using R = cpp_compat_detail::remove_cvref_t<std::invoke_result_t<F, const E &>>;
    if (has_)
      return R();
    return std::invoke(std::forward<F>(f), err_);
  }
};
 
}  // namespace Aleph
 
#endif  // ALEPH_HAS_STD_EXPECTED
 
#endif  // ALEPH_CPP_COMPAT_H