Flag.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
#ifndef LSST_AFW_TABLE_Flag_h_INCLUDED
#define LSST_AFW_TABLE_Flag_h_INCLUDED

#include <cstdint>

#include "lsst/utils/hashCombine.h"

#include "lsst/afw/table/misc.h"
#include "lsst/afw/table/FieldBase.h"
#include "lsst/afw/table/KeyBase.h"

namespace lsst {
namespace afw {
namespace table {

namespace detail {

class Access;

}  // namespace detail

template <>
struct FieldBase<Flag> {
    typedef bool Value;            
    typedef std::int64_t Element;  

    int getElementCount() const { return 1; }

    static std::string getTypeString() { return "Flag"; }

    // Only the first of these constructors is valid for this specializations, but
    // it's convenient to be able to instantiate both, since the other is used
    // by other specializations.
    FieldBase() = default;
    FieldBase(int) {
        throw LSST_EXCEPT(lsst::pex::exceptions::LogicError,
                          "Constructor disabled (this Field type is not sized).");
    }

    FieldBase(FieldBase const &) = default;
    FieldBase(FieldBase &&) = default;
    FieldBase &operator=(FieldBase const &) = default;
    FieldBase &operator=(FieldBase &&) = default;
    ~FieldBase() = default;

protected:
    void stream(std::ostream &os) const {}
};

template <>
class KeyBase<Flag> {
public:
    static bool const HAS_NAMED_SUBFIELDS = false;

    Key<FieldBase<Flag>::Element> getStorage() const;

    KeyBase() = default;
    KeyBase(KeyBase const &) = default;
    KeyBase(KeyBase &&) = default;
    KeyBase &operator=(KeyBase const &) = default;
    KeyBase &operator=(KeyBase &&) = default;
    ~KeyBase() = default;
};

template <>
class Key<Flag> : public KeyBase<Flag>, public FieldBase<Flag> {
public:

    template <typename OtherT>
    bool operator==(Key<OtherT> const &other) const {
        return false;
    }
    template <typename OtherT>
    bool operator!=(Key<OtherT> const &other) const {
        return true;
    }

    bool operator==(Key const &other) const { return _offset == other._offset && _bit == other._bit; }
    bool operator!=(Key const &other) const { return !this->operator==(other); }

    std::size_t hash_value() const noexcept {
        // Completely arbitrary seed
        return utils::hashCombine(17, _offset, _bit);
    }

    int getOffset() const { return _offset; }

    int getBit() const { return _bit; }

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

    Key() : FieldBase<Flag>(), _offset(-1), _bit(0) {}

    Key(Key const &) = default;
    Key(Key &&) = default;
    Key &operator=(Key const &) = default;
    Key &operator=(Key &&) = default;
    ~Key() = default;

    inline friend std::ostream &operator<<(std::ostream &os, Key<Flag> const &key) {
        return os << "Key['" << Key<Flag>::getTypeString() << "'](offset=" << key.getOffset()
                  << ", bit=" << key.getBit() << ")";
    }

private:
    friend class detail::Access;
    friend class BaseRecord;

    Value getValue(Element const *p, ndarray::Manager::Ptr const &) const {
        return (*p) & (Element(1) << _bit);
    }

    void setValue(Element *p, ndarray::Manager::Ptr const &, Value v) const {
        if (v) {
            *p |= (Element(1) << _bit);
        } else {
            *p &= ~(Element(1) << _bit);
        }
    }

    explicit Key(int offset, int bit) : _offset(offset), _bit(bit) {}

    int _offset;
    int _bit;
};
}  // namespace table
}  // namespace afw
}  // namespace lsst

namespace std {
template <>
struct hash<lsst::afw::table::Key<lsst::afw::table::Flag>> {
    using argument_type = lsst::afw::table::Key<lsst::afw::table::Flag>;
    using result_type = size_t;
    size_t operator()(argument_type const &obj) const noexcept { return obj.hash_value(); }
};
}  // namespace std

#endif  // !LSST_AFW_TABLE_Flag_h_INCLUDED