default_value.hpp

Go to the documentation of this file.

 
#ifndef PLSSVM_DEFAULT_VALUE_HPP_
#define PLSSVM_DEFAULT_VALUE_HPP_
#pragma once
 
#include "plssvm/detail/type_traits.hpp"  // PLSSVM_REQUIRES
 
#include <cstddef>      // std::size_t
#include <functional>   // std::hash
#include <istream>      // std::istream
#include <ostream>      // std::ostream
#include <type_traits>  // std::is_nothrow_default_constructible_v, std::is_nothrow_move_constructible_v, std::is_nothrow_move_assignable_v, std::is_nothrow_swappable_v,
                        // std::is_convertible_v, std::true_type, std::false_type, std::remove_reference_t, std::remove_cv_t
#include <utility>      // std::move_if_noexcept, std::swap
 
namespace plssvm {
 
//*************************************************************************************************************************************//
//                                                            default_init                                                             //
//*************************************************************************************************************************************//
 
template <typename T>
struct default_init {
    constexpr default_init() noexcept(std::is_nothrow_default_constructible_v<T>) = default;
    constexpr explicit default_init(T val) noexcept(std::is_nothrow_move_constructible_v<T>) :
        value{ std::move_if_noexcept(val) } {}
 
    T value{};
};
 
//*************************************************************************************************************************************//
//                                                            default_value                                                            //
//*************************************************************************************************************************************//
 
template <typename T>
class default_value {
    // befriend a default_value encapsulating another type (used to be able to convert between, e.g., default_value<int> and default_value<float>)
    template <typename>
    friend class default_value;
    // befriend input stream operator to be able to construct a default_value from a std::istream
    template <typename U>
    friend std::istream &operator>>(std::istream &in, default_value<U> &);
 
  public:
    using value_type = T;
 
    constexpr explicit default_value(default_init<value_type> default_val = default_init<value_type>{}) noexcept(std::is_nothrow_move_constructible_v<value_type>) :
        default_init_{ std::move_if_noexcept(default_val) } {}
    constexpr default_value &operator=(value_type non_default_val) noexcept(std::is_nothrow_move_assignable_v<value_type>) {
        value_ = std::move_if_noexcept(non_default_val);
        use_default_init_ = false;
        return *this;
    }
 
    template <typename U, PLSSVM_REQUIRES(std::is_convertible_v<U, value_type>)>
    constexpr explicit default_value(const default_value<U> &other) noexcept(std::is_nothrow_copy_constructible_v<U>) :
        value_{ static_cast<value_type>(other.value_) },
        use_default_init_{ other.use_default_init_ },
        default_init_{ static_cast<value_type>(other.default_init_.value) } {}
    template <typename U, PLSSVM_REQUIRES(std::is_convertible_v<U, value_type>)>
    constexpr explicit default_value(default_value<U> &&other) noexcept(std::is_nothrow_move_constructible_v<U>) :
        value_{ static_cast<value_type>(std::move_if_noexcept(other.value_)) },
        use_default_init_{ other.use_default_init_ },
        default_init_{ static_cast<value_type>(std::move_if_noexcept(other.default_init_.value)) } {}
    template <typename U, PLSSVM_REQUIRES(std::is_convertible_v<U, value_type>)>
    constexpr default_value &operator=(const default_value<U> &other) noexcept(std::is_nothrow_copy_assignable_v<U>) {
        value_ = static_cast<value_type>(other.value_);
        use_default_init_ = other.use_default_init_;
        default_init_ = default_init<value_type>{ static_cast<value_type>(other.default_init_.value) };
        return *this;
    }
    template <typename U, PLSSVM_REQUIRES(std::is_convertible_v<U, value_type>)>
    constexpr default_value &operator=(default_value<U> &&other) noexcept(std::is_nothrow_move_assignable_v<U>) {
        value_ = static_cast<value_type>(std::move_if_noexcept(other.value_));
        use_default_init_ = other.use_default_init_;
        default_init_ = default_init<value_type>{ static_cast<value_type>(std::move_if_noexcept(other.default_init_.value)) };
        return *this;
    }
 
    [[nodiscard]] constexpr const value_type &value() const noexcept {
        return this->is_default() ? default_init_.value : value_;
    }
    [[nodiscard]] constexpr operator const value_type &() const noexcept {
        return this->value();
    }
    [[nodiscard]] constexpr const value_type &get_default() const noexcept {
        return default_init_.value;
    }
    [[nodiscard]] constexpr bool is_default() const noexcept {
        return use_default_init_;
    }
 
    constexpr void swap(default_value &other) noexcept(std::is_nothrow_swappable_v<T>) {
        using std::swap;
        swap(value_, other.value_);
        swap(use_default_init_, other.use_default_init_);
        swap(default_init_, other.default_init_);
    }
    constexpr void reset() noexcept {
        use_default_init_ = true;
    }
 
