BDE 4.14.0 Production release
Loading...
Searching...
No Matches
Classes | Public Types | Public Member Functions | List of all members
bsl::pair< T1, T2 > Class Template Reference

#include <bslstl_pair.h>

Inheritance diagram for bsl::pair< T1, T2 >:
bsl::Pair_First< T1 > bsl::Pair_Second< T2 >

Public Types

typedef T1 first_type
 
typedef T2 second_type
 

Public Member Functions

BSLS_KEYWORD_CONSTEXPR pair ()
 
 pair (BloombergLP::bslma::Allocator *basicAllocator)
 
 pair (const pair &original, BloombergLP::bslma::Allocator *basicAllocator)
 
BSLS_KEYWORD_CONSTEXPR pair (BloombergLP::bslmf::MovableRef< pair > original)
 
 pair (BloombergLP::bslmf::MovableRef< pair > original, BloombergLP::bslma::Allocator *basicAllocator)
 
BSLS_KEYWORD_CONSTEXPR pair (typename bsl::add_lvalue_reference< const T1 >::type a, typename bsl::add_lvalue_reference< const T2 >::type b)
 
 pair (typename bsl::add_lvalue_reference< const T1 >::type a, typename bsl::add_lvalue_reference< const T2 >::type b, BloombergLP::bslma::Allocator *basicAllocator)
 
template<class PARAM_1 , class PARAM_2 >
BSLS_KEYWORD_CONSTEXPR pair (const PARAM_1 &a, const PARAM_2 &b, typename bsl::enable_if< bsl::is_convertible< PARAM_1, T1 >::value &&bsl::is_convertible< PARAM_2, T2 >::value &&!(bsl::is_pointer< typename bsl::remove_reference< PARAM_2 >::type >::value &&bsl::is_convertible< PARAM_2, BloombergLP::bslma::Allocator * >::value), SfinaeEnable >::type=SfinaeEnable())
 
template<class PARAM_1 , class PARAM_2 >
 pair (const PARAM_1 &a, const PARAM_2 &b, BloombergLP::bslma::Allocator *basicAllocator)
 
template<class PARAM_1 , class PARAM_2 >
BSLS_KEYWORD_CONSTEXPR pair (PARAM_1 &a, const PARAM_2 &b, typename bsl::enable_if< bsl::is_convertible< PARAM_1, T1 >::value &&bsl::is_convertible< PARAM_2, T2 >::value &&!(bsl::is_pointer< typename bsl::remove_reference< PARAM_2 >::type >::value &&bsl::is_convertible< PARAM_2, BloombergLP::bslma::Allocator * >::value), SfinaeEnable >::type=SfinaeEnable())
 
template<class PARAM_1 , class PARAM_2 >
 pair (PARAM_1 &a, const PARAM_2 &b, BloombergLP::bslma::Allocator *basicAllocator)
 
template<class PARAM_1 , class PARAM_2 >
BSLS_KEYWORD_CONSTEXPR pair (const PARAM_1 &a, PARAM_2 &b, typename bsl::enable_if< bsl::is_convertible< PARAM_1, T1 >::value &&bsl::is_convertible< PARAM_2, T2 >::value &&!(bsl::is_pointer< typename bsl::remove_reference< PARAM_2 >::type >::value &&bsl::is_convertible< PARAM_2, BloombergLP::bslma::Allocator * >::value), SfinaeEnable >::type=SfinaeEnable())
 
template<class PARAM_1 , class PARAM_2 >
 pair (const PARAM_1 &a, PARAM_2 &b, BloombergLP::bslma::Allocator *basicAllocator)
 
template<class PARAM_1 , class PARAM_2 >
BSLS_KEYWORD_CONSTEXPR pair (PARAM_1 &a, PARAM_2 &b, typename bsl::enable_if< bsl::is_convertible< PARAM_1, T1 >::value &&bsl::is_convertible< PARAM_2, T2 >::value &&!(bsl::is_pointer< typename bsl::remove_reference< PARAM_2 >::type >::value &&bsl::is_convertible< PARAM_2, BloombergLP::bslma::Allocator * >::value), SfinaeEnable >::type=SfinaeEnable())
 
template<class PARAM_1 , class PARAM_2 >
 pair (PARAM_1 &a, PARAM_2 &b, BloombergLP::bslma::Allocator *basicAllocator)
 
