BDE 4.14.0 Production release
Loading...
Searching...
No Matches
Namespaces | Classes | Typedefs | Functions | Variables
bdlb Namespace Reference
Group bdl » Package bdlb » bdlb_algorithmworkaroundutil | Group bdl » Package bdlb » bdlb_arrayutil | Group bdl » Package bdlb » bdlb_bigendian | Group bdl » Package bdlb » bdlb_bitmaskutil | Group bdl » Package bdlb » bdlb_bitstringimputil | Group bdl » Package bdlb » bdlb_bitstringutil | Group bdl » Package bdlb » bdlb_bitutil | Group bdl » Package bdlb » bdlb_caselessstringviewequalto | Group bdl » Package bdlb » bdlb_caselessstringviewhash | Group bdl » Package bdlb » bdlb_caselessstringviewless | Group bdl » Package bdlb » bdlb_chartype | Group bdl » Package bdlb » bdlb_cstringequalto | Group bdl » Package bdlb » bdlb_cstringhash | Group bdl » Package bdlb » bdlb_cstringless | Group bdl » Package bdlb » bdlb_float | Group bdl » Package bdlb » bdlb_functionoutputiterator | Group bdl » Package bdlb » bdlb_guid | Group bdl » Package bdlb » bdlb_guidutil | Group bdl » Package bdlb » bdlb_hashutil | Group bdl » Package bdlb » bdlb_indexspan | Group bdl » Package bdlb » bdlb_indexspanstringutil | Group bdl » Package bdlb » bdlb_indexspanutil | Group bdl » Package bdlb » bdlb_literalutil | Group bdl » Package bdlb » bdlb_nullableallocatedvalue | Group bdl » Package bdlb » bdlb_nullableallocatedvalue_pointerbitspair | Group bdl » Package bdlb » bdlb_nullablevalue | Group bdl » Package bdlb » bdlb_nullablevalueref | Group bdl » Package bdlb » bdlb_nullopt | Group bdl » Package bdlb » bdlb_nulloutputiterator | Group bdl » Package bdlb » bdlb_numericparseutil | Group bdl » Package bdlb » bdlb_optionalprinter | Group bdl » Package bdlb » bdlb_pairutil | Group bdl » Package bdlb » bdlb_pcgrandomgenerator | Group bdl » Package bdlb » bdlb_print | Group bdl » Package bdlb » bdlb_printadapter | Group bdl » Package bdlb » bdlb_printmethods | Group bdl » Package bdlb » bdlb_random | Group bdl » Package bdlb » bdlb_randomdevice | Group bdl » Package bdlb » bdlb_scopeexit | Group bdl » Package bdlb » bdlb_string | Group bdl » Package bdlb » bdlb_stringrefutil | Group bdl » Package bdlb » bdlb_stringviewutil | Group bdl » Package bdlb » bdlb_testinputiterator | Group bdl » Package bdlb » bdlb_tokenizer | Group bdl » Package bdlb » bdlb_topologicalsortutil | Group bdl » Package bdlb » bdlb_transformiterator | Group bdl » Package bdlb » bdlb_transparentequalto | Group bdl » Package bdlb » bdlb_transparenthash | Group bdl » Package bdlb » bdlb_transparentless | Group bdl » Package bdlb » bdlb_variant

Namespaces

namespace  PrintMethods
 

Classes

struct  AlgorithmWorkaroundUtil
 
struct  ArrayUtil
 
class  BDLB_SUNITERATORWORKAROUND
 
class  BigEndianInt16
 
class  BigEndianInt32
 
class  BigEndianInt64
 
class  BigEndianUint16
 
class  BigEndianUint32
 
class  BigEndianUint64
 
struct  BitMaskUtil
 
struct  BitStringImpUtil
 
struct  BitStringUtil
 
struct  BitUtil
 
struct  CaselessStringViewEqualTo
 
struct  CaselessStringViewHash
 
struct  CaselessStringViewLess
 
struct  CharType
 
class  ConstNullableValueRef
 
struct  CStringEqualTo
 
struct  CStringHash
 
struct  CStringLess
 
struct  Float
 Namespace for floating-point classification types and functions. More...
 
class  Guid
 
class  GuidState_Imp
 
struct  GuidUtil
 
struct  HashUtil
 This struct provides a namespace for hash functions. More...
 
struct  HasPrintMethod
 
class  IndexSpan
 
struct  IndexSpanStringUtil
 
struct  IndexSpanUtil
 
struct  LiteralUtil
 
class  NullableAllocatedValue
 
class  NullableAllocatedValue_PointerBitsPair
 
class  NullableValue
 
class  NullableValue_WithAllocator
 
class  NullableValue_WithoutAllocator
 
class  NullableValueRef
 
class  NullOutputIterator
 
class  NullOutputIteratorAssignmentProxy
 
struct  NumericParseUtil
 
class  OptionalPrinter
 
struct  OptionalPrinterUtil
 
struct  PairUtil
 This struct provides a namespace for the tie static function. More...
 
class  PcgRandomGenerator
 
struct  Print
 
class  PrintAdapter
 
struct  PrintAdapterUtil
 
struct  PrintMethods_Imp
 
struct  PrintMethods_Imp< TYPE, bslmf::SelectTraitCase< bslalg::HasStlIterators > >
 
struct  PrintMethods_Imp< TYPE, bslmf::SelectTraitCase< bslmf::IsPair > >
 
struct  PrintMethods_Imp< TYPE, bslmf::SelectTraitCase< HasPrintMethod > >
 
struct  PrintMethods_Imp< TYPE, bslmf::SelectTraitCase<> >
 
struct  PrintStringHexDumper
 
struct  PrintStringSingleLineHexDumper
 
struct  Random
 
struct  RandomDevice
 
