Quick Links:

bal | bbl | bdl | bsl

Namespaces | Classes | Typedefs | Functions | Variables

bdlb Namespace Reference
[Component bdlb_algorithmworkaroundutil, Component bdlb_arrayutil, Component bdlb_bigendian, Component bdlb_bitmaskutil, Component bdlb_bitstringimputil, Component bdlb_bitstringutil, Component bdlb_bitutil, Component bdlb_caselessstringviewequalto, Component bdlb_caselessstringviewhash, Component bdlb_caselessstringviewless, Component bdlb_chartype, Component bdlb_cstringequalto, Component bdlb_cstringhash, Component bdlb_cstringless, Component bdlb_float, Component bdlb_functionoutputiterator, Component bdlb_guid, Component bdlb_guidutil, Component bdlb_hashutil, Component bdlb_indexspan, Component bdlb_indexspanstringutil, Component bdlb_indexspanutil, Component bdlb_literalutil, Component bdlb_nullableallocatedvalue, Component bdlb_nullablevalue, Component bdlb_nullopt, Component bdlb_nulloutputiterator, Component bdlb_numericparseutil, Component bdlb_optionalprinter, Component bdlb_pairutil, Component bdlb_pcgrandomgenerator, Component bdlb_print, Component bdlb_printadapter, Component bdlb_random, Component bdlb_randomdevice, Component bdlb_scopeexit, Component bdlb_string, Component bdlb_stringrefutil, Component bdlb_stringviewutil, Component bdlb_testinputiterator, Component bdlb_tokenizer, Component bdlb_topologicalsortutil, Component bdlb_transformiterator, Component bdlb_transparentequalto, Component bdlb_transparenthash, Component bdlb_transparentless, Component bdlb_variant]

Namespaces

namespace  PrintMethods

Classes

struct  AlgorithmWorkaroundUtil
 namespace for fixed faulty standard algorithms More...
struct  ArrayUtil
class  BigEndianInt16
class  BigEndianUint16
class  BigEndianInt32
class  BigEndianUint32
class  BigEndianInt64
class  BigEndianUint64
struct  BitMaskUtil
struct  BitStringImpUtil
struct  BitStringUtil
struct  BitUtil
struct  CaselessStringViewEqualTo
struct  CaselessStringViewHash
struct  CaselessStringViewLess
struct  CharType
struct  CStringEqualTo
struct  CStringHash
struct  CStringLess
struct  Float
class  FunctionOutputIterator
class  Guid
class  GuidState_Imp
struct  GuidUtil
struct  HashUtil
class  IndexSpan
struct  IndexSpanStringUtil
struct  IndexSpanUtil
struct  LiteralUtil
class  NullableAllocatedValue
class  NullableValue
class  NullOptType
 tag type representing an empty nullable value More...
class  NullOutputIteratorAssignmentProxy
class  NullOutputIterator
struct  NumericParseUtil
class  OptionalPrinter
struct  OptionalPrinterUtil
struct  PairUtil
class  PcgRandomGenerator
struct  Print
struct  PrintStringHexDumper
struct  PrintStringSingleLineHexDumper
class  PrintAdapter
struct  PrintAdapterUtil
struct  HasPrintMethod
struct  TypeTraitHasPrintMethod
struct  Random
struct  RandomDevice
class  ScopeExit
struct  String
struct  StringRefUtil
struct  StringViewUtil
struct  TestInputIterator
class  Tokenizer_Data
class  Tokenizer_Proxy
class  TokenizerIterator
class  Tokenizer
struct  TopologicalSortUtilEdgeTraits
struct  TopologicalSortUtilEdgeTraits< bsl::pair< NODE_TYPE, NODE_TYPE > >
class  TopologicalSortUtil_Helper
struct  TopologicalSortUtil
struct  TransformIterator_Traits
struct  TransformIterator_Traits< RESULT(*)(ARGUMENT), ITERATOR >
struct  TransformIterator_Traits< RESULT(ARGUMENT), ITERATOR >
struct  TransformIterator_AllocatorOfIteratorMethod
struct  TransformIterator_AllocatorOfIteratorMethod< BASE_TYPE, true >
struct  TransformIterator_AllocatorOfFunctorMethod
struct  TransformIterator_AllocatorOfFunctorMethod< BASE_TYPE, true >
class  TransformIterator
struct  TransformIteratorUtil
struct  TransparentEqualTo
struct  TransparentHash
struct  TransparentLess
struct  Variant_ReturnValueHelper_NoType
struct  Variant_ReturnValueHelper
class  VariantImp_AllocatorBase
class  VariantImp_NoAllocatorBase
struct  VariantImp_Traits
struct  Variant_ReturnAnyTypeUtil
struct  Variant_ReturnAnyTypeUtil< void >
struct  Variant_ReturnAnyTypeUtil< TYPE & >
class  Variant_RawVisitorHelper
class  VariantImp
class  Variant
class  Variant2
class  Variant3
class  Variant4
class  Variant5
class  Variant6
class  Variant7
class  Variant8
class  Variant9
class  Variant10
class  Variant11
class  Variant12
class  Variant13
class  Variant14
class  Variant15
class  Variant16
class  Variant17
class  Variant18
class  Variant19
struct  Variant_TypeIndex
struct  Variant_DefaultConstructVisitor
struct  Variant_CopyConstructVisitor
struct  Variant_MoveConstructVisitor
struct  Variant_DestructorVisitor
struct  Variant_CopyAssignVisitor
struct  Variant_MoveAssignVisitor
struct  Variant_SwapVisitor
struct  Variant_BdexStreamInVisitor
struct  Variant_BdexStreamOutVisitor
struct  Variant_PrintVisitor
struct  Variant_EqualityTestVisitor

Typedefs

typedef ScopeExit
< bsl::function< void()> > 		ScopeExitAny
typedef char Variant_ReturnValueHelper_YesType

Functions

