The LinkedMap Class Template Reference

Container class representing a vector of objects with keys. More...

Declaration

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >> class LinkedMap<T, Hash, KeyEqual, Map> { ... }

Included Headers

#include <src/linkedmap.h>

Public Member Typedefs Index

template < ... >
using	Ptr = std::unique_ptr< T >
template < ... >
using	Vec = std::vector< Ptr >
template < ... >
using	iterator = typename Vec::iterator
template < ... >
using	const_iterator = typename Vec::const_iterator
template < ... >
using	reverse_iterator = typename Vec::reverse_iterator
template < ... >
using	const_reverse_iterator = typename Vec::const_reverse_iterator

Public Operators Index

template < ... >
Ptr &	operator[] (size_t pos)
template < ... >
const Ptr &	operator[] (size_t pos) const

Public Member Functions Index

template < ... >
const T *	find (const std::string &key) const
template < ... >
const T *	find (const QCString &key) const
template < ... >
const T *	find (const char *key) const
template < ... >
T *	find (const char *key)
	A non-const wrapper for find() const. More...
template < ... >
T *	find (const QCString &key)
	A non-const wrapper for find() const. More...
template < ... >
T *	find (const std::string &key)
	A non-const wrapper for find() const. More...
template <class... Args>
T *	add (const char *k, Args &&... args)
template <class... Args>
T *	add (const QCString &k, Args &&... args)
template < ... >
T *	add (const char *k, Ptr &&ptr)
template < ... >
T *	add (const QCString &k, Ptr &&ptr)
template <class... Args>
T *	prepend (const char *k, Args &&... args)
template <class... Args>
T *	prepend (const QCString &key, Args &&... args)
template < ... >
bool	del (const QCString &key)
template < ... >
iterator	begin ()
template < ... >
iterator	end ()
template < ... >
const_iterator	begin () const
template < ... >
const_iterator	end () const
template < ... >
reverse_iterator	rbegin ()
template < ... >
reverse_iterator	rend ()
template < ... >
const_reverse_iterator	rbegin () const
template < ... >
const_reverse_iterator	rend () const
template < ... >
bool	empty () const
template < ... >
size_t	size () const
template < ... >
void	clear ()

Private Member Attributes Index

template < ... >
Map	m_lookup
template < ... >
Vec	m_entries

Description

Container class representing a vector of objects with keys.

Objects can efficiently be looked up given the key. Objects are owned by the container. When adding objects the order of addition is kept, and used while iterating.

Definition at line 35 of file linkedmap.h.

Public Member Typedefs

const_iterator

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

using LinkedMap< T, Hash, KeyEqual, Map >::const_iterator = typename Vec::const_iterator

Definition at line 41 of file linkedmap.h.

41 using const_iterator = typename Vec::const_iterator;

const_reverse_iterator

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

using LinkedMap< T, Hash, KeyEqual, Map >::const_reverse_iterator = typename Vec::const_reverse_iterator

Definition at line 43 of file linkedmap.h.

43 using const_reverse_iterator = typename Vec::const_reverse_iterator;

iterator

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

using LinkedMap< T, Hash, KeyEqual, Map >::iterator = typename Vec::iterator

Definition at line 40 of file linkedmap.h.

40 using iterator = typename Vec::iterator;

Ptr

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

using LinkedMap< T, Hash, KeyEqual, Map >::Ptr = std::unique_ptr<T>

Definition at line 38 of file linkedmap.h.

38 using Ptr = std::unique_ptr<T>;

reverse_iterator

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

using LinkedMap< T, Hash, KeyEqual, Map >::reverse_iterator = typename Vec::reverse_iterator

Definition at line 42 of file linkedmap.h.

42 using reverse_iterator = typename Vec::reverse_iterator;

Vec

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

using LinkedMap< T, Hash, KeyEqual, Map >::Vec = std::vector<Ptr>

Definition at line 39 of file linkedmap.h.

39 using Vec = std::vector<Ptr>;

Public Operators

operator[]()

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

Ptr & LinkedMap< T, Hash, KeyEqual, Map >::operator[] (size_t pos)

inline

Definition at line 199 of file linkedmap.h.

199 Ptr &operator[](size_t pos) { return m_entries[pos]; }

Reference LinkedMap< T, Hash, KeyEqual, Map >::m_entries.

operator[]()

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

