optional.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 MTCORE_OPTIONAL_HPP
#define MTCORE_OPTIONAL_HPP
 
#include "../core.hpp"
#include "../traits.hpp"
 
#include <memory>
#include <ostream>
#include <variant>
 
namespace mtcore {

  template<typename T>
  struct Optional;

  template<typename T>
  struct Optional<T *> {
  private:
    T *v;
 
  public:
    Optional() : v(nullptr) {}

    Optional(T *value) : v(value) {}

    bool operator==(const Optional &other) const noexcept {
      if (v == nullptr) {
        return other.v == nullptr;
      }
      if (other.v == nullptr) {
        return false;
      }
 
      ensure(v && other.v, "EXISTS CHECK FAILED");
      return v == other.v;
    }

    [[nodiscard]] bool has_value() const noexcept { return v != nullptr; }

    [[nodiscard]] T value_or(const T &def) const noexcept {
      if (has_value()) {
        return value();
      }
      return def;
    }
 
    [[nodiscard]] T &value() noexcept {
      ensure(has_value(), "CANNOT GET VALUE WHEN OPTIONAL IS EMPTY");
      return *v;
    }
 
    [[nodiscard]] const T &value() const noexcept {
      ensure(has_value(), "CANNOT GET VALUE WHEN OPTIONAL IS EMPTY");
      return *v;
    }

    [[nodiscard]] bool copy_if_present(T *&out) const noexcept {
      if (has_value()) {
        out = v;
      }
      return has_value();
    }

    [[nodiscard]] bool copy_if_present(std::remove_const_t<T> &out) const noexcept {
      if (has_value()) {
        out = *v;
      }
      return has_value();
    }

    [[nodiscard]] bool move_if_present(std::remove_const_t<T> *&out) noexcept {
      mtdefer { v = nullptr; };
      if (has_value()) {
        out = std::move(v);
        return true;
      }
      return false;
    }

    [[nodiscard]] bool move_if_present(std::remove_const_t<T> &out) noexcept {
      if (has_value()) {
        out = std::move(*v);
      }
      mtdefer { v = nullptr; };
      return has_value();
    }

    const T &operator*() const {
      ensure(has_value(), "CANNNOT DERERFERENCE NULL OPTIONAL");
      return *v;
    }

    const T *operator->() const {
      ensure(has_value(), "CANNNOT DERERFERENCE NULL OPTIONAL");
      return v;
    }

    T &operator*() {
      ensure(has_value(), "CANNNOT DERERFERENCE NULL OPTIONAL");
      return *v;
    }

    T *operator->() {
      ensure(has_value(), "CANNNOT DERERFERENCE NULL OPTIONAL");
      return v;
    }
  };
 
  template<typename T>
  struct Optional {
  private:
    std::variant<std::monostate, T> v;
 
  public:
    Optional() : v(std::monostate{}) { ensure(!has_value()); }

    Optional(const T &value) : v(value) {}

    Optional(T &&value) : v(std::forward<T>(value)) {}

    bool operator==(const Optional &other) const noexcept {
      if (has_value() != other.has_value()) {
        return false;
      }
      if (!has_value()) {
        return true;
      }
 
      ensure(has_value() && other.has_value(), "EXISTS CHECK FAILED");
      return std::get<T>(v) == std::get<T>(other.v);
    }

    bool operator==(const T &other) const noexcept {
      if (!has_value()) {
        return false;
      }
      return std::get<T>(v) == other;
    }

    [[nodiscard]] T value_or(const T &def) const noexcept {
      if (has_value()) {
        return value();
      }
      return def;
    }

    [[nodiscard]] bool has_value() const noexcept { return std::holds_alternative<T>(v); }

    [[nodiscard]] bool empty() const noexcept { return std::holds_alternative<std::monostate>(v); }
 
    [[nodiscard]] T &value() noexcept {
      ensure(has_value(), "CANNOT GET VALUE WHEN OPTIONAL IS EMPTY");
      return std::get<T>(v);
    }
 
    [[nodiscard]] const T &value() const noexcept {
      ensure(has_value(), "CANNOT GET VALUE WHEN OPTIONAL IS EMPTY");
      return std::get<T>(v);
    }

    [[nodiscard]] bool copy_if_present(std::remove_const_t<T> &out) const noexcept {
      if (has_value()) {
        out = std::get<T>(v);
        return true;
      }
      return false;
    }

    [[nodiscard]] bool move_if_present(T &out) noexcept {
      if (has_value()) {
        out = std::move(std::get<T>(v));
        v   = std::monostate{};
        return true;
      }
      return false;
    }

    const T &operator*() const {
      ensure(has_value(), "CANNNOT DERERFERENCE NULL OPTIONAL");
      return std::get<T>(v);
    }

    const T *operator->() const {
      ensure(has_value(), "CANNNOT DERERFERENCE NULL OPTIONAL");
      return &std::get<T>(v);
    }

    T &operator*() {
      ensure(has_value(), "CANNNOT DERERFERENCE NULL OPTIONAL");
      return std::get<T>(v);
    }

    T *operator->() {
      ensure(has_value(), "CANNNOT DERERFERENCE NULL OPTIONAL");
      return &std::get<T>(v);
    }
  };

  struct Nullopt {
    template<typename T>
    operator Optional<T>() const {
      return Optional<T>{};
    }
  };

  constexpr auto nullopt = Nullopt{};
}  // namespace mtcore
 
 
#endif  // MTCORE_OPTIONAL_HPP