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
|
// Copyright (C) 2023 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
#pragma once
#include <QPointer>
#include <memory.h>
#include <type_traits>
namespace Utils {
namespace Internal {
template<typename Type>
class UniqueObjectInternalPointer : public QPointer<Type>
{
public:
using QPointer<Type>::QPointer;
template<typename UpType,
typename = std::enable_if_t<std::is_convertible_v<UpType *, Type *>
&& !std::is_same_v<std::decay_t<UpType>, std::decay_t<Type>>>>
UniqueObjectInternalPointer(const UniqueObjectInternalPointer<UpType> &p) noexcept
: QPointer<Type>{p.data()}
{}
};
template<typename Type>
struct UniqueObjectPtrDeleter
{
using pointer = UniqueObjectInternalPointer<Type>;
constexpr UniqueObjectPtrDeleter() noexcept = default;
template<typename UpType, typename = std::enable_if_t<std::is_convertible_v<UpType *, Type *>>>
constexpr UniqueObjectPtrDeleter(const UniqueObjectPtrDeleter<UpType> &) noexcept
{}
constexpr void operator()(pointer p) const
{
static_assert(!std::is_void_v<Type>, "can't delete pointer to incomplete type");
static_assert(sizeof(Type) > 0, "can't delete pointer to incomplete type");
delete p.data();
}
};
template<typename Type>
struct UniqueObjectPtrLateDeleter
{
using pointer = UniqueObjectInternalPointer<Type>;
constexpr UniqueObjectPtrLateDeleter() noexcept = default;
template<typename UpType, typename = std::enable_if_t<std::is_convertible_v<UpType *, Type *>>>
constexpr UniqueObjectPtrLateDeleter(const UniqueObjectPtrLateDeleter<UpType> &) noexcept
{}
constexpr void operator()(pointer p) const
{
static_assert(!std::is_void_v<Type>, "can't delete pointer to incomplete type");
static_assert(sizeof(Type) > 0, "can't delete pointer to incomplete type");
p->deleteLater();
}
};
} // namespace Internal
template<typename Type>
using UniqueObjectPtr = std::unique_ptr<Type, Internal::UniqueObjectPtrDeleter<Type>>;
template<typename Type, typename... Arguments>
auto makeUniqueObjectPtr(Arguments &&...arguments)
{
return UniqueObjectPtr<Type>{new Type(std::forward<Arguments>(arguments)...)};
}
template<typename Type>
using UniqueObjectLatePtr = std::unique_ptr<Type, Internal::UniqueObjectPtrLateDeleter<Type>>;
template<typename Type, typename... Arguments>
auto makeUniqueObjectLatePtr(Arguments &&...arguments)
{
return UniqueObjectLatePtr<Type>{new Type(std::forward<Arguments>(arguments)...)};
}
} // namespace Utils
|