const Ptr & LinkedMap< T, Hash, KeyEqual, Map >::operator[] (size_t pos)

inline

Definition at line 200 of file linkedmap.h.

200 const Ptr &operator[](size_t pos) const { return m_entries[pos]; }

Reference LinkedMap< T, Hash, KeyEqual, Map >::m_entries.

Public Member Functions

add()

template <class... Args>

T * LinkedMap< T, Hash, KeyEqual, Map >::add (const char * k, Args &&... args)

inline

Adds a new object to the ordered vector if it was not added already. Return a non-owning pointer to the newly added object, or to the existing object if it was already inserted before under the given key.

Definition at line 90 of file linkedmap.h.

90 [[maybe_unused]] T *add(const char *k, Args&&... args)

91 {

92 T *result = find(k);

93 if (result==nullptr)

94 {

95 std::string key(k ? k : "");

96 Ptr ptr = std::make_unique<T>(QCString(k),std::forward<Args>(args)...);

97 result = ptr.get();

98 m_lookup.emplace(key,result);

99 m_entries.push_back(std::move(ptr));

100 }

101 return result;

102 }

References LinkedMap< T, Hash, KeyEqual, Map >::find, LinkedMap< T, Hash, KeyEqual, Map >::m_entries and LinkedMap< T, Hash, KeyEqual, Map >::m_lookup.

Referenced by SectionManager::add, SectionManager::add, addEnumValuesToEnums, addXRefItem, findEnums, ClassDefImpl::mergeCategory, ClassDefImpl::mergeMembersFromBaseClasses, readDir, readFileOrDirectory and SectionManager::replace.

add()

template <class... Args>

T * LinkedMap< T, Hash, KeyEqual, Map >::add (const QCString & k, Args &&... args)

inline

Definition at line 105 of file linkedmap.h.

105 [[maybe_unused]] T *add(const QCString &k, Args&&... args)

106 {

107 std::string key = k.str();

108 T *result = find(key);

109 if (result==nullptr)

110 {

111 Ptr ptr = std::make_unique<T>(k,std::forward<Args>(args)...);

112 result = ptr.get();

113 m_lookup.emplace(key,result);

114 m_entries.push_back(std::move(ptr));

115 }

116 return result;

117 }

References LinkedMap< T, Hash, KeyEqual, Map >::find, LinkedMap< T, Hash, KeyEqual, Map >::m_entries, LinkedMap< T, Hash, KeyEqual, Map >::m_lookup and QCString::str.

add()

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

T * LinkedMap< T, Hash, KeyEqual, Map >::add (const char * k, Ptr && ptr)

inline

Adds an existing object to the ordered vector (unless another object was already added under the same key). Ownership is transferred. Return a non-owning pointer to the newly added object, or to the existing object if it was already inserted before under the given key.

Definition at line 123 of file linkedmap.h.

123 [[maybe_unused]] T *add(const char *k, Ptr &&ptr)

124 {

125 T *result = find(k);

126 if (result==nullptr)

127 {

128 std::string key(k ? k : "");

129 result = ptr.get();

130 m_lookup.emplace(key,result);

131 m_entries.push_back(std::move(ptr));

132 }

133 return result;

134 }

References LinkedMap< T, Hash, KeyEqual, Map >::find, LinkedMap< T, Hash, KeyEqual, Map >::m_entries and LinkedMap< T, Hash, KeyEqual, Map >::m_lookup.

add()

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

T * LinkedMap< T, Hash, KeyEqual, Map >::add (const QCString & k, Ptr && ptr)

inline

Definition at line 136 of file linkedmap.h.

136 [[maybe_unused]] T *add(const QCString &k, Ptr &&ptr)

137 {

138 std::string key = k.str();

139 T *result = find(key);

140 if (result==nullptr)

141 {

142 result = ptr.get();

143 m_lookup.emplace(key,result);

144 m_entries.push_back(std::move(ptr));

145 }

146 return result;

147 }

References LinkedMap< T, Hash, KeyEqual, Map >::find, LinkedMap< T, Hash, KeyEqual, Map >::m_entries, LinkedMap< T, Hash, KeyEqual, Map >::m_lookup and QCString::str.

begin()

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

iterator LinkedMap< T, Hash, KeyEqual, Map >::begin ()

inline

Definition at line 201 of file linkedmap.h.

201 iterator begin() { return m_entries.begin(); }

