either.hpp

Go to the documentation of this file.

 
#ifndef ZEN_EITHER_HPP
#define ZEN_EITHER_HPP
 
#include <condition_variable>
#include <type_traits>
#include <utility>
 
#include "zen/config.hpp"
#include "zen/formatting.hpp"
 
ZEN_NAMESPACE_START
 
struct dummy {};

template<typename L>
struct left_t {
  using storage_t = std::conditional_t<std::is_void_v<L>, dummy, L>;
  storage_t value;
};

template<typename R>
struct right_t {
  using storage_t = std::conditional_t<std::is_void_v<R>, dummy, R>;
  storage_t value;
};

template<typename L, typename R>
class either {
 
  template<typename L2, typename R2>
  friend class either;
 
  using left_storage_t = std::conditional_t<std::is_void_v<L>, dummy, L>;
  using right_storage_t = std::conditional_t<std::is_void_v<R>, dummy, R>;
 
  union {
    left_storage_t left_value;
    right_storage_t right_value;
  };
 
  bool has_right_v;
 
public:

  template<typename L2>
  inline either(left_t<L2>&& value): left_value(std::move(value.value)), has_right_v(false) {};

  template<typename R2>
  inline either(right_t<R2>&& value): right_value(std::move(value.value)), has_right_v(true) {};
 
  either(either &&other): has_right_v(std::move(other.has_right_v)) {
    if (has_right_v) {
      new(&right_value)R(std::move(other.right_value));
    } else {
      new(&left_value)L(std::move(other.left_value));
    }
  }
 
  either(const either &other): has_right_v(other.has_right_v) {
    if (has_right_v) {
      new(&right_value)R(other.right_value);
    } else {
      new(&left_value)L(other.left_value);
    }
  }
 
  template<typename L2, typename R2>
  either(either<L2, R2>&& other): has_right_v(std::move(other.has_right_v)) {
    if (has_right_v) {
      new(&right_value)R(std::move(other.right_value));
    } else {
      new(&left_value)L(std::move(other.left_value));
    }
  }
 
  template<typename L2, typename R2>
  either(const either<L2, R2> &other): has_right_v(other.has_right_v) {
    if (has_right_v) {
      new(&right_value)R(other.right_value);
    } else {
      new(&left_value)L(other.left_value);
    }
  }
 
  either<L, R>& operator=(const either<L, R>& other) {
    if (has_right_v) {
      new(&right_value)R(other.right_value);
    } else {
      new(&left_value)L(other.left_value);
    }
    return *this;
  }
 
  either<L, R>& operator=(either<L, R>&& other) {
    if (has_right_v) {
      new(&right_value)R(std::move(other.right_value));
    } else {
      new(&left_value)L(std::move(other.left_value));
    }
    return *this;
  }
 
  R* operator->() {
    ZEN_ASSERT(has_right_v);
    return &right_value;
  }
 
  template<typename T = R>
  T &operator*() requires (!std::same_as<T, void>) {
    ZEN_ASSERT(has_right_v);
    return right_value;
  }

  bool is_left() const { return !has_right_v; }

  bool is_right() const { return has_right_v; }
 
  operator bool() const {
    return is_right();
  }
 
  R unwrap() requires (has_display<L>) {
    if (!has_right_v) {
      ZEN_PANIC("error: %s", display(left_value).c_str());
    }
    return right_value;
  }
 
  R unwrap() requires (!has_display<L>) {
    if (!has_right_v) {
      ZEN_PANIC("trying to unwrap a zen::either which is left-valued");
    }
    return right_value;
  }
 
  L unwrap_left() {
    if (has_right_v) {
      ZEN_PANIC("trying to unwrap the left side a zen::either which is right-valued");
    }
    return left_value;
  }

  template<typename T = L>
  T &left() requires (!std::same_as<void, T>) {
    ZEN_ASSERT(!has_right_v);
    return left_value;
  }

  template<typename T = R>
  T &right() requires (!std::same_as<T, void>) {
    ZEN_ASSERT(has_right_v);
    return right_value;
  }

  L take_left() && {
    ZEN_ASSERT(!has_right_v);
    return std::move(left_value);
  }

  R take_right() && {
    ZEN_ASSERT(has_right_v);
    return std::move(right_value);
  }
 
  ~either() {
    if (has_right_v) {
      right_value.~right_storage_t();
    } else {
      left_value.~left_storage_t();
    }
  }
 
};

inline left_t<void> left() {
  return left_t<void> {};
}

template<typename L>
left_t<L&> left(L& value) {
  return left_t<L&> { value };
}

template<typename L>
left_t<L> left(L&& value) {
  return left_t<L> { std::move(value) };
}

inline right_t<void> right() {
  return right_t<void> {};
}

template<typename R>
right_t<R&> right(R& value) {
  return right_t<R&> { value };
}

template<typename R>
right_t<R> right(R&& value) {
  return right_t<R> { std::move(value) };
}

#define ZEN_TRY(value) \
  if (value.is_left()) { \
    return ::zen::left(std::move(value).take_left()); \
  }

#define ZEN_TRY_DISCARD(expr) \
  { \
    auto zen__either__result = (expr); \
    if (zen__either__result.is_left()) { \
      return ::zen::left(std::move(zen__either__result.left())); \
    } \
  }
 
ZEN_NAMESPACE_END
 
#endif // ZEN_EITHER_HPP