class  ScopeExit
 
struct  String
 
struct  StringRefUtil
 
struct  StringViewUtil
 
struct  TestInputIterator
 
class  Tokenizer
 
class  Tokenizer_Data
 
class  Tokenizer_Proxy
 
class  TokenizerIterator
 
struct  TopologicalSortUtil
 
class  TopologicalSortUtil_Helper
 
struct  TopologicalSortUtilEdgeTraits
 
struct  TopologicalSortUtilEdgeTraits< bsl::pair< NODE_TYPE, NODE_TYPE > >
 
class  TransformIterator
 
struct  TransformIterator_AllocatorOfFunctorMethod
 
struct  TransformIterator_AllocatorOfFunctorMethod< BASE_TYPE, true >
 
struct  TransformIterator_AllocatorOfIteratorMethod
 
struct  TransformIterator_AllocatorOfIteratorMethod< BASE_TYPE, true >
 
struct  TransformIterator_Traits
 
struct  TransformIterator_Traits< RESULT(*)(ARGUMENT), ITERATOR >
 
struct  TransformIterator_Traits< RESULT(ARGUMENT), ITERATOR >
 
struct  TransformIteratorUtil
 
struct  TransparentEqualTo
 
struct  TransparentHash
 
struct  TransparentLess
 
struct  TypeTraitHasPrintMethod
 
class  Variant
 
class  Variant10
 
class  Variant11
 
class  Variant12
 
class  Variant13
 
class  Variant14
 
class  Variant15
 
class  Variant16
 
class  Variant17
 
class  Variant18
 
class  Variant19
 
class  Variant2
 
class  Variant3
 
class  Variant4
 
class  Variant5
 
class  Variant6
 
class  Variant7
 
class  Variant8
 
class  Variant9
 
struct  Variant_BdexStreamInVisitor
 
struct  Variant_BdexStreamOutVisitor
 
struct  Variant_CopyAssignVisitor
 
struct  Variant_CopyConstructVisitor
 
struct  Variant_DefaultConstructVisitor
 
struct  Variant_DestructorVisitor
 
struct  Variant_EqualityTestVisitor
 
struct  Variant_MoveAssignVisitor
 
struct  Variant_MoveConstructVisitor
 
struct  Variant_PrintVisitor
 
class  Variant_RawVisitorHelper
 
struct  Variant_ReturnValueHelper
 
struct  Variant_ReturnValueHelper_Matcher
 
struct  Variant_ReturnValueHelper_NoType
 
struct  Variant_SwapVisitor
 
struct  Variant_TypeIndex
 
class  VariantImp
 
class  VariantImp_AllocatorBase
 
class  VariantImp_NoAllocatorBase
 
struct  VariantImp_Traits
 

Typedefs

typedef bsl::nullopt_t NullOptType
 
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)
 Do nothing and return specified iterator.
 