Reference LinkedMap< T, Hash, KeyEqual, Map >::m_entries.

begin()

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

const_iterator LinkedMap< T, Hash, KeyEqual, Map >::begin ()

inline

Definition at line 203 of file linkedmap.h.

203 const_iterator begin() const { return m_entries.cbegin(); }

Reference LinkedMap< T, Hash, KeyEqual, Map >::m_entries.

clear()

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

void LinkedMap< T, Hash, KeyEqual, Map >::clear ()

inline

Definition at line 212 of file linkedmap.h.

212 void clear()

213 {

214 m_entries.clear();

215 m_lookup.clear();

216 }

References LinkedMap< T, Hash, KeyEqual, Map >::m_entries and LinkedMap< T, Hash, KeyEqual, Map >::m_lookup.

Referenced by cleanUpDoxygen and clearAll.

del()

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

bool LinkedMap< T, Hash, KeyEqual, Map >::del (const QCString & key)

inline

Removes an object from the container and deletes it. Returns true if the object was deleted or false it is was not found.

Definition at line 183 of file linkedmap.h.

183 bool del(const QCString &key)

184 {

185 auto it = m_lookup.find(key.str());

186 if (it!=m_lookup.end())

187 {

188 auto vecit = std::find_if(m_entries.begin(),m_entries.end(),[obj=it->second](auto &el) { return el.get()==obj; });

189 if (vecit!=m_entries.end()) // should always be true

190 {

191 m_entries.erase(vecit);

192 m_lookup.erase(it);

193 return true;

194 }

195 }

196 return false;

197 }

References LinkedMap< T, Hash, KeyEqual, Map >::m_entries, LinkedMap< T, Hash, KeyEqual, Map >::m_lookup and QCString::str.

Referenced by ClassDefImpl::hideDerivedVariablesInPython.

empty()

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

bool LinkedMap< T, Hash, KeyEqual, Map >::empty ()

inline

Definition at line 209 of file linkedmap.h.

209 bool empty() const { return m_entries.empty(); }

Reference LinkedMap< T, Hash, KeyEqual, Map >::m_entries.

end()

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

iterator LinkedMap< T, Hash, KeyEqual, Map >::end ()

inline

Definition at line 202 of file linkedmap.h.

202 iterator end() { return m_entries.end(); }

Reference LinkedMap< T, Hash, KeyEqual, Map >::m_entries.

end()

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

const_iterator LinkedMap< T, Hash, KeyEqual, Map >::end ()

inline

Definition at line 204 of file linkedmap.h.

204 const_iterator end() const { return m_entries.cend(); }

Reference LinkedMap< T, Hash, KeyEqual, Map >::m_entries.

find()

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

const T * LinkedMap< T, Hash, KeyEqual, Map >::find (const std::string & key)

inline

Find an object given the key. Returns a pointer to the element if found or nullptr if it is not found.

Definition at line 47 of file linkedmap.h.

47 const T *find(const std::string &key) const

48 {

49 auto it = m_lookup.find(key);

50 return it!=m_lookup.end() ? it->second : nullptr;

51 }

Reference LinkedMap< T, Hash, KeyEqual, Map >::m_lookup.

Referenced by LinkedMap< T, Hash, KeyEqual, Map >::add, LinkedMap< T, Hash, KeyEqual, Map >::add, LinkedMap< T, Hash, KeyEqual, Map >::add, LinkedMap< T, Hash, KeyEqual, Map >::add, addAnchor, addEnumValuesToEnums, addRelatedPage, addSection, DefinitionImpl::addSectionsToDefinition, addXRefItem, computeMemberRelationsForBaseClass, DocAnchor::DocAnchor, DocHtmlCaption::DocHtmlCaption, DocRef::DocRef, LinkedMap< T, Hash, KeyEqual, Map >::find, LinkedMap< T, Hash, KeyEqual, Map >::find, LinkedMap< T, Hash, KeyEqual, Map >::find, LinkedMap< T, Hash, KeyEqual, Map >::find, findFileDef, findMainPage, findUsingDeclImports, PerlModGenerator::generatePerlModForPage, generateSqlite3ForPage, generateXMLForPage, ClassDefImpl::hideDerivedVariablesInPython, ClassDefImpl::mergeCategory, ClassDefImpl::mergeMembersFromBaseClasses, DocRoot::parse, DocSecRefItem::parse, DocSection::parse, DocXRefItem::parse, LinkedMap< T, Hash, KeyEqual, Map >::prepend, LinkedMap< T, Hash, KeyEqual, Map >::prepend, processSection, SectionManager::replace, resolveLink, resolveTypeDef, showFileDefMatches, PageDefImpl::writeDocumentation and writeGroupTreeNode.

