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 "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 boost::int64_t Element;   

    int getElementCount() const { return 1; }

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

#ifndef SWIG_BUG_3465431_FIXED
    // SWIG uses this template to define the interface for the other specializations.
    // We can add other methods to full specializations using %extend, but we can't add
    // constructors that way.
    FieldBase() {}
    FieldBase(int) {
        throw LSST_EXCEPT(
            lsst::pex::exceptions::LogicError,
            "Constructor disabled (it only appears to exist as a workaround for a SWIG bug)."
        );
    }
#endif

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;
};

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); }

    int getOffset() const { return _offset; }

    int getBit() const { return _bit; }

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

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

    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 lsst::afw::table

#endif // !LSST_AFW_TABLE_Flag_h_INCLUDED