delayed_construct.h

Go to the documentation of this file.

/* *****************************************************************************
 * kblib is a general utility library for C++14 and C++17, intended to provide
 * performant high-level abstractions and more expressive ways to do simple
 * things.
 *
 * Copyright (c) 2021 killerbee
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 * ****************************************************************************/
 
#ifndef DELAYED_CONSTRUCT_H
#define DELAYED_CONSTRUCT_H
 
#include "hash.h"
#include "tdecl.h"
 
#if KBLIB_USE_CXX17
 
#  include <optional>
 
#  if KBLIB_USE_CXX20
 
#     include <compare>
 
#  endif
 
namespace KBLIB_NS {
 
template <typename T>
class delayed_construct {
 private:
   using Base = std::optional<T>;
 
 protected:
   Base storage;
 
 public:
   template <typename... Ts>
   KBLIB_CXX20(requires(std::constructible_from<Base, Ts...>))
   delayed_construct(Ts&&... args)
       : storage(std::forward<Ts>(args)...) {}
   template <typename U,
             std::enable_if_t<std::is_assignable_v<T&, U&&>, int> = 0>
   auto operator=(U&& t) -> delayed_construct& {
      storage = std::forward<U>(t);
      return *this;
   }
   auto operator=(std::nullopt_t) -> delayed_construct& = delete;
 
   template <typename... Ts>
   auto emplace(Ts&&... args) const -> decltype(auto) {
      return storage.emplace(std::forward<Ts>(args)...);
   }
 
   delayed_construct(const delayed_construct&) = default;
   delayed_construct(delayed_construct&&) = default;
   auto operator=(const delayed_construct&) -> delayed_construct& = default;
   auto operator=(delayed_construct&&) -> delayed_construct& = default;
   ~delayed_construct() = default;
 
   auto operator->() const -> decltype(auto) { return storage.operator->(); }
   auto operator*() const -> decltype(auto) { return storage.operator*(); }
   auto value() const -> decltype(auto) { return storage.value(); }
   explicit operator bool() const { return static_cast<bool>(storage); }
   KBLIB_NODISCARD constexpr auto is_constructed() const noexcept -> bool {
      return storage.has_value();
   }
 
   // TODO(killerbee13): add C++20 operator<=> support to delayed_construct
 
#  if 0
 
   template <std::three_way_comparable_with<Base> U>
   requires(not std::same_as<U, delayed_construct>) KBLIB_NODISCARD auto
   operator<=>(const U& other) const {
      return storage <=> other;
   }
   template <std::equality_comparable_with<Base> U>
   requires(not std::same_as<U, delayed_construct>) KBLIB_NODISCARD auto
   operator==(const U& other) const {
      return storage == other;
   }
   KBLIB_NODISCARD auto operator<=>(
       const delayed_construct& other) const = default;
   KBLIB_NODISCARD auto operator==(const delayed_construct& other) const -> bool
       = default;
 
#  else
 
#     define OVERLOAD_DEFER_OP(op)                                          \
         KBLIB_NODISCARD friend constexpr auto operator op(                  \
             const delayed_construct& lhs,                                   \
             const delayed_construct& rhs) noexcept->bool {                  \
            return lhs.storage op rhs.storage;                               \
         }                                                                   \
         template <typename U>                                               \
         KBLIB_NODISCARD friend constexpr auto operator op(                  \
             const delayed_construct& lhs,                                   \
             const delayed_construct<U>& rhs) noexcept->bool {               \
            return lhs.storage op static_cast<const std::optional<U>&>(rhs); \
         }                                                                   \
         KBLIB_NODISCARD friend constexpr auto operator op(                  \
             const delayed_construct& lhs,                                   \
             std::nullopt_t rhs) noexcept->bool {                            \
            return lhs.storage op rhs;                                       \
         }                                                                   \
         KBLIB_NODISCARD friend constexpr auto operator op(                  \
             std::nullopt_t lhs,                                             \
             const delayed_construct& rhs) noexcept->bool {                  \
            return lhs op rhs.storage;                                       \
         }                                                                   \
         template <typename U>                                               \
         KBLIB_NODISCARD friend constexpr auto operator op(                  \
             const delayed_construct& opt, const U& value) noexcept->bool {  \
            return opt.storage op value;                                     \
         }                                                                   \
         template <typename U>                                               \
         KBLIB_NODISCARD friend constexpr auto operator op(                  \
             const U& value, const delayed_construct& opt) noexcept->bool {  \
            return value op opt.storage;                                     \
         }
 
   OVERLOAD_DEFER_OP(==)
   OVERLOAD_DEFER_OP(!=)
 
   OVERLOAD_DEFER_OP(<)
   OVERLOAD_DEFER_OP(<=)
   OVERLOAD_DEFER_OP(>)
   OVERLOAD_DEFER_OP(>=)
 
#     undef OVERLOAD_DEFER_OP
#  endif
 
   friend struct std::hash<delayed_construct<T>>;
   friend struct FNV_hash<delayed_construct<T>>;
};
 
template <typename T>
struct FNV_hash<delayed_construct<T>, void> {
   KBLIB_NODISCARD constexpr std::size_t operator()(
       const delayed_construct<T>& key,
       std::size_t offset
       = fnv::fnv_offset<std::size_t>::value) const noexcept {
      if (key) {
         return FNV_hash<T>{}(key.value(), offset);
      } else {
         return FNV_hash<std::nullopt_t>{}(std::nullopt, offset);
      }
   }
};
 
} // namespace KBLIB_NS
 
namespace std {
 
// Inheriting from another hash specialization means that this hash is (mostly)
// disabled when std::hash<T> is (if I read the requirements correctly,
// operator() should not be declared in a disabled std::hash, but I basically
// can't do that in any sensible way)
template <typename T>
struct hash<kblib::delayed_construct<T>> : hash<T> {
   using argument_type = kblib::delayed_construct<T>;
   auto operator()(const argument_type& value) const noexcept -> std::size_t {
      return hash<optional<T>>{}(static_cast<const optional<T>&>(value));
   }
};
 
} // namespace std
 
#endif // KBLIB_USE_CXX17
 
#endif // DELAYED_CONSTRUCT_H