lsst::afw::typehandling::Key< K, V > Class Template Reference

Key for type-safe lookup in a GenericMap. More...

#include <Key.h>

Public Types
using	KeyType = K
using	ValueType = V

Public Member Functions
constexpr	Key (K id)
	Construct a new key. More...
	Key (Key const &)=default
	Key (Key &&)=default
Key &	operator= (Key const &)=default
Key &	operator= (Key &&)=default
template<typename U >
	Key (Key< K, U > other)
	Convert a key to a different key that could retrieve the same values. More...
constexpr K const &	getId () const noexcept
	Return the identifier of this field. More...
template<typename U >
constexpr bool	operator< (Key< K, U > const &other) const noexcept
	Define sort order for Keys. More...
std::size_t	hash_value () const noexcept
	Return a hash of this object. More...
constexpr bool	operator== (Key< K, V > const &other) const noexcept
	Test for key equality. More...
template<typename U >
constexpr std::enable_if_t<!std::is_same< U, V >::value, bool >	operator== (Key< K, U > const &) const noexcept
	Test for key equality. More...
template<typename U >
constexpr bool	operator!= (Key< K, U > const &other) const noexcept
	Test for key equality. More...

Related Functions
(Note that these are not member functions.)
template<typename V , typename K >
constexpr Key< K, V >	makeKey (K const &id)
	Factory function for Key, to enable type parameter inference. More...
template<typename K , typename V >
std::ostream &	operator<< (std::ostream &os, Key< K, V > const &key)
	Output operator for Key. More...

Detailed Description

template<typename K, typename V>
class lsst::afw::typehandling::Key< K, V >

Key for type-safe lookup in a GenericMap.

Template Parameters

K	the logical type of the key (e.g., a string)
V	the type of the value mapped to this key

Key objects are equality-comparable, hashable, sortable, or printable if and only if K is comparable, hashable, sortable, or printable, respectively. Key can be used in compile-time expressions if and only if K can (in particular, Key<std::string, V> cannot).

Definition at line 52 of file Key.h.

Member Typedef Documentation

KeyType

template<typename K , typename V >

using lsst::afw::typehandling::Key< K, V >::KeyType = K

Definition at line 54 of file Key.h.

ValueType

template<typename K , typename V >

using lsst::afw::typehandling::Key< K, V >::ValueType = V

Definition at line 55 of file Key.h.

Constructor & Destructor Documentation

Key() [1/4]

template<typename K , typename V >

constexpr lsst::afw::typehandling::Key< K, V >::Key ( K  id )

inlineexplicitconstexpr

Construct a new key.

Parameters

id	the identifier of the field. For most purposes, this value is the actual key; it can be retrieved by calling getId().

Exception Safety

Provides the same exception safety as the copy-constructor of K.

See also

makeKey

Definition at line 68 of file Key.h.

: id(id) {}

Key() [2/4]

template<typename K , typename V >

lsst::afw::typehandling::Key< K, V >::Key ( Key< K, V > const &  )

default

Key() [3/4]

template<typename K , typename V >

lsst::afw::typehandling::Key< K, V >::Key ( Key< K, V > &&  )

default

Key() [4/4]

template<typename K , typename V >

template<typename U >

lsst::afw::typehandling::Key< K, V >::Key ( Key< K, U >  other )

inline

Convert a key to a different key that could retrieve the same values.

Template Parameters

U	The value type being converted from. Smart pointer keys are convertible if and only if the corresponding pointers are; other keys are convertible if and only if their value references are (consistent with pointers being retrieved by value and other types by reference).

Parameters

other

Note

This constructor is intended to support implicit conversions.

Definition at line 89 of file Key.h.

                         : id(other.getId()) {
        static_assert((!detail::IS_SMART_PTR<U> && !detail::IS_SMART_PTR<V> &&
                       std::is_convertible<U&, V&>::value) ||
                              (detail::IS_SMART_PTR<U> && detail::IS_SMART_PTR<V> &&
                               std::is_convertible<U, V>::value),
                      "Implicit conversion of Keys whose types are not implicitly convertible.");
    }

Member Function Documentation

getId()

template<typename K , typename V >

constexpr K const& lsst::afw::typehandling::Key< K, V >::getId ( ) const

inlineconstexprnoexcept

Return the identifier of this field.

The identifier serves as the "key" for the map abstraction represented by GenericMap.

