Global Metrics

Spaces Data

Minimal test - lines (99, 102)

Code

  CFTypeRefPtr& operator=(const CFTypeRefPtr& aRhs) {
    assign_with_CFRetain(aRhs.mRawPtr);
    return *this;
  }

Minimal test - lines (86, 90)

Code

  static CFTypeRefPtr WrapUnderGetRule(PtrT aRawPtr) {
    CFTypeRefPtr ptr;
    ptr.AssignUnderGetRule(aRawPtr);
    return ptr;
  }

Minimal test - lines (54, 58)

Code

  ~CFTypeRefPtr() {
    if (mRawPtr) {
      CFRelease(mRawPtr);
    }
  }

Minimal test - lines (80, 84)

Code

  static CFTypeRefPtr WrapUnderCreateRule(PtrT aRawPtr) {
    CFTypeRefPtr ptr;
    ptr.AssignUnderCreateRule(aRawPtr);
    return ptr;
  }

Minimal test - lines (42, 48)

Code

  void assign_assuming_CFRetain(PtrT aNewPtr) {
    PtrT oldPtr = mRawPtr;
    mRawPtr = aNewPtr;
    if (oldPtr) {
      CFRelease(oldPtr);
    }
  }

Minimal test - lines (75, 75)

Code

  MOZ_IMPLICIT CFTypeRefPtr(decltype(nullptr)) : mRawPtr(nullptr) {}

Minimal test - lines (71, 73)

Code

  CFTypeRefPtr(CFTypeRefPtr&& aRefPtr) : mRawPtr(aRefPtr.mRawPtr) {
    aRefPtr.mRawPtr = nullptr;
  }

Minimal test - lines (62, 62)

Code

  CFTypeRefPtr() : mRawPtr(nullptr) {}

Minimal test - lines (104, 108)

Code

  CFTypeRefPtr& operator=(CFTypeRefPtr&& aRefPtr) {
    assign_assuming_CFRetain(aRefPtr.mRawPtr);
    aRefPtr.mRawPtr = nullptr;
    return *this;
  }

Minimal test - lines (37, 40)

Code

  void assign_with_CFRetain(PtrT aRawPtr) {
    CFRetain(aRawPtr);
    assign_assuming_CFRetain(aRawPtr);
  }

Minimal test - lines (64, 69)

Code

  CFTypeRefPtr(const CFTypeRefPtr& aSmartPtr)
      : mRawPtr(aSmartPtr.mRawPtr) {
    if (mRawPtr) {
      CFRetain(mRawPtr);
    }
  }

Minimal test - lines (35, 139)

Code

class CFTypeRefPtr {
 private:
  void assign_with_CFRetain(PtrT aRawPtr) {
    CFRetain(aRawPtr);
    assign_assuming_CFRetain(aRawPtr);
  }

  void assign_assuming_CFRetain(PtrT aNewPtr) {
    PtrT oldPtr = mRawPtr;
    mRawPtr = aNewPtr;
    if (oldPtr) {
      CFRelease(oldPtr);
    }
  }

 private:
  PtrT mRawPtr;

 public:
  ~CFTypeRefPtr() {
    if (mRawPtr) {
      CFRelease(mRawPtr);
    }
  }

  // Constructors

  CFTypeRefPtr() : mRawPtr(nullptr) {}

  CFTypeRefPtr(const CFTypeRefPtr& aSmartPtr)
      : mRawPtr(aSmartPtr.mRawPtr) {
    if (mRawPtr) {
      CFRetain(mRawPtr);
    }
  }

  CFTypeRefPtr(CFTypeRefPtr&& aRefPtr) : mRawPtr(aRefPtr.mRawPtr) {
    aRefPtr.mRawPtr = nullptr;
  }

  MOZ_IMPLICIT CFTypeRefPtr(decltype(nullptr)) : mRawPtr(nullptr) {}

  // There is no constructor from a raw pointer value.
  // Use one of the static WrapUnder*Rule methods below instead.

  static CFTypeRefPtr WrapUnderCreateRule(PtrT aRawPtr) {
    CFTypeRefPtr ptr;
    ptr.AssignUnderCreateRule(aRawPtr);
    return ptr;
  }

  static CFTypeRefPtr WrapUnderGetRule(PtrT aRawPtr) {
    CFTypeRefPtr ptr;
    ptr.AssignUnderGetRule(aRawPtr);
    return ptr;
  }

  // Assignment operators

  CFTypeRefPtr& operator=(decltype(nullptr)) {
    assign_assuming_CFRetain(nullptr);
    return *this;
  }

  CFTypeRefPtr& operator=(const CFTypeRefPtr& aRhs) {
    assign_with_CFRetain(aRhs.mRawPtr);
    return *this;
  }

  CFTypeRefPtr& operator=(CFTypeRefPtr&& aRefPtr) {
    assign_assuming_CFRetain(aRefPtr.mRawPtr);
    aRefPtr.mRawPtr = nullptr;
    return *this;
  }

  // There is no operator= for a raw pointer value.
  // Use one of the AssignUnder*Rule methods below instead.

  CFTypeRefPtr& AssignUnderCreateRule(PtrT aRawPtr) {
    // Freshly-created objects come with a retain count of 1.
    assign_assuming_CFRetain(aRawPtr);
    return *this;
  }

  CFTypeRefPtr& AssignUnderGetRule(PtrT aRawPtr) {
    assign_with_CFRetain(aRawPtr);
    return *this;
  }

  // Other pointer operators

  // This is the only way to get the raw pointer out of the smart pointer.
  // There is no implicit conversion to a raw pointer.
  PtrT get() const { return mRawPtr; }

  // Don't allow implicit conversion of temporary CFTypeRefPtr to raw pointer,
  // because the refcount might be one and the pointer will immediately become
  // invalid.
  operator PtrT() const&& = delete;
  // Also don't allow implicit conversion of non-temporary CFTypeRefPtr.
  operator PtrT() const& = delete;

  // These let you null-check a pointer without calling get().
  explicit operator bool() const { return !!mRawPtr; }
};

Minimal test - lines (94, 97)

Code

  CFTypeRefPtr& operator=(decltype(nullptr)) {
    assign_assuming_CFRetain(nullptr);
    return *this;
  }