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/utils/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 utils::hashCombine(17, _offset, this->getElementCount());
    }

    int getOffset() const noexcept { return _offset; }

    bool isValid() const noexcept { return _offset >= 0; }

    Key() noexcept : FieldBase<T>(FieldBase<T>::makeDefault()), _offset(-1) {}

    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(int offset, FieldBase<T> const& fb = FieldBase<T>()) noexcept
            : FieldBase<T>(fb), _offset(offset) {}

    int _offset;
};
}  // 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