KratosMultiphysics
KRATOS Multiphysics (Kratos) is a framework for building parallel, multi-disciplinary simulation software, aiming at modularity, extensibility, and high performance. Kratos is written in C++, and counts with an extensive Python interface.
Classes | List of all members
Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType > Class Template Referencefinal

PointerVectorMap is a sorted associative container like stl map but using a vector to store pointers to its data. More...

#include <pointer_vector_map.h>

Collaboration diagram for Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >:

Public Member Functions

Life Cycle
 PointerVectorMap ()
 Default constructor. More...
 
 PointerVectorMap (const PointerVectorMap &rOther)
 
 PointerVectorMap (const TContainerType &rContainer)
 
 ~PointerVectorMap ()
 Destructor. More...
 
Operators
PointerVectorMap & operator= (const PointerVectorMap &rOther)
 
TDataType & operator[] (const key_type &Key)
 
pointer operator() (const key_type &Key)
 
Operations
iterator begin ()
 
const_iterator begin () const
 
iterator end ()
 
const_iterator end () const
 
reverse_iterator rbegin ()
 
const_reverse_iterator rbegin () const
 
reverse_iterator rend ()
 
const_reverse_iterator rend () const
 
pair_iterator pair_begin ()
 
pair_const_iterator pair_begin () const
 
pair_iterator pair_end ()
 
pair_const_iterator pair_end () const
 
pair_reverse_iterator pair_rbegin ()
 
pair_const_reverse_iterator pair_rbegin () const
 
pair_reverse_iterator pair_rend ()
 
pair_const_reverse_iterator pair_rend () const
 
reference front ()
 
const_reference front () const
 
reference back ()
 
const_reference back () const
 
size_type size () const
 
size_type max_size () const
 
key_compare key_comp () const
 
void swap (PointerVectorMap &rOther)
 
void push_back (value_type x)
 
iterator insert (key_type const &Key, const TDataType &rData)
 
iterator insert (key_type const &Key, const TPointerType pData)
 
iterator erase (iterator pos)
 
iterator erase (iterator first, iterator last)
 
iterator erase (const key_type &k)
 
void clear ()
 
iterator find (const key_type &Key)
 
const_iterator find (const key_type &Key) const
 
size_type count (const key_type &Key)
 
TDataType & at (const key_type &Key)
 
TDataType & at (const key_type &Key) const
 
void Sort ()
 
Access
TContainerType & GetContainer ()
 
const TContainerType & GetContainer () const
 
size_type GetMaxBufferSize () const
 Get the maximum size of buffer used in the container. More...
 
void SetMaxBufferSize (const size_type NewSize)
 Set the maximum size of buffer used in the container. More...
 
size_type GetSortedPartSize () const
 Get the sorted part size of buffer used in the container. More...
 
void SetSortedPartSize (const size_type NewSize)
 Set the sorted part size of buffer used in the container. More...
 
Inquiry
bool empty () const
 
bool IsSorted () const
 
Input and output
std::string Info () const
 Turn back information as a string. More...
 
void PrintInfo (std::ostream &rOStream) const
 Print information about this object. More...
 
void PrintData (std::ostream &rOStream) const
 Print object's data. More...
 

Type Definitions

typedef TKeyType key_type
 Key type for searching in this container. More...
 
typedef TDataType data_type
 data type stores in this container. More...
 
typedef std::pair< TKeyType, TPointerType > value_type
 
typedef TCompareType key_compare
 
typedef TPointerType pointer
 
typedef TDataType & reference
 
typedef const TDataType & const_reference
 
typedef TContainerType ContainerType
 
typedef PointerVectorMapIterator< typename TContainerType::iterator, TDataType > iterator
 
typedef PointerVectorMapIterator< typename TContainerType::const_iterator, TDataType > const_iterator
 
typedef PointerVectorMapIterator< typename TContainerType::reverse_iterator, TDataType > reverse_iterator
 
typedef PointerVectorMapIterator< typename TContainerType::const_reverse_iterator, TDataType > const_reverse_iterator
 
typedef TContainerType::size_type size_type
 
typedef TContainerType::iterator pair_iterator
 
