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

#include <src/linkedmap.h>

Inheritance diagram for LinkedRefMap< T, Hash, KeyEqual, Map >:

Public Types
using	Ptr = T*

using	Vec = std::vector<Ptr>

using	iterator = typename Vec::iterator

using	const_iterator = typename Vec::const_iterator

using	reverse_iterator = typename Vec::reverse_iterator

using	const_reverse_iterator = typename Vec::const_reverse_iterator

Public Member Functions
const T *	find (const std::string &key) const
	find an object given the key.

const T *	find (const QCString &key) const
	find an object given the key.

const T *	find (const char *key) const
	find an object given the key.

T *	find (const char *key)
	non-const wrapper for find() const

T *	find (const QCString &key)

T *	find (const std::string &key)
	non-const wrapper for find() const

bool	add (const char k, T obj)
	Adds an object reference to the ordered vector if it was not added already.

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

bool	prepend (const char k, T obj)
	Prepends an object reference to the ordered vector if it was not added already.

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

bool	del (const QCString &key)
	Removes an object from the container and deletes it.

Ptr &	operator[] (size_t pos)

const Ptr &	operator[] (size_t pos) const

iterator	begin ()

iterator	end ()

const_iterator	begin () const

const_iterator	end () const

reverse_iterator	rbegin ()

reverse_iterator	rend ()

const_reverse_iterator	rbegin () const

const_reverse_iterator	rend () const

bool	empty () const

size_t	size () const

void	clear ()

Private Attributes
Map	m_lookup

Vec	m_entries

Detailed Description

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 >

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.

Member Typedef Documentation

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

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

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

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

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

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

Member Function Documentation

◆ add() [1/2]

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.

    {
      if (find(k)==nullptr) // new element
      {
        std::string key(k ? k : "");
        m_lookup.emplace(key,obj);
        m_entries.push_back(obj);
        return true;
      }
      else // already existing, don't add
      {
        return false;
      }
    }

References find(), m_entries, and m_lookup.

Referenced by FileDefImpl::insertClass(), and NamespaceDefImpl::insertClass().

◆ add() [2/2]

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.

    {
      std::string key = k.str();
      if (find(key)==nullptr) // new element
      {
        m_lookup.emplace(key,obj);
        m_entries.push_back(obj);
        return true;
      }
      else // already existing, don't add
      {
        return false;
      }
    }

References find(), m_entries, m_lookup, and QCString::str().

◆ begin() [1/2]

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{ return m_entries.begin(); }

References m_entries.

◆ begin() [2/2]

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 ( ) const

inline

Definition at line 368 of file linkedmap.h.

368{ return m_entries.cbegin(); }

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

    {
      m_entries.clear();
      m_lookup.clear();
    }

References m_entries, and 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.

    {
      auto it = m_lookup.find(key.str());
      if (it!=m_lookup.end())
      {
        auto vecit = std::find_if(m_entries.begin(),m_entries.end(),[obj=it->second](auto &el) { return el.get()==obj; });
        if (vecit!=m_entries.end()) // should always be true
        {
          m_entries.erase(vecit);
          m_lookup.erase(it);
          return true;
        }
      }
      return false;
    }

References m_entries, 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 ( ) const

inline

Definition at line 374 of file linkedmap.h.

374{ return m_entries.empty(); }

References m_entries.

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

◆ end() [1/2]

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{ return m_entries.end(); }

References m_entries.

◆ end() [2/2]

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 ( ) const

inline

Definition at line 369 of file linkedmap.h.

369{ return m_entries.cend(); }

References m_entries.

◆ find() [1/6]

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.

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

References find().

◆ find() [2/6]

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

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.

    {
      return find(std::string(key ? key : ""));
    }

References find().

◆ find() [3/6]

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.

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

References find().

◆ find() [4/6]

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

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.

    {
      auto it = m_lookup.find(key.str());
      return it!=m_lookup.end() ? it->second : nullptr;
    }

References m_lookup, and QCString::str().

◆ find() [5/6]

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.

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

References find().

◆ find() [6/6]

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

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.

    {
      auto it = m_lookup.find(key);
      return it!=m_lookup.end() ? it->second : nullptr;
    }

References m_lookup.

Referenced by add(), add(), find(), find(), find(), find(), findGlobalMember(), prepend(), and prepend().

◆ operator[]() [1/2]

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{ return m_entries[pos]; }

References m_entries.

◆ operator[]() [2/2]

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

inline

Definition at line 365 of file linkedmap.h.

365{ return m_entries[pos]; }

References m_entries.

◆ prepend() [1/2]

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.

    {
      if (find(k)==nullptr) // new element
      {
        std::string key(k ? k : "");
        m_lookup.emplace(key,obj);
        m_entries.insert(m_entries.begin(),obj);
        return true;
      }
      else // already existing, don't add
      {
        return false;
      }
    }

References find(), m_entries, and m_lookup.

◆ prepend() [2/2]

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.

    {
      if (find(key)==nullptr) // new element
      {
        m_lookup.emplace(key.str(),obj);
        m_entries.insert(m_entries.begin(),obj);
        return true;
      }
      else // already existing, don't add
      {
        return false;
      }
    }

References find(), m_entries, m_lookup, and QCString::str().

◆ rbegin() [1/2]

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{ return m_entries.rbegin(); }

References m_entries.

◆ rbegin() [2/2]

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 ( ) const

inline

Definition at line 372 of file linkedmap.h.

372{ return m_entries.crbegin(); }

References m_entries.

◆ rend() [1/2]

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{ return m_entries.rend(); }

References m_entries.

◆ rend() [2/2]

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 ( ) const

inline

Definition at line 373 of file linkedmap.h.

373{ return m_entries.crend(); }

References 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 ( ) const

inline

Definition at line 375 of file linkedmap.h.

375{ return m_entries.size(); }

References m_entries.

Referenced by writeGroupTreeNode().

Member Data Documentation

◆ 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

private

Definition at line 385 of file linkedmap.h.

Referenced by add(), add(), begin(), begin(), clear(), del(), empty(), end(), end(), operator[](), operator[](), prepend(), prepend(), rbegin(), rbegin(), rend(), rend(), and 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

private

Definition at line 384 of file linkedmap.h.

Referenced by add(), add(), clear(), del(), find(), find(), prepend(), and prepend().

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

src/linkedmap.h

Public Types

Public Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ const_iterator

◆ const_reverse_iterator

◆ iterator

◆ Ptr

◆ reverse_iterator

◆ Vec

Member Function Documentation

◆ add() [1/2]

◆ add() [2/2]

◆ begin() [1/2]

◆ begin() [2/2]

◆ clear()

◆ del()

◆ empty()

◆ end() [1/2]

◆ end() [2/2]

◆ find() [1/6]

◆ find() [2/6]

◆ find() [3/6]

◆ find() [4/6]

◆ find() [5/6]

◆ find() [6/6]

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ prepend() [1/2]

◆ prepend() [2/2]

◆ rbegin() [1/2]

◆ rbegin() [2/2]

◆ rend() [1/2]

◆ rend() [2/2]

◆ size()

Member Data Documentation

◆ m_entries

◆ m_lookup