template<class FUNCTION >
FunctionOutputIterator< FUNCTION > operator++ (FunctionOutputIterator< FUNCTION > &iterator, int)
 Do nothing and return specified iterator.
 
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 RHS_TYPE &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator== (const 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 LHS_TYPE , class RHS_TYPE >
bool operator!= (const NullableAllocatedValue< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator!= (const 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 LHS_TYPE , class RHS_TYPE >
bool operator< (const NullableAllocatedValue< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator< (const 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 LHS_TYPE , class RHS_TYPE >
bool operator<= (const NullableAllocatedValue< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator<= (const 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 LHS_TYPE , class RHS_TYPE >
bool operator> (const NullableAllocatedValue< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator> (const 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 LHS_TYPE , class RHS_TYPE >
bool operator>= (const NullableAllocatedValue< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator>= (const LHS_TYPE &lhs, const NullableAllocatedValue< RHS_TYPE > &rhs)
 
template<class TYPE >
bsl::ostream & operator<< (bsl::ostream &stream, const NullableAllocatedValue< TYPE > &object)
 
template<class TYPE >
bool operator== (const NullableAllocatedValue< TYPE > &lhs, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 Return true if the specified lhs is null, and false otherwise.
 
template<class TYPE >
bool operator== (const bsl::nullopt_t &, const NullableAllocatedValue< TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
 Return true if the specified rhs is null, and false otherwise.
 
template<class TYPE >
bool operator!= (const NullableAllocatedValue< TYPE > &lhs, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 Return true if the specified lhs is not null, and false otherwise.
 
template<class TYPE >
bool operator!= (const bsl::nullopt_t &, const NullableAllocatedValue< TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
 
template<class TYPE >
bool operator< (const NullableAllocatedValue< TYPE > &, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 
template<class TYPE >
bool operator< (const bsl::nullopt_t &, const NullableAllocatedValue< TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
 
template<class TYPE >
bool operator> (const NullableAllocatedValue< TYPE > &lhs, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 
template<class TYPE >
bool operator> (const bsl::nullopt_t &, const NullableAllocatedValue< TYPE > &) BSLS_KEYWORD_NOEXCEPT
 
template<class TYPE >
bool operator<= (const NullableAllocatedValue< TYPE > &lhs, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 Return true if the specified lhs is null, and false otherwise.
 
template<class TYPE >
bool operator<= (const bsl::nullopt_t &, const NullableAllocatedValue< TYPE > &) BSLS_KEYWORD_NOEXCEPT
 Return true.
 
template<class TYPE >
bool operator>= (const NullableAllocatedValue< TYPE > &, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 Return true.
 
template<class TYPE >
bool operator>= (const bsl::nullopt_t &, const NullableAllocatedValue< TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
 Return true if the specified rhs is null, and false otherwise.
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator== (const NullableAllocatedValue< 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 NullableAllocatedValue< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator!= (const NullableAllocatedValue< 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 NullableAllocatedValue< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator< (const NullableAllocatedValue< 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 NullableAllocatedValue< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator> (const NullableAllocatedValue< 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 NullableAllocatedValue< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator<= (const NullableAllocatedValue< 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 NullableAllocatedValue< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator>= (const NullableAllocatedValue< 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 NullableAllocatedValue< RHS_TYPE > &rhs)
 
template<class HASHALG , class TYPE >
void hashAppend (HASHALG &hashAlg, const NullableAllocatedValue< TYPE > &input)
 
template<class TYPE >
void swap (NullableAllocatedValue< TYPE > &a, NullableAllocatedValue< TYPE > &b)
 
template<class t_TYPE , unsigned t_NUM_BITS>
bool operator== (const NullableAllocatedValue_PointerBitsPair< t_TYPE, t_NUM_BITS > &lhs, const NullableAllocatedValue_PointerBitsPair< t_TYPE, t_NUM_BITS > &rhs)
 
template<class t_TYPE , unsigned t_NUM_BITS>
bool operator!= (const NullableAllocatedValue_PointerBitsPair< t_TYPE, t_NUM_BITS > &lhs, const NullableAllocatedValue_PointerBitsPair< t_TYPE, t_NUM_BITS > &rhs)
 
template<class t_TYPE , unsigned t_NUM_BITS>
void swap (NullableAllocatedValue_PointerBitsPair< t_TYPE, t_NUM_BITS > &a, NullableAllocatedValue_PointerBitsPair< t_TYPE, t_NUM_BITS > &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 bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 Return true if the specified value is null, and false otherwise.
 
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator== (const bsl::nullopt_t &, const NullableValue< TYPE > &value) BSLS_KEYWORD_NOEXCEPT
 Return true if the specified value is null, and false otherwise.
 
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator!= (const NullableValue< TYPE > &value, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator!= (const bsl::nullopt_t &, const NullableValue< TYPE > &value) BSLS_KEYWORD_NOEXCEPT
 
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator< (const NullableValue< TYPE > &, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator< (const bsl::nullopt_t &, const NullableValue< TYPE > &value) BSLS_KEYWORD_NOEXCEPT
 
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator> (const NullableValue< TYPE > &value, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator> (const bsl::nullopt_t &, const NullableValue< TYPE > &) BSLS_KEYWORD_NOEXCEPT
 
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator<= (const NullableValue< TYPE > &value, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 Return true if the specified value is null, and false otherwise.
 
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator<= (const bsl::nullopt_t &, const NullableValue< TYPE > &) BSLS_KEYWORD_NOEXCEPT
 Return true.
 
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator>= (const NullableValue< TYPE > &, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 Return true.
 
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator>= (const bsl::nullopt_t &, const NullableValue< TYPE > &value) BSLS_KEYWORD_NOEXCEPT
 Return true if the specified value is null, and false otherwise.
 
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::enable_if<!BloombergLP::bslma::UsesBslmaAllocator< TYPE >::value, void >::type swap (NullableValue< TYPE > &lhs, NullableValue< TYPE > &rhs)
 
template<class HASHALG , class TYPE >
void hashAppend (HASHALG &hashAlg, const NullableValueRef< TYPE > &input)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator== (const NullableValueRef< LHS_TYPE > &lhs, const NullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator== (const NullableValueRef< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator== (const LHS_TYPE &lhs, const NullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator!= (const NullableValueRef< LHS_TYPE > &lhs, const NullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator!= (const NullableValueRef< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator!= (const LHS_TYPE &lhs, const NullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator< (const NullableValueRef< LHS_TYPE > &lhs, const NullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator< (const NullableValueRef< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator< (const LHS_TYPE &lhs, const NullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator<= (const NullableValueRef< LHS_TYPE > &lhs, const NullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator<= (const NullableValueRef< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator<= (const LHS_TYPE &lhs, const NullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator> (const NullableValueRef< LHS_TYPE > &lhs, const NullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator> (const NullableValueRef< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator> (const LHS_TYPE &lhs, const NullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator>= (const NullableValueRef< LHS_TYPE > &lhs, const NullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator>= (const NullableValueRef< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator>= (const LHS_TYPE &lhs, const NullableValueRef< RHS_TYPE > &rhs)
 
template<class TYPE >
bool operator== (const NullableValueRef< TYPE > &lhs, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 Return true if the specified lhs is null, and false otherwise.
 
template<class TYPE >
bool operator== (const bsl::nullopt_t &, const NullableValueRef< TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
 Return true if the specified rhs is null, and false otherwise.
 
template<class TYPE >
bool operator!= (const NullableValueRef< TYPE > &lhs, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 Return true if the specified lhs is not null, and false otherwise.
 
template<class TYPE >
bool operator!= (const bsl::nullopt_t &, const NullableValueRef< TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
 
template<class TYPE >
bool operator< (const NullableValueRef< TYPE > &, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 
template<class TYPE >
bool operator< (const bsl::nullopt_t &, const NullableValueRef< TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
 
template<class TYPE >
bool operator> (const NullableValueRef< TYPE > &lhs, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 
template<class TYPE >
bool operator> (const bsl::nullopt_t &, const NullableValueRef< TYPE > &) BSLS_KEYWORD_NOEXCEPT
 
template<class TYPE >
bool operator<= (const NullableValueRef< TYPE > &lhs, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 Return true if the specified lhs is null, and false otherwise.
 
template<class TYPE >
bool operator<= (const bsl::nullopt_t &, const NullableValueRef< TYPE > &) BSLS_KEYWORD_NOEXCEPT
 Return true.
 
template<class TYPE >
bool operator>= (const NullableValueRef< TYPE > &, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 Return true.
 
template<class TYPE >
bool operator>= (const bsl::nullopt_t &, const NullableValueRef< TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
 Return true if the specified rhs is null, and false otherwise.
 
template<class HASHALG , class TYPE >
void hashAppend (HASHALG &hashAlg, const ConstNullableValueRef< TYPE > &input)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator== (const ConstNullableValueRef< LHS_TYPE > &lhs, const ConstNullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator== (const ConstNullableValueRef< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator== (const LHS_TYPE &lhs, const ConstNullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator!= (const ConstNullableValueRef< LHS_TYPE > &lhs, const ConstNullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator!= (const ConstNullableValueRef< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator!= (const LHS_TYPE &lhs, const ConstNullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator< (const ConstNullableValueRef< LHS_TYPE > &lhs, const ConstNullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator< (const ConstNullableValueRef< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator< (const LHS_TYPE &lhs, const ConstNullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator<= (const ConstNullableValueRef< LHS_TYPE > &lhs, const ConstNullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator<= (const ConstNullableValueRef< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator<= (const LHS_TYPE &lhs, const ConstNullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator> (const ConstNullableValueRef< LHS_TYPE > &lhs, const ConstNullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator> (const ConstNullableValueRef< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator> (const LHS_TYPE &lhs, const ConstNullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator>= (const ConstNullableValueRef< LHS_TYPE > &lhs, const ConstNullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator>= (const ConstNullableValueRef< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator>= (const LHS_TYPE &lhs, const ConstNullableValueRef< RHS_TYPE > &rhs)
 
template<class TYPE >
bool operator== (const ConstNullableValueRef< TYPE > &lhs, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 Return true if the specified lhs is null, and false otherwise.
 
template<class TYPE >
bool operator== (const bsl::nullopt_t &, const ConstNullableValueRef< TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
 Return true if the specified rhs is null, and false otherwise.
 
template<class TYPE >
bool operator!= (const ConstNullableValueRef< TYPE > &lhs, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 Return true if the specified lhs is not null, and false otherwise.
 
template<class TYPE >
bool operator!= (const bsl::nullopt_t &, const ConstNullableValueRef< TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
 
template<class TYPE >
bool operator< (const ConstNullableValueRef< TYPE > &, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 
template<class TYPE >
bool operator< (const bsl::nullopt_t &, const ConstNullableValueRef< TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
 
template<class TYPE >
bool operator> (const ConstNullableValueRef< TYPE > &lhs, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 
template<class TYPE >
bool operator> (const bsl::nullopt_t &, const ConstNullableValueRef< TYPE > &) BSLS_KEYWORD_NOEXCEPT
 
template<class TYPE >
bool operator<= (const ConstNullableValueRef< TYPE > &lhs, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 Return true if the specified lhs is null, and false otherwise.
 
template<class TYPE >
bool operator<= (const bsl::nullopt_t &, const ConstNullableValueRef< TYPE > &) BSLS_KEYWORD_NOEXCEPT
 Return true.
 
template<class TYPE >
bool operator>= (const ConstNullableValueRef< TYPE > &, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
 Return true.
 
template<class TYPE >
bool operator>= (const bsl::nullopt_t &, const ConstNullableValueRef< TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
 Return true if the specified rhs is null, and false otherwise.
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator== (const ConstNullableValueRef< LHS_TYPE > &lhs, const NullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator== (const NullableValueRef< LHS_TYPE > &lhs, const ConstNullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator!= (const ConstNullableValueRef< LHS_TYPE > &lhs, const NullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator!= (const NullableValueRef< LHS_TYPE > &lhs, const ConstNullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator< (const ConstNullableValueRef< LHS_TYPE > &lhs, const NullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator< (const NullableValueRef< LHS_TYPE > &lhs, const ConstNullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator<= (const ConstNullableValueRef< LHS_TYPE > &lhs, const NullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator<= (const NullableValueRef< LHS_TYPE > &lhs, const ConstNullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator> (const ConstNullableValueRef< LHS_TYPE > &lhs, const NullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator> (const NullableValueRef< LHS_TYPE > &lhs, const ConstNullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator>= (const ConstNullableValueRef< LHS_TYPE > &lhs, const NullableValueRef< RHS_TYPE > &rhs)
 
template<class LHS_TYPE , class RHS_TYPE >
bool operator>= (const NullableValueRef< LHS_TYPE > &lhs, const ConstNullableValueRef< RHS_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)
 
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 bsl::nullopt_t nullOpt
 

Typedef Documentation

◆ NullOptType

typedef bsl::nullopt_t bdlb::NullOptType

This class provides an empty tag type so that bdlb::NullableValue can be explicitly constructed in or assigned to an empty state. There are no publicly accessible constructors for this type other than the copy constructor. In particular, it is not default constructible, nor list-initializable in C++11.

◆ ScopeExitAny

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

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

◆ Variant_ReturnValueHelper_YesType

typedef char bdlb::Variant_ReturnValueHelper_YesType

Function Documentation

◆ hashAppend() [1/12]

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

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

◆ hashAppend() [2/12]

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

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

◆ hashAppend() [3/12]

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

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

◆ hashAppend() [4/12]

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

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

◆ hashAppend() [5/12]

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

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

◆ hashAppend() [6/12]

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

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

◆ hashAppend() [7/12]

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.

◆ hashAppend() [8/12]

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

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

◆ hashAppend() [9/12]

template<class HASHALG , class TYPE >
void bdlb::hashAppend ( HASHALG &  hashAlg,
const ConstNullableValueRef< TYPE > &  input 
)

Pass the boolean value of whether the specified input references a non-empty nullable value to the specified hashAlg hashing algorithm of (template parameter) type HASHALG. If input.has_value is true, additionally pass the value to hashAlg.

◆ hashAppend() [10/12]

template<class HASHALG , class TYPE >
void bdlb::hashAppend ( HASHALG &  hashAlg,
const NullableAllocatedValue< 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.

◆ hashAppend() [11/12]

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.

◆ hashAppend() [12/12]

template<class HASHALG , class TYPE >
void bdlb::hashAppend ( HASHALG &  hashAlg,
const NullableValueRef< TYPE > &  input 
)

Pass the boolean value of whether the specified input references a non-empty nullable value to the specified hashAlg hashing algorithm of (template parameter) type HASHALG. If input.has_value is true, additionally pass the value to hashAlg.

◆ operator!=() [1/39]

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.

◆ operator!=() [2/39]

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.

◆ operator!=() [3/39]

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.

◆ operator!=() [4/39]

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.

◆ operator!=() [5/39]

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.

◆ operator!=() [6/39]

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.

◆ operator!=() [7/39]

template<class TYPE >
bool bdlb::operator!= ( const bsl::nullopt_t &  ,
const ConstNullableValueRef< TYPE > &  rhs 
)

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

◆ operator!=() [8/39]

template<class TYPE >
bool bdlb::operator!= ( const bsl::nullopt_t &  ,
const NullableAllocatedValue< TYPE > &  rhs 
)

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

◆ operator!=() [9/39]

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

◆ operator!=() [10/39]

template<class TYPE >
bool bdlb::operator!= ( const bsl::nullopt_t &  ,
const NullableValueRef< TYPE > &  rhs 
)

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

◆ operator!=() [11/39]

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

◆ operator!=() [12/39]

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

◆ operator!=() [13/39]

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

Return true if the specified lhs and rhs nullable objects do not have the same value, and false otherwise. Two nullable wrappers do not have the same value if one is null and the other is non-null, or if bost 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.

◆ operator!=() [14/39]

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

Return true if the specified lhs and rhs nullable objects do not have the same value, and false otherwise. Two nullable wrappers 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.

◆ operator!=() [15/39]

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

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. A nullable wrappers and a value of some type do not have the same value if either the nullable wrappers 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.

◆ operator!=() [16/39]

template<class TYPE >
bool bdlb::operator!= ( const ConstNullableValueRef< TYPE > &  lhs,
const bsl::nullopt_t &   
)

◆ operator!=() [17/39]

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.

◆ operator!=() [18/39]

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.

◆ operator!=() [19/39]

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

◆ operator!=() [20/39]

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

◆ operator!=() [21/39]

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

◆ operator!=() [22/39]

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

◆ operator!=() [23/39]

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

If neither of the specified lhs and rhs contain a value, return false. If one contains a value, and the other does not, return true. Otherwise, return lhs.value != rhs.value().

◆ operator!=() [24/39]

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.

◆ operator!=() [25/39]

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator!= ( const NullableAllocatedValue< LHS_TYPE > &  lhs,
const 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.

◆ operator!=() [26/39]

template<class TYPE >
bool bdlb::operator!= ( const NullableAllocatedValue< TYPE > &  lhs,
const bsl::nullopt_t &   
)

◆ operator!=() [27/39]

template<class t_TYPE , unsigned t_NUM_BITS>
bool bdlb::operator!= ( const NullableAllocatedValue_PointerBitsPair< t_TYPE, t_NUM_BITS > &  lhs,
const NullableAllocatedValue_PointerBitsPair< t_TYPE, t_NUM_BITS > &  rhs 
)

Return false if the specified lhs and rhs objects have the same value, and true otherwise. Two NullableAllocatedValue_PointerBitsPair objects have the same value when their pointer and flags are the same.

◆ operator!=() [28/39]

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

◆ operator!=() [29/39]

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator!= ( const NullableValue< LHS_TYPE > &  lhs,
const NullableValue< 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.

◆ operator!=() [30/39]

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

◆ operator!=() [31/39]

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

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

◆ operator!=() [32/39]

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

◆ operator!=() [33/39]

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

Return true if the specified lhs and rhs nullable objects do not have the same value, and false otherwise. Two nullable wrappers 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.

◆ operator!=() [34/39]

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

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. A nullable wrappers and a value of some type do not have the same value if either the nullable wrappers 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.

◆ operator!=() [35/39]

template<class TYPE >
bool bdlb::operator!= ( const NullableValueRef< TYPE > &  lhs,
const bsl::nullopt_t &   
)

◆ operator!=() [36/39]

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

◆ operator!=() [37/39]

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.

◆ operator!=() [38/39]

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.

◆ operator!=() [39/39]

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.

◆ operator+() [1/2]

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.

◆ operator+() [2/2]

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.

◆ operator++() [1/4]

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

◆ operator++() [2/4]

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

◆ operator++() [3/4]

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.

◆ operator++() [4/4]

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.

◆ operator-() [1/2]

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.

◆ operator-() [2/2]

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.

◆ operator--()

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.

◆ operator<() [1/28]

template<class TYPE >
bool bdlb::operator< ( const bsl::nullopt_t &  ,
const ConstNullableValueRef< TYPE > &  rhs 
)

Return true if the specified rhs is not null, and false otherwise. Note that bsl::nullopt is ordered before any ConstNullableValueRef that is not null.

◆ operator<() [2/28]

template<class TYPE >
bool bdlb::operator< ( const bsl::nullopt_t &  ,
const NullableAllocatedValue< TYPE > &  rhs 
)

Return true if the specified rhs is not null, and false otherwise. Note that bsl::nullopt is ordered before any NullableAllocatedValue that is not null.

◆ operator<() [3/28]

template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool bdlb::operator< ( const bsl::nullopt_t &  ,
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.

◆ operator<() [4/28]

template<class TYPE >
bool bdlb::operator< ( const bsl::nullopt_t &  ,
const NullableValueRef< TYPE > &  rhs 
)

Return true if the specified rhs is not null, and false otherwise. Note that bsl::nullopt is ordered before any NullableValueRef that is not null.

◆ operator<() [5/28]

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

If neither of the specified lhs and rhs contain a value, return false. If lhs contains a value, and rhs does not, return false. If lhs does not contains a value, rhs does, return true. Otherwise, return lhs.value < rhs.value().

◆ operator<() [6/28]

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

◆ operator<() [7/28]

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

Return true if the specified lhs nullable wrapper 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.

◆ operator<() [8/28]

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

Return true if the specified lhs nullable wrapper 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.

◆ operator<() [9/28]

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

Return true if the specified lhs nullable wrapper 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.

◆ operator<() [10/28]

template<class TYPE >
bool bdlb::operator< ( const ConstNullableValueRef< TYPE > &  ,
const bsl::nullopt_t &   
)

Return false. bsl::nullopt never orders after a ConstNullableValueRef.

◆ operator<() [11/28]

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.

◆ operator<() [12/28]

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

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

◆ operator<() [13/28]

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator< ( const LHS_TYPE &  lhs,
const NullableAllocatedValue< 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().

◆ operator<() [14/28]

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

◆ operator<() [15/28]

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

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

◆ operator<() [16/28]

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

If neither of the specified lhs and rhs contain a value, return false. If lhs contains a value, and rhs does not, return false. If lhs does not contains a value, rhs does, return true. Otherwise, return lhs.value < rhs.value().

◆ operator<() [17/28]

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

◆ operator<() [18/28]

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator< ( const NullableAllocatedValue< 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.

◆ operator<() [19/28]

template<class TYPE >
bool bdlb::operator< ( const NullableAllocatedValue< TYPE > &  ,
const bsl::nullopt_t &   
)

Return false. Note that bsl::nullopt never orders after a NullableAllocatedValue.

◆ operator<() [20/28]

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

◆ operator<() [21/28]

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator< ( const NullableValue< LHS_TYPE > &  lhs,
const NullableValue< 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.

◆ operator<() [22/28]

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.

◆ operator<() [23/28]

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

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

◆ operator<() [24/28]

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

◆ operator<() [25/28]

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

Return true if the specified lhs nullable wrapper 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.

◆ operator<() [26/28]

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

Return true if the specified lhs nullable wrapper 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.

◆ operator<() [27/28]

template<class TYPE >
bool bdlb::operator< ( const NullableValueRef< TYPE > &  ,
const bsl::nullopt_t &   
)

Return false. bsl::nullopt never orders after a NullableValueRef.

◆ operator<() [28/28]

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.

◆ operator<<() [1/16]

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.

◆ operator<<() [2/16]

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.

◆ operator<<() [3/16]

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.

◆ operator<<() [4/16]

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.

◆ operator<<() [5/16]

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.

◆ operator<<() [6/16]

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.

◆ operator<<() [7/16]

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.

◆ operator<<() [8/16]

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

◆ operator<<() [9/16]

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

◆ operator<<() [10/16]

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

◆ operator<<() [11/16]

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

◆ operator<<() [12/16]

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

◆ operator<<() [13/16]

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

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.

◆ operator<<() [14/16]

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

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

◆ operator<<() [15/16]

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

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

◆ operator<<() [16/16]

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.

◆ operator<=() [1/28]

template<class TYPE >
bool bdlb::operator<= ( const bsl::nullopt_t &  ,
const ConstNullableValueRef< TYPE > &   
)

◆ operator<=() [2/28]

template<class TYPE >
bool bdlb::operator<= ( const bsl::nullopt_t &  ,
const NullableAllocatedValue< TYPE > &   
)

◆ operator<=() [3/28]

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

◆ operator<=() [4/28]

template<class TYPE >
bool bdlb::operator<= ( const bsl::nullopt_t &  ,
const NullableValueRef< TYPE > &   
)

◆ operator<=() [5/28]

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

If neither of the specified lhs and rhs contain a value, return true. If lhs contains a value, and rhs does not, return false. If lhs does not contains a value, rhs does, return true. Otherwise, return lhs.value <= rhs.value().

◆ operator<=() [6/28]

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

◆ operator<=() [7/28]

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

Return true if the specified lhs nullable wrapper 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 function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

◆ operator<=() [8/28]

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

Return true if the specified lhs nullable wrapper 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 function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

◆ operator<=() [9/28]

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

Return true if the specified lhs nullable wrapper 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).

◆ operator<=() [10/28]

template<class TYPE >
bool bdlb::operator<= ( const ConstNullableValueRef< TYPE > &  lhs,
const bsl::nullopt_t &   
)

◆ operator<=() [11/28]

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.

◆ operator<=() [12/28]

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

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

◆ operator<=() [13/28]

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator<= ( const LHS_TYPE &  lhs,
const NullableAllocatedValue< 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).

◆ operator<=() [14/28]

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==.)

◆ operator<=() [15/28]

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

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

◆ operator<=() [16/28]

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

If neither of the specified lhs and rhs contain a value, return true. If lhs contains a value, and rhs does not, return false. If lhs does not contains a value, rhs does, return true. Otherwise, return lhs.value <= rhs.value().

◆ operator<=() [17/28]

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

◆ operator<=() [18/28]

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator<= ( const NullableAllocatedValue< 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).

◆ operator<=() [19/28]

template<class TYPE >
bool bdlb::operator<= ( const NullableAllocatedValue< TYPE > &  lhs,
const bsl::nullopt_t &   
)

◆ operator<=() [20/28]

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

◆ operator<=() [21/28]

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator<= ( const NullableValue< LHS_TYPE > &  lhs,
const NullableValue< 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 *lhs <= *rhs when both operands are of NullableValue type and have a value. Also note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

◆ operator<=() [22/28]

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==.)

◆ operator<=() [23/28]

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

◆ operator<=() [24/28]

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

◆ operator<=() [25/28]

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

Return true if the specified lhs nullable wrapper 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 function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

◆ operator<=() [26/28]

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

Return true if the specified lhs nullable wrapper 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).

◆ operator<=() [27/28]

template<class TYPE >
bool bdlb::operator<= ( const NullableValueRef< TYPE > &  lhs,
const bsl::nullopt_t &   
)

◆ operator<=() [28/28]

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.

◆ operator==() [1/39]

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.

◆ operator==() [2/39]

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.

◆ operator==() [3/39]

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.

◆ operator==() [4/39]

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.

◆ operator==() [5/39]

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.

◆ operator==() [6/39]

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.

◆ operator==() [7/39]

template<class TYPE >
bool bdlb::operator== ( const bsl::nullopt_t &  ,
const ConstNullableValueRef< TYPE > &  rhs 
)

◆ operator==() [8/39]

template<class TYPE >
bool bdlb::operator== ( const bsl::nullopt_t &  ,
const NullableAllocatedValue< TYPE > &  rhs 
)

◆ operator==() [9/39]

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

◆ operator==() [10/39]

template<class TYPE >
bool bdlb::operator== ( const bsl::nullopt_t &  ,
const NullableValueRef< TYPE > &  rhs 
)

◆ operator==() [11/39]

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

◆ operator==() [12/39]

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

◆ operator==() [13/39]

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

Return true if the specified lhs and rhs nullable wrappers have the same value, and false otherwise. Two nullable wrappers have the same value if both targets 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.

◆ operator==() [14/39]

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

Return true if the specified lhs and rhs nullable wrappers have the same value, and false otherwise. Two nullable wrappers have the same value if both targets 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.

◆ operator==() [15/39]

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

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

◆ operator==() [16/39]

template<class TYPE >
bool bdlb::operator== ( const ConstNullableValueRef< TYPE > &  lhs,
const bsl::nullopt_t &   
)

◆ operator==() [17/39]

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.

◆ operator==() [18/39]

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.

◆ operator==() [19/39]

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

◆ operator==() [20/39]

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

◆ operator==() [21/39]

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

◆ operator==() [22/39]

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

◆ operator==() [23/39]

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

If neither of the specified lhs and rhs contain a value, return true. If one contains a value, and the other does not, return false. Otherwise, return lhs.value == rhs.value().

◆ operator==() [24/39]

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.

◆ operator==() [25/39]

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator== ( const NullableAllocatedValue< LHS_TYPE > &  lhs,
const 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.

◆ operator==() [26/39]

template<class TYPE >
bool bdlb::operator== ( const NullableAllocatedValue< TYPE > &  lhs,
const bsl::nullopt_t &   
)

◆ operator==() [27/39]

template<class t_TYPE , unsigned t_NUM_BITS>
bool bdlb::operator== ( const NullableAllocatedValue_PointerBitsPair< t_TYPE, t_NUM_BITS > &  lhs,
const NullableAllocatedValue_PointerBitsPair< t_TYPE, t_NUM_BITS > &  rhs 
)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two NullableAllocatedValue_PointerBitsPair objects have the same value when their pointer and flags are the same.

◆ operator==() [28/39]

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

◆ operator==() [29/39]

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator== ( const NullableValue< 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.

◆ operator==() [30/39]

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

◆ operator==() [31/39]

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

◆ operator==() [32/39]

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

◆ operator==() [33/39]

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

Return true if the specified lhs and rhs nullable wrappers have the same value, and false otherwise. Two nullable wrappers have the same value if both targets 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.

◆ operator==() [34/39]

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

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

◆ operator==() [35/39]

template<class TYPE >
bool bdlb::operator== ( const NullableValueRef< TYPE > &  lhs,
const bsl::nullopt_t &   
)

◆ operator==() [36/39]

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

◆ operator==() [37/39]

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.

◆ operator==() [38/39]

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.

◆ operator==() [39/39]

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.

◆ operator>() [1/28]

template<class TYPE >
bool bdlb::operator> ( const bsl::nullopt_t &  ,
const ConstNullableValueRef< TYPE > &   
)

Return false. bsl::nullopt never orders after a NullableValueRef.

◆ operator>() [2/28]

template<class TYPE >
bool bdlb::operator> ( const bsl::nullopt_t &  ,
const NullableAllocatedValue< TYPE > &   
)

Return false. Note that bsl::nullopt never orders after a NullableAllocatedValue.

◆ operator>() [3/28]

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

◆ operator>() [4/28]

template<class TYPE >
bool bdlb::operator> ( const bsl::nullopt_t &  ,
const NullableValueRef< TYPE > &   
)

Return false. bsl::nullopt never orders after a NullableValueRef.

◆ operator>() [5/28]

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

If neither of the specified lhs and rhs contain a value, return false. If lhs contains a value, and rhs does not, return true. If lhs does not contains a value, rhs does, return false. Otherwise, return lhs.value > rhs.value().

◆ operator>() [6/28]

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

◆ operator>() [7/28]

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

Return true if the specified lhs nullable wrapper 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.

◆ operator>() [8/28]

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

Return true if the specified lhs nullable wrapper 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.

◆ operator>() [9/28]

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

Return true if the specified lhs nullable wrapper 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.

◆ operator>() [10/28]

template<class TYPE >
bool bdlb::operator> ( const ConstNullableValueRef< TYPE > &  lhs,
const bsl::nullopt_t &   
)

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

◆ operator>() [11/28]

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.

◆ operator>() [12/28]

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

Return true if the specified lhs is ordered after the specified rhs nullable wrapper, 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.

◆ operator>() [13/28]

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator> ( const LHS_TYPE &  lhs,
const NullableAllocatedValue< 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.

◆ operator>() [14/28]

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

◆ operator>() [15/28]

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

Return true if the specified lhs is ordered after the specified rhs nullable wrapper, 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.

◆ operator>() [16/28]

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

If neither of the specified lhs and rhs contain a value, return false. If lhs contains a value, and rhs does not, return true. If lhs does not contains a value, rhs does, return false. Otherwise, return lhs.value > rhs.value().

◆ operator>() [17/28]

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

◆ operator>() [18/28]

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator> ( const NullableAllocatedValue< 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.

◆ operator>() [19/28]

template<class TYPE >
bool bdlb::operator> ( const NullableAllocatedValue< TYPE > &  lhs,
const bsl::nullopt_t &   
)

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

◆ operator>() [20/28]

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

◆ operator>() [21/28]

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator> ( const NullableValue< LHS_TYPE > &  lhs,
const NullableValue< 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 *lhs > *rhs when both operands are of NullableValue type and both have values. Also note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

◆ operator>() [22/28]

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.

◆ operator>() [23/28]

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

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

◆ operator>() [24/28]

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

◆ operator>() [25/28]

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

Return true if the specified lhs nullable wrapper 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 bsl::optional type. Also note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

◆ operator>() [26/28]

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

Return true if the specified lhs nullable wrapper 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.

◆ operator>() [27/28]

template<class TYPE >
bool bdlb::operator> ( const NullableValueRef< TYPE > &  lhs,
const bsl::nullopt_t &   
)

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

◆ operator>() [28/28]

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.

◆ operator>=() [1/28]

template<class TYPE >
bool bdlb::operator>= ( const bsl::nullopt_t &  ,
const ConstNullableValueRef< TYPE > &  rhs 
)

◆ operator>=() [2/28]

template<class TYPE >
bool bdlb::operator>= ( const bsl::nullopt_t &  ,
const NullableAllocatedValue< TYPE > &  rhs 
)

◆ operator>=() [3/28]

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

◆ operator>=() [4/28]

template<class TYPE >
bool bdlb::operator>= ( const bsl::nullopt_t &  ,
const NullableValueRef< TYPE > &  rhs 
)

◆ operator>=() [5/28]

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

If neither of the specified lhs and rhs contain a value, return true. If lhs contains a value, and rhs does not, return true. If lhs does not contains a value, rhs does, return false. Otherwise, return lhs.value >= rhs.value().

◆ operator>=() [6/28]

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

◆ operator>=() [7/28]

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

Return true if the specified lhs nullable object is ordered after the specified rhs nullable wrapper 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.

◆ operator>=() [8/28]

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

Return true if the specified lhs nullable object is ordered after the specified rhs nullable wrapper 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.

◆ operator>=() [9/28]

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

Return true if the specified lhs nullable wrapper 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).

◆ operator>=() [10/28]

template<class TYPE >
bool bdlb::operator>= ( const ConstNullableValueRef< TYPE > &  ,
const bsl::nullopt_t &   
)

◆ operator>=() [11/28]

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.

◆ operator>=() [12/28]

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

Return true if the specified lhs is wrapper 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).

◆ operator>=() [13/28]

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator>= ( const LHS_TYPE &  lhs,
const NullableAllocatedValue< 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).

◆ operator>=() [14/28]

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==.)

◆ operator>=() [15/28]

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

Return true if the specified lhs is wrapper 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).

◆ operator>=() [16/28]

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

If neither of the specified lhs and rhs contain a value, return true. If lhs contains a value, and rhs does not, return true. If lhs does not contains a value, rhs does, return false. Otherwise, return lhs.value >= rhs.value().

◆ operator>=() [17/28]

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

◆ operator>=() [18/28]

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator>= ( const NullableAllocatedValue< 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).

◆ operator>=() [19/28]

template<class TYPE >
bool bdlb::operator>= ( const NullableAllocatedValue< TYPE > &  ,
const bsl::nullopt_t &   
)

◆ operator>=() [20/28]

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

◆ operator>=() [21/28]

template<class LHS_TYPE , class RHS_TYPE >
bool bdlb::operator>= ( const NullableValue< LHS_TYPE > &  lhs,
const NullableValue< 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 and have a value. Also note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

◆ operator>=() [22/28]

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==.)

◆ operator>=() [23/28]

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

◆ operator>=() [24/28]

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

◆ operator>=() [25/28]

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

Return true if the specified lhs nullable object is ordered after the specified rhs nullable wrapper 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 bsl::optional type. Also note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

◆ operator>=() [26/28]

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

Return true if the specified lhs nullable wrapper 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).

◆ operator>=() [27/28]

template<class TYPE >
bool bdlb::operator>= ( const NullableValueRef< TYPE > &  ,
const bsl::nullopt_t &   
)

◆ operator>=() [28/28]

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.

◆ swap() [1/6]

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.

◆ swap() [2/6]

template<class t_TYPE , unsigned t_NUM_BITS>
void bdlb::swap ( NullableAllocatedValue_PointerBitsPair< t_TYPE, t_NUM_BITS > &  a,
NullableAllocatedValue_PointerBitsPair< t_TYPE, t_NUM_BITS > &  b 
)

Exchange the values of the specified a and b objects. This function provides the no-throw exception-safety guarantee.

◆ swap() [3/6]

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.

◆ swap() [4/6]

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

◆ swap() [5/6]

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.

◆ swap() [6/6]

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

◆ nullOpt

const bsl::nullopt_t bdlb::nullOpt
extern

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