// Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef ANGLEBASE_NO_DESTRUCTOR_H_
#define ANGLEBASE_NO_DESTRUCTOR_H_

#include <new>
#include <utility>

namespace angle
{

namespace base
{

// A wrapper that makes it easy to create an object of type T with static
// storage duration that:
// - is only constructed on first access
// - never invokes the destructor
// in order to satisfy the styleguide ban on global constructors and
// destructors.
//
// Runtime constant example:
// const std::string& GetLineSeparator() {
//  // Forwards to std::string(size_t, char, const Allocator&) constructor.
//   static const base::NoDestructor<std::string> s(5, '-');
//   return *s;
// }
//
// More complex initialization with a lambda:
// const std::string& GetSessionNonce() {
//   static const base::NoDestructor<std::string> nonce([] {
//     std::string s(16);
//     crypto::RandString(s.data(), s.size());
//     return s;
//   }());
//   return *nonce;
// }
//
// NoDestructor<T> stores the object inline, so it also avoids a pointer
// indirection and a malloc. Also note that since C++11 static local variable
// initialization is thread-safe and so is this pattern. Code should prefer to
// use NoDestructor<T> over:
// - A function scoped static T* or T& that is dynamically initialized.
// - A global base::LazyInstance<T>.
//
// Note that since the destructor is never run, this *will* leak memory if used
// as a stack or member variable. Furthermore, a NoDestructor<T> should never
// have global scope as that may require a static initializer.
template <typename T>
class NoDestructor
{
  public:
    // Not constexpr; just write static constexpr T x = ...; if the value should
    // be a constexpr.
    template <typename... Args>
    explicit NoDestructor(Args &&... args)
    {
        new (storage_) T(std::forward<Args>(args)...);
    }

    // Allows copy and move construction of the contained type, to allow
    // construction from an initializer list, e.g. for std::vector.
    explicit NoDestructor(const T &x) { new (storage_) T(x); }
    explicit NoDestructor(T &&x) { new (storage_) T(std::move(x)); }

    NoDestructor(const NoDestructor &) = delete;
    NoDestructor &operator=(const NoDestructor &) = delete;

    ~NoDestructor() = default;

    const T &operator*() const { return *get(); }
    T &operator*() { return *get(); }

    const T *operator->() const { return get(); }
    T *operator->() { return get(); }

    const T *get() const { return reinterpret_cast<const T *>(storage_); }
    T *get() { return reinterpret_cast<T *>(storage_); }

  private:
    alignas(T) char storage_[sizeof(T)];

#if defined(LEAK_SANITIZER)
    // TODO(https://crbug.com/812277): This is a hack to work around the fact
    // that LSan doesn't seem to treat NoDestructor as a root for reachability
    // analysis. This means that code like this:
    //   static base::NoDestructor<std::vector<int>> v({1, 2, 3});
    // is considered a leak. Using the standard leak sanitizer annotations to
    // suppress leaks doesn't work: std::vector is implicitly constructed before
    // calling the base::NoDestructor constructor.
    //
    // Unfortunately, I haven't been able to demonstrate this issue in simpler
    // reproductions: until that's resolved, hold an explicit pointer to the
    // placement-new'd object in leak sanitizer mode to help LSan realize that
    // objects allocated by the contained type are still reachable.
    T *storage_ptr_ = reinterpret_cast<T *>(storage_);
#endif  // defined(LEAK_SANITIZER)
};

}  // namespace base

}  // namespace angle

#endif  // ANGLEBASE_NO_DESTRUCTOR_H_