Returns

the unique key defining this field

Definition at line 105 of file Key.h.

{ return id; }

hash_value()

template<typename K , typename V >

std::size_t lsst::afw::typehandling::Key< K, V >::hash_value ( ) const

inlinenoexcept

Return a hash of this object.

Definition at line 149 of file Key.h.

{ return std::hash<K>()(id); }

operator!=()

template<typename K , typename V >

template<typename U >

constexpr bool lsst::afw::typehandling::Key< K, V >::operator!= ( Key< K, U > const &  other ) const

inlineconstexprnoexcept

Test for key equality.

A key is considered equal to another key if and only if their getId() are equal and their value types are exactly the same (including const/volatile qualifications).

Definition at line 123 of file Key.h.

                                                                     {
        return !(*this == other);
    }

operator<()

template<typename K , typename V >

template<typename U >

constexpr bool lsst::afw::typehandling::Key< K, V >::operator< ( Key< K, U > const &  other ) const

inlineconstexprnoexcept

Define sort order for Keys.

This must be expressed as operator< instead of std::less because only std::less<void> supports arguments of mixed types, and it cannot be specialized.

Parameters

other

the key, possibly of a different type, to compare to

Returns

equivalent to this->getId() < other.getId()

Warning

this comparison operator provides a strict weak ordering so long as K does, but is not consistent with equality. In particular, keys with the same value of getId() but different types will be equivalent but not equal.

Definition at line 143 of file Key.h.

                                                                    {
        const std::less<K> comparator;
        return comparator(this->getId(), other.getId());
    }

operator=() [1/2]

template<typename K , typename V >

Key& lsst::afw::typehandling::Key< K, V >::operator= ( Key< K, V > &&  )

default

operator=() [2/2]

template<typename K , typename V >

Key& lsst::afw::typehandling::Key< K, V >::operator= ( Key< K, V > const &  )

default

operator==() [1/2]

template<typename K , typename V >

template<typename U >

constexpr std::enable_if_t<!std::is_same<U, V>::value, bool> lsst::afw::typehandling::Key< K, V >::operator== ( Key< K, U > const &  ) const

inlineconstexprnoexcept

Test for key equality.

A key is considered equal to another key if and only if their getId() are equal and their value types are exactly the same (including const/volatile qualifications).

Definition at line 118 of file Key.h.

                                                                                                       {
        return false;
    }

operator==() [2/2]

template<typename K , typename V >

constexpr bool lsst::afw::typehandling::Key< K, V >::operator== ( Key< K, V > const &  other ) const

inlineconstexprnoexcept

Test for key equality.

A key is considered equal to another key if and only if their getId() are equal and their value types are exactly the same (including const/volatile qualifications).

Definition at line 115 of file Key.h.

{ return this->id == other.id; }

Friends And Related Function Documentation

makeKey()

template<typename V , typename K >

constexpr Key< K, V > makeKey ( K const &  id )

related

Factory function for Key, to enable type parameter inference.

Parameters

id	the key ID to create.

Returns

a key of the desired type

Exception Safety

Provides the same exception safety as the copy-constructor of K.

Calling this function prevents you from having to explicitly name the key type:

auto key = makeKey<int>("foo");

Definition at line 173 of file Key.h.

                                         {
    return Key<K, V>(id);
}

operator<<()

template<typename K , typename V >

std::ostream & operator<< ( std::ostream &  os, Key< K, V > const &  key  )

related

Output operator for Key.

The output will use C++ template notation for the key; for example, a key "foo" pointing to an int may print as "foo<int>".

Parameters

os	the desired output stream
key	the key to print

Returns

a reference to os

Exception Safety

Provides basic exception safety if the output operator of K is exception-safe.

Warning

the type name is compiler-specific and may be mangled or unintuitive; for example, some compilers say "i" instead of "int"

Definition at line 196 of file Key.h.

                                                             {
    static const std::string typeStr = boost::core::demangle(typeid(V).name());
    static const std::string constStr = std::is_const<V>::value ? " const" : "";
    static const std::string volatileStr = std::is_volatile<V>::value ? " volatile" : "";
    os << key.getId() << "<" << typeStr << constStr << volatileStr << ">";
    return os;
}

---

The documentation for this class was generated from the following file:

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/afw/22.0.1-42-gca6935d93+ba5e5ca3eb/include/lsst/afw/typehandling/Key.h