The LinkedRefMap 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 LinkedRefMap<T, Hash, KeyEqual, Map> { ... }

Included Headers

#include <src/linkedmap.h>

Public Member Typedefs Index

template < ... >
using	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)
	non-const wrapper for find() const More...
template < ... >
T *	find (const QCString &key)
template < ... >
T *	find (const std::string &key)
	non-const wrapper for find() const More...
template < ... >
bool	add (const char *k, T *obj)
template < ... >
bool	add (const QCString &k, T *obj)
template < ... >
bool	prepend (const char *k, T *obj)
template < ... >
bool	prepend (const QCString &key, T *obj)
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 be efficiently be looked up given the key. Objects are not owned by the container, the container will only hold references. When adding objects the order of addition is kept, and used while iterating.

Definition at line 231 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 LinkedRefMap< T, Hash, KeyEqual, Map >::const_iterator = typename Vec::const_iterator

Definition at line 237 of file linkedmap.h.

237 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 LinkedRefMap< T, Hash, KeyEqual, Map >::const_reverse_iterator = typename Vec::const_reverse_iterator

Definition at line 239 of file linkedmap.h.

239 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 LinkedRefMap< T, Hash, KeyEqual, Map >::iterator = typename Vec::iterator

Definition at line 236 of file linkedmap.h.

236 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 LinkedRefMap< T, Hash, KeyEqual, Map >::Ptr = T*

Definition at line 234 of file linkedmap.h.

234 using 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 LinkedRefMap< T, Hash, KeyEqual, Map >::reverse_iterator = typename Vec::reverse_iterator

Definition at line 238 of file linkedmap.h.

238 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 LinkedRefMap< T, Hash, KeyEqual, Map >::Vec = std::vector<Ptr>

Definition at line 235 of file linkedmap.h.

235 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 & LinkedRefMap< T, Hash, KeyEqual, Map >::operator[] (size_t pos)

inline

Definition at line 364 of file linkedmap.h.

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

Reference LinkedRefMap< 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 & LinkedRefMap< T, Hash, KeyEqual, Map >::operator[] (size_t pos)

inline

Definition at line 365 of file linkedmap.h.

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

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

Public Member Functions

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 >>

bool LinkedRefMap< T, Hash, KeyEqual, Map >::add (const char * k, T * obj)

inline

Adds an object reference to the ordered vector if it was not added already. Return true if the reference was added, and false if an object with the same key was already added before

Definition at line 284 of file linkedmap.h.

284 bool add(const char *k, T* obj)

285 {

286 if (find(k)==nullptr) // new element

287 {

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

289 m_lookup.emplace(key,obj);

290 m_entries.push_back(obj);

291 return true;

292 }

293 else // already existing, don't add

294 {

295 return false;

296 }

297 }

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

Referenced by FileDefImpl::insertClass and NamespaceDefImpl::insertClass.

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 >>

bool LinkedRefMap< T, Hash, KeyEqual, Map >::add (const QCString & k, T * obj)

inline

Definition at line 299 of file linkedmap.h.

299 bool add(const QCString &k, T* obj)

300 {

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

302 if (find(key)==nullptr) // new element

303 {

304 m_lookup.emplace(key,obj);

305 m_entries.push_back(obj);

306 return true;

307 }

308 else // already existing, don't add

309 {

310 return false;

311 }

312 }

References LinkedRefMap< T, Hash, KeyEqual, Map >::find, LinkedRefMap< T, Hash, KeyEqual, Map >::m_entries, LinkedRefMap< 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 LinkedRefMap< T, Hash, KeyEqual, Map >::begin ()

inline

Definition at line 366 of file linkedmap.h.

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

Reference LinkedRefMap< 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 LinkedRefMap< T, Hash, KeyEqual, Map >::begin ()

inline

Definition at line 368 of file linkedmap.h.

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

Reference LinkedRefMap< 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 LinkedRefMap< T, Hash, KeyEqual, Map >::clear ()

inline

Definition at line 377 of file linkedmap.h.

377 void clear()

378 {

379 m_entries.clear();

380 m_lookup.clear();

381 }

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

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 LinkedRefMap< 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 348 of file linkedmap.h.

348 bool del(const QCString &key)

349 {

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

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

352 {

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

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

355 {

356 m_entries.erase(vecit);

357 m_lookup.erase(it);

358 return true;

359 }

360 }

361 return false;

362 }

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

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 LinkedRefMap< T, Hash, KeyEqual, Map >::empty ()

inline

Definition at line 374 of file linkedmap.h.

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

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

Referenced by findScopeFromQualifiedName, PerlModGenerator::generatePerlModForGroup, PerlModGenerator::generatePerlModForModule, PerlModGenerator::generatePerlModForNamespace, processTagLessClasses and writeGroupTreeNode.

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 LinkedRefMap< T, Hash, KeyEqual, Map >::end ()

inline

Definition at line 367 of file linkedmap.h.

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

Reference LinkedRefMap< 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 LinkedRefMap< T, Hash, KeyEqual, Map >::end ()

inline

Definition at line 369 of file linkedmap.h.

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

Reference LinkedRefMap< 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 * LinkedRefMap< T, Hash, KeyEqual, Map >::find (const std::string & key)

inline

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

Definition at line 243 of file linkedmap.h.

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

244 {

245 auto it = m_lookup.find(key);

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

247 }

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

Referenced by LinkedRefMap< T, Hash, KeyEqual, Map >::add, LinkedRefMap< T, Hash, KeyEqual, Map >::add, LinkedRefMap< T, Hash, KeyEqual, Map >::find, LinkedRefMap< T, Hash, KeyEqual, Map >::find, LinkedRefMap< T, Hash, KeyEqual, Map >::find, LinkedRefMap< T, Hash, KeyEqual, Map >::find, findGlobalMember, LinkedRefMap< T, Hash, KeyEqual, Map >::prepend and LinkedRefMap< T, Hash, KeyEqual, Map >::prepend.

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 * LinkedRefMap< T, Hash, KeyEqual, Map >::find (const QCString & key)