find()

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

const T * LinkedMap< T, Hash, KeyEqual, Map >::find (const QCString & key)

inline

Find an object given the key. Returns a pointer to the element if found or nullptr if it is not found.

Definition at line 55 of file linkedmap.h.

55 const T *find(const QCString &key) const

56 {

57 auto it = m_lookup.find(key.str());

58 return it!=m_lookup.end() ? it->second : nullptr;

59 }

References LinkedMap< T, Hash, KeyEqual, Map >::m_lookup and QCString::str.

find()

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

const T * LinkedMap< T, Hash, KeyEqual, Map >::find (const char * key)

inline

Find an object given the key. Returns a pointer to the element if found or nullptr if it is not found.

Definition at line 63 of file linkedmap.h.

63 const T *find(const char *key) const

64 {

65 return find(std::string(key ? key : ""));

66 }

Reference LinkedMap< T, Hash, KeyEqual, Map >::find.

find()

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

T * LinkedMap< T, Hash, KeyEqual, Map >::find (const char * key)

inline

A non-const wrapper for find() const.

Definition at line 69 of file linkedmap.h.

69 T* find(const char *key)

70 {

71 return const_cast<T*>(static_cast<const LinkedMap&>(*this).find(key));

72 }

Reference LinkedMap< T, Hash, KeyEqual, Map >::find.

find()

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

T * LinkedMap< T, Hash, KeyEqual, Map >::find (const QCString & key)

inline

A non-const wrapper for find() const.

Definition at line 75 of file linkedmap.h.

75 T* find(const QCString &key)

76 {

77 return const_cast<T*>(static_cast<const LinkedMap&>(*this).find(key));

78 }

Reference LinkedMap< T, Hash, KeyEqual, Map >::find.

find()

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

T * LinkedMap< T, Hash, KeyEqual, Map >::find (const std::string & key)

inline

A non-const wrapper for find() const.

Definition at line 81 of file linkedmap.h.

81 T* find(const std::string &key)

82 {

83 return const_cast<T*>(static_cast<const LinkedMap&>(*this).find(key));

84 }

Reference LinkedMap< T, Hash, KeyEqual, Map >::find.

prepend()

template <class... Args>

T * LinkedMap< T, Hash, KeyEqual, Map >::prepend (const char * k, Args &&... args)

inline

Prepends a new object to the ordered vector if it was not added already. Return a non-owning pointer to the newly added object, or to the existing object if it was already inserted before under the given key.

Definition at line 153 of file linkedmap.h.

153 T *prepend(const char *k, Args&&... args)

154 {

155 T *result = find(k);

156 if (result==nullptr)

157 {

158 std::string key(k ? k : "");

159 Ptr ptr = std::make_unique<T>(key.c_str(),std::forward<Args>(args)...);

160 result = ptr.get();

161 m_lookup.emplace(key,result);

162 m_entries.push_front(std::move(ptr));

163 }

164 return result;

165 }

References LinkedMap< T, Hash, KeyEqual, Map >::find, LinkedMap< T, Hash, KeyEqual, Map >::m_entries and LinkedMap< T, Hash, KeyEqual, Map >::m_lookup.

prepend()

template <class... Args>

T * LinkedMap< T, Hash, KeyEqual, Map >::prepend (const QCString & key, Args &&... args)

inline

Definition at line 168 of file linkedmap.h.

168 T *prepend(const QCString &key, Args&&... args)

169 {

170 T *result = find(key);

171 if (result==nullptr)

172 {

173 Ptr ptr = std::make_unique<T>(key,std::forward<Args>(args)...);

174 result = ptr.get();

175 m_lookup.emplace(key.str(),result);

176 m_entries.push_front(std::move(ptr));

177 }

178 return result;

179 }

References LinkedMap< T, Hash, KeyEqual, Map >::find, LinkedMap< T, Hash, KeyEqual, Map >::m_entries, LinkedMap< T, Hash, KeyEqual, Map >::m_lookup and QCString::str.