  private:
    value_type value_{};
    bool use_default_init_{ true };
    default_init<value_type> default_init_{};
};
 
template <typename T>
inline std::ostream &operator<<(std::ostream &out, const default_value<T> &val) {
    return out << val.value();
}
template <typename T>
inline std::istream &operator>>(std::istream &in, default_value<T> &val) {
    in >> val.value_;
    val.use_default_init_ = false;
    return in;
}
 
template <typename T>
constexpr void swap(default_value<T> &lhs, default_value<T> &rhs) noexcept(noexcept(lhs.swap(rhs))) {
    lhs.swap(rhs);
}
 
template <typename T>
[[nodiscard]] constexpr bool operator==(const default_value<T> &lhs, const default_value<T> &rhs) noexcept {
    return lhs.value() == rhs.value();
}
template <typename T>
[[nodiscard]] constexpr bool operator==(const default_value<T> &lhs, const T &rhs) noexcept {
    return lhs.value() == rhs;
}
template <typename T>
[[nodiscard]] constexpr bool operator==(const T &lhs, const default_value<T> &rhs) noexcept {
    return lhs == rhs.value();
}
 
template <typename T>
[[nodiscard]] constexpr bool operator!=(const default_value<T> &lhs, const default_value<T> &rhs) noexcept {
    return !(lhs == rhs);
}
template <typename T>
[[nodiscard]] constexpr bool operator!=(const default_value<T> &lhs, const T &rhs) noexcept {
    return !(lhs == rhs);
}
template <typename T>
[[nodiscard]] constexpr bool operator!=(const T &lhs, const default_value<T> &rhs) noexcept {
    return !(lhs == rhs);
}
 
template <typename T>
[[nodiscard]] constexpr bool operator<(const default_value<T> &lhs, const default_value<T> &rhs) noexcept {
    return lhs.value() < rhs.value();
}
template <typename T>
[[nodiscard]] constexpr bool operator<(const default_value<T> &lhs, const T &rhs) noexcept {
    return lhs.value() < rhs;
}
template <typename T>
[[nodiscard]] constexpr bool operator<(const T &lhs, const default_value<T> &rhs) noexcept {
    return lhs < rhs.value();
}
 
template <typename T>
[[nodiscard]] constexpr bool operator>(const default_value<T> &lhs, const default_value<T> &rhs) noexcept {
    return rhs < lhs;
}
 
template <typename T>
[[nodiscard]] constexpr bool operator>(const default_value<T> &lhs, const T &rhs) noexcept {
    return lhs.value() > rhs;
}
 
template <typename T>
[[nodiscard]] constexpr bool operator>(const T &lhs, const default_value<T> &rhs) noexcept {
    return lhs > rhs.value();
}
 
template <typename T>
[[nodiscard]] constexpr bool operator<=(const default_value<T> &lhs, const default_value<T> &rhs) noexcept {
    return !(lhs > rhs);
}
template <typename T>
[[nodiscard]] constexpr bool operator<=(const default_value<T> &lhs, const T &rhs) noexcept {
    return !(lhs.value() > rhs);
}
template <typename T>
[[nodiscard]] constexpr bool operator<=(const T &lhs, const default_value<T> &rhs) noexcept {
    return !(lhs > rhs.value());
}
 
template <typename T>
[[nodiscard]] constexpr bool operator>=(const default_value<T> &lhs, const default_value<T> &rhs) noexcept {
    return !(lhs < rhs);
}
template <typename T>
[[nodiscard]] constexpr bool operator>=(const default_value<T> &lhs, const T &rhs) noexcept {
    return !(lhs.value() < rhs);
}
template <typename T>
[[nodiscard]] constexpr bool operator>=(const T &lhs, const default_value<T> &rhs) noexcept {
    return !(lhs < rhs.value());
}
 
namespace detail {
 
template <typename T>
struct is_default_value : std::false_type {};
template <typename T>
struct is_default_value<default_value<T>> : std::true_type {};
 
}  // namespace detail
 
template <typename T>
struct is_default_value : detail::is_default_value<std::remove_cv_t<std::remove_reference_t<T>>> {};  // can't use detail::remove_cvref_t because of circular dependencies
template <typename T>
constexpr bool is_default_value_v = is_default_value<T>::value;
 
}  // namespace plssvm
 
namespace std {
 
template <typename T>
struct hash<plssvm::default_value<T>> {
    std::size_t operator()(const plssvm::default_value<T> &val) const noexcept {
        return std::hash<T>{}(val.value());
    }
};
 
}  // namespace std
 
#endif  // PLSSVM_DEFAULT_VALUE_HPP_