Key.h

Go to the documentation of this file.

// -*- LSST-C++ -*-
/*
 * This file is part of afw.
 *
 * Developed for the LSST Data Management System.
 * This product includes software developed by the LSST Project
 * (https://www.lsst.org).
 * See the COPYRIGHT file at the top-level directory of this distribution
 * for details of code ownership.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef LSST_AFW_TYPEHANDLING_KEY_H
#define LSST_AFW_TYPEHANDLING_KEY_H
 
#include <functional>
#include <ostream>
#include <string>
#include <type_traits>
 
#include "boost/core/demangle.hpp"
 
#include "lsst/afw/typehandling/detail/type_traits.h"
 
namespace lsst {
namespace afw {
namespace typehandling {
 
template <typename K, typename V>
class Key final {
public:
    using KeyType = K;
    using ValueType = V;
 
    constexpr explicit Key(K id) : id(id) {}
 
    Key(Key const&) = default;
    Key(Key&&) = default;
    Key& operator=(Key const&) = default;
    Key& operator=(Key&&) = default;
 
    template <typename U>
    Key(Key<K, U> other) : 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.");
    }
 
    constexpr K const& getId() const noexcept { return id; }
 
    constexpr bool operator==(Key<K, V> const& other) const noexcept { return this->id == other.id; }
 
    template <typename U>
    constexpr std::enable_if_t<!std::is_same<U, V>::value, bool> operator==(Key<K, U> const&) const noexcept {
        return false;
    }
 
    template <typename U>
    constexpr bool operator!=(Key<K, U> const& other) const noexcept {
        return !(*this == other);
    }
 
    template <typename U>
    constexpr bool operator<(Key<K, U> const& other) const noexcept {
        const std::less<K> comparator;
        return comparator(this->getId(), other.getId());
    }
 
    std::size_t hash_value() const noexcept { return std::hash<K>()(id); }
 
private:
    K id;
};
 
// template parameters must be reversed for inference to work correctly
template <typename V, typename K>
constexpr Key<K, V> makeKey(K const& id) {
    return Key<K, V>(id);
}
 
template <typename K, typename V>
std::ostream& operator<<(std::ostream& os, Key<K, V> const& key) {
    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;
}
 
}  // namespace typehandling
}  // namespace afw
}  // namespace lsst
 
namespace std {
template <typename K, typename V>
struct hash<typename lsst::afw::typehandling::Key<K, V>> {
    using argument_type = typename lsst::afw::typehandling::Key<K, V>;
    using result_type = size_t;
    size_t operator()(argument_type const& obj) const noexcept { return obj.hash_value(); }
};
}  // namespace std
 
#endif