bslstl_string.h File Reference

#include <bsls_ident.h>
#include <bslscm_version.h>
#include <bslstl_algorithm.h>
#include <bslstl_compare.h>
#include <bslstl_concepts.h>
#include <bslstl_hash.h>
#include <bslstl_isconvertibletocstring.h>
#include <bslstl_isconvertibletostringview.h>
#include <bslstl_iterator.h>
#include <bslstl_iteratorutil.h>
#include <bslstl_ranges.h>
#include <bslstl_stdexceptutil.h>
#include <bslstl_stringrefdata.h>
#include <bslstl_stringview.h>
#include <bslstl_stringviewlikeparam.h>
#include <bslalg_containerbase.h>
#include <bslalg_scalarprimitives.h>
#include <bslalg_typetraithasstliterators.h>
#include <bslh_hash.h>
#include <bslma_allocator.h>
#include <bslma_allocatortraits.h>
#include <bslma_allocatorutil.h>
#include <bslma_isstdallocator.h>
#include <bslma_bslallocator.h>
#include <bslma_usesbslmaallocator.h>
#include <bslmf_assert.h>
#include <bslmf_containercompatiblerange.h>
#include <bslmf_enableif.h>
#include <bslmf_integralconstant.h>
#include <bslmf_isaccessiblebaseof.h>
#include <bslmf_isbitwisemoveable.h>
#include <bslmf_isconvertible.h>
#include <bslmf_issame.h>
#include <bslmf_matchanytype.h>
#include <bslmf_matcharithmetictype.h>
#include <bslmf_movableref.h>
#include <bslmf_nestedtraitdeclaration.h>
#include <bslmf_nil.h>
#include <bslmf_util.h>
#include <bslmf_voidtype.h>
#include <bsls_alignedbuffer.h>
#include <bsls_alignment.h>
#include <bsls_alignmentfromtype.h>
#include <bsls_assert.h>
#include <bsls_compilerfeatures.h>
#include <bsls_keyword.h>
#include <bsls_libraryfeatures.h>
#include <bsls_nullptr.h>
#include <bsls_performancehint.h>
#include <bsls_platform.h>
#include <bsls_util.h>
#include <istream>
#include <limits>
#include <locale>
#include <ostream>
#include <string>
#include <bsls_nativestd.h>
#include <exception>
#include <stdexcept>

Go to the source code of this file.

Classes
class	bsl::String_Imp< CHAR_TYPE, SIZE_TYPE >
class	bsl::String_ClearProctor< FULL_STRING_TYPE >
class	bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >
struct	bsl::hash< basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > >
struct	bslalg::HasStlIterators< bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > >
struct	bslma::UsesBslmaAllocator< bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > >

Macros
#define	BSLSTL_STRING_REQUIRES_CONTAINER_COMPATIBLE_RANGE(R, T)
#define	BSLSTL_CHAR_TRAITS   CHAR_TRAITS
#define	BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T(...)
#define	BSLSTL_INSERT_RETURN_TYPE    typename basic_string<CHAR_TYPE,CHAR_TRAITS,ALLOCATOR>::iterator

Typedefs
typedef basic_string< char >	bsl::string
typedef basic_string< wchar_t >	bsl::wstring

Enumerations
enum	bsl::MaxDecimalStringLengths {   bsl::e_MAX_SHORT_STRLEN10 = 2 + sizeof(short) * 3 , bsl::e_MAX_INT_STRLEN10 = 2 + sizeof(int) * 3 , bsl::e_MAX_INT64_STRLEN10 = 26 , bsl::e_MAX_FLOAT_STRLEN10 = 48 ,   bsl::e_MAX_DOUBLE_STRLEN10 = 318 , bsl::e_MAX_LONGDOUBLE_STRLEN10 = 4942 , bsl::e_MAX_SCALAR_STRLEN10 = e_MAX_INT64_STRLEN10 , bsl::e_STARTING_LONGDOUBLE_STRLEN10 = 318 }