typedef TContainerType::const_iterator pair_const_iterator
 
typedef TContainerType::reverse_iterator pair_reverse_iterator
 
typedef TContainerType::const_reverse_iterator pair_const_reverse_iterator
 
 KRATOS_CLASS_POINTER_DEFINITION (PointerVectorMap)
 Pointer definition of PointerVectorMap. More...
 

Serialization

class Serializer
 

Detailed Description

template<class TKeyType, class TDataType, class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
class Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >

PointerVectorMap is a sorted associative container like stl map but using a vector to store pointers to its data.

PointerVectorMap is a sorted associative container like stl map but using a vector to store pointers its data.

This Container unlike the boost one does not free the memory by itself and relies on using of counted pointers or manual deleting.

Member Typedef Documentation

◆ const_iterator

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
typedef PointerVectorMapIterator<typename TContainerType::const_iterator, TDataType> Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::const_iterator

◆ const_reference

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
typedef const TDataType& Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::const_reference

◆ const_reverse_iterator

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
typedef PointerVectorMapIterator<typename TContainerType::const_reverse_iterator, TDataType> Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::const_reverse_iterator

◆ ContainerType

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
typedef TContainerType Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::ContainerType

◆ data_type

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
typedef TDataType Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::data_type

data type stores in this container.

◆ iterator

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
typedef PointerVectorMapIterator<typename TContainerType::iterator, TDataType> Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::iterator

◆ key_compare

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
typedef TCompareType Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::key_compare

◆ key_type

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
typedef TKeyType Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::key_type

Key type for searching in this container.

◆ pair_const_iterator

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
typedef TContainerType::const_iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::pair_const_iterator

◆ pair_const_reverse_iterator

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
typedef TContainerType::const_reverse_iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::pair_const_reverse_iterator

◆ pair_iterator

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
typedef TContainerType::iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::pair_iterator

◆ pair_reverse_iterator

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
typedef TContainerType::reverse_iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::pair_reverse_iterator

◆ pointer

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
typedef TPointerType Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::pointer

◆ reference

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
typedef TDataType& Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::reference

◆ reverse_iterator

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
typedef PointerVectorMapIterator<typename TContainerType::reverse_iterator, TDataType> Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::reverse_iterator

◆ size_type

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
typedef TContainerType::size_type Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::size_type

◆ value_type

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
typedef std::pair<TKeyType, TPointerType> Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::value_type

Constructor & Destructor Documentation

◆ PointerVectorMap() [1/3]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::PointerVectorMap ( )
inline

Default constructor.

◆ PointerVectorMap() [2/3]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::PointerVectorMap ( const PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType > &  rOther)
inline

◆ PointerVectorMap() [3/3]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::PointerVectorMap ( const TContainerType &  rContainer)
inlineexplicit

◆ ~PointerVectorMap()

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::~PointerVectorMap ( )
inline

Destructor.

Member Function Documentation