template<class PARAM_1 , class PARAM_2 >
BSLS_KEYWORD_CONSTEXPR pair (const pair< PARAM_1, PARAM_2 > &other, typename bsl::enable_if< std::is_constructible< T1, const PARAM_1 & >::value &&std::is_constructible< T2, const PARAM_2 & >::value, SfinaeEnable >::type=SfinaeEnable())
 
template<class PARAM_1 , class PARAM_2 >
BSLS_KEYWORD_CONSTEXPR pair (const std::pair< PARAM_1, PARAM_2 > &other, typename bsl::enable_if< std::is_constructible< T1, const PARAM_1 & >::value &&std::is_constructible< T2, const PARAM_2 & >::value, SfinaeEnable >::type=SfinaeEnable())
 
template<class PARAM_1 , class PARAM_2 >
 pair (const pair< PARAM_1, PARAM_2 > &other, BloombergLP::bslma::Allocator *basicAllocator)
 
template<class PARAM_1 , class PARAM_2 >
 pair (const std::pair< PARAM_1, PARAM_2 > &other, BloombergLP::bslma::Allocator *basicAllocator)
 
template<class PARAM_1 , class PARAM_2 >
BSLS_KEYWORD_CONSTEXPR pair (BloombergLP::bslmf::MovableRef< pair< PARAM_1, PARAM_2 > > other, typename bsl::enable_if< bsl::is_convertible< PARAM_1, T1 >::value &&bsl::is_convertible< PARAM_2, T2 >::value, SfinaeEnable >::type=SfinaeEnable())
 
template<class PARAM_1 , class PARAM_2 >
BSLS_KEYWORD_CONSTEXPR pair (BloombergLP::bslmf::MovableRef< std::pair< PARAM_1, PARAM_2 > > other, typename bsl::enable_if< bsl::is_convertible< PARAM_1, T1 >::value &&bsl::is_convertible< PARAM_2, T2 >::value, SfinaeEnable >::type=SfinaeEnable())
 
template<class PARAM_1 , class PARAM_2 >
 pair (BloombergLP::bslmf::MovableRef< pair< PARAM_1, PARAM_2 > > other, BloombergLP::bslma::Allocator *basicAllocator)
 
template<class PARAM_1 , class PARAM_2 >
 pair (BloombergLP::bslmf::MovableRef< std::pair< PARAM_1, PARAM_2 > > other, BloombergLP::bslma::Allocator *basicAllocator)
 
template<class PARAM_1 , class PARAM_2 >
BSLS_KEYWORD_CONSTEXPR pair (const BloombergLP::bslma::ManagedPtr_PairProxy< PARAM_1, PARAM_2 > &rhs)
 
 ~pair ()=default
 
template<class PARAM_1 , class PARAM_2 >
pair & operator= (const pair< PARAM_1, PARAM_2 > &rhs)
 
pair & operator= (BloombergLP::bslmf::MovableRef< pair > rhs) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(false)
 
template<class PARAM_1 , class PARAM_2 >
pair & operator= (BloombergLP::bslmf::MovableRef< pair< PARAM_1, PARAM_2 > > rhs)
 
template<class PARAM_1 , class PARAM_2 >
pair & operator= (const std::pair< PARAM_1, PARAM_2 > &rhs)
 
template<class PARAM_1 , class PARAM_2 >
pair< T1, T2 > & operator= (const pair< PARAM_1, PARAM_2 > &rhs)
 
template<class PARAM_1 , class PARAM_2 >
pair< T1, T2 > & operator= (BloombergLP::bslmf::MovableRef< pair< PARAM_1, PARAM_2 > > rhs)
 
template<class PARAM_1 , class PARAM_2 >
pair< T1, T2 > & operator= (const std::pair< PARAM_1, PARAM_2 > &rhs)
 
- Public Member Functions inherited from bsl::Pair_First< T1 >
BSLS_KEYWORD_CONSTEXPR Pair_First ()
 
 Pair_First (BloombergLP::bslma::Allocator *basicAllocator, Pair_BslmaIdiomNone)
 
 Pair_First (BloombergLP::bslma::Allocator *basicAllocator, Pair_BslmaIdiomAtEnd)
 
 Pair_First (BloombergLP::bslma::Allocator *basicAllocator, Pair_BslmaIdiomAllocatorArgT)
 
