optional_ref.hpp

Go to the documentation of this file.

//    OpenVPN -- An application to securely tunnel IP networks
//               over a single port, with support for SSL/TLS-based
//               session authentication and key exchange,
//               packet encryption, packet authentication, and
//               packet compression.
//
//    Copyright (C) 2024- OpenVPN Inc.
//
//    This program is free software: you can redistribute it and/or modify
//    it under the terms of the GNU Affero General Public License Version 3
//    as published by the Free Software Foundation.
//
//    This program is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU Affero General Public License for more details.
//
//    You should have received a copy of the GNU Affero General Public License
//    along with this program in the COPYING file.
//    If not, see <http://www.gnu.org/licenses/>.
 
#pragma once
 
#include <optional> // std::nullopt_t
#include <stdexcept>
#include <type_traits>
 
namespace openvpn {
 
template <typename T>
    requires std::is_reference_v<T>
class optional
{
    using value_type = std::remove_reference_t<T>;
    value_type *mRef = nullptr;
    static constexpr char errorMsg[] = "optional<T &>: access error";
 
  public:
    constexpr optional() noexcept = default;
 
    constexpr optional(std::nullopt_t noOption) noexcept;
 
    constexpr optional(T r) noexcept;
 
    constexpr optional(value_type *r) noexcept;
 
    constexpr optional(const optional &) noexcept = default;
 
    constexpr optional(optional &&) noexcept = default;
 
    optional &operator=(const optional &) noexcept = default;
 
    optional &operator=(optional &&) noexcept = default;
 
    optional &operator=(std::nullopt_t noOption) noexcept;
 
    void reset() noexcept;
 
    [[nodiscard]] constexpr bool has_value() const noexcept;
 
    [[nodiscard]] constexpr explicit operator bool() const noexcept;
 
    constexpr value_type value() const;
 
    constexpr value_type value_or(const value_type &default_value) const noexcept;
 
    const T operator*() const;
 
    T operator*();
 
    const value_type *operator->() const;
 
    value_type *operator->();
};
 
// Implementations below
 
template <typename T>
    requires std::is_reference_v<T>
inline constexpr optional<T>::optional(std::nullopt_t) noexcept
    : optional()
{
}
 
template <typename T>
    requires std::is_reference_v<T>
inline constexpr optional<T>::optional(T r) noexcept
    : mRef(&r)
{
}
 
template <typename T>
    requires std::is_reference_v<T>
inline constexpr optional<T>::optional(value_type *r) noexcept
    : mRef(r)
{
}
 
template <typename T>
    requires std::is_reference_v<T>
inline optional<T> &optional<T>::operator=(std::nullopt_t) noexcept
{
    reset();
    return *this;
}
 
template <typename T>
    requires std::is_reference_v<T>
inline void optional<T>::reset() noexcept
{
    mRef = nullptr;
}
 
template <typename T>
    requires std::is_reference_v<T>
inline constexpr bool optional<T>::has_value() const noexcept
{
    return mRef != nullptr;
}
 
template <typename T>
    requires std::is_reference_v<T>
inline constexpr optional<T>::operator bool() const noexcept
{
    return has_value();
}
 
template <typename T>
    requires std::is_reference_v<T>
inline constexpr auto optional<T>::value() const -> value_type
{
    if (!bool(*this))
        throw std::runtime_error(errorMsg);
    return *mRef;
}
 
template <typename T>
    requires std::is_reference_v<T>
inline constexpr auto optional<T>::value_or(const value_type &default_value) const noexcept -> value_type
{
    return bool(*this) ? *mRef : default_value;
}
 
template <typename T>
    requires std::is_reference_v<T>
inline const T optional<T>::operator*() const
{
    if (!bool(*this))
        throw std::runtime_error(errorMsg);
    return *mRef;
}
 
template <typename T>
    requires std::is_reference_v<T>
inline T optional<T>::operator*()
{
    return const_cast<T &>(*(std::as_const(*this)));
}
 
template <typename T>
    requires std::is_reference_v<T>
inline auto optional<T>::operator->() const -> const value_type *
{
    if (!bool(*this))
        throw std::runtime_error(errorMsg);
    return mRef;
}
 
template <typename T>
    requires std::is_reference_v<T>
inline auto optional<T>::operator->() -> value_type *
{
    return const_cast<value_type *>(std::as_const(*this).operator->());
}
 
} // namespace openvpn