inline

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

Definition at line 251 of file linkedmap.h.

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

252 {

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

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

255 }

References LinkedRefMap< 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 * LinkedRefMap< T, Hash, KeyEqual, Map >::find (const char * key)

inline

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

Definition at line 259 of file linkedmap.h.

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

260 {

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

262 }

Reference LinkedRefMap< 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 * LinkedRefMap< T, Hash, KeyEqual, Map >::find (const char * key)

inline

non-const wrapper for find() const

Definition at line 265 of file linkedmap.h.

265 T* find(const char *key)

266 {

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

268 }

Reference LinkedRefMap< 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 * LinkedRefMap< T, Hash, KeyEqual, Map >::find (const QCString & key)

inline

Definition at line 270 of file linkedmap.h.

270 T* find(const QCString &key)

271 {

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

273 }

Reference LinkedRefMap< 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 * LinkedRefMap< T, Hash, KeyEqual, Map >::find (const std::string & key)

inline

non-const wrapper for find() const

Definition at line 276 of file linkedmap.h.

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

277 {

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

279 }

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

prepend()

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 LinkedRefMap< T, Hash, KeyEqual, Map >::prepend (const char * k, T * obj)

inline

Prepends an object reference to the ordered vector if it was not added already. Return true if the reference was added, and false if an object with the same key was already added before

Definition at line 317 of file linkedmap.h.

317 bool prepend(const char *k, T* obj)

318 {

319 if (find(k)==nullptr) // new element

320 {

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

322 m_lookup.emplace(key,obj);

323 m_entries.insert(m_entries.begin(),obj);

324 return true;

325 }

326 else // already existing, don't add

327 {

328 return false;

329 }

330 }

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

prepend()

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 LinkedRefMap< T, Hash, KeyEqual, Map >::prepend (const QCString & key, T * obj)

inline

Definition at line 332 of file linkedmap.h.

332 bool prepend(const QCString &key, T* obj)

333 {

334 if (find(key)==nullptr) // new element

335 {

336 m_lookup.emplace(key.str(),obj);

337 m_entries.insert(m_entries.begin(),obj);

338 return true;

339 }

340 else // already existing, don't add

341 {

342 return false;

343 }

344 }

References LinkedRefMap< T, Hash, KeyEqual, Map >::find, LinkedRefMap< T, Hash, KeyEqual, Map >::m_entries, LinkedRefMap< 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 LinkedRefMap< T, Hash, KeyEqual, Map >::rbegin ()

inline

Definition at line 370 of file linkedmap.h.

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

Reference LinkedRefMap< 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 LinkedRefMap< T, Hash, KeyEqual, Map >::rbegin ()

inline

Definition at line 372 of file linkedmap.h.

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

Reference LinkedRefMap< 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 LinkedRefMap< T, Hash, KeyEqual, Map >::rend ()

inline

Definition at line 371 of file linkedmap.h.

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

Reference LinkedRefMap< 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 LinkedRefMap< T, Hash, KeyEqual, Map >::rend ()

inline

Definition at line 373 of file linkedmap.h.

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

Reference LinkedRefMap< 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 LinkedRefMap< T, Hash, KeyEqual, Map >::size ()

inline

Definition at line 375 of file linkedmap.h.

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

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

Referenced by writeGroupTreeNode.

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 LinkedRefMap< T, Hash, KeyEqual, Map >::m_entries

Definition at line 385 of file linkedmap.h.

385 Vec m_entries;

Referenced by LinkedRefMap< T, Hash, KeyEqual, Map >::add, LinkedRefMap< T, Hash, KeyEqual, Map >::add, LinkedRefMap< T, Hash, KeyEqual, Map >::begin, LinkedRefMap< T, Hash, KeyEqual, Map >::begin, LinkedRefMap< T, Hash, KeyEqual, Map >::clear, LinkedRefMap< T, Hash, KeyEqual, Map >::del, LinkedRefMap< T, Hash, KeyEqual, Map >::empty, LinkedRefMap< T, Hash, KeyEqual, Map >::end, LinkedRefMap< T, Hash, KeyEqual, Map >::end, LinkedRefMap< T, Hash, KeyEqual, Map >::operator[], LinkedRefMap< T, Hash, KeyEqual, Map >::operator[], LinkedRefMap< T, Hash, KeyEqual, Map >::prepend, LinkedRefMap< T, Hash, KeyEqual, Map >::prepend, LinkedRefMap< T, Hash, KeyEqual, Map >::rbegin, LinkedRefMap< T, Hash, KeyEqual, Map >::rbegin, LinkedRefMap< T, Hash, KeyEqual, Map >::rend, LinkedRefMap< T, Hash, KeyEqual, Map >::rend and LinkedRefMap< 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 LinkedRefMap< T, Hash, KeyEqual, Map >::m_lookup

Definition at line 384 of file linkedmap.h.

384 Map m_lookup;

Referenced by LinkedRefMap< T, Hash, KeyEqual, Map >::add, LinkedRefMap< T, Hash, KeyEqual, Map >::add, LinkedRefMap< T, Hash, KeyEqual, Map >::clear, LinkedRefMap< T, Hash, KeyEqual, Map >::del, LinkedRefMap< T, Hash, KeyEqual, Map >::find, LinkedRefMap< T, Hash, KeyEqual, Map >::find, LinkedRefMap< T, Hash, KeyEqual, Map >::prepend and LinkedRefMap< 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.