no_destructor.h

// Copyright 2025 The Pigweed Authors
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.
#pragma once
 
#include <type_traits>
#include <utility>
 
#include "pw_polyfill/language_feature_macros.h"
 
namespace pw {
 
template <typename T>
class NoDestructor {
 public:
  using value_type = T;
 
  // Initializes a T in place.
  //
  // This overload is disabled when it might collide with copy/move.
  template <typename... Args,
            typename std::enable_if<!std::is_same<void(std::decay_t<Args>&...),
                                                  void(NoDestructor&)>::value,
                                    int>::type = 0>
  explicit constexpr NoDestructor(Args&&... args)
      : storage_(std::forward<Args>(args)...) {}
 
  // Move or copy from the contained type. This allows for construction from an
  // initializer list, e.g. for std::vector.
  explicit constexpr NoDestructor(const T& x) : storage_(x) {}
  explicit constexpr NoDestructor(T&& x) : storage_(std::move(x)) {}
 
  NoDestructor(const NoDestructor&) = delete;
  NoDestructor& operator=(const NoDestructor&) = delete;
 
  ~NoDestructor() = default;
 
  constexpr const T& operator*() const { return get(); }
  constexpr T& operator*() { return get(); }
 
  constexpr const T* operator->() const { return &get(); }
  constexpr T* operator->() { return &get(); }
 
 private:
  constexpr T& get() {
    if constexpr (std::is_trivially_destructible_v<T>) {
      return storage_;
    } else {
      return storage_.value;
    }
  }
 
  constexpr const T& get() const {
    if constexpr (std::is_trivially_destructible_v<T>) {
      return storage_;
    } else {
      return storage_.value;
    }
  }
 
  union NonTrivialStorage {
    template <typename... Args>
    constexpr NonTrivialStorage(Args&&... args)
        : value(std::forward<Args>(args)...) {}
 
    // Unfortunately, this cannot be trivially destructible because having a
    // union member of non-trivially destructible T implicitly deletes the
    // destructor. Trivial destruction may be possible in future C++ standards.
    PW_CONSTEXPR_CPP20 ~NonTrivialStorage() {}
 
    T value;
  };
 
  std::conditional_t<std::is_trivially_destructible_v<T>, T, NonTrivialStorage>
      storage_;
};
 
}  // namespace pw