common/comptr.h


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

#ifndef COMMON_COMPTR_H
#define COMMON_COMPTR_H

#include <cstddef>
#include <utility>

#include "opthelpers.h"


template<typename T>
class ComPtr {
    T *mPtr{nullptr};

public:
    ComPtr() noexcept = default;
    ComPtr(const ComPtr &rhs) : mPtr{rhs.mPtr} { if(mPtr) mPtr->AddRef(); }
    ComPtr(ComPtr&& rhs) noexcept : mPtr{rhs.mPtr} { rhs.mPtr = nullptr; }
    ComPtr(std::nullptr_t) noexcept { }
    explicit ComPtr(T *ptr) noexcept : mPtr{ptr} { }
    ~ComPtr() { if(mPtr) mPtr->Release(); }

    ComPtr& operator=(const ComPtr &rhs)
    {
        if(!rhs.mPtr)
        {
            if(mPtr)
                mPtr->Release();
            mPtr = nullptr;
        }
        else
        {
            rhs.mPtr->AddRef();
            try {
                if(mPtr)
                    mPtr->Release();
                mPtr = rhs.mPtr;
            }
            catch(...) {
                rhs.mPtr->Release();
                throw;
            }
        }
        return *this;
    }
    ComPtr& operator=(ComPtr&& rhs)
    {
        if(likely(&rhs != this))
        {
            if(mPtr) mPtr->Release();
            mPtr = std::exchange(rhs.mPtr, nullptr);
        }
        return *this;
    }

    explicit operator bool() const noexcept { return mPtr != nullptr; }

    T& operator*() const noexcept { return *mPtr; }
    T* operator->() const noexcept { return mPtr; }
    T* get() const noexcept { return mPtr; }
    T** getPtr() noexcept { return &mPtr; }

    T* release() noexcept { return std::exchange(mPtr, nullptr); }

    void swap(ComPtr &rhs) noexcept { std::swap(mPtr, rhs.mPtr); }
    void swap(ComPtr&& rhs) noexcept { std::swap(mPtr, rhs.mPtr); }
};

#endif