DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Mercurial (b6d82b1a6b02)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */

#ifndef mozilla_StaticLocalPtr_h
#define mozilla_StaticLocalPtr_h

#include "mozilla/AlreadyAddRefed.h"
#include "mozilla/Assertions.h"
#include "mozilla/Attributes.h"
#include "mozilla/RefPtr.h"

namespace mozilla {

/**
 * StaticLocalAutoPtr and StaticLocalRefPtr are like nsAutoPtr and nsRefPtr,
 * except they are suitable for use as "magic static" local variables -- that
 * is, they are able to take advantage of C++11's guarantee of thread safety
 * during initialization by atomically constructing both the smart pointer
 * itself as well as the object being pointed to.
 *
 * A static local instance of StaticLocal{Auto,Ref}Ptr does not cause the
 * compiler to emit any atexit calls. In order to accomplish this,
 * StaticLocal{Auto,Ref}Ptr must have a trivial destructor. As a consequence,
 * it does not delete/release its raw pointer upon destruction.
 *
 * The clang plugin, run as part of our "static analysis" builds, makes it a
 * compile-time error to use StaticLocal{Auto,Ref}Ptr as anything except a
 * static local variable.
 *
 * StaticLocal{Auto,Ref}Ptr have a limited interface as compared to
 * ns{Auto,Ref}Ptr; this is intentional, since their range of acceptable uses is
 * smaller.
 */

template <typename T>
class MOZ_STATIC_LOCAL_CLASS StaticLocalAutoPtr final {
 public:
  explicit StaticLocalAutoPtr(T* aRawPtr) : mRawPtr(aRawPtr) {}

  StaticLocalAutoPtr(StaticLocalAutoPtr<T>&& aOther) : mRawPtr(aOther.mRawPtr) {
    aOther.mRawPtr = nullptr;
  }

  StaticLocalAutoPtr<T>& operator=(T* aRhs) {
    Assign(aRhs);
    return *this;
  }

  T* get() const { return mRawPtr; }

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

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

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

  T* forget() {
    T* temp = mRawPtr;
    mRawPtr = nullptr;
    return temp;
  }

 private:
  StaticLocalAutoPtr(const StaticLocalAutoPtr<T>& aOther) = delete;

  // We do not allow assignment as the intention of this class is to only
  // assign to mRawPtr during construction.
  StaticLocalAutoPtr& operator=(const StaticLocalAutoPtr<T>& aOther) = delete;
  StaticLocalAutoPtr& operator=(StaticLocalAutoPtr<T>&&) = delete;

  void Assign(T* aNewPtr) {
    MOZ_ASSERT(!aNewPtr || mRawPtr != aNewPtr);
    T* oldPtr = mRawPtr;
    mRawPtr = aNewPtr;
    delete oldPtr;
  }

  T* mRawPtr;
};

template <typename T>
class MOZ_STATIC_LOCAL_CLASS StaticLocalRefPtr final {
 public:
  explicit StaticLocalRefPtr(T* aRawPtr) : mRawPtr(nullptr) {
    AssignWithAddref(aRawPtr);
  }

  explicit StaticLocalRefPtr(already_AddRefed<T>& aPtr) : mRawPtr(nullptr) {
    AssignAssumingAddRef(aPtr.take());
  }

  explicit StaticLocalRefPtr(already_AddRefed<T>&& aPtr) : mRawPtr(nullptr) {
    AssignAssumingAddRef(aPtr.take());
  }

  StaticLocalRefPtr(const StaticLocalRefPtr<T>& aPtr)
      : StaticLocalRefPtr(aPtr.mRawPtr) {}

  StaticLocalRefPtr(StaticLocalRefPtr<T>&& aPtr) : mRawPtr(aPtr.mRawPtr) {
    aPtr.mRawPtr = nullptr;
  }

  StaticLocalRefPtr<T>& operator=(T* aRhs) {
    AssignWithAddref(aRhs);
    return *this;
  }

  already_AddRefed<T> forget() {
    T* temp = mRawPtr;
    mRawPtr = nullptr;
    return already_AddRefed<T>(temp);
  }

  T* get() const { return mRawPtr; }

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

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

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

 private:
  // We do not allow assignment as the intention of this class is to only
  // assign to mRawPtr during construction.
  StaticLocalRefPtr<T>& operator=(const StaticLocalRefPtr<T>& aRhs) = delete;
  StaticLocalRefPtr<T>& operator=(StaticLocalRefPtr<T>&& aRhs) = delete;

