BloombergLP::bslstl::HashTable_ComparatorWrapper

Synopsis

Declared in <bslstl_hashtable.h>

template<class FUNCTOR>
class HashTable_ComparatorWrapper;

Description

TBD Provide an optimization for the case of an empty base functor, where we can safely const_cast want calling the base class operator.

Member Functions

Name	Description
`HashTable_ComparatorWrapper` [constructor]	Constructors
`functor`	Return a reference providing non-modifiable access to the hash functor wrapped by this object.
`operator()`	Call the wrapped `functor` with the specified `arg1` and `arg2` (in that order) and return the result. Note that `ARGn_TYPE` will typically be deduced as a `const` type.
`swap`	Exchange the value of this object with the specified `other` object.

Specializations

Name Description

HashTable_ComparatorWrapper<FUNCTOR const> This partial specialization handles const qualified functors, that may not be stored as a mutable member in the primary template. The need to wrap such functors diminishes greatly, as there is no need to play mutable tricks to invoke the function call operator. An alternative to providing this specialization would be to skip the wrapper entirely if using a const qualified functor in a HashTable. Note that this type has a const qualified data member, so is neither assignable nor swappable.

HashTable_ComparatorWrapper<FUNCTOR&> This partial specialization handles const qualified functors, that may not be stored as a mutable member in the primary template. Note that the FUNCTOR type itself may be const-qualified, so this one partial template specialization also handles const FUNCTOR& references. In order to correctly parse with the reference-binding rules, we drop the const in front of many of the references to FUNCTOR seen in the primary template definition. Note that this type has a reference data member, so is not default constructible, assignable or swappable.

Name	Description
`HashTable_ComparatorWrapper<FUNCTOR const>`	This partial specialization handles `const` qualified functors, that may not be stored as a `mutable` member in the primary template. The need to wrap such functors diminishes greatly, as there is no need to play mutable tricks to invoke the function call operator. An alternative to providing this specialization would be to skip the wrapper entirely if using a `const` qualified functor in a `HashTable`. Note that this type has a `const` qualified data member, so is neither assignable nor swappable.
`HashTable_ComparatorWrapper<FUNCTOR&>`	This partial specialization handles `const` qualified functors, that may not be stored as a `mutable` member in the primary template. Note that the `FUNCTOR` type itself may be `const`-qualified, so this one partial template specialization also handles `const FUNCTOR&` references. In order to correctly parse with the reference-binding rules, we drop the `const` in front of many of the references to `FUNCTOR` seen in the primary template definition. Note that this type has a reference data member, so is not default constructible, assignable or swappable.

Non-Member Functions

Name	Description
`swap`	Swap the functor wrapped by the specified `lhs` object with the functor wrapped by the specified `rhs` object.