bool operator== (const BigEndianInt16 &lhs, const BigEndianInt16 &rhs)
bool operator!= (const BigEndianInt16 &lhs, const BigEndianInt16 &rhs)
bsl::ostream & operator<< (bsl::ostream &stream, const BigEndianInt16 &integer)
template<class HASH_ALGORITHM >
void hashAppend (HASH_ALGORITHM &hashAlgorithm, const BigEndianInt16 &object)
bool operator== (const BigEndianUint16 &lhs, const BigEndianUint16 &rhs)
bool operator!= (const BigEndianUint16 &lhs, const BigEndianUint16 &rhs)
bsl::ostream & operator<< (bsl::ostream &stream, const BigEndianUint16 &integer)
template<class HASH_ALGORITHM >
void hashAppend (HASH_ALGORITHM &hashAlgorithm, const BigEndianUint16 &object)
bool operator== (const BigEndianInt32 &lhs, const BigEndianInt32 &rhs)
bool operator!= (const BigEndianInt32 &lhs, const BigEndianInt32 &rhs)
bsl::ostream & operator<< (bsl::ostream &stream, const BigEndianInt32 &integer)
template<class HASH_ALGORITHM >
void hashAppend (HASH_ALGORITHM &hashAlgorithm, const BigEndianInt32 &object)
bool operator== (const BigEndianUint32 &lhs, const BigEndianUint32 &rhs)
bool operator!= (const BigEndianUint32 &lhs, const BigEndianUint32 &rhs)
bsl::ostream & operator<< (bsl::ostream &stream, const BigEndianUint32 &integer)
template<class HASH_ALGORITHM >
void hashAppend (HASH_ALGORITHM &hashAlgorithm, const BigEndianUint32 &object)
bool operator== (const BigEndianInt64 &lhs, const BigEndianInt64 &rhs)
bool operator!= (const BigEndianInt64 &lhs, const BigEndianInt64 &rhs)
bsl::ostream & operator<< (bsl::ostream &stream, const BigEndianInt64 &integer)
template<class HASH_ALGORITHM >
void hashAppend (HASH_ALGORITHM &hashAlgorithm, const BigEndianInt64 &object)
bool operator== (const BigEndianUint64 &lhs, const BigEndianUint64 &rhs)
bool operator!= (const BigEndianUint64 &lhs, const BigEndianUint64 &rhs)
bsl::ostream & operator<< (bsl::ostream &stream, const BigEndianUint64 &integer)
template<class HASH_ALGORITHM >
void hashAppend (HASH_ALGORITHM &hashAlgorithm, const BigEndianUint64 &object)
bsl::ostream & operator<< (bsl::ostream &out, CharType::Category category)
template<class FUNCTION >
FunctionOutputIterator
< FUNCTION > & 		operator++ (FunctionOutputIterator< FUNCTION > &iterator)
template<class FUNCTION >
FunctionOutputIterator< FUNCTION > operator++ (FunctionOutputIterator< FUNCTION > &iterator, int)
bool operator== (const Guid &lhs, const Guid &rhs)
bool operator!= (const Guid &lhs, const Guid &rhs)
bool operator< (const Guid &lhs, const Guid &rhs)
bool operator<= (const Guid &lhs, const Guid &rhs)
bool operator> (const Guid &lhs, const Guid &rhs)
bool operator>= (const Guid &lhs, const Guid &rhs)
bsl::ostream & operator<< (bsl::ostream &stream, const Guid &guid)
template<class HASH_ALGORITHM >
void hashAppend (HASH_ALGORITHM &hashAlgorithm, const Guid &guid)
bool operator== (const IndexSpan &lhs, const IndexSpan &rhs)
bool operator!= (const IndexSpan &lhs, const IndexSpan &rhs)
bsl::ostream & operator<< (bsl::ostream &stream, const IndexSpan &object)
template<class HASH_ALGORITHM >
void hashAppend (HASH_ALGORITHM &hashAlgorithm, const IndexSpan &object)
template<class LHS_TYPE , class RHS_TYPE >
bool operator== (const NullableAllocatedValue< LHS_TYPE > &lhs, const NullableAllocatedValue< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator!= (const NullableAllocatedValue< LHS_TYPE > &lhs, const NullableAllocatedValue< RHS_TYPE > &rhs)
template<class TYPE >
bsl::ostream & operator<< (bsl::ostream &stream, const NullableAllocatedValue< TYPE > &object)
template<class TYPE >
void swap (NullableAllocatedValue< TYPE > &a, NullableAllocatedValue< TYPE > &b)
template<class LHS_TYPE , class RHS_TYPE >
bool operator== (const NullableValue< LHS_TYPE > &lhs, const NullableValue< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator== (const NullableValue< LHS_TYPE > &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator== (const bsl::optional< LHS_TYPE > &lhs, const NullableValue< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator!= (const NullableValue< LHS_TYPE > &lhs, const NullableValue< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator!= (const bsl::optional< LHS_TYPE > &lhs, const NullableValue< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator!= (const NullableValue< LHS_TYPE > &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator!= (const NullableValue< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator!= (const LHS_TYPE &lhs, const NullableValue< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator== (const NullableValue< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator== (const LHS_TYPE &lhs, const NullableValue< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator< (const NullableValue< LHS_TYPE > &lhs, const NullableValue< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator< (const bsl::optional< LHS_TYPE > &lhs, const NullableValue< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator< (const NullableValue< LHS_TYPE > &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator< (const NullableValue< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator< (const LHS_TYPE &lhs, const NullableValue< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator> (const NullableValue< LHS_TYPE > &lhs, const NullableValue< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator> (const bsl::optional< LHS_TYPE > &lhs, const NullableValue< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator> (const NullableValue< LHS_TYPE > &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator> (const NullableValue< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator> (const LHS_TYPE &lhs, const NullableValue< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator<= (const NullableValue< LHS_TYPE > &lhs, const NullableValue< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator<= (const bsl::optional< LHS_TYPE > &lhs, const NullableValue< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator<= (const NullableValue< LHS_TYPE > &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator<= (const NullableValue< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator<= (const LHS_TYPE &lhs, const NullableValue< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator>= (const NullableValue< LHS_TYPE > &lhs, const NullableValue< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator>= (const bsl::optional< LHS_TYPE > &lhs, const NullableValue< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator>= (const NullableValue< LHS_TYPE > &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator>= (const NullableValue< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator>= (const LHS_TYPE &lhs, const NullableValue< RHS_TYPE > &rhs)
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator== (const NullableValue< TYPE > &value, const NullOptType &) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator== (const NullOptType &, const NullableValue< TYPE > &value) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator!= (const NullableValue< TYPE > &value, const NullOptType &) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator!= (const NullOptType &, const NullableValue< TYPE > &value) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator< (const NullableValue< TYPE > &, const NullOptType &) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator< (const NullOptType &, const NullableValue< TYPE > &value) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator> (const NullableValue< TYPE > &value, const NullOptType &) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator> (const NullOptType &, const NullableValue< TYPE > &value) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator<= (const NullableValue< TYPE > &value, const NullOptType &) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator<= (const NullOptType &, const NullableValue< TYPE > &value) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator>= (const NullableValue< TYPE > &value, const NullOptType &) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator>= (const NullOptType &, const NullableValue< TYPE > &value) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
bsl::ostream & operator<< (bsl::ostream &stream, const NullableValue< TYPE > &object)
template<class HASHALG , class TYPE >
void hashAppend (HASHALG &hashAlg, const NullableValue< TYPE > &input)
template<class TYPE >
bsl::enable_if
< BloombergLP::bslma::UsesBslmaAllocator
< TYPE >::value, void >::type 		swap (NullableValue< TYPE > &lhs, NullableValue< TYPE > &rhs)
template<class TYPE >
bsl::ostream & operator<< (bsl::ostream &stream, const OptionalPrinter< TYPE > &printer)
bool operator== (const PcgRandomGenerator &lhs, const PcgRandomGenerator &rhs)
bool operator!= (const PcgRandomGenerator &lhs, const PcgRandomGenerator &rhs)
bsl::ostream & operator<< (bsl::ostream &stream, const PrintStringHexDumper &rhs)
bsl::ostream & operator<< (bsl::ostream &stream, const PrintStringSingleLineHexDumper &rhs)
template<class TYPE >
bsl::ostream & operator<< (bsl::ostream &stream, const PrintAdapter< TYPE > &adapter)
bool operator== (const TokenizerIterator &lhs, const TokenizerIterator &rhs)
bool operator!= (const TokenizerIterator &lhs, const TokenizerIterator &rhs)
const TokenizerIterator operator++ (TokenizerIterator &object, int)
const Tokenizer operator++ (Tokenizer &object, int)
template<class FUNCTOR , class ITERATOR >
bool operator== (const TransformIterator< FUNCTOR, ITERATOR > &lhs, const TransformIterator< FUNCTOR, ITERATOR > &rhs)
template<class FUNCTOR , class ITERATOR >
bool operator!= (const TransformIterator< FUNCTOR, ITERATOR > &lhs, const TransformIterator< FUNCTOR, ITERATOR > &rhs)
template<class FUNCTOR , class ITERATOR >
bool operator< (const TransformIterator< FUNCTOR, ITERATOR > &lhs, const TransformIterator< FUNCTOR, ITERATOR > &rhs)
template<class FUNCTOR , class ITERATOR >
bool operator> (const TransformIterator< FUNCTOR, ITERATOR > &lhs, const TransformIterator< FUNCTOR, ITERATOR > &rhs)
template<class FUNCTOR , class ITERATOR >
bool operator<= (const TransformIterator< FUNCTOR, ITERATOR > &lhs, const TransformIterator< FUNCTOR, ITERATOR > &rhs)
template<class FUNCTOR , class ITERATOR >
bool operator>= (const TransformIterator< FUNCTOR, ITERATOR > &lhs, const TransformIterator< FUNCTOR, ITERATOR > &rhs)
template<class FUNCTOR , class ITERATOR >
TransformIterator< FUNCTOR,
ITERATOR > 		operator++ (TransformIterator< FUNCTOR, ITERATOR > &iterator, int)
template<class FUNCTOR , class ITERATOR >
TransformIterator< FUNCTOR,
ITERATOR > 		operator-- (TransformIterator< FUNCTOR, ITERATOR > &iterator, int)
template<class FUNCTOR , class ITERATOR >
TransformIterator< FUNCTOR,
ITERATOR > 		operator+ (const TransformIterator< FUNCTOR, ITERATOR > &iterator, typename TransformIterator< FUNCTOR, ITERATOR >::difference_type offset)
template<class FUNCTOR , class ITERATOR >
TransformIterator< FUNCTOR,
ITERATOR > 		operator+ (typename TransformIterator< FUNCTOR, ITERATOR >::difference_type offset, const TransformIterator< FUNCTOR, ITERATOR > &iterator)
template<class FUNCTOR , class ITERATOR >
TransformIterator< FUNCTOR,
ITERATOR > 		operator- (const TransformIterator< FUNCTOR, ITERATOR > &iterator, typename TransformIterator< FUNCTOR, ITERATOR >::difference_type offset)
template<class FUNCTOR , class ITERATOR >
TransformIterator< FUNCTOR,
ITERATOR >::difference_type 		operator- (const TransformIterator< FUNCTOR, ITERATOR > &a, const TransformIterator< FUNCTOR, ITERATOR > &b)
template<class FUNCTOR , class ITERATOR >
void swap (TransformIterator< FUNCTOR, ITERATOR > &a, TransformIterator< FUNCTOR, ITERATOR > &b)
template<class TYPES >
bool operator== (const VariantImp< TYPES > &lhs, const VariantImp< TYPES > &rhs)
template<class TYPES >
bool operator!= (const VariantImp< TYPES > &lhs, const VariantImp< TYPES > &rhs)
template<class TYPES >
bsl::ostream & operator<< (bsl::ostream &stream, const VariantImp< TYPES > &object)
template<class TYPES >
void swap (VariantImp< TYPES > &a, VariantImp< TYPES > &b)

Variables

const NullOptType nullOpt

Typedef Documentation

typedef ScopeExit<bsl::function<void()> > bdlb::ScopeExitAny

ScopeExitAny is an alias to ScopeExit<bsl::function<void()> >, effectively making it a polymorphic scope exit type.

typedef char bdlb::Variant_ReturnValueHelper_YesType

Function Documentation

bool bdlb::operator== ( const BigEndianInt16 &  lhs,
const BigEndianInt16 &  rhs 
)

Return true if the specified lhs and rhs BigEndianInt16 objects have the same value, and false otherwise. Two BigEndianInt16 objects have the same value if and only if the respective integral network byte-order values that they represent have the same value.

bool bdlb::operator!= ( const BigEndianInt16 &  lhs,
const BigEndianInt16 &  rhs 
)

Return true if the specified lhs and rhs BigEndianInt16 objects do not have the same value, and false otherwise. Two BigEndianInt16 objects do not have the same value if and only if the respective integral network byte-order values that they represent do not have the same value.

bsl::ostream& bdlb::operator<< ( bsl::ostream &  stream,
const BigEndianInt16 &  integer 
)

Write the specified integer to the specified output stream and return a reference to the modifiable stream.

template<class HASH_ALGORITHM >
void bdlb::hashAppend ( HASH_ALGORITHM &  hashAlgorithm,
const BigEndianInt16 &  object 
)

Invoke the specified hashAlgorithm on the attributes of the specified object.

bool bdlb::operator== ( const BigEndianUint16 &  lhs,
const BigEndianUint16 &  rhs 
)

Return true if the specified lhs and rhs BigEndianUint16 objects have the same value, and false otherwise. Two BigEndianUint16 objects have the same value if and only if the respective integral network byte-order values that they represent have the same value.

bool bdlb::operator!= ( const BigEndianUint16 &  lhs,
const BigEndianUint16 &  rhs 
)

Return true if the specified lhs and rhs BigEndianUint16 objects do not have the same value, and false otherwise. Two BigEndianUint16 objects do not have the same value if and only if the respective integral network byte-order values that they represent do not have the same value.

bsl::ostream& bdlb::operator<< ( bsl::ostream &  stream,
const BigEndianUint16 &  integer 
)

Write the specified integer to the specified output stream, and return a reference to the modifiable stream.

template<class HASH_ALGORITHM >
void bdlb::hashAppend ( HASH_ALGORITHM &  hashAlgorithm,
const BigEndianUint16 &  object 
)

Invoke the specified hashAlgorithm on the attributes of the specified object.

bool bdlb::operator== ( const BigEndianInt32 &  lhs,
const BigEndianInt32 &  rhs 
)

Return true if the specified lhs and rhs BigEndianInt32 objects have the same value, and false otherwise. Two BigEndianInt32 objects have the same value if and only if the respective integral network byte-order values that they represent have the same value.

bool bdlb::operator!= ( const BigEndianInt32 &  lhs,
const BigEndianInt32 &  rhs 
)

Return true if the specified lhs and rhs BigEndianInt32 objects do not have the same value, and false otherwise. Two BigEndianInt32 objects do not have the same value if and only if the respective integral network byte-order values that they represent do not have the same value.

bsl::ostream& bdlb::operator<< ( bsl::ostream &  stream,
const BigEndianInt32 &  integer 
)

Write the specified integer to the specified output stream, and return a reference to the modifiable stream.

template<class HASH_ALGORITHM >
void bdlb::hashAppend ( HASH_ALGORITHM &  hashAlgorithm,
const BigEndianInt32 &  object 
)

Invoke the specified hashAlgorithm on the attributes of the specified object.

bool bdlb::operator== ( const BigEndianUint32 &  lhs,
const BigEndianUint32 &  rhs 
)

Return true if the specified lhs and rhs BigEndianUint32 objects have the same value, and false otherwise. Two BigEndianUint32 objects have the same value if and only if the respective integral network byte-order values that they represent have the same value.

bool bdlb::operator!= ( const BigEndianUint32 &  lhs,
const BigEndianUint32 &  rhs 
)

Return true if the specified lhs and rhs BigEndianUint32 objects do not have the same value, and false otherwise. Two BigEndianUint32 objects do not have the same value if and only if the respective integral network byte-order values that they represent do not have the same value.

bsl::ostream& bdlb::operator<< ( bsl::ostream &  stream,
const BigEndianUint32 &  integer 
)

Write the specified integer to the specified output stream, and return a reference to the modifiable stream.

template<class HASH_ALGORITHM >
void bdlb::hashAppend ( HASH_ALGORITHM &  hashAlgorithm,
const BigEndianUint32 &  object 
)

Invoke the specified hashAlgorithm on the attributes of the specified object.

bool bdlb::operator== ( const BigEndianInt64 &  lhs,
const BigEndianInt64 &  rhs 
)

Return true if the specified lhs and rhs BigEndianInt64 objects have the same value, and false otherwise. Two BigEndianInt64 objects have the same value if and only if the respective integral network byte-order values that they represent have the same value.

bool bdlb::operator!= ( const BigEndianInt64 &  lhs,
const BigEndianInt64 &  rhs 
)

Return true if the specified lhs and rhs BigEndianInt64 objects do not have the same value, and false otherwise. Two BigEndianInt64 objects do not have the same value if and only if the respective integral network byte-order values that they represent do not have the same value.

bsl::ostream& bdlb::operator<< ( bsl::ostream &  stream,
const BigEndianInt64 &  integer 
)

Write the specified integer to the specified output stream, and return a reference to the modifiable stream.

template<class HASH_ALGORITHM >
void bdlb::hashAppend ( HASH_ALGORITHM &  hashAlgorithm,
const BigEndianInt64 &  object 
)

Invoke the specified hashAlgorithm on the attributes of the specified object.

bool bdlb::operator== ( const BigEndianUint64 &  lhs,
const BigEndianUint64 &  rhs 
)

Return true if the specified lhs and rhs BigEndianUint64 objects have the same value, and false otherwise. Two BigEndianUint64 objects have the same value if and only if the respective integral network byte-order values that they represent have the same value.

bool bdlb::operator!= ( const BigEndianUint64 &  lhs,
const BigEndianUint64 &  rhs 
)

Return true if the specified lhs and rhs BigEndianUint64 objects do not have the same value, and false otherwise. Two BigEndianUint64 objects do not have the same value if and only if the respective integral network byte-order values that they represent do not have the same value.

bsl::ostream& bdlb::operator<< ( bsl::ostream &  stream,
const BigEndianUint64 &  integer 
)

Write the specified integer to the specified output stream, and return a reference to the modifiable stream.

template<class HASH_ALGORITHM >
void bdlb::hashAppend ( HASH_ALGORITHM &  hashAlgorithm,
const BigEndianUint64 &  object 
)

Invoke the specified hashAlgorithm on the attributes of the specified object.

bsl::ostream& bdlb::operator<< ( bsl::ostream &  out,
CharType::Category  category 
)

Write the specified character category enumerator to the specified output stream as a string that is identical to the enumerator name.

template<class FUNCTION >
FunctionOutputIterator<FUNCTION>& bdlb::operator++ ( FunctionOutputIterator< FUNCTION > &  iterator  )  [inline]

Do nothing and return specified iterator.

template<class FUNCTION >
FunctionOutputIterator<FUNCTION> bdlb::operator++ ( FunctionOutputIterator< FUNCTION > &  iterator,
int   
) [inline]

Do nothing and return specified iterator.

bool bdlb::operator== ( const Guid &  lhs,
const Guid &  rhs 
)

Return true if the specified lhs and specified rhs guid objects have the same value, and false otherwise. Two guid objects have the same value if each corresponding byte in their internal buffers are equal.

bool bdlb::operator!= ( const Guid &  lhs,
const Guid &  rhs 
)

Return true if the specified lhs and specified rhs guid objects have different values, and false otherwise. Two guid objects have different value if any of corresponding byte in their internal buffers differ.

bool bdlb::operator< ( const Guid &  lhs,
const Guid &  rhs 
)

Return true if the value of the specified lhs guid object is less than the value of the specified rhs guid object, and false otherwise. Note that the comparison is accomplished using a lexicographic comparison of the internal representations.

bool bdlb::operator<= ( const Guid &  lhs,
const Guid &  rhs 
)

Return true if the value of the specified lhs guid object is less than or equal to the value of the specified rhs guid object, and false otherwise. Note that the comparison is accomplished using a lexicographic comparison of the internal representations.

bool bdlb::operator> ( const Guid &  lhs,
const Guid &  rhs 
)

Return true if the value of the specified lhs guid object is greater than the value of the specified rhs guid object, and false otherwise. Note that the comparison is accomplished using a lexicographic comparison of the internal representations.

bool bdlb::operator>= ( const Guid &  lhs,
const Guid &  rhs 
)

Return true if the value of the specified lhs guid object is greater than or equal to the value of the specified rhs guid object, and false otherwise. Note that the comparison is accomplished using a lexicographic comparison of the internal representations.

bsl::ostream& bdlb::operator<< ( bsl::ostream &  stream,
const Guid &  guid 
)

Write the value of the specified guid object to the specified output stream in a single-line format, and return a reference to stream. If stream is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified, can change without notice, and is logically equivalent to: 

      print(stream, 0, -1);
template<class HASH_ALGORITHM >
void bdlb::hashAppend ( HASH_ALGORITHM &  hashAlgorithm,
const Guid &  guid 
)

Invoke the specified hashAlgorithm on the underlying buffer held by the specified guid object.

bool bdlb::operator== ( const IndexSpan &  lhs,
const IndexSpan &  rhs 
)

Return true if the specified lhs and rhs index span objects have the same value, and false otherwise. Two index span objects have the same value if their position and length attributes compare equal.

bool bdlb::operator!= ( const IndexSpan &  lhs,
const IndexSpan &  rhs 
)

Return true if the specified lhs and rhs index span objects do not have the same value, and false otherwise. Two index span objects do not have the same value if either their position or length attributes do not compare equal.

bsl::ostream& bdlb::operator<< ( bsl::ostream &  stream,
const IndexSpan &  object 
)

Write the value of the specified object to the specified output stream in a single-line format, and return a reference to stream. If stream is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified, can change without notice, and is logically equivalent to: 

      print(stream, 0, -1);
template<class HASH_ALGORITHM >
void bdlb::hashAppend ( HASH_ALGORITHM &  hashAlgorithm,
const IndexSpan &  object 
)

Invoke the specified hashAlgorithm on the attributes of the specified object.

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator== ( const NullableAllocatedValue< LHS_TYPE > &  lhs,
const NullableAllocatedValue< RHS_TYPE > &  rhs 
)

Return true if the specified lhs and rhs nullable objects have the same value, and false otherwise. Two nullable objects have the same value if both are null, or if both are non-null and the values of their underlying objects compare equal. Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator!= ( const NullableAllocatedValue< LHS_TYPE > &  lhs,
const NullableAllocatedValue< RHS_TYPE > &  rhs 
)

Return true if the specified lhs and rhs nullable objects do not have the same value, and false otherwise. Two nullable objects do not have the same value if one is null and the other is non-null, or if both are non-null and the values of their underlying objects do not compare equal. Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<class TYPE >
bsl::ostream& bdlb::operator<< ( bsl::ostream &  stream,
const NullableAllocatedValue< TYPE > &  object 
)

Write the value of the specified object to the specified output stream in a single-line format, and return a reference to stream. If stream is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified, can change without notice, and is logically equivalent to: 

      print(stream, 0, -1);
template<class TYPE >
void bdlb::swap ( NullableAllocatedValue< TYPE > &  a,
NullableAllocatedValue< TYPE > &  b 
)

Exchange the values of the specified a and b objects. This function provides the no-throw exception-safety guarantee if the two objects were created with the same allocator and the basic guarantee otherwise.

Referenced by bdlb::Variant_SwapVisitor::operator()().

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator== ( const NullableValue< LHS_TYPE > &  lhs,
const NullableValue< RHS_TYPE > &  rhs 
)
template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator== ( const NullableValue< LHS_TYPE > &  lhs,
const bsl::optional< RHS_TYPE > &  rhs 
)
template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator== ( const bsl::optional< LHS_TYPE > &  lhs,
const NullableValue< RHS_TYPE > &  rhs 
)

Return true if the specified lhs and rhs nullable objects have the same value, and false otherwise. Two nullable objects have the same value if both are null, or if both are non-null and the values of their underlying objects compare equal. Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator!= ( const NullableValue< LHS_TYPE > &  lhs,
const NullableValue< RHS_TYPE > &  rhs 
)
template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator!= ( const bsl::optional< LHS_TYPE > &  lhs,
const NullableValue< RHS_TYPE > &  rhs 
)
template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator!= ( const NullableValue< LHS_TYPE > &  lhs,
const bsl::optional< RHS_TYPE > &  rhs 
)

Return true if the specified lhs and rhs nullable objects do not have the same value, and false otherwise. Two nullable objects do not have the same value if one is null and the other is non-null, or if both are non-null and the values of their underlying objects do not compare equal. Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator!= ( const NullableValue< LHS_TYPE > &  lhs,
const RHS_TYPE &  rhs 
)
template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator!= ( const LHS_TYPE &  lhs,
const NullableValue< RHS_TYPE > &  rhs 
)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. A nullable object and a value of some type do not have the same value if either the nullable object is null, or its underlying value does not compare equal to the other value. Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator== ( const NullableValue< LHS_TYPE > &  lhs,
const RHS_TYPE &  rhs 
)
template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator== ( const LHS_TYPE &  lhs,
const NullableValue< RHS_TYPE > &  rhs 
)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. A nullable object and a value of some type have the same value if the nullable object is non-null and its underlying value compares equal to the other value. Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator< ( const NullableValue< LHS_TYPE > &  lhs,
const NullableValue< RHS_TYPE > &  rhs 
)
template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator< ( const bsl::optional< LHS_TYPE > &  lhs,
const NullableValue< RHS_TYPE > &  rhs 
)
template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator< ( const NullableValue< LHS_TYPE > &  lhs,
const bsl::optional< RHS_TYPE > &  rhs 
)

Return true if the specified lhs nullable object is ordered before the specified rhs nullable object, and false otherwise. lhs is ordered before rhs if lhs is null and rhs is non-null or if both are non-null and lhs.value() is ordered before rhs.value(). Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator< ( const NullableValue< LHS_TYPE > &  lhs,
const RHS_TYPE &  rhs 
)

Return true if the specified lhs nullable object is ordered before the specified rhs, and false otherwise. lhs is ordered before rhs if lhs is null or lhs.value() is ordered before rhs.

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator< ( const LHS_TYPE &  lhs,
const NullableValue< RHS_TYPE > &  rhs 
)

Return true if the specified lhs is ordered before the specified rhs nullable object, and false otherwise. lhs is ordered before rhs if rhs is not null and lhs is ordered before rhs.value().

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator> ( const NullableValue< LHS_TYPE > &  lhs,
const NullableValue< RHS_TYPE > &  rhs 
)
template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator> ( const bsl::optional< LHS_TYPE > &  lhs,
const NullableValue< RHS_TYPE > &  rhs 
)
template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator> ( const NullableValue< LHS_TYPE > &  lhs,
const bsl::optional< RHS_TYPE > &  rhs 
)

Return true if the specified lhs nullable object is ordered after the specified rhs nullable object, and false otherwise. lhs is ordered after rhs if lhs is non-null and rhs is null or if both are non-null and lhs.value() is ordered after rhs.value(). Note that this operator returns rhs < lhs when both operands are of NullableValue type. Also note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator> ( const NullableValue< LHS_TYPE > &  lhs,
const RHS_TYPE &  rhs 
)

Return true if the specified lhs nullable object is ordered after the specified rhs, and false otherwise. lhs is ordered after rhs if lhs is not null and lhs.value() is ordered after rhs. Note that this operator returns rhs < lhs.

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator> ( const LHS_TYPE &  lhs,
const NullableValue< RHS_TYPE > &  rhs 
)

Return true if the specified lhs is ordered after the specified rhs nullable object, and false otherwise. lhs is ordered after rhs if rhs is null or lhs is ordered after rhs.value(). Note that this operator returns rhs < lhs.

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator<= ( const NullableValue< LHS_TYPE > &  lhs,
const NullableValue< RHS_TYPE > &  rhs 
)
template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator<= ( const bsl::optional< LHS_TYPE > &  lhs,
const NullableValue< RHS_TYPE > &  rhs 
)
template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator<= ( const NullableValue< LHS_TYPE > &  lhs,
const bsl::optional< RHS_TYPE > &  rhs 
)

Return true if the specified lhs nullable object is ordered before the specified rhs nullable object or lhs and rhs have the same value, and false otherwise. (See operator< and operator==.) Note that this operator returns !(rhs < lhs) when both operands are of NullableValue type. Also note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator<= ( const NullableValue< LHS_TYPE > &  lhs,
const RHS_TYPE &  rhs 
)

Return true if the specified lhs nullable object is ordered before the specified rhs or lhs and rhs have the same value, and false otherwise. (See operator< and operator==.) Note that this operator returns !(rhs < lhs).

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator<= ( const LHS_TYPE &  lhs,
const NullableValue< RHS_TYPE > &  rhs 
)

Return true if the specified lhs is ordered before the specified rhs nullable object or lhs and rhs have the same value, and false otherwise. (See operator< and operator==.) Note that this operator returns !(rhs < lhs).

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator>= ( const NullableValue< LHS_TYPE > &  lhs,
const NullableValue< RHS_TYPE > &  rhs 
)
template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator>= ( const bsl::optional< LHS_TYPE > &  lhs,
const NullableValue< RHS_TYPE > &  rhs 
)
template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator>= ( const NullableValue< LHS_TYPE > &  lhs,
const bsl::optional< RHS_TYPE > &  rhs 
)

Return true if the specified lhs nullable object is ordered after the specified rhs nullable object or lhs and rhs have the same value, and false otherwise. (See operator> and operator==.) Note that this operator returns !(lhs < rhs) when both operands are of NullableValue type. Also note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator>= ( const NullableValue< LHS_TYPE > &  lhs,
const RHS_TYPE &  rhs 
)

Return true if the specified lhs nullable object is ordered after the specified rhs or lhs and rhs have the same value, and false otherwise. (See operator> and operator==.) Note that this operator returns !(lhs < rhs).

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator>= ( const LHS_TYPE &  lhs,
const NullableValue< RHS_TYPE > &  rhs 
)

Return true if the specified lhs is ordered after the specified rhs nullable object or lhs and rhs have the same value, and false otherwise. (See operator> and operator==.) Note that this operator returns !(lhs < rhs).

template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool bdlb::operator== ( const NullableValue< TYPE > &  value,
const NullOptType &   
)
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool bdlb::operator== ( const NullOptType &  ,
const NullableValue< TYPE > &  value 
)

Return true if the specified value is null, and false otherwise.

template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool bdlb::operator!= ( const NullableValue< TYPE > &  value,
const NullOptType &   
)
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool bdlb::operator!= ( const NullOptType &  ,
const NullableValue< TYPE > &  value 
)

Return true if the specified value is not null, and false otherwise.

template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool bdlb::operator< ( const NullableValue< TYPE > &  ,
const NullOptType &   
)

Return false. Note that bdlb::nullOpt never orders after a NullableValue.

template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool bdlb::operator< ( const NullOptType &  ,
const NullableValue< TYPE > &  value 
)

Return true if the specified value is not null, and false otherwise. Note that bdlb::nullOpt is ordered before any NullableValue that is not null.

template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool bdlb::operator> ( const NullableValue< TYPE > &  value,
const NullOptType &   
)

Return true if the specified value is not null, and false otherwise.

template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool bdlb::operator> ( const NullOptType &  ,
const NullableValue< TYPE > &  value 
)

Return false. Note that bdlb::nullOpt never orders after a NullableValue.

template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool bdlb::operator<= ( const NullableValue< TYPE > &  value,
const NullOptType &   
)

Return true if the specified value is null, and false otherwise.

template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool bdlb::operator<= ( const NullOptType &  ,
const NullableValue< TYPE > &  value 
)

Return true.

template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool bdlb::operator>= ( const NullableValue< TYPE > &  value,
const NullOptType &   
)

Return true.

template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool bdlb::operator>= ( const NullOptType &  ,
const NullableValue< TYPE > &  value 
)

Return true if the specified value is null, and false otherwise.

template<class TYPE >
bsl::ostream& bdlb::operator<< ( bsl::ostream &  stream,
const NullableValue< TYPE > &  object 
)

Write the value of the specified object to the specified output stream in a single-line format, and return a reference to stream. If stream is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified, can change without notice, and is logically equivalent to: 

      print(stream, 0, -1);
template<class HASHALG , class TYPE >
void bdlb::hashAppend ( HASHALG &  hashAlg,
const NullableValue< TYPE > &  input 
)

Pass the boolean value of whether the specified input contains a value to the specified hashAlg hashing algorithm of (template parameter) type HASHALG. If input contains a value, additionally pass that value to hashAlg.

template<class TYPE >
bsl::enable_if<!BloombergLP::bslma::UsesBslmaAllocator< TYPE >::value, void >::type bdlb::swap ( NullableValue< TYPE > &  lhs,
NullableValue< TYPE > &  rhs 
)

Exchange the values of the specified rhs and lhs objects. This function provides the no-throw exception-safety guarantee if the (template parameter) TYPE provides that guarantee, the two objects were created with the same allocator (if applicable), and the result of the isNull method for the two objects is the same; otherwise this function provides the basic guarantee.

template<class TYPE >
bsl::ostream& bdlb::operator<< ( bsl::ostream &  stream,
const OptionalPrinter< TYPE > &  printer 
)

Write the value of the specified printer object to the specified output stream in a single-line format, and return a reference to stream. If stream is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified, can change without notice, and is logically equivalent to: 

      print(stream, 0, -1);
bool bdlb::operator== ( const PcgRandomGenerator &  lhs,
const PcgRandomGenerator &  rhs 
)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two PcgRandomGenerator objects have the same value if they would produce the same sequence of random numbers from subsequent invocations of generate().

bool bdlb::operator!= ( const PcgRandomGenerator &  lhs,
const PcgRandomGenerator &  rhs 
)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two PcgRandomGenerator objects do not have the same value if they would not produce the same sequence of random numbers from subsequent invocations of generate().

bsl::ostream& bdlb::operator<< ( bsl::ostream &  stream,
const PrintStringHexDumper &  rhs 
) [inline]

Hex dump the data referenced by the specified rhs to the specified stream.

bsl::ostream& bdlb::operator<< ( bsl::ostream &  stream,
const PrintStringSingleLineHexDumper &  rhs 
) [inline]

Hex dump the data referenced by the specified rhs to the specified stream.

template<class TYPE >
bsl::ostream& bdlb::operator<< ( bsl::ostream &  stream,
const PrintAdapter< TYPE > &  adapter 
)

Write the value of the specified object to the specified output stream and return a non-'const' reference to stream. If stream is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified and can change without notice.

bool bdlb::operator== ( const TokenizerIterator &  lhs,
const TokenizerIterator &  rhs 
)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two TokenizerIterator objects have the same value if both of them are pointing to the same token within the same tokenized string or if they both point past the tokenized string. The behaviour is undefined unless the iterators returned by the same Tokenizer object, or if the underlying input has been modified or destroyed since any of those objects were created.

bool bdlb::operator!= ( const TokenizerIterator &  lhs,
const TokenizerIterator &  rhs 
)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. The behaviour is undefined unless the iterators returned by the same Tokenizer object, or if the underlying input has been modified or destroyed since any of those objects were created.

const TokenizerIterator bdlb::operator++ ( TokenizerIterator &  object,
int   
)

Advance the iteration state of the specified object to refer to the next token in the underlying input sequence, and return a copy of this object prior advancing the iteration state. The behavior is undefined unless the iteration state of this object is initially valid, or if the underlying input has been modified or destroyed since this object was created.

const Tokenizer bdlb::operator++ ( Tokenizer &  object,
int   
)
template<class FUNCTOR , class ITERATOR >
bool bdlb::operator== ( const TransformIterator< FUNCTOR, ITERATOR > &  lhs,
const TransformIterator< FUNCTOR, ITERATOR > &  rhs 
)

Return true if the underlying iterator of the specified lhs compares equal to the underlying iterator of the specified rhs, and false otherwise. The behavior is undefined if comparing the underlying iterators in this way is undefined. Note that the functors are not compared.

template<class FUNCTOR , class ITERATOR >
bool bdlb::operator!= ( const TransformIterator< FUNCTOR, ITERATOR > &  lhs,
const TransformIterator< FUNCTOR, ITERATOR > &  rhs 
)

Return true if the underlying iterator of the specified lhs compares unequal to the underlying iterator of the specified rhs, and false otherwise. The behavior is undefined if comparing the underlying iterators in this way is undefined. Note that the functors are not compared.

template<class FUNCTOR , class ITERATOR >
bool bdlb::operator< ( const TransformIterator< FUNCTOR, ITERATOR > &  lhs,
const TransformIterator< FUNCTOR, ITERATOR > &  rhs 
)

Return true if the underlying iterator of the specified lhs compares less than the underlying iterator of the specified rhs, and false otherwise. The behavior is undefined if comparing the underlying iterators in this way is undefined. Note that the functors are not compared.

template<class FUNCTOR , class ITERATOR >
bool bdlb::operator> ( const TransformIterator< FUNCTOR, ITERATOR > &  lhs,
const TransformIterator< FUNCTOR, ITERATOR > &  rhs 
)

Return true if the underlying iterator of the specified lhs compares greater than the underlying iterator of the specified rhs, and false otherwise. The behavior is undefined if comparing the underlying iterators in this way is undefined. Note that the functors are not compared.

template<class FUNCTOR , class ITERATOR >
bool bdlb::operator<= ( const TransformIterator< FUNCTOR, ITERATOR > &  lhs,
const TransformIterator< FUNCTOR, ITERATOR > &  rhs 
)

Return true if the underlying iterator of the specified lhs compares less than or equal to the underlying iterator of the specified rhs, and false otherwise. The behavior is undefined if comparing the underlying iterators in this way is undefined. Note that the functors are not compared.

template<class FUNCTOR , class ITERATOR >
bool bdlb::operator>= ( const TransformIterator< FUNCTOR, ITERATOR > &  lhs,
const TransformIterator< FUNCTOR, ITERATOR > &  rhs 
)

Return true if the underlying iterator of the specified lhs compares greater than or equal to the underlying iterator of the specified rhs, and false otherwise. The behavior is undefined if comparing the underlying iterators in this way is undefined. Note that the functors are not compared.

template<class FUNCTOR , class ITERATOR >
TransformIterator<FUNCTOR, ITERATOR> bdlb::operator++ ( TransformIterator< FUNCTOR, ITERATOR > &  iterator,
int   
)

Increment the underlying iterator of the specified iterator, and return a copy of iterator before the increment. The behavior is undefined if incrementing the underlying iterator is undefined.

template<class FUNCTOR , class ITERATOR >
TransformIterator<FUNCTOR, ITERATOR> bdlb::operator-- ( TransformIterator< FUNCTOR, ITERATOR > &  iterator,
int   
)

Decrement the underlying iterator of the specified iterator, and return a copy of iterator before the decrement. The behavior is undefined if decrementing the underlying iterator is undefined.

template<class FUNCTOR , class ITERATOR >
TransformIterator<FUNCTOR, ITERATOR> bdlb::operator+ ( const TransformIterator< FUNCTOR, ITERATOR > &  iterator,
typename TransformIterator< FUNCTOR, ITERATOR >::difference_type  offset 
)

Return a copy of the specified iterator object with its underlying iterator advanced by the specified (signed) offset from that of iterator. The behavior is undefined if so advancing the underlying iterator is undefined.

template<class FUNCTOR , class ITERATOR >
TransformIterator<FUNCTOR, ITERATOR> bdlb::operator+ ( typename TransformIterator< FUNCTOR, ITERATOR >::difference_type  offset,
const TransformIterator< FUNCTOR, ITERATOR > &  iterator 
)

Return a copy of the specified iterator object with its underlying iterator advanced by the specified (signed) offset from that of iterator. The behavior is undefined if so advancing the underlying iterator is undefined.

template<class FUNCTOR , class ITERATOR >
TransformIterator<FUNCTOR, ITERATOR> bdlb::operator- ( const TransformIterator< FUNCTOR, ITERATOR > &  iterator,
typename TransformIterator< FUNCTOR, ITERATOR >::difference_type  offset 
)

Return a copy of the specified iterator object with its underlying iterator regressed by the specified (signed) offset from that of iterator. The behavior is undefined if so regressing the underlying iterator is undefined.

template<class FUNCTOR , class ITERATOR >
TransformIterator<FUNCTOR, ITERATOR>::difference_type bdlb::operator- ( const TransformIterator< FUNCTOR, ITERATOR > &  a,
const TransformIterator< FUNCTOR, ITERATOR > &  b 
)

Return the result of subtracting the underlying iterator of the specified a object from the underlying iterator of the specified b object. The behavior is undefined if this subtraction is undefined.

template<class FUNCTOR , class ITERATOR >
void bdlb::swap ( TransformIterator< FUNCTOR, ITERATOR > &  a,
TransformIterator< FUNCTOR, ITERATOR > &  b 
)

Efficiently exchange the values of the specified a and b objects by applying swap to each of the functor and underlying iterator fields of the two objects.

template<class TYPES >
bool bdlb::operator== ( const VariantImp< TYPES > &  lhs,
const VariantImp< TYPES > &  rhs 
)

Return true if the specified lhs variant object has the same value as the specified rhs variant object, and false otherwise. Two variant objects have the same value if they are both set and hold objects of the same type and same value, or are both unset.

template<class TYPES >
bool bdlb::operator!= ( const VariantImp< TYPES > &  lhs,
const VariantImp< TYPES > &  rhs 
)

Return true if the specified lhs variant object does not have the same value as the specified rhs variant object, and false otherwise. Two variant objects do not have the same value if one is set and the other is unset, or if they are both set but hold objects that differ in type or value.

template<class TYPES >
bsl::ostream& bdlb::operator<< ( bsl::ostream &  stream,
const VariantImp< TYPES > &  object 
)

Write the specified variant object to the specified output stream in a single-line (human-readable) format, and return a reference to stream.

template<class TYPES >
void bdlb::swap ( VariantImp< TYPES > &  a,
VariantImp< TYPES > &  b 
)

Swap the values of the specified a and b objects. This method provides the no-throw guarantee if the TYPE template parameter has a no-throw swap and the two variant objects being swapped has the same type; otherwise this method provides the basic guarantee.

Variable Documentation

const NullOptType bdlb::nullOpt

Value of type NullOptType that serves as a literal value for the empty state of any nullable value.

Generated on Fri Mar 31 2023 13:27:05 for BDE Release 3.115.0.0 Production Release by  doxygen 1.7.1