◆ at() [1/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
TDataType& Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::at ( const key_type &  Key)
inline

◆ at() [2/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
TDataType& Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::at ( const key_type &  Key) const
inline

◆ back() [1/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
reference Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::back ( )
inline

◆ back() [2/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
const_reference Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::back ( ) const
inline

◆ begin() [1/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::begin ( )
inline

◆ begin() [2/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
const_iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::begin ( ) const
inline

◆ clear()

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
void Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::clear ( )
inline

◆ count()

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
size_type Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::count ( const key_type &  Key)
inline

◆ empty()

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
bool Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::empty ( ) const
inline

◆ end() [1/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::end ( )
inline

◆ end() [2/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
const_iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::end ( ) const
inline

◆ erase() [1/3]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::erase ( const key_type &  k)
inline

◆ erase() [2/3]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::erase ( iterator  first,
iterator  last 
)
inline

◆ erase() [3/3]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::erase ( iterator  pos)
inline

◆ find() [1/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::find ( const key_type &  Key)
inline

◆ find() [2/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
const_iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::find ( const key_type &  Key) const
inline

◆ front() [1/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
reference Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::front ( )
inline

◆ front() [2/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
const_reference Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::front ( ) const
inline

◆ GetContainer() [1/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
TContainerType& Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::GetContainer ( )
inline

Gives a reference to underly normal container.

◆ GetContainer() [2/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
const TContainerType& Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::GetContainer ( ) const
inline

Gives a constant reference to underly normal container.

◆ GetMaxBufferSize()

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
size_type Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::GetMaxBufferSize ( ) const
inline

Get the maximum size of buffer used in the container.

◆ GetSortedPartSize()

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
size_type Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::GetSortedPartSize ( ) const
inline

Get the sorted part size of buffer used in the container.

◆ Info()

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
std::string Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::Info ( ) const
inline

Turn back information as a string.

◆ insert() [1/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::insert ( key_type const &  Key,
const TDataType &  rData 
)
inline

◆ insert() [2/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::insert ( key_type const &  Key,
const TPointerType  pData 
)
inline

◆ IsSorted()

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
bool Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::IsSorted ( ) const
inline

◆ key_comp()

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
key_compare Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::key_comp ( ) const
inline

◆ KRATOS_CLASS_POINTER_DEFINITION()

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::KRATOS_CLASS_POINTER_DEFINITION ( PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >  )

Pointer definition of PointerVectorMap.

◆ max_size()

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
size_type Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::max_size ( ) const
inline

◆ operator()()

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
pointer Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::operator() ( const key_type &  Key)
inline

◆ operator=()

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
PointerVectorMap& Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::operator= ( const PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType > &  rOther)
inline

◆ operator[]()

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
TDataType& Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::operator[] ( const key_type &  Key)
inline

◆ pair_begin() [1/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
pair_iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::pair_begin ( )
inline

◆ pair_begin() [2/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
pair_const_iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::pair_begin ( ) const
inline

◆ pair_end() [1/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
pair_iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::pair_end ( )
inline

◆ pair_end() [2/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
pair_const_iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::pair_end ( ) const
inline

◆ pair_rbegin() [1/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
pair_reverse_iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::pair_rbegin ( )
inline

◆ pair_rbegin() [2/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
pair_const_reverse_iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::pair_rbegin ( ) const
inline

◆ pair_rend() [1/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
pair_reverse_iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::pair_rend ( )
inline

◆ pair_rend() [2/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
pair_const_reverse_iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::pair_rend ( ) const
inline

◆ PrintData()

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
void Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::PrintData ( std::ostream &  rOStream) const
inline

Print object's data.

◆ PrintInfo()

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
void Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::PrintInfo ( std::ostream &  rOStream) const
inline

Print information about this object.

◆ push_back()

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
void Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::push_back ( value_type  x)
inline

◆ rbegin() [1/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
reverse_iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::rbegin ( )
inline

◆ rbegin() [2/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
const_reverse_iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::rbegin ( ) const
inline

◆ rend() [1/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
reverse_iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::rend ( )
inline

◆ rend() [2/2]

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
const_reverse_iterator Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::rend ( ) const
inline

◆ SetMaxBufferSize()

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
void Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::SetMaxBufferSize ( const size_type  NewSize)
inline

Set the maximum size of buffer used in the container.

This container uses a buffer which keep data unsorted. After buffer size arrived to the MaxBufferSize it will sort all container and empties buffer.

Parameters
NewSizeIs the new buffer maximum size.

◆ SetSortedPartSize()

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
void Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::SetSortedPartSize ( const size_type  NewSize)
inline

Set the sorted part size of buffer used in the container.

Parameters
NewSizeIs the new buffer maximum size.

◆ size()

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
size_type Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::size ( ) const
inline

◆ Sort()

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
void Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::Sort ( )
inline

◆ swap()

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
void Kratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >::swap ( PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType > &  rOther)
inline

Friends And Related Function Documentation

◆ Serializer

template<class TKeyType , class TDataType , class TCompareType = std::less<TKeyType>, class TPointerType = Kratos::shared_ptr<TDataType>, class TContainerType = std::vector<std::pair<TKeyType, TPointerType> >>
friend class Serializer
friend
The documentation for this class was generated from the following file:
Generated on Sat Feb 3 2024 02:51:01 for KratosMultiphysics by doxygen 1.9.1