  void AssignWithAddref(T* aNewPtr) {
    if (aNewPtr) {
      aNewPtr->AddRef();
    }
    AssignAssumingAddRef(aNewPtr);
  }

  void AssignAssumingAddRef(T* aNewPtr) {
    T* oldPtr = mRawPtr;
    mRawPtr = aNewPtr;
    if (oldPtr) {
      oldPtr->Release();
    }
  }

  T* MOZ_OWNING_REF mRawPtr;
};

namespace StaticLocalPtr_internal {
class Zero;
}  // namespace StaticLocalPtr_internal

#define REFLEXIVE_EQUALITY_OPERATORS(type1, type2, eq_fn, ...) \
  template <__VA_ARGS__>                                       \
  inline bool operator==(type1 lhs, type2 rhs) {               \
    return eq_fn;                                              \
  }                                                            \
                                                               \
  template <__VA_ARGS__>                                       \
  inline bool operator==(type2 lhs, type1 rhs) {               \
    return rhs == lhs;                                         \
  }                                                            \
                                                               \
  template <__VA_ARGS__>                                       \
  inline bool operator!=(type1 lhs, type2 rhs) {               \
    return !(lhs == rhs);                                      \
  }                                                            \
                                                               \
  template <__VA_ARGS__>                                       \
  inline bool operator!=(type2 lhs, type1 rhs) {               \
    return !(lhs == rhs);                                      \
  }

// StaticLocalAutoPtr (in)equality operators

template <class T, class U>
inline bool operator==(const StaticLocalAutoPtr<T>& aLhs,
                       const StaticLocalAutoPtr<U>& aRhs) {
  return aLhs.get() == aRhs.get();
}

template <class T, class U>
inline bool operator!=(const StaticLocalAutoPtr<T>& aLhs,
                       const StaticLocalAutoPtr<U>& aRhs) {
  return !(aLhs == aRhs);
}

REFLEXIVE_EQUALITY_OPERATORS(const StaticLocalAutoPtr<T>&, const U*,
                             lhs.get() == rhs, class T, class U)

REFLEXIVE_EQUALITY_OPERATORS(const StaticLocalAutoPtr<T>&, U*, lhs.get() == rhs,
                             class T, class U)

// Let us compare StaticLocalAutoPtr to 0.
REFLEXIVE_EQUALITY_OPERATORS(const StaticLocalAutoPtr<T>&,
                             StaticLocalPtr_internal::Zero*,
                             lhs.get() == nullptr, class T)

// StaticLocalRefPtr (in)equality operators

template <class T, class U>
inline bool operator==(const StaticLocalRefPtr<T>& aLhs,
                       const StaticLocalRefPtr<U>& aRhs) {
  return aLhs.get() == aRhs.get();
}

template <class T, class U>
inline bool operator!=(const StaticLocalRefPtr<T>& aLhs,
                       const StaticLocalRefPtr<U>& aRhs) {
  return !(aLhs == aRhs);
}

REFLEXIVE_EQUALITY_OPERATORS(const StaticLocalRefPtr<T>&, const U*,
                             lhs.get() == rhs, class T, class U)

REFLEXIVE_EQUALITY_OPERATORS(const StaticLocalRefPtr<T>&, U*, lhs.get() == rhs,
                             class T, class U)

// Let us compare StaticLocalRefPtr to 0.
REFLEXIVE_EQUALITY_OPERATORS(const StaticLocalRefPtr<T>&,
                             StaticLocalPtr_internal::Zero*,
                             lhs.get() == nullptr, class T)

#undef REFLEXIVE_EQUALITY_OPERATORS

}  // namespace mozilla

// Declared in mozilla/RefPtr.h
template <class T>
template <class U>
RefPtr<T>::RefPtr(const mozilla::StaticLocalRefPtr<U>& aOther)
    : RefPtr(aOther.get()) {}

template <class T>
template <class U>
RefPtr<T>& RefPtr<T>::operator=(const mozilla::StaticLocalRefPtr<U>& aOther) {
  return operator=(aOther.get());
}

template <class T>
inline already_AddRefed<T> do_AddRef(
    const mozilla::StaticLocalRefPtr<T>& aObj) {
  RefPtr<T> ref(aObj);
  return ref.forget();
}

#endif  // mozilla_StaticLocalPtr_h