Key.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
#ifndef AFW_TABLE_Key_h_INCLUDED
#define AFW_TABLE_Key_h_INCLUDED
 
#include "lsst/cpputils/hashCombine.h"
 
#include "lsst/afw/table/FieldBase.h"
#include "lsst/afw/table/Flag.h"
#include "lsst/afw/table/KeyBase.h"
 
namespace lsst {
namespace afw {
namespace table {
 
namespace detail {
 
class Access;
 
}  // namespace detail
 
template <typename T>
class Key : public KeyBase<T>, public FieldBase<T> {
public:
 
    template <typename OtherT>
    bool operator==(Key<OtherT> const& other) const noexcept {
        return false;
    }
    template <typename OtherT>
    bool operator!=(Key<OtherT> const& other) const noexcept {
        return true;
    }
 
    bool operator==(Key const& other) const noexcept {
        return _offset == other._offset && this->getElementCount() == other.getElementCount();
    }
    bool operator!=(Key const& other) const noexcept { return !this->operator==(other); }
 
    std::size_t hash_value() const noexcept {
        // Completely arbitrary seed
        return cpputils::hashCombine(17, _offset, this->getElementCount());
    }
 
    std::size_t getOffset() const noexcept { return _offset; }
 
    bool isValid() const noexcept { return _valid; }
 
    Key() noexcept : FieldBase<T>(FieldBase<T>::makeDefault()), _offset(0), _valid(false) {}
 
    Key(Key const&) noexcept = default;
    Key(Key&&) noexcept = default;
    Key& operator=(Key const&) noexcept = default;
    Key& operator=(Key&&) noexcept = default;
    ~Key() noexcept = default;
 
    inline friend std::ostream& operator<<(std::ostream& os, Key<T> const& key) {
        return os << "Key<" << Key<T>::getTypeString() << ">(offset=" << key.getOffset()
                  << ", nElements=" << key.getElementCount() << ")";
    }
 
private:
    friend class detail::Access;
    friend class BaseRecord;
 
    explicit Key(std::size_t offset, FieldBase<T> const& fb = FieldBase<T>()) noexcept
            : FieldBase<T>(fb), _offset(offset), _valid(true) {}
 
    std::size_t _offset;
    bool _valid;
};
}  // namespace table
}  // namespace afw
}  // namespace lsst
 
namespace std {
template <typename T>
struct hash<lsst::afw::table::Key<T>> {
    using argument_type = lsst::afw::table::Key<T>;
    using result_type = size_t;
    size_t operator()(argument_type const& obj) const noexcept { return obj.hash_value(); }
};
}  // namespace std
 
#endif  // !AFW_TABLE_Key_h_INCLUDED