kc3-lang/angle/src/common/base/anglebase/no_destructor.h

• Show log

  Commit

• Hash : c991eb22
  Author :
  Date : 2022-12-01T14:05:07
  

  Move the anglebase folder up a level
  
  This code originates from Chromium's base/ directory so it doesn't have
  to be under a third-party folder.
  
  Bug: b/260093525
  Change-Id: I0bf6950095c685f36c5c237093980a64cf6e74f0
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4068339
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Nicolas Capens <nicolascapens@google.com>
  

Download

• src/common/base/anglebase/no_destructor.h

• // 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_
  

Download