File Flag.h¶

template<> struct hash<lsst::afw::table::Key<lsst::afw::table::Flag>>¶

Public Types

template<> using argument_type = lsst::afw::table::Key<lsst::afw::table::Flag>¶

template<> using result_type = size_t¶

Public Functions

size_t operator()(argument_type const &obj) const

namespace lsst

Class for a simple mapping implementing a generic AstrometryTransform.

Remove all non-astronomical counts from the Chunk Exposure’s pixels.

Forward declarations for lsst::utils::Cache

For details on the Cache class, see the Cache.h file.

It uses a template rather than a pointer so that the derived classes can use the specifics of the transform. The class simplePolyMapping overloads a few routines.

A base class for image defects

Numeric constants used by the Integrate.h integrator routines.

Compute Image Statistics

Note: Gauss-Kronrod-Patterson quadrature coefficients for use in quadpack routine qng. These coefficients were calculated with 101 decimal digit arithmetic by L. W. Fullerton, Bell Labs, Nov 1981.

Note: The Statistics class itself can only handle lsst::afw::image::MaskedImage() types. The philosophy has been to handle other types by making them look like lsst::afw::image::MaskedImage() and reusing that code. Users should have no need to instantiate a Statistics object directly, but should use the overloaded makeStatistics() factory functions.

namespace afw

namespace table

template<> struct FieldBase<Flag>¶

#include <Flag.h>

Specialization for Flag fields.

Flag fields are handled specially in many places, because their keys have both an offset into an integer element and the bit in that element; while other fields have one or more elements per field, Flags have multiple fields per element. This means we can’t put all the custom code for Flag in FieldBase, and because Flags have an explicit Key specialization, we put the record access implementation in Key.

Subclassed by lsst::afw::table::Field< Flag >, lsst::afw::table::Key< Flag >

Public Types

typedef bool Value: the type returned by BaseRecord::get

typedef std::int64_t Element: the actual storage type (shared by multiple flag fields)

Public Functions

int getElementCount() const: Return the number of subfield elements (always one for scalars).

FieldBase()

FieldBase(int)

FieldBase(FieldBase const&)

FieldBase(FieldBase&&)

FieldBase &operator=(FieldBase const&)

FieldBase &operator=(FieldBase&&)

~FieldBase()

Public Static Functions

static std::string getTypeString(): Return a string description of the field type.

Protected Functions

void stream(std::ostream &os) const: Defines how fields are printed.

template<> class Key<Flag> : public lsst::afw::table::KeyBase<Flag>, public lsst::afw::table::FieldBase<Flag>

#include <Flag.h>

Key specialization for Flag.

Flag fields are special; their keys need to contain not only the offset to the integer element they share with other Flag fields, but also their position in that shared field.

Flag fields operate mostly like a bool field, but they do not support reference access, and internally they are packed into an integer shared by multiple fields so the marginal cost of each Flag field is only one bit.

Unnamed Group

template<typename OtherT> bool operator==(Key<OtherT> const &other) const

Equality comparison.

Two keys with different types are never equal. Keys with the same type are equal if they point to the same location in a table, regardless of what Schema they were constructed from (for instance, if a field has a different name in one Schema than another, but is otherwise the same, the two keys will be equal).

template<typename OtherT> bool operator!=(Key<OtherT> const &other) const

bool operator==(Key const &other) const

bool operator!=(Key const &other) const

Public Functions

std::size_t hash_value() const: Return a hash of this object.

int getOffset() const: Return the offset in bytes of the integer element that holds this field’s bit.

int getBit() const: The index of this field’s bit within the integer it shares with other Flag fields.

bool isValid() const

Return true if the key was initialized to valid offset.

This does not guarantee that a key is valid with any particular schema, or even that any schemas still exist in which this key is valid.

A key that is default constructed will always be invalid.

Key()

Default construct a field.

The new field will be invalid until a valid Key is assigned to it.

Key(Key const&)

Key(Key&&)

Key &operator=(Key const&)

Key &operator=(Key&&)

~Key()

Private Functions

Value getValue(Element const *p, ndarray::Manager::Ptr const&) const¶: Used to implement BaseRecord::get.

void setValue(Element *p, ndarray::Manager::Ptr const&, Value v) const¶: Used to implement BaseRecord::set.

Key(int offset, int bit)¶

Private Members

int _offset¶

int _bit¶

Friends

friend lsst::afw::table::detail::Access

friend lsst::afw::table::BaseRecord

std::ostream &operator<<(std::ostream &os, Key<Flag> const &key): Stringification.

template<> class KeyBase<Flag>

#include <Flag.h>

A base class for Key that allows the underlying storage field to be extracted.

Subclassed by lsst::afw::table::Key< Flag >

Public Functions

Key<FieldBase<Flag>::Element> getStorage() const: Return a key corresponding to the integer element where this field’s bit is packed.

KeyBase()

KeyBase(KeyBase const&)

KeyBase(KeyBase&&)

KeyBase &operator=(KeyBase const&)

KeyBase &operator=(KeyBase&&)

~KeyBase()

Public Static Attributes

bool const HAS_NAMED_SUBFIELDS = false

namespace std

template<> struct hash<lsst::afw::table::Key<lsst::afw::table::Flag>>

Public Types

template<> using argument_type = lsst::afw::table::Key<lsst::afw::table::Flag>

template<> using result_type = size_t

Public Functions

size_t operator()(argument_type const &obj) const

Navigation

File Flag.h¶