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

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

#include <GenericMap.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 &)=delete
Key &	operator= (Key &&)=delete
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).

Note

Objects of this type are immutable.

Definition at line 63 of file GenericMap.h.

Member Typedef Documentation

KeyType

template<typename K, typename V>

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

Definition at line 65 of file GenericMap.h.

ValueType

template<typename K, typename V>

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

Definition at line 66 of file GenericMap.h.

Constructor & Destructor Documentation

Key() [1/3]

template<typename K, typename V>

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

inline

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 79 of file GenericMap.h.

: id(id) {}

Key() [2/3]

template<typename K, typename V>

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

default

Key() [3/3]

template<typename K, typename V>

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

default

Member Function Documentation

getId()

template<typename K, typename V>

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

inlinenoexcept

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 94 of file GenericMap.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 138 of file GenericMap.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

inlinenoexcept

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 112 of file GenericMap.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

inlinenoexcept

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 132 of file GenericMap.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 > const &  )

delete

operator=() [2/2]

template<typename K, typename V>

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

delete

operator==() [1/2]

template<typename K, typename V>

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

inlinenoexcept

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 104 of file GenericMap.h.

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

operator==() [2/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

inlinenoexcept

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 107 of file GenericMap.h.

                                                                                                       {
        return false;
    }

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 162 of file GenericMap.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 185 of file GenericMap.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/Linux64/afw/17.0.1-30-g596af8797/include/lsst/afw/typehandling/GenericMap.h