Optional.h

Go to the documentation of this file.

#ifndef INLCUDE_MOLASSEMBLER_TEMPLE_CONSTEXPR_OPTIONAL_H
#define INLCUDE_MOLASSEMBLER_TEMPLE_CONSTEXPR_OPTIONAL_H

#include "Molassembler/Temple/Preprocessor.h"

#include <utility>

namespace Scine {
namespace Molassembler {
namespace Temple {

template<typename T>
class Optional {
public:

  constexpr Optional() {
    static_assert(
      std::is_same<T, std::decay_t<T>>::value,
      "T must not be a reference or const-qualified type"
    );
  }

  constexpr explicit Optional(T value) : value_(std::move(value)), hasValue_(true) {
    static_assert(
      std::is_same<T, std::decay_t<T>>::value,
      "T must not be a reference or const-qualified type"
    );
  }


  PURITY_WEAK constexpr bool hasValue() const {
    return hasValue_;
  }

  PURITY_WEAK constexpr T value() const {
    return value_;
  }

  template<class UnaryFunction>
  constexpr auto map(UnaryFunction&& function) const {
    // Function has signature T -> U
    using U = decltype(function(value_));

    if(hasValue_) {
      return Optional<U> {
        function(value_)
      };
    }

    return Optional<U> {};
  }

  template<class UnaryFunction>
  constexpr auto flatMap(UnaryFunction&& function) const {
    // Function has signature T -> Optional<U>
    using OptionalU = decltype(function(value_));

    if(hasValue_) {
      return OptionalU {function(value_)};
    }

    return OptionalU {};
  }

  PURITY_WEAK constexpr T valueOr(const T& alternative) const {
    if(hasValue_) {
      return value_;
    }

    return alternative;
  }

  constexpr Optional& operator = (T assignment) {
    value_ = assignment;
    hasValue_ = true;

    return *this;
  }

  PURITY_WEAK constexpr operator bool () const {
    return hasValue_;
  }

  PURITY_WEAK constexpr bool operator == (const Optional& other) const {
    if(!hasValue_ && !other.hasValue_) {
      return true;
    }

    if(hasValue_ && other.hasValue_) {
      return value_ == other.value_;
    }

    return false;
  }

  PURITY_WEAK constexpr bool operator != (const Optional& other) const {
    return !(*this == other);
  }

  PURITY_WEAK constexpr bool operator < (const Optional& other) const {
    // If neither has a value, they are equal
    if(!hasValue_ && !other.hasValue_) {
      return false;
    }

    // If we do not have a value, but the other does, we are smaller
    if(!hasValue_ && other.hasValue_) {
      return true;
    }

    // If we have a value, but the other doesn't, we are bigger
    if(hasValue_ && !other.hasValue_) {
      return false;
    }

    // Remaining case: both have values
    return (
      value_ < other.value_
    );
  }

  PURITY_WEAK constexpr bool operator > (const Optional& other) const {
    return (other < *this);
  }

private:
  T value_ = T {};
  bool hasValue_ = false;
};

template<typename T>
class Optional<T&> {
public:

  constexpr Optional() : ref_(dummy_) {}

  constexpr explicit Optional(T& value) : ref_(value), hasValue_(true) {}


  PURITY_WEAK constexpr bool hasValue() const {
    return hasValue_;
  }

  PURITY_WEAK constexpr T& value() const {
    return ref_;
  }

  template<class UnaryFunction>
  constexpr auto map(UnaryFunction&& function) const {
    // Function has signature T -> U
    using U = decltype(function(ref_));

    if(hasValue_) {
      return Optional<U> {
        function(ref_)
      };
    }

    return Optional<U> {};
  }

  template<class UnaryFunction>
  constexpr auto flatMap(UnaryFunction&& function) const {
    // Function has signature T -> Optional<U>
    using OptionalU = decltype(function(ref_));

    if(hasValue_) {
      return OptionalU {function(ref_)};
    }

    return OptionalU {};
  }

  PURITY_WEAK constexpr T valueOr(const T& alternative) const {
    if(hasValue_) {
      return ref_;
    }

    return alternative;
  }

  PURITY_WEAK constexpr operator bool () const {
    return hasValue_;
  }

  PURITY_WEAK constexpr bool operator == (const Optional& other) const {
    if(!hasValue_ && !other.hasValue_) {
      return true;
    }

    if(hasValue_ && other.hasValue_) {
      return ref_ == other.ref_;
    }

    return false;
  }

  PURITY_WEAK constexpr bool operator != (const Optional& other) const {
    return !(*this == other);
  }

  PURITY_WEAK constexpr bool operator < (const Optional& other) const {
    // If neither has a value, they are equal
    if(!hasValue_ && !other.hasValue_) {
      return false;
    }

    // If we do not have a value, but the other does, we are smaller
    if(!hasValue_ && other.hasValue_) {
      return true;
    }

    // If we have a value, but the other doesn't, we are bigger
    if(hasValue_ && !other.hasValue_) {
      return false;
    }

    // Remaining case: both have values
    return (
      ref_ < other.ref_
    );
  }

  PURITY_WEAK constexpr bool operator > (const Optional& other) const {
    return (other < *this);
  }

private:
  T dummy_ = T{};
  T& ref_;
  bool hasValue_ = false;
};

} // namespace Temple
} // namespace Molassembler
} // namespace Scine

#endif