rbegin()

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

reverse_iterator LinkedMap< T, Hash, KeyEqual, Map >::rbegin ()

inline

Definition at line 205 of file linkedmap.h.

205 reverse_iterator rbegin() { return m_entries.rbegin(); }

Reference LinkedMap< T, Hash, KeyEqual, Map >::m_entries.

rbegin()

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

const_reverse_iterator LinkedMap< T, Hash, KeyEqual, Map >::rbegin ()

inline

Definition at line 207 of file linkedmap.h.

207 const_reverse_iterator rbegin() const { return m_entries.crbegin(); }

Reference LinkedMap< T, Hash, KeyEqual, Map >::m_entries.

rend()

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

reverse_iterator LinkedMap< T, Hash, KeyEqual, Map >::rend ()

inline

Definition at line 206 of file linkedmap.h.

206 reverse_iterator rend() { return m_entries.rend(); }

Reference LinkedMap< T, Hash, KeyEqual, Map >::m_entries.

rend()

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

const_reverse_iterator LinkedMap< T, Hash, KeyEqual, Map >::rend ()

inline

Definition at line 208 of file linkedmap.h.

208 const_reverse_iterator rend() const { return m_entries.crend(); }

Reference LinkedMap< T, Hash, KeyEqual, Map >::m_entries.

size()

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

size_t LinkedMap< T, Hash, KeyEqual, Map >::size ()

inline

Definition at line 210 of file linkedmap.h.

210 size_t size() const { return m_entries.size(); }

Reference LinkedMap< T, Hash, KeyEqual, Map >::m_entries.

Referenced by computeClassRelations.

Private Member Attributes

m_entries

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

Vec LinkedMap< T, Hash, KeyEqual, Map >::m_entries

Definition at line 221 of file linkedmap.h.

221 Vec m_entries;

Referenced by LinkedMap< T, Hash, KeyEqual, Map >::add, LinkedMap< T, Hash, KeyEqual, Map >::add, LinkedMap< T, Hash, KeyEqual, Map >::add, LinkedMap< T, Hash, KeyEqual, Map >::add, LinkedMap< T, Hash, KeyEqual, Map >::begin, LinkedMap< T, Hash, KeyEqual, Map >::begin, LinkedMap< T, Hash, KeyEqual, Map >::clear, LinkedMap< T, Hash, KeyEqual, Map >::del, LinkedMap< T, Hash, KeyEqual, Map >::empty, LinkedMap< T, Hash, KeyEqual, Map >::end, LinkedMap< T, Hash, KeyEqual, Map >::end, LinkedMap< T, Hash, KeyEqual, Map >::operator[], LinkedMap< T, Hash, KeyEqual, Map >::operator[], LinkedMap< T, Hash, KeyEqual, Map >::prepend, LinkedMap< T, Hash, KeyEqual, Map >::prepend, LinkedMap< T, Hash, KeyEqual, Map >::rbegin, LinkedMap< T, Hash, KeyEqual, Map >::rbegin, LinkedMap< T, Hash, KeyEqual, Map >::rend, LinkedMap< T, Hash, KeyEqual, Map >::rend and LinkedMap< T, Hash, KeyEqual, Map >::size.

m_lookup

template <class T, class Hash = std::hash<std::string>, class KeyEqual = std::equal_to<std::string>, class Map = std::unordered_map<std::string,T*,Hash,KeyEqual >>

Map LinkedMap< T, Hash, KeyEqual, Map >::m_lookup

Definition at line 220 of file linkedmap.h.

220 Map m_lookup;

Referenced by LinkedMap< T, Hash, KeyEqual, Map >::add, LinkedMap< T, Hash, KeyEqual, Map >::add, LinkedMap< T, Hash, KeyEqual, Map >::add, LinkedMap< T, Hash, KeyEqual, Map >::add, LinkedMap< T, Hash, KeyEqual, Map >::clear, LinkedMap< T, Hash, KeyEqual, Map >::del, LinkedMap< T, Hash, KeyEqual, Map >::find, LinkedMap< T, Hash, KeyEqual, Map >::find, LinkedMap< T, Hash, KeyEqual, Map >::prepend and LinkedMap< T, Hash, KeyEqual, Map >::prepend.

---

The documentation for this class was generated from the following file:

• linkedmap.h

---

Generated via doxygen2docusaurus by Doxygen 1.14.0.