Functions
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	bsl::operator== (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	bsl::operator== (const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	bsl::operator== (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const CHAR_TYPE *rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	bsl::operator== (const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	bsl::operator== (const CHAR_TYPE *lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	bsl::operator!= (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	bsl::operator!= (const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	bsl::operator!= (const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	bsl::operator!= (const CHAR_TYPE *lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	bsl::operator!= (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const CHAR_TYPE *rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	bsl::operator< (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	bsl::operator< (const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	bsl::operator< (const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	bsl::operator< (const CHAR_TYPE *lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	bsl::operator< (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const CHAR_TYPE *rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	bsl::operator> (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	bsl::operator> (const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	bsl::operator> (const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	bsl::operator> (const CHAR_TYPE *lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	bsl::operator> (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const CHAR_TYPE *rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	bsl::operator<= (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	bsl::operator<= (const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	bsl::operator<= (const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	bsl::operator<= (const CHAR_TYPE *lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	bsl::operator<= (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const CHAR_TYPE *rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	bsl::operator>= (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	bsl::operator>= (const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	bsl::operator>= (const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	bsl::operator>= (const CHAR_TYPE *lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	bsl::operator>= (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const CHAR_TYPE *rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >	bsl::operator+ (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 >	bsl::operator+ (const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 >	bsl::operator+ (const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >	bsl::operator+ (const CHAR_TYPE *lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >	bsl::operator+ (CHAR_TYPE lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >	bsl::operator+ (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &lhs, const CHAR_TYPE *rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >	bsl::operator+ (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &lhs, CHAR_TYPE rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR , class STRING_VIEW_LIKE_TYPE >
	bsl::BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T (bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >) operator+(const basic_string< CHAR_TYPE
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR , class STRING_VIEW_LIKE_TYPE >
	bsl::BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T (bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >) operator+(const STRING_VIEW_LIKE_TYPE &lhs
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
std::basic_ostream< CHAR_TYPE, CHAR_TRAITS > &	bsl::operator<< (std::basic_ostream< CHAR_TYPE, CHAR_TRAITS > &os, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &str)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
std::basic_istream< CHAR_TYPE, CHAR_TRAITS > &	bsl::operator>> (std::basic_istream< CHAR_TYPE, CHAR_TRAITS > &is, basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &str)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
void	bsl::swap (basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &a, basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(BSLS_KEYWORD_NOEXCEPT_OPERATOR(a.swap(b)))
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
std::basic_istream< CHAR_TYPE, CHAR_TRAITS > &	bsl::getline (std::basic_istream< CHAR_TYPE, CHAR_TRAITS > &is, basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &str, CHAR_TYPE delim)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
std::basic_istream< CHAR_TYPE, CHAR_TRAITS > &	bsl::getline (std::basic_istream< CHAR_TYPE, CHAR_TRAITS > &is, basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &str)
int	bsl::stoi (const string &str, std::size_t *pos=0, int base=10)
int	bsl::stoi (const wstring &str, std::size_t *pos=0, int base=10)
long	bsl::stol (const string &str, std::size_t *pos=0, int base=10)
long	bsl::stol (const wstring &str, std::size_t *pos=0, int base=10)
unsigned long	bsl::stoul (const string &str, std::size_t *pos=0, int base=10)
unsigned long	bsl::stoul (const wstring &str, std::size_t *pos=0, int base=10)
long long	bsl::stoll (const string &str, std::size_t *pos=0, int base=10)
long long	bsl::stoll (const wstring &str, std::size_t *pos=0, int base=10)
unsigned long long	bsl::stoull (const string &str, std::size_t *pos=0, int base=10)
unsigned long long	bsl::stoull (const wstring &str, std::size_t *pos=0, int base=10)
float	bsl::stof (const string &str, std::size_t *pos=0)
float	bsl::stof (const wstring &str, std::size_t *pos=0)
double	bsl::stod (const string &str, std::size_t *pos=0)
double	bsl::stod (const wstring &str, std::size_t *pos=0)
long double	bsl::stold (const string &str, std::size_t *pos=0)
long double	bsl::stold (const wstring &str, std::size_t *pos=0)
string	bsl::to_string (int value)
string	bsl::to_string (long value)
string	bsl::to_string (long long value)
string	bsl::to_string (unsigned value)
string	bsl::to_string (unsigned long value)
string	bsl::to_string (unsigned long long value)
string	bsl::to_string (float value)
string	bsl::to_string (double value)
string	bsl::to_string (long double value)
wstring	bsl::to_wstring (int value)
wstring	bsl::to_wstring (long value)
wstring	bsl::to_wstring (long long value)
wstring	bsl::to_wstring (unsigned value)
wstring	bsl::to_wstring (unsigned long value)
wstring	bsl::to_wstring (unsigned long long value)
wstring	bsl::to_wstring (float value)
wstring	bsl::to_wstring (double value)
wstring	bsl::to_wstring (long double value)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR , class OTHER_CHAR_TYPE >
basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >::size_type	bsl::erase (basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &str, const OTHER_CHAR_TYPE &c)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR , class UNARY_PREDICATE >
basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >::size_type	bsl::erase_if (basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &str, const UNARY_PREDICATE &pred)
template<class HASHALG , class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
void	bsl::hashAppend (HASHALG &hashAlg, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &input)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
std::size_t	bsl::hashBasicString (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &str)
std::size_t	bsl::hashBasicString (const string &str)
std::size_t	bsl::hashBasicString (const wstring &str)
template<class HASHALG , class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
BSLS_PLATFORM_AGGRESSIVE_INLINE void	bslh::hashAppend (HASHALG &hashAlg, const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &input)
template<class STRING_VIEW_LIKE_TYPE >
	bsl::BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T (basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &) basic_string< CHAR_TYPE
template<class STRING_VIEW_LIKE_TYPE >
BSLS_PLATFORM_AGGRESSIVE_INLINE	bsl::BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T (basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &) basic_string< CHAR_TYPE
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR , class STRING_VIEW_LIKE_TYPE >
	BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T (bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >) bsl
template<class CHAR_TYPE , class CHAR_TRAITS >
bool	bslstl_string_fill (std::basic_ostream< CHAR_TYPE, CHAR_TRAITS > &os, std::basic_streambuf< CHAR_TYPE, CHAR_TRAITS > *buf, std::size_t n)

Variables
	bsl::CHAR_TRAITS
ALLOCATOR &	bsl::lhs
ALLOCATOR const STRING_VIEW_LIKE_TYPE &	bsl::rhs

Detailed Description

The content of this file has been pre-processed for Doxygen.

Macro Definition Documentation

BSLSTL_CHAR_TRAITS

#define BSLSTL_CHAR_TRAITS   CHAR_TRAITS

BSLSTL_INSERT_RETURN_TYPE

#define BSLSTL_INSERT_RETURN_TYPE    typename basic_string<CHAR_TYPE,CHAR_TRAITS,ALLOCATOR>::iterator

BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T

#define BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T

(

...

)

Value:

    typename bsl::enable_if<                                                  \
        BloombergLP::bslstl::IsConvertibleToStringView<                       \
            CHAR_TYPE,                                                        \
            CHAR_TRAITS,                                                      \
            BSLSTL_STRINGVIEWLIKEPARAM_TYPE_IF_COMPLETE>::value               \
     && !BloombergLP::bslstl::IsConvertibleToCString<                         \
            CHAR_TYPE,                                                        \
            BSLSTL_STRINGVIEWLIKEPARAM_TYPE_IF_COMPLETE>::value               \
     && !BloombergLP::bslmf::IsAccessibleBaseOf<                              \
            bsl::basic_string<CHAR_TYPE, CHAR_TRAITS, ALLOCATOR>,             \
            STRING_VIEW_LIKE_TYPE>::value                                     \
     && !BloombergLP::bslmf::IsAccessibleBaseOf<                              \
            std::basic_string<CHAR_TYPE, CHAR_TRAITS, ALLOCATOR>,             \
            STRING_VIEW_LIKE_TYPE>::value,                                    \
        __VA_ARGS__>::type

SFINAE enable_if type alias for types convertible to string_view but NOT convertible to C-string and NOT an accessible base of bsl::basic_string or std::basic_string. The result type is the macro argument if enabled. This is a variadic macro to support result types containing commas (e.g., basic_string<CHAR_TYPE, CHAR_TRAITS, ALLOCATOR>).