BSLS_KEYWORD_CONSTEXPR Pair_First (typename bsl::add_lvalue_reference< const T1 >::type value)
 
BSLS_KEYWORD_CONSTEXPR Pair_First (const PARAM &value)
 
BSLS_KEYWORD_CONSTEXPR Pair_First (PARAM &value)
 
 Pair_First (const PARAM &value, BloombergLP::bslma::Allocator *basicAllocator, Pair_BslmaIdiomNone)
 
 Pair_First (PARAM &value, BloombergLP::bslma::Allocator *basicAllocator, Pair_BslmaIdiomNone)
 
 Pair_First (const PARAM &value, BloombergLP::bslma::Allocator *basicAllocator, Pair_BslmaIdiomAtEnd)
 
 Pair_First (PARAM &value, BloombergLP::bslma::Allocator *basicAllocator, Pair_BslmaIdiomAtEnd)
 
 Pair_First (const PARAM &value, BloombergLP::bslma::Allocator *basicAllocator, Pair_BslmaIdiomAllocatorArgT)
 
 Pair_First (PARAM &value, BloombergLP::bslma::Allocator *basicAllocator, Pair_BslmaIdiomAllocatorArgT)
 
 Pair_First (const Pair_First &)=default
 
 Pair_First (Pair_First &&)=default
 
Pair_First & operator= (Pair_First &&)=default
 
 ~Pair_First ()=default
 

Additional Inherited Members

- Public Attributes inherited from bsl::Pair_First< T1 >
T1 first
 
- Protected Member Functions inherited from bsl::Pair_Second< T2 >
BSLS_KEYWORD_CONSTEXPR Pair_Second ()
 
 Pair_Second (BloombergLP::bslma::Allocator *basicAllocator, Pair_BslmaIdiomNone)
 
 Pair_Second (BloombergLP::bslma::Allocator *basicAllocator, Pair_BslmaIdiomAtEnd)
 
 Pair_Second (BloombergLP::bslma::Allocator *basicAllocator, Pair_BslmaIdiomAllocatorArgT)
 
BSLS_KEYWORD_CONSTEXPR Pair_Second (typename bsl::add_lvalue_reference< const T2 >::type value)
 
BSLS_KEYWORD_CONSTEXPR Pair_Second (const PARAM &value)
 
BSLS_KEYWORD_CONSTEXPR Pair_Second (PARAM &value)
 
 Pair_Second (const PARAM &value, BloombergLP::bslma::Allocator *basicAllocator, Pair_BslmaIdiomNone)
 
 Pair_Second (PARAM &value, BloombergLP::bslma::Allocator *basicAllocator, Pair_BslmaIdiomNone)
 
 Pair_Second (const PARAM &value, BloombergLP::bslma::Allocator *basicAllocator, Pair_BslmaIdiomAtEnd)
 
 Pair_Second (PARAM &value, BloombergLP::bslma::Allocator *basicAllocator, Pair_BslmaIdiomAtEnd)
 
 Pair_Second (const PARAM &value, BloombergLP::bslma::Allocator *basicAllocator, Pair_BslmaIdiomAllocatorArgT)
 
 Pair_Second (PARAM &value, BloombergLP::bslma::Allocator *basicAllocator, Pair_BslmaIdiomAllocatorArgT)
 
 Pair_Second (const Pair_Second &)=default
 
 Pair_Second (Pair_Second &&)=default
 
Pair_Second & operator= (Pair_Second &&)=default
 
 ~Pair_Second ()=default
 
- Protected Attributes inherited from bsl::Pair_Second< T2 >
T2 second
 

Detailed Description

template<class T1, class T2>
class bsl::pair< T1, T2 >

The class template pair provides a pair of public data members, first and second, of type T1 and T2 respectively. If either T1 or T2 uses bslma::Allocator for memory management, then provide an optional bslma::Allocator argument for each constructor, to be passed through to the constructors of first and/or second as appropriate. The interface to this class is identical to the standard std::pair except for the addition of the allocators. Note that the implementation of this class provides first and second through multiple base classes in order to simplify construction of each member when allowing for the various rules for passing allocators in C++11.

See bslstl_pair

Member Typedef Documentation

◆ first_type

template<class T1 , class T2 >
typedef T1 bsl::pair< T1, T2 >::first_type

◆ second_type

