CustomizableOptional.h

Go to the documentation of this file.

//===- CustomizableOptional.h - Optional with custom storage ----*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#ifndef CLANG_BASIC_CUSTOMIZABLEOPTIONAL_H
#define CLANG_BASIC_CUSTOMIZABLEOPTIONAL_H
 
#include "llvm/ADT/Hashing.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/type_traits.h"
#include <cassert>
#include <new>
#include <optional>
#include <utility>
 
namespace clang {
 
namespace optional_detail {
template <typename> class OptionalStorage;
} // namespace optional_detail
 
// Optional type which internal storage can be specialized by providing
// OptionalStorage. The interface follows std::optional.
template <typename T> class CustomizableOptional {
  optional_detail::OptionalStorage<T> Storage;
 
public:
  using value_type = T;
 
  constexpr CustomizableOptional() = default;
  constexpr CustomizableOptional(std::nullopt_t) {}
 
  constexpr CustomizableOptional(const T &y) : Storage(std::in_place, y) {}
  constexpr CustomizableOptional(const CustomizableOptional &O) = default;
 
  constexpr CustomizableOptional(T &&y)
      : Storage(std::in_place, std::move(y)) {}
  constexpr CustomizableOptional(CustomizableOptional &&O) = default;
 
  template <typename... ArgTypes>
  constexpr CustomizableOptional(std::in_place_t, ArgTypes &&...Args)
      : Storage(std::in_place, std::forward<ArgTypes>(Args)...) {}
 
  // Allow conversion from std::optional<T>.
  constexpr CustomizableOptional(const std::optional<T> &y)
      : CustomizableOptional(y ? *y : CustomizableOptional()) {}
  constexpr CustomizableOptional(std::optional<T> &&y)
      : CustomizableOptional(y ? std::move(*y) : CustomizableOptional()) {}
 
  CustomizableOptional &operator=(T &&y) {
    Storage = std::move(y);
    return *this;
  }
  CustomizableOptional &operator=(CustomizableOptional &&O) = default;
 
  /// Create a new object by constructing it in place with the given arguments.
  template <typename... ArgTypes> void emplace(ArgTypes &&...Args) {
    Storage.emplace(std::forward<ArgTypes>(Args)...);
  }
 
  CustomizableOptional &operator=(const T &y) {
    Storage = y;
    return *this;
  }
  CustomizableOptional &operator=(const CustomizableOptional &O) = default;
 
  void reset() { Storage.reset(); }
 
  LLVM_DEPRECATED("Use &*X instead.", "&*X")
  constexpr const T *getPointer() const { return &Storage.value(); }
  LLVM_DEPRECATED("Use &*X instead.", "&*X")
  T *getPointer() { return &Storage.value(); }
  LLVM_DEPRECATED("std::optional::value is throwing. Use *X instead", "*X")
  constexpr const T &value() const & { return Storage.value(); }
  LLVM_DEPRECATED("std::optional::value is throwing. Use *X instead", "*X")
  T &value() & { return Storage.value(); }
 
  constexpr explicit operator bool() const { return has_value(); }
  constexpr bool has_value() const { return Storage.has_value(); }
  constexpr const T *operator->() const { return &Storage.value(); }
  T *operator->() { return &Storage.value(); }
  constexpr const T &operator*() const & { return Storage.value(); }
  T &operator*() & { return Storage.value(); }
 
  template <typename U> constexpr T value_or(U &&alt) const & {
    return has_value() ? operator*() : std::forward<U>(alt);
  }
 
  LLVM_DEPRECATED("std::optional::value is throwing. Use *X instead", "*X")
  T &&value() && { return std::move(Storage.value()); }
  T &&operator*() && { return std::move(Storage.value()); }
 
  template <typename U>