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
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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 http://mozilla.org/MPL/2.0/. */
#ifndef nsClassHashtable_h__
#define nsClassHashtable_h__
#include "mozilla/Move.h"
#include "nsBaseHashtable.h"
#include "nsHashKeys.h"
#include "nsAutoPtr.h"
/**
* templated hashtable class maps keys to C++ object pointers.
* See nsBaseHashtable for complete declaration.
* @param KeyClass a wrapper-class for the hashtable key, see nsHashKeys.h
* for a complete specification.
* @param Class the class-type being wrapped
* @see nsInterfaceHashtable, nsClassHashtable
*/
template<class KeyClass, class T>
class nsClassHashtable
: public nsBaseHashtable<KeyClass, nsAutoPtr<T>, T*>
{
public:
typedef typename KeyClass::KeyType KeyType;
typedef T* UserDataType;
typedef nsBaseHashtable<KeyClass, nsAutoPtr<T>, T*> base_type;
using base_type::IsEmpty;
nsClassHashtable() {}
explicit nsClassHashtable(uint32_t aInitLength)
: nsBaseHashtable<KeyClass, nsAutoPtr<T>, T*>(aInitLength)
{
}
/**
* Looks up aKey in the hash table. If it doesn't exist a new object of
* KeyClass will be created (using the arguments provided) and then returned.
*/
template<typename... Args>
UserDataType LookupOrAdd(KeyType aKey, Args&&... aConstructionArgs);
/**
* @copydoc nsBaseHashtable::Get
* @param aData if the key doesn't exist, pData will be set to nullptr.
*/
bool Get(KeyType aKey, UserDataType* aData) const;
/**
* @copydoc nsBaseHashtable::Get
* @returns nullptr if the key is not present.
*/
UserDataType Get(KeyType aKey) const;
/**
* Remove the entry for the given key from the hashtable and return it in
* aOut. If the key is not in the hashtable, aOut's pointer is set to
* nullptr.
*
* Normally, an entry is deleted when it's removed from an nsClassHashtable,
* but this function transfers ownership of the entry back to the caller
* through aOut -- the entry will be deleted when aOut goes out of scope.
*
* @param aKey the key to get and remove from the hashtable
*/
void RemoveAndForget(KeyType aKey, nsAutoPtr<T>& aOut);
};
//
// nsClassHashtable definitions
//
template<class KeyClass, class T>
template<typename... Args>
T*
nsClassHashtable<KeyClass, T>::LookupOrAdd(KeyType aKey,
Args&&... aConstructionArgs)
{
typename base_type::EntryType* ent = this->PutEntry(aKey);
if (!ent->mData) {
ent->mData = new T(mozilla::Forward<Args>(aConstructionArgs)...);
}
return ent->mData;
}
template<class KeyClass, class T>
bool
nsClassHashtable<KeyClass, T>::Get(KeyType aKey, T** aRetVal) const
{
typename base_type::EntryType* ent = this->GetEntry(aKey);
if (ent) {
if (aRetVal) {
*aRetVal = ent->mData;
}
return true;
}
if (aRetVal) {
*aRetVal = nullptr;
}
return false;
}
template<class KeyClass, class T>
T*
nsClassHashtable<KeyClass, T>::Get(KeyType aKey) const
{
typename base_type::EntryType* ent = this->GetEntry(aKey);
if (!ent) {
return nullptr;
}
return ent->mData;
}
template<class KeyClass, class T>
void
nsClassHashtable<KeyClass, T>::RemoveAndForget(KeyType aKey, nsAutoPtr<T>& aOut)
{
aOut = nullptr;
typename base_type::EntryType* ent = this->GetEntry(aKey);
if (!ent) {
return;
}
// Transfer ownership from ent->mData into aOut.
aOut = mozilla::Move(ent->mData);
this->Remove(aKey);
}
#endif // nsClassHashtable_h__
|
