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> {
    using Value = bool;            
    using Element = std::int64_t;  
 
    std::size_t 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(std::size_t) {
        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);
    }
 
    std::size_t getOffset() const { return _offset; }
 
    std::size_t getBit() const { return _bit; }
 
    bool isValid() const { return _valid; }
 
    Key() : FieldBase<Flag>(), _offset(0), _bit(0), _valid(false) {}
 
    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(std::size_t offset, std::size_t bit) : _offset(offset), _bit(bit), _valid(true) {}
 
    std::size_t _offset;
    std::size_t _bit;
    bool _valid;
};
}  // 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