Optional.hpp

Go to the documentation of this file.

// ======================================================================
// \title  Optional.hpp
// \author celskeggs
// \brief  hpp file for Optional type
//
// \description
//   A lightweight optional type for C++14 environments where
//   std::optional (C++17) is not available.
//
// \copyright
// Copyright (C) 2025-2026 California Institute of Technology.
// ALL RIGHTS RESERVED.  United States Government Sponsorship
// acknowledged.
//
// ======================================================================

#ifndef Fw_Optional_HPP
#define Fw_Optional_HPP

#include <Fw/Types/Assert.hpp>
#include <type_traits>

namespace Fw {

struct None_t {
    constexpr explicit None_t() {}
};

constexpr None_t NONE = None_t();

template <typename T>
class Optional {
    static_assert(std::is_trivially_copyable<T>::value, "Fw::Optional only supports trivially copyable types");

    T m_val;
    bool m_engaged;

  public:
    // ----------------------------------------------------------------------
    // Construction
    // ----------------------------------------------------------------------

    constexpr Optional() : m_val(), m_engaged(false) {}

    constexpr Optional(const None_t& a) : Optional() { (void)a; }

    constexpr Optional(const T& t) : m_val(t), m_engaged(true) {}

    Optional(const Optional& other) : Optional() {
        if (other.has_value()) {
            *this = other.value();
        }
    }

    ~Optional() = default;

    // ----------------------------------------------------------------------
    // Observers
    // ----------------------------------------------------------------------

    bool has_value() const { return m_engaged; }

    T& value() {
        FW_ASSERT(m_engaged);
        return m_val;
    }

    const T& value() const {
        FW_ASSERT(m_engaged);
        return m_val;
    }

    T value_or(const T& default_value) const { return m_engaged ? m_val : default_value; }

    // ----------------------------------------------------------------------
    // Modifiers
    // ----------------------------------------------------------------------

    void reset() { m_engaged = false; }

    // ----------------------------------------------------------------------
    // Assignment operators
    // ----------------------------------------------------------------------

    Optional& operator=(const T& t) {
        m_engaged = true;
        m_val = t;
        return *this;
    }

    Optional& operator=(const None_t& a) {
        (void)a;
        reset();
        return *this;
    }

    Optional& operator=(const Optional& other) {
        if (other.has_value()) {
            *this = other.value();
        } else {
            reset();
        }
        return *this;
    }

    // ----------------------------------------------------------------------
    // Comparison operators
    // ----------------------------------------------------------------------

    bool operator==(const None_t& a) const {
        (void)a;
        return !m_engaged;
    }

    bool operator!=(const None_t& a) const {
        (void)a;
        return m_engaged;
    }

    bool operator==(const Optional& other) const {
        if (m_engaged != other.m_engaged) {
            return false;
        }
        if (!m_engaged) {
            return true;
        }
        return m_val == other.m_val;
    }

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

}  // namespace Fw

#endif