template<class T1 , class T2 >
typedef T2 bsl::pair< T1, T2 >::second_type

Constructor & Destructor Documentation

◆ pair() [1/24]

template<class T1 , class T2 >
BSLS_KEYWORD_CONSTEXPR bsl::pair< T1, T2 >::pair ( )
inline

◆ pair() [2/24]

template<class T1 , class T2 >
bsl::pair< T1, T2 >::pair ( BloombergLP::bslma::Allocator *  basicAllocator)
inlineexplicit

Construct a pair with the first and second members initialized to default values. Optionally specify a basicAllocator, used to supply memory for each of first and second when its type (template parameter T1 or T2, respectively) uses bslma-style allocators. This method requires that T1 and T2 be default-constructible.

◆ pair() [3/24]

template<class T1 , class T2 >
bsl::pair< T1, T2 >::pair ( const pair< T1, T2 > &  original,
BloombergLP::bslma::Allocator *  basicAllocator 
)
inline

Construct a pair having the same value as that of the specified original pair. Optionally specify a basicAllocator, used to supply memory for each of first and second when its type (template parameter T1 or T2, respectively) uses bslma-style allocators. Note that the copy constructor is implicitly declared (if T1 and T2 are both copy-constructible) by compilers that do not support defaulted declarations.

◆ pair() [4/24]

template<class T1 , class T2 >
BSLS_KEYWORD_CONSTEXPR bsl::pair< T1, T2 >::pair ( BloombergLP::bslmf::MovableRef< pair< T1, T2 > >  original)
inline

◆ pair() [5/24]

template<class T1 , class T2 >
BSLS_KEYWORD_CONSTEXPR bsl::pair< T1, T2 >::pair ( BloombergLP::bslmf::MovableRef< pair< T1, T2 > >  original,
BloombergLP::bslma::Allocator *  basicAllocator 
)
inline

Construct a pair having the same value as that of the specified original before the call to the move constructor. Optionally specify a basicAllocator, used to supply memory for each of first and second when its type (template parameter T1 or T2, respectively) uses bslma-style allocators. Note that original is left in a valid but unspecified state. Also note that this method requires that T1 and T2 be move-constructible. Note that the move constructor is implicitly declared (if T1 and T2 are both move-constructible) by compilers that do not support defaulted declarations, but do support rvalue references.

◆ pair() [6/24]

template<class T1 , class T2 >
BSLS_KEYWORD_CONSTEXPR bsl::pair< T1, T2 >::pair ( typename bsl::add_lvalue_reference< const T1 >::type  a,
typename bsl::add_lvalue_reference< const T2 >::type  b 
)
inline

◆ pair() [7/24]

template<class T1 , class T2 >
bsl::pair< T1, T2 >::pair ( typename bsl::add_lvalue_reference< const T1 >::type  a,
typename bsl::add_lvalue_reference< const T2 >::type  b,
BloombergLP::bslma::Allocator *  basicAllocator 
)
inline

Construct a pair with the first member initialized to the specified a value and the second member initialized to the specified b value. Optionally specify a basicAllocator, used to supply memory for each of first and second when its type (template parameter T1 or T2, respectively) uses bslma-style allocators. This method requires that T1 and T2 be copy-constructible.

◆ pair() [8/24]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
BSLS_KEYWORD_CONSTEXPR bsl::pair< T1, T2 >::pair ( const PARAM_1 &  a,
const PARAM_2 &  b,
typename bsl::enable_if< bsl::is_convertible< PARAM_1, T1 >::value &&bsl::is_convertible< PARAM_2, T2 >::value &&!(bsl::is_pointer< typename bsl::remove_reference< PARAM_2 >::type >::value &&bsl::is_convertible< PARAM_2, BloombergLP::bslma::Allocator * >::value), SfinaeEnable >::type  = SfinaeEnable() 
)
inline

◆ pair() [9/24]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
bsl::pair< T1, T2 >::pair ( const PARAM_1 &  a,
const PARAM_2 &  b,
BloombergLP::bslma::Allocator *  basicAllocator 
)
inline

◆ pair() [10/24]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
BSLS_KEYWORD_CONSTEXPR bsl::pair< T1, T2 >::pair ( PARAM_1 &  a,
const PARAM_2 &  b,
typename bsl::enable_if< bsl::is_convertible< PARAM_1, T1 >::value &&bsl::is_convertible< PARAM_2, T2 >::value &&!(bsl::is_pointer< typename bsl::remove_reference< PARAM_2 >::type >::value &&bsl::is_convertible< PARAM_2, BloombergLP::bslma::Allocator * >::value), SfinaeEnable >::type  = SfinaeEnable() 
)
inline

◆ pair() [11/24]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
bsl::pair< T1, T2 >::pair ( PARAM_1 &  a,
const PARAM_2 &  b,
BloombergLP::bslma::Allocator *  basicAllocator 
)
inline

◆ pair() [12/24]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
BSLS_KEYWORD_CONSTEXPR bsl::pair< T1, T2 >::pair ( const PARAM_1 &  a,
PARAM_2 &  b,
typename bsl::enable_if< bsl::is_convertible< PARAM_1, T1 >::value &&bsl::is_convertible< PARAM_2, T2 >::value &&!(bsl::is_pointer< typename bsl::remove_reference< PARAM_2 >::type >::value &&bsl::is_convertible< PARAM_2, BloombergLP::bslma::Allocator * >::value), SfinaeEnable >::type  = SfinaeEnable() 
)
inline

◆ pair() [13/24]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
bsl::pair< T1, T2 >::pair ( const PARAM_1 &  a,
PARAM_2 &  b,
BloombergLP::bslma::Allocator *  basicAllocator 
)
inline

◆ pair() [14/24]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
BSLS_KEYWORD_CONSTEXPR bsl::pair< T1, T2 >::pair ( PARAM_1 &  a,
PARAM_2 &  b,
typename bsl::enable_if< bsl::is_convertible< PARAM_1, T1 >::value &&bsl::is_convertible< PARAM_2, T2 >::value &&!(bsl::is_pointer< typename bsl::remove_reference< PARAM_2 >::type >::value &&bsl::is_convertible< PARAM_2, BloombergLP::bslma::Allocator * >::value), SfinaeEnable >::type  = SfinaeEnable() 
)
inline

◆ pair() [15/24]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
bsl::pair< T1, T2 >::pair ( PARAM_1 &  a,
PARAM_2 &  b,
BloombergLP::bslma::Allocator *  basicAllocator 
)
inline

◆ pair() [16/24]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
BSLS_KEYWORD_CONSTEXPR bsl::pair< T1, T2 >::pair ( const pair< PARAM_1, PARAM_2 > &  other,
typename bsl::enable_if< std::is_constructible< T1, const PARAM_1 & >::value &&std::is_constructible< T2, const PARAM_2 & >::value, SfinaeEnable >::type  = SfinaeEnable() 
)
inline

◆ pair() [17/24]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
BSLS_KEYWORD_CONSTEXPR bsl::pair< T1, T2 >::pair ( const std::pair< PARAM_1, PARAM_2 > &  other,
typename bsl::enable_if< std::is_constructible< T1, const PARAM_1 & >::value &&std::is_constructible< T2, const PARAM_2 & >::value, SfinaeEnable >::type  = SfinaeEnable() 
)
inline

◆ pair() [18/24]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
bsl::pair< T1, T2 >::pair ( const pair< PARAM_1, PARAM_2 > &  other,
BloombergLP::bslma::Allocator *  basicAllocator 
)
inline

Construct a pair from the specified other pair, holding first and second values of (template parameter) type PARAM_1 and PARAM_2 respectively. Optionally specify a basicAllocator, used to supply memory for each of first and second when its type (template parameter T1 or T2, respectively) uses bslma-style allocators. This method requires that T1 and T2 be convertible from PARAM_1 and PARAM_2, respectively.

◆ pair() [19/24]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
bsl::pair< T1, T2 >::pair ( const std::pair< PARAM_1, PARAM_2 > &  other,
BloombergLP::bslma::Allocator *  basicAllocator 
)
inline

◆ pair() [20/24]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
BSLS_KEYWORD_CONSTEXPR bsl::pair< T1, T2 >::pair ( BloombergLP::bslmf::MovableRef< pair< PARAM_1, PARAM_2 > >  other,
typename bsl::enable_if< bsl::is_convertible< PARAM_1, T1 >::value &&bsl::is_convertible< PARAM_2, T2 >::value, SfinaeEnable >::type  = SfinaeEnable() 
)
inline

◆ pair() [21/24]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
BSLS_KEYWORD_CONSTEXPR bsl::pair< T1, T2 >::pair ( BloombergLP::bslmf::MovableRef< std::pair< PARAM_1, PARAM_2 > >  other,
typename bsl::enable_if< bsl::is_convertible< PARAM_1, T1 >::value &&bsl::is_convertible< PARAM_2, T2 >::value, SfinaeEnable >::type  = SfinaeEnable() 
)
inline

◆ pair() [22/24]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
bsl::pair< T1, T2 >::pair ( BloombergLP::bslmf::MovableRef< pair< PARAM_1, PARAM_2 > >  other,
BloombergLP::bslma::Allocator *  basicAllocator 
)

Construct a pair from the specified other pair, holding first and second values of (template parameter) type PARAM_1 and PARAM_2 respectively. Optionally specify a basicAllocator, used to supply memory for each of first and second when its type (template parameter T1 or T2, respectively) uses bslma-style allocators. This method requires that T1 and T2 be convertible from PARAM_1 and PARAM_2, respectively.

◆ pair() [23/24]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
bsl::pair< T1, T2 >::pair ( BloombergLP::bslmf::MovableRef< std::pair< PARAM_1, PARAM_2 > >  other,
BloombergLP::bslma::Allocator *  basicAllocator 
)

◆ pair() [24/24]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
BSLS_KEYWORD_CONSTEXPR bsl::pair< T1, T2 >::pair ( const BloombergLP::bslma::ManagedPtr_PairProxy< PARAM_1, PARAM_2 > &  rhs)

Create a pair that has the same value as the specified rhs pair proxy. The behavior is undefined unless T1 is constructible from PARAM_1 and T2 is constructible from from PARAM_2.

◆ ~pair()

template<class T1 , class T2 >
bsl::pair< T1, T2 >::~pair ( )
default

Member Function Documentation

◆ operator=() [1/7]

template<class T1 , class T2 >
pair< T1, T2 > & bsl::pair< T1, T2 >::operator= ( BloombergLP::bslmf::MovableRef< pair< T1, T2 > >  rhs)

◆ operator=() [2/7]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
pair & bsl::pair< T1, T2 >::operator= ( BloombergLP::bslmf::MovableRef< pair< PARAM_1, PARAM_2 > >  rhs)

Assign to this pair the value of the specified rhs pair, holding first and second values of (template parameter) types PARAM_1 and PARAM_2 respectively, and return a reference providing modifiable access to this object. This method requires that T1 be assignable from PARAM_1 and T2 be assignable from PARAM_2.

◆ operator=() [3/7]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
pair< T1, T2 > & bsl::pair< T1, T2 >::operator= ( BloombergLP::bslmf::MovableRef< pair< PARAM_1, PARAM_2 > >  rhs)

◆ operator=() [4/7]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
pair & bsl::pair< T1, T2 >::operator= ( const pair< PARAM_1, PARAM_2 > &  rhs)

Assign to this pair from the specified rhs pair, holding the parameterized types PARAM_1 and PARAM_2, and return a reference offering modifiable access to this object. Assign first the value in rhs.first and second the value in rhs.second. Attempted use of this assignment operator will not compile unless both T1 and T2 supply assignment operators, and T1 is assignable from PARAM_1 and T2 is assignable from PARAM_2.

◆ operator=() [5/7]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
pair< T1, T2 > & bsl::pair< T1, T2 >::operator= ( const pair< PARAM_1, PARAM_2 > &  rhs)
inline

◆ operator=() [6/7]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
pair & bsl::pair< T1, T2 >::operator= ( const std::pair< PARAM_1, PARAM_2 > &  rhs)

Assign to this pair from the specified rhs pair, where the type rhs is the pair type native to the compiler's library, holding the parameterized types PARAM_1 and PARAM_2, and return a reference offering modifiable access to this object. Assign first the value in rhs.first and second the value in rhs.second. Attempted use of this assignment operator will not compile unless both T1 and T2 supply assignment operators, and T1 is assignable from PARAM_1 and T2 is assignable from PARAM_2.

◆ operator=() [7/7]

template<class T1 , class T2 >
template<class PARAM_1 , class PARAM_2 >
pair< T1, T2 > & bsl::pair< T1, T2 >::operator= ( const std::pair< PARAM_1, PARAM_2 > &  rhs)
inline
The documentation for